fix(webapp): short-circuit ClickHouse lookup on mollifier-buffered runs in events endpoint

`api.v1.runs.$runId.events.ts` calls `ApiRetrieveRunPresenter.findRun`,
which now returns a buffered fallback. The route then proceeds to
`getRunEvents` against ClickHouse with `run.traceId` (empty string for
buffered runs) and `run.taskEventStore` (`"taskEvent"` default) — a
guaranteed-empty round trip, since the mollifier gate intercepts BEFORE
any trace event is written. Devin's analysis on PR #3755 flagged this
as a wasted ClickHouse round trip per request hitting the events
endpoint with a buffered runId.

Add an `isBuffered: boolean` flag to `FoundRun`. The PG branch of
`findRun` sets `isBuffered: false` on the spread Prisma row; the
buffered branch's `synthesiseFoundRunFromBuffer` sets `isBuffered:
true`. The events route short-circuits on the flag and returns
`{ events: [] }` with status 200, matching the semantically-correct
behaviour without the ClickHouse hop.

Gating on the explicit flag (rather than probing surrogates like
`traceId === ""`) keeps the contract clear for future callers that
need the same "PG-only" gate — they can introspect the same field.

Includes a unit test in `mollifierSynthesiseFoundRun.test.ts` pinning
`isBuffered: true` on the synth.

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

Author: d-cs

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

@@ -90,6 +90,15 @@ export type FoundRun = CommonRelatedRun & {
   parentTaskRun: CommonRelatedRun | null;
   rootTaskRun: CommonRelatedRun | null;
   childRuns: CommonRelatedRun[];
+  // True when this run was synthesised from the mollifier buffer rather
+  // than read from Postgres. Callers that would otherwise query backing
+  // stores keyed on PG identifiers (e.g. ClickHouse event lookups by
+  // traceId) can short-circuit to an empty response — buffered runs
+  // haven't executed and have no events to fetch. Devin's analysis on
+  // PR #3755 (events endpoint) flagged the pre-fix code as making a
+  // wasted ClickHouse round-trip when this is set; gate on this flag
+  // instead.
+  isBuffered: boolean;
 };
 
 export class ApiRetrieveRunPresenter {
@@ -132,7 +141,7 @@ export class ApiRetrieveRunPresenter {
       },
     });
 
-    if (pgRow) return pgRow;
+    if (pgRow) return { ...pgRow, isBuffered: false };
 
     // Postgres miss → fall back to the mollifier buffer. When the gate
     // diverted a trigger, the run lives in Redis until the drainer replays
@@ -668,5 +677,6 @@ export function synthesiseFoundRunFromBuffer(buffered: SyntheticRun): FoundRun {
     parentTaskRun: null,
     rootTaskRun: null,
     childRuns: [],
+    isBuffered: true,
   };
 }

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

@@ -38,6 +38,16 @@ export const loader = createLoaderApiRoute(
     },
   },
   async ({ resource: run, authentication }) => {
+    // Short-circuit for mollifier-buffered runs. The drainer hasn't
+    // materialised execution events yet (the gate intercepts before
+    // any trace event is written), so a ClickHouse round-trip is
+    // guaranteed to come back empty. `findRun` now sets `isBuffered`
+    // explicitly on its return value — gate on that rather than
+    // probing surrogate fields like `traceId === ""`.
+    if (run.isBuffered) {
+      return json({ events: [] }, { status: 200 });
+    }
+
     const eventRepository = await getEventRepositoryForStore(
       run.taskEventStore,
       authentication.environment.organization.id

apps/webapp/test/mollifierSynthesiseFoundRun.test.ts

@@ -66,6 +66,17 @@ describe("synthesiseFoundRunFromBuffer", () => {
     expect(found.friendlyId).toBe("run_friendly_1");
   });
 
+  it("marks the synth as isBuffered=true so callers like the events route can short-circuit ClickHouse lookups", () => {
+    // The PG path of `findRun` sets `isBuffered: false`; the buffered
+    // path goes through `synthesiseFoundRunFromBuffer` and must set
+    // `isBuffered: true` so consumers (e.g. the events endpoint) can
+    // skip queries that are guaranteed to return empty for buffered
+    // runs without rewriting them around surrogate signals like
+    // `traceId === ""`.
+    const found: FoundRun = synthesiseFoundRunFromBuffer(makeSyntheticRun());
+    expect(found.isBuffered).toBe(true);
+  });
+
   it("forwards scheduleId from the snapshot so resolveSchedule can hydrate the schedule field", () => {
     // Regression: scheduleId was previously hardcoded to null, dropping the
     // schedule metadata for buffered scheduled runs even though the snapshot