@@ -778,6 +778,15 @@ export class WaitpointSystem {
     runId: string,
     blockingWaitpoints: RunBlockEdge[]
   ): Promise<CompletedWaitpointRecord[] | undefined> {
+    // `.some` before the dedup, so the gate allocates nothing in the case that is universal
+    // today and stays common through a partial rollout: no blocking waitpoint is store-format.
+    // Building the mapped array, the filtered array and the Set first meant three allocations
+    // per resume -- for a 1000-wide batch fan-in too -- to discover there was nothing to ask for.
+    if (!blockingWaitpoints.some((b) => parseWaitpointId(b.waitpoint.id).format === "b32hexW")) {
+      return undefined;
+    }
+
+    // Only a set that really holds one pays for the dedup.
     const storeFormatIds = [
       ...new Set(
         blockingWaitpoints
@@ -786,10 +795,6 @@ export class WaitpointSystem {
       ),
     ];
 
-    if (storeFormatIds.length === 0) {
-      return undefined;
-    }
-
     const sources = await this.coordinator.readCompletionEnvelopes({
       runId,
       waitpointIds: storeFormatIds,
 
@@ -5,7 +5,7 @@ import { postgresTest } from "@internal/testcontainers";
 import { PostgresRunStore } from "@internal/run-store";
 import type { PrismaClient, Waitpoint } from "@trigger.dev/database";
 import { describe, expect } from "vitest";
-import { seedChildRunWithOutput } from "./testFixtures/childRun.js";
+import { seedChildRunsWithOutputs, seedChildRunWithOutput } from "./testFixtures/childRun.js";
 import { enhanceExecutionSnapshotWithWaitpoints } from "../systems/executionSnapshotSystem.js";
 import { buildCompletedWaitpointRecords } from "./completedWaitpointRecords.js";
 import {
@@ -192,6 +192,46 @@ describe("the resolver reproduces the existing hydration", () => {
     expect(actual).toEqual(expected);
   });
 
+  // Two deferring records in ONE cycle, which is the shape a batch fan-in produces and the one
+  // the batched read introduced. Every other case here defers at most once, so a mis-keyed map
+  // or a swapped output would compare equal against the oracle in all of them.
+  //
+  // The outputs differ deliberately, and one run sits at two interleaved positions, so a swap
+  // between the two runs and a lost second position both show up as a diff.
+  postgresTest("for two RUN waitpoints deferring to different runs", async ({ prisma }) => {
+    const [runA, runB] = await seedChildRunsWithOutputs(prisma, ['{"child":"a"}', '{"child":"b"}']);
+
+    const { expected, actual } = await bothPaths(
+      prisma,
+      [
+        pair({
+          id: "wp_run_a",
+          type: "RUN",
+          output: '{"child":"a"}',
+          completedByTaskRunId: runA,
+        }),
+        pair({
+          id: "wp_run_b",
+          type: "RUN",
+          output: '{"child":"b"}',
+          completedByTaskRunId: runB,
+        }),
+      ],
+      ["wp_run_a", "wp_run_b", "wp_run_a"],
+      BATCH_ID
+    );
+
+    expect(actual).toEqual(expected);
+    // Stated as well as compared: the oracle agreeing is the assertion, but a reader should not
+    // have to run it to see that three entries come back and each output landed on its own id.
+    expect(actual).toHaveLength(3);
+    expect(actual.filter((w) => w.id === "wp_run_a").map((w) => w.output)).toEqual([
+      '{"child":"a"}',
+      '{"child":"a"}',
+    ]);
+    expect(actual.find((w) => w.id === "wp_run_b")?.output).toBe('{"child":"b"}');
+  });
+
   postgresTest("for a RUN waitpoint read under a batch", async ({ prisma }) => {
     const childRunId = await seedChildRunWithOutput(prisma, '{"ok":true}');
     const { expected, actual } = await bothPaths(
 
@@ -175,6 +175,46 @@ describe("the deriveFromRun branch", () => {
     }
   });
 
+  // An empty string is a VALUE, not an absence. The reader's `row.output !== null` is what keeps
+  // it: narrowed to a truthy test it would report the run as output-less and throw
+  // lost-run-output on a run that completed perfectly well. Nothing else pins that, and
+  // `chooseOutput` already treats empty as a value on the write side.
+  postgresTest("keeps an empty-string output rather than refusing", async ({ prisma }) => {
+    const runId = await seedChildRunWithOutput(prisma, "");
+
+    const [entry] = await resolverFor(prisma)({
+      runId: "run_parent",
+      pointer: { cycleSeq: 1, count: 0 },
+      order: [],
+      distinctIds: ["wp_run"],
+      records: [deriveRecord(runId)],
+    });
+
+    expect(entry?.output).toBe("");
+  });
+
+  // Two waitpoints completed by the SAME run. One id in one batch, and both entries carry it:
+  // the dedup must not cost the second waitpoint its output.
+  postgresTest("reads a shared run once and hydrates both waitpoints", async ({ prisma }) => {
+    const runId = await seedChildRunWithOutput(prisma, '{"shared":true}');
+    const { resolve, batches } = countingResolver(prisma);
+
+    const result = await resolve({
+      runId: "run_parent",
+      pointer: { cycleSeq: 1, count: 2 },
+      order: ["wp_first", "wp_second"],
+      distinctIds: ["wp_first", "wp_second"],
+      records: [
+        { ...deriveRecord(runId), id: "wp_first", friendlyId: "waitpoint_wp_first" },
+        { ...deriveRecord(runId), id: "wp_second", friendlyId: "waitpoint_wp_second" },
+      ],
+    });
+
+    expect(batches).toEqual([[runId]]);
+    expect(result).toHaveLength(2);
+    expect(result.map((w) => w.output)).toEqual(['{"shared":true}', '{"shared":true}']);
+  });
+
   // A cycle that defers nothing reads nothing, so an all-inline resume pays no Postgres round
   // trip at all.
   postgresTest("reads nothing when no record defers", async ({ prisma }) => {
 
@@ -1,6 +1,5 @@
 import type {
   CompletedWaitpointRecord,
-  ReadClient,
   ResolveCompletedWaitpointsArgs,
   RunStore,
 } from "@internal/run-store";
@@ -64,17 +63,23 @@ const RUN_OUTPUT_CHUNK_SIZE = 100;
  * `findRunsByIds` is the store's own grouped replacement for `Promise.all(ids.map(findRun))`,
  * and it forces `id` into the projection so the map keys correctly even though this select
  * names only `output`.
+ *
+ * Takes no read client on purpose. The router reads the owning store's REPLICA when no client is
+ * passed, and forces its PRIMARY for any client that is not replica-branded -- so accepting one
+ * would let a caller put a wide `TaskRun.output` read on the writer by reflex. This read does not
+ * need read-your-writes: the child run committed its output before it completed the waitpoint that
+ * unblocked this parent, so replica lag cannot hide it. That is the opposite of the envelope read
+ * in the legacy arm, which reads a waitpoint completed moments earlier and must use the writer.
  */
 export function createRunOutputsReader(
-  runStore: Pick<RunStore, "findRunsByIds">,
-  client?: ReadClient
+  runStore: Pick<RunStore, "findRunsByIds">
 ): (taskRunIds: string[]) => Promise<Map<string, string>> {
   return async (taskRunIds) => {
     const outputs = new Map<string, string>();
 
     for (let i = 0; i < taskRunIds.length; i += RUN_OUTPUT_CHUNK_SIZE) {
       const chunk = taskRunIds.slice(i, i + RUN_OUTPUT_CHUNK_SIZE);
-      const rows = await runStore.findRunsByIds(chunk, { select: { output: true } }, client);
+      const rows = await runStore.findRunsByIds(chunk, { select: { output: true } });
 
       for (const [id, row] of rows) {
         // A row present with a null output is the same absence as a missing row: either way the
@@ -218,27 +223,34 @@ async function readDeferredOutputs(
   deps: CompletedWaitpointResolverDeps
 ): Promise<Map<string, string>> {
   const runIds = new Set<string>();
-  let deferring: CompletedWaitpointRecord | undefined;
+  let read: NonNullable<CompletedWaitpointResolverDeps["readRunOutputs"]> | undefined;
 
   for (const record of records) {
     const runId = deferredRunIdOf(record);
-    if (runId !== undefined) {
-      runIds.add(runId);
-      deferring ??= record;
+    if (runId === undefined) {
+      continue;
     }
-  }
 
-  if (runIds.size === 0) {
-    return new Map();
+    // Checked here rather than after the pass, so the message names a record that really does
+    // defer rather than whichever one happened to be first. A missing reader is a wiring fault,
+    // so every deferring record is equally implicated and the first is as informative as any.
+    if (!deps.readRunOutputs) {
+      throw new Error(
+        `Waitpoint ${record.id} defers its output to run ${runId}, but the resolver was built with no run-output reader.`
+      );
+    }
+
+    read = deps.readRunOutputs;
+    runIds.add(runId);
   }
 
-  if (!deps.readRunOutputs) {
-    throw new Error(
-      `Waitpoint ${deferring?.id} defers its output to run ${deferring?.completedByTaskRunId}, but the resolver was built with no run-output reader.`
-    );
+  // Set exactly when a record deferred, so this is the same condition as an empty `runIds` --
+  // and unlike `runIds.size`, it carries the reader with it.
+  if (read === undefined) {
+    return new Map();
   }
 
-  return deps.readRunOutputs([...runIds]);
+  return read([...runIds]);
 }
 
 // The run a record defers its output to, or undefined when it carries its own output or has