refactor(webapp): move the mollifier-globally-enabled check behind a DI hook

The previous commit added a perf short-circuit at the call site that
read `env.TRIGGER_MOLLIFIER_ENABLED` directly. That broke three
mollifier integration tests in CI: the tests inject a custom
`evaluateGate` via the existing DI seam expecting the buffer-write
branch to be reached, but CI has no `.env` (the `apps/webapp/.env`
symlink target is absent), the Zod default `"0"` wins, the call site
short-circuits to `null` before the injected gate runs, and
`buffer.accepted` stays empty.

Make the global-enabled check itself injectable:

  - New constructor opt `isMollifierGloballyEnabled?: () => boolean`,
    defaulting to `() => env.TRIGGER_MOLLIFIER_ENABLED === "1"`. Each
    DI hook now represents one decision (gate, buffer, global-enabled),
    so a test that wants the buffer-write branch reached can inject
    `isMollifierGloballyEnabled: () => true` alongside its custom gate.
  - Call site now reads `this.isMollifierGloballyEnabled()` instead of
    `env.TRIGGER_MOLLIFIER_ENABLED` directly. In production, with no DI
    override, the default closure resolves `env` exactly once per call
    just as before — same perf win when the flag is off.
  - All six mollifier DI injection sites in triggerTask.test.ts now also
    pass `isMollifierGloballyEnabled: () => true` so the tests' DI
    surface matches the new contract regardless of CI env state.

Author: d-cs

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

@@ -73,9 +73,12 @@ export class RunEngineTriggerTaskService {
   private readonly metadataMaximumSize: number;
   // Mollifier hooks are DI'd so tests can drive the call-site's mollify branch
   // deterministically (stub the gate to return mollify, inject a real or fake
-  // buffer). In production both default to the live module-level singletons.
+  // buffer, force the global-enabled predicate to true so the call site
+  // doesn't short-circuit on an unset env). In production all three default
+  // to the live module-level singletons + env read.
   private readonly evaluateGate: MollifierEvaluateGate;
   private readonly getMollifierBuffer: MollifierGetBuffer;
+  private readonly isMollifierGloballyEnabled: () => boolean;
 
   constructor(opts: {
     prisma: PrismaClientOrTransaction;
@@ -90,6 +93,7 @@ export class RunEngineTriggerTaskService {
     triggerRacepointSystem?: TriggerRacepointSystem;
     evaluateGate?: MollifierEvaluateGate;
     getMollifierBuffer?: MollifierGetBuffer;
+    isMollifierGloballyEnabled?: () => boolean;
   }) {
     this.prisma = opts.prisma;
     this.engine = opts.engine;
@@ -103,6 +107,8 @@ export class RunEngineTriggerTaskService {
     this.triggerRacepointSystem = opts.triggerRacepointSystem ?? new NoopTriggerRacepointSystem();
     this.evaluateGate = opts.evaluateGate ?? defaultEvaluateGate;
     this.getMollifierBuffer = opts.getMollifierBuffer ?? defaultGetMollifierBuffer;
+    this.isMollifierGloballyEnabled =
+      opts.isMollifierGloballyEnabled ?? (() => env.TRIGGER_MOLLIFIER_ENABLED === "1");
   }
 
   public async call({
@@ -342,17 +348,19 @@ export class RunEngineTriggerTaskService {
       // 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;
+      // in the system. The check goes through a DI'd predicate so unit
+      // tests that inject a custom `evaluateGate` can also override the
+      // gate-on check (the default reads `env.TRIGGER_MOLLIFIER_ENABLED`,
+      // which is "0" in CI where no .env file is present).
+      const mollifierOutcome: GateOutcome | null = this.isMollifierGloballyEnabled()
+        ? 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(

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

@@ -1246,6 +1246,7 @@ describe("RunEngineTriggerTaskService", () => {
         metadataMaximumSize: 1024 * 1024,
         evaluateGate: evaluateGateSpy,
         getMollifierBuffer: () => buffer as never,
+        isMollifierGloballyEnabled: () => true,
       });
 
       await expect(
@@ -1309,6 +1310,7 @@ describe("RunEngineTriggerTaskService", () => {
         metadataMaximumSize: 1024 * 1024,
         evaluateGate: async () => ({ action: "mollify", decision: trippedDecision }),
         getMollifierBuffer: () => buffer as never,
+        isMollifierGloballyEnabled: () => true,
       });
 
       const result = await triggerTaskService.call({
@@ -1376,6 +1378,7 @@ describe("RunEngineTriggerTaskService", () => {
         metadataMaximumSize: 1024 * 1024,
         evaluateGate: async () => ({ action: "pass_through" }),
         getMollifierBuffer: getBufferSpy,
+        isMollifierGloballyEnabled: () => true,
       });
 
       const result = await triggerTaskService.call({
@@ -1475,6 +1478,7 @@ describe("RunEngineTriggerTaskService", () => {
           },
         }),
         getMollifierBuffer: () => buffer as never,
+        isMollifierGloballyEnabled: () => true,
       });
 
       await expect(
@@ -1581,6 +1585,7 @@ describe("RunEngineTriggerTaskService", () => {
         metadataMaximumSize: 1024 * 1024,
         evaluateGate: evaluateGateSpy,
         getMollifierBuffer: () => buffer as never,
+        isMollifierGloballyEnabled: () => true,
       });
 
       const cached = await mollifierService.call({
@@ -1709,6 +1714,7 @@ describe("RunEngineTriggerTaskService", () => {
           },
         }),
         getMollifierBuffer: () => buffer as never,
+        isMollifierGloballyEnabled: () => true,
       });
 
       const debounced = await mollifierService.call({