Function decide

apps/cloud/src/engine/execution-rate-limit.ts:314–403

(organizationId: string)

    });

  const decide = (organizationId: string): Effect.Effect<GateDecision> =>
    Effect.suspend(() => {
      const windowId = Math.floor(now() / windowMs);
      return increment(organizationId, windowId).pipe(
        Effect.timeoutOrElse({
          duration: `${timeoutMs} millis`,
          orElse: () => Effect.fail(new RateLimitCheckTimeoutError({ timeoutMs })),
        }),
        Effect.flatMap((count): Effect.Effect<GateDecision> => {
          // Under the cap: no exemption lookup, no extra I/O.
          if (count <= limit)
            return Effect.as(
              Effect.annotateCurrentSpan({
                "rate_limit.count": count,
                "rate_limit.blocked": false,
                "rate_limit.check.failed_open": false,
              }),
              { blocked: false },
            );
          return Effect.gen(function* () {
            yield* Effect.annotateCurrentSpan({
              "rate_limit.count": count,
              "rate_limit.check.failed_open": false,
            });
            if (yield* resolveExemption(organizationId)) {
              yield* Effect.annotateCurrentSpan({
                "rate_limit.blocked": false,
                "rate_limit.exempt": true,
              });
              return { blocked: false } as const satisfies GateDecision;
            }
            // The only record that the backstop fired. A blocked execution is
            // never usage-tracked (the gate short-circuits before the tracker)
            // and deliberately not sent to Sentry — a backstop stopping
            // runaway automation is expected, not exceptional — so without
            // this line a blocked org is invisible outside a bug report, which
            // is how the 2026-08-18 block went unnoticed until a customer
            // sent a screenshot.
            yield* Effect.sync(() => {
              console.warn(
                `[rate-limit] blocked execution for ${organizationId}: ${count} > ${limit} in window ${windowId}`,
              );
            });
            yield* Effect.annotateCurrentSpan({
              "rate_limit.blocked": true,
              "rate_limit.exempt": false,
            });
            return {
              blocked: true,
              error: new ExecutionRateLimitExceededError({
                organizationId,
                message: RATE_LIMIT_BLOCKED_MESSAGE,
              }),
            } as const satisfies GateDecision;
          });
        }),
        // FAIL OPEN: the backstop must never block executions because its
        // counter is unreachable or slow.