fix(webapp): span detail panel renders for buffered runs

The right-side span detail panel on the run-detail page calls into
`SpanPresenter.call` via the `resources.../runs.$runParam.spans.$spanParam`
resource route. The presenter's first step is a Prisma `findFirst` for
the parent run; for a buffered run that returns null and the whole
`call()` returns undefined.

The route loader interprets undefined as "event not found" and
redirects with that toast. The browser hops back to the run-detail URL
which the previous F2 fix redirects to the `?span=` form, which hits
this resource route again, which returns undefined, which redirects...
the visible symptom is a permanent loading spinner on the detail panel
plus an "Event not found." toast pop on every poll.

Add a buffered fallback inside `SpanPresenter.call`: when the
`parentRun` Prisma lookup misses, resolve the env from
`(projectId, envSlug)`, call
`findRunByIdWithMollifierFallback({runId, envId, orgId})`, and
synthesise the SpanRun with `buildSyntheticSpanRun` (reusing the
existing helper). The resource route now passes `envSlug` through
so the presenter can find the env without an extra round trip.

`envSlug` is optional on `call()`'s arg type to preserve every existing
caller — only the dashboard-side path needs the buffer fallback;
other call sites (cached-span lookups, etc.) keep their existing
PG-only behaviour.

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

Author: d-cs

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

@@ -32,6 +32,8 @@ import {
   extractAIEmbedData,
 } from "~/components/runs/v3/ai";
 import { getEventRepositoryForStore } from "~/v3/eventRepository/index.server";
+import { findRunByIdWithMollifierFallback } from "~/v3/mollifier/readFallback.server";
+import { buildSyntheticSpanRun } from "~/v3/mollifier/syntheticSpanRun.server";
 
 export type PromptSpanData = {
   slug: string;
@@ -84,12 +86,18 @@ export class SpanPresenter extends BasePresenter {
   public async call({
     userId,
     projectSlug,
+    envSlug,
     spanId,
     runFriendlyId,
     linkedRunId,
   }: {
     userId: string;
     projectSlug: string;
+    // Optional for backwards compatibility, required for the mollifier
+    // buffer fallback when the parent run isn't yet in PG — we need to
+    // resolve the env id to satisfy `findRunByIdWithMollifierFallback`'s
+    // auth check.
+    envSlug?: string;
     spanId: string;
     runFriendlyId: string;
     linkedRunId?: string;
@@ -127,7 +135,32 @@ export class SpanPresenter extends BasePresenter {
     });
 
     if (!parentRun) {
-      return;
+      // PG miss → fall back to the mollifier buffer. Without this the
+      // right-side span detail panel on the run-detail page never
+      // resolves for buffered runs: `call()` returns undefined, the
+      // resource route redirects with an "Event not found" toast, the
+      // run-detail page reloads, the toast fires again — a perpetual
+      // spin until the drainer materialises the row. Synthesise a
+      // SpanRun straight from the buffer snapshot, reusing
+      // `buildSyntheticSpanRun` (the same helper the run-detail
+      // loader's header fallback already uses).
+      if (!envSlug) return;
+      const envRow = await this._replica.runtimeEnvironment.findFirst({
+        where: { project: { id: project.id }, slug: envSlug },
+        select: { id: true, slug: true, type: true, organizationId: true },
+      });
+      if (!envRow) return;
+      const buffered = await findRunByIdWithMollifierFallback({
+        runId: runFriendlyId,
+        environmentId: envRow.id,
+        organizationId: envRow.organizationId,
+      });
+      if (!buffered) return;
+      const synth = await buildSyntheticSpanRun({
+        run: buffered,
+        environment: { id: envRow.id, slug: envRow.slug, type: envRow.type },
+      });
+      return { type: "run" as const, run: synth };
     }
 
     const { traceId } = parentRun;

apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.spans.$spanParam/route.tsx

@@ -120,6 +120,7 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   try {
     const result = await presenter.call({
       projectSlug: projectParam,
+      envSlug: envParam,
       spanId: spanParam,
       runFriendlyId: runParam,
       userId,