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

In Phase 1 the buffer entry is audit-only — engine.trigger below is the
primary write path. Awaiting buffer.accept added Redis round-trip latency
to every mollified trigger, which is the wrong tradeoff for an audit
write. Switch to a fire-and-forget then/catch so a slow or unreachable
Redis adds zero latency to the customer-facing path; the buffered/error
log lines move to the microtask queue but still fire on the same lines
operators alert on today.

Updates the orphan-entry test docstring to reflect the scheduled (rather
than synchronous) ordering — the invariant the test pins is unchanged.

Author: d-cs

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

@@ -398,36 +398,39 @@ export class RunEngineTriggerTaskService {
                   createdAt: new Date(),
                 });
 
-                try {
-                  const serialisedPayload = serialiseSnapshot(canonicalPayload);
-                  await buffer.accept({
+                // 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({
                     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 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.
+      // 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.
 
       const engine = new RunEngine({
         prisma,