fix(run-ops split): align WaitpointPresenter single-DB fallback and repair read-side test shims

- WaitpointPresenter: default omitted read-through clients to the presenter's own
  replica instead of the global run-ops singletons, so single-DB/self-host reads
  hydrate the waitpoint and its connected runs from one DB.
- SpanPresenter test: bind proxy-returned store methods to the target so private
  field access holds for all methods (e.g. findRunOnPrimary), not just findRun/findRuns.
- ApiRetrieveRunPresenter read-route test: select scalar lockedToVersionId and fold
  the resolved lockedToVersion per node, matching the presenter's current shape.

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

Author: d-cs

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

@@ -1,10 +1,5 @@
 import { isWaitpointOutputTimeout, prettyPrintPacket } from "@trigger.dev/core/v3";
-import {
-  type PrismaClientOrTransaction,
-  type PrismaReplicaClient,
-  runOpsNewReplica,
-  runOpsLegacyReplica,
-} from "~/db.server";
+import { type PrismaClientOrTransaction, type PrismaReplicaClient } from "~/db.server";
 import { clickhouseFactory } from "~/services/clickhouse/clickhouseFactoryInstance.server";
 import { generateHttpCallbackUrl } from "~/services/httpCallback.server";
 import { logger } from "~/services/logger.server";
@@ -74,10 +69,11 @@ export class WaitpointPresenter extends BasePresenter {
       deps: {
         splitEnabled: this.readThroughDeps.splitEnabled,
         newClient:
-          (this.readThroughDeps.newClient as PrismaReplicaClient | undefined) ?? runOpsNewReplica,
+          (this.readThroughDeps.newClient as PrismaReplicaClient | undefined) ??
+          (this._replica as unknown as PrismaReplicaClient),
         legacyReplica:
           (this.readThroughDeps.legacyReplica as PrismaReplicaClient | undefined) ??
-          runOpsLegacyReplica,
+          (this._replica as unknown as PrismaReplicaClient),
       },
     });
 

apps/webapp/test/SpanPresenter.readthrough.test.ts

@@ -157,15 +157,16 @@ async function createRun(
 function ownDbStore(prisma: PrismaClient): RunStore {
   const inner = new PostgresRunStore({ prisma, readOnlyPrisma: prisma });
   return new Proxy(inner, {
-    get(target, prop, receiver) {
+    get(target, prop) {
       if (prop === "findRun" || prop === "findRuns") {
         return (...args: unknown[]) => {
           // Strip a trailing explicit `client` arg so the store reads from its own DB.
           const stripped = stripTrailingClient(prop, args);
-          return (target[prop] as (...a: unknown[]) => unknown)(...stripped);
+          return (target[prop] as (...a: unknown[]) => unknown).apply(target, stripped);
         };
       }
-      return Reflect.get(target, prop, receiver);
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
     },
   }) as unknown as RunStore;
 }

apps/webapp/test/apiRetrieveRunPresenter.readroute.test.ts

@@ -60,7 +60,7 @@ const commonRunSelect = {
   scheduleId: true,
   workerQueue: true,
   region: true,
-  lockedToVersion: { select: { version: true } },
+  lockedToVersionId: true,
   resumeParentOnCompletion: true,
   batch: { select: { id: true, friendlyId: true } },
   runTags: true,
@@ -84,18 +84,28 @@ const findRunSelect = {
 } satisfies Prisma.TaskRunSelect;
 
 // Drive the read exactly as `findRun` does: the RunStore.findRun contract over
-// the given store with the presenter's where+select, mapping to FoundRun.
+// the given store with the presenter's where+select. The scalar `lockedToVersionId`
+// folds to a resolved `lockedToVersion` per node, matching the presenter's shape;
+// seeded runs carry no locked version, so every node resolves to null.
 async function readFoundRunViaStore(
   store: PostgresRunStore,
   friendlyId: string,
   runtimeEnvironmentId: string
 ): Promise<FoundRun | null> {
-  const pgRow = await store.findRun(
+  const pgRow = (await store.findRun(
     { friendlyId, runtimeEnvironmentId },
     { select: findRunSelect }
-  );
+  )) as Record<string, any> | null;
   if (!pgRow) return null;
-  return { ...(pgRow as Omit<FoundRun, "isBuffered">), isBuffered: false };
+  const foldVersion = (run: Record<string, any>) => ({ ...run, lockedToVersion: null });
+  return {
+    ...pgRow,
+    lockedToVersion: null,
+    parentTaskRun: pgRow.parentTaskRun ? foldVersion(pgRow.parentTaskRun) : null,
+    rootTaskRun: pgRow.rootTaskRun ? foldVersion(pgRow.rootTaskRun) : null,
+    childRuns: (pgRow.childRuns ?? []).map(foldVersion),
+    isBuffered: false,
+  } as FoundRun;
 }
 
 async function seedOrgProjectEnv(prisma: PrismaClient, suffix: string) {