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.
2026-08-01 01:37:50 +04:00
parent c5317eb2b4
commit 766ca091a7
8 changed files with 350 additions and 39 deletions
@@ -3,9 +3,14 @@ package main
 import (
 	"context"
 	"database/sql"
+	"strings"
 	"testing"
 	"time"

+	"github.com/kami/maven/internal/config"
+	"github.com/kami/maven/internal/delivery"
+	"github.com/kami/maven/internal/loop"
+	"github.com/kami/maven/internal/pattern"
 	"github.com/kami/maven/internal/store"
 )

@@ -27,16 +32,16 @@ func seedRefillEvents(t *testing.T, st *store.Store, ctx context.Context, base t

 // TestTickDetectsPatternFromStoredEvents proves the tick notices a pattern on
 // its own, reading straight from the store — not as a side effect of a live
-// utterance (Vikunja #43). Three weekly events with no voice turn in sight
-// must produce exactly one proposed routine.
+// utterance (Vikunja #43). MinEvents weekly events with no voice turn in
+// sight must produce exactly one proposed routine.
 func TestTickDetectsPatternFromStoredEvents(t *testing.T) {
 	st := newTestStore(t)
 	ctx := context.Background()
 	now := refNow()
-	seedRefillEvents(t, st, ctx, now, 3)
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)

 	tl := newTestTickLoop(t, st, &fakeSink{}, nil)
-	tl.detectPatterns(ctx, now)
+	tl.detectPatterns(ctx, now, loop.State{})

 	rows, err := st.ListProposedRoutines(ctx)
 	if err != nil {
@@ -58,11 +63,11 @@ func TestTickPatternDetectionIsIdempotent(t *testing.T) {
 	st := newTestStore(t)
 	ctx := context.Background()
 	now := refNow()
-	seedRefillEvents(t, st, ctx, now, 3)
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)

 	tl := newTestTickLoop(t, st, &fakeSink{}, nil)
-	tl.detectPatterns(ctx, now)
-	tl.detectPatterns(ctx, now.Add(time.Hour))
+	tl.detectPatterns(ctx, now, loop.State{})
+	tl.detectPatterns(ctx, now.Add(time.Hour), loop.State{})

 	rows, err := st.ListProposedRoutines(ctx)
 	if err != nil {
@@ -81,10 +86,10 @@ func TestTickPatternDetectionRespectsDismissal(t *testing.T) {
 	st := newTestStore(t)
 	ctx := context.Background()
 	now := refNow()
-	seedRefillEvents(t, st, ctx, now, 3)
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)

 	tl := newTestTickLoop(t, st, &fakeSink{}, nil)
-	tl.detectPatterns(ctx, now)
+	tl.detectPatterns(ctx, now, loop.State{})

 	rows, err := st.ListProposedRoutines(ctx)
 	if err != nil {
@@ -99,8 +104,8 @@ func TestTickPatternDetectionRespectsDismissal(t *testing.T) {

 	// More events for the same pair arrive, and the tick runs again — a
 	// dismissed pattern must not resurface.
-	seedRefillEvents(t, st, ctx, now.Add(30*24*time.Hour), 3)
-	tl.detectPatterns(ctx, now.Add(60*24*time.Hour))
+	seedRefillEvents(t, st, ctx, now.Add(30*24*time.Hour), pattern.MinEvents)
+	tl.detectPatterns(ctx, now.Add(60*24*time.Hour), loop.State{})

 	proposed, err := st.ListProposedRoutinesByStatus(ctx, store.RoutineProposed)
 	if err != nil {
@@ -120,3 +125,161 @@ func TestTickPatternDetectionRespectsDismissal(t *testing.T) {
 		t.Errorf("status = %s, want dismissed", all[0].Status)
 	}
 }
+
+// proposalRule — the rule name announceProposal uses for the seeded pair.
+const proposalRule = "proposal:refill cat_water"
+
+// TestTickProposalSilentByDefault — detection is always on, announcing is not.
+// With no pattern_proposals block the tick still records the proposal, and says
+// nothing about it: Maven is not autonomous, so a behaviour that speaks without
+// being asked stays off until it is configured.
+func TestTickProposalSilentByDefault(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow()
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)
+	markPresent(t, st, ctx, now)
+
+	sink := &fakeSink{}
+	tl := newTestTickLoop(t, st, sink, nil)
+	tl.tick(ctx, now)
+
+	if n := countSends(sink, proposalRule); n != 0 {
+		t.Fatalf("announced %d proposals with no config, want 0", n)
+	}
+	rows, err := st.ListProposedRoutinesByStatus(ctx, store.RoutineProposed)
+	if err != nil {
+		t.Fatalf("list proposed: %v", err)
+	}
+	if len(rows) != 1 {
+		t.Fatalf("proposed routines = %d, want 1 (silent, but recorded)", len(rows))
+	}
+}
+
+// TestTickAnnouncesProposalWhenConfigured — with notify on, the proposal goes
+// out once through the ordinary delivery path, worded by the detector itself.
+// Later ticks stay quiet because the pair is already proposed: one pattern is
+// one announcement, ever.
+func TestTickAnnouncesProposalWhenConfigured(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow()
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)
+	markPresent(t, st, ctx, now)
+
+	sink := &fakeSink{}
+	tl := newTestTickLoop(t, st, sink, nil)
+	tl.proposalCfg = &config.PatternProposalConfig{Notify: true}
+	tl.tick(ctx, now)
+
+	var got *delivery.Sendable
+	for i := range sink.sends {
+		if sink.sends[i].RuleName == proposalRule {
+			got = &sink.sends[i]
+		}
+	}
+	if got == nil {
+		t.Fatalf("proposal was not announced; sends=%+v", sink.sends)
+	}
+	if !strings.Contains(got.Body, "напоминать?") {
+		t.Errorf("body = %q, want the detector's own question", got.Body)
+	}
+	if got.Channel != delivery.ChannelVoice {
+		t.Errorf("channel = %v, want voice (sev1, present)", got.Channel)
+	}
+
+	// A month of further ticks: the pair already has a row, so there is
+	// nothing new to detect and nothing more to say.
+	sink.sends = nil
+	later := now.Add(40 * 24 * time.Hour)
+	markPresent(t, st, ctx, later)
+	tl.tick(ctx, later)
+	if n := countSends(sink, proposalRule); n != 0 {
+		t.Fatalf("re-announced an existing proposal %d times, want 0", n)
+	}
+}
+
+// TestTickProposalRespectsGate — a proposal is the least urgent thing Maven can
+// say, so it is sev1 and the restraint gate suppresses it. Away presence means
+// it is not announced at all: it is not held, not retried, it just lives on
+// /routines. The proposal row is still written — noticing is never gated.
+func TestTickProposalRespectsGate(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow()
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)
+	// no presence probes ⇒ away ⇒ care-class gate blocks.
+
+	sink := &fakeSink{}
+	tl := newTestTickLoop(t, st, sink, nil)
+	tl.proposalCfg = &config.PatternProposalConfig{Notify: true}
+	tl.tick(ctx, now)
+
+	if n := countSends(sink, proposalRule); n != 0 {
+		t.Fatalf("away: announced %d proposals, want 0", n)
+	}
+	if !tl.lastProposalAt.IsZero() {
+		t.Error("cooldown clock advanced on a suppressed announcement")
+	}
+	rows, err := st.ListProposedRoutinesByStatus(ctx, store.RoutineProposed)
+	if err != nil {
+		t.Fatalf("list proposed: %v", err)
+	}
+	if len(rows) != 1 {
+		t.Fatalf("proposed routines = %d, want 1 (detection is never gated)", len(rows))
+	}
+}
+
+// TestTickProposalCooldownSpacesAnnouncements — two patterns detected on the
+// same tick must not become two interruptions. The second one waits for the
+// cooldown, and is on /routines meanwhile.
+func TestTickProposalCooldownSpacesAnnouncements(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow()
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)
+	for i := 0; i < pattern.MinEvents; i++ {
+		ts := now.Add(time.Duration(i) * 3 * 24 * time.Hour)
+		factID, err := st.WriteFact(ctx, ts, store.KindSelf, "litter_box", "clean", "test", 1.0, sql.NullInt64{})
+		if err != nil {
+			t.Fatalf("write fact: %v", err)
+		}
+		if _, err := st.CreateEvent(ctx, factID, "clean", "litter_box", ts); err != nil {
+			t.Fatalf("create event: %v", err)
+		}
+	}
+	markPresent(t, st, ctx, now)
+
+	sink := &fakeSink{}
+	tl := newTestTickLoop(t, st, sink, nil)
+	tl.proposalCfg = &config.PatternProposalConfig{Notify: true, Cooldown: config.Duration(24 * time.Hour)}
+	tl.tick(ctx, now)
+
+	announced := 0
+	for _, s := range sink.sends {
+		if strings.HasPrefix(s.RuleName, "proposal:") {
+			announced++
+		}
+	}
+	if announced != 1 {
+		t.Fatalf("announced %d proposals on one tick, want exactly 1", announced)
+	}
+	rows, err := st.ListProposedRoutinesByStatus(ctx, store.RoutineProposed)
+	if err != nil {
+		t.Fatalf("list proposed: %v", err)
+	}
+	if len(rows) != 2 {
+		t.Fatalf("proposed routines = %d, want 2 (both recorded, one announced)", len(rows))
+	}
+
+	// Still inside the cooldown: silence, even though a proposal is pending.
+	sink.sends = nil
+	soon := now.Add(time.Hour)
+	markPresent(t, st, ctx, soon)
+	tl.tick(ctx, soon)
+	for _, s := range sink.sends {
+		if strings.HasPrefix(s.RuleName, "proposal:") {
+			t.Fatalf("announced %q inside the cooldown", s.RuleName)
+		}
+	}
+}