feat(webapp): mollifier read-fallback for /api/v1/runs/{id}/trace

Phase A1 of the mollifier API parity work. The trace endpoint now falls
back to the mollifier buffer when the run isn't in Postgres yet, returning
an empty trace skeleton (200) instead of a 404 for buffered runs.

`findResource` is restructured into a discriminated union — `pg` for real
TaskRun rows, `buffer` for synthesised shapes from the buffer entry. The
authorization branch handles both shapes; the handler renders an empty
`{ trace: { traceId, rootSpan: null, events: [] } }` for buffered runs so
the customer sees the same 200 contract they'd get for a freshly-triggered
PG run that hasn't had its first span recorded yet.

See _plans/2026-05-19-mollifier-api-parity.md for the full plan and
_plans/2026-05-19-mollifier-listing-design.md for the read-fallback
companion infrastructure this builds on.

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

Author: d-cs

apps/webapp/app/routes/api.v1.runs.$runId.trace.ts

@@ -8,41 +8,92 @@ import {
 } from "~/services/routeBuilders/apiBuilder.server";
 import { resolveEventRepositoryForStore } from "~/v3/eventRepository/index.server";
 import { getTaskEventStoreTableForRun } from "~/v3/taskEventStore.server";
+import { findRunByIdWithMollifierFallback } from "~/v3/mollifier/readFallback.server";
 
 const ParamsSchema = z.object({
   runId: z.string(), // This is the run friendly ID
 });
 
+// Discriminator on the resolved resource — `pg` is the real Prisma TaskRun
+// row, `buffer` is a synthesised shape from the mollifier buffer for runs
+// whose drainer hasn't yet materialised them. The handler renders an empty
+// trace for buffered runs so the customer sees the same 200 shape they'd
+// get for a freshly-triggered PG run with no spans yet (matches the
+// pass-through control case in scripts/mollifier-api-parity.sh).
+type ResolvedRun =
+  | { source: "pg"; run: Awaited<ReturnType<typeof findPgRun>> & {} }
+  | { source: "buffer"; run: NonNullable<Awaited<ReturnType<typeof findRunByIdWithMollifierFallback>>> };
+
+async function findPgRun(runId: string, environmentId: string) {
+  return $replica.taskRun.findFirst({
+    where: { friendlyId: runId, runtimeEnvironmentId: environmentId },
+  });
+}
+
 export const loader = createLoaderApiRoute(
   {
     params: ParamsSchema,
     allowJWT: true,
     corsStrategy: "all",
-    findResource: (params, auth) => {
-      return $replica.taskRun.findFirst({
-        where: {
-          friendlyId: params.runId,
-          runtimeEnvironmentId: auth.environment.id,
-        },
+    findResource: async (params, auth): Promise<ResolvedRun | null> => {
+      const pgRun = await findPgRun(params.runId, auth.environment.id);
+      if (pgRun) return { source: "pg", run: pgRun };
+
+      const buffered = await findRunByIdWithMollifierFallback({
+        runId: params.runId,
+        environmentId: auth.environment.id,
+        organizationId: auth.environment.organizationId,
       });
+      if (buffered) return { source: "buffer", run: buffered };
+
+      return null;
     },
     shouldRetryNotFound: true,
     authorization: {
       action: "read",
-      resource: (run) => {
+      resource: (resolved) => {
+        if (resolved.source === "pg") {
+          const run = resolved.run;
+          const resources = [
+            { type: "runs", id: run.friendlyId },
+            { type: "tasks", id: run.taskIdentifier },
+            ...run.runTags.map((tag) => ({ type: "tags", id: tag })),
+          ];
+          if (run.batchId) {
+            resources.push({ type: "batch", id: BatchId.toFriendlyId(run.batchId) });
+          }
+          return anyResource(resources);
+        }
+        const run = resolved.run;
         const resources = [
           { type: "runs", id: run.friendlyId },
-          { type: "tasks", id: run.taskIdentifier },
-          ...run.runTags.map((tag) => ({ type: "tags", id: tag })),
+          ...(run.taskIdentifier ? [{ type: "tasks", id: run.taskIdentifier }] : []),
+          ...run.tags.map((tag) => ({ type: "tags", id: tag })),
         ];
-        if (run.batchId) {
-          resources.push({ type: "batch", id: BatchId.toFriendlyId(run.batchId) });
-        }
         return anyResource(resources);
       },
     },
   },
-  async ({ resource: run, authentication }) => {
+  async ({ resource: resolved, authentication }) => {
+    if (resolved.source === "buffer") {
+      // Buffered runs have no events ingested yet — the drainer hasn't
+      // materialised the PG row and the worker hasn't started executing.
+      // Return an empty trace skeleton so the customer's SDK sees the same
+      // 200 shape it would get from a freshly-triggered PG run that hasn't
+      // had its first span recorded yet.
+      return json(
+        {
+          trace: {
+            traceId: resolved.run.traceId ?? "",
+            rootSpan: null,
+            events: [],
+          },
+        },
+        { status: 200 }
+      );
+    }
+
+    const run = resolved.run;
     const eventRepository = resolveEventRepositoryForStore(run.taskEventStore);
 
     const traceSummary = await eventRepository.getTraceDetailedSummary(