Revert "perf(mollifier): fire-and-forget buffer.accept on the hot path"

This reverts commit 4135aca.

Author: d-cs

apps/webapp/app/runEngine/services/triggerTask.server.ts

@@ -398,39 +398,36 @@ export class RunEngineTriggerTaskService {
                   createdAt: new Date(),
                 });
 
-                // Fire-and-forget. The buffer entry is audit-only in
-                // Phase 1 — engine.trigger below is the primary write path,
-                // so the customer must never wait on Redis here. A slow or
-                // unreachable buffer adds zero latency to the hot path;
-                // worst case the audit record is lost and we see a gap
-                // between `mollifier.would_mollify` (gate decision) and
-                // `mollifier.drained` (drainer). Errors land on the same
-                // log line as before so operators can still alert on them.
-                const serialisedPayload = serialiseSnapshot(canonicalPayload);
-                void buffer
-                  .accept({
+                try {
+                  const serialisedPayload = serialiseSnapshot(canonicalPayload);
+                  await buffer.accept({
                     runId: runFriendlyId,
                     envId: environment.id,
                     orgId: environment.organizationId,
                     payload: serialisedPayload,
-                  })
-                  .then(() => {
-                    logger.info("mollifier.buffered", {
-                      runId: runFriendlyId,
-                      envId: environment.id,
-                      orgId: environment.organizationId,
-                      taskId,
-                      payloadBytes: serialisedPayload.length,
-                    });
-                  })
-                  .catch((err) => {
-                    logger.error("mollifier.buffer_accept_failed", {
-                      runId: runFriendlyId,
-                      envId: environment.id,
-                      taskId,
-                      err: err instanceof Error ? err.message : String(err),
-                    });
                   });
+                  // Light log on the hot path — keep this synchronous work
+                  // O(1) per trigger. The drainer computes the payload hash
+                  // off-path; operators correlate `mollifier.buffered` →
+                  // `mollifier.drained` by runId.
+                  logger.info("mollifier.buffered", {
+                    runId: runFriendlyId,
+                    envId: environment.id,
+                    orgId: environment.organizationId,
+                    taskId,
+                    payloadBytes: serialisedPayload.length,
+                  });
+                } catch (err) {
+                  // Fail-open: buffer write must never block the customer's
+                  // trigger. engine.trigger below is the primary write path
+                  // in Phase 1 — the customer still gets a valid run.
+                  logger.error("mollifier.buffer_accept_failed", {
+                    runId: runFriendlyId,
+                    envId: environment.id,
+                    taskId,
+                    err: err instanceof Error ? err.message : String(err),
+                  });
+                }
               }
             }
 

apps/webapp/test/engine/triggerTask.test.ts

@@ -1442,11 +1442,11 @@ describe("RunEngineTriggerTaskService", () => {
       //   Phase 2's responsibility once the buffer becomes the primary write
       //   — at that point we add the mollifier-specific idempotency index.
       //
-      // This test pins the invariant: buffer.accept is scheduled (fire-and-
-      // forget) BEFORE engine.trigger runs, and engine.trigger failure does
-      // NOT roll back the buffer write. Any future change that reverses the
-      // order or adds a silent rollback will fail this assertion and force a
-      // design decision rather than a silent behaviour change.
+      // This test pins the current ordering: buffer.accept fires synchronously
+      // BEFORE engine.trigger, and engine.trigger failure does NOT roll back
+      // the buffer write. Any future change that reverses the order or adds
+      // a silent rollback will fail this assertion and force a design
+      // decision rather than a silent behaviour change.
 
       const engine = new RunEngine({
         prisma,