feat: route new task runs to a parallel task_run_v2 table

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

@@ -23,6 +23,7 @@ import {
 } from "~/v3/mollifier/readFallback.server";
 import { generatePresignedUrl } from "~/v3/objectStore.server";
 import { runStore } from "~/v3/runStore.server";
+import { hydrateParentAndRoot, hydrateChildRuns } from "~/v3/runHierarchy.server";
 import { tracer } from "~/v3/tracer.server";
 import { startSpanWithEnv } from "~/v3/tracing.server";
 
@@ -133,21 +134,34 @@ export class ApiRetrieveRunPresenter {
           attemptNumber: true,
           engine: true,
           taskEventStore: true,
-          parentTaskRun: {
-            select: commonRunSelect,
-          },
-          rootTaskRun: {
-            select: commonRunSelect,
-          },
-          childRuns: {
-            select: commonRunSelect,
-          },
+          parentTaskRunId: true,
+          rootTaskRunId: true,
         },
       },
       $replica
     );
 
-    if (pgRow) return { ...pgRow, isBuffered: false };
+    if (pgRow) {
+      // Resolve parent/root/children across both run tables. A single Prisma
+      // relation select is table-bound, so a v2 run's legacy parent (or a
+      // legacy run's v2 children), which arise in the mixed window, would come
+      // back null/empty. Resolve parent/root by id (RunStore routes by format)
+      // and children by a both-table predicate.
+      const { parentTaskRun, rootTaskRun } = await hydrateParentAndRoot(
+        { parentTaskRunId: pgRow.parentTaskRunId, rootTaskRunId: pgRow.rootTaskRunId },
+        { runtimeEnvironmentId: env.id },
+        commonRunSelect,
+        $replica
+      );
+      const childRuns = await hydrateChildRuns(
+        pgRow.id,
+        { runtimeEnvironmentId: env.id },
+        commonRunSelect,
+        $replica
+      );
+
+      return { ...pgRow, parentTaskRun, rootTaskRun, childRuns, isBuffered: false };
+    }
 
     // Postgres miss → fall back to the mollifier buffer. When the gate
     // diverted a trigger, the run lives in Redis until the drainer replays

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

@@ -9,6 +9,7 @@ import { isFinalRunStatus } from "~/v3/taskStatus";
 import { env } from "~/env.server";
 import { getEventRepositoryForStore } from "~/v3/eventRepository/index.server";
 import { runStore } from "~/v3/runStore.server";
+import { hydrateParentAndRoot } from "~/v3/runHierarchy.server";
 
 type Result = Awaited<ReturnType<RunPresenter["call"]>>;
 export type Run = Result["run"];
@@ -93,20 +94,8 @@ export class RunPresenter {
           completedAt: true,
           logsDeletedAt: true,
           annotations: true,
-          rootTaskRun: {
-            select: {
-              friendlyId: true,
-              spanId: true,
-              createdAt: true,
-            },
-          },
-          parentTaskRun: {
-            select: {
-              friendlyId: true,
-              spanId: true,
-              createdAt: true,
-            },
-          },
+          rootTaskRunId: true,
+          parentTaskRunId: true,
           runtimeEnvironment: {
             select: {
               id: true,
@@ -143,6 +132,16 @@ export class RunPresenter {
 
     const showLogs = showDeletedLogs || !run.logsDeletedAt;
 
+    // Resolve parent/root across both physical run tables: a v2 run can have a
+    // legacy parent/root (or vice versa) in the mixed window, which a
+    // table-bound Prisma relation select would miss.
+    const { parentTaskRun, rootTaskRun } = await hydrateParentAndRoot(
+      { parentTaskRunId: run.parentTaskRunId, rootTaskRunId: run.rootTaskRunId },
+      { runtimeEnvironmentId: run.runtimeEnvironment.id },
+      { friendlyId: true, spanId: true, createdAt: true },
+      this.#prismaClient
+    );
+
     const runData = {
       id: run.id,
       number: run.number,
@@ -154,8 +153,8 @@ export class RunPresenter {
       startedAt: run.startedAt,
       completedAt: run.completedAt,
       logsDeletedAt: showDeletedLogs ? null : run.logsDeletedAt,
-      rootTaskRun: run.rootTaskRun,
-      parentTaskRun: run.parentTaskRun,
+      rootTaskRun,
+      parentTaskRun,
       environment: {
         id: run.runtimeEnvironment.id,
         organizationId: run.runtimeEnvironment.organizationId,
@@ -184,7 +183,7 @@ export class RunPresenter {
       getTaskEventStoreTableForRun(run),
       run.runtimeEnvironment.id,
       run.traceId,
-      run.rootTaskRun?.createdAt ?? run.createdAt,
+      rootTaskRun?.createdAt ?? run.createdAt,
       run.completedAt ?? undefined,
       { includeDebugLogs: showDebug }
     );

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

@@ -587,22 +587,9 @@ export class SpanPresenter extends BasePresenter {
             filePath: true,
           },
         },
-        //relationships
-        rootTaskRun: {
-          select: {
-            taskIdentifier: true,
-            friendlyId: true,
-            spanId: true,
-            createdAt: true,
-          },
-        },
-        parentTaskRun: {
-          select: {
-            taskIdentifier: true,
-            friendlyId: true,
-            spanId: true,
-          },
-        },
+        //relationships (resolved across both run tables after the fetch)
+        rootTaskRunId: true,
+        parentTaskRunId: true,
         batch: {
           select: {
             friendlyId: true,
@@ -626,7 +613,31 @@ export class SpanPresenter extends BasePresenter {
       this._replica
     );
 
-    return run;
+    if (!run) {
+      return run;
+    }
+
+    // Resolve parent/root across both run tables: a v2 run can reference a
+    // legacy parent/root (or vice versa) in the mixed window, which a
+    // table-bound Prisma relation select on a single table would miss.
+    const [parentTaskRun, rootTaskRun] = await Promise.all([
+      run.parentTaskRunId
+        ? runStore.findRun(
+            { id: run.parentTaskRunId, runtimeEnvironmentId: environmentId },
+            { select: { taskIdentifier: true, friendlyId: true, spanId: true } },
+            this._replica
+          )
+        : Promise.resolve(null),
+      run.rootTaskRunId
+        ? runStore.findRun(
+            { id: run.rootTaskRunId, runtimeEnvironmentId: environmentId },
+            { select: { taskIdentifier: true, friendlyId: true, spanId: true, createdAt: true } },
+            this._replica
+          )
+        : Promise.resolve(null),
+    ]);
+
+    return { ...run, parentTaskRun, rootTaskRun };
   }
 
   async #getSpan({