fix(webapp): reflect terminal state in mollifier synthetic span/trace

The synthetic SpanRun/trace builders for buffered runs hardcoded
non-terminal state, so a CANCELED or FAILED buffered run rendered as a
healthy in-progress run:

- syntheticSpanRun: FAILED now maps to SYSTEM_FAILURE (matching
  ApiRetrieveRunPresenter.bufferedStatusToTaskRunStatus); isFinished is
  true for CANCELED/FAILED; isError is true for FAILED; the error block
  is synthesised as STRING_ERROR and statusReason carries the message.
- syntheticSpanRun: drop the empty-string spanId/taskIdentifier
  relationship stubs (blank task name + misleading `?span=` jump) since
  the snapshot only carries friendly IDs.
- syntheticTrace: FAILED now renders as an errored, non-partial,
  "failed" root span instead of executing/partial. CANCELED stays
  "completed", matching RunPresenter's derivation.
- tests: cover the CANCELED and FAILED terminal paths.

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

Author: d-cs

apps/webapp/app/v3/mollifier/syntheticSpanRun.server.ts

@@ -20,9 +20,11 @@ function narrowMachinePreset(value: string | undefined): SpanRun["machinePreset"
 
 // Synthesise a SpanRun-shaped object from a buffered run so the run-detail
 // page's right-side details panel renders identically to a PG-resident
-// run. The shape matches `SpanPresenter.getRun`'s return value exactly;
-// buffered-irrelevant fields (output, error, attempts, schedule, session,
-// region, batch) are filled with sensible defaults.
+// run. The shape matches `SpanPresenter.getRun`'s return value;
+// buffered-irrelevant fields (output, attempts, schedule, session,
+// region, batch) are filled with sensible defaults, while terminal state
+// (CANCELED / FAILED) is reflected into `status`, `isFinished`, `isError`
+// and `error` so a finished buffered run does not render as PENDING.
 //
 // Pretty-printing for payload and metadata mirrors SpanPresenter so the
 // UI receives data in the same shape. Buffered runs cannot use the
@@ -64,11 +66,36 @@ export async function buildSyntheticSpanRun(args: {
 
   const queueName = run.queue ?? "task/";
   const isCancelled = run.status === "CANCELED";
+  const isFailed = run.status === "FAILED";
+
+  // The run-detail panel derives terminal/error state from `status`,
+  // `isFinished` and `isError` (SpanPresenter.getRun -> isFinalRunStatus /
+  // isFailedRunStatus). Buffered FAILED runs surface as SYSTEM_FAILURE to
+  // match ApiRetrieveRunPresenter.bufferedStatusToTaskRunStatus; both
+  // CANCELED and SYSTEM_FAILURE are final run statuses, and SYSTEM_FAILURE
+  // is also a failed status.
+  const status: SpanRun["status"] = isCancelled
+    ? "CANCELED"
+    : isFailed
+    ? "SYSTEM_FAILURE"
+    : "PENDING";
+
+  // Mirror ApiRetrieveRunPresenter's STRING_ERROR synthesis so the panel
+  // shows why a buffered run failed instead of an empty error block.
+  const error: SpanRun["error"] =
+    isFailed && run.error
+      ? { type: "STRING_ERROR", raw: `${run.error.code}: ${run.error.message}` }
+      : undefined;
+
   return {
     id: run.id,
     friendlyId: run.friendlyId,
-    status: isCancelled ? "CANCELED" : "PENDING",
-    statusReason: isCancelled ? run.cancelReason ?? undefined : undefined,
+    status,
+    statusReason: isCancelled
+      ? run.cancelReason ?? undefined
+      : isFailed
+      ? run.error?.message ?? undefined
+      : undefined,
     createdAt: run.createdAt,
     startedAt: null,
     executedAt: null,
@@ -102,32 +129,24 @@ export async function buildSyntheticSpanRun(args: {
     costInCents: 0,
     totalCostInCents: 0,
     usageDurationMs: 0,
-    isFinished: false,
+    isFinished: isCancelled || isFailed,
     isRunning: false,
-    isError: false,
+    isError: isFailed,
     isAgentRun,
     payload,
     payloadType: run.payloadType ?? "application/json",
     output: undefined,
     outputType: "application/json",
-    error: undefined,
+    error,
+    // The snapshot only carries the root/parent friendly IDs, not the
+    // spanId or taskIdentifier that SpanPresenter sources from the joined
+    // PG rows. Emitting them with empty-string stubs renders a blank task
+    // name and a misleading `?span=` jump target, so we omit the
+    // relationships until the drainer materialises the row (a transient
+    // window). Top-level buffered runs have no relationships regardless.
     relationships: {
-      root: run.rootTaskRunFriendlyId
-        ? {
-            friendlyId: run.rootTaskRunFriendlyId,
-            spanId: "",
-            taskIdentifier: "",
-            createdAt: run.createdAt,
-            isParent: run.parentTaskRunFriendlyId === run.rootTaskRunFriendlyId,
-          }
-        : undefined,
-      parent: run.parentTaskRunFriendlyId
-        ? {
-            friendlyId: run.parentTaskRunFriendlyId,
-            spanId: "",
-            taskIdentifier: "",
-          }
-        : undefined,
+      root: undefined,
+      parent: undefined,
     },
     context: JSON.stringify(
       {

apps/webapp/app/v3/mollifier/syntheticTrace.server.ts

@@ -13,6 +13,7 @@ import type { SyntheticRun } from "./readFallback.server";
 export function buildSyntheticTraceForBufferedRun(run: SyntheticRun) {
   const spanId = run.spanId ?? "";
   const isCancelled = run.status === "CANCELED";
+  const isFailed = run.status === "FAILED";
   const span: SpanSummary = {
     id: spanId,
     parentId: run.parentSpanId,
@@ -23,8 +24,11 @@ export function buildSyntheticTraceForBufferedRun(run: SyntheticRun) {
       events: [],
       startTime: run.createdAt,
       duration: 0,
-      isError: false,
-      isPartial: !isCancelled,
+      isError: isFailed,
+      // CANCELED and FAILED are terminal; only a still-queued buffered run
+      // is partial. A partial failed span would otherwise render as
+      // "executing" forever in the timeline.
+      isPartial: !isCancelled && !isFailed,
       isCancelled,
       isDebug: false,
       level: "TRACE",
@@ -54,7 +58,13 @@ export function buildSyntheticTraceForBufferedRun(run: SyntheticRun) {
     : [];
 
   return {
-    rootSpanStatus: (isCancelled ? "completed" : "executing") as "executing" | "completed" | "failed",
+    // Matches RunPresenter's derivation: failed root span -> "failed",
+    // otherwise a terminal (non-partial) span -> "completed", else
+    // "executing". CANCELED is terminal-but-not-error, so "completed".
+    rootSpanStatus: (isFailed ? "failed" : isCancelled ? "completed" : "executing") as
+      | "executing"
+      | "completed"
+      | "failed",
     events,
     duration: totalDuration,
     rootStartedAt: tree?.data.startTime,

apps/webapp/test/mollifierSyntheticSpanRun.test.ts

@@ -129,17 +129,16 @@ describe("buildSyntheticSpanRun", () => {
     expect(noKey.idempotencyKeyStatus).toBeUndefined();
   });
 
-  it("fills relationship metadata from parent/root snapshot fields when present", async () => {
+  it("omits relationships even when parent/root friendlyIds are present, since the snapshot lacks their spanId/taskIdentifier", async () => {
     const synth = await buildSyntheticSpanRun({
       run: makeSyntheticRun({
         parentTaskRunFriendlyId: "run_parent",
         rootTaskRunFriendlyId: "run_root",
       }),
       environment: ENV,
     });
-    expect(synth.relationships.parent?.friendlyId).toBe("run_parent");
-    expect(synth.relationships.root?.friendlyId).toBe("run_root");
-    expect(synth.relationships.root?.isParent).toBe(false);
+    expect(synth.relationships.parent).toBeUndefined();
+    expect(synth.relationships.root).toBeUndefined();
   });
 
   it("returns no relationship objects when the snapshot has no parent/root", async () => {
@@ -151,6 +150,40 @@ describe("buildSyntheticSpanRun", () => {
     expect(synth.relationships.root).toBeUndefined();
   });
 
+  it("reflects a buffered CANCELED run as a finished, cancelled terminal state", async () => {
+    const synth = await buildSyntheticSpanRun({
+      run: makeSyntheticRun({
+        status: "CANCELED",
+        cancelledAt: NOW,
+        cancelReason: "cancelled by user",
+      }),
+      environment: ENV,
+    });
+    expect(synth.status).toBe("CANCELED");
+    expect(synth.statusReason).toBe("cancelled by user");
+    expect(synth.isFinished).toBe(true);
+    expect(synth.isError).toBe(false);
+    expect(synth.completedAt).toEqual(NOW);
+  });
+
+  it("reflects a buffered FAILED run as a finished, errored SYSTEM_FAILURE", async () => {
+    const synth = await buildSyntheticSpanRun({
+      run: makeSyntheticRun({
+        status: "FAILED",
+        error: { code: "GATE_REJECTED", message: "buffer rejected the run" },
+      }),
+      environment: ENV,
+    });
+    expect(synth.status).toBe("SYSTEM_FAILURE");
+    expect(synth.isFinished).toBe(true);
+    expect(synth.isError).toBe(true);
+    expect(synth.statusReason).toBe("buffer rejected the run");
+    expect(synth.error).toEqual({
+      type: "STRING_ERROR",
+      raw: "GATE_REJECTED: buffer rejected the run",
+    });
+  });
+
   it("flags the synthetic run as 'not cached' since cache lookup did not match it", async () => {
     const synth = await buildSyntheticSpanRun({ run: makeSyntheticRun(), environment: ENV });
     expect(synth.isCached).toBe(false);