better validity

lib/gat/gatcaddyfile/critic.go

 package gatcaddyfile
 
 import (
+	"time"
+
 	"github.com/caddyserver/caddy/v2"
 	"github.com/caddyserver/caddy/v2/caddyconfig"
 	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
@@ -10,16 +12,30 @@ import (
 
 func init() {
 	RegisterDirective(Critic, "latency", func(d *caddyfile.Dispenser, warnings *[]caddyconfig.Warning) (caddy.Module, error) {
+		module := &latency.Critic{
+			Validity: caddy.Duration(5 * time.Minute),
+		}
+
 		if !d.NextArg() {
 			return nil, d.ArgErr()
 		}
+
 		threshold, err := caddy.ParseDuration(d.Val())
 		if err != nil {
 			return nil, d.WrapErr(err)
 		}
+		module.Threshold = caddy.Duration(threshold)
+
+		if d.NextArg() {
+			// optional validity
+			var validity time.Duration
+			validity, err = caddy.ParseDuration(d.Val())
+			if err != nil {
+				return nil, d.WrapErr(err)
+			}
+			module.Validity = caddy.Duration(validity)
+		}
 
-		return &latency.Critic{
-			Threshold: caddy.Duration(threshold),
-		}, nil
+		return module, nil
 	})
 }

lib/gat/handlers/pool/spool/kitchen/oven.go

@@ -119,42 +119,91 @@ func (T *Oven) cook(r *Recipe) (*fed.Conn, error) {
 	return r.recipe.Dial()
 }
 
-func (T *Oven) score(r *Recipe) (int, error) {
-	conn, err := r.recipe.Dial()
-	if err != nil {
-		return 0, err
-	}
-	defer func() {
-		_ = conn.Close()
-	}()
-
+func (T *Oven) score(r *Recipe) error {
 	now := time.Now()
 
 	r.ratings = slices.Resize(r.ratings, len(T.config.Critics))
 
+	fast := true
+	for i := range T.config.Critics {
+		if now.After(r.ratings[i].Expiration) {
+			fast = false
+			break
+		}
+	}
+
+	if fast {
+		// score is just old, nothing changes
+		return nil
+	}
+
+	critics := make([]pool.Critic, len(T.config.Critics))
+	ratings := make([]Rating, len(T.config.Critics))
+
 	total := 0
+
 	for i, critic := range T.config.Critics {
 		if now.Before(r.ratings[i].Expiration) {
 			total += r.ratings[i].Score
 			continue
 		}
 
-		var score int
-		var validity time.Duration
-		score, validity, err = critic.Taste(conn)
+		critics[i] = critic
+	}
+
+	err := func() error {
+		T.mu.Unlock()
+		defer T.mu.Lock()
+
+		conn, err := r.recipe.Dial()
 		if err != nil {
-			return 0, err
+			return err
 		}
+		defer func() {
+			_ = conn.Close()
+		}()
 
-		r.ratings[i] = Rating{
-			Expiration: time.Now().Add(validity),
-			Score:      score,
+		for i, critic := range critics {
+			if critic == nil {
+				continue
+			}
+
+			var score int
+			var validity time.Duration
+			score, validity, err = critic.Taste(conn)
+			if err != nil {
+				return err
+			}
+
+			ratings[i] = Rating{
+				Expiration: time.Now().Add(validity),
+				Score:      score,
+			}
+
+			total += score
 		}
 
-		total += score
+		return nil
+	}()
+	if err != nil {
+		return err
 	}
 
-	return total, nil
+	// update total score
+	r.score = total
+
+	// update ratings
+	r.ratings = slices.Resize(r.ratings, len(T.config.Critics))
+
+	for i, critic := range critics {
+		if critic == nil {
+			continue
+		}
+
+		r.ratings[i] = ratings[i]
+	}
+
+	return nil
 }
 
 // Cook will cook the best recipe
@@ -163,13 +212,11 @@ func (T *Oven) Cook() (*fed.Conn, error) {
 	defer T.mu.Unlock()
 
 	for _, r := range T.byName {
-		score, err := T.score(r)
-		if err != nil {
+		if err := T.score(r); err != nil {
 			r.score = math.MaxInt
 			T.config.Logger.Error("failed to score recipe", zap.Error(err))
 			continue
 		}
-		r.score = score
 	}
 
 	sort.Slice(T.order, func(i, j int) bool {