perf(webapp): short-circuit mollifier gate when globally disabled

evaluateGate ran on every trigger regardless of TRIGGER_MOLLIFIER_ENABLED.
With the flag off (the default everywhere it hasn't been opted in), the
gate still produced a `pass_through` decision after allocating a
GateInputs object, spreading defaultGateDependencies inside evaluateGate,
and incrementing the `mollifier.decisions{outcome=pass_through}` OTel
counter. Cheap individually, but triggerTask is the hottest code path in
the system — multiply by trigger rate and the unnecessary work compounds.

Guard the gate call with a direct env.TRIGGER_MOLLIFIER_ENABLED check at
the call site. When the flag is off, mollifierOutcome is null and the
downstream `mollifierOutcome?.action === "mollify"` branch skips the
buffer dual-write entirely — zero allocation, zero counter increment on
the disabled path. When the flag is on, behaviour is unchanged.

Lost-signal note: with mollifier off, we no longer count "pass_through"
decisions in the OTel counter (the gate never runs). That's a non-issue
— "pass_through count when feature is off" is just total trigger rate,
which is already observable via the trigger handler's own spans/counters
upstream. The gate counter remains the source of truth for the
mollify/shadow/pass_through ratio when the feature is on, which is the
load-bearing signal.

Author: d-cs

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

@@ -40,8 +40,10 @@ import type {
   TriggerTaskRequest,
   TriggerTaskValidator,
 } from "../types";
+import { env } from "~/env.server";
 import {
   evaluateGate as defaultEvaluateGate,
+  type GateOutcome,
   type MollifierEvaluateGate,
 } from "~/v3/mollifier/mollifierGate.server";
 import {
@@ -335,13 +337,22 @@ export class RunEngineTriggerTaskService {
         taskKind: taskKind ?? "STANDARD",
       };
 
-      const mollifierOutcome = await this.evaluateGate({
-        envId: environment.id,
-        orgId: environment.organizationId,
-        taskId,
-        orgFeatureFlags:
-          (environment.organization.featureFlags as Record<string, unknown> | null) ?? null,
-      });
+      // Short-circuit before the gate when mollifier is globally off (the
+      // default for every deployment that hasn't opted in). Avoids the
+      // GateInputs allocation, the deps spread inside `evaluateGate`, and
+      // the `mollifier.decisions{outcome=pass_through}` OTel increment on
+      // every trigger — `triggerTask` is the highest-throughput code path
+      // in the system. When the flag is on, behaviour is unchanged.
+      const mollifierOutcome: GateOutcome | null =
+        env.TRIGGER_MOLLIFIER_ENABLED === "1"
+          ? await this.evaluateGate({
+              envId: environment.id,
+              orgId: environment.organizationId,
+              taskId,
+              orgFeatureFlags:
+                (environment.organization.featureFlags as Record<string, unknown> | null) ?? null,
+            })
+          : null;
 
       try {
         return await this.traceEventConcern.traceRun(
@@ -363,7 +374,7 @@ export class RunEngineTriggerTaskService {
             // dequeue mechanism works. Phase 2 will replace engine.trigger
             // (below) with a synthesised 200 response and rely on the
             // drainer to perform the Postgres write via replay.
-            if (mollifierOutcome.action === "mollify") {
+            if (mollifierOutcome?.action === "mollify") {
               const buffer = this.getMollifierBuffer();
               if (buffer) {
                 const canonicalPayload = buildBufferedTriggerPayload({