@checkstack/healthcheck-backend 1.18.0 → 1.19.0

package/src/queue-executor.ts

@@ -35,20 +35,17 @@ import {
 } from "@checkstack/healthcheck-common";
 import {
   CatalogApi,
-  catalogRoutes,
-  createSystemSubject,
   type Environment,
 } from "@checkstack/catalog-common";
 import {
   resolveEffectiveEnvironments,
   type EffectiveEnvironment,
 } from "./effective-environments";
-import { systemHealthCollapseKey } from "@checkstack/healthcheck-common";
+import { buildHealthTransitionNotification } from "./health-notification-content";
 import { MaintenanceApi } from "@checkstack/maintenance-common";
 import { IncidentApi } from "@checkstack/incident-common";
 import { NotificationApi } from "@checkstack/notification-common";
-import { healthcheckSystemSubscription } from "@checkstack/healthcheck-common";
-import { resolveRoute, type InferClient, extractErrorMessage} from "@checkstack/common";
+import { type InferClient, extractErrorMessage} from "@checkstack/common";
 import { secretEnvMappingSchema } from "@checkstack/secrets-common";
 import type {
   SecretResolverService,
@@ -465,6 +462,13 @@ async function notifyStateChange(props: {
   systemId: string;
   systemName: string;
   configurationId: string;
+  /**
+   * Human-readable name of the health check whose run drove this transition.
+   * Named in the body and surfaced as a `healthcheck.healthcheck` subject so
+   * subscribers see WHICH check failed, not just which system. Best-effort:
+   * falls back to the `configurationId` when the name could not be resolved.
+   */
+  configurationName?: string;
   previousStatus: HealthCheckStatus;
   newStatus: HealthCheckStatus;
   /**
@@ -493,6 +497,7 @@ async function notifyStateChange(props: {
     systemId,
     systemName,
     configurationId,
+    configurationName,
     previousStatus,
     newStatus,
     environmentId,
@@ -505,8 +510,9 @@ async function notifyStateChange(props: {
     logger,
   } = props;
 
-  const envScoped = typeof environmentId === "string";
-  const envSuffix = envScoped && environmentName ? ` (${environmentName})` : "";
+  // The check that just ran is the one driving this aggregate transition, so
+  // its name is the authoritative check to blame. Fall back to the id.
+  const checkName = configurationName ?? configurationId;
 
   const transition = classifyTransition(previousStatus, newStatus);
   if (transition === "none") {
@@ -572,70 +578,24 @@ async function notifyStateChange(props: {
     );
   }
 
-  let title: string;
-  let body: string;
-  let importance: "info" | "warning" | "critical";
-
-  if (transition === "recovery") {
-    title = `System health restored${envSuffix}: ${systemName}`;
-    body = envScoped
-      ? `Health checks for **${systemName}** in environment **${environmentName ?? environmentId}** are now passing. The system has returned to normal operation in that environment.`
-      : `All health checks for **${systemName}** are now passing. The system has returned to normal operation.`;
-    importance = "info";
-  } else if (newStatus === "unhealthy") {
-    title = `System health critical${envSuffix}: ${systemName}`;
-    body = envScoped
-      ? `Health checks indicate **${systemName}** is unhealthy in environment **${environmentName ?? environmentId}** and may be down in that environment.`
-      : `Health checks indicate **${systemName}** is unhealthy and may be down.`;
-    importance = "critical";
-  } else {
-    // degraded — either an escalation from healthy or a partial recovery
-    title = `System health degraded${envSuffix}: ${systemName}`;
-    body = envScoped
-      ? `Some health checks for **${systemName}** in environment **${environmentName ?? environmentId}** are failing. That environment may be experiencing issues.`
-      : `Some health checks for **${systemName}** are failing. The system may be experiencing issues.`;
-    importance = "warning";
-  }
-
-  const systemDetailPath = resolveRoute(catalogRoutes.routes.systemDetail, {
-    systemId,
-  });
-  // Recovery lands on the default (all) view; failing transitions deep-link
-  // operators into the failing-checks filter so they can debug immediately.
-  const actionUrl =
-    transition === "recovery"
-      ? systemDetailPath
-      : `${systemDetailPath}?filter=failing`;
-  const actionLabel =
-    transition === "recovery" ? "View System" : "View failing checks";
-
   void catalogClient; // parents are resolved server-side via stored target edges
 
   try {
-    await notificationClient.notifyForSubscription({
-      specId: healthcheckSystemSubscription.specId,
-      resourceKeys: [systemId],
-      title,
-      body,
-      importance,
-      action: { label: actionLabel, url: actionUrl },
-      // Env-qualified collapse key so two failing envs of one system generate
-      // two independent notification cards (one per env) instead of merging
-      // -> operators see all env outages. The system-rollup transition
-      // (`environmentId === null`/undefined) keys on the bare systemId and
-      // therefore reuses the pre-existing single-card identity.
-      collapseKey: envScoped
-        ? systemHealthCollapseKey(systemId, environmentId)
-        : systemHealthCollapseKey(systemId),
-      subjects: [
-        createSystemSubject({
-          id: systemId,
-          name: systemName,
-          url: systemDetailPath,
-          status: newStatus,
-        }),
-      ],
-    });
+    // Content (title/body/subjects/collapseKey) is built by a pure, unit-tested
+    // helper so the wording - which now NAMES the failing check and pushes a
+    // `healthcheck.healthcheck` subject - can be verified without the executor.
+    await notificationClient.notifyForSubscription(
+      buildHealthTransitionNotification({
+        transition,
+        systemId,
+        systemName,
+        configurationId,
+        checkName,
+        newStatus,
+        environmentId,
+        environmentName,
+      }),
+    );
     logger.debug(
       `Notified subscribers: ${previousStatus} → ${newStatus} for system ${systemId}`,
     );
@@ -1390,6 +1350,7 @@ async function executeHealthCheckJob(props: {
           systemId,
           systemName,
           configurationId: configId,
+          configurationName: configRow.configName,
           previousStatus,
           newStatus: newState.status,
           environmentId,
@@ -1557,6 +1518,7 @@ async function executeHealthCheckJob(props: {
         systemId,
         systemName,
         configurationId: configId,
+        configurationName: configRow.configName,
         previousStatus,
         newStatus: newState.status,
         environmentId,
@@ -1723,6 +1685,7 @@ async function executeHealthCheckJob(props: {
         systemId,
         systemName,
         configurationId: configId,
+        configurationName: configName,
         previousStatus,
         newStatus: newState.status,
         service,

package/src/router.ts

@@ -227,6 +227,27 @@ export const createHealthCheckRouter = (opts: {
       });
     }
 
+    // Recompute the rollup `health` entity for this system NOW. Changing an
+    // assignment's environment set can make a previously-effective env slice
+    // orphaned (env disabled/removed from `environmentIds`): that slice stops
+    // producing runs, so NO per-env health-change event will ever fire for it,
+    // and the event-driven rollup consumer would never recompute the disabled
+    // env's last (unhealthy) status away. `getSystemHealthStatus` now excludes
+    // non-effective slices, so this recompute promptly drops the stale slice
+    // from the persisted entity - closing any SLO downtime it was holding open
+    // and clearing the badge - instead of waiting for its runs to age out of
+    // the window. Best-effort: a recompute failure is logged inside the helper
+    // and never breaks the mutation (the live RPC reads are already correct).
+    if (recomputeSystemRollupHealth) {
+      try {
+        await recomputeSystemRollupHealth(args.systemId);
+      } catch (error) {
+        logger.warn(
+          `Failed to recompute rollup health after assignment change for system ${args.systemId}: ${extractErrorMessage(error, "unknown")}`,
+        );
+      }
+    }
+
     // Notify subscribers (e.g., satellite-backend) that assignments changed.
     const emitHook = getEmitHook();
     if (emitHook) {
@@ -473,6 +494,17 @@ export const createHealthCheckRouter = (opts: {
       },
     ),
 
+    getBulkAssignedHealthCheckCounts:
+      os.getBulkAssignedHealthCheckCounts.handler(async ({ input }) => {
+        // ONE grouped query for the whole visible system list (replaces the
+        // per-row getSystemAssociations N+1). recordKey gating on the contract
+        // drops counts for systems the caller may not read.
+        const counts = await service.getBulkAssignedHealthCheckCounts(
+          input.systemIds,
+        );
+        return { counts };
+      }),
+
     associateSystem: os.associateSystem.handler(async ({ input, context }) => {
       await enforceNotGitOpsLocked("System", input.systemId);
       await service.associateSystem({
@@ -573,6 +605,10 @@ export const createHealthCheckRouter = (opts: {
       return service.getRunStats(input);
     }),
 
+    getBulkRunStats: os.getBulkRunStats.handler(async ({ input }) => {
+      return { stats: await service.getBulkRunStats(input) };
+    }),
+
     getDetailedHistory: os.getDetailedHistory.handler(
       async ({ input, context }) => {
         // Handler-side authorization (the contract's `access` is deliberately

package/src/service-batching.test.ts

@@ -18,6 +18,8 @@ describe("HealthCheckService.getSystemHealthStatus - read batching", () => {
       enabled: true,
       paused: false,
       stateThresholds: null,
+      // All-environments selector; each check has only the env-less slice below.
+      environmentIds: null,
     }));
     const assocWhere = mock(() => Promise.resolve(associations));
     const assocInnerJoin = Object.assign(Promise.resolve([]), {
@@ -39,6 +41,11 @@ describe("HealthCheckService.getSystemHealthStatus - read batching", () => {
       orderBy: runsOrderBy,
     });
 
+    // Distinct env keys query per check: a single env-less (null) slice.
+    const distinctFrom = Object.assign(Promise.resolve([]), {
+      where: mock(() => Promise.resolve([{ environmentId: null }])),
+    });
+
     let selectCallCount = 0;
     const db = withTransactionMock({
       select: mock(() => {
@@ -46,6 +53,7 @@ describe("HealthCheckService.getSystemHealthStatus - read batching", () => {
         if (selectCallCount === 1) return { from: mock(() => assocFrom) };
         return { from: mock(() => runsFrom) };
       }),
+      selectDistinct: mock(() => ({ from: mock(() => distinctFrom) })),
       insert: mock(() => ({ values: mock(() => Promise.resolve()) })),
       update: mock(() => ({
         set: mock(() => ({ where: mock(() => Promise.resolve()) })),

package/src/service-bulk-counts.it.test.ts

@@ -0,0 +1,144 @@
+/**
+ * Integration test for `HealthCheckService.getBulkAssignedHealthCheckCounts`
+ * against a REAL Postgres. The method's whole point is the GROUP BY / COUNT and
+ * the zero-fill for systems with no rows - behaviour a mocked db cannot prove
+ * (the database does the grouping). These tests pin: counts are grouped per
+ * system, systems with no assignments report 0, requested-but-absent systems
+ * report 0, and non-requested systems never leak in.
+ *
+ * Gated on CHECKSTACK_IT so it runs in CI (shared compose Postgres) and is
+ * skipped in the default `bun test` run, matching the other *.it.test.ts here.
+ */
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "bun:test";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+import type {
+  SafeDatabase,
+  HealthCheckRegistry,
+  CollectorRegistry,
+} from "@checkstack/backend-api";
+import * as schema from "./schema";
+import { HealthCheckService } from "./service";
+
+const PG_URL =
+  process.env.CHECKSTACK_IT_PG_URL ??
+  "postgres://postgres:postgres@localhost:5432/postgres";
+const SCHEMA = "healthcheck_it_bulk_counts";
+
+let admin: Pool;
+let pool: Pool;
+let service: HealthCheckService;
+
+async function insertAssignment(row: {
+  systemId: string;
+  configurationId: string;
+}): Promise<void> {
+  await pool.query(
+    `INSERT INTO "${SCHEMA}".system_health_checks (system_id, configuration_id)
+     VALUES ($1, $2)`,
+    [row.systemId, row.configurationId],
+  );
+}
+
+describe.skipIf(!process.env.CHECKSTACK_IT)(
+  "HealthCheckService.getBulkAssignedHealthCheckCounts (shared Postgres)",
+  () => {
+    beforeAll(async () => {
+      admin = new Pool({ connectionString: PG_URL });
+      await admin.query(`DROP SCHEMA IF EXISTS "${SCHEMA}" CASCADE`);
+      await admin.query(`CREATE SCHEMA "${SCHEMA}"`);
+      // Only the columns the grouped COUNT touches; no FK to configurations so
+      // the DDL stays minimal and focused on the aggregation behaviour.
+      await admin.query(
+        `CREATE TABLE "${SCHEMA}".system_health_checks (
+          system_id text NOT NULL,
+          configuration_id uuid NOT NULL,
+          PRIMARY KEY (system_id, configuration_id)
+        )`,
+      );
+      pool = new Pool({
+        connectionString: PG_URL,
+        options: `-c search_path=${SCHEMA}`,
+      });
+      const db = drizzle(pool, {
+        schema,
+      }) as unknown as SafeDatabase<typeof schema>;
+      // registry / collectorRegistry are unused by the count method under test;
+      // stub them so the constructor is satisfied without wiring real registries.
+      const service_ = new HealthCheckService(
+        db,
+        {} as unknown as HealthCheckRegistry,
+        {} as unknown as CollectorRegistry,
+      );
+      service = service_;
+    });
+
+    afterAll(async () => {
+      await pool?.end();
+      await admin.query(`DROP SCHEMA IF EXISTS "${SCHEMA}" CASCADE`);
+      await admin.end();
+    });
+
+    beforeEach(async () => {
+      await pool.query(`TRUNCATE "${SCHEMA}".system_health_checks`);
+    });
+
+    it("groups counts per system and zero-fills systems with no assignments", async () => {
+      // sys-a: 2 assignments, sys-b: 1, sys-c: none.
+      await insertAssignment({
+        systemId: "sys-a",
+        configurationId: crypto.randomUUID(),
+      });
+      await insertAssignment({
+        systemId: "sys-a",
+        configurationId: crypto.randomUUID(),
+      });
+      await insertAssignment({
+        systemId: "sys-b",
+        configurationId: crypto.randomUUID(),
+      });
+
+      const counts = await service.getBulkAssignedHealthCheckCounts([
+        "sys-a",
+        "sys-b",
+        "sys-c",
+      ]);
+
+      expect(counts).toEqual({ "sys-a": 2, "sys-b": 1, "sys-c": 0 });
+    });
+
+    it("returns 0 for a requested system that has no rows at all", async () => {
+      await insertAssignment({
+        systemId: "sys-a",
+        configurationId: crypto.randomUUID(),
+      });
+
+      const counts = await service.getBulkAssignedHealthCheckCounts([
+        "sys-a",
+        "missing",
+      ]);
+
+      expect(counts).toEqual({ "sys-a": 1, missing: 0 });
+    });
+
+    it("never leaks counts for systems not in the requested set", async () => {
+      await insertAssignment({
+        systemId: "sys-a",
+        configurationId: crypto.randomUUID(),
+      });
+      await insertAssignment({
+        systemId: "sys-other",
+        configurationId: crypto.randomUUID(),
+      });
+
+      const counts = await service.getBulkAssignedHealthCheckCounts(["sys-a"]);
+
+      expect(counts).toEqual({ "sys-a": 1 });
+      expect(Object.keys(counts)).not.toContain("sys-other");
+    });
+
+    it("returns an empty map for an empty request without querying", async () => {
+      expect(await service.getBulkAssignedHealthCheckCounts([])).toEqual({});
+    });
+  },
+);

package/src/service-bulk-run-stats.it.test.ts

@@ -0,0 +1,197 @@
+/**
+ * Integration test for `HealthCheckService.getBulkRunStats` against a REAL
+ * Postgres. The method's whole point is the single grouped read over
+ * `health_check_runs` for MANY systems, then per-system summarization - so each
+ * entry MUST be byte-identical to what the single `getRunStats({ systemId })`
+ * would return for the same window. A mocked db cannot prove the `inArray`
+ * grouping / windowing, so this real-DB guard pins the equivalence, the
+ * per-system isolation, and the "systems with no runs are omitted" behaviour
+ * the status-page uptime column relies on.
+ *
+ * Gated on CHECKSTACK_IT so it runs in CI (shared compose Postgres) and is
+ * skipped in the default `bun test` run, matching the other *.it.test.ts here.
+ */
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "bun:test";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+import type {
+  SafeDatabase,
+  HealthCheckRegistry,
+  CollectorRegistry,
+} from "@checkstack/backend-api";
+import * as schema from "./schema";
+import { HealthCheckService } from "./service";
+
+const PG_URL =
+  process.env.CHECKSTACK_IT_PG_URL ??
+  "postgres://postgres:postgres@localhost:5432/postgres";
+const SCHEMA = "healthcheck_it_bulk_run_stats";
+
+const START = new Date("2026-06-01T00:00:00.000Z");
+const END = new Date("2026-06-01T23:59:59.000Z");
+
+let admin: Pool;
+let pool: Pool;
+let service: HealthCheckService;
+
+async function insertRun(row: {
+  systemId: string;
+  status: string;
+  latencyMs?: number | null;
+  at: string;
+  environmentId?: string | null;
+}): Promise<void> {
+  await pool.query(
+    `INSERT INTO "${SCHEMA}".health_check_runs
+       (id, configuration_id, system_id, environment_id, status, latency_ms, timestamp)
+     VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+    [
+      crypto.randomUUID(),
+      crypto.randomUUID(),
+      row.systemId,
+      row.environmentId ?? null,
+      row.status,
+      row.latencyMs ?? null,
+      row.at,
+    ],
+  );
+}
+
+describe.skipIf(!process.env.CHECKSTACK_IT)(
+  "HealthCheckService.getBulkRunStats (shared Postgres)",
+  () => {
+    beforeAll(async () => {
+      admin = new Pool({ connectionString: PG_URL });
+      await admin.query(`DROP SCHEMA IF EXISTS "${SCHEMA}" CASCADE`);
+      await admin.query(`CREATE SCHEMA "${SCHEMA}"`);
+      // Minimal DDL: only the columns the grouped read touches; status is plain
+      // text and configuration_id carries no FK, keeping the schema
+      // self-contained like the sibling *.it.test.ts files.
+      await admin.query(
+        `CREATE TABLE "${SCHEMA}".health_check_runs (
+          id uuid PRIMARY KEY,
+          configuration_id uuid NOT NULL,
+          system_id text NOT NULL,
+          environment_id text,
+          status text NOT NULL,
+          latency_ms integer,
+          result jsonb,
+          source_id text,
+          source_label text,
+          timestamp timestamp NOT NULL DEFAULT now()
+        )`,
+      );
+      pool = new Pool({
+        connectionString: PG_URL,
+        options: `-c search_path=${SCHEMA}`,
+      });
+      const db = drizzle(pool, {
+        schema,
+      }) as unknown as SafeDatabase<typeof schema>;
+      // registry / collectorRegistry are unused by the stats read under test;
+      // stub them so the constructor is satisfied.
+      service = new HealthCheckService(
+        db,
+        {} as unknown as HealthCheckRegistry,
+        {} as unknown as CollectorRegistry,
+      );
+    });
+
+    afterAll(async () => {
+      await pool?.end();
+      await admin.query(`DROP SCHEMA IF EXISTS "${SCHEMA}" CASCADE`);
+      await admin.end();
+    });
+
+    beforeEach(async () => {
+      await pool.query(`TRUNCATE "${SCHEMA}".health_check_runs`);
+    });
+
+    it("returns per-system stats identical to getRunStats for the same window", async () => {
+      // sys-a: 3 healthy + 1 unhealthy; sys-b: 2 healthy; sys-c: no runs.
+      await insertRun({ systemId: "sys-a", status: "healthy", latencyMs: 10, at: "2026-06-01T01:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "healthy", latencyMs: 20, at: "2026-06-01T02:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "healthy", latencyMs: 30, at: "2026-06-01T03:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "unhealthy", latencyMs: 40, at: "2026-06-01T04:00:00Z" });
+      await insertRun({ systemId: "sys-b", status: "healthy", latencyMs: 5, at: "2026-06-01T05:00:00Z" });
+      await insertRun({ systemId: "sys-b", status: "healthy", latencyMs: 7, at: "2026-06-01T06:00:00Z" });
+      // A run OUTSIDE the window must be ignored by both endpoints.
+      await insertRun({ systemId: "sys-a", status: "unhealthy", at: "2026-05-01T00:00:00Z" });
+
+      const ids = ["sys-a", "sys-b", "sys-c"];
+      const stats = await service.getBulkRunStats({
+        systemIds: ids,
+        startDate: START,
+        endDate: END,
+        maxBuckets: 24,
+      });
+
+      for (const systemId of ids) {
+        const single = await service.getRunStats({ systemId, startDate: START, endDate: END, maxBuckets: 24 });
+        if (single.total.runCount === 0) {
+          // Zero-run systems are omitted from the bulk record.
+          expect(stats[systemId]).toBeUndefined();
+        } else {
+          expect(stats[systemId]).toEqual(single);
+        }
+      }
+
+      // sys-c had no runs => omitted; only populated systems are keys.
+      expect(Object.keys(stats).toSorted()).toEqual(["sys-a", "sys-b"]);
+      // Sanity: sys-a uptime = 3/4 healthy = 75%.
+      expect(stats["sys-a"]?.total.uptimePct).toBe(75);
+    });
+
+    it("scopes uptime to the selected environments (status-page env filter)", async () => {
+      // sys-a: prod 2 healthy; staging 1 healthy + 1 unhealthy; env-less 1
+      // unhealthy. A prod-only page must count ONLY the two prod runs (100%),
+      // never the staging or env-less runs.
+      await insertRun({ systemId: "sys-a", status: "healthy", environmentId: "env-prod", at: "2026-06-01T01:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "healthy", environmentId: "env-prod", at: "2026-06-01T02:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "healthy", environmentId: "env-stage", at: "2026-06-01T03:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "unhealthy", environmentId: "env-stage", at: "2026-06-01T04:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "unhealthy", environmentId: null, at: "2026-06-01T05:00:00Z" });
+
+      const prodOnly = await service.getBulkRunStats({
+        systemIds: ["sys-a"],
+        startDate: START,
+        endDate: END,
+        environmentIds: ["env-prod"],
+        maxBuckets: 24,
+      });
+      expect(prodOnly["sys-a"]?.total.runCount).toBe(2);
+      expect(prodOnly["sys-a"]?.total.uptimePct).toBe(100);
+
+      // No env filter counts every run (5 total, 3 healthy = 60%).
+      const all = await service.getBulkRunStats({
+        systemIds: ["sys-a"],
+        startDate: START,
+        endDate: END,
+        maxBuckets: 24,
+      });
+      expect(all["sys-a"]?.total.runCount).toBe(5);
+      expect(all["sys-a"]?.total.uptimePct).toBe(60);
+
+      // getRunStats honors the same set filter for the single-system uptime widget.
+      const single = await service.getRunStats({
+        systemId: "sys-a",
+        startDate: START,
+        endDate: END,
+        environmentIds: ["env-prod", "env-stage"],
+        maxBuckets: 24,
+      });
+      expect(single.total.runCount).toBe(4);
+    });
+
+    it("returns an empty record for an empty request without querying", async () => {
+      expect(
+        await service.getBulkRunStats({
+          systemIds: [],
+          startDate: START,
+          endDate: END,
+          maxBuckets: 1,
+        }),
+      ).toEqual({});
+    });
+  },
+);

package/src/service-ordering.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, mock, beforeEach } from "bun:test";
 import type { InferSelectModel } from "drizzle-orm";
+import { withTransactionMock } from "@checkstack/test-utils-backend";
 import { HealthCheckService } from "./service";
 import {
   healthCheckRuns,
@@ -78,10 +79,13 @@ describe("HealthCheckService data ordering", () => {
       orderBy: orderByMock,
     }));
 
-    return {
+    // getSystemHealthOverview batches its reads in ONE scoped transaction, so
+    // the mock must expose `.transaction(cb)` (runs `cb` against the same mock
+    // db). getHistory/getDetailedHistory run standalone and ignore it.
+    return withTransactionMock({
       select: mock(() => ({ from: fromMock })),
       $count: mock(() => Promise.resolve(mockRuns.length)),
-    };
+    });
   }
 
   beforeEach(() => {

package/src/service-paused-filter.test.ts

@@ -93,6 +93,12 @@ describe("HealthCheckService - paused configuration filtering", () => {
       })),
     });
 
+    // Distinct env keys query (rollup): resolves to no env slices for these
+    // fixtures (runs are empty), so the rollup has nothing to evaluate.
+    const distinctFrom = Object.assign(Promise.resolve([]), {
+      where: mock(() => Promise.resolve([])),
+    });
+
     let selectCallCount = 0;
     return {
       select: mock(() => {
@@ -104,6 +110,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
         }
         return { from: mock(() => runsFrom) };
       }),
+      selectDistinct: mock(() => ({ from: mock(() => distinctFrom) })),
       insert: mock(() => ({
         values: mock(() => ({
           onConflictDoUpdate: mock(() => Promise.resolve()),
@@ -199,6 +206,11 @@ describe("HealthCheckService - paused configuration filtering", () => {
         orderBy: runsOrderBy,
       });
 
+      // Distinct env keys: a single env-less (null) slice for this env-less check.
+      const distinctFrom = Object.assign(Promise.resolve([]), {
+        where: mock(() => Promise.resolve([{ environmentId: null }])),
+      });
+
       let selectCallCount = 0;
       const mockDb = {
         select: mock(() => {
@@ -208,6 +220,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
           }
           return { from: mock(() => runsFrom) };
         }),
+        selectDistinct: mock(() => ({ from: mock(() => distinctFrom) })),
         insert: mock(() => ({
           values: mock(() => ({
             onConflictDoUpdate: mock(() => Promise.resolve()),