fix(run-ops split): drop dead connectedRuns relation from ApiWaitpointPresenter hydrate select

GET /api/v1/waitpoints/tokens/:id returned HTTP 500 under split routing. The
hydrate() select in ApiWaitpointPresenter included the connectedRuns RELATION,
but it is never referenced in the returned object (all scalars) — dead code left
over from the presenters de-join pass (48ae62b70), which stripped relations from
WaitpointListPresenter but missed this one.

Under split routing a standalone cuid token classifies LEGACY, so readThroughRun
probes the scalar-only run-ops NEW client FIRST. The dedicated run-ops Waitpoint
model is scalar-only (relations de-normalized), so Prisma threw
PrismaClientValidationError: Unknown field connectedRuns before the legacy
fallback could run.

Removing the block makes the select all-scalar and valid against both the
control-plane client and the scalar-only run-ops-new client. No return-shape,
type, or SDK change.

Regression test: extends apiWaitpointPresenter.readthrough.test.ts with a
heteroRunOpsPostgresTest case that uses the REAL scalar-only run-ops client
(prisma17) as the split-mode NEW client and seeds a cuid token on the legacy
side. Fails before the fix (Unknown field connectedRuns), passes after
(resolves via the legacy fallback). Not caught by the existing heteroPostgresTest
cases because those run the full control-plane schema on both sides.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: d-cs

apps/webapp/app/presenters/v3/ApiWaitpointPresenter.server.ts

@@ -65,12 +65,6 @@ export class ApiWaitpointPresenter extends BasePresenter {
             completedAfter: true,
             completedAt: true,
             createdAt: true,
-            connectedRuns: {
-              select: {
-                friendlyId: true,
-              },
-              take: 5,
-            },
             tags: true,
           },
         });

apps/webapp/test/apiWaitpointPresenter.readthrough.test.ts

@@ -2,7 +2,12 @@
 // The DB is never mocked: reads hit the two real containers. Only pure boundaries
 // (splitEnabled, isPastRetention) and recording client wrappers are
 // injected. heteroPostgresTest runs the legacy and new databases on different major versions.
-import { heteroPostgresTest, postgresTest } from "@internal/testcontainers";
+import {
+  heteroPostgresTest,
+  heteroRunOpsPostgresTest,
+  postgresTest,
+} from "@internal/testcontainers";
+import type { RunOpsPrismaClient } from "@internal/run-ops-database";
 import type { PrismaClient, WaitpointType } from "@trigger.dev/database";
 import { generateKsuidId } from "@trigger.dev/core/v3/isomorphic";
 import { describe, expect, vi } from "vitest";
@@ -22,7 +27,7 @@ function generateLegacyCuid() {
 
 // A read client whose waitpoint.findFirst is recorded; throws if used after being marked
 // forbidden, so we can prove a store was NEVER read.
-function recording(client: PrismaClient, opts: { forbidden?: boolean } = {}) {
+function recording(client: PrismaClient | RunOpsPrismaClient, opts: { forbidden?: boolean } = {}) {
   const calls: unknown[] = [];
   const waitpoint = {
     findFirst: (args: unknown) => {
@@ -253,6 +258,45 @@ describe("ApiWaitpointPresenter read-through (heterogeneous legacy + new Postgre
   );
 });
 
+// Regression: the split-mode NEW client is the REAL scalar-only run-ops client (prisma17). A cuid
+// classifies LEGACY, so readThroughRun probes NEW first — a relation in hydrate() (connectedRuns)
+// throws PrismaClientValidationError there (the 500) before the legacy fallback runs.
+describe("ApiWaitpointPresenter read-through (dedicated scalar-only run-ops NEW client)", () => {
+  heteroRunOpsPostgresTest(
+    "cuid token: hydrate() select is valid against the scalar-only run-ops client, resolves via legacy",
+    async ({ prisma17, prisma14 }) => {
+      const id = generateLegacyCuid();
+      expect(id.length).toBe(25);
+
+      const { project, environment } = await seedOrgProjectEnv(prisma14, "scalar-legacy");
+      const seeded = await seedWaitpoint(
+        prisma14,
+        id,
+        { id: environment.id, projectId: project.id },
+        { tags: ["p", "q"], output: JSON.stringify({ ok: true }) }
+      );
+
+      const newClient = recording(prisma17);
+      const legacy = recording(prisma14);
+
+      const presenter = new ApiWaitpointPresenter(undefined, undefined, {
+        splitEnabled: true,
+        newClient: newClient.handle,
+        legacyReplica: legacy.handle,
+      });
+
+      // Must NOT throw PrismaClientValidationError; resolves the token off the legacy side.
+      const result = await presenter.call(environmentArg(environment), id);
+
+      expect(result.id).toBe(seeded.friendlyId);
+      expect(result.tags).toEqual(["p", "q"]);
+      expect(result.output).toBe(JSON.stringify({ ok: true }));
+      expect(newClient.calls.length).toBe(1);
+      expect(legacy.calls.length).toBe(1);
+    }
+  );
+});
+
 describe("ApiWaitpointPresenter passthrough (single-DB)", () => {
   postgresTest(
     "no read-through deps → one plain replica read; legacy never touched",