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_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/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/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/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)
+		}
+	}
+}

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) {