nudge: add digest/batching mode for care nudges

When enabled, eligible nudges (sev ≤ ceiling) are queued in memory
instead of sent immediately. Every 'window' duration (or when
'max_items' reached), the queue is flushed as a single digest
notification with concatenated bodies.

Config:
  digest:
    enabled: true           # default false
    window: 30m             # flush window (default 30m)
    max_items: 5            # flush at this count (default 5)
    severity_ceiling: 2     # max sev batched (default 2; sev3+ bypass)

Changes:
- config.go: add DigestConfig struct with defaults
- tick.go: QueuedNudge type, digest queue/flush in TickLoop,
  shouldQueue/maybeFlush/flushDigest helpers
- main.go: pass cfg.Digest to newTickLoop
- tick_test.go: 6 new tests covering queue, flush, bypass, dedup

cmd/mavend/tick.go

@@ -14,15 +14,26 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"strings"
 	"sync"
 	"time"
 
+	"github.com/kami/maven/internal/config"
 	"github.com/kami/maven/internal/delivery"
 	"github.com/kami/maven/internal/loop"
 	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/store"
 )
 
+// QueuedNudge — a nudge held in the digest queue pending batch flush.
+type QueuedNudge struct {
+	Rule     string
+	Severity int
+	Body     string
+	Key      string
+	QueuedAt time.Time
+}
+
 // tickLoop — the impure driver. holds everything wired at daemon construction
 // that the per-tick path needs. the rules slice is read-only here; the gatherer
 // already captured it, but we keep it for a possible future re-seed path.
@@ -37,6 +48,14 @@ type tickLoop struct {
 	repeatInterval time.Duration
 	autotuneInterval time.Duration // 0 ⇒ autotune disabled (gatherer falls back to static Base)
 
+	// digestCfg — the digest/batching config. nil ⇒ every nudge is sent
+	// immediately (legacy behaviour).
+	digestCfg *config.DigestConfig
+
+	// digestQ — in-memory queue of eligible nudges waiting for batch flush.
+	// populated when digestCfg != nil && digestCfg.Enabled.
+	digestQ []QueuedNudge
+
 	// lastPhrase caches the phraser output per rule so the sev4 repeat path
 	// can re-send roughly what the user was first alerted with (an alarm
 	// that re-phrases differently every 5m is hostile; the same terse body
@@ -54,6 +73,7 @@ func newTickLoop(
 	p phraser.Phraser,
 	rules []loop.Rule,
 	tickInterval, repeatInterval, autotuneInterval time.Duration,
+	digestCfg *config.DigestConfig,
 ) *tickLoop {
 	return &tickLoop{
 		store:            st,
@@ -64,6 +84,8 @@ func newTickLoop(
 		tickInterval:     tickInterval,
 		repeatInterval:   repeatInterval,
 		autotuneInterval: autotuneInterval,
+		digestCfg:        digestCfg,
+		digestQ:          nil,
 		lastPhrase:       make(map[string]delivery.PhrasedNudge),
 	}
 }
@@ -112,17 +134,26 @@ func (t *tickLoop) tick(ctx context.Context, now time.Time) {
 
 	// proactive: at most one candidate, max severity.
 	if cand := loop.Tick(state, t.rules); cand != nil {
-		pn, err := t.phraser.PhraseNudge(ctx, *cand)
-		if err != nil {
-			log.Printf("tick: phrase nudge %s: %v", cand.Rule.Name, err)
+		if t.shouldQueue(cand) {
+			t.queueNudge(ctx, cand, state, now)
 		} else {
-			t.cachePhrase(pn)
-			if _, err := t.dispatcher.DispatchNudge(ctx, pn, now); err != nil {
-				log.Printf("tick: dispatch nudge %s: %v", cand.Rule.Name, err)
+			pn, err := t.phraser.PhraseNudge(ctx, *cand)
+			if err != nil {
+				log.Printf("tick: phrase nudge %s: %v", cand.Rule.Name, err)
+			} else {
+				t.cachePhrase(pn)
+				if _, err := t.dispatcher.DispatchNudge(ctx, pn, now); err != nil {
+					log.Printf("tick: dispatch nudge %s: %v", cand.Rule.Name, err)
+				}
 			}
 		}
 	}
 
+	// digest flush: after candidate processing, flush if the window has
+	// elapsed or MaxItems was reached. Processing the candidate first
+	// (with dedup) avoids re-queueing the same rule after a flush.
+	t.maybeFlush(ctx, now, state)
+
 	// reminders: gate-bypassing class. fired once, marked after a successful
 	// delivery.  a failed send leaves the reminder pending — the next tick
 	// re-gathers and re-attempts.
@@ -182,6 +213,92 @@ func (t *tickLoop) repeatPhrase(rule string) (body, summary string) {
 	return pn.Body, pn.Summary
 }
 
+// shouldQueue — true when digest is enabled and the candidate's severity is
+// at or below the configured ceiling.
+func (t *tickLoop) shouldQueue(cand *loop.Candidate) bool {
+	return t.digestCfg != nil && t.digestCfg.Enabled &&
+		cand.Severity <= loop.Severity(t.digestCfg.SeverityCeiling)
+}
+
+// queueNudge — phrases the candidate and appends it to the digest queue.
+// Deduplicates by rule name: if the same rule is already queued, this is a
+// no-op (the first fire within the window is the one that counts).
+func (t *tickLoop) queueNudge(ctx context.Context, cand *loop.Candidate, _ loop.State, now time.Time) {
+	for _, q := range t.digestQ {
+		if q.Rule == cand.Rule.Name {
+			return // already queued
+		}
+	}
+	pn, err := t.phraser.PhraseNudge(ctx, *cand)
+	if err != nil {
+		log.Printf("tick: phrase nudge %s: %v", cand.Rule.Name, err)
+		return
+	}
+	t.digestQ = append(t.digestQ, QueuedNudge{
+		Rule:     cand.Rule.Name,
+		Severity: int(cand.Severity),
+		Body:     pn.Body,
+		Key:      cand.Rule.Name,
+		QueuedAt: now,
+	})
+	t.cachePhrase(pn)
+}
+
+// maybeFlush — flushes the digest queue if the window has elapsed since the
+// first item or the queue reached MaxItems.
+func (t *tickLoop) maybeFlush(ctx context.Context, now time.Time, state loop.State) {
+	if t.digestCfg == nil || !t.digestCfg.Enabled || len(t.digestQ) == 0 {
+		return
+	}
+	first := t.digestQ[0]
+	if now.Sub(first.QueuedAt) >= time.Duration(t.digestCfg.Window) ||
+		len(t.digestQ) >= t.digestCfg.MaxItems {
+		t.flushDigest(ctx, now, state)
+	}
+}
+
+// flushDigest — concatenates queued nudge bodies into a single digest
+// notification and dispatches it. Clears the queue after a successful send.
+// The digest uses the max severity among queued items for routing.
+func (t *tickLoop) flushDigest(ctx context.Context, now time.Time, state loop.State) {
+	if len(t.digestQ) == 0 {
+		return
+	}
+
+	var b strings.Builder
+	maxSev := 0
+	for i, q := range t.digestQ {
+		if i > 0 {
+			b.WriteString(" · ")
+		}
+		b.WriteString(q.Body)
+		if q.Severity > maxSev {
+			maxSev = q.Severity
+		}
+	}
+	body := b.String()
+	summary := fmt.Sprintf("%d pending notifications", len(t.digestQ))
+
+	cand := loop.Candidate{
+		Rule: loop.Rule{
+			Name:     "digest",
+			Severity: loop.Severity(maxSev),
+		},
+		Severity: loop.Severity(maxSev),
+		State:    state,
+	}
+	pn := delivery.PhrasedNudge{
+		Candidate: cand,
+		Body:      body,
+		Summary:   summary,
+	}
+	t.cachePhrase(pn)
+	if _, err := t.dispatcher.DispatchNudge(ctx, pn, now); err != nil {
+		log.Printf("tick: dispatch digest: %v", err)
+	}
+	t.digestQ = nil
+}
+
 // tune — the feedback auto-tuner's impure step. runs on a slow cadence
 // (autotuneInterval, see run) so it doesn't write a fact every tick. for each
 // rule: