Announce tick-inferred routines, opt-in and rate-limited (#247, #43)

The digestion tick already runs the pattern detector over all recorded
events (67563ed) and writes a proposed_routines row. What was missing is
the other half of #247: a proposal that nobody is at the mic for reaches
nothing but the /routines page, so a pattern noticed at 03:00 is only
seen if he goes looking.

This wires the tick's proposals into the existing care-delivery path
rather than a second channel: sev1 nudge, loop.Gate, dispatcher, same
routing table as an accepted routine. Restraints, since a feature that
speaks unprompted is the easiest way to turn Maven into a nag:

  - off unless configured — the new pattern_proposals block, absent by
    default, and deploy/mavend.json ships notify: false;
  - at most one announcement per tick however many patterns surfaced;
  - at most one per cooldown (24h default) across all pairs;
  - sev1, so quiet hours, away and snooze suppress it;
  - suppressed means dropped, not queued — /routines still has it;
  - once per pair for good, since proposed_routines is
    UNIQUE(action, object) and the row survives dismissal.

The body is pattern.PhraseRoutine's literal Russian, not LLM-worded, so
an inferred routine cannot arrive describing something never observed.

Also raises pattern.MinEvents from 3 to 4 — the interval-quality item on
#43. Two intervals with a ±50% band is a coincidence with a mean, not a
pattern, and now that a scan of all history can announce itself the cost
of a false positive is a permanent dismissal of that pair.

internal/pattern/detector.go

@@ -20,9 +20,19 @@ type ProposedRoutine struct {
 const MaxIntervalRatio = 1.5
 
 // MinEvents is the minimum number of events needed to detect a pattern.
-// With N events, there are N-1 intervals; we need at least 2 intervals
-// before proposing anything.
-const MinEvents = 3
+// With N events there are N-1 intervals, so 4 events means 3 intervals.
+//
+// This used to be 3 (two intervals), which is not a pattern — it is a
+// coincidence with a mean. Two gaps of similar length happen constantly:
+// water the plants on a Sunday, again the next Sunday, once more the Sunday
+// after, and a detector with a ±50% band calls that a weekly routine. The
+// cost of being wrong is asymmetric now that the digestion tick scans all of
+// history on its own schedule and can announce what it finds: a false
+// positive is something the owner has to read and dismiss, and a dismissal
+// is permanent, so one bad guess burns that action+object pair forever.
+// Three intervals is the cheapest bar that makes a run distinguishable from
+// a repeat. False negatives cost one more observation and nothing else.
+const MinEvents = 4
 
 // Detect checks whether a sequence of events for the same action+object
 // forms a stable recurring pattern. Returns a ProposedRoutine when:

internal/pattern/detector_test.go

@@ -6,12 +6,13 @@ import (
 )
 
 func TestDetectEnoughEvents(t *testing.T) {
-	// 3 events with 7-day intervals → stable pattern
+	// MinEvents events with 7-day intervals → stable pattern
 	base := time.Date(2026, 7, 1, 12, 0, 0, 0, time.UTC)
 	events := []Event{
 		{Action: "refill", Object: "cat_water", Ts: base},
 		{Action: "refill", Object: "cat_water", Ts: base.Add(7 * 24 * time.Hour)},
 		{Action: "refill", Object: "cat_water", Ts: base.Add(14 * 24 * time.Hour)},
+		{Action: "refill", Object: "cat_water", Ts: base.Add(21 * 24 * time.Hour)},
 	}
 
 	r, err := Detect(events)
@@ -24,8 +25,8 @@ func TestDetectEnoughEvents(t *testing.T) {
 	if r.Action != "refill" || r.Object != "cat_water" {
 		t.Fatalf("action/object: want refill/cat_water, got %s/%s", r.Action, r.Object)
 	}
-	if r.N != 3 {
-		t.Fatalf("want N=3, got %d", r.N)
+	if r.N != 4 {
+		t.Fatalf("want N=4, got %d", r.N)
 	}
 	// ~7 days
 	if r.IntervalDays < 6.9 || r.IntervalDays > 7.1 {
@@ -33,19 +34,28 @@ func TestDetectEnoughEvents(t *testing.T) {
 	}
 }
 
+// TestDetectNotEnoughEvents — two intervals are a coincidence, not a routine
+// (Vikunja #43). Three same-day-of-week events used to be enough to propose a
+// weekly reminder; MinEvents is 4 now so a repeat has to happen a third time
+// before Maven calls it a pattern.
 func TestDetectNotEnoughEvents(t *testing.T) {
 	base := time.Date(2026, 7, 1, 12, 0, 0, 0, time.UTC)
-	events := []Event{
-		{Action: "refill", Object: "cat_water", Ts: base},
-		{Action: "refill", Object: "cat_water", Ts: base.Add(7 * 24 * time.Hour)},
-	}
-
-	r, err := Detect(events)
-	if err != nil {
-		t.Fatalf("Detect: %v", err)
-	}
-	if r != nil {
-		t.Fatal("want nil for <3 events")
+	for _, n := range []int{1, 2, MinEvents - 1} {
+		events := make([]Event, n)
+		for i := range events {
+			events[i] = Event{
+				Action: "refill",
+				Object: "cat_water",
+				Ts:     base.Add(time.Duration(i) * 7 * 24 * time.Hour),
+			}
+		}
+		r, err := Detect(events)
+		if err != nil {
+			t.Fatalf("Detect(%d events): %v", n, err)
+		}
+		if r != nil {
+			t.Fatalf("Detect(%d events) proposed %+v, want nil below MinEvents=%d", n, r, MinEvents)
+		}
 	}
 }
 
@@ -68,12 +78,13 @@ func TestDetectEmpty(t *testing.T) {
 }
 
 func TestDetectIrregularRejects(t *testing.T) {
-	// 3 events but wildly irregular: 1 day, then 14 days → ratio 14 > 1.5
+	// wildly irregular: 1 day, then 14 days → ratio 14 > 1.5
 	base := time.Date(2026, 7, 1, 12, 0, 0, 0, time.UTC)
 	events := []Event{
 		{Action: "refill", Object: "cat_water", Ts: base},
 		{Action: "refill", Object: "cat_water", Ts: base.Add(1 * 24 * time.Hour)},
 		{Action: "refill", Object: "cat_water", Ts: base.Add(15 * 24 * time.Hour)},
+		{Action: "refill", Object: "cat_water", Ts: base.Add(16 * 24 * time.Hour)},
 	}
 
 	r, err := Detect(events)
@@ -117,6 +128,7 @@ func TestDetectSameTimestamp(t *testing.T) {
 		{Action: "refill", Object: "cat_water", Ts: base},
 		{Action: "refill", Object: "cat_water", Ts: base},
 		{Action: "refill", Object: "cat_water", Ts: base.Add(7 * 24 * time.Hour)},
+		{Action: "refill", Object: "cat_water", Ts: base.Add(14 * 24 * time.Hour)},
 	}
 
 	r, err := Detect(events)