mavend, router: stop three sources claiming turns the world should answer (V-474)

The querySources order predates the 2026-08-02 ruling that live search leads.

An unconfigured feeds source claimed every news question and answered with a
configuration status, so "что происходит сейчас в новостях про искусственный
интеллект?" never reached the search sitting one source below. It now claims
only when neither SearXNG nor the ZIMs are configured, which is the case the
"не читаю ленты" line was written for — general knowledge would otherwise
invent a bulletin.

The calendar matches on a day word alone and sits above the weather, so
"какая сегодня погода в Москве?" answered "на 02.08.2026 ничего нет." It now
steps aside on weather wording, the same bail-out queryHome already does.

"что нового в лентах?" routed system and answered "пока не умею", while the
same question worded with "новостях" worked. FeedQueryGrammar routes it to
query at stage 0, requiring an ask word and a feed noun so the bare greeting
"что нового?" stays a greeting. Wired in the eval too, since the fixture is
only worth anything while its grammar set is the daemon's.

Also: the claiming source is now logged. /trace is the nudge-rule trace and
carries no query-source field, so a wrong answer could not be told apart from
a wrongly-ordered chain.

Kiwix having no live coverage is filed separately as V-508 — it is a decision
about search quality, not an ordering fix.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

cmd/mavend/actions.go

@@ -57,6 +57,9 @@ var actionHandlers = map[router.Intent]func(*reactiveHandler, context.Context, r
 func (h *reactiveHandler) actionChat(ctx context.Context, dec router.Decision) string {
 	// Conversational: build history from dialogue session (prior user turns)
 	// and let the LLM respond from general knowledge + context.
+	if h.phraser == nil {
+		return "поговорили."
+	}
 	history := h.chatHistory()
 	reply, err := h.phraser.PhraseChat(ctx, dec.Utterance, history)
 	if err != nil {

cmd/mavend/actions_fact.go

@@ -38,6 +38,21 @@ func (h *reactiveHandler) actionFact(ctx context.Context, dec router.Decision) s
 		q.Slots.Value = ""
 		return h.actionQuery(ctx, q)
 	}
+	// A complaint is not a fact either (#481). "сеть какая-то медленная" and
+	// "интернет не работает" were stored as `self` rows at confidence 1.00, and
+	// recall reads a self row back later as if it were still true — the same
+	// class of row that outranked live search in #470. The sentence describes a
+	// moment, so she answers it and stores nothing. An explicit "запомни ..."
+	// and anything about him are both left alone by the test.
+	if router.IsTransientComplaint(dec.Utterance) {
+		log.Printf("voice: fact write refused, utterance is a passing complaint: %q (key %q) — answering as chat",
+			dec.Utterance, dec.Slots.Key)
+		c := dec
+		c.Intent = router.IntentChat
+		c.Slots.Key, c.Slots.HasKey = "", false
+		c.Slots.Value = ""
+		return h.actionChat(ctx, c)
+	}
 	now := h.now()
 	req := ipc.WriteFactReq{
 		Ts:     now,

cmd/mavend/actions_query.go

@@ -81,6 +81,11 @@ var querySources = []querySource{
 	// matcher requires a task noun or an explicit "что … сделать", so a
 	// date-bearing question still reaches the calendar.
 	{name: "tasks", answer: (*reactiveHandler).queryTasks},
+	// Next to "tasks" and for the same reason: "что требует внимания?" is a
+	// question about the operational state Praxis holds, and it used to fall
+	// through every source to the web search (Vikunja #475). Its matcher needs
+	// an attention marker, and it falls through when Praxis is not configured.
+	{name: "attention", answer: (*reactiveHandler).queryAttention},
 	// Before the recall sources too: "сколько я потратил?" is a question about
 	// the money facts the poller wrote, and the notes pass would otherwise
 	// answer it from whatever he once said about spending. Its matcher needs a
@@ -140,6 +145,13 @@ func (h *reactiveHandler) actionQuery(ctx context.Context, dec router.Decision)
 			continue
 		}
 		if reply, ok := src.answer(h, ctx, t); ok {
+			// Which source claimed is the one thing about a query turn that was
+			// invisible from outside: /trace is the nudge-rule trace and carries
+			// no query-source field, so a wrong answer could not be told from a
+			// wrongly-ordered chain (Vikunja #474). Only the name is logged —
+			// the utterance and the answer are already on the voice lines above
+			// and below this one.
+			log.Printf("voice: query claimed by source %q", src.name)
 			return reply
 		}
 	}
@@ -278,9 +290,17 @@ func (h *reactiveHandler) queryFeeds(ctx context.Context, t *queryTurn) (string,
 		return "", false
 	}
 	if !h.feedsOn {
-		// Claim the turn rather than fall through: "не читаю ленты" is true, and
-		// letting general knowledge answer "что нового?" would be an invented
-		// news bulletin.
+		// Claim only when nothing below can read the world. The reason this
+		// source used to claim unconditionally was that general knowledge would
+		// answer "что нового?" with an invented news bulletin — true, and it
+		// stopped being the only alternative on 2026-08-02, when live search
+		// took the lead. With SearXNG or the ZIMs configured, "что происходит
+		// в новостях про искусственный интеллект?" has a real answer below,
+		// and a configuration status is the wrong thing to say instead
+		// (Vikunja #474).
+		if h.search != nil || h.kiwix != nil {
+			return "", false
+		}
 		return "я пока не читаю ленты — они не настроены.", true
 	}
 	// By source, not the last 200 notes of any kind: a busy day of voice notes
@@ -317,6 +337,15 @@ func (h *reactiveHandler) queryFeeds(ctx context.Context, t *queryTurn) (string,
 // h.now(), not time.Now(): the handler's clock is the injected one, so this
 // source can be tested at a fixed time like the rest.
 func (h *reactiveHandler) queryCalendar(ctx context.Context, t *queryTurn) (string, bool) {
+	// A day word is all this source matches on, so any question that merely
+	// names a day reached it first. "какая сегодня погода в Москве?" answered
+	// "на 02.08.2026 ничего нет." (Vikunja #474). Weather is asked about a day
+	// far more often than the calendar is, and the weather source sits right
+	// below, so the calendar steps aside on weather wording — the same bail-out
+	// queryHome already does for the same reason.
+	if isWeatherQuery(t.dec.Utterance) {
+		return "", false
+	}
 	date, ok := router.ParseCalendarDate(t.dec.Utterance, h.now())
 	if !ok {
 		return "", false

cmd/mavend/actions_reminder.go

@@ -24,7 +24,10 @@ func (h *reactiveHandler) actionReminder(ctx context.Context, dec router.Decisio
 			return "не получилось разобрать время напоминания."
 		}
 	}
-	payload := `{"text":` + jsonString(dec.Utterance) + `}`
+	// The body is what she says at the hour, so the marker and the time come
+	// out of it: the fire time is already a column, and "напомни" is an
+	// instruction that has been carried out (Vikunja #469).
+	payload := `{"text":` + jsonString(reminderBody(dec.Utterance, dec.Slots.Text)) + `}`
 	if _, err := h.api.CreateReminder(ctx, dec.Slots.Time, payload, ""); err != nil {
 		log.Printf("voice: create reminder: %v", err)
 		return "не получилось поставить напоминание."

cmd/mavend/attentionq.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"context"
+	"strings"
+
+	"github.com/kami/maven/internal/router"
+)
+
+// attentionMarkers — the ways he asks what Praxis is holding. Substrings on a
+// stem, because "внимание", "внимания" and "вниманию" are one word to him.
+//
+// "что нового" is deliberately absent: the feeds source claims it, and it
+// still should — a question about news is a question about the feeds she
+// reads. This list is about the operational state of his things.
+var attentionMarkers = []string{
+	"внимани", "что требует", "что не так", "что важн", "что срочн",
+	"needs attention", "what needs looking",
+}
+
+// isAttentionQuery reports whether the utterance asks what needs looking at.
+func isAttentionQuery(u string) bool {
+	s := strings.ToLower(strings.TrimSpace(u))
+	if s == "" {
+		return false
+	}
+	for _, m := range attentionMarkers {
+		if strings.Contains(s, m) {
+			return true
+		}
+	}
+	return false
+}
+
+// queryAttention answers "что требует внимания?" from Praxis.
+//
+// The capability was already built and already degraded correctly, and no
+// utterance could reach it (Vikunja #475). Its aliases live on the act
+// dispatch, and the question routes to IntentQuery, so it fell through every
+// source to the web search and came back with an encyclopedia article about
+// the concept of attention — worse than silence, because it reads as an
+// answer.
+//
+// Placed above the recall sources and well above the personal boundary: this
+// is operational state about his things, and a notes pass would otherwise
+// answer it from whatever he once wrote about a server. An unconfigured or
+// absent Praxis falls through rather than claiming the turn, the same
+// convention queryHome and queryNetwork follow. A Praxis that is configured
+// and down does claim it, and says it cannot reach the service — that is the
+// degradation the ecosystem contract asks for, and it comes from the same
+// handler the act path uses.
+func (h *reactiveHandler) queryAttention(ctx context.Context, t *queryTurn) (string, bool) {
+	if !isAttentionQuery(t.dec.Utterance) {
+		return "", false
+	}
+	if h.ecosystem == nil || h.ecosystem.praxis == nil {
+		return "", false
+	}
+	reply := h.handlePraxisAct(ctx, router.Decision{
+		Utterance: t.dec.Utterance,
+		Intent:    router.IntentAct,
+		Slots:     router.Slots{Fn: "list_attention", HasFn: true},
+	})
+	if reply == "" {
+		return "", false
+	}
+	return reply, true
+}

cmd/mavend/attentionq_test.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/kami/maven/internal/router"
+)
+
+func TestIsAttentionQuery(t *testing.T) {
+	for _, tc := range []struct {
+		text string
+		want bool
+	}{
+		{"что требует внимания", true},
+		{"на что обратить внимание?", true},
+		{"что не так?", true},
+		{"что важного?", true},
+		// The feeds source owns this one, and should keep owning it.
+		{"что нового?", false},
+		{"какая погода?", false},
+		{"", false},
+	} {
+		if got := isAttentionQuery(tc.text); got != tc.want {
+			t.Errorf("isAttentionQuery(%q) = %v, want %v", tc.text, got, tc.want)
+		}
+	}
+}
+
+// TestAttentionQuestionReachesPraxis — the defect (Vikunja #475). The question
+// routes to IntentQuery, and every source used to pass, so a web search about
+// the concept of attention answered it.
+func TestAttentionQuestionReachesPraxis(t *testing.T) {
+	ctx := context.Background()
+	praxis := newFakePraxis(t, fixturePraxisAttentionItems(map[string]any{
+		"id": "item_1", "title": "disk almost full", "importance": 3.0,
+	}))
+	h := ecoHandler(t, nil, praxis, nil)
+
+	reply, ok := h.queryAttention(ctx, &queryTurn{dec: router.Decision{
+		Intent: router.IntentQuery, Utterance: "что требует внимания",
+	}})
+	if !ok {
+		t.Fatal("the attention question must be claimed before the world sources")
+	}
+	if !strings.Contains(reply, "disk almost full") {
+		t.Fatalf("reply = %q, want the praxis item", reply)
+	}
+}
+
+// A configured Praxis that is down claims the turn and says so. Falling
+// through here would answer an outage with an encyclopedia article.
+func TestAttentionQuestionSaysWhenPraxisIsDown(t *testing.T) {
+	ctx := context.Background()
+	praxis := newFakePraxis(t, fixturePraxisAttentionItems())
+	h := ecoHandler(t, nil, praxis, nil)
+	praxis.SetFault(503)
+
+	reply, ok := h.queryAttention(ctx, &queryTurn{dec: router.Decision{
+		Intent: router.IntentQuery, Utterance: "что требует внимания",
+	}})
+	if !ok || !strings.Contains(reply, "не могу") {
+		t.Fatalf("an outage must name the gap, got ok=%v reply=%q", ok, reply)
+	}
+}
+
+// No Praxis configured means no claim: the rest of the chain still runs.
+func TestAttentionQuestionFallsThroughWithoutPraxis(t *testing.T) {
+	h, _ := newFactGateHandler(t, time.Now())
+	if _, ok := h.queryAttention(context.Background(), &queryTurn{dec: router.Decision{
+		Intent: router.IntentQuery, Utterance: "что требует внимания",
+	}}); ok {
+		t.Fatal("an unconfigured praxis must not claim the turn")
+	}
+}

cmd/mavend/clarify_test.go

@@ -497,8 +497,12 @@ func TestClarifySubjectAnswerFillsRatherThanClobbers(t *testing.T) {
 	if !strings.Contains(reminders[0].Payload, "маме") {
 		t.Fatalf("the answer never reached the reminder: %q", reminders[0].Payload)
 	}
-	if !strings.Contains(reminders[0].Payload, "11") {
-		t.Fatalf("the answer clobbered the original request: %q", reminders[0].Payload)
+	// The hour is the fire time, not a word in the body: the body is what she
+	// says at the hour, and the time expression is stripped out of it
+	// (Vikunja #469). Clobbering the parked request would show up here as a
+	// reminder that fires at some other time than the one he asked for.
+	if got := reminders[0].FireTs.UTC(); !got.Equal(at.UTC()) {
+		t.Fatalf("the answer clobbered the original request: fires at %v, want %v", got, at.UTC())
 	}
 }
 

cmd/mavend/factgate_test.go

@@ -123,3 +123,48 @@ func mustEmbedPassage(t *testing.T, h *reactiveHandler, text string) []float32 {
 	}
 	return vec
 }
+
+// The write half of #481: a complaint about a thing is a state of the
+// afternoon, not a fact about him. Stored as a `self` row at confidence 1.00
+// it comes back on recall as if the network were still down.
+func TestActionFact_ComplaintIsNotWritten(t *testing.T) {
+	ctx := context.Background()
+	h, api := newFactGateHandler(t, time.Now())
+
+	reply := h.actionFact(ctx, router.Decision{
+		Intent:    router.IntentFact,
+		Utterance: "сеть какая-то медленная",
+		Slots:     router.Slots{Key: "network_speed", HasKey: true, Value: "медленная"},
+	})
+
+	if _, err := api.LatestFact(ctx, "network_speed"); err == nil {
+		t.Fatal("a passing complaint was stored as a fact about him")
+	}
+	hits, err := h.memStore.Search(ctx, mustEmbedPassage(t, h, "сеть какая-то медленная"), 3)
+	if err != nil {
+		t.Fatalf("memory search: %v", err)
+	}
+	if len(hits) != 0 {
+		t.Fatalf("the complaint was indexed for recall: %+v", hits)
+	}
+	if reply == "" {
+		t.Fatal("the turn was neither stored nor answered")
+	}
+}
+
+// And the complaint he asked her to keep: the capture verb wins, as it does
+// over the question gate.
+func TestActionFact_AskedToRememberAComplaintStillWrites(t *testing.T) {
+	ctx := context.Background()
+	h, api := newFactGateHandler(t, time.Now())
+
+	h.actionFact(ctx, router.Decision{
+		Intent:    router.IntentFact,
+		Utterance: "запомни что интернет не работает",
+		Slots:     router.Slots{Key: "internet", HasKey: true, Value: "не работает"},
+	})
+
+	if _, err := api.LatestFact(ctx, "internet"); err != nil {
+		t.Fatalf("an explicit capture was refused: %v", err)
+	}
+}

cmd/mavend/feeds_test.go

@@ -194,3 +194,22 @@ func TestFeedWorkerFetcherIsAllowlisted(t *testing.T) {
 		t.Fatal("the poller fetched a private address")
 	}
 }
+
+// TestQueryFeedsPassesWhenTheWorldCanAnswer — the defect (Vikunja #474). The
+// deployed box has no feeds block and does have SearXNG, and "что происходит
+// сейчас в новостях про искусственный интеллект?" got a configuration status
+// instead of the live answer sitting one source below.
+func TestQueryFeedsPassesWhenTheWorldCanAnswer(t *testing.T) {
+	h := buildFeedHandler(t, false)
+	h.search = &searchWiring{max: 3, runes: 1500}
+
+	if reply, ok := askFeeds(t, h, "что нового в лентах?"); ok {
+		t.Fatalf("feeds off with a search configured must fall through, got %q", reply)
+	}
+	// With nothing below that reads the world, the honest status is still said:
+	// general knowledge would otherwise answer with an invented bulletin.
+	h.search = nil
+	if reply, ok := askFeeds(t, h, "что нового в лентах?"); !ok || !strings.Contains(reply, "не настроены") {
+		t.Fatalf("no search and no ZIMs: reply = %q, ok = %v", reply, ok)
+	}
+}

cmd/mavend/reminderbody.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+	"regexp"
+	"strings"
+)
+
+// reminderMarker — the words that open a reminder. Stripped because they are
+// the instruction, not the thing to say at the hour.
+var reminderMarker = regexp.MustCompile(`(?i)^\s*(?:напомни(?:те)?|напомнить|remind)\s*(?:мне|me)?[\s,:—-]*`)
+
+// reminderTimeWords — the time expressions a reminder carries, removed from
+// the body because the fire time is already a column. Ordered longest-first
+// where two could match the same words, so "через полтора часа" does not leave
+// "полтора" behind.
+//
+// Go's \b is ASCII-only and never fires next to a Cyrillic letter, so the word
+// boundaries here are written out as whitespace or an end of string — the same
+// trap the agenda grammars hit.
+var reminderTimeWords = []*regexp.Regexp{
+	regexp.MustCompile(`(?i)(^|\s)через\s+\S+(\s+(часа?|часов|минут[уы]?|секунд[уы]?|дня|дней|недел[юи]))?(\s|$)`),
+	regexp.MustCompile(`(?i)(^|\s)(в|во)\s+\d{1,2}(:\d{2})?(\s*(часа?|часов))?(\s*(утра|вечера|дня|ночи))?(\s|$)`),
+	regexp.MustCompile(`(?i)(^|\s)(завтра|послезавтра|сегодня|вечером|утром|днём|днем|ночью)(\s|$)`),
+	regexp.MustCompile(`(?i)(^|\s)(at|in)\s+\d{1,2}(:\d{2})?\s*(am|pm)?(\s|$)`),
+	regexp.MustCompile(`(?i)(^|\s)(tomorrow|today|tonight)(\s|$)`),
+}
+
+// reminderBody is what she says at the hour.
+//
+// The whole utterance used to be stored, so /reminders read "напомни завтра в
+// 9 утра выпить таблетки" where it should read "выпить таблетки", and the
+// agenda recited the marker back at him (Vikunja #469). The fire time is
+// already a column, and the marker is an instruction that was carried out.
+//
+// Falls back to the fuller text whenever stripping would leave nothing: an
+// empty body is a reminder that fires and says nothing, which is worse than a
+// wordy one.
+func reminderBody(utterance, text string) string {
+	body := strings.TrimSpace(text)
+	if body == "" {
+		body = strings.TrimSpace(utterance)
+	}
+	stripped := reminderMarker.ReplaceAllString(body, "")
+	for _, re := range reminderTimeWords {
+		stripped = re.ReplaceAllString(stripped, " ")
+	}
+	stripped = strings.TrimSpace(strings.Join(strings.Fields(stripped), " "))
+	stripped = strings.Trim(stripped, " ,;:—-")
+	if stripped == "" {
+		return body
+	}
+	return stripped
+}

cmd/mavend/reminderbody_test.go

@@ -0,0 +1,21 @@
+package main
+
+import "testing"
+
+func TestReminderBody(t *testing.T) {
+	for _, tc := range []struct{ utterance, text, want string }{
+		// The row from the QA sitting: the whole utterance was the body.
+		{"напомни завтра в 9 утра выпить таблетки", "завтра в 9 утра выпить таблетки", "выпить таблетки"},
+		{"напомни мне позвонить маме в семь вечера", "позвонить маме в 7 вечера", "позвонить маме"},
+		{"напомни через полчаса проверить бэкап", "через полчаса проверить бэкап", "проверить бэкап"},
+		{"remind me to call mom at 7pm", "to call mom at 7pm", "to call mom"},
+		// Nothing left after stripping ⇒ keep what there was. A reminder that
+		// fires and says nothing is worse than a wordy one.
+		{"напомни завтра", "завтра", "завтра"},
+		{"", "", ""},
+	} {
+		if got := reminderBody(tc.utterance, tc.text); got != tc.want {
+			t.Errorf("reminderBody(%q, %q) = %q, want %q", tc.utterance, tc.text, got, tc.want)
+		}
+	}
+}

cmd/mavend/tick_test.go

@@ -584,7 +584,7 @@ func TestDigestSev4BypassesQueue(t *testing.T) {
 	ctx := context.Background()
 	now := refNow()
 	markPresent(t, st, ctx, now)
-	if _, err := st.SetValue(ctx, store.KindSelf, "service_down:db", "poll:uptimekuma", "down", now); err != nil {
+	if _, err := st.SetValue(ctx, store.KindSelf, "service_down", "poll:uptimekuma", "down", now); err != nil {
 		t.Fatalf("seed service_down: %v", err)
 	}
 	sink := &fakeSink{}

cmd/mavend/voicewire.go

@@ -382,6 +382,9 @@ func buildRouter(emb router.Embedder, acts router.ActMatcher, threshold float64,
 	// question and must keep reaching replySystem, while "что у меня сегодня"
 	// is an agenda question and must not.
 	grammars = append(grammars, router.AgendaQueryGrammars()...)
+	// Same reason as the agenda rules, for the feeds: "что нового в лентах?"
+	// routed system and answered "пока не умею" (Vikunja #474).
+	grammars = append(grammars, router.FeedQueryGrammar())
 	grammars = append(grammars, router.ReminderGrammar())
 	// Last, and it matches any utterance shape — its Build is the filter. An
 	// explicit capture marker beats the model, which called it an act and

cmd/mavend/weatherq_test.go

@@ -1,6 +1,11 @@
 package main
 
-import "testing"
+import (
+	"context"
+	"testing"
+
+	"github.com/kami/maven/internal/router"
+)
 
 // TestExtractWeatherLocation — any place he names comes through, not just the
 // six that used to be in a table (Vikunja #421).
@@ -31,3 +36,30 @@ func TestExtractWeatherLocation(t *testing.T) {
 		}
 	}
 }
+
+// TestCalendarStepsAsideForWeather — the defect (Vikunja #474). "какая сегодня
+// погода в Москве?" answered "на 02.08.2026 ничего нет.": the calendar matches
+// on a day word alone, and it sits above the weather source.
+func TestCalendarStepsAsideForWeather(t *testing.T) {
+	h, api := contQueryHandler()
+	for _, u := range []string{
+		"какая сегодня погода в Москве?",
+		"будет дождь завтра?",
+		"сколько градусов сегодня?",
+	} {
+		if reply, ok := h.queryCalendar(context.Background(), &queryTurn{
+			dec: router.Decision{Intent: router.IntentQuery, Utterance: u},
+		}); ok {
+			t.Errorf("the calendar claimed %q with %q", u, reply)
+		}
+	}
+	if api.events != 0 {
+		t.Errorf("CalendarEvents called %d times for weather questions, want 0", api.events)
+	}
+	// The agenda question it exists for still reaches it.
+	if _, ok := h.queryCalendar(context.Background(), &queryTurn{
+		dec: router.Decision{Intent: router.IntentQuery, Utterance: "что у меня сегодня?"},
+	}); !ok {
+		t.Fatal("the calendar stopped answering the agenda question")
+	}
+}

cmd/mavpoll/main.go

@@ -140,10 +140,6 @@ type poller struct {
 	wgIface    string
 	wgCmd      string
 
-	// kumaSeen — monitor name → state as of the last poll, so a monitor that
-	// disappears from the gauge can be marked unknown instead of staying down.
-	kumaSeen map[string]string
-
 	// zen is nil unless a token file was configured — money tracking is a
 	// capability, off by default like weather and telegram.
 	zen      *zenmoney.Client
@@ -337,96 +333,50 @@ func maxSeverity(a netdataAlarms) string {
 	return sev
 }
 
-// ---- kuma: monitor_status gauge → one fact per monitor ---------------------
+// ---- kuma: monitor_status gauge → aggregate service_down -------------------
 
 // Kuma exposes Prometheus text: `monitor_status{...,monitor_name="X"} V` where
-// V is 1=up 0=down 2=pending 3=maintenance. We write one fact per monitor,
-// keyed `service_down:<monitor name>`, because the nudge has to say WHICH
-// service is down. The aggregate this used to write could not, which is why
-// the rule shipped disabled.
-var (
-	kumaLine = regexp.MustCompile(`^monitor_status\{([^}]*)\}\s+([0-9.eE+-]+)`)
-	kumaName = regexp.MustCompile(`monitor_name="([^"]*)"`)
-)
+// V is 1=up 0=down 2=pending 3=maintenance. We reduce to one aggregate the
+// existing ServiceDownRule consumes: "down" if ANY monitor reads 0, else "up".
+// Per-service granularity is a later add (a fact per monitor) — the MVP nudge
+// only needs "something is down".
+var kumaLine = regexp.MustCompile(`^monitor_status\{([^}]*)\}\s+([0-9.eE+-]+)`)
 
 func (p *poller) pollKuma(ctx context.Context, now time.Time) error {
 	body, err := p.get(ctx, p.kumaURL, p.kumaKey)
 	if err != nil {
 		return err
 	}
-	states := kumaMonitors(body)
-	if len(states) == 0 {
+	down, seen := kumaAnyDown(body)
+	if !seen {
 		return fmt.Errorf("no monitor_status metrics (auth/endpoint wrong?)")
 	}
-	var firstErr error
-	for name, val := range states {
-		if err := p.writeIfChanged(ctx, kumaFactKey(name), kumaSource, val, now); err != nil && firstErr == nil {
-			firstErr = err // one bad monitor must not blind the rest
-		}
+	val := "up"
+	if down {
+		val = "down"
 	}
-	// A monitor deleted in kuma stops appearing in the gauge, and its last fact
-	// would otherwise read "down" forever. Mark it unknown, which no rule fires
-	// on. The seen-set is in memory, so a restart forgets it — harmless, since
-	// the next poll that still lacks the monitor says nothing new either.
-	for name := range p.kumaSeen {
-		if _, still := states[name]; !still {
-			if err := p.writeIfChanged(ctx, kumaFactKey(name), kumaSource, "unknown", now); err != nil && firstErr == nil {
-				firstErr = err
-			}
-		}
-	}
-	p.kumaSeen = states
-	return firstErr
+	return p.writeIfChanged(ctx, "service_down", "poll:uptimekuma", val, now)
 }
 
-// kumaSource — the provenance the loop rule requires. Written here, checked in
-// loop.ServiceDownRule; a poller under any other source cannot fire it.
-const kumaSource = "poll:uptimekuma"
-
-// kumaFactKey — the fact key for one monitor. The suffix is the name he hears,
-// so it stays as kuma spells it rather than being slugged into something else.
-func kumaFactKey(name string) string { return "service_down:" + name }
-
-// kumaMonitors parses kuma's Prometheus text into monitor name → state
-// ("up"/"down"/"pending"/"maintenance"). An empty map means no monitor_status
-// line matched at all (wrong endpoint, or auth rejected before the body).
-// A line with no monitor_name label is skipped: a fact nobody can name is
-// exactly the thing this replaced.
-func kumaMonitors(body []byte) map[string]string {
-	out := make(map[string]string)
+// kumaAnyDown parses kuma's Prometheus text: down=true if any monitor reads 0
+// (pending=2/maintenance=3 are not "down"). seen=false ⇒ no monitor_status
+// lines matched at all (wrong endpoint or auth rejected before the body).
+func kumaAnyDown(body []byte) (down, seen bool) {
 	for _, line := range strings.Split(string(body), "\n") {
 		m := kumaLine.FindStringSubmatch(strings.TrimSpace(line))
 		if m == nil {
 			continue
 		}
-		nm := kumaName.FindStringSubmatch(m[1])
-		if nm == nil || strings.TrimSpace(nm[1]) == "" {
-			continue
-		}
+		seen = true
 		v, err := strconv.ParseFloat(m[2], 64)
 		if err != nil {
 			continue
 		}
-		out[strings.TrimSpace(nm[1])] = kumaState(v)
-	}
-	return out
-}
-
-// kumaState — the gauge's four values. pending and maintenance are not "down":
-// a monitor paused in kuma should silence that monitor, not page him.
-func kumaState(v float64) string {
-	switch v {
-	case 0:
-		return "down"
-	case 1:
-		return "up"
-	case 2:
-		return "pending"
-	case 3:
-		return "maintenance"
-	default:
-		return "unknown"
+		if v == 0 {
+			down = true
+		}
 	}
+	return down, seen
 }
 
 // ---- helpers ---------------------------------------------------------------

cmd/mavpoll/main_test.go

@@ -35,46 +35,22 @@ func TestMaxSeverity(t *testing.T) {
 	}
 }
 
-func TestKumaMonitorsNamesEveryOne(t *testing.T) {
+func TestKumaAnyDown(t *testing.T) {
 	cases := []struct {
-		name string
-		body string
-		want map[string]string
+		body       string
+		down, seen bool
 	}{
-		{"empty body", "", map[string]string{}},
-		{"help line only", `# HELP monitor_status ...`, map[string]string{}},
-		{
-			"one up one down",
-			`monitor_status{monitor_name="web"} 1` + "\n" + `monitor_status{monitor_name="db"} 0`,
-			map[string]string{"web": "up", "db": "down"},
-		},
-		{"maintenance is not down", `monitor_status{monitor_name="mnt"} 3`, map[string]string{"mnt": "maintenance"}},
-		{"pending is not down", `monitor_status{monitor_name="p"} 2`, map[string]string{"p": "pending"}},
-		{
-			"other labels do not hide the name",
-			`monitor_status{monitor_type="http",monitor_name="ci",monitor_url="x"} 0`,
-			map[string]string{"ci": "down"},
-		},
-		{"a nameless line is skipped", `monitor_status{monitor_type="http"} 0`, map[string]string{}},
+		{"", false, false},
+		{`monitor_status{monitor_name="web"} 1`, false, true},
+		{`monitor_status{monitor_name="web"} 1` + "\n" + `monitor_status{monitor_name="db"} 0`, true, true},
+		{`monitor_status{monitor_name="mnt"} 3`, false, true}, // maintenance ≠ down
+		{`# HELP monitor_status ...`, false, false},
 	}
 	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			got := kumaMonitors([]byte(c.body))
-			if len(got) != len(c.want) {
-				t.Fatalf("kumaMonitors = %v, want %v", got, c.want)
-			}
-			for k, v := range c.want {
-				if got[k] != v {
-					t.Errorf("monitor %q = %q, want %q", k, got[k], v)
-				}
-			}
-		})
-	}
-}
-
-func TestKumaFactKeyCarriesTheName(t *testing.T) {
-	if got := kumaFactKey("nexus db"); got != "service_down:nexus db" {
-		t.Errorf("kumaFactKey = %q", got)
+		down, seen := kumaAnyDown([]byte(c.body))
+		if down != c.down || seen != c.seen {
+			t.Errorf("kumaAnyDown(%q) = (%v,%v), want (%v,%v)", c.body, down, seen, c.down, c.seen)
+		}
 	}
 }
 

cmd/mavweb/ambient_test.go

@@ -139,10 +139,7 @@ func TestHandleAmbientIgnoresNonMeetings(t *testing.T) {
 }
 
 func TestHandleAmbientAuth(t *testing.T) {
-	// "завтра" so the meeting is in the future in every zone: the clock in the
-	// text is a local wall clock and posted_at is a Z instant, so a bare "10:00"
-	// is already stale on a box east of UTC and stores nothing.
-	body := `{"title":"Планёрка завтра 10:00","posted_at":"2026-08-03T09:40:00Z"}`
+	body := `{"title":"Планёрка 10:00","posted_at":"2026-08-03T09:40:00Z"}`
 
 	newReq := func(hdr, val string) *http.Request {
 		r := httptest.NewRequest(http.MethodPost, "/api/ambient", strings.NewReader(body))
@@ -248,31 +245,3 @@ func TestHandleAmbientBadInput(t *testing.T) {
 		}
 	})
 }
-
-// The Z-instant defect end to end: a phone posts an RFC 3339 instant in UTC and
-// the clock inside the text is his wall clock. On a UTC+4 box a 14:30 standup
-// used to be stored at 18:30, and the size of the error was the deploy's offset.
-func TestHandleAmbientStoresTheWallClockHeRead(t *testing.T) {
-	// No zone juggling: the assertion is that the stored wall clock is the one
-	// he read, whatever zone the box is in. That is false under the old code
-	// on every box except a UTC one.
-	core := &ambientCore{}
-	rr, resp := postAmbient(t, core, ambientTestToken, calendar.Notification{
-		Package: "com.slack",
-		Title:   "Standup",
-		Text:    "созвон завтра в 14:30",
-		Posted:  time.Date(2026, 8, 2, 9, 0, 0, 0, time.UTC),
-	})
-	if rr.Code != http.StatusCreated {
-		t.Fatalf("status = %d, want 201: %s", rr.Code, rr.Body)
-	}
-	if !strings.HasSuffix(resp.Key, "_Standup") {
-		t.Errorf("key = %q, want a key naming the meeting", resp.Key)
-	}
-	if len(core.writeLog) != 1 {
-		t.Fatalf("expected 1 fact write, got %d", len(core.writeLog))
-	}
-	if got := core.writeLog[0].Value; got != "Standup @ 14:30-15:00" {
-		t.Errorf("value = %q, want %q", got, "Standup @ 14:30-15:00")
-	}
-}

cmd/mavweb/main.go

@@ -946,6 +946,51 @@ func deliveryRows(as []ipc.DeliveryAttempt) []deliveryRow {
 	return out
 }
 
+// reminderRow is one line on /reminders, with the payload unwrapped and both
+// timestamps already in his clock.
+//
+// The page rendered `{{.Payload}}` and the UTC instant, so a reminder read
+// `{"text":"выпить таблетки"}` and fired an hour off what he was told
+// (Vikunja #469). Neither is a formatting nicety: the envelope is an internal
+// shape he never chose, and a time on a page he reads is the time on his wall.
+type reminderRow struct {
+	Created string
+	Fires   string
+	Status  string
+	Text    string
+}
+
+// reminderText unwraps the {"text":...} payload the router writes.
+//
+// A copy of store.ReminderText rather than a call to it, because mavweb is one
+// of the pure-Go daemons and internal/store carries the CGO sqlite driver. The
+// ipc DTO is decoupled from the store on purpose, so the unwrap belongs to
+// whoever renders it. Payload that is not that shape is shown as he said it.
+func reminderText(payload string) string {
+	var m map[string]any
+	if err := json.Unmarshal([]byte(payload), &m); err == nil {
+		if t, ok := m["text"]; ok {
+			if s, isStr := t.(string); isStr && s != "" {
+				return s
+			}
+		}
+	}
+	return strings.TrimSpace(payload)
+}
+
+func reminderRows(rs []ipc.Reminder) []reminderRow {
+	out := make([]reminderRow, 0, len(rs))
+	for _, r := range rs {
+		out = append(out, reminderRow{
+			Created: r.CreatedTs.Local().Format("02 Jan 15:04"),
+			Fires:   r.FireTs.Local().Format("02 Jan 15:04"),
+			Status:  r.Status,
+			Text:    reminderText(r.Payload),
+		})
+	}
+	return out
+}
+
 func handleReminders(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
 	if core == nil {
 		http.Error(w, "reminders disabled (no -core)", http.StatusServiceUnavailable)
@@ -959,7 +1004,7 @@ func handleReminders(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
 		return
 	}
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	if err := remindersTmpl.Execute(w, map[string]any{"Reminders": reminders}); err != nil {
+	if err := remindersTmpl.Execute(w, map[string]any{"Reminders": reminderRows(reminders)}); err != nil {
 		log.Printf("reminders template: %v", err)
 	}
 }

cmd/mavweb/reminders.html

@@ -3,10 +3,10 @@
 {{if .Reminders}}<div class=scroll><table>
 <tr><th>created</th><th>fires</th><th>status</th><th>what</th></tr>
 {{range .Reminders}}<tr>
-<td class=hint>{{.CreatedTs.Format "02 Jan 15:04"}}</td>
-<td>{{.FireTs.Format "02 Jan 15:04"}}</td>
+<td class=hint>{{.Created}}</td>
+<td>{{.Fires}}</td>
 <td><span class="badge {{.Status}}">{{.Status}}</span></td>
-<td class=text-max>{{.Payload}}</td>
+<td class=text-max>{{.Text}}</td>
 </tr>{{end}}</table></div>
 {{else}}<div class=empty>
   <svg class=icon width="24" height="24"><use href="/ethos-icons.svg#i-calendar"/></svg>

cmd/mavweb/reminders_test.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/kami/maven/internal/ipc"
+)
+
+// The page showed the storage envelope and the UTC instant (Vikunja #469).
+func TestReminderRowsUnwrapAndLocalise(t *testing.T) {
+	fire := time.Date(2026, 8, 4, 18, 30, 0, 0, time.UTC)
+	rows := reminderRows([]ipc.Reminder{{
+		CreatedTs: fire.Add(-time.Hour),
+		FireTs:    fire,
+		Status:    "pending",
+		Payload:   `{"text":"выпить таблетки"}`,
+	}})
+	if len(rows) != 1 {
+		t.Fatalf("rows = %d, want 1", len(rows))
+	}
+	if rows[0].Text != "выпить таблетки" {
+		t.Errorf("Text = %q, want the words without the envelope", rows[0].Text)
+	}
+	if want := fire.Local().Format("02 Jan 15:04"); rows[0].Fires != want {
+		t.Errorf("Fires = %q, want %q", rows[0].Fires, want)
+	}
+	if strings.Contains(rows[0].Text, "{") {
+		t.Errorf("Text still carries JSON: %q", rows[0].Text)
+	}
+}
+
+// A payload that is not the envelope is his own words, so it is shown as it is.
+func TestReminderTextKeepsPlainPayload(t *testing.T) {
+	for _, tc := range []struct{ in, want string }{
+		{`{"text":"позвонить маме"}`, "позвонить маме"},
+		{"  полить цветы  ", "полить цветы"},
+		{`{"body":"nope"}`, `{"body":"nope"}`},
+		{"", ""},
+	} {
+		if got := reminderText(tc.in); got != tc.want {
+			t.Errorf("reminderText(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}

deploy/mavend.json

@@ -8,12 +8,12 @@
   "//disabled_rules": [
     "Nudge rules that are not wired at all. Names come from loop.DefaultRules:",
     "water, meal, break, service_down, netdata_critical.",
-    "service_down is back on: mavpoll now writes one fact per kuma monitor",
-    "(service_down:<name>), so the nudge names the service and pausing a monitor",
-    "in kuma silences that monitor. It is also edge-triggered, so a service that",
-    "stays down is one nudge, not one every fifteen minutes."
+    "service_down is off because it cannot say WHICH service — mavpoll folds the",
+    "whole kuma gauge into one boolean, so the nudge is always the generic 'a",
+    "service on homesrv is down'. Nothing to act on, every fifteen minutes.",
+    "Turn it back on once Vikunja #444 lands a fact per monitor."
   ],
-  "disabled_rules": [],
+  "disabled_rules": ["service_down"],
 
   "phraser": {
     "model_path": "/opt/maven/models/llm/qwen3/Qwen3-1.7B-UD-Q4_K_XL.gguf",

docs/design.md

@@ -389,29 +389,6 @@ lives in `source`; rules trust provenance.
   `source=poll:healthcheck`. A compromised poller must not be able to forge a
   trigger.
 
-#### A fact per monitor, not an aggregate
-
-mavpoll writes one fact per kuma monitor, keyed `service_down:<monitor name>`.
-It used to fold the whole gauge into a single boolean, and the nudge could then
-only say that something on homesrv was down. That is not something he can act
-on, so the rule shipped disabled.
-
-Three things follow from the split:
-
-- The key set is no longer known at wiring time. A rule declares
-  `WantPrefixes` and the gatherer resolves the family per tick, which is the
-  only prefix read in the loop.
-- Pausing a monitor in kuma silences that monitor. Under the aggregate it
-  silenced nothing, because some other monitor kept the boolean at "down".
-- A monitor deleted in kuma would keep its last fact reading "down" forever, so
-  mavpoll marks a vanished monitor "unknown". No rule fires on "unknown".
-
-The rule is also edge-triggered: it fires on a transition it has not already
-nudged about (`State.NudgedSince`). A polled fact is written only when the
-value changes, but the predicate reads the current value, so without the edge
-check a service that stays down qualifies on every tick and cooldown is the
-only brake.
-
 ### Presence — concrete scoring
 
 **Combiner — noisy-OR, not weighted sum.** These are independent-ish positive

internal/calendar/ambient.go

@@ -68,28 +68,7 @@ var dayWords = map[string]int{
 // word ("завтра", "tomorrow") when the notification carries one, and the result
 // is refused if it lands more than ambientPastGrace in the past. A bare start
 // time gets DefaultReminderDuration.
-//
-// The clock reading is a wall clock in the daemon's local zone. See
-// EventFromNotificationIn.
 func EventFromNotification(n Notification) (Event, bool) {
-	return EventFromNotificationIn(n, time.Local)
-}
-
-// EventFromNotificationIn is EventFromNotification against an explicit zone.
-//
-// "созвон в 14:30" carries no zone, and nobody writing a phone notification
-// means 14:30Z. The wall clock used to be resolved against Posted's own zone,
-// and a phone posts an RFC 3339 instant ending in Z, so every ambient meeting
-// on this box landed four hours late. The size of the error is the deploy's UTC
-// offset, which is why it is invisible on a UTC box and wrong everywhere else.
-//
-// Posted stays an instant in its own zone: it says when the phone showed the
-// notification, and the past-grace check compares instants. Only the day and
-// the wall clock are read in loc.
-func EventFromNotificationIn(n Notification, loc *time.Location) (Event, bool) {
-	if loc == nil {
-		loc = time.Local
-	}
 	if n.Posted.IsZero() {
 		return Event{}, false
 	}
@@ -103,9 +82,8 @@ func EventFromNotificationIn(n Notification, loc *time.Location) (Event, bool) {
 		return Event{}, false
 	}
 
-	// The day is Posted's LOCAL day: a notification posted at 23:30Z saying
-	// "завтра в 09:00" is already tomorrow where he is standing.
-	y, m, d := n.Posted.In(loc).AddDate(0, 0, dayOffset(line)).Date()
+	y, m, d := n.Posted.AddDate(0, 0, dayOffset(line)).Date()
+	loc := n.Posted.Location()
 	s := time.Date(y, m, d, start.hour, start.min, 0, 0, loc)
 	// Too far in the past to be the meeting this notification is about. The day
 	// was inferred, so the honest reading is that the inference was wrong.

internal/calendar/ambient_test.go

@@ -74,12 +74,12 @@ func TestEventFromNotification(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			ev, ok := EventFromNotificationIn(Notification{
+			ev, ok := EventFromNotification(Notification{
 				Package: "com.google.android.gm",
 				Title:   tt.title,
 				Text:    tt.text,
 				Posted:  posted,
-			}, posted.Location())
+			})
 			if ok != tt.wantOK {
 				t.Fatalf("ok = %v, want %v (event %+v)", ok, tt.wantOK, ev)
 			}
@@ -98,8 +98,8 @@ func TestEventFromNotification(t *testing.T) {
 			if !ev.End.After(ev.Start) {
 				t.Errorf("end %v must be after start %v", ev.End, ev.Start)
 			}
-			// The event lands on the day the phone showed it, in the zone it
-			// was resolved against — never shifted into UTC.
+			// The event lands on the day the phone showed it, in the phone's
+			// location — not shifted into UTC.
 			if ev.Start.Location() != posted.Location() {
 				t.Errorf("location = %v, want %v", ev.Start.Location(), posted.Location())
 			}
@@ -162,10 +162,10 @@ func TestEventFromNotificationDayWords(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			ev, ok := EventFromNotificationIn(Notification{
+			ev, ok := EventFromNotification(Notification{
 				Package: "com.google.android.calendar",
 				Title:   tt.title, Text: tt.text, Posted: tt.posted,
-			}, tt.posted.Location())
+			})
 			if ok != tt.wantOK {
 				t.Fatalf("ok = %v, want %v (event %+v)", ok, tt.wantOK, ev)
 			}
@@ -189,10 +189,10 @@ func TestEventFromNotificationDayWords(t *testing.T) {
 // summary makes "Завтра Планёрка" the name of the meeting, and FactKey folds
 // that into the key.
 func TestEventFromNotificationDropsDayWordFromSummary(t *testing.T) {
-	ev, ok := EventFromNotificationIn(Notification{
+	ev, ok := EventFromNotification(Notification{
 		Title:  "Завтра Планёрка 09:00",
 		Posted: time.Date(2026, 8, 3, 21, 0, 0, 0, time.UTC),
-	}, time.UTC)
+	})
 	if !ok {
 		t.Fatal("expected an event")
 	}
@@ -209,10 +209,10 @@ func TestEventFromNotificationNeedsPostedAt(t *testing.T) {
 
 // An ambient event must never be indistinguishable from a calendar read.
 func TestAmbientEventsAreStoredAtReducedConfidence(t *testing.T) {
-	ev, ok := EventFromNotificationIn(Notification{
+	ev, ok := EventFromNotification(Notification{
 		Title:  "Планёрка 10:00-10:30",
 		Posted: time.Date(2026, 8, 3, 9, 0, 0, 0, time.UTC),
-	}, time.UTC)
+	})
 	if !ok {
 		t.Fatal("expected an event")
 	}
@@ -237,52 +237,3 @@ func TestStripClock(t *testing.T) {
 		}
 	}
 }
-
-// The defect this file's zone handling exists for: a phone posts an RFC 3339
-// instant ending in Z, and "созвон в 14:30" used to be resolved against that
-// Z, so on a UTC+4 box the meeting was stored at 18:30. A wall clock in a
-// notification is local by construction.
-func TestNotificationClockIsLocalNotUTC(t *testing.T) {
-	samara := time.FixedZone("+04", 4*3600)
-	n := Notification{
-		Package: "com.slack",
-		Title:   "Standup",
-		Text:    "созвон в 14:30",
-		Posted:  time.Date(2026, 8, 2, 9, 0, 0, 0, time.UTC), // 13:00 local
-	}
-	ev, ok := EventFromNotificationIn(n, samara)
-	if !ok {
-		t.Fatal("expected an event")
-	}
-	if got := ev.Start.Format("15:04"); got != "14:30" {
-		t.Errorf("start = %s local, want 14:30", got)
-	}
-	if got := ev.Start.UTC().Format("15:04"); got != "10:30" {
-		t.Errorf("start = %sZ, want 10:30Z (14:30 at UTC+4)", got)
-	}
-	if ev.Start.Location() != samara {
-		t.Errorf("location = %v, want %v", ev.Start.Location(), samara)
-	}
-	// The stored key is the local day, so it files under the day he lived.
-	if want, got := "calendar_event_20260802_Standup", FactKeyIn(ev, samara); got != want {
-		t.Errorf("FactKey = %q, want %q", got, want)
-	}
-}
-
-// A notification posted late in the UTC evening is already the next day where
-// he is standing. The day must come from the local clock, not from Posted's.
-func TestNotificationDayIsTheLocalDay(t *testing.T) {
-	samara := time.FixedZone("+04", 4*3600)
-	n := Notification{
-		Title:  "Планёрка 09:00",
-		Text:   "завтра",
-		Posted: time.Date(2026, 8, 2, 21, 0, 0, 0, time.UTC), // 03-08 01:00 local
-	}
-	ev, ok := EventFromNotificationIn(n, samara)
-	if !ok {
-		t.Fatal("expected an event")
-	}
-	if y, m, d := ev.Start.Date(); y != 2026 || m != time.August || d != 4 {
-		t.Errorf("date = %d-%02d-%02d, want 2026-08-04 (tomorrow, locally)", y, m, d)
-	}
-}

internal/config/config.go

@@ -149,11 +149,10 @@ type Config struct {
 	//
 	// Rules are code, not config (see loop.DefaultRules), and that stays true:
 	// this only subtracts. It exists because a rule can be right in principle
-	// and useless in practice. service_down was the case that forced it: it
-	// could not name the service it was nudging about, so being told "a service
-	// on homesrv is down" every fifteen minutes was noise with no action
-	// attached. That is fixed — one fact per kuma monitor — and the rule ships
-	// enabled again. The escape hatch stays.
+	// and useless in practice — kuma's service_down cannot name the service it
+	// is nudging about (Vikunja #444), so being told "a service on homesrv is
+	// down" every fifteen minutes is noise with no action attached. Turning it
+	// off beats learning to ignore her.
 	//
 	// A disabled rule is never gathered for, never evaluated, and never
 	// delivered on any channel. Unknown names are ignored, so removing a rule

internal/loop/explain_test.go

@@ -103,7 +103,7 @@ func TestExplainGate_PresenceAway(t *testing.T) {
 func TestExplainGate_PresenceAwayOpsBypass(t *testing.T) {
 	now := refTime()
 	s := State{Now: now, Presence: store.Away,
-		Facts: map[string]store.Fact{"service_down:db": factAt("service_down:db", "poll:uptimekuma", `"down"`, now.Add(-1*time.Minute))},
+		Facts: map[string]store.Fact{"service_down": factAt("service_down", "poll:uptimekuma", `"down"`, now.Add(-1*time.Minute))},
 	}
 	r := ServiceDownRule() // Sev4 ops
 	passed, blocked, d := ExplainGate(s, r)
@@ -259,8 +259,8 @@ func TestExplainTick_WinnerRecorded(t *testing.T) {
 		Now:      now,
 		Presence: store.Present,
 		Facts: map[string]store.Fact{
-			"water":           factAt("water", "tap:water", `"250ml"`, now.Add(-4*time.Hour)),
-			"service_down:db": factAt("service_down:db", "poll:uptimekuma", `"down"`, now.Add(-1*time.Minute)),
+			"water":        factAt("water", "tap:water", `"250ml"`, now.Add(-4*time.Hour)),
+			"service_down": factAt("service_down", "poll:uptimekuma", `"down"`, now.Add(-1*time.Minute)),
 		},
 	}
 	cand, trace := ExplainTick(s, DefaultRules())

internal/loop/gate_test.go

@@ -198,12 +198,12 @@ func TestTickNeverDogpilesAndPicksLoudest(t *testing.T) {
 		Now:      now,
 		Presence: store.Present,
 		Facts: map[string]store.Fact{
-			"water":           ago("water", "tap:water", `"250ml"`, 5*time.Hour),
-			"meal":            ago("meal", "voice", `"lunch"`, 8*time.Hour),
-			"desk_active":     ago("desk_active", "infer:hyprland", "1", 30*time.Second),
-			"break":           ago("break", "voice", `"walk"`, 3*time.Hour),
-			"service_down:db": ago("service_down:db", "poll:uptimekuma", `"down"`, time.Minute),
-			"netdata_alarm":   ago("netdata_alarm", "poll:netdata", `"critical"`, time.Minute),
+			"water":         ago("water", "tap:water", `"250ml"`, 5*time.Hour),
+			"meal":          ago("meal", "voice", `"lunch"`, 8*time.Hour),
+			"desk_active":   ago("desk_active", "infer:hyprland", "1", 30*time.Second),
+			"break":         ago("break", "voice", `"walk"`, 3*time.Hour),
+			"service_down":  ago("service_down", "poll:uptimekuma", `"down"`, time.Minute),
+			"netdata_alarm": ago("netdata_alarm", "poll:netdata", `"critical"`, time.Minute),
 		},
 	}
 	// sanity: every rule really does want to fire, so the pick is a real choice.

internal/loop/gather.go

@@ -91,20 +91,6 @@ func (g *Gatherer) GatherState(ctx context.Context, now time.Time) (State, []sto
 		return State{}, nil, err
 	}
 
-	// prefix families — the keys a rule cannot name at wiring time (one fact
-	// per kuma monitor). Loaded into the same map; State.FactsUnder reads them.
-	for _, r := range g.rules {
-		for _, p := range r.WantPrefixes {
-			fam, err := g.store.LatestFactsByPrefix(ctx, p)
-			if err != nil {
-				return State{}, nil, err
-			}
-			for _, f := range fam {
-				facts[f.Key] = f
-			}
-		}
-	}
-
 	// last nudge per rule + cooldown-until derived from the active cooldown.
 	// "active" = the feedback tuner's persisted base if one exists, else the
 	// rule's static Base. LatestFactBySource is the trust-by-provenance read

internal/loop/gather_test.go

@@ -1,47 +0,0 @@
-package loop
-
-import (
-	"context"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/kami/maven/internal/store"
-)
-
-// The gatherer is the only impure piece, and a rule over a prefix has no keys
-// to declare at wiring time. This is the end of that path: mavpoll's per-monitor
-// facts reach the snapshot, and the rule fires on the one that is down.
-func TestGatherStateLoadsPrefixFamilies(t *testing.T) {
-	ctx := context.Background()
-	s, err := store.Open(ctx, filepath.Join(t.TempDir(), "loop_test.db"))
-	if err != nil {
-		t.Fatalf("Open: %v", err)
-	}
-	t.Cleanup(func() { _ = s.Close() })
-
-	now := time.Now().UTC().Truncate(time.Millisecond)
-	for key, val := range map[string]string{
-		"service_down:db":  "down",
-		"service_down:web": "up",
-	} {
-		if _, err := s.SetValue(ctx, store.KindEnv, key, ServiceDownSource, val, now.Add(-time.Minute)); err != nil {
-			t.Fatalf("SetValue %s: %v", key, err)
-		}
-	}
-
-	rules := []Rule{ServiceDownRule()}
-	st, _, err := NewGatherer(s, rules).GatherState(ctx, now)
-	if err != nil {
-		t.Fatalf("GatherState: %v", err)
-	}
-	if _, ok := st.Facts["service_down:db"]; !ok {
-		t.Fatalf("prefix family not gathered: %v", st.Facts)
-	}
-	if got := DownServices(st); len(got) != 1 || got[0] != "db" {
-		t.Fatalf("DownServices = %v, want [db]", got)
-	}
-	if !rules[0].Predicate(st) {
-		t.Fatal("the rule must fire on a gathered per-monitor fact")
-	}
-}

internal/loop/loop_test.go

@@ -82,7 +82,7 @@ func TestTickOpsHardSurvivesAwayAndQuiet(t *testing.T) {
 		Presence:   store.Away,
 		QuietHours: true,
 		Facts: map[string]store.Fact{
-			"service_down:db": factAt("service_down:db", "poll:uptimekuma", `"down"`, now.Add(-1*time.Minute)),
+			"service_down": factAt("service_down", "poll:uptimekuma", `"down"`, now.Add(-1*time.Minute)),
 		},
 	}
 	got := Tick(s, DefaultRules())
@@ -99,7 +99,7 @@ func TestTickServiceSourceTrustRefusesForgedTrigger(t *testing.T) {
 		Now:      now,
 		Presence: store.Present,
 		Facts: map[string]store.Fact{
-			"service_down:db": factAt("service_down:db", "ambient", `"down"`, now.Add(-1*time.Minute)),
+			"service_down": factAt("service_down", "ambient", `"down"`, now.Add(-1*time.Minute)),
 		},
 	}
 	if got := Tick(s, DefaultRules()); got != nil {
@@ -115,8 +115,8 @@ func TestTickOneNudgePerTickMaxSeverityWins(t *testing.T) {
 		Now:      now,
 		Presence: store.Present,
 		Facts: map[string]store.Fact{
-			"water":           factAt("water", "tap:water", `"250ml"`, now.Add(-4*time.Hour)),
-			"service_down:db": factAt("service_down:db", "poll:uptimekuma", `"down"`, now.Add(-1*time.Minute)),
+			"water":        factAt("water", "tap:water", `"250ml"`, now.Add(-4*time.Hour)),
+			"service_down": factAt("service_down", "poll:uptimekuma", `"down"`, now.Add(-1*time.Minute)),
 		},
 	}
 	got := Tick(s, DefaultRules())

internal/loop/rules.go

@@ -28,13 +28,6 @@ type Rule struct {
 	// that check itself, leave this empty. Otherwise set to the key(s) the rule
 	// needs and the gate will skip the rule when any are missing.
 	InertWhenNoData []string
-
-	// WantPrefixes — key prefixes whose whole family the gatherer must load.
-	// InertWhenNoData names keys that exist at wiring time; a rule over a key
-	// set that is only known at read time (one fact per kuma monitor) declares
-	// the prefix here instead. Prefixes never make a rule inert: an empty
-	// family is the predicate's own "no data" case.
-	WantPrefixes []string
 }
 
 // Cooldown — tunable bounded by the envelope so a weird week (auto-tuned) can't
@@ -105,58 +98,23 @@ func BreakRule() Rule {
 	}
 }
 
-// ServiceDownPrefix — mavpoll writes one fact per kuma monitor under this
-// prefix, `service_down:<monitor name>`. The suffix is the name he hears.
-const ServiceDownPrefix = "service_down:"
-
-// ServiceDownSource — kuma is the source of truth for service up/down. The
-// rule is provenance-scoped: a poller writing under a different source cannot
-// forge the trigger.
-const ServiceDownSource = "poll:uptimekuma"
-
-// DownServices — the monitors currently reading "down", by name, in key order.
-//
-// Pure, and the rule and the phraser both call it, so the message can never
-// name a service the predicate did not fire on.
-func DownServices(s State) []string {
-	var out []string
-	for _, f := range s.FactsUnder(ServiceDownPrefix) {
-		if f.Source == ServiceDownSource && f.Value == `"down"` {
-			out = append(out, strings.TrimPrefix(f.Key, ServiceDownPrefix))
-		}
-	}
-	return out
-}
-
-// ServiceDownRule — sev4 ops hard: at least one kuma monitor reads "down".
-//
-// It used to read one aggregate `service_down` fact, which is why it was
-// disabled in deploy: the nudge could say that something on homesrv was down
-// but never which thing. Per-monitor facts fix that, and pausing a monitor in
-// kuma now silences that monitor rather than nothing.
-//
-// Edge-triggered — see State.NudgedSince. Without it a service that stays down
-// for a day qualifies on every tick and cooldown alone is the only brake.
+// ServiceDownRule — sev4 ops hard: the `service_down` aggregate fact reads
+// "down". Source must be poll:uptimekuma — kuma is the source of truth for
+// service up/down (mavpoll writes this key). The predicate is provenance-scoped:
+// a compromised poller writing under a different source can't forge the trigger.
 func ServiceDownRule() Rule {
 	return Rule{
-		Name:         "service_down",
-		Severity:     Sev4,
-		Cooldown:     Cooldown{Base: 15 * time.Minute, Min: 5 * time.Minute, Max: 1 * time.Hour},
-		WantPrefixes: []string{ServiceDownPrefix},
+		Name:            "service_down",
+		Severity:        Sev4,
+		Cooldown:        Cooldown{Base: 15 * time.Minute, Min: 5 * time.Minute, Max: 1 * time.Hour},
+		InertWhenNoData: []string{"service_down"},
 		Predicate: func(s State) bool {
-			var newest time.Time
-			for _, f := range s.FactsUnder(ServiceDownPrefix) {
-				if f.Source != ServiceDownSource || f.Value != `"down"` {
-					continue
-				}
-				if f.Ts.After(newest) {
-					newest = f.Ts
-				}
+			f, ok := s.Fact("service_down")
+			if !ok || f.Ts.IsZero() {
+				return false
 			}
-			if newest.IsZero() {
-				return false // nothing down, or no data at all → shut up
-			}
-			return !s.NudgedSince("service_down", newest)
+			// value is json `"down"`; trivial check keyed off source provenance.
+			return f.Source == "poll:uptimekuma" && f.Value == `"down"`
 		},
 	}
 }

internal/loop/rules_test.go

@@ -193,13 +193,13 @@ func TestOpsRulePredicates(t *testing.T) {
 		{
 			name:  "service_down fires on a kuma down fact",
 			rule:  ServiceDownRule(),
-			facts: map[string]store.Fact{"service_down:db": ago("service_down:db", "poll:uptimekuma", `"down"`, time.Minute)},
+			facts: map[string]store.Fact{"service_down": ago("service_down", "poll:uptimekuma", `"down"`, time.Minute)},
 			want:  true,
 		},
 		{
 			name:  "service_down quiet when kuma says up",
 			rule:  ServiceDownRule(),
-			facts: map[string]store.Fact{"service_down:db": ago("service_down:db", "poll:uptimekuma", `"up"`, time.Minute)},
+			facts: map[string]store.Fact{"service_down": ago("service_down", "poll:uptimekuma", `"up"`, time.Minute)},
 			want:  false,
 		},
 		{
@@ -211,38 +211,38 @@ func TestOpsRulePredicates(t *testing.T) {
 		{
 			name:  "service_down quiet on a zero-timestamp fact",
 			rule:  ServiceDownRule(),
-			facts: map[string]store.Fact{"service_down:db": {Key: "service_down:db", Source: "poll:uptimekuma", Value: `"down"`}},
+			facts: map[string]store.Fact{"service_down": {Key: "service_down", Source: "poll:uptimekuma", Value: `"down"`}},
 			want:  false,
 		},
 		// forgery attempts — right value, wrong writer.
 		{
 			name:  "service_down refuses a forgery from the netdata poller",
 			rule:  ServiceDownRule(),
-			facts: map[string]store.Fact{"service_down:db": ago("service_down:db", "poll:netdata", `"down"`, time.Minute)},
+			facts: map[string]store.Fact{"service_down": ago("service_down", "poll:netdata", `"down"`, time.Minute)},
 			want:  false,
 		},
 		{
 			name:  "service_down refuses a forgery from ambient audio",
 			rule:  ServiceDownRule(),
-			facts: map[string]store.Fact{"service_down:db": ago("service_down:db", "ambient:other", `"down"`, time.Minute)},
+			facts: map[string]store.Fact{"service_down": ago("service_down", "ambient:other", `"down"`, time.Minute)},
 			want:  false,
 		},
 		{
 			name:  "service_down refuses a forgery from the user's own voice",
 			rule:  ServiceDownRule(),
-			facts: map[string]store.Fact{"service_down:db": ago("service_down:db", "voice", `"down"`, time.Minute)},
+			facts: map[string]store.Fact{"service_down": ago("service_down", "voice", `"down"`, time.Minute)},
 			want:  false,
 		},
 		{
 			name:  "service_down refuses a source that only looks like kuma",
 			rule:  ServiceDownRule(),
-			facts: map[string]store.Fact{"service_down:db": ago("service_down:db", "poll:uptimekuma-staging", `"down"`, time.Minute)},
+			facts: map[string]store.Fact{"service_down": ago("service_down", "poll:uptimekuma-staging", `"down"`, time.Minute)},
 			want:  false,
 		},
 		{
 			name:  "service_down refuses an unquoted down value",
 			rule:  ServiceDownRule(),
-			facts: map[string]store.Fact{"service_down:db": ago("service_down:db", "poll:uptimekuma", `down`, time.Minute)},
+			facts: map[string]store.Fact{"service_down": ago("service_down", "poll:uptimekuma", `down`, time.Minute)},
 			want:  false,
 		},
 
@@ -312,11 +312,9 @@ func TestOpsRulePredicates(t *testing.T) {
 // a second no-data backstop, so a rule that forgets it loses the safety net
 // even if its predicate happens to check.
 func TestDefaultRulesDeclareInertKeys(t *testing.T) {
-	// A rule over a key set that only exists at read time declares a prefix
-	// instead — the gatherer still needs to be told what to load.
 	for _, r := range DefaultRules() {
-		if len(r.InertWhenNoData) == 0 && len(r.WantPrefixes) == 0 {
-			t.Errorf("rule %q declares neither InertWhenNoData keys nor WantPrefixes", r.Name)
+		if len(r.InertWhenNoData) == 0 {
+			t.Errorf("rule %q declares no InertWhenNoData keys", r.Name)
 		}
 	}
 }
@@ -379,11 +377,11 @@ func TestDefaultRuleCooldownsAreBounded(t *testing.T) {
 // hidden state, no clock reads.
 func TestPredicatesArePure(t *testing.T) {
 	s := stateWith(map[string]store.Fact{
-		"water":           ago("water", "tap:water", `"250ml"`, 4*time.Hour),
-		"meal":            ago("meal", "voice", `"lunch"`, 7*time.Hour),
-		"desk_active":     ago("desk_active", "infer:hyprland", "1", 30*time.Second),
-		"break":           ago("break", "voice", `"walk"`, 2*time.Hour),
-		"service_down:db": ago("service_down:db", "poll:uptimekuma", `"down"`, time.Minute),
+		"water":        ago("water", "tap:water", `"250ml"`, 4*time.Hour),
+		"meal":         ago("meal", "voice", `"lunch"`, 7*time.Hour),
+		"desk_active":  ago("desk_active", "infer:hyprland", "1", 30*time.Second),
+		"break":        ago("break", "voice", `"walk"`, 2*time.Hour),
+		"service_down": ago("service_down", "poll:uptimekuma", `"down"`, time.Minute),
 	})
 	for _, r := range DefaultRules() {
 		first := r.Predicate(s)
@@ -436,66 +434,3 @@ func TestRulesExceptEmptyKeepsEverything(t *testing.T) {
 		t.Errorf("rules = %v, dropped = %v", ruleNames(rules), dropped)
 	}
 }
-
-// ---------------------------- per-monitor service_down -----------------------
-
-// The rule must name what fired on it, and the phraser reads the same helper,
-// so a service that is up can never be spoken as down.
-func TestDownServicesNamesOnlyTheDownOnes(t *testing.T) {
-	s := State{
-		Now: refTime(),
-		Facts: map[string]store.Fact{
-			"service_down:web":     ago("service_down:web", ServiceDownSource, `"up"`, time.Minute),
-			"service_down:db":      ago("service_down:db", ServiceDownSource, `"down"`, time.Minute),
-			"service_down:vault":   ago("service_down:vault", ServiceDownSource, `"down"`, time.Minute),
-			"service_down:paused":  ago("service_down:paused", ServiceDownSource, `"maintenance"`, time.Minute),
-			"service_down:forged":  ago("service_down:forged", "voice", `"down"`, time.Minute),
-			"service_down:missing": ago("service_down:missing", ServiceDownSource, `"unknown"`, time.Minute),
-		},
-	}
-	got := DownServices(s)
-	want := []string{"db", "vault"} // key order, so speech is stable
-	if len(got) != len(want) {
-		t.Fatalf("DownServices = %v, want %v", got, want)
-	}
-	for i := range want {
-		if got[i] != want[i] {
-			t.Fatalf("DownServices = %v, want %v", got, want)
-		}
-	}
-}
-
-// A monitor paused in kuma must silence that monitor. Before per-monitor facts
-// the aggregate stayed "down" and pausing achieved nothing.
-func TestPausedMonitorSilencesOnlyItself(t *testing.T) {
-	base := map[string]store.Fact{
-		"service_down:db":  ago("service_down:db", ServiceDownSource, `"maintenance"`, time.Minute),
-		"service_down:web": ago("service_down:web", ServiceDownSource, `"down"`, time.Minute),
-	}
-	if !ServiceDownRule().Predicate(State{Now: refTime(), Facts: base}) {
-		t.Fatal("web is still down, the rule must fire")
-	}
-	delete(base, "service_down:web")
-	if ServiceDownRule().Predicate(State{Now: refTime(), Facts: base}) {
-		t.Fatal("only a paused monitor is left, the rule must be quiet")
-	}
-}
-
-// Edge-triggered: he is told once per transition. A service that stays down
-// for a day used to qualify on every tick, with cooldown as the only brake.
-func TestServiceDownFiresOncePerTransition(t *testing.T) {
-	down := ago("service_down:db", ServiceDownSource, `"down"`, time.Hour)
-	s := State{Now: refTime(), Facts: map[string]store.Fact{"service_down:db": down}}
-	if !ServiceDownRule().Predicate(s) {
-		t.Fatal("first sight of the transition must fire")
-	}
-	s.LastNudge = map[string]store.Nudge{"service_down": {Ts: down.Ts.Add(time.Minute)}}
-	if ServiceDownRule().Predicate(s) {
-		t.Fatal("already told about this transition, must be quiet")
-	}
-	// A second service goes down after that nudge — a new edge, so it fires.
-	s.Facts["service_down:web"] = ago("service_down:web", ServiceDownSource, `"down"`, time.Minute)
-	if !ServiceDownRule().Predicate(s) {
-		t.Fatal("a later transition must fire again")
-	}
-}

internal/loop/state.go

@@ -23,8 +23,6 @@
 package loop
 
 import (
-	"sort"
-	"strings"
 	"time"
 
 	"github.com/kami/maven/internal/store"
@@ -97,32 +95,6 @@ func (s State) Fact(key string) (store.Fact, bool) {
 	return f, true
 }
 
-// FactsUnder returns every gathered fact whose key starts with prefix, ordered
-// by key so a caller that names them speaks them in a stable order. Facts with
-// a zero Ts are skipped, the same "no data" rule Fact applies.
-func (s State) FactsUnder(prefix string) []store.Fact {
-	var out []store.Fact
-	for k, f := range s.Facts {
-		if strings.HasPrefix(k, prefix) && !f.Ts.IsZero() {
-			out = append(out, f)
-		}
-	}
-	sort.Slice(out, func(i, j int) bool { return out[i].Key < out[j].Key })
-	return out
-}
-
-// NudgedSince reports whether rule already sent a nudge at or after ts.
-//
-// It is what makes a rule edge-triggered. A polled fact is written only when
-// the value changes, so its Ts is the moment the service went down — but the
-// predicate reads the current value, so a service that stays down keeps
-// qualifying forever and cooldown alone only slows the repetition. Asking
-// whether he was already told about THIS transition stops it.
-func (s State) NudgedSince(rule string, ts time.Time) bool {
-	n, ok := s.LastNudge[rule]
-	return ok && !n.Ts.Before(ts)
-}
-
 // Since returns the duration since the latest fact for key, or (0,false).
 // "false" ⇒ no data ⇒ shuts up when uncertain.
 func (s State) Since(key string) (time.Duration, bool) {

internal/phraser/llmphraser.go

@@ -975,9 +975,6 @@ var fallbackNudges = map[string]string{
 }
 
 func fallbackNudge(c loop.Candidate) string {
-	if down := loop.DownServices(c.State); len(down) > 0 {
-		return "Не отвечает: " + strings.Join(down, ", ") + "."
-	}
 	if s, ok := fallbackNudges[c.Rule.Name]; ok {
 		return s
 	}
@@ -993,11 +990,6 @@ func buildNudgePrompt(c loop.Candidate) string {
 	if f, ok := c.State.Facts[c.Rule.Name]; ok && f.Key != "" && f.Key != c.Rule.Name {
 		ctxParts = append(ctxParts, "Что именно: "+f.Key)
 	}
-	if down := loop.DownServices(c.State); len(down) > 0 {
-		// The names come from the same helper the rule fired on, so the model
-		// is never handed a service that is actually up.
-		ctxParts = append(ctxParts, "Какие сервисы лежат: "+strings.Join(down, ", "))
-	}
 	if d, ok := c.State.Since(c.Rule.Name); ok {
 		ctxParts = append(ctxParts, "Прошло: "+ruDur(d))
 	}

internal/phraser/phraser.go

@@ -142,21 +142,16 @@ func phraseNudge(c loop.Candidate) (body, summary string) {
 		}
 		return body, "take a break"
 	case "service_down":
-		// One fact per kuma monitor, so the nudge names the service. The rule
-		// and this share loop.DownServices, so the message cannot name a
-		// service the predicate did not fire on.
-		down := loop.DownServices(c.State)
-		switch len(down) {
-		case 0:
-			return "a service on homesrv is down — check journalctl.", "service down on homesrv"
-		case 1:
-			return fmt.Sprintf("%s on homesrv is down — check journalctl.", down[0]),
-				fmt.Sprintf("%s down on homesrv", down[0])
-		default:
-			list := strings.Join(down, ", ")
-			return fmt.Sprintf("%s on homesrv are down — check journalctl.", list),
-				fmt.Sprintf("%d services down on homesrv", len(down))
+		// the fact value is json `"down"`; the key carries the service name.
+		body = "a service on homesrv is down — check journalctl."
+		summary = "service down on homesrv"
+		if f, ok := c.State.Fact("service_down"); ok {
+			if f.Key != "" && f.Key != "service_down" {
+				body = fmt.Sprintf("%s on homesrv is down — check journalctl.", f.Key)
+				summary = fmt.Sprintf("%s down on homesrv", f.Key)
+			}
 		}
+		return body, summary
 	default:
 		// generic: name the rule + severity; the LLM impl replaces this with
 		// a prompted phrase. the Stub never editorializes beyond the rule name.

internal/phraser/phraser_test.go

@@ -78,14 +78,12 @@ func TestPhraseNudgeBreakDeskDuration(t *testing.T) {
 }
 
 func TestPhraseNudgeServiceDownNamedService(t *testing.T) {
-	// one fact per kuma monitor → the phrase names the monitor that is down.
+	// a service_down fact whose Key is the specific service name → the phrase
+	// names the service, not just "service down".
 	now := time.Now().UTC()
 	st := loop.State{
-		Now: now,
-		Facts: map[string]store.Fact{
-			"service_down:nginx": {Key: "service_down:nginx", Ts: now, Source: loop.ServiceDownSource, Value: `"down"`},
-			"service_down:db":    {Key: "service_down:db", Ts: now, Source: loop.ServiceDownSource, Value: `"up"`},
-		},
+		Now:   now,
+		Facts: map[string]store.Fact{"service_down": {Key: "nginx", Ts: now, Source: "poll:healthcheck", Value: `"down"`}},
 	}
 	c := loop.Candidate{Rule: loop.ServiceDownRule(), Severity: loop.Sev4, State: st}
 	pn, _ := NewStub().PhraseNudge(context.Background(), c)
@@ -98,12 +96,12 @@ func TestPhraseNudgeServiceDownNamedService(t *testing.T) {
 }
 
 func TestPhraseNudgeServiceDownGenericKey(t *testing.T) {
-	// the old aggregate key, still in the store from before the per-monitor
-	// facts landed → the generic phrase, never a phantom "service_down down".
+	// the rule key itself ("service_down") rather than a specific service →
+	// the generic phrase, not a phantom "service_down down on homesrv".
 	now := time.Now().UTC()
 	st := loop.State{
 		Now:   now,
-		Facts: map[string]store.Fact{"service_down": {Key: "service_down", Ts: now, Source: loop.ServiceDownSource, Value: `"down"`}},
+		Facts: map[string]store.Fact{"service_down": {Key: "service_down", Ts: now, Source: "poll:healthcheck", Value: `"down"`}},
 	}
 	c := loop.Candidate{Rule: loop.ServiceDownRule(), Severity: loop.Sev4, State: st}
 	pn, _ := NewStub().PhraseNudge(context.Background(), c)
@@ -112,26 +110,6 @@ func TestPhraseNudgeServiceDownGenericKey(t *testing.T) {
 	}
 }
 
-// Two monitors down at once must both be named — he needs to know the blast
-// radius, and "a service is down" was the whole defect being fixed here.
-func TestPhraseNudgeServiceDownNamesEveryDownMonitor(t *testing.T) {
-	now := time.Now().UTC()
-	st := loop.State{
-		Now: now,
-		Facts: map[string]store.Fact{
-			"service_down:nginx": {Key: "service_down:nginx", Ts: now, Source: loop.ServiceDownSource, Value: `"down"`},
-			"service_down:db":    {Key: "service_down:db", Ts: now, Source: loop.ServiceDownSource, Value: `"down"`},
-		},
-	}
-	c := loop.Candidate{Rule: loop.ServiceDownRule(), Severity: loop.Sev4, State: st}
-	pn, _ := NewStub().PhraseNudge(context.Background(), c)
-	for _, want := range []string{"nginx", "db"} {
-		if !strings.Contains(pn.Body, want) {
-			t.Fatalf("body should name %q, got %q", want, pn.Body)
-		}
-	}
-}
-
 func TestPhraseNudgeUnknownRuleFallsBack(t *testing.T) {
 	// a rule without a dedicated template — generic fallback names the rule +
 	// severity gist. never empty.

internal/router/complaint.go

@@ -0,0 +1,79 @@
+package router
+
+import "strings"
+
+// transientStems — the states a thing is in for an afternoon. Compared as
+// prefixes because Russian inflects the ending: "медленн" covers "медленная",
+// "медленный" and "медленно" without listing them.
+var transientStems = []string{
+	"медленн", "тормоз", "лаг", "завис", "виснет", "глюч", "барахл",
+	"отвал", "падает", "упал", "сдох", "греется", "перегре",
+	"slow", "laggy", "stuck", "frozen", "flaky", "broken", "down",
+}
+
+// brokenVerbs — what "не ..." is denying when the sentence is a complaint.
+// "не работает", "не грузит", "не открывается". Prefixes again.
+var brokenVerbs = []string{
+	"работ", "пашет", "груз", "открыва", "включа", "коннект", "подключ",
+	"work", "load", "connect", "respond",
+}
+
+// selfMarkers — the words that make a sentence about him rather than about a
+// thing. Their presence turns the test off, because losing a fact he meant to
+// store is worse than keeping a complaint: "я сломал руку" is durable, and
+// "интернет не работает" is not.
+var selfMarkers = []string{"я", "мне", "меня", "мной", "i", "me", "my"}
+
+// IsTransientComplaint reports whether text observes a passing state of some
+// thing rather than recording a fact.
+//
+// It exists because "сеть какая-то медленная" and "интернет не работает" were
+// written to the fact store as `self` rows at confidence 1.00 (Vikunja #481),
+// where recall reads them back later as if they were still true. A complaint
+// describes a moment; the fact store describes him.
+//
+// Deterministic, offline, and shaped exactly like IsQuestionShaped: an
+// explicit capture verb wins over everything, because "запомни что интернет
+// не работает" is an instruction and not a passing remark. A first-person
+// marker also turns it off — the test is meant to catch a sentence about a
+// thing, and it errs toward storing.
+func IsTransientComplaint(text string) bool {
+	t := strings.TrimSpace(text)
+	if t == "" {
+		return false
+	}
+	toks := planTokens(strings.ToLower(t))
+	for _, v := range captureVerbs {
+		if hasTok(toks, v) {
+			return false
+		}
+	}
+	for _, m := range selfMarkers {
+		if hasTok(toks, m) {
+			return false
+		}
+	}
+	for _, tok := range toks {
+		for _, stem := range transientStems {
+			if strings.HasPrefix(tok, stem) {
+				return true
+			}
+		}
+	}
+	// "не" plus a verb of working, in either order of the two tokens that
+	// follow it — "не работает" and "не очень работает" both deny the same
+	// thing.
+	for i, tok := range toks {
+		if tok != "не" && tok != "not" && tok != "isn" {
+			continue
+		}
+		for j := i + 1; j < len(toks) && j <= i+2; j++ {
+			for _, v := range brokenVerbs {
+				if strings.HasPrefix(toks[j], v) {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}

internal/router/complaint_test.go

@@ -0,0 +1,35 @@
+package router
+
+import "testing"
+
+func TestIsTransientComplaint(t *testing.T) {
+	for _, tc := range []struct {
+		text string
+		want bool
+	}{
+		// The two rows from the QA run that named this bug.
+		{"сеть какая-то медленная", true},
+		{"интернет не работает", true},
+		{"вайфай тормозит", true},
+		{"сервер завис", true},
+		{"the wifi is slow", true},
+
+		// An instruction wins: he asked for it to be written down.
+		{"запомни что интернет не работает", false},
+		{"запиши что сеть медленная", false},
+
+		// About him, so it stays a fact even when it sounds like a complaint.
+		{"я сломал руку", false},
+		{"мне медленно думается", false},
+
+		// Ordinary captures must not be touched.
+		{"поужинал", false},
+		{"выпил воды", false},
+		{"машина на парковке", false},
+		{"", false},
+	} {
+		if got := IsTransientComplaint(tc.text); got != tc.want {
+			t.Errorf("IsTransientComplaint(%q) = %v, want %v", tc.text, got, tc.want)
+		}
+	}
+}

internal/router/dateparser.go

@@ -81,6 +81,9 @@ func NewPythonDateParser() *PythonDateParser {
 // or dateparser is unavailable, falls back to the stub parser. Returns
 // (time, true, nil) on success; (zero, false, nil) when no date is found.
 func (p *PythonDateParser) Parse(ctx context.Context, text string, now time.Time) (time.Time, bool, error) {
+	// Speech says the hour in words, and neither this parser nor the stub
+	// reads "в семь вечера" (Vikunja #469). Both see the digits instead.
+	text = SpellOutDigits(text)
 	t, ok, err := p.parseWithPython(ctx, text, now)
 	if err != nil {
 		// python3 missing, dateparser not installed, or process failure —

internal/router/eval/eval_test.go

@@ -236,6 +236,7 @@ func newBaselineRouter(t *testing.T, emb router.Embedder, llmR *router.LLMRouter
 	// Same order as buildRouter (voicewire.go). The fixture is only worth
 	// anything while its grammar set is the daemon's grammar set.
 	grammars = append(grammars, router.AgendaQueryGrammars()...)
+	grammars = append(grammars, router.FeedQueryGrammar())
 	grammars = append(grammars, router.ReminderGrammar())
 	return router.New(router.Config{
 		Grammars:   grammars,

internal/router/feedgrammar_test.go

@@ -0,0 +1,55 @@
+package router
+
+import (
+	"context"
+	"testing"
+)
+
+func feedRouter(t *testing.T) *Router {
+	t.Helper()
+	r := newTestRouter(t, 0.0)
+	r.grammars = append(r.grammars, SystemTimeDateGrammars()...)
+	r.grammars = append(r.grammars, AgendaQueryGrammars()...)
+	r.grammars = append(r.grammars, FeedQueryGrammar())
+	return r
+}
+
+// The documented utterance of task 258 step 1 routed system and answered
+// "пока не умею отвечать на этот вопрос.", while the same question worded with
+// "новостях" worked (Vikunja #474).
+func TestFeedQuestionsRouteToQuery(t *testing.T) {
+	r := feedRouter(t)
+	for _, u := range []string{
+		"что нового в лентах?",
+		"что в лентах?",
+		"расскажи что в новостных лентах",
+		"покажи ленту",
+	} {
+		d, err := r.Route(context.Background(), u, refNow())
+		if err != nil {
+			t.Fatalf("route(%q): %v", u, err)
+		}
+		if d.Intent != IntentQuery {
+			t.Errorf("route(%q) = %s, want query", u, d.Intent)
+		}
+	}
+}
+
+// The greeting and the statement keep their intents. "что нового?" is the most
+// common opener in the language, and a rule that claimed it would answer hello
+// with a configuration status.
+func TestFeedGrammarLeavesTheGreetingAlone(t *testing.T) {
+	r := feedRouter(t)
+	for _, u := range []string{
+		"что нового?",
+		"у меня новая лента в инстаграме",
+	} {
+		d, err := r.Route(context.Background(), u, refNow())
+		if err != nil {
+			t.Fatalf("route(%q): %v", u, err)
+		}
+		if d.Stage == 0 {
+			t.Errorf("route(%q) was claimed at stage 0 as %s", u, d.Intent)
+		}
+	}
+}

internal/router/numwords.go

@@ -0,0 +1,97 @@
+package router
+
+import "strings"
+
+// ruNumerals — spoken numbers as digits, for the clock hours and the minutes
+// that follow them. Every case ending he might say is listed rather than
+// stemmed: "в семь", "к семи", "около семи" are three forms of one hour, and a
+// prefix rule short enough to cover them also matches "семья".
+//
+// Stops at thirty, which is as far as a spoken time goes ("без двадцати
+// восемь", "в половине шестого"). Anything larger is said in digits.
+var ruNumerals = map[string]string{
+	"один": "1", "одного": "1", "одну": "1", "час": "1", "часу": "1",
+	"два": "2", "две": "2", "двух": "2",
+	"три": "3", "трёх": "3", "трех": "3",
+	"четыре": "4", "четырёх": "4", "четырех": "4",
+	"пять": "5", "пяти": "5",
+	"шесть": "6", "шести": "6",
+	"семь": "7", "семи": "7",
+	"восемь": "8", "восьми": "8",
+	"девять": "9", "девяти": "9",
+	"десять": "10", "десяти": "10",
+	"одиннадцать": "11", "одиннадцати": "11",
+	"двенадцать": "12", "двенадцати": "12",
+	"тринадцать": "13", "тринадцати": "13",
+	"четырнадцать": "14", "четырнадцати": "14",
+	"пятнадцать": "15", "пятнадцати": "15",
+	"шестнадцать": "16", "шестнадцати": "16",
+	"семнадцать": "17", "семнадцати": "17",
+	"восемнадцать": "18", "восемнадцати": "18",
+	"девятнадцать": "19", "девятнадцати": "19",
+	"двадцать": "20", "двадцати": "20",
+	"тридцать": "30", "тридцати": "30",
+	"сорок": "40", "сорока": "40",
+	"пятьдесят": "50", "пятидесяти": "50",
+}
+
+// numeralContext — the words that make a numeral a time. A numeral is only
+// rewritten when one of these sits next to it, so "три яблока" in a note is
+// left alone and "в три часа" is not.
+var numeralContext = map[string]bool{
+	"в": true, "во": true, "к": true, "около": true, "на": true,
+	"часа": true, "часов": true, "час": true, "часу": true,
+	"утра": true, "вечера": true, "дня": true, "ночи": true,
+	"минут": true, "минуты": true, "минуту": true,
+	"at": true, "by": true,
+}
+
+// SpellOutDigits rewrites spoken numbers as digits so the date parsers see the
+// shape they know.
+//
+// "напомни мне позвонить маме в семь вечера" parsed to nothing, while "в 19:00"
+// parsed fine (Vikunja #469). Speech is where reminders come from, and speech
+// says the hour in words, so this is not a long-tail case — it is the ordinary
+// one. dateparser reads "в 7 вечера" through the qualifier rewrite the python
+// script already does; it does not read "в семь вечера".
+//
+// Conservative by construction: a numeral is only rewritten when a time word
+// stands beside it. "три часа" becomes "3 часа"; "три яблока" stays as it is,
+// and a note or a fact carrying a spoken number is untouched.
+func SpellOutDigits(text string) string {
+	toks := strings.Fields(text)
+	if len(toks) == 0 {
+		return text
+	}
+	out := make([]string, len(toks))
+	copy(out, toks)
+	for i, tok := range toks {
+		key := strings.ToLower(strings.Trim(tok, ".,!?;:«»\"'"))
+		digit, ok := ruNumerals[key]
+		if !ok {
+			continue
+		}
+		// "час" and "часу" are the hour noun as often as they are the number
+		// one, and rewriting "в час дня" to "в 1 дня" is right either way. What
+		// must not happen is rewriting the noun that gives another numeral its
+		// context: "в семь часов" must keep "часов".
+		if !hasTimeNeighbour(toks, i) {
+			continue
+		}
+		out[i] = digit
+	}
+	return strings.Join(out, " ")
+}
+
+// hasTimeNeighbour reports whether the token before or after i is a time word.
+func hasTimeNeighbour(toks []string, i int) bool {
+	for _, j := range []int{i - 1, i + 1} {
+		if j < 0 || j >= len(toks) {
+			continue
+		}
+		if numeralContext[strings.ToLower(strings.Trim(toks[j], ".,!?;:«»\"'"))] {
+			return true
+		}
+	}
+	return false
+}

internal/router/numwords_test.go

@@ -0,0 +1,38 @@
+package router
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func TestSpellOutDigits(t *testing.T) {
+	for _, tc := range []struct{ in, want string }{
+		{"напомни мне позвонить маме в семь вечера", "напомни мне позвонить маме в 7 вечера"},
+		{"в три часа дня", "в 3 часа дня"},
+		{"напомни в половине шестого", "напомни в половине шестого"},
+		{"через двадцать минут", "через 20 минут"},
+		// Untouched: no time word stands beside the number.
+		{"купить три яблока", "купить три яблока"},
+		{"семь раз отмерь", "семь раз отмерь"},
+		{"напомни в 19:00", "напомни в 19:00"},
+		{"", ""},
+	} {
+		if got := SpellOutDigits(tc.in); got != tc.want {
+			t.Errorf("SpellOutDigits(%q) = %q, want %q", tc.in, got, tc.want)
+		}
+	}
+}
+
+// The utterance from the QA sitting that named this bug: the numeric form
+// parsed and the spoken form did not.
+func TestStubParsesASpokenHour(t *testing.T) {
+	now := time.Date(2026, 8, 2, 9, 0, 0, 0, time.Local)
+	got, ok, err := StubDateTimeParser{}.Parse(context.Background(), "напомни мне позвонить маме в семь вечера", now)
+	if err != nil || !ok {
+		t.Fatalf("Parse ok=%v err=%v, want a time", ok, err)
+	}
+	if got.Hour() != 19 {
+		t.Fatalf("hour = %d, want 19", got.Hour())
+	}
+}

internal/router/slots.go

@@ -176,7 +176,7 @@ func afterWord(s, w string) string {
 type StubDateTimeParser struct{}
 
 func (StubDateTimeParser) Parse(_ context.Context, text string, now time.Time) (time.Time, bool, error) {
-	s := strings.ToLower(strings.TrimSpace(text))
+	s := strings.ToLower(strings.TrimSpace(SpellOutDigits(text)))
 	toks := strings.Fields(s)
 	// scan for "in <num> <unit>" anywhere — dateparser extracts the datetime
 	// expression from surrounding text; the stub does the same naively.
@@ -204,14 +204,22 @@ func (StubDateTimeParser) Parse(_ context.Context, text string, now time.Time) (
 
 	// --- Russian time expressions (stub floor; dateparser replaces) ---
 
-	// "в <clock>" anywhere — mirror of the English "at" scan.
+	// "в <clock>" anywhere — mirror of the English "at" scan. A qualifier
+	// after the hour moves it into the afternoon: "в 7 вечера" is 19:00, and
+	// with SpellOutDigits in front of this that is what "в семь вечера" reads
+	// as too (Vikunja #469).
 	for i := 0; i+1 < len(toks); i++ {
 		if toks[i] != "в" {
 			continue
 		}
-		if t, ok := parseClock(toks[i+1], now); ok {
-			return t, true, nil
+		t, ok := parseClock(toks[i+1], now)
+		if !ok {
+			continue
 		}
+		if i+2 < len(toks) {
+			t = applyRuQualifier(t, toks[i+2], now)
+		}
+		return t, true, nil
 	}
 
 	// "через <N> <unit>" / "через <unit>" (bare = 1) / "через полчаса".
@@ -476,3 +484,30 @@ func midnight(now time.Time, days int) time.Time {
 	y, m, d := now.AddDate(0, 0, days).Date()
 	return time.Date(y, m, d, 0, 0, 0, 0, now.Location())
 }
+
+// applyRuQualifier moves an hour into the afternoon when he said "вечера" or
+// "дня" after it. Noon-crossing only: 7 becomes 19, and 19 stays 19. Morning
+// qualifiers need no arithmetic, they only confirm the hour as spoken.
+//
+// The date is recomputed rather than shifted, so an hour that parseClock
+// already pushed to tomorrow does not land two days out.
+func applyRuQualifier(t time.Time, qualifier string, now time.Time) time.Time {
+	h := t.Hour()
+	switch strings.Trim(strings.ToLower(qualifier), ".,!?;:") {
+	case "вечера", "дня":
+		if h < 12 {
+			h += 12
+		}
+	case "утра", "ночи":
+		if h == 12 {
+			h = 0
+		}
+	default:
+		return t
+	}
+	out := time.Date(now.Year(), now.Month(), now.Day(), h, t.Minute(), 0, 0, now.Location())
+	if !out.After(now) {
+		out = out.Add(24 * time.Hour)
+	}
+	return out
+}

internal/router/stage0.go

@@ -208,13 +208,39 @@ func AgendaQueryGrammars() []Grammar {
 	}
 }
 
+// FeedQueryGrammar — stage-0 rule for "что нового в лентах?", routed to
+// IntentQuery so it reaches queryFeeds.
+//
+// Same shape of defect as the agenda grammars: the model calls it system, and
+// replySystem has no feeds arm, so the documented utterance of task 258 step 1
+// answered "пока не умею отвечать на этот вопрос." while the same question
+// worded with "новостях" worked (Vikunja #474).
+//
+// An ask word at the front and a feed noun after it are both required, which
+// is the same pair ParseFeedQuery wants. "что нового?" on its own is a greeting
+// — the most common opener in the language — and vagueNouns in feeds.go exists
+// to keep it out of the feed reader; routing it to query here would put it
+// back. "у меня новая лента в инстаграме" carries the noun without the ask and
+// stays the statement it is.
+func FeedQueryGrammar() Grammar {
+	return Grammar{
+		Name: "feed-query",
+		// (\s|[?!.]|$) rather than \b, which is ASCII-only and never fires next
+		// to a Cyrillic letter.
+		Pattern: regexp.MustCompile(`(?i)^\s*(что|какие|расскажи|покажи|почитай|прочитай)\s+.*(лент|новостн)[а-я]*(\s|[?!.]|$)`),
+		Build:   agendaQueryBuild,
+	}
+}
+
 // dayWordPattern — the day words an agenda question can name. Weekdays appear
 // in the accusative and prepositional forms the questions actually use ("в
 // среду", "на среде"), which is why the stems carry an inflection tail rather
 // than a fixed ending.
 const dayWordPattern = `(сегодня|завтра|послезавтра|выходн[а-я]+|недел[а-я]+|понедельник[а-я]*|вторник[а-я]*|сред[ауые][а-я]*|четверг[а-я]*|пятниц[ауые][а-я]*|суббот[ауые][а-я]*|воскресень[ея][а-я]*)`
 
-// agendaQueryBuild — shared Build for the agenda grammars. Confidence 1.0 on
+// agendaQueryBuild — shared Build for the agenda grammars and the feed one,
+// which all do the same single thing: keep the utterance out of IntentSystem
+// and let the query chain decide who answers it. Confidence 1.0 on
 // the intent only: the utterance travels intact and the query chain's own
 // matchers decide the rest.
 func agendaQueryBuild(m []string) (Decision, bool) {

internal/store/facts.go

@@ -254,41 +254,6 @@ func (s *Store) LatestFactBySource(ctx context.Context, key, source string) (Fac
 	return scanFact(row)
 }
 
-// LatestFactsByPrefix — the latest non-voided fact for every key that starts
-// with prefix, newest-per-key, ordered by key.
-//
-// The loop's gatherer loads the keys its rules declare, which works while the
-// key set is static. Kuma's monitors are not: one fact per monitor means the
-// keys are only known once the gauge is read, so the rule declares the prefix
-// and this read resolves it per tick. `_` and `%` are escaped — a monitor name
-// is user text and must not act as a LIKE wildcard.
-func (s *Store) LatestFactsByPrefix(ctx context.Context, prefix string) ([]Fact, error) {
-	esc := strings.NewReplacer(`\`, `\\`, `%`, `\%`, `_`, `\_`).Replace(prefix)
-	rows, err := s.db.QueryContext(ctx, `
-		SELECT id, ts, kind, key, value, source, confidence, voids_id
-		  FROM facts f
-		 WHERE key LIKE ? ESCAPE '\'
-		   AND id NOT IN (SELECT voids_id FROM facts WHERE voids_id IS NOT NULL)
-		   AND id = (SELECT id FROM facts g
-		              WHERE g.key = f.key
-		                AND g.id NOT IN (SELECT voids_id FROM facts WHERE voids_id IS NOT NULL)
-		              ORDER BY g.ts DESC, g.id DESC LIMIT 1)
-		 ORDER BY key`, esc+"%")
-	if err != nil {
-		return nil, fmt.Errorf("facts by prefix %q: %w", prefix, err)
-	}
-	defer rows.Close()
-	var out []Fact
-	for rows.Next() {
-		f, err := scanFact(rows)
-		if err != nil {
-			return nil, err
-		}
-		out = append(out, f)
-	}
-	return out, rows.Err()
-}
-
 // Since returns how long ago the latest non-voided fact for key landed, or
 // (0, ErrNoFact). Implements the `since(key)==null → don't fire` guard from
 // the spec — silence on no-data is "shuts up when uncertain".

internal/store/facts_test.go

@@ -1,62 +0,0 @@
-package store
-
-import (
-	"context"
-	"testing"
-	"time"
-)
-
-// One fact per kuma monitor means the loop cannot name its keys at wiring time,
-// so it asks for the family by prefix. The read must return the newest row per
-// key and stop at the prefix boundary.
-func TestLatestFactsByPrefix(t *testing.T) {
-	s := newTestStore(t)
-	ctx := context.Background()
-	now := time.Now().UTC().Truncate(time.Millisecond)
-	write := func(key, val string, at time.Time) int64 {
-		id, err := s.SetValue(ctx, KindEnv, key, "poll:uptimekuma", val, at)
-		if err != nil {
-			t.Fatalf("SetValue %s: %v", key, err)
-		}
-		return id
-	}
-	write("service_down:db", "up", now.Add(-2*time.Hour))
-	write("service_down:db", "down", now.Add(-time.Hour)) // newer wins
-	write("service_down:web", "up", now.Add(-time.Hour))
-	write("service_downtime", "irrelevant", now) // no colon, not in the family
-	write("water", "250ml", now)
-
-	got, err := s.LatestFactsByPrefix(ctx, "service_down:")
-	if err != nil {
-		t.Fatalf("LatestFactsByPrefix: %v", err)
-	}
-	if len(got) != 2 {
-		t.Fatalf("got %d facts, want 2: %+v", len(got), got)
-	}
-	if got[0].Key != "service_down:db" || got[0].Value != `"down"` {
-		t.Errorf("first = %s=%s, want the newest db row", got[0].Key, got[0].Value)
-	}
-	if got[1].Key != "service_down:web" {
-		t.Errorf("second = %s, want service_down:web", got[1].Key)
-	}
-}
-
-// A monitor name is user text. An underscore in it must match itself, not act
-// as a LIKE wildcard and drag in every other monitor.
-func TestLatestFactsByPrefixEscapesWildcards(t *testing.T) {
-	s := newTestStore(t)
-	ctx := context.Background()
-	now := time.Now().UTC().Truncate(time.Millisecond)
-	for _, k := range []string{"a_b:one", "axb:two"} {
-		if _, err := s.SetValue(ctx, KindEnv, k, "poll:uptimekuma", "down", now); err != nil {
-			t.Fatalf("SetValue %s: %v", k, err)
-		}
-	}
-	got, err := s.LatestFactsByPrefix(ctx, "a_b:")
-	if err != nil {
-		t.Fatalf("LatestFactsByPrefix: %v", err)
-	}
-	if len(got) != 1 || got[0].Key != "a_b:one" {
-		t.Fatalf("got %+v, want only a_b:one", got)
-	}
-}