fix(run-store): compare the index-bearing waitpoint set like-for-like

Derive the Postgres waitpointIdSet from completedWaitpointOrder (index-bearing)
to match the Redis read surface, whose distinctIds is the dedupe of the same
ordered set. Comparing it against the full completedWaitpoints relation flagged
a spurious divergence for a non-indexed completed waitpoint (a single wait).

Author: d-cs

internal-packages/run-store/src/snapshotComparator.test.ts

@@ -3,6 +3,7 @@ import {
   diffLatest,
   diffSince,
   normalizeFromRedis,
+  normalizeFromPg,
   SnapshotComparator,
   type DivergenceClass,
   type NormalizedSnapshot,
@@ -154,6 +155,39 @@ describe("diffLatest", () => {
     );
     expect(d.some((x) => x.field === "toString" && x.class === "unknownField")).toBe(true);
   });
+
+  it("normalizeFromPg's waitpointIdSet is index-bearing only, matching the Redis read surface", () => {
+    // A non-indexed completed waitpoint is in the relation but not in completedWaitpointOrder; Redis's
+    // distinctIds (dedupe of order) does not expose it, so the PG side must not either.
+    const row = {
+      id: "s1",
+      engine: "V2",
+      executionStatus: "EXECUTING",
+      description: "d",
+      isValid: true,
+      error: null,
+      previousSnapshotId: null,
+      runId: "r1",
+      runStatus: "EXECUTING",
+      batchId: null,
+      attemptNumber: null,
+      environmentId: "env",
+      environmentType: "DEVELOPMENT",
+      projectId: "p",
+      organizationId: "o",
+      checkpointId: null,
+      workerId: null,
+      runnerId: null,
+      createdAt: new Date(1000),
+      updatedAt: new Date(1000),
+      metadata: null,
+      completedWaitpointOrder: ["w_indexed"],
+      completedWaitpoints: [{ id: "w_indexed" }, { id: "w_nonindexed" }],
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const n = normalizeFromPg(row as any);
+    expect(n.waitpointIdSet).toEqual(["w_indexed"]);
+  });
 });
 
 describe("diffSince", () => {

internal-packages/run-store/src/snapshotComparator.ts

@@ -101,7 +101,6 @@ function canonicalJson(v: unknown): string {
 export function normalizeFromPg(
   row: Prisma.TaskRunExecutionSnapshotGetPayload<{ include: { completedWaitpoints: true } }>
 ): NormalizedSnapshot {
-  const wps = (row.completedWaitpoints ?? []) as Array<{ id: string }>;
   const n: NormalizedSnapshot = {
     id: row.id,
     engine: row.engine,
@@ -125,7 +124,10 @@ export function normalizeFromPg(
     updatedAt: row.updatedAt.getTime(),
     metadata: row.metadata ?? null,
     completedWaitpointOrder: [...(row.completedWaitpointOrder ?? [])],
-    waitpointIdSet: [...wps.map((w) => w.id)].sort(),
+    // Index-bearing distinct set, from completedWaitpointOrder, to match the Redis read surface
+    // (distinctIds = dedupe of `order`). The full relation holds non-indexed ids Redis does not
+    // expose here (payload-layer, out of scope), so comparing it would fire a spurious divergence.
+    waitpointIdSet: [...new Set(row.completedWaitpointOrder ?? [])].sort(),
   };
   carryUnknownKeys(n, row as unknown as Record<string, unknown>);
   return n;