fix(webapp): readFallback batch + parent/root friendlyId from snapshot

Addresses two Devin findings on PR #3753 (readFallback.server.ts:206 comments 2026-05-28).

1) batchId field-name mismatch: #buildEngineTriggerInput in triggerTask.server.ts writes batch info as a nested object 'batch: { id, index }', not as a flat 'batchId'. readFallback was reading the non-existent snapshot.batchId so SyntheticRun.batchId was always undefined for buffered runs. Now reads snapshot.batch.id (the internal cuid, matching what PG stores in TaskRun.batchId).

2) parentTaskRunFriendlyId / rootTaskRunFriendlyId structurally unfillable: the snapshot carries the INTERNAL parent/root ids (parentTaskRunId / rootTaskRunId, what engine.trigger consumes), not friendlyIds. Convert internal to friendly via RunId.toFriendlyId so consumers do not have to special-case the buffered path.

Four regression tests in mollifierReadFallback.test.ts: batchId extracted from nested snapshot.batch.id; a flat snapshot.batchId key is ignored (belt-and-braces); parent/root friendly conversion round-trips through RunId.generate(); parent/root undefined when the snapshot has no parent context.

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

Author: d-cs

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

@@ -109,6 +109,15 @@ function asDate(value: unknown): Date | undefined {
   return Number.isNaN(parsed.getTime()) ? undefined : parsed;
 }
 
+// Snapshot ids are written by engine.trigger as INTERNAL ids (cuids); the
+// SyntheticRun contract exposes friendlyIds. `RunId.toFriendlyId` is
+// already used for the synthetic run's own id (line 155); reuse it for
+// parent/root so consumers see the same shape as the PG path.
+function internalRunIdToFriendlyId(internalId: string | undefined): string | undefined {
+  if (!internalId) return undefined;
+  return RunId.toFriendlyId(internalId);
+}
+
 export async function findRunByIdWithMollifierFallback(
   input: ReadFallbackInput,
   deps: ReadFallbackDeps = {},
@@ -201,9 +210,23 @@ export async function findRunByIdWithMollifierFallback(
       annotations: snapshot.annotations,
       traceContext: snapshot.traceContext,
       scheduleId: asString(snapshot.scheduleId),
-      batchId: asString(snapshot.batchId),
-      parentTaskRunFriendlyId: asString(snapshot.parentTaskRunFriendlyId),
-      rootTaskRunFriendlyId: asString(snapshot.rootTaskRunFriendlyId),
+      // The engine.trigger input embeds the batch as `{ id, index }` (see
+      // triggerTask.server.ts #buildEngineTriggerInput), not as a flat
+      // `batchId`. The nested `id` is the batch's internal cuid — the same
+      // value PG stores in `TaskRun.batchId` — so callers reconstruct the
+      // friendly id via `BatchId.toFriendlyId` exactly as the PG path does.
+      batchId: asString((snapshot.batch as { id?: unknown } | undefined)?.id),
+      // The snapshot only carries the INTERNAL parent/root ids
+      // (`parentTaskRunId` / `rootTaskRunId` — what engine.trigger consumes),
+      // not the friendlyIds the SyntheticRun contract expects. Convert
+      // internal → friendly here so consumers don't have to special-case
+      // the buffered path.
+      parentTaskRunFriendlyId: internalRunIdToFriendlyId(
+        asString(snapshot.parentTaskRunId)
+      ),
+      rootTaskRunFriendlyId: internalRunIdToFriendlyId(
+        asString(snapshot.rootTaskRunId)
+      ),
 
       error: entry.lastError,
     };

apps/webapp/test/mollifierReadFallback.test.ts

@@ -7,6 +7,7 @@ vi.mock("~/db.server", () => ({
 
 import { findRunByIdWithMollifierFallback } from "~/v3/mollifier/readFallback.server";
 import type { MollifierBuffer, BufferEntry } from "@trigger.dev/redis-worker";
+import { RunId } from "@trigger.dev/core/v3/isomorphic";
 
 function fakeBuffer(entry: BufferEntry | null): MollifierBuffer {
   return {
@@ -329,4 +330,100 @@ describe("findRunByIdWithMollifierFallback", () => {
     expect(result!.workerQueue).toBeUndefined();
     expect(result!.queue).toBeUndefined();
   });
+
+  it("extracts batchId from the nested snapshot.batch object (not the flat key)", async () => {
+    // Regression for the field-name mismatch Devin flagged:
+    // #buildEngineTriggerInput writes batch info as
+    // `batch: { id, index }`, never as a flat `batchId`. readFallback
+    // must read the nested key, otherwise SyntheticRun.batchId is always
+    // undefined for buffered runs.
+    const entry: BufferEntry = {
+      runId: "run_1",
+      envId: "env_a",
+      orgId: "org_1",
+      payload: JSON.stringify({
+        taskIdentifier: "t",
+        batch: { id: "batch_internal_xyz", index: 3 },
+      }),
+      status: "QUEUED",
+      attempts: 0,
+      createdAt: NOW,
+    };
+    const result = await findRunByIdWithMollifierFallback(
+      { runId: "run_1", environmentId: "env_a", organizationId: "org_1" },
+      { getBuffer: () => fakeBuffer(entry) },
+    );
+    expect(result!.batchId).toBe("batch_internal_xyz");
+  });
+
+  it("does NOT read a flat `batchId` key — only the nested batch.id", async () => {
+    // Belt-and-braces: a payload with the wrong-shaped flat key should
+    // resolve to undefined, not silently pick up the bogus value.
+    const entry: BufferEntry = {
+      runId: "run_1",
+      envId: "env_a",
+      orgId: "org_1",
+      payload: JSON.stringify({
+        taskIdentifier: "t",
+        batchId: "should-be-ignored",
+      }),
+      status: "QUEUED",
+      attempts: 0,
+      createdAt: NOW,
+    };
+    const result = await findRunByIdWithMollifierFallback(
+      { runId: "run_1", environmentId: "env_a", organizationId: "org_1" },
+      { getBuffer: () => fakeBuffer(entry) },
+    );
+    expect(result!.batchId).toBeUndefined();
+  });
+
+  it("converts internal parent/root IDs in the snapshot to friendlyIds", async () => {
+    // Regression for Devin's structural-unfillable finding: the snapshot
+    // only carries INTERNAL parent/root ids (engine.trigger consumes the
+    // internal shape), while SyntheticRun exposes friendlyIds. Convert
+    // here so consumers don't have to special-case the buffered path.
+    // The conversion is deterministic via RunId.toFriendlyId — we drive
+    // it through `RunId.generate()` to get a matching internal+friendly
+    // pair and assert the round-trip.
+    const parent = RunId.generate();
+    const root = RunId.generate();
+    const entry: BufferEntry = {
+      runId: "run_1",
+      envId: "env_a",
+      orgId: "org_1",
+      payload: JSON.stringify({
+        taskIdentifier: "t",
+        parentTaskRunId: parent.id,
+        rootTaskRunId: root.id,
+      }),
+      status: "QUEUED",
+      attempts: 0,
+      createdAt: NOW,
+    };
+    const result = await findRunByIdWithMollifierFallback(
+      { runId: "run_1", environmentId: "env_a", organizationId: "org_1" },
+      { getBuffer: () => fakeBuffer(entry) },
+    );
+    expect(result!.parentTaskRunFriendlyId).toBe(parent.friendlyId);
+    expect(result!.rootTaskRunFriendlyId).toBe(root.friendlyId);
+  });
+
+  it("leaves parent/root friendlyIds undefined when the snapshot carries no parent context", async () => {
+    const entry: BufferEntry = {
+      runId: "run_1",
+      envId: "env_a",
+      orgId: "org_1",
+      payload: JSON.stringify({ taskIdentifier: "t" }),
+      status: "QUEUED",
+      attempts: 0,
+      createdAt: NOW,
+    };
+    const result = await findRunByIdWithMollifierFallback(
+      { runId: "run_1", environmentId: "env_a", organizationId: "org_1" },
+      { getBuffer: () => fakeBuffer(entry) },
+    );
+    expect(result!.parentTaskRunFriendlyId).toBeUndefined();
+    expect(result!.rootTaskRunFriendlyId).toBeUndefined();
+  });
 });