fix(run-ops split): self-default resolveWaitpointThroughReadThrough to safe run-ops clients

The read-through concern defaulted both newClient and legacyReplica to $replica
(control-plane), so a bare caller that omits `deps` — the waitpoints wait route —
never queried the dedicated run-ops replica. A co-located, NEW-resident waitpoint
minted by streams.input().wait() lives on the run-ops-new DB, so the read missed,
returned null, and the route 404'd (re-serialized to 500).

Match the deps the complete/callback routes pass: default newClient to
runOpsNewReplica, legacyReplica to $replica, and splitEnabled to
runOpsSplitReadEnabled — mirroring readThroughRun's own self-defaulting. This
immunizes any bare caller (present or future) against the control-plane pin,
without touching the wait route. The wait/complete/callback call sites live on a
higher branch and are unchanged; complete/callback keep their explicit deps
(now redundant but harmless).

Adds a heteroRunOps regression case driving the concern with no `deps` via the
`defaults` DI seam: proves the old $replica default misses a NEW-resident
waitpoint (null) while the safe run-ops default finds it. No mocks; the fallback
is exercised against real PG14/PG17 containers.

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

Author: d-cs

apps/webapp/app/runEngine/concerns/resolveWaitpointThroughReadThrough.server.ts

@@ -1,5 +1,9 @@
 import type { PrismaReplicaClient } from "~/db.server";
-import { $replica } from "~/db.server";
+import {
+  $replica as defaultLegacyReplica,
+  runOpsNewReplica as defaultNewClient,
+  runOpsSplitReadEnabled as defaultSplitReadEnabled,
+} from "~/db.server";
 import { readThroughRun } from "~/v3/runOpsMigration/readThrough.server";
 
 type ResolveWaitpointDeps = {
@@ -9,21 +13,38 @@ type ResolveWaitpointDeps = {
   isPastRetention?: (id: string) => boolean;
 };
 
+// Safe defaults matching the deps `complete`/`callback` pass, so a bare caller still fans
+// out to the dedicated run-ops replica (NEW-resident waitpoints) before control-plane.
+export type ResolveWaitpointReadThroughDefaults = {
+  newClient: PrismaReplicaClient;
+  legacyReplica: PrismaReplicaClient;
+  splitEnabled: boolean;
+};
+
+const productionDefaults: ResolveWaitpointReadThroughDefaults = {
+  newClient: defaultNewClient,
+  legacyReplica: defaultLegacyReplica,
+  splitEnabled: defaultSplitReadEnabled,
+};
+
 export async function resolveWaitpointThroughReadThrough<T>(opts: {
   waitpointId: string;
   environmentId: string;
   read: (client: PrismaReplicaClient) => Promise<T | null>;
   deps?: ResolveWaitpointDeps;
+  defaults?: ResolveWaitpointReadThroughDefaults;
 }): Promise<T | null> {
+  const defaults = opts.defaults ?? productionDefaults;
+
   const result = await readThroughRun({
     runId: opts.waitpointId,
     environmentId: opts.environmentId,
     readNew: (client) => opts.read(client),
     readLegacy: (replica) => opts.read(replica),
     deps: {
-      splitEnabled: opts.deps?.splitEnabled,
-      newClient: opts.deps?.newClient ?? $replica,
-      legacyReplica: opts.deps?.legacyReplica ?? $replica,
+      splitEnabled: opts.deps?.splitEnabled ?? defaults.splitEnabled,
+      newClient: opts.deps?.newClient ?? defaults.newClient,
+      legacyReplica: opts.deps?.legacyReplica ?? defaults.legacyReplica,
       isPastRetention: opts.deps?.isPastRetention,
     },
   });

apps/webapp/test/resolveWaitpointThroughReadThrough.readthrough.test.ts

@@ -151,6 +151,49 @@ describe("resolveWaitpointThroughReadThrough (hetero PG14 legacy + dedicated run
     }
   );
 
+  heteroRunOpsPostgresTest(
+    "bare caller (no deps) resolves a NEW-resident waitpoint via the safe run-ops defaults",
+    async ({ prisma17, prisma14 }) => {
+      // The bare wait route passes NO `deps`; the `defaults` DI seam models old vs new
+      // fallback against containers, avoiding the real db.server topology.
+      const id = generateKsuidId();
+      expect(id.length).toBe(27);
+      const environmentId = generateKsuidId();
+      const projectId = generateKsuidId();
+      const seeded = await seedWaitpoint(prisma17, id, { id: environmentId, projectId });
+
+      // FAIL-BEFORE: old default pinned newClient to control-plane ($replica ≈ prisma14) → miss.
+      const oldDefaultResult = await resolveWaitpointThroughReadThrough({
+        waitpointId: id,
+        environmentId,
+        read: read(id, environmentId),
+        defaults: {
+          newClient: prisma14 as unknown as PrismaReplicaClient,
+          legacyReplica: prisma14 as unknown as PrismaReplicaClient,
+          splitEnabled: true,
+        },
+      });
+      expect(oldDefaultResult).toBeNull();
+
+      // PASS-AFTER: safe default routes newClient to the run-ops replica (runOpsNewReplica ≈ prisma17).
+      const safeDefaultResult = await resolveWaitpointThroughReadThrough({
+        waitpointId: id,
+        environmentId,
+        read: read(id, environmentId),
+        defaults: {
+          newClient: prisma17 as unknown as PrismaReplicaClient,
+          legacyReplica: prisma14 as unknown as PrismaReplicaClient,
+          splitEnabled: true,
+        },
+      });
+
+      expect(safeDefaultResult).not.toBeNull();
+      expect(safeDefaultResult!.id).toBe(seeded.id);
+      expect(safeDefaultResult!.projectId).toBe(projectId);
+      expect(safeDefaultResult!.environmentId).toBe(environmentId);
+    }
+  );
+
   heteroRunOpsPostgresTest("not-found maps to null (no throw)", async ({ prisma17, prisma14 }) => {
     const id = generateLegacyCuid();
     const { environment } = await seedOrgProjectEnv(prisma14, "nf");