@checkstack/dependency-backend 0.2.15 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @checkstack/dependency-backend
 
+## 0.3.0
+
+### Minor Changes
+
+- 298bf42: ### Notification System Optimizations
+
+  **System context in notifications**: All notification senders (healthcheck, incident, maintenance, dependency) now include the affected system name in the notification title and body. Users can immediately identify which system is affected without clicking through to the detail page.
+
+  **Upstream notification deduplication**: When an upstream dependency goes down affecting multiple downstream systems, the dependency notification sidecar now sends **one personalized notification per user** instead of one notification per affected system. Each user's notification lists only the systems they are subscribed to, with a link to the upstream root cause system. This prevents notification floods for users subscribed to groups containing many dependent systems.
+
+  **New catalog endpoint**: Added `getSystemGroupIds` S2S RPC endpoint on the catalog to resolve which catalog groups contain a given system, used by the dependency plugin for efficient subscriber resolution during batched notification dispatch.
+
+### Patch Changes
+
+- Updated dependencies [298bf42]
+  - @checkstack/healthcheck-backend@0.17.0
+  - @checkstack/catalog-common@1.5.0
+  - @checkstack/catalog-backend@0.6.0
+
+## 0.2.16
+
+### Patch Changes
+
+- Updated dependencies [9a320fe]
+  - @checkstack/healthcheck-backend@0.16.5
+
 ## 0.2.15
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/dependency-backend",
-  "version": "0.2.15",
+  "version": "0.3.0",
   "type": "module",
   "main": "src/index.ts",
   "checkstack": {
@@ -16,11 +16,12 @@
     "@checkstack/backend-api": "0.12.0",
     "@checkstack/dependency-common": "0.2.1",
     "@checkstack/catalog-common": "1.4.1",
-    "@checkstack/catalog-backend": "0.5.1",
+    "@checkstack/catalog-backend": "0.5.4",
     "@checkstack/healthcheck-common": "0.11.0",
-    "@checkstack/healthcheck-backend": "0.16.1",
+    "@checkstack/healthcheck-backend": "0.16.5",
     "@checkstack/maintenance-common": "0.4.9",
     "@checkstack/incident-common": "0.4.7",
+    "@checkstack/notification-common": "0.2.8",
     "@checkstack/signal-common": "0.1.9",
     "@checkstack/common": "0.6.5",
     "drizzle-orm": "^0.45.0",

package/src/index.ts

@@ -14,6 +14,7 @@ import { CatalogApi } from "@checkstack/catalog-common";
 import { HealthCheckApi } from "@checkstack/healthcheck-common";
 import { MaintenanceApi } from "@checkstack/maintenance-common";
 import { IncidentApi } from "@checkstack/incident-common";
+import { NotificationApi } from "@checkstack/notification-common";
 import { catalogHooks } from "@checkstack/catalog-backend";
 import { healthCheckHooks } from "@checkstack/healthcheck-backend";
 import { evaluateAndNotifyDownstream } from "./notifications";
@@ -73,6 +74,7 @@ export default createBackendPlugin({
         const healthCheckClient = rpcClient.forPlugin(HealthCheckApi);
         const maintenanceClient = rpcClient.forPlugin(MaintenanceApi);
         const incidentClient = rpcClient.forPlugin(IncidentApi);
+        const notificationClient = rpcClient.forPlugin(NotificationApi);
 
         /**
          * Build system statuses for warning evaluation.
@@ -161,6 +163,7 @@ export default createBackendPlugin({
               warningService,
               fetchSystemStatuses,
               catalogClient,
+              notificationClient,
               maintenanceClient,
               incidentClient,
               signalService,
@@ -186,6 +189,7 @@ export default createBackendPlugin({
               warningService,
               fetchSystemStatuses,
               catalogClient,
+              notificationClient,
               maintenanceClient,
               incidentClient,
               signalService,

package/src/notifications.ts

@@ -5,6 +5,7 @@ import type { CatalogApi } from "@checkstack/catalog-common";
 import { catalogRoutes } from "@checkstack/catalog-common";
 import type { MaintenanceApi } from "@checkstack/maintenance-common";
 import type { IncidentApi } from "@checkstack/incident-common";
+import type { NotificationApi } from "@checkstack/notification-common";
 import type { DerivedState } from "@checkstack/dependency-common";
 import { DEPENDENCY_WARNINGS_CHANGED } from "@checkstack/dependency-common";
 import type { DependencyService } from "./services/dependency-service";
@@ -45,26 +46,30 @@ function derivedStateToImportance(
 export function buildNotificationTitle({
   derivedState,
   isRecovery,
+  systemName,
 }: {
   derivedState?: DerivedState;
   isRecovery: boolean;
+  systemName?: string;
 }): string {
+  const prefix = systemName ? `${systemName}: ` : "";
+
   if (isRecovery) {
-    return "Dependency impact resolved";
+    return `${prefix}Dependency impact resolved`;
   }
 
   switch (derivedState) {
     case "info": {
-      return "Upstream dependency issue (informational)";
+      return `${prefix}Upstream dependency issue (informational)`;
     }
     case "degraded": {
-      return "Availability impacted by upstream dependency";
+      return `${prefix}Availability impacted by upstream dependency`;
     }
     case "down": {
-      return "Availability critically impacted by upstream dependency";
+      return `${prefix}Availability critically impacted by upstream dependency`;
     }
     default: {
-      return "Dependency impact changed";
+      return `${prefix}Dependency impact changed`;
     }
   }
 }
@@ -76,26 +81,29 @@ export function buildNotificationBody({
   upstreamNames,
   derivedState,
   isRecovery,
+  systemName,
 }: {
   upstreamNames: string[];
   derivedState?: DerivedState;
   isRecovery: boolean;
+  systemName?: string;
 }): string {
   const upstreamList = upstreamNames.join(", ");
+  const systemRef = systemName ? `**${systemName}**` : "This system";
 
   if (isRecovery) {
-    return "All upstream dependencies have recovered. This system is no longer affected by dependency failures.";
+    return `All upstream dependencies have recovered. ${systemRef} is no longer affected by dependency failures.`;
   }
 
   switch (derivedState) {
     case "info": {
-      return `An upstream dependency (${upstreamList}) is experiencing issues. This is informational — no direct impact expected.`;
+      return `An upstream dependency (${upstreamList}) is experiencing issues. ${systemRef} — this is informational, no direct impact expected.`;
     }
     case "degraded": {
-      return `An upstream dependency (${upstreamList}) is experiencing issues. This system's availability may be degraded.`;
+      return `An upstream dependency (${upstreamList}) is experiencing issues. ${systemRef}'s availability may be degraded.`;
     }
     case "down": {
-      return `A critical upstream dependency (${upstreamList}) is down. This system is expected to be unavailable.`;
+      return `A critical upstream dependency (${upstreamList}) is down. ${systemRef} is expected to be unavailable.`;
     }
     default: {
       return `Upstream dependency status has changed (${upstreamList}).`;
@@ -103,12 +111,68 @@ export function buildNotificationBody({
   }
 }
 
+/**
+ * Represents a downstream system that needs notification due to a state change.
+ */
+export interface SystemNotificationEntry {
+  systemId: string;
+  systemName: string;
+  derivedState?: DerivedState;
+  isRecovery: boolean;
+  importance: "info" | "warning" | "critical";
+  upstreamNames: string[];
+}
+
+/**
+ * Resolve the worst importance level from a list of notification entries.
+ */
+function resolveWorstImportance(
+  entries: SystemNotificationEntry[],
+): "info" | "warning" | "critical" {
+  let worst: "info" | "warning" | "critical" = "info";
+  for (const entry of entries) {
+    if (entry.importance === "critical") return "critical";
+    if (entry.importance === "warning") worst = "warning";
+  }
+  return worst;
+}
+
+/**
+ * Format a per-system impact line with criticality indicator for multi-system
+ * notification bodies.
+ */
+export function formatSystemImpactLine(entry: SystemNotificationEntry): string {
+  if (entry.isRecovery) {
+    return `- ✅ **${entry.systemName}** — recovered`;
+  }
+
+  switch (entry.derivedState) {
+    case "down": {
+      return `- 🔴 **${entry.systemName}** — critically impacted`;
+    }
+    case "degraded": {
+      return `- 🟡 **${entry.systemName}** — degraded`;
+    }
+    case "info": {
+      return `- ℹ️ **${entry.systemName}** — informational`;
+    }
+    default: {
+      return `- **${entry.systemName}** — impact changed`;
+    }
+  }
+}
+
 /**
  * Evaluate downstream systems for dependency-driven state changes
  * and notify subscribers when the derived state transitions.
  *
  * This is the Sidecar Notification Orchestration function.
  * It runs when an upstream system's health status changes.
+ *
+ * Notification deduplication: Instead of sending one notification per
+ * downstream system (which floods users subscribed to groups), we resolve
+ * all affected subscribers and send one personalized notification per user
+ * listing only the systems they are subscribed to.
  */
 export async function evaluateAndNotifyDownstream({
   changedSystemId,
@@ -117,6 +181,7 @@ export async function evaluateAndNotifyDownstream({
   warningService,
   fetchSystemStatuses,
   catalogClient,
+  notificationClient,
   maintenanceClient,
   incidentClient,
   signalService,
@@ -130,6 +195,7 @@ export async function evaluateAndNotifyDownstream({
     systemIds: string[],
   ) => Promise<Map<string, SystemStatus>>;
   catalogClient: InferClient<typeof CatalogApi>;
+  notificationClient: InferClient<typeof NotificationApi>;
   maintenanceClient: InferClient<typeof MaintenanceApi>;
   incidentClient: InferClient<typeof IncidentApi>;
   signalService: SignalService;
@@ -236,8 +302,10 @@ export async function evaluateAndNotifyDownstream({
       }
     }
 
-    // 6. Compare and notify for each downstream system
+    // 6. Evaluate state changes and collect systems that need notification
     const changedSystemIds: string[] = [];
+    const systemsToNotify: SystemNotificationEntry[] = [];
+
     for (const systemId of downstreamIds) {
       const currentWarning = warningMap.get(systemId);
       const currentState = currentWarning?.derivedState;
@@ -278,52 +346,40 @@ export async function evaluateAndNotifyDownstream({
         continue;
       }
 
-      // Build notification
+      // Collect notification entry instead of sending immediately
       const isRecovery = !currentState && !!previousState;
       const upstreamNames =
         currentWarning?.affectedUpstreams.map(
           (u) => u.systemName ?? u.systemId,
         ) ?? [];
+      const systemName =
+        statuses.get(systemId)?.systemName ?? systemId;
 
-      const title = buildNotificationTitle({
+      systemsToNotify.push({
+        systemId,
+        systemName,
         derivedState: currentState,
         isRecovery,
-      });
-      const body = buildNotificationBody({
+        importance: isRecovery
+          ? "info"
+          : derivedStateToImportance(currentState!),
         upstreamNames,
-        derivedState: currentState,
-        isRecovery,
       });
-      const importance = isRecovery
-        ? ("info" as const)
-        : derivedStateToImportance(currentState!);
+    }
 
-      const systemDetailPath = resolveRoute(catalogRoutes.routes.systemDetail, {
-        systemId,
+    // 7. Send batched per-user notifications (deduplication)
+    if (systemsToNotify.length > 0) {
+      await sendBatchedNotifications({
+        systemsToNotify,
+        changedSystemId,
+        statuses,
+        catalogClient,
+        notificationClient,
+        logger,
       });
-
-      try {
-        await catalogClient.notifySystemSubscribers({
-          systemId,
-          title,
-          body,
-          importance,
-          action: { label: "View System", url: systemDetailPath },
-          includeGroupSubscribers: true,
-        });
-        logger.debug(
-          `Dependency notification sent: ${systemId} ${previousState ?? "none"} → ${currentState ?? "none"}`,
-        );
-      } catch (error) {
-        // Notifications are best-effort
-        logger.warn(
-          `Failed to send dependency notification for ${systemId}:`,
-          error,
-        );
-      }
     }
 
-    // 7. Broadcast signal so frontends can react
+    // 8. Broadcast signal so frontends can react
     if (changedSystemIds.length > 0) {
       await signalService.broadcast(DEPENDENCY_WARNINGS_CHANGED, {
         affectedSystemIds: changedSystemIds,
@@ -337,3 +393,148 @@ export async function evaluateAndNotifyDownstream({
     );
   }
 }
+
+/**
+ * Send batched, per-user personalized notifications.
+ *
+ * Instead of sending one notification per affected system (which causes
+ * floods for group subscribers), this function:
+ * 1. Resolves all notification group IDs for each affected system
+ * 2. Resolves subscribers per group and builds a user → systems reverse map
+ * 3. Sends one personalized notification per user with only their relevant systems
+ */
+async function sendBatchedNotifications({
+  systemsToNotify,
+  changedSystemId,
+  statuses,
+  catalogClient,
+  notificationClient,
+  logger,
+}: {
+  systemsToNotify: SystemNotificationEntry[];
+  changedSystemId: string;
+  statuses: Map<string, SystemStatus>;
+  catalogClient: InferClient<typeof CatalogApi>;
+  notificationClient: InferClient<typeof NotificationApi>;
+  logger: Logger;
+}): Promise<void> {
+  // Phase 1: Resolve all notification group IDs for affected systems
+  const systemToGroupIds = new Map<string, string[]>();
+  for (const system of systemsToNotify) {
+    const groupIds = [`catalog.system.${system.systemId}`];
+
+    try {
+      const { groupIds: catalogGroupIds } =
+        await catalogClient.getSystemGroupIds({
+          systemId: system.systemId,
+        });
+      groupIds.push(
+        ...catalogGroupIds.map((gid) => `catalog.group.${gid}`),
+      );
+    } catch (error) {
+      logger.warn(
+        `Failed to resolve group IDs for system ${system.systemId}:`,
+        error,
+      );
+    }
+
+    systemToGroupIds.set(system.systemId, groupIds);
+  }
+
+  // Phase 2: Resolve subscribers per group → build user → systems reverse map
+  const userSystems = new Map<string, Set<string>>();
+  for (const system of systemsToNotify) {
+    const groupIds = systemToGroupIds.get(system.systemId) ?? [];
+    for (const groupId of groupIds) {
+      try {
+        const { userIds } =
+          await notificationClient.getGroupSubscribers({ groupId });
+        for (const userId of userIds) {
+          if (!userSystems.has(userId)) {
+            userSystems.set(userId, new Set());
+          }
+          userSystems.get(userId)!.add(system.systemId);
+        }
+      } catch (error) {
+        logger.warn(
+          `Failed to resolve subscribers for group ${groupId}:`,
+          error,
+        );
+      }
+    }
+  }
+
+  if (userSystems.size === 0) {
+    return;
+  }
+
+  // Phase 3: Send one personalized notification per user
+  const upstreamName =
+    statuses.get(changedSystemId)?.systemName ?? changedSystemId;
+  const upstreamSystemDetailPath = resolveRoute(
+    catalogRoutes.routes.systemDetail,
+    { systemId: changedSystemId },
+  );
+
+  for (const [userId, subscribedSystemIds] of userSystems) {
+    const relevantSystems = systemsToNotify.filter((s) =>
+      subscribedSystemIds.has(s.systemId),
+    );
+    if (relevantSystems.length === 0) continue;
+
+    const allRecovery = relevantSystems.every((s) => s.isRecovery);
+    const systemNames = relevantSystems.map((s) => s.systemName);
+
+    let title: string;
+    let body: string;
+
+    if (relevantSystems.length === 1) {
+      // Single system — use detailed title/body
+      const entry = relevantSystems[0];
+      title = buildNotificationTitle({
+        derivedState: entry.derivedState,
+        isRecovery: entry.isRecovery,
+        systemName: entry.systemName,
+      });
+      body = buildNotificationBody({
+        upstreamNames: entry.upstreamNames,
+        derivedState: entry.derivedState,
+        isRecovery: entry.isRecovery,
+        systemName: entry.systemName,
+      });
+    } else if (allRecovery) {
+      title = `Dependency impact resolved: ${upstreamName}`;
+      body = `All upstream dependencies of **${systemNames.join("**, **")}** have recovered.`;
+    } else {
+      title = `Upstream dependency issue: ${upstreamName} — ${relevantSystems.length} systems affected`;
+      const systemLines = relevantSystems
+        .map((entry) => formatSystemImpactLine(entry))
+        .join("\n");
+      body = `An upstream dependency (**${upstreamName}**) is affecting:\n\n${systemLines}`;
+    }
+
+    const importance = allRecovery
+      ? ("info" as const)
+      : resolveWorstImportance(relevantSystems);
+
+    try {
+      await notificationClient.notifyUsers({
+        userIds: [userId],
+        title,
+        body,
+        importance,
+        action: { label: "View Root Cause", url: upstreamSystemDetailPath },
+      });
+      logger.debug(
+        `Dependency notification sent to user ${userId}: ${relevantSystems.length} system(s)`,
+      );
+    } catch (error) {
+      // Notifications are best-effort
+      logger.warn(
+        `Failed to send dependency notification to user ${userId}:`,
+        error,
+      );
+    }
+  }
+}
+

package/tests/notifications.test.ts

@@ -2,7 +2,9 @@ import { describe, test, expect } from "bun:test";
 import {
   buildNotificationTitle,
   buildNotificationBody,
+  formatSystemImpactLine,
 } from "../src/notifications";
+import type { SystemNotificationEntry } from "../src/notifications";
 import type { DerivedState } from "@checkstack/dependency-common";
 
 describe("Dependency Notification Sidecar", () => {
@@ -15,6 +17,15 @@ describe("Dependency Notification Sidecar", () => {
       expect(title).toBe("Dependency impact resolved");
     });
 
+    test("returns recovery title with system name prefix", () => {
+      const title = buildNotificationTitle({
+        derivedState: undefined,
+        isRecovery: true,
+        systemName: "API Gateway",
+      });
+      expect(title).toBe("API Gateway: Dependency impact resolved");
+    });
+
     test("returns info title for info derived state", () => {
       const title = buildNotificationTitle({
         derivedState: "info",
@@ -23,6 +34,16 @@ describe("Dependency Notification Sidecar", () => {
       expect(title).toContain("informational");
     });
 
+    test("returns info title with system name prefix", () => {
+      const title = buildNotificationTitle({
+        derivedState: "info",
+        isRecovery: false,
+        systemName: "Web Frontend",
+      });
+      expect(title).toStartWith("Web Frontend: ");
+      expect(title).toContain("informational");
+    });
+
     test("returns degraded title for degraded derived state", () => {
       const title = buildNotificationTitle({
         derivedState: "degraded",
@@ -31,6 +52,16 @@ describe("Dependency Notification Sidecar", () => {
       expect(title).toContain("impacted");
     });
 
+    test("returns degraded title with system name prefix", () => {
+      const title = buildNotificationTitle({
+        derivedState: "degraded",
+        isRecovery: false,
+        systemName: "Payment Service",
+      });
+      expect(title).toStartWith("Payment Service: ");
+      expect(title).toContain("impacted");
+    });
+
     test("returns critical title for down derived state", () => {
       const title = buildNotificationTitle({
         derivedState: "down",
@@ -39,6 +70,16 @@ describe("Dependency Notification Sidecar", () => {
       expect(title).toContain("critically impacted");
     });
 
+    test("returns critical title with system name prefix", () => {
+      const title = buildNotificationTitle({
+        derivedState: "down",
+        isRecovery: false,
+        systemName: "Database",
+      });
+      expect(title).toStartWith("Database: ");
+      expect(title).toContain("critically impacted");
+    });
+
     test("returns fallback title for undefined state", () => {
       const title = buildNotificationTitle({
         derivedState: undefined,
@@ -46,6 +87,15 @@ describe("Dependency Notification Sidecar", () => {
       });
       expect(title).toBe("Dependency impact changed");
     });
+
+    test("returns fallback title with system name prefix", () => {
+      const title = buildNotificationTitle({
+        derivedState: undefined,
+        isRecovery: false,
+        systemName: "Monitoring",
+      });
+      expect(title).toBe("Monitoring: Dependency impact changed");
+    });
   });
 
   describe("buildNotificationBody", () => {
@@ -59,6 +109,17 @@ describe("Dependency Notification Sidecar", () => {
       expect(body).toContain("no longer affected");
     });
 
+    test("returns recovery body with system name reference", () => {
+      const body = buildNotificationBody({
+        upstreamNames: ["Database"],
+        derivedState: undefined,
+        isRecovery: true,
+        systemName: "API Gateway",
+      });
+      expect(body).toContain("recovered");
+      expect(body).toContain("**API Gateway**");
+    });
+
     test("includes upstream name in info body", () => {
       const body = buildNotificationBody({
         upstreamNames: ["Redis"],
@@ -69,6 +130,17 @@ describe("Dependency Notification Sidecar", () => {
       expect(body).toContain("informational");
     });
 
+    test("includes system name in info body", () => {
+      const body = buildNotificationBody({
+        upstreamNames: ["Redis"],
+        derivedState: "info",
+        isRecovery: false,
+        systemName: "Cache Layer",
+      });
+      expect(body).toContain("Redis");
+      expect(body).toContain("**Cache Layer**");
+    });
+
     test("includes upstream name in degraded body", () => {
       const body = buildNotificationBody({
         upstreamNames: ["API Gateway"],
@@ -97,6 +169,26 @@ describe("Dependency Notification Sidecar", () => {
       });
       expect(body).toContain("Service A, Service B");
     });
+
+    test("uses 'This system' when no systemName is provided", () => {
+      const body = buildNotificationBody({
+        upstreamNames: ["Redis"],
+        derivedState: "degraded",
+        isRecovery: false,
+      });
+      expect(body).toContain("This system");
+    });
+
+    test("uses bold system name when provided", () => {
+      const body = buildNotificationBody({
+        upstreamNames: ["Redis"],
+        derivedState: "degraded",
+        isRecovery: false,
+        systemName: "My App",
+      });
+      expect(body).toContain("**My App**");
+      expect(body).not.toContain("This system");
+    });
   });
 
   describe("importance mapping", () => {
@@ -151,5 +243,99 @@ describe("Dependency Notification Sidecar", () => {
         expect(body).toContain("Test System");
       });
     }
+
+    for (const state of ["info", "degraded", "down"] as DerivedState[]) {
+      test(`non-recovery '${state}' with system name produces meaningful title and body`, () => {
+        const title = buildNotificationTitle({
+          derivedState: state,
+          isRecovery: false,
+          systemName: "My Service",
+        });
+        const body = buildNotificationBody({
+          upstreamNames: ["Upstream DB"],
+          derivedState: state,
+          isRecovery: false,
+          systemName: "My Service",
+        });
+
+        expect(title).toStartWith("My Service: ");
+        expect(body).toContain("**My Service**");
+        expect(body).toContain("Upstream DB");
+      });
+    }
+  });
+
+  describe("formatSystemImpactLine", () => {
+    const baseEntry: SystemNotificationEntry = {
+      systemId: "sys-1",
+      systemName: "API Gateway",
+      isRecovery: false,
+      importance: "info",
+      upstreamNames: ["Database"],
+    };
+
+    test("formats critically impacted system with red indicator", () => {
+      const line = formatSystemImpactLine({
+        ...baseEntry,
+        derivedState: "down",
+        importance: "critical",
+      });
+      expect(line).toContain("🔴");
+      expect(line).toContain("**API Gateway**");
+      expect(line).toContain("critically impacted");
+    });
+
+    test("formats degraded system with yellow indicator", () => {
+      const line = formatSystemImpactLine({
+        ...baseEntry,
+        derivedState: "degraded",
+        importance: "warning",
+      });
+      expect(line).toContain("🟡");
+      expect(line).toContain("**API Gateway**");
+      expect(line).toContain("degraded");
+    });
+
+    test("formats informational system with info indicator", () => {
+      const line = formatSystemImpactLine({
+        ...baseEntry,
+        derivedState: "info",
+        importance: "info",
+      });
+      expect(line).toContain("ℹ️");
+      expect(line).toContain("**API Gateway**");
+      expect(line).toContain("informational");
+    });
+
+    test("formats recovered system with checkmark indicator", () => {
+      const line = formatSystemImpactLine({
+        ...baseEntry,
+        isRecovery: true,
+        importance: "info",
+      });
+      expect(line).toContain("✅");
+      expect(line).toContain("**API Gateway**");
+      expect(line).toContain("recovered");
+    });
+
+    test("formats system with undefined state", () => {
+      const line = formatSystemImpactLine({
+        ...baseEntry,
+        derivedState: undefined,
+        importance: "info",
+      });
+      expect(line).toContain("**API Gateway**");
+      expect(line).toContain("impact changed");
+    });
+
+    test("all lines start with markdown list prefix", () => {
+      for (const state of ["info", "degraded", "down"] as DerivedState[]) {
+        const line = formatSystemImpactLine({
+          ...baseEntry,
+          derivedState: state,
+        });
+        expect(line).toStartWith("- ");
+      }
+    });
   });
 });