the fact parser gets a corpus, and the LLM arm gets run (V-586)

V-586 reported 64/91 on the RU routing fixture, unchanged. That number does not
bear on the change: the fixture holds three fact cases and all three miss on
intent, so DefaultFactParser is never reached and any parser edit scores as
"unchanged".

So the parser gets its own corpus, 91 cases, scored against BOTH
implementations — the closed classes that ship and legacyFactParse, a verbatim
copy of the substring parser at 0445693, frozen in the test file so the
comparison reruns. True positives 35/40 to 39/40, misfires rejected 8/15 to
14/15. The rewrite wins every case anyone argued about.

The third case class is the point: 36 sentences a person would plainly say
whose word is in no lexicon set. The old parser caught 3 by accident, the new
one catches 0. "ем суп", "вздремнул", "помылся", "перекур", "i napped". A
silent miss is this parser's worst failure mode and the corpus sizes it.

Two defects recorded rather than fixed, since this branch measures: "допил
воду" misses because the dictionary lemmatises допил to допилить, the same saw
collision drink_verbs carries пил for; and the oblique cases of душ go with the
exact match that keeps the soul out.

The LLM arm the original commit skipped is run here against gemma-4-12b on the
workstation at 192.168.1.105:8080 — it was reachable all along, the failure was
the shell's HTTP_PROXY. cascade+llm 85.7% to 86.8%, one case, same failing set,
variance. Full write-up in docs/evals/2026-08-06-fact-parser.md.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0117tgnmbgZpHVV3XSNw8Qua

cmd/mavcaldav/main.go

@@ -188,6 +188,11 @@ func (p *poller) pollOnce(ctx context.Context) {
 	}
 }
 
+// maxResponseBody bounds every CalDAV response this daemon reads (the poller's
+// GET and the renderer's PROPFIND) — a misbehaving or malicious server gets a
+// truncated read, not an unbounded one.
+const maxResponseBody = 4 << 20
+
 // fetchEvents GETs the calendar URL and parses VEVENTs from the iCal response.
 func (p *poller) fetchEvents(ctx context.Context, now time.Time) ([]calendar.Event, error) {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, p.url, nil)
@@ -203,7 +208,7 @@ func (p *poller) fetchEvents(ctx context.Context, now time.Time) ([]calendar.Eve
 	}
 	defer resp.Body.Close()
 
-	body, err := io.ReadAll(io.LimitReader(resp.Body, 4<<20))
+	body, err := io.ReadAll(io.LimitReader(resp.Body, maxResponseBody))
 	if err != nil {
 		return nil, err
 	}

cmd/mavcaldav/render.go

@@ -142,7 +142,7 @@ func (r *renderer) listPublished(ctx context.Context) ([]int64, error) {
 		return nil, err
 	}
 	defer resp.Body.Close()
-	raw, err := io.ReadAll(io.LimitReader(resp.Body, 4<<20))
+	raw, err := io.ReadAll(io.LimitReader(resp.Body, maxResponseBody))
 	if err != nil {
 		return nil, err
 	}

cmd/mavenclient/main.go

@@ -31,15 +31,11 @@ import (
 	"errors"
 	"flag"
 	"fmt"
-	"io"
 	"log"
-	"net"
 	"os"
 	"os/signal"
 	"path/filepath"
-	"strconv"
 	"syscall"
-	"time"
 
 	"github.com/kami/maven/internal/audio"
 	"github.com/kami/maven/internal/voice"
@@ -155,9 +151,3 @@ func writeWAV(path string, a audio.Audio) error {
 // jsonUnmarshal — kept local rather than pulling encoding/json into main.go
 // top-level space.
 func jsonUnmarshal(b []byte, v any) error { return json.Unmarshal(b, v) }
-
-// keep strconv + io + net + time alive for future duration/size helpers.
-var _ = strconv.Atoi
-var _ io.Reader = (io.Reader)(nil)
-var _ = net.IPv4
-var _ = time.Second

cmd/mavend/actions_query.go

@@ -235,7 +235,13 @@ func (h *reactiveHandler) queryFactByKey(ctx context.Context, t *queryTurn) (str
 //
 // Read-only by construction — the plan is assembled and rendered core-side and
 // nothing here schedules or announces. "что дальше?" asks for the rest of the
-// day, so that phrasing trims what has already passed.
+// day, so that phrasing trims what has already passed and reads only the next
+// morning.NextSpoken entries. Trimming alone was not enough: asked early it cuts
+// nothing, and she read 43 entries aloud in one sentence (V-618).
+//
+// "что у меня сегодня?" is a different question and is not narrowed here — it
+// carries no plan word, so IsDayPlanQuery declines it and the calendar source
+// answers the whole day.
 //
 // What surface this belongs on is still open, tracked as Vikunja #431 ("Board
 // surface: Maven holds the work board, runs the intake form, never argues").
@@ -254,16 +260,23 @@ func (h *reactiveHandler) queryDayPlan(ctx context.Context, t *queryTurn) (strin
 	}
 	// Rebuild the pure plan so the rest-of-day rendering is the same code that
 	// rendered the whole day — one formatter, one persona.
-	p := morning.Plan{Date: plan.Date}
+	//
+	// The instants are put back in the asking clock's zone on the way in. They
+	// arrive carrying whatever zone the core read them in — a calendar fact's Ts
+	// and a reminder's FireTs are UTC out of the store — and FormatRU reads the
+	// hours in the plan's own frame, so setting that frame here is what makes
+	// the recital name his clock rather than the store's (V-614).
+	zone := h.now().Location()
+	p := morning.Plan{Date: plan.Date.In(zone)}
 	for _, it := range plan.Items {
 		p.Items = append(p.Items, morning.PlanEntry{
-			At:        it.At,
+			At:        it.At.In(zone),
 			Text:      it.Text,
 			Kind:      morning.PlanKind(it.Kind),
 			Uncertain: it.Uncertain,
 		})
 	}
-	return p.After(h.now()).FormatRU(), true
+	return p.Next(h.now(), morning.NextSpoken).FormatRU(), true
 }
 
 // habitFactWindow — how many recent SELF facts the behaviour profile is counted

cmd/mavend/actions_reminder.go

@@ -19,7 +19,10 @@ func (h *reactiveHandler) actionReminder(ctx context.Context, dec router.Decisio
 		// time wasn't parsed. Run the parser as a fallback.
 		if dec.Stage == 0 && h.timeParser != nil {
 			t, ok, err := h.timeParser.Parse(ctx, dec.Utterance, h.now())
-			if err == nil && ok {
+			// Same gate as the extractor (V-577, V-579, V-610): a request whose
+			// hour was not spoken, or was spoken and not read, gets asked about
+			// and is never completed from the clock.
+			if err == nil && ok && router.ResolvedTheHour(dec.Utterance, t) {
 				dec.Slots.Time = t
 				dec.Slots.HasTime = true
 			}

cmd/mavend/clarify.go

@@ -200,7 +200,7 @@ func lowerFirst(s string) string {
 // missingFor returns the slots a decision still needs, most important first.
 // Empty ⇒ there is nothing identifiable to ask about.
 func missingFor(dec router.Decision) []dialogue.Slot {
-	return dialogue.StillMissing(wantedSlots[dec.Intent], toDialogueSlots(dec.Slots))
+	return stillMissingFor(dec.Intent, dec.Utterance, toDialogueSlots(dec.Slots))
 }
 
 // clarifyQuestion picks the one question to ask for a clarify decision. Returns
@@ -209,18 +209,32 @@ func missingFor(dec router.Decision) []dialogue.Slot {
 // One question about one thing: if two slots are missing she asks about the
 // first only. Two questions in one breath is an interrogation. The second gap
 // is picked up on the turn after the first one is answered (askRemainingGap).
-func clarifyQuestion(dec router.Decision) (dialogue.Slot, string, bool) {
+func (h *reactiveHandler) clarifyQuestion(dec router.Decision) (dialogue.Slot, string, bool) {
 	missing := missingFor(dec)
 	if len(missing) == 0 {
 		return "", "", false
 	}
-	q, ok := clarifyQuestionFor(missing[0], 1)
+	q, ok := h.questionFor(missing[0], 1, dec.Utterance, toDialogueSlots(dec.Slots), "")
 	if !ok {
 		return "", "", false
 	}
 	return missing[0], q, true
 }
 
+// questionFor picks the wording for one gap. Every slot but the reminder's time
+// reads its deck by attempt; the time asks about whichever of the hour, the half
+// of the day and the day he has not said, and states the clock while it does
+// (V-579).
+//
+// taken is the acknowledgement of what his last turn added, empty when it added
+// nothing and empty for a first ask, which has no turn behind it (V-593).
+func (h *reactiveHandler) questionFor(slot dialogue.Slot, attempt int, utterance string, s dialogue.Slots, taken string) (string, bool) {
+	if slot != dialogue.SlotTime {
+		return clarifyQuestionFor(slot, attempt)
+	}
+	return whenQuestion(whenGapOf(utterance, s.HasTime), attempt, h.now(), taken)
+}
+
 // askClarify parks the request and returns the question to ask instead of the
 // canned "не поняла". Returns ("", false) when there is nothing to ask about, so
 // the caller falls back to the canned reply.
@@ -228,7 +242,7 @@ func (h *reactiveHandler) askClarify(ctx context.Context, dec router.Decision) (
 	if h.clarifyStore == nil {
 		return "", false
 	}
-	slot, question, ok := clarifyQuestion(dec)
+	slot, question, ok := h.clarifyQuestion(dec)
 	if !ok {
 		return "", false
 	}
@@ -348,6 +362,15 @@ func (h *reactiveHandler) resolveClarifyAnswer(ctx context.Context, text string)
 		// the V-554 shape.
 		h.noteSuspended(ctx, q)
 		return "", false
+	case roleAside:
+		// He stated something in the middle of the flow. Same machinery as a
+		// side query and for the same reason: the words are answered as
+		// themselves, so the note or the fact is stored, and the question comes
+		// back on the end of the same reply (V-577 shape 2). Storing it in
+		// silence and dropping it in silence are both wrong, and dropping it is
+		// what she did.
+		h.noteSuspended(ctx, q)
+		return "", false
 	case roleNewRequest:
 		// He moved on. A parked question used to swallow whatever came next, so
 		// one act she could not fulfil ate the following three turns (Vikunja
@@ -364,8 +387,35 @@ func (h *reactiveHandler) resolveClarifyAnswer(ctx context.Context, text string)
 	// as the reminder payload — so a reminder clarified out of a bare "напомни"
 	// would fire at 11:00 saying "напомни" and nothing else.
 	q.Utterance = foldAnswerIntoUtterance(q.Utterance, merged.Text)
-	if len(dialogue.StillMissing(q.Missing, merged)) > 0 {
-		return h.reaskOrGiveUp(ctx, q, merged, text), true
+	// A fact answers with a key and a value and fills no Text slot at all, so
+	// the fold above leaves the utterance at the bare "запиши" — and that is
+	// what the confirmation now reads back to him (V-592). His raw words are the
+	// only record of what he said, so they are what is folded. Never for a time
+	// question: what he says about when is kept apart in WhenText on purpose,
+	// or the reminder would read the day back at him when it fires.
+	if merged.Text == "" && !asksAboutTime(q.Missing) {
+		q.Utterance = foldAnswerIntoUtterance(q.Utterance, text)
+	}
+	// An answer about the time joins everything else he has said about the time,
+	// and the whole of it is re-read as one request (V-579). "завтра" names the
+	// day of an hour she is already holding, and read alone it names no hour at
+	// all, so the parser would have nothing and she would ask for ever.
+	// What he had already said about the time, read BEFORE this answer joins it.
+	// A re-ask that cannot tell the two apart is the one that repeats itself
+	// byte for byte (V-593).
+	var taken string
+	if asksAboutTime(q.Missing) {
+		before := whenKnownOf(whenTextOf(q), q.Slots.HasTime)
+		q.WhenText = strings.TrimSpace(q.WhenText + " " + text)
+		if t, ok := h.readWhen(ctx, intent, q, text); ok {
+			merged.Time, merged.HasTime = t, true
+		}
+		if before.movedForward(whenKnownOf(whenTextOf(q), merged.HasTime)) {
+			taken = whenTakenLine(text)
+		}
+	}
+	if stillOpen(q.Missing, whenTextOf(q), merged) {
+		return h.reaskOrGiveUp(ctx, q, merged, text, taken), true
 	}
 	h.clarifyStore.Delete(dialogueIDOf(ctx))
 
@@ -460,13 +510,13 @@ func foldAnswerIntoUtterance(utterance, subject string) string {
 // costs a question exactly like a second try at the first one does, so the cap
 // still bounds how many times she can speak before acting or letting go.
 func (h *reactiveHandler) askRemainingGap(ctx context.Context, q *dialogue.PendingQuestion, intent router.Intent, merged dialogue.Slots) (string, bool) {
-	remaining := dialogue.StillMissing(wantedSlots[intent], merged)
+	remaining := stillMissingFor(intent, whenTextOf(q), merged)
 	if len(remaining) == 0 {
 		return "", false
 	}
 	// Attempts+1 is the question she is about to ask, and the budget is shared
 	// with the re-ask path, so the second gap is worded like a second try.
-	question, ok := clarifyQuestionFor(remaining[0], q.Attempts+1)
+	question, ok := h.questionFor(remaining[0], q.Attempts+1, whenTextOf(q), merged, "")
 	if !ok || !q.CanAsk() {
 		return "", false
 	}
@@ -475,6 +525,7 @@ func (h *reactiveHandler) askRemainingGap(ctx context.Context, q *dialogue.Pendi
 		Slots:       merged,
 		Missing:     []dialogue.Slot{remaining[0]},
 		Utterance:   q.Utterance,
+		WhenText:    q.WhenText,
 		Asked:       h.now(),
 		TTL:         clarifyTTL,
 		Attempts:    q.Attempts + 1,
@@ -487,10 +538,12 @@ func (h *reactiveHandler) askRemainingGap(ctx context.Context, q *dialogue.Pendi
 // reaskOrGiveUp handles an answer that left the gap open: ask the same question
 // again while she has attempts left, otherwise say she did not understand and
 // let the request go. Never returns "" — a mute give-up reads as "done".
-func (h *reactiveHandler) reaskOrGiveUp(ctx context.Context, q *dialogue.PendingQuestion, merged dialogue.Slots, text string) string {
+// taken is the acknowledgement of what this answer DID give, empty when it gave
+// nothing (V-593). The give-up line never carries it: it is not another ask.
+func (h *reactiveHandler) reaskOrGiveUp(ctx context.Context, q *dialogue.PendingQuestion, merged dialogue.Slots, text, taken string) string {
 	question := ""
 	if len(q.Missing) > 0 {
-		question, _ = clarifyQuestionFor(q.Missing[0], q.Attempts+1)
+		question, _ = h.questionFor(q.Missing[0], q.Attempts+1, whenTextOf(q), merged, taken)
 	}
 	if question == "" || !q.CanAsk() {
 		h.clarifyStore.Delete(dialogueIDOf(ctx))

cmd/mavend/clarify_test.go

@@ -58,18 +58,26 @@ func TestClarifyQuestionForMissingSlot(t *testing.T) {
 		want  string
 		asked bool
 	}{
-		{"reminder without a time", clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме"), "Когда?", true},
+		{"reminder without a time", clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме"), "Сейчас 09:00. Когда?", true},
 		{"fact without a key", clarifyDec(router.IntentFact, router.Slots{Text: "запиши"}, "запиши"), "Что записать?", true},
 		{"act without a fn", clarifyDec(router.IntentAct, router.Slots{Text: "сделай это"}, "сделай это"), "Что сделать?", true},
 		// A time with nothing to say at that time is still half a reminder, so
 		// the subject is what she asks about — not silence.
 		{"reminder that has a time but no subject", clarifyDec(router.IntentReminder, router.Slots{HasTime: true}, "напомни в 11"), "О чём напомнить?", true},
-		{"reminder that has both", clarifyDec(router.IntentReminder, router.Slots{Text: "позвонить маме", HasTime: true}, "напомни в 11 позвонить маме"), "", false},
+		// A bare hour is half of a day away from being an answer, and she asks
+		// which half rather than picking one (V-579).
+		{"reminder whose hour could be either half of the day", clarifyDec(router.IntentReminder, router.Slots{Text: "позвонить маме", HasTime: true}, "напомни в 11 позвонить маме"), "Сейчас 09:00. Это утра или вечера?", true},
+		{"reminder that has all three", clarifyDec(router.IntentReminder, router.Slots{Text: "позвонить маме", HasTime: true}, "напомни завтра в 15:00 позвонить маме"), "", false},
+		// The owner's own two, confirmed 2026-08-06: an unambiguous time and a
+		// relative one are both complete and are never asked about.
+		{"an interval names the instant by itself", clarifyDec(router.IntentReminder, router.Slots{Text: "позвонить маме", HasTime: true}, "напомни через час позвонить маме"), "", false},
+		{"half an hour is an interval too", clarifyDec(router.IntentReminder, router.Slots{Text: "выключить духовку", HasTime: true}, "напомни через полчаса выключить духовку"), "", false},
 		{"chat is never worth a question", clarifyDec(router.IntentChat, router.Slots{Text: "мгм"}, "мгм"), "", false},
 		{"query is never worth a question", clarifyDec(router.IntentQuery, router.Slots{Text: "а"}, "а"), "", false},
 	}
+	h, _, _ := newClarifyHandler(t)
 	for _, tc := range cases {
-		_, got, asked := clarifyQuestion(tc.dec)
+		_, got, asked := h.clarifyQuestion(tc.dec)
 		if asked != tc.asked || got != tc.want {
 			t.Errorf("%s: got (%q, %v), want (%q, %v)", tc.name, got, asked, tc.want, tc.asked)
 		}
@@ -83,11 +91,13 @@ func TestClarifyReminderCompletesOnAnswer(t *testing.T) {
 	h, st, _ := newClarifyHandler(t)
 
 	question, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме"))
-	if !asked || question != "Когда?" {
+	if !asked || question != "Сейчас 09:00. Когда?" {
 		t.Fatalf("expected the time question, got %q asked=%v", question, asked)
 	}
 
-	reply, handled := h.resolveClarifyAnswer(ctx, "в 11:00")
+	// The answer names the day as well as the hour. A reminder commits on what,
+	// what time and what day, and a dayless hour is asked about (V-579).
+	reply, handled := h.resolveClarifyAnswer(ctx, "сегодня в 11:00")
 	if !handled {
 		t.Fatal("the answer to an open question must be consumed as an answer")
 	}
@@ -159,11 +169,11 @@ func TestClarifyAsksThreeTimesThenSaysSo(t *testing.T) {
 		}
 		// The wording changes with the attempt (Vikunja #457): repeating a
 		// question he already failed to answer is the worst way to ask it.
-		want, _ := clarifyQuestionFor(dialogue.SlotTime, i)
+		want, _ := whenQuestion(whenNoHour, i, h.now(), "")
 		if reply != want {
 			t.Fatalf("attempt %d should ask again as %q, got %q", i, want, reply)
 		}
-		if first, _ := clarifyQuestionFor(dialogue.SlotTime, 1); reply == first {
+		if first, _ := whenQuestion(whenNoHour, 1, h.now(), ""); reply == first {
 			t.Fatalf("attempt %d repeated the first wording: %q", i, reply)
 		}
 		if h.clarifyStore.Get(voiceDialogueID, h.now()) == nil {
@@ -216,10 +226,11 @@ func TestClarifyRestatedAnswerWins(t *testing.T) {
 	if q == nil {
 		t.Fatal("expected an armed question")
 	}
-	first := h.extractor.Extract(ctx, router.IntentReminder, "в 11:00", h.now())
-	q.Slots = q.Answer("в 11:00", toDialogueSlots(first))
+	first := h.extractor.Extract(ctx, router.IntentReminder, "сегодня в 11:00", h.now())
+	q.Slots = q.Answer("сегодня в 11:00", toDialogueSlots(first))
+	q.WhenText = "сегодня в 11:00"
 
-	if reply, handled := h.resolveClarifyAnswer(ctx, "нет, в 15:00"); !handled || reply == clarifyGaveUp {
+	if reply, handled := h.resolveClarifyAnswer(ctx, "нет, сегодня в 15:00"); !handled || reply == clarifyGaveUp {
 		t.Fatalf("the restated answer should complete the request, handled=%v reply=%q", handled, reply)
 	}
 	reminders, err := st.DueReminders(ctx, h.now().Add(48*time.Hour))
@@ -357,7 +368,7 @@ func TestClarifyAsksAboutTheSecondGapToo(t *testing.T) {
 	}
 	// Second gap, second attempt, so it is the second wording of the time
 	// question — the attempt budget is shared between the two paths.
-	want, _ := clarifyQuestionFor(dialogue.SlotTime, 2)
+	want, _ := whenQuestion(whenNoHour, 2, h.now(), "")
 	if reply != want {
 		t.Fatalf("a filled subject with no time must ask about the time as %q, got %q", want, reply)
 	}
@@ -369,7 +380,7 @@ func TestClarifyAsksAboutTheSecondGapToo(t *testing.T) {
 		t.Fatalf("the re-parked question lost the answered subject: %+v", q.Slots)
 	}
 
-	if reply, handled := h.resolveClarifyAnswer(ctx, "в 11:00"); !handled || reply == clarifyGaveUp {
+	if reply, handled := h.resolveClarifyAnswer(ctx, "сегодня в 11:00"); !handled || reply == clarifyGaveUp {
 		t.Fatalf("the time answer must complete the reminder, handled=%v reply=%q", handled, reply)
 	}
 	reminders, err := st.DueReminders(ctx, h.now().Add(48*time.Hour))
@@ -487,7 +498,7 @@ func TestClarifySubjectAnswerFillsRatherThanClobbers(t *testing.T) {
 	at := h.now().Add(2 * time.Hour)
 
 	question, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder,
-		router.Slots{Time: at, HasTime: true}, "напомни в 11"))
+		router.Slots{Time: at, HasTime: true}, "напомни сегодня в 11 утра"))
 	if !asked || question != "О чём напомнить?" {
 		t.Fatalf("expected the subject question, got %q asked=%v", question, asked)
 	}
@@ -623,7 +634,7 @@ func TestClarifyQuestionShapedAnswerThatFillsTheGapStillLands(t *testing.T) {
 	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме")); !asked {
 		t.Fatal("expected the time question")
 	}
-	if reply, handled := h.resolveClarifyAnswer(ctx, "а что если в 11:00"); !handled || reply == clarifyGaveUp {
+	if reply, handled := h.resolveClarifyAnswer(ctx, "а что если сегодня в 11:00"); !handled || reply == clarifyGaveUp {
 		t.Fatalf("an answer that fills the gap must land, handled=%v reply=%q", handled, reply)
 	}
 	if reminders, err := st.DueReminders(ctx, h.now().Add(48*time.Hour)); err != nil || len(reminders) != 1 {
@@ -674,14 +685,14 @@ func TestIncompleteReminderAsksInsteadOfFailing(t *testing.T) {
 	h, st := newRoutingClarifyHandler(t)
 
 	reply := h.handleText(ctx, "web", "напомни позвонить маме")
-	want, _ := clarifyQuestionFor(dialogue.SlotTime, 1)
+	want, _ := whenQuestion(whenNoHour, 1, h.now(), "")
 	if reply != want {
 		t.Fatalf("reply = %q, want the time question %q", reply, want)
 	}
 	if h.clarifyStore.Get(dialogueIDFor(sourceText, "web"), h.now()) == nil {
 		t.Fatal("the request must be parked, or the answer has nowhere to land")
 	}
-	if reply := h.handleText(ctx, "web", "в семь вечера"); strings.Contains(reply, "нашла") {
+	if reply := h.handleText(ctx, "web", "сегодня в семь вечера"); strings.Contains(reply, "нашла") {
 		t.Fatalf("the answer to her own question must not be looked up: %q", reply)
 	}
 	if reminders, err := st.DueReminders(ctx, h.now().Add(48*time.Hour)); err != nil || len(reminders) != 1 {
@@ -715,7 +726,7 @@ func TestACompleteTurnStillDoesNotAsk(t *testing.T) {
 	h, _, _ := newClarifyHandler(t)
 
 	complete := []router.Decision{
-		{Intent: router.IntentReminder, Slots: router.Slots{Text: "позвонить маме", HasTime: true}, Utterance: "напомни в 11 позвонить маме"},
+		{Intent: router.IntentReminder, Slots: router.Slots{Text: "позвонить маме", HasTime: true}, Utterance: "напомни завтра в 11 утра позвонить маме"},
 		{Intent: router.IntentFact, Slots: router.Slots{Key: "water", Value: "выпил", HasKey: true}, Utterance: "я выпил воды"},
 		{Intent: router.IntentNote, Slots: router.Slots{Text: "купить хлеб"}, Utterance: "запиши купить хлеб"},
 		{Intent: router.IntentQuery, Slots: router.Slots{Text: "что у меня сегодня"}, Utterance: "что у меня сегодня"},

cmd/mavend/confirm.go

@@ -24,6 +24,14 @@ type pendingHexisExec struct {
 	entityID     string
 	displayName  string
 	expiry       time.Time
+
+	// correlationID — the id the proposing turn minted for this action. A
+	// confirm arrives on a later turn with a context of its own, so without
+	// carrying it here the execution recorded a fresh id and no causation at
+	// all, and the resolve, the discovery and the thing they authorised sat in
+	// the trace as unrelated calls. The contract mints one id per action, and
+	// the action began when she asked.
+	correlationID string
 }
 
 // pendingRoutineConfirm — a proposed routine awaiting a spoken y/n to become
@@ -144,7 +152,11 @@ func (h *reactiveHandler) confirmResolvers(ctx context.Context) []confirmResolve
 				return hx != nil && !h.now().After(hx.expiry)
 			},
 			yes: func() string {
-				return h.execHexis(ctx, hx.capabilityID, hx.capName, hx.entityID, hx.displayName)
+				execCtx := ctx
+				if hx.correlationID != "" {
+					execCtx = withCorrelationID(execCtx, hx.correlationID)
+				}
+				return h.execHexis(execCtx, hx.capabilityID, hx.capName, hx.entityID, hx.displayName)
 			},
 			no: func() string { return phraser.C(phraser.ConfirmCancelled, nil) },
 		},

cmd/mavend/crawls.go

@@ -173,6 +173,13 @@ func (a *crawlFetcher) Get(ctx context.Context, u string) (*crawl.Response, erro
 		case errors.Is(err, webfetch.ErrBlocked), errors.Is(err, webfetch.ErrPrivate), errors.Is(err, webfetch.ErrScheme):
 			return nil, fmt.Errorf("%w: %v", crawl.ErrFetchRefused, err)
 		case errors.Is(err, webfetch.ErrStatus):
+			// Carry the code across the seam. The crawler needs to tell a 5xx
+			// from a 404 to decide what a failed robots.txt means, and it must
+			// not learn that by reading this sentence.
+			var se *webfetch.StatusError
+			if errors.As(err, &se) {
+				return nil, &crawl.StatusError{Code: se.Code}
+			}
 			return nil, fmt.Errorf("%w: %v", crawl.ErrFetchStatus, err)
 		}
 		return nil, err

cmd/mavend/dayplan_test.go

@@ -4,12 +4,14 @@ import (
 	"context"
 	"database/sql"
 	"errors"
+	"fmt"
 	"strings"
 	"testing"
 	"time"
 
 	"github.com/kami/maven/internal/calendar"
 	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/morning"
 	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/store"
@@ -111,6 +113,88 @@ func TestQueryDayPlanRestOfDayWhenNothingIsLeft(t *testing.T) {
 	}
 }
 
+// "что дальше?" rebuilds the plan off the wire and renders it here, and the
+// instants on it carry the zone the core read them in — a calendar fact's Ts
+// and a reminder's FireTs are UTC out of the store. Read raw, the recital named
+// the store's clock instead of his (V-614). The asking clock is three hours off
+// whatever this machine runs in, so the assertion holds under TZ=UTC too.
+func TestQueryDayPlanRestOfDayReadsHisClock(t *testing.T) {
+	_, off := time.Now().Zone()
+	away := time.FixedZone("away", off+3*60*60)
+	stored := time.Date(2026, 8, 3, 8, 0, 0, 0, time.UTC)
+
+	h := &reactiveHandler{
+		api: &planAPI{plan: ipc.DayPlan{
+			Date:  time.Date(2026, 8, 3, 0, 0, 0, 0, time.UTC),
+			Items: []ipc.DayPlanItem{{At: stored, Text: "позвонить маме", Kind: "reminder"}},
+		}},
+		now: func() time.Time { return time.Date(2026, 8, 3, 9, 0, 0, 0, away) },
+	}
+	reply, ok := h.queryDayPlan(context.Background(), &queryTurn{
+		dec: router.Decision{Intent: router.IntentQuery, Utterance: "что дальше?"},
+	})
+	if !ok {
+		t.Fatal("expected the plan source to claim it")
+	}
+	if want := stored.In(away).Format("15:04"); !strings.Contains(reply, want) {
+		t.Errorf("the reminder is not read in his clock (%s): %q", want, reply)
+	}
+	if bad := stored.Format("15:04"); strings.Contains(reply, bad) {
+		t.Errorf("the reminder is read in the store's zone (%s): %q", bad, reply)
+	}
+}
+
+// The defect V-618 fixes, at the handler: asked at 04:45 the trim removes
+// nothing, because the whole day is still ahead. She read 43 entries aloud as
+// one sentence. The zone is three hours off UTC so the test also fails under
+// TZ=UTC if the rendering ever slips zones.
+func TestQueryDayPlanCapsWhatItReadsAloud(t *testing.T) {
+	zone := time.FixedZone("MSK", 3*60*60)
+	mid := time.Date(2026, 8, 3, 0, 0, 0, 0, zone)
+	plan := ipc.DayPlan{Date: mid, Spoken: "план на 03.08.2026: …"}
+	for i := 0; i < 43; i++ {
+		plan.Items = append(plan.Items, ipc.DayPlanItem{
+			At:   mid.Add(time.Duration(345+i*20) * time.Minute), // 05:45 onward
+			Text: fmt.Sprintf("пункт %d", i),
+			Kind: "event",
+		})
+	}
+	h := &reactiveHandler{api: &planAPI{plan: plan}, now: func() time.Time {
+		return time.Date(2026, 8, 3, 4, 45, 0, 0, zone)
+	}}
+	reply, ok := h.queryDayPlan(context.Background(), &queryTurn{
+		dec: router.Decision{Intent: router.IntentQuery, Utterance: "что дальше?"},
+	})
+	if !ok {
+		t.Fatal("expected the plan source to claim it")
+	}
+	if n := strings.Count(reply, "пункт "); n != morning.NextSpoken {
+		t.Errorf("read %d entries aloud, want %d: %q", n, morning.NextSpoken, reply)
+	}
+	if !strings.HasPrefix(reply, "дальше: 05:45 — пункт 0;") {
+		t.Errorf("the next thing is not first: %q", reply)
+	}
+	// The rest is counted, not silently dropped.
+	if !strings.Contains(reply, "и ещё 40 дел до конца дня.") {
+		t.Errorf("the sentence hides that the day goes on: %q", reply)
+	}
+}
+
+// "что у меня сегодня?" is the whole day and is not narrowed. It carries no
+// plan word, so the plan source declines it and the calendar listing answers —
+// asserted here beside the cap so the two questions cannot drift together.
+func TestWholeDayQuestionIsNotTheRestOfTheDay(t *testing.T) {
+	if router.IsDayPlanQuery("что у меня сегодня?") {
+		t.Error("the plan source claims the whole-day question")
+	}
+	if !router.IsDayPlanQuery("что дальше?") {
+		t.Error("the plan source stopped claiming the rest-of-day question")
+	}
+	if router.IsRestOfDayQuery("какие планы на сегодня?") {
+		t.Error("the whole-day plan question got narrowed to the rest of the day")
+	}
+}
+
 // A question that is not about the plan must fall through, or the plan buries
 // the calendar listing and the weather behind it.
 func TestQueryDayPlanPassesOnEverythingElse(t *testing.T) {

cmd/mavend/dialogue_contract_test.go

@@ -114,8 +114,18 @@ type turn struct {
 	wait time.Duration
 	// question — the reply must be exactly this clarify question, worded for
 	// this attempt. Zero slot ⇒ not checked.
-	question   dialogue.Slot
-	attempt    int
+	question dialogue.Slot
+	attempt  int
+	// gap — which part of the time she is asking about, for a SlotTime question
+	// (V-579). Zero value is the missing hour, which is what she asks first.
+	gap whenGap
+	// took — the words of the PREVIOUS turn that this ask must acknowledge
+	// before asking again (V-593). Empty ⇒ the ask carries no acknowledgement,
+	// which is right for a first ask and for an answer that moved nothing.
+	took string
+	// differs — this reply must not be byte-identical to the one before it. Set
+	// on a re-ask whose turn moved the request forward (V-593).
+	differs    bool
 	contains   []string
 	notContain []string
 	// noQuestion — the reply must not be any clarify question. Used where the
@@ -157,11 +167,29 @@ type trace struct {
 func newDialogueHandler(t *testing.T) (*reactiveHandler, *store.Store, *time.Time) {
 	t.Helper()
 	h, st, now := newClarifyHandler(t)
+	// A minute no trace ever says, so "fires at the current clock" is a defect
+	// and never a coincidence (V-577, V-579). checkEnd refuses any reminder
+	// landing on it, and at 09:00 the row that answers "на 9" would trip that.
+	*now = time.Date(2026, 7, 31, 9, 17, 0, 0, time.UTC)
 	h.router = buildRouter(router.NewHashEmbedder(1024), h.matcher, 0.55, nil)
 	h.recall = recallWiring{embedder: router.NewHashEmbedder(1024), memStore: memory.NewInMemoryStore()}
 	return h, st, now
 }
 
+// wantedQuestion builds the question a turn must be answered with, from the
+// same code the daemon asks through. A time question is built from the gap,
+// because she names the clock and asks about the part he left out (V-579).
+func wantedQuestion(tn turn, now time.Time) (string, bool) {
+	if tn.question == dialogue.SlotTime {
+		gap := tn.gap
+		if gap == whenComplete {
+			gap = whenNoHour
+		}
+		return whenQuestion(gap, tn.attempt, now, whenTakenLine(tn.took))
+	}
+	return clarifyQuestionFor(tn.question, tn.attempt)
+}
+
 // runTrace drives one trace through handleText and checks every turn, then the
 // end state. Every failure carries the decision trace so far, so a wrong
 // claimant reads differently from wrong copy.
@@ -180,6 +208,7 @@ func runTrace(t *testing.T, tr trace) {
 	id := dialogueIDFor(sourceText, conversation)
 
 	var claims []claim
+	var previous string
 	fail := func(turnIdx int, format string, args ...any) {
 		t.Helper()
 		lines := make([]string, 0, len(claims))
@@ -217,7 +246,7 @@ func runTrace(t *testing.T, tr trace) {
 			fail(i, "reply %q announced an expiry nothing asked for", reply)
 		}
 		if tn.question != "" {
-			want, ok := clarifyQuestionFor(tn.question, tn.attempt)
+			want, ok := wantedQuestion(tn, h.now())
 			if !ok {
 				fail(i, "no question exists for slot %s attempt %d", tn.question, tn.attempt)
 			}
@@ -238,6 +267,10 @@ func runTrace(t *testing.T, tr trace) {
 				fail(i, "reply %q carries %q and must not", body, unwanted)
 			}
 		}
+		if tn.differs && reply == previous {
+			fail(i, "reply %q is byte-identical to the one before it, and his turn between them answered part of the gap", reply)
+		}
+		previous = reply
 		checkParked(t, fail, i, h.clarifyStore.Get(id, h.now()), tn.parked)
 	}
 	checkEnd(t, ctx, st, h, tr.end, claims)
@@ -248,12 +281,16 @@ func runTrace(t *testing.T, tr trace) {
 func isAnyClarifyQuestion(reply string) bool {
 	for _, variants := range clarifyQuestionVariants {
 		for _, v := range variants {
-			if reply == v {
+			// HasSuffix, not equality: a question about the time opens with the
+			// clock she is reasoning from (V-579).
+			if strings.HasSuffix(reply, v) {
 				return true
 			}
 		}
 	}
-	return false
+	// The two questions with no deck behind them, asked when the hour is said
+	// and its half of the day or its day is not.
+	return strings.HasSuffix(reply, "утра или вечера?") || strings.HasSuffix(reply, "В какой день?")
 }
 
 func checkParked(t *testing.T, fail func(int, string, ...any), i int, got *dialogue.PendingQuestion, want *parkedWant) {
@@ -294,6 +331,17 @@ func checkEnd(t *testing.T, ctx context.Context, st *store.Store, h *reactiveHan
 	if len(reminders) != len(want.reminders) {
 		t.Fatalf("end state: %d reminder(s), want %d: %+v%s", len(reminders), len(want.reminders), reminders, trace)
 	}
+	// No trace may leave a reminder at the current clock, whatever else it
+	// asserts (V-577, V-579). Twice on the box a sentence naming a day and no
+	// hour was completed from time.Now(): "что у меня сегодня?" became 01:28 and
+	// "на завтра" became 01:38. Neither minute was ever spoken, and a row that
+	// only checked the payload would have passed both.
+	for _, r := range reminders {
+		if r.FireTs.In(h.now().Location()).Format("15:04") == h.now().Format("15:04") {
+			t.Fatalf("end state: reminder %q fires at %s, which is the clock — a time slot naming no hour is asked about, never filled from now()%s",
+				r.Payload, r.FireTs.Format("15:04"), trace)
+		}
+	}
 	for i, w := range want.reminders {
 		if !strings.Contains(reminders[i].Payload, w.payload) {
 			t.Fatalf("end state: reminder %d payload %q does not carry %q%s", i, reminders[i].Payload, w.payload, trace)
@@ -355,11 +403,18 @@ func dialogueTraces() []trace {
 		// from: she asks for the time, he gives it, the reminder lands with the
 		// subject he said in the FIRST turn.
 		{
-			name: "reminder completed over two turns",
+			// Three turns since V-579, not two. An hour with no day named is
+			// not an answer she can act on: 11:00 today has passed as often as
+			// not, and picking one for him is the invention the whole rule is
+			// against. So she says the clock she is reasoning from and asks
+			// which day.
+			name: "reminder completed over three turns",
 			turns: []turn{
 				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
 					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "маме"}},
-				{say: "в 11:00", contains: []string{"11:00"}, notContain: []string{"?"}},
+				{say: "в 11:00", question: dialogue.SlotTime, attempt: 2, gap: whenNoDay, took: "в 11:00",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 2, carries: "маме"}},
+				{say: "сегодня", contains: []string{"11:00"}, notContain: []string{"?"}},
 			},
 			end: endState{reminders: []reminderWant{{payload: "позвонить маме", fireAt: "2026-07-31 11:00"}}},
 		},
@@ -370,7 +425,9 @@ func dialogueTraces() []trace {
 			turns: []turn{
 				{say: "запиши", question: dialogue.SlotKey, attempt: 1,
 					parked: &parkedWant{slot: dialogue.SlotKey, attempt: 1}},
-				{say: "пил воду", contains: []string{"water"}},
+				// His words back, not the key the parser filed them under
+				// (V-592). "water" is machine vocabulary and he never said it.
+				{say: "пил воду", contains: []string{"пил воду"}},
 			},
 			end: endState{factKeys: []string{"water"}},
 		},
@@ -438,8 +495,181 @@ func dialogueTraces() []trace {
 			end: endState{tasks: []string{"купить молоко"}},
 		},
 
+		// V-577 shape 1, the worst of the nine claimants measured on 2026-08-06.
+		// Every token of "что у меня сегодня?" is frame — an interrogative, a
+		// preposition, a particle and a day word — so the role classifier never
+		// looked at the route, the parked reminder read "сегодня" as its time,
+		// and the hour came from the clock. He got a reminder he never asked for
+		// at a minute he never said, and his question was answered nowhere.
+		//
+		// Two claims: the calendar answers, and nothing is written. The flow
+		// survives underneath, because a question of his own is not a request to
+		// abandon the one he was making.
+		{
+			name: "an agenda question mid-flow is answered, not eaten",
+			turns: []turn{
+				{say: "напомни забрать посылку", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "посылку"}},
+				{say: "что у меня сегодня?", contains: []string{"31.07.2026"},
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "посылку"}},
+			},
+			end: endState{},
+		},
+		// V-577 shape 2. He states something in the middle of the flow. It is
+		// neither a slot value nor a cancel, and it was scored as a failed
+		// answer and dropped in silence: alone the same sentence is stored.
+		// Silence is the one option that is wrong, so it is stored, no retry is
+		// spent, and the question comes back on the end of the same reply.
+		//
+		// The words are a fact and not the owner's note, because the fact parser
+		// is deterministic and the offline floor marks every classifier route
+		// Clarify. The row below carries his own sentence and needs the model.
+		//
+		// What this floor can prove is the arbitration: no retry is spent, the
+		// flow survives on the same attempt, and the words are answered as
+		// themselves with the question coming back after them. Whether the fact
+		// is then WRITTEN is the routing engine's business — the hash embedder
+		// is unsure of every sentence it sees, and an unsure fact has never been
+		// stored.
+		{
+			name: "a fact stated mid-flow steps aside without spending a retry",
+			turns: []turn{
+				{say: "напомни позвонить врачу", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "врачу"}},
+				// Nothing she says about it may be a word he did not say
+				// (V-592). On the box this sentence came back as "Проверила, что
+				// ты выпел стакан воды": a non-word for the verb, a glass copied
+				// out of the example in ReplySystemPrompt, and a claim to have
+				// checked something. The store held key=water value="drank"
+				// throughout, so all of it was generated from two tokens.
+				//
+				// The positive half of the contract — the confirmation IS his
+				// sentence — is asserted by "fact completed over two turns"
+				// above. It cannot be asserted here: the hash embedder marks
+				// this route Clarify, and an unsure fact is answered with the
+				// canned line rather than a confirmation of anything.
+				{say: "я выпил воды", contains: []string{"напоминание?"},
+					notContain: []string{"стакан", "выпел", "Проверила", "water"},
+					parked:     &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "врачу"}},
+			},
+			end: endState{},
+		},
+		// V-593: two asks about the same half of the day, with a turn between
+		// them that answered the DAY. Asking again is right and asking in the
+		// same bytes is not — from his side it is indistinguishable from not
+		// having been heard, which is what the whole V-558 family is about.
+		//
+		// The clock still opens every ask (the owner's rule, V-579); the
+		// acknowledgement goes after it and before the question.
+		{
+			name: "a re-ask names what the answer before it gave her",
+			turns: []turn{
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+				{say: "на 9", question: dialogue.SlotTime, attempt: 2, gap: whenAmbiguousHour, took: "на 9",
+					contains: []string{"Сейчас "},
+					parked:   &parkedWant{slot: dialogue.SlotTime, attempt: 2}},
+				{say: "на завтра", question: dialogue.SlotTime, attempt: 3, gap: whenAmbiguousHour, took: "на завтра",
+					contains: []string{"Сейчас ", "завтра"}, differs: true,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 3}},
+			},
+			end: endState{},
+		},
+		// V-579 turn 3: the preposition decided whether the hour was read. "в 9"
+		// set the reminder and "на 9" was not read at all, on the same build and
+		// with the same cardinal.
+		{
+			// It is read, and being read is not the same as being enough: nine is
+			// either half of the day, so she asks which and then which day
+			// (V-579). Both answers are frame words and neither carries an hour
+			// of its own, so this row is also the proof that an answer is read
+			// against the whole request rather than alone.
+			name: "на 9 answers the time question like в 9",
+			turns: []turn{
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+				{say: "на 9", question: dialogue.SlotTime, attempt: 2, gap: whenAmbiguousHour, took: "на 9",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 2}},
+				{say: "утра", question: dialogue.SlotTime, attempt: 3, gap: whenNoDay, took: "утра",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 3}},
+				{say: "завтра", contains: []string{"09:00"}},
+			},
+			end: endState{reminders: []reminderWant{{payload: "позвонить маме", fireAt: "2026-08-01 09:00"}}},
+		},
+		// The owner's own four, ruled 2026-08-06 (V-579). A reminder commits
+		// when what, what time and what day are all answered, and every ask
+		// states the clock she is reasoning from.
+		{
+			name: "his first example: a bare 3 is asked about",
+			turns: []turn{
+				{say: "напомни завтра в 3 заказать цветы",
+					question: dialogue.SlotTime, attempt: 1, gap: whenAmbiguousHour,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "цветы"}},
+			},
+			end: endState{},
+		},
+		{
+			// The hour is unambiguous and the day is still missing, so she asks.
+			// Today being a valid reading is not the same as him saying it.
+			name: "his second example: nine in the evening of which day",
+			turns: []turn{
+				{say: "напомни в 9 вечера разгрузить стиралку",
+					question: dialogue.SlotTime, attempt: 1, gap: whenNoDay,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "стиралку"}},
+				{say: "завтра", contains: []string{"21:00"}},
+			},
+			end: endState{reminders: []reminderWant{{payload: "стиралку", fireAt: "2026-08-01 21:00"}}},
+		},
+		{
+			// All three answered in one breath, so she does not ask at all.
+			name: "his third example: a full time commits",
+			turns: []turn{
+				{say: "напомни завтра в 15:00 заказать цветы", notContain: []string{"?"}},
+			},
+			end: endState{reminders: []reminderWant{{payload: "цветы", fireAt: "2026-08-01 15:00"}}},
+		},
+		{
+			// An interval is one instant, so it answers the hour and the day
+			// together. Confirmed by the owner: "через час is fine as is".
+			name: "an interval commits without a question",
+			turns: []turn{
+				{say: "напомни через час позвонить маме", notContain: []string{"?"}},
+			},
+			end: endState{reminders: []reminderWant{{payload: "маме", fireAt: "2026-07-31 10:17"}}},
+		},
+		// V-579 turn 4: he named a day and no hour, and got the day at the
+		// current minute. She has to ask instead, and the global check in
+		// checkEnd refuses the invented minute for every row at once.
+		{
+			name: "a day with no hour is asked about, not taken from the clock",
+			turns: []turn{
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+				{say: "на завтра", question: dialogue.SlotTime, attempt: 2,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 2}},
+			},
+			end: endState{},
+		},
+
 		// ---- rows below carry the CORRECT expectation and fail today ----
 
+		// The owner's own sentence from V-577 shape 2, in his words. It needs
+		// an engine that can route it: the hash embedder marks it note with
+		// Clarify set, and a route she is not sure of is not evidence that he
+		// stated anything. The row above is the same contract in words the
+		// floor's deterministic fact parser reads.
+		{
+			name: "a note stated mid-flow is stored, not dropped",
+			skip: "the offline floor cannot route «у меня новый ноутбук» confidently; needs the resident model",
+			turns: []turn{
+				{say: "напомни позвонить врачу", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "врачу"}},
+				{say: "у меня новый ноутбук",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "врачу"}},
+			},
+			end: endState{notes: 1},
+		},
+
 		// The owner's target transcript, V-561. He asks for a reminder, she asks
 		// when, he asks something else entirely, and then comes back to her
 		// question. On the box this created a reminder at 00:12 and never
@@ -452,26 +682,39 @@ func dialogueTraces() []trace {
 		// still standing, on the same attempt — a side query is not a failed
 		// answer and must not spend a retry.
 		//
-		// Unskipping this needs more than V-561, and V-561 landing did not change
-		// that. The suspend and resume it asked for is done — the row below is
-		// the same shape in words the floor can parse and is green. What is left
-		// here is the parser: StubDateTimeParser does not read "на 9" or "на
-		// завтра", so turn 3 lands as an answer that filled nothing and spends a
-		// retry, which is what this row now fails on. V-562 and V-543 own the
-		// ambiguous hour and the day correction behind those two words.
+		// The skip came off with V-579. What held it was the parser, not the
+		// arbitration: neither the stub nor the production one read "на 9",
+		// because only "в" framed a spoken hour, and "на завтра" was completed
+		// from the clock.
+		//
+		// Turn 3 now closes the flow, where the transcript has one more exchange
+		// in it. That is the 12-hour question — the owner's turn 4 answers "на
+		// 9" with "сейчас 15:23, на 9 сегодня вечером?" — and it is a decision of
+		// its own, not one to invent here. Nine o'clock is read as nine and, at
+		// 09:17, as tomorrow's, which is where the transcript ends up anyway.
+		// Turn 4 then has nothing to answer and must not write anything.
 		{
 			name: "the owner's transcript from V-561",
-			skip: "V-543/V-562: the floor's date parser reads neither «на 9» nor «на завтра»",
 			turns: []turn{
 				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
 					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
 				{say: "какая сейчас погода в Риме?",
 					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "маме"}},
-				{say: "а, да, прости - на 9.",
-					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "маме"}},
-				{say: "на завтра."},
+				// His words, unchanged. What changed under V-579 is that "на 9"
+				// is a question and not a commit: nine could be either half of
+				// the day, so she says the clock she is reading from and asks.
+				// "на завтра." then answers the day and leaves the half open, so
+				// she asks that one again.
+				// Each ask names what the turn before it gave her (V-593). The
+				// two asks about the half of the day are the same question and
+				// must not be the same sentence: he answered between them, and a
+				// reply with no trace of that reads as not having been heard.
+				{say: "а, да, прости - на 9.", question: dialogue.SlotTime, attempt: 2, gap: whenAmbiguousHour, took: "а, да, прости - на 9.",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 2}},
+				{say: "на завтра.", question: dialogue.SlotTime, attempt: 3, gap: whenAmbiguousHour, took: "на завтра.",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 3}},
 			},
-			end: endState{reminders: []reminderWant{{payload: "позвонить маме", fireAt: "2026-08-01 09:00"}}},
+			end: endState{},
 		},
 		// The same shape said in words StubDateTimeParser reads. GREEN since
 		// V-561. Same three claims: Rome is answered, the question survives the
@@ -488,7 +731,9 @@ func dialogueTraces() []trace {
 					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
 				{say: "какая сейчас погода в Риме?",
 					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "маме"}},
-				{say: "в 11:00", contains: []string{"11:00"}},
+				{say: "в 11:00", question: dialogue.SlotTime, attempt: 2, gap: whenNoDay, took: "в 11:00",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 2, carries: "маме"}},
+				{say: "сегодня", contains: []string{"11:00"}},
 			},
 			end: endState{reminders: []reminderWant{{payload: "позвонить маме", fireAt: "2026-07-31 11:00"}}},
 		},

cmd/mavend/ecosystem.go

@@ -12,6 +12,7 @@ import (
 	"log"
 	"net/http"
 	"net/url"
+	"strings"
 	"time"
 
 	hexisclient "github.com/kami/hexis/pkg/client"
@@ -179,6 +180,54 @@ func httpError(service, op string, status int) *ecosystemError {
 	}
 }
 
+// hexisStatusTexts maps the http.StatusText spelling back to its code, for the
+// failure statuses a Hexis call can plausibly answer with. It is the inverse of
+// what the vendored client threw away.
+var hexisStatusTexts = func() map[string]int {
+	codes := []int{
+		http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden,
+		http.StatusNotFound, http.StatusMethodNotAllowed, http.StatusNotAcceptable,
+		http.StatusRequestTimeout, http.StatusConflict, http.StatusGone,
+		http.StatusUnprocessableEntity, http.StatusUpgradeRequired,
+		http.StatusTooManyRequests, http.StatusInternalServerError,
+		http.StatusNotImplemented, http.StatusBadGateway,
+		http.StatusServiceUnavailable, http.StatusGatewayTimeout,
+	}
+	m := make(map[string]int, len(codes))
+	for _, c := range codes {
+		m[http.StatusText(c)] = c
+	}
+	return m
+}()
+
+// hexisError re-wraps an error from the vendored Hexis client as an
+// *ecosystemError, so a Hexis failure classifies the same way a Nexus or Praxis
+// one does and ecosystemGap can tell a refused credential from an outage.
+//
+// This is a boundary adapter and it is not the fix anyone would choose. The
+// Hexis client lives in another repository and returns
+// fmt.Errorf("%s: %s", http.StatusText(status), body) for every status at or
+// above 400, so the status text is the only signal that survives — the correct
+// fix is a typed error carrying the code, and Maven cannot land it unilaterally
+// (Vikunja #587, docs/plans/20-two-artifacts-and-neither-is-spring.md). Parsing
+// here is bounded: the message's first colon-delimited segment is the status
+// text verbatim, no status text contains a colon, and anything unrecognised —
+// "do request: ...", "create request: ..." — is a transport failure and is left
+// at status 0, which is exactly what Unreachable() means.
+func hexisError(op string, err error) error {
+	if err == nil {
+		return nil
+	}
+	var ee *ecosystemError
+	if errors.As(err, &ee) {
+		return err
+	}
+	head, _, _ := strings.Cut(err.Error(), ": ")
+	return &ecosystemError{
+		Service: "hexis", Op: op, Status: hexisStatusTexts[head], Err: err,
+	}
+}
+
 type nexusClient struct {
 	ecosystemHTTP
 }
@@ -530,6 +579,7 @@ func (w *ecosystemWiring) discoverCapabilities(ctx context.Context, entityID str
 	}
 	caps, err := w.hexis.Capabilities(ctx, entityID)
 	if err != nil {
+		err = hexisError("capabilities", err)
 		log.Printf("ecosystem: hexis capabilities error: %v", err)
 		return nil, err
 	}
@@ -557,7 +607,10 @@ func (w *ecosystemWiring) executeCapability(ctx context.Context, capabilityID, t
 
 	exec, err := w.hexis.Execute(ctx, req)
 	if err != nil {
-		return correlationID, fmt.Errorf("execute: %w", err)
+		// A classified dependency failure. The two returns below are NOT: an
+		// execution that ran and failed is the command failing, not Hexis
+		// degrading, and it keeps its plain error so the caller says so.
+		return correlationID, hexisError("execute", err)
 	}
 	if exec.Status == "succeeded" {
 		return correlationID, nil

cmd/mavend/ecosystem_acts.go

@@ -22,8 +22,9 @@ import (
 // already knows which one it was talking to — it records the same name in the
 // trace (Vikunja #521).
 const (
-	serviceNexus = "Nexus"
-	serviceHexis = "Hexis"
+	serviceNexus  = "Nexus"
+	servicePraxis = "Praxis"
+	serviceHexis  = "Hexis"
 )
 
 // serviceVars — the one-key map the eco_down and eco_denied lines take.
@@ -141,7 +142,13 @@ type praxisItemAction struct {
 	verbs   []string
 	ask     string // reply when no item id was given
 	op      string // trace + log name of the operation
-	failure string // reply when the Praxis call errors
+	// failure is the first half of the reply when the Praxis call errors: which
+	// operation did not happen. ecosystemGap supplies the second half, which
+	// names Praxis and splits a refused token from an outage — those two used to
+	// produce the identical sentence and neither said "Praxis" (Vikunja #588).
+	// The verb is kept alongside the service name because the trace is the only
+	// other place it exists, and he is not reading the trace.
+	failure string
 	success string
 	call    func(ctx context.Context, px *praxisClient, id string) error
 }
@@ -158,7 +165,7 @@ func (a praxisItemAction) handle(ctx context.Context, h *reactiveHandler, px *pr
 		log.Printf("ecosystem: praxis %s %s: %v", a.op, id, err)
 		h.recordEcosystemTrace(ctx, "praxis", a.op, traceStatusForError(err), started,
 			mergeFields(traceErrorFields(err), map[string]any{"item_id": id}))
-		return a.failure
+		return a.failure + " " + ecosystemGap(servicePraxis, err)
 	}
 	h.recordPraxisTrace(ctx, a.op, started, map[string]any{"item_id": id})
 	return a.success
@@ -339,14 +346,24 @@ func (entityAttentionCapability) handle(ctx context.Context, h *reactiveHandler,
 	})
 
 	var parts []string
+	var spoken []string
 	for _, item := range items {
 		title, _ := item["title"].(string)
 		if title == "" {
 			continue
 		}
 		parts = append(parts, title)
-		surfaceSpoken(ctx, px, item)
+		if id := surfaceSpoken(ctx, px, item); id != "" {
+			spoken = append(spoken, id)
+		}
 	}
+	// The scoped digest is a list she read out, so it replaces the positional
+	// memory exactly as the unscoped one does. It used to surface these items
+	// and remember none of them, which left the previous digest live: "отметь
+	// второй как сделанное" then indexed into a list he had not just heard and
+	// transitioned somebody else's item (docs/ecosystem.md — a wrong guess here
+	// transitions the wrong item).
+	h.rememberSurfaced(spoken)
 	if known := h.localFactsForEntity(ctx, entityID); known != "" {
 		parts = append(parts, known)
 	}
@@ -551,6 +568,14 @@ func unauthorizedEcosystemError(err error) bool {
 	return errors.As(err, &ee) && ee.Unauthorized()
 }
 
+// isEcosystemError reports a failure that belongs to the service rather than to
+// what was asked of it: a call that never landed, or one the far side refused.
+// It separates "Hexis is down" from "the restart failed".
+func isEcosystemError(err error) bool {
+	var ee *ecosystemError
+	return errors.As(err, &ee)
+}
+
 // traceErrorFields describes an ecosystemError for a trace without leaking the
 // payload: the HTTP status and the failure class, nothing else.
 func traceErrorFields(err error) map[string]any {
@@ -753,6 +778,9 @@ func (h *reactiveHandler) handleHexisAct(ctx context.Context, dec router.Decisio
 			entityID:     entityID,
 			displayName:  displayName,
 			expiry:       h.now().Add(confirmTTL),
+			// This action's id, so the execution the confirm authorises is
+			// joined to the resolve and the discovery that proposed it.
+			correlationID: correlationIDFromCtx(ctx),
 		}
 		h.mu.Unlock()
 		h.recordEcosystemTrace(ctx, "hexis", "confirmation", tracePending, started,
@@ -777,6 +805,14 @@ func (h *reactiveHandler) execHexis(ctx context.Context, capID, capName, entityI
 			mergeFields(traceErrorFields(err), map[string]any{
 				"entity_id": entityID, "capability": capName, "causation_id": causationID,
 			}))
+		// Hexis never answering, or answering "no", is a gap in Hexis and is
+		// named as one — a refused token said "не получилось выполнить команду"
+		// here and sent him to debug a capability that was never reached
+		// (Vikunja #587). An execution that genuinely ran and failed is not an
+		// ecosystemError and keeps the command-level line.
+		if isEcosystemError(err) {
+			return ecosystemGap(serviceHexis, err)
+		}
 		return phraser.A(phraser.ActFailEntity, map[string]string{"name": displayName})
 	}
 	// One record per hop: the second write this used to make said the same

cmd/mavend/ecosystem_gap_test.go

@@ -0,0 +1,159 @@
+package main
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/phraser"
+)
+
+// A refused credential and an outage are different answers, and on the Hexis
+// path only one of them used to be said. These tests pin the difference at both
+// Hexis sites: the discovery hop and the execute hop (Vikunja #587). The Praxis
+// half of the same defect is in praxis_gap_test.go.
+//
+// unreachableURL is a port nothing listens on, which is what "the service is
+// down" looks like from inside a call: the connection is refused, no HTTP
+// answer is ever produced, and ecosystemError.Unreachable() is true.
+const unreachableURL = "http://127.0.0.1:1"
+
+func denied(service, reply string) bool {
+	return phraser.IsA(phraser.EcoDenied, serviceVars(service), reply)
+}
+
+func down(service, reply string) bool {
+	return phraser.IsA(phraser.EcoDown, serviceVars(service), reply)
+}
+
+// hexisGapHandler wires a handler whose Nexus resolves cleanly and whose Hexis
+// is the caller's to break. hexisURL is taken separately so a test can point it
+// at a dead port.
+func hexisGapHandler(t *testing.T, nexusURL, hexisURL string) *reactiveHandler {
+	t.Helper()
+	st := newTestStore(t)
+	now := time.Now()
+	return &reactiveHandler{
+		api:       ipc.NewStoreAPI(st),
+		dataStore: st,
+		now:       func() time.Time { return now },
+		ecosystem: stubEcosystem(nexusURL, hexisURL),
+	}
+}
+
+// TestHexisDiscovery401IsDeniedNotDown — the discovery hop.
+//
+// The vendored Hexis client returns a plain fmt.Errorf for every status at or
+// above 400, so errors.As for *ecosystemError never matched and every failure
+// fell through to the outage line. "Hexis is down" for a rejected token sends
+// him to inspect a service that is running fine.
+func TestHexisDiscovery401IsDeniedNotDown(t *testing.T) {
+	ctx := context.Background()
+	nexus := newFakeNexus(t, fixtureNexusResolved("ent_muzick", muzickIndexer, "service"))
+	caps := fixtureHexisCapabilities(map[string]any{"id": "cap_restart", "name": "restart", "read_only": true})
+	hexis := newFakeHexis(t, caps, fixtureHexisExecuted("exec_1", "succeeded"))
+	h := hexisGapHandler(t, nexus.URL, hexis.URL)
+
+	hexis.SetFault(401)
+	reply := h.handleHexisAct(ctx, actDec("muzick indexer"))
+	if !denied(serviceHexis, reply) {
+		t.Fatalf("401 from hexis discovery: got %q, want the denied line naming Hexis", reply)
+	}
+	if !strings.Contains(reply, serviceHexis) {
+		t.Errorf("reply does not name Hexis: %q", reply)
+	}
+}
+
+// TestHexisDiscoveryOutageIsDownNotDenied — the other half of the same fork.
+// Without this the fix could pass by calling everything a refused credential.
+func TestHexisDiscoveryOutageIsDownNotDenied(t *testing.T) {
+	ctx := context.Background()
+	nexus := newFakeNexus(t, fixtureNexusResolved("ent_muzick", muzickIndexer, "service"))
+	h := hexisGapHandler(t, nexus.URL, unreachableURL)
+
+	reply := h.handleHexisAct(ctx, actDec("muzick indexer"))
+	if !down(serviceHexis, reply) {
+		t.Fatalf("connection refused from hexis: got %q, want the outage line naming Hexis", reply)
+	}
+	if denied(serviceHexis, reply) {
+		t.Error("an outage must not be reported as a refused credential")
+	}
+}
+
+// TestHexisExecute401IsDeniedNotCommandFailure — the execute hop, which did not
+// consult ecosystemGap at all and named neither the service nor the cause.
+func TestHexisExecute401IsDeniedNotCommandFailure(t *testing.T) {
+	ctx := context.Background()
+	nexus := newFakeNexus(t, fixtureNexusResolved("ent_muzick", muzickIndexer, "service"))
+	caps := fixtureHexisCapabilities(map[string]any{"id": "cap_restart", "name": "restart", "read_only": true})
+	hexis := newFakeHexis(t, caps, fixtureHexisExecuted("exec_1", "succeeded"))
+	h := hexisGapHandler(t, nexus.URL, hexis.URL)
+
+	// Discovery stays healthy; only the execute endpoint refuses. A blanket
+	// fault would never reach the site under test.
+	hexis.SetRouteFault("/api/v1/execute", 401)
+	reply := h.handleHexisAct(ctx, actDec("muzick indexer"))
+	if !denied(serviceHexis, reply) {
+		t.Fatalf("401 from hexis execute: got %q, want the denied line naming Hexis", reply)
+	}
+}
+
+// TestHexisExecuteOutageIsDown — same site, the other classification.
+//
+// Discovery and execution share one base URL, so the outage has to be scoped to
+// the execute endpoint rather than to the server: it answers capabilities
+// normally and drops the connection on execute, which is what the client sees
+// when the far side dies mid-call. That produces no HTTP status at all, which is
+// what Unreachable() means.
+func TestHexisExecuteOutageIsDown(t *testing.T) {
+	ctx := context.Background()
+	nexus := newFakeNexus(t, fixtureNexusResolved("ent_muzick", muzickIndexer, "service"))
+	caps := fixtureHexisCapabilities(map[string]any{"id": "cap_restart", "name": "restart", "read_only": true})
+	hexis := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/api/v1/execute" {
+			conn, _, err := w.(http.Hijacker).Hijack()
+			if err != nil {
+				t.Errorf("hijack: %v", err)
+				return
+			}
+			conn.Close()
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(caps))
+	}))
+	t.Cleanup(hexis.Close)
+	h := hexisGapHandler(t, nexus.URL, hexis.URL)
+
+	reply := h.handleHexisAct(ctx, actDec("muzick indexer"))
+	if !down(serviceHexis, reply) {
+		t.Fatalf("dropped connection on hexis execute: got %q, want the outage line", reply)
+	}
+	if denied(serviceHexis, reply) {
+		t.Error("an outage must not be reported as a refused credential")
+	}
+}
+
+// TestHexisExecutionFailedStaysCommandFailure — the boundary of the fix. Hexis
+// answering 200 with a failed execution is the command failing, not Hexis
+// degrading, and it must keep the command-level line rather than accusing a
+// healthy service of being down.
+func TestHexisExecutionFailedStaysCommandFailure(t *testing.T) {
+	ctx := context.Background()
+	nexus := newFakeNexus(t, fixtureNexusResolved("ent_muzick", muzickIndexer, "service"))
+	caps := fixtureHexisCapabilities(map[string]any{"id": "cap_restart", "name": "restart", "read_only": true})
+	hexis := newFakeHexis(t, caps, fixtureHexisExecutionFailed("exec_1", "unit refused to start"))
+	h := hexisGapHandler(t, nexus.URL, hexis.URL)
+
+	reply := h.handleHexisAct(ctx, actDec("muzick indexer"))
+	if down(serviceHexis, reply) || denied(serviceHexis, reply) {
+		t.Fatalf("a failed execution must not be reported as an ecosystem gap, got %q", reply)
+	}
+	if !phraser.IsA(phraser.ActFailEntity, map[string]string{"name": muzickIndexer}, reply) {
+		t.Fatalf("want the command-failure line, got %q", reply)
+	}
+}

cmd/mavend/ecosystem_harness_test.go

@@ -115,3 +115,83 @@ func TestFakeNexus_FaultInjectionThenRecovery(t *testing.T) {
 		t.Fatalf("expected success once nexus recovers, got %q", reply)
 	}
 }
+
+// TestPraxisEntityAttention_RemembersWhatItReadOut: the scoped digest is a list
+// she read out, so a positional follow-up must land on one of ITS items. It
+// surfaced them and remembered none, which left the previous digest live and
+// sent "отметь второй" at somebody else's item.
+func TestPraxisEntityAttention_RemembersWhatItReadOut(t *testing.T) {
+	ctx := context.Background()
+	nexus := newFakeNexus(t, fixtureNexusResolved("ent_muzick", "Muzick indexer", "service"))
+	scoped := fixturePraxisAttentionScoped("ent_muzick",
+		map[string]any{"id": "item_scoped_1", "title": "indexer wedged"})
+	praxis := newFakePraxis(t, scoped)
+	h := ecoHandler(t, nexus, praxis, nil)
+
+	// A digest from an earlier turn, still the positional memory.
+	h.rememberSurfaced([]string{"item_stale"})
+
+	reply := h.handlePraxisAct(ctx, router.Decision{
+		Intent: router.IntentAct,
+		Slots:  router.Slots{Fn: "entity_attention", HasFn: true, Value: "muzick indexer"},
+	})
+	if !strings.Contains(reply, "indexer wedged") {
+		t.Fatalf("expected the scoped item to be read out, got %q", reply)
+	}
+
+	h.mu.Lock()
+	surfaced := append([]string(nil), h.surfacedItems...)
+	h.mu.Unlock()
+	if len(surfaced) != 1 || surfaced[0] != "item_scoped_1" {
+		t.Fatalf("scoped digest must replace the positional memory, got %v", surfaced)
+	}
+
+	// The follow-up resolves against what he just heard, not the stale list.
+	if reply := h.handlePraxisAct(ctx, praxisItemDec("resolve_item", "last")); reply == "" {
+		t.Fatal("positional follow-up should have been claimed by praxis")
+	}
+	var body string
+	for _, r := range praxis.Requests() {
+		if r.Method == "POST" && r.Path == "/api/v1/tools/resolve" {
+			body = string(r.Body)
+		}
+	}
+	if !strings.Contains(body, "item_scoped_1") {
+		t.Fatalf("resolve must transition the item she read out, posted %q", body)
+	}
+	if strings.Contains(body, "item_stale") {
+		t.Fatal("resolve transitioned an item from a previous digest")
+	}
+}
+
+// TestHexisConfirm_KeepsOneCorrelationIDPerAction: the confirm arrives on a
+// later turn with a context of its own. The contract mints one id per action,
+// so the execution it authorises must still be joinable to the resolve and the
+// discovery that proposed it — it recorded a fresh id and no causation at all.
+func TestHexisConfirm_KeepsOneCorrelationIDPerAction(t *testing.T) {
+	ctx := context.Background()
+	nexus := newFakeNexus(t, fixtureNexusResolved("ent_muzick", "Muzick indexer", "service"))
+	caps := fixtureHexisCapabilities(map[string]any{"id": "cap_restart", "name": "restart", "read_only": false})
+	hexis := newFakeHexis(t, caps, fixtureHexisExecuted("exec_1", "succeeded"))
+	h := ecoHandler(t, nexus, nil, hexis)
+
+	if reply := h.handleHexisAct(ctx, actDec("restart")); !strings.Contains(reply, "да") {
+		t.Fatalf("mutating capability must ask for confirmation, got %q", reply)
+	}
+	resolve := findTrace(t, h, "nexus", "resolve")
+	if resolve == nil || resolve.CorrelationID == "" {
+		t.Fatalf("expected a nexus resolve trace carrying a correlation id, got %+v", resolve)
+	}
+
+	if _, handled := h.resolveConfirm(ctx, "да"); !handled {
+		t.Fatal("confirm should have been claimed")
+	}
+	exec := findTrace(t, h, "hexis", "execute")
+	if exec == nil {
+		t.Fatal("expected a hexis execute trace")
+	}
+	if exec.CausationID != resolve.CorrelationID {
+		t.Fatalf("confirmed execution must cite the action that proposed it: causation %q, action %q",
+			exec.CausationID, resolve.CorrelationID)
+	}
+}

cmd/mavend/praxis_gap_test.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/kami/maven/internal/phraser"
+)
+
+// A Praxis lifecycle failure used to return a hardcoded constant that named the
+// verb and never the service, so an outage, a refused token and a contract
+// mismatch all produced the identical sentence (Vikunja #588). The helpers and
+// the Hexis half of the same defect are in ecosystem_gap_test.go.
+
+func TestPraxisLifecycle401NamesPraxis(t *testing.T) {
+	ctx := context.Background()
+	praxis := newFakePraxis(t, fixturePraxisAttentionItems())
+	h := newPraxisTestHandler(t, praxis)
+
+	praxis.SetFault(401)
+	reply := h.handlePraxisAct(ctx, praxisItemDec("resolve_item", "item_1"))
+	if !strings.Contains(reply, servicePraxis) {
+		t.Fatalf("praxis failure does not name Praxis: %q", reply)
+	}
+	if !strings.Contains(reply, phraser.A(phraser.EcoDenied, serviceVars(servicePraxis))) {
+		t.Fatalf("401 from praxis: got %q, want the denied line", reply)
+	}
+	// The verb that did not happen is still said: the trace is the only other
+	// place it exists and he is not reading the trace.
+	if !strings.Contains(reply, "не получилось отметить сделанным.") {
+		t.Errorf("reply dropped the operation that failed: %q", reply)
+	}
+}
+
+// TestPraxisLifecycleOutageDiffersFrom401 — the identity that was the bug.
+func TestPraxisLifecycleOutageDiffersFrom401(t *testing.T) {
+	ctx := context.Background()
+	praxis := newFakePraxis(t, fixturePraxisAttentionItems())
+	h := newPraxisTestHandler(t, praxis)
+
+	praxis.SetFault(401)
+	refused := h.handlePraxisAct(ctx, praxisItemDec("acknowledge_item", "item_1"))
+
+	h.ecosystem = &ecosystemWiring{praxis: newPraxisClient(unreachableURL)}
+	outage := h.handlePraxisAct(ctx, praxisItemDec("acknowledge_item", "item_1"))
+
+	if refused == outage {
+		t.Fatalf("a refused token and an outage still say the same thing: %q", refused)
+	}
+	if !strings.Contains(outage, phraser.A(phraser.EcoDown, serviceVars(servicePraxis))) {
+		t.Fatalf("praxis outage: got %q, want the outage line naming Praxis", outage)
+	}
+}

cmd/mavend/reminderwhen.go

@@ -0,0 +1,209 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/kami/maven/internal/dialogue"
+	"github.com/kami/maven/internal/router"
+)
+
+// A reminder commits only when three things are answered: what to say, what
+// time to say it, and what day (owner's rule, 2026-08-06, V-579). Anything
+// missing is asked about, and nothing missing is filled from the clock.
+//
+// "напомни завтра в 3 заказать цветы" has the what and the day and an hour that
+// could be either half of the day, so she asks which 3. "напомни в 9 вечера
+// разгрузить стиралку" has the what and an unambiguous hour and no day, so she
+// asks which day. Today being a valid reading is not the same as him saying it.
+//
+// Two things are already whole and are not asked about. A time that admits one
+// reading is not queried for its half of the day, so "завтра в 15:00" commits.
+// And an interval is an instant, so "через час" carries all three by itself.
+type whenGap string
+
+const (
+	whenComplete      whenGap = ""
+	whenNoHour        whenGap = "hour"
+	whenAmbiguousHour whenGap = "part_of_day"
+	whenNoDay         whenGap = "day"
+)
+
+// whenGapOf reads the request and names the first thing about its time that he
+// has not said. hasTime is whether a parser could read an instant out of it,
+// which is necessary and not sufficient: the parser answers a dayless "в 9"
+// with a day it picked.
+func whenGapOf(text string, hasTime bool) whenGap {
+	if !router.NamesAnHour(text) {
+		return whenNoHour
+	}
+	if router.NamesAnInterval(text) {
+		return whenComplete
+	}
+	if !hasTime {
+		return whenNoHour
+	}
+	if router.HourIsAmbiguous(text) {
+		return whenAmbiguousHour
+	}
+	if !router.NamesADay(text) {
+		return whenNoDay
+	}
+	return whenComplete
+}
+
+// whenQuestion is what she asks for each gap. Every one of them opens with the
+// current time, because she is reasoning from it and he cannot check that
+// reasoning unless he hears it. The hour deck varies with the attempt, like
+// every other slot; the other two say one thing and there is only one way to
+// say it.
+//
+// taken is what his last turn added, in his own words, and it goes between the
+// clock and the question (V-593). It is empty whenever his turn moved nothing
+// forward, which is the case where repeating the question verbatim is honest.
+func whenQuestion(gap whenGap, attempt int, now time.Time, taken string) (string, bool) {
+	clock := fmt.Sprintf("Сейчас %s.", now.Format("15:04"))
+	if taken != "" {
+		clock += " " + taken
+	}
+	switch gap {
+	case whenNoHour:
+		q, ok := clarifyQuestionFor(dialogue.SlotTime, attempt)
+		if !ok {
+			return "", false
+		}
+		return clock + " " + q, true
+	case whenAmbiguousHour:
+		return clock + " Это утра или вечера?", true
+	case whenNoDay:
+		return clock + " В какой день?", true
+	}
+	return "", false
+}
+
+// whenKnown — the three things he has to say about the time, and whether the
+// words so far say them. Read off the same predicates whenGapOf reads, so the
+// two cannot disagree about what is still open.
+type whenKnown struct{ hour, part, day bool }
+
+func whenKnownOf(text string, hasTime bool) whenKnown {
+	if !router.NamesAnHour(text) {
+		return whenKnown{}
+	}
+	if router.NamesAnInterval(text) {
+		return whenKnown{hour: true, part: true, day: true}
+	}
+	if !hasTime {
+		return whenKnown{}
+	}
+	return whenKnown{
+		hour: true,
+		part: !router.HourIsAmbiguous(text),
+		day:  router.NamesADay(text),
+	}
+}
+
+// movedForward reports whether b says something a did not.
+func (a whenKnown) movedForward(b whenKnown) bool {
+	return (!a.hour && b.hour) || (!a.part && b.part) || (!a.day && b.day)
+}
+
+// whenTakenLine — the acknowledgement in front of a re-ask, in the words he
+// just used (V-593).
+//
+// It is an echo and never a restatement, for the same reason the fact
+// confirmation is (V-592): a 1.7B asked to say a Russian sentence back invents.
+// Its only job is evidence that the turn between two asks was heard, so after
+// "на 9" and then "на завтра" she does not ask "утра или вечера?" twice
+// byte-identically while he wonders whether the microphone is on.
+func whenTakenLine(text string) string {
+	text = strings.TrimSpace(text)
+	text = strings.TrimRight(text, " \t.,!?;:")
+	if text == "" {
+		return ""
+	}
+	return "Поняла: " + text + "."
+}
+
+// whenTextOf is everything he has said about when, the original request plus
+// every answer he has given to a question about it.
+//
+// The answers are kept apart from the utterance on purpose. The utterance is
+// the reminder's payload, so folding "завтра" into it would have her read the
+// day back to him at the time she says it. And a time answer has to be read
+// against the request rather than alone: "завтра" names no hour, and the hour
+// it belongs to is the one she is already holding.
+func whenTextOf(q *dialogue.PendingQuestion) string {
+	if q.WhenText == "" {
+		return q.Utterance
+	}
+	return strings.TrimSpace(q.Utterance + " " + q.WhenText)
+}
+
+// slotStillMissing reports whether a slot is still open. Every slot but the
+// reminder's time is open when it is empty; the time is open until all three of
+// what he must say about it are said.
+func slotStillMissing(slot dialogue.Slot, utterance string, s dialogue.Slots) bool {
+	if len(dialogue.StillMissing([]dialogue.Slot{slot}, s)) > 0 {
+		return true
+	}
+	return slot == dialogue.SlotTime && whenGapOf(utterance, s.HasTime) != whenComplete
+}
+
+// readWhen reads the instant out of what he has said about the time, newest
+// statement first.
+//
+// The request plus his latest answer is tried before the whole history, and
+// that order is what makes a correction win: "нет, сегодня в 15:00" after "в
+// 11:00" must land on 15:00, and a parser reading left to right off the joined
+// history would find the 11 he just took back. The history is the fallback,
+// because an answer often completes an earlier one rather than replacing it -
+// "вечера" says which 9, and alone it names no hour at all.
+func (h *reactiveHandler) readWhen(ctx context.Context, intent router.Intent, q *dialogue.PendingQuestion, text string) (time.Time, bool) {
+	latest := strings.TrimSpace(q.Utterance + " " + text)
+	if router.NamesAnHour(text) {
+		if w := h.extractor.Extract(ctx, intent, latest, h.now()); w.HasTime {
+			return w.Time, true
+		}
+	}
+	if w := h.extractor.Extract(ctx, intent, whenTextOf(q), h.now()); w.HasTime {
+		return w.Time, true
+	}
+	return time.Time{}, false
+}
+
+// asksAboutTime reports whether the parked question is one about when.
+func asksAboutTime(missing []dialogue.Slot) bool {
+	for _, s := range missing {
+		if s == dialogue.SlotTime {
+			return true
+		}
+	}
+	return false
+}
+
+// stillOpen reports whether any of the slots she asked about is still unsaid.
+func stillOpen(missing []dialogue.Slot, utterance string, s dialogue.Slots) bool {
+	for _, slot := range missing {
+		if slotStillMissing(slot, utterance, s) {
+			return true
+		}
+	}
+	return false
+}
+
+// stillMissingFor is missingFor's engine, in wantedSlots order. It reads the
+// utterance as well as the slots, which plain StillMissing cannot: whether an
+// hour is ambiguous is a fact about the words, not about the instant they
+// parsed to.
+func stillMissingFor(intent router.Intent, utterance string, s dialogue.Slots) []dialogue.Slot {
+	var out []dialogue.Slot
+	for _, want := range wantedSlots[intent] {
+		if slotStillMissing(want, utterance, s) {
+			out = append(out, want)
+		}
+	}
+	return out
+}

cmd/mavend/replier_llm.go

@@ -31,6 +31,14 @@ func (r *llmReplier) Reply(d router.Decision) string {
 		// a generation to say something this small.
 		return clarifyMissedLine(d)
 	}
+	if d.Intent == router.IntentFact {
+		// A captured fact is confirmed by echoing him, and the model is not
+		// asked (V-592). It has nothing to phrase FROM: replyContext hands it
+		// "записала факт: water \"drank\"", so every Russian word in the reply
+		// was the model's own invention, and on 2026-08-06 that was "Проверила,
+		// что ты выпел стакан воды" for "я выпил воды".
+		return phraser.FactAck(d.Utterance)
+	}
 	out, err := r.p.PhraseReply(context.Background(), d)
 	if err != nil || out == "" {
 		return r.stub.Reply(d)

cmd/mavend/ruwords.go

@@ -17,6 +17,7 @@ import (
 	"time"
 
 	"github.com/kami/maven/internal/lexicon"
+	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/say"
 )
 
@@ -73,22 +74,26 @@ func mentionsUnknownPlace(u string) bool {
 // date for a day she did not understand.
 const onlyNearDaysReply = "я считаю только сегодня, завтра, послезавтра и вчера — про другие дни пока не скажу."
 
-// dayWords — day references the calendar parser cannot resolve. A weekday name
-// or a "через …" phrase means he asked about a specific other day.
-var dayWords = []string{
-	"понедельник", "вторник", "сред", "четверг", "пятниц", "суббот", "воскресен",
-	"через", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday",
-}
-
 // mentionsUnknownDay reports whether the question names a day the calendar
 // parser could not resolve. Mirror of mentionsUnknownPlace: it exists only to
 // pick an honest reply over a confidently wrong one.
 //
 // Only called after ParseCalendarDate has already failed, so "завтра" and the
 // other words it does know never reach here.
+//
+// The weekday half was a list of STEMS matched with strings.Contains until
+// V-581 — "сред", "пятниц", "суббот". That is the hand-written Russian pattern
+// the sweep of 2026-08-04 took out, and it was wrong in the way such a pattern
+// always is: "среди", "средство" and "средний" all contain "сред", so a question
+// carrying any of them was answered with onlyNearDaysReply instead of the date.
+// Whole tokens now, and the weekday itself is router.WeekdayIndex, which reads
+// the lexicon and asks the dictionary about the case.
 func mentionsUnknownDay(u string) bool {
-	for _, w := range dayWords {
-		if strings.Contains(u, w) {
+	for _, tok := range quietTokens(u) {
+		if tok == "через" {
+			return true
+		}
+		if _, ok := router.WeekdayIndex(tok); ok {
 			return true
 		}
 	}
@@ -149,6 +154,11 @@ func hasDurationWords(u string) bool {
 // Used by the query handler when answering "когда я это сделал?"-style questions.
 func formatTime(t time.Time) string {
 	now := time.Now()
+	// The argument is a fact's Ts, which the store hands back as UTC. Only the
+	// last branch names a wall clock, and it named the store's until V-614: an
+	// answer to "когда я это сделал?" read hours off, in the same sentence
+	// shape the plan reads a day in.
+	t = t.Local()
 	if t.After(now.Add(-2*time.Minute)) && t.Before(now.Add(2*time.Minute)) {
 		return "только что"
 	}

cmd/mavend/ruwords_test.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+// "когда я это сделал?" answers off a fact's Ts, which the store hands back as
+// UTC, and the branch that names a wall clock printed it in whatever zone it
+// arrived in (V-614). The instant here is built three hours off this machine's
+// zone, so the assertion holds under TZ=UTC as well.
+func TestFormatTimeReadsHisClock(t *testing.T) {
+	_, off := time.Now().Zone()
+	away := time.FixedZone("away", off+3*60*60)
+	stored := time.Now().Add(-72 * time.Hour).In(away)
+
+	got := formatTime(stored)
+	if want := stored.Local().Format("15:04"); !strings.Contains(got, want) {
+		t.Errorf("formatTime = %q, want the hour on his clock (%s)", got, want)
+	}
+	if bad := stored.Format("15:04"); strings.Contains(got, bad) {
+		t.Errorf("formatTime = %q reads the zone the fact arrived in (%s)", got, bad)
+	}
+}
+
+// TestMentionsUnknownDayReadsWordsNotStems — the defect V-581 found. The
+// weekday half of this guard was a list of stems matched with strings.Contains,
+// so "среди", "средство" and "средний" all read as Wednesday and the question
+// was answered with onlyNearDaysReply instead of a date.
+//
+// The other half of the fix is coverage: a stem list stops at the forms whoever
+// wrote it thought of, and "воскресеньях" was not one of them.
+func TestMentionsUnknownDayReadsWordsNotStems(t *testing.T) {
+	for _, u := range []string{
+		"какое число в понедельник",
+		"какое число в среду",
+		"какое число в среде",
+		"что там по воскресеньям",
+		"what is the date on friday",
+		"какое число через неделю",
+	} {
+		if !mentionsUnknownDay(u) {
+			t.Errorf("mentionsUnknownDay(%q) = false, want true", u)
+		}
+	}
+	for _, u := range []string{
+		"какое число в среднем",
+		"сколько это в среднем",
+		"какое сегодня средство",
+		"какое число",
+	} {
+		if mentionsUnknownDay(u) {
+			t.Errorf("mentionsUnknownDay(%q) = true; it names no day", u)
+		}
+	}
+}

cmd/mavend/testdata/scenarios/evening_degraded.json

@@ -24,8 +24,8 @@
       "at": "21:00",
       "note": "he speaks. The whole voice path runs: push-to-talk, the STT seam parked with the golden transcript, the real router, the real store write, the phrasing contract.",
       "audio": "ru_fact",
-      "expect_reply_contains": ["записала"],
-      "expect_reply_lacks": ["записал ", "записал,", "записал.", "милый", "ваш"],
+      "expect_reply_contains": ["записала", "выпил воды"],
+      "expect_reply_lacks": ["записал ", "записал,", "записал.", "милый", "ваш", "стакан"],
       "expect_events": ["water"]
     },
     {

cmd/mavend/testdata/scenarios/morning_missed.json

@@ -81,10 +81,10 @@
     },
     {
       "at": "08:55",
-      "note": "stating a fact writes it and says so, in the feminine. This reply comes back through the replier from the scripted model, so the persona check is against generated text rather than a constant. The masculine forms are listed with their following character — \"записал \" and \"записал,\" — because \"записала\" contains \"записал\", and the earlier check on the comma alone passed on \"записал что ты выпил воды\".",
+      "note": "stating a fact writes it and says so, in the feminine, and in his own words. The reply no longer comes from the model at all (V-592): a 1.7B asked to restate «я выпил воды» answered «Проверила, что ты выпел стакан воды», so the confirmation is now a deck frame with his sentence in it. The masculine forms are listed with their following character — \"записал \" and \"записал,\" — because \"записала\" contains \"записал\".",
       "say": "я выпил воды",
-      "expect_reply_contains": ["записала"],
-      "expect_reply_lacks": ["записал ", "записал,", "записал.", "милый"],
+      "expect_reply_contains": ["записала", "я выпил воды"],
+      "expect_reply_lacks": ["записал ", "записал,", "записал.", "милый", "стакан"],
       "expect_events": ["water"]
     },
     {

cmd/mavend/turnrole.go

@@ -31,6 +31,7 @@ const (
 	roleCorrection    turnRole = "correction"     // it replaces a value she already had
 	roleSideQuery     turnRole = "side_query"     // a question of its own, asked mid-flow
 	roleNewRequest    turnRole = "new_request"    // a different request entirely
+	roleAside         turnRole = "aside"          // something he stated, not an answer
 	roleCancel        turnRole = "cancel"         // call the pending action off
 	roleNotApplicable turnRole = "not_applicable" // nothing is pending; not our turn
 )
@@ -212,11 +213,28 @@ func classifyTurnRole(q *dialogue.PendingQuestion, text string, answer dialogue.
 	// tests are the floor and answer for free; the route is what sees a request
 	// with no shape to it — "погода в риме" asks a question and carries neither
 	// a question mark nor an interrogative, and only the router knows that.
+	//
+	// An utterance of pure frame gets one more chance, and V-577 is why. Every
+	// token of "что у меня сегодня?" is frame, so the content gate called it an
+	// answer, the parked reminder took "сегодня" for its time, and the question
+	// he asked was answered nowhere. A routed intent beats a frame match,
+	// because the frame is a hint and the route is a decision.
+	//
+	// The condition is that it fills nothing she asked about. That keeps the
+	// hedged "а что если в 11:00" an answer, which is what it is: it carries the
+	// hour, and no route saying "question" changes that. It works because the
+	// extractor no longer reads a day word as the current clock, so a sentence
+	// that names no hour now fills nothing to weigh.
 	own := false
 	if len(ownContent(text)) > 0 {
 		own = offlineOwnRequest(text) || (ok && carriesOwnRequest(routed, text))
+	} else if ok && fillsNothingAsked(q, answer) {
+		own = carriesOwnRequest(routed, text)
 	}
 	if !own {
+		if isAside(q, text, answer, routed, ok) {
+			return roleAside
+		}
 		if replacesFilledSlot(q, answer) {
 			return roleCorrection
 		}
@@ -228,6 +246,59 @@ func classifyTurnRole(q *dialogue.PendingQuestion, text string, answer dialogue.
 	return roleNewRequest
 }
 
+// isAside reports whether the utterance is something he STATED while she was
+// waiting on a question (V-577 shape 2).
+//
+// "у меня новый ноутбук" said into a parked reminder was dropped in silence: it
+// carries no capture verb, so it is not a request of its own, and it fills no
+// slot, so it is not an answer either. Neither storing it nor saying it was
+// ignored is the one behaviour that is wrong, and it was the behaviour.
+//
+// Three conditions, and all three are needed. The route has to call it a
+// statement AND stand behind that, so a bare time is never an aside. It has to
+// fill none of what she asked about, so an answer she can use stays an answer.
+// And it has to say something, so a shrug is still a failed answer and still
+// spends a retry.
+func isAside(q *dialogue.PendingQuestion, text string, answer dialogue.Slots, routed router.Decision, ok bool) bool {
+	if !ok || q == nil {
+		return false
+	}
+	if !statesSomething(routed) {
+		return false
+	}
+	if len(ownContent(text)) == 0 {
+		return false
+	}
+	return fillsNothingAsked(q, answer)
+}
+
+// statesSomething reports whether the route is evidence that these words state
+// a thing, rather than a guess she has to interrupt a flow over.
+//
+// Two kinds of evidence, and the second one exists because the classifier floor
+// marks nearly everything Clarify. A parsed fact key comes from the
+// deterministic fact parser and not from a similarity score, so "я выпил воды"
+// is a statement on any engine. A confident note or fact is the other kind, and
+// that is the one the resident model gives for "у меня новый ноутбук".
+func statesSomething(routed router.Decision) bool {
+	switch routed.Intent {
+	case router.IntentFact:
+		return routed.Slots.HasKey || !routed.Clarify
+	case router.IntentNote:
+		return !routed.Clarify
+	}
+	return false
+}
+
+// fillsNothingAsked reports whether the utterance gave her none of what she
+// asked for. Nothing is pending counts as nothing filled.
+func fillsNothingAsked(q *dialogue.PendingQuestion, answer dialogue.Slots) bool {
+	if q == nil {
+		return true
+	}
+	return len(dialogue.StillMissing(q.Missing, answer)) == len(q.Missing)
+}
+
 // replacesFilledSlot reports whether the utterance overwrites something the
 // pending action already had, rather than filling the gap she asked about —
 // "нет, на девять" while she is waiting for the subject. Both are handled the

cmd/mavend/turnrole_test.go

@@ -123,6 +123,37 @@ func TestTurnRoleReadsTheRoutedDecision(t *testing.T) {
 			ok:     true,
 			want:   roleAnswer,
 		},
+		{
+			// V-577 shape 1. Every token is frame, so the content gate called
+			// this an answer and the reminder took "сегодня" for its time. It
+			// fills nothing she asked about, so the route decides, and the route
+			// says the calendar answers it.
+			name:   "an agenda question of pure frame words is a side query",
+			text:   "что у меня сегодня?",
+			routed: dec(router.IntentQuery, router.Slots{}),
+			ok:     true,
+			want:   roleSideQuery,
+		},
+		{
+			// V-577 shape 2. Neither a slot value nor a request nor a cancel.
+			// It was dropped in silence; it is an aside, and an aside is stored
+			// and re-asked.
+			name:   "a fact stated mid-flow is an aside",
+			text:   "у меня новый ноутбук",
+			routed: dec(router.IntentNote, router.Slots{Text: "у меня новый ноутбук"}),
+			ok:     true,
+			want:   roleAside,
+		},
+		{
+			// A route she is not sure of is not evidence that he stated
+			// anything, and "позвонить маме" is the answer to the other half of
+			// a reminder.
+			name:   "an unsure note is not an aside",
+			text:   "позвонить маме",
+			routed: router.Decision{Intent: router.IntentNote, Clarify: true},
+			ok:     true,
+			want:   roleAnswer,
+		},
 		{
 			name: "a bare noun that answers nothing is still an answer",
 			text: "ага",

cmd/mavend/turnroute.go

@@ -110,6 +110,16 @@ func (h *reactiveHandler) routeForRole(ctx context.Context, text string) (router
 // This is a fast path to the SAME answer and must stay one. If it ever needs a
 // rule the classifier does not have, it has become a second decision procedure
 // and it is the thing V-560 deleted.
+//
+// A question shape is the exception and V-577 is why (measured 2026-08-06).
+// "что у меня сегодня?" is an interrogative, a preposition, a particle and a day
+// word, so every token of it is frame and it left no content of its own. The
+// fast path called it an answer, the parked reminder read "сегодня" as its time,
+// and the question he asked was never answered. Asked alone the same sentence
+// routes to query at stage 0, so the route knew and was never consulted.
 func needsRoute(text string) bool {
-	return !isCancel(text) && len(ownContent(text)) > 0
+	if isCancel(text) {
+		return false
+	}
+	return len(ownContent(text)) > 0 || router.IsQuestionShaped(text)
 }

cmd/mavend/weatherq.go

@@ -7,6 +7,10 @@ package main
 import (
 	"regexp"
 	"strings"
+
+	"github.com/kami/maven/internal/lexicon"
+	"github.com/kami/maven/internal/morph"
+	"github.com/kami/maven/internal/router"
 )
 
 // isWeatherQuery returns true if the utterance is about weather.
@@ -27,16 +31,42 @@ func isWeatherQuery(u string) bool {
 // come through whole and "в 5 утра" does not.
 var weatherPlace = regexp.MustCompile(`(?i)(?:^|\s)(?:в|во|in)\s+([\p{L}-]+(?:\s+[\p{L}-]+)?)`)
 
-// weatherNonPlaces — words that follow "в" in a weather question and are not
-// cities. "какая погода в доме" is the smart-home sensor, not Open-Meteo, and
-// "тепло в комнате" is the same question about the same room.
-var weatherNonPlaces = map[string]bool{
+// weatherRooms — the rooms of the house, which are the only words in this
+// guard that belong to it. "какая погода в доме" is the smart-home sensor, not
+// Open-Meteo, and "тепло в комнате" is the same question about the same room.
+//
+// The rest of the guard used to be a third copy of three closed sets that
+// already exist in the lexicon: the weekdays, the parts of the day, and the
+// words that follow "в" without naming a place (V-581). Each copy was short in
+// its own direction — "среду" but not "среде", "утром" but not "утра", "целом"
+// but not "общем" — so the same question phrased one word differently reached
+// the geocoder as a city.
+var weatherRooms = map[string]bool{
 	"доме": true, "квартире": true, "комнате": true, "спальне": true,
 	"гостиной": true, "кухне": true, "гараже": true, "офисе": true,
-	"выходные": true, "субботу": true, "воскресенье": true, "понедельник": true,
-	"вторник": true, "среду": true, "четверг": true, "пятницу": true,
-	"обед": true, "обеде": true, "утро": true, "утром": true, "вечер": true,
-	"вечером": true, "ночь": true, "ночью": true, "целом": true, "принципе": true,
+	"обед": true, "обеде": true, "выходные": true, "выходных": true,
+}
+
+// isWeatherNonPlace reports whether the word after "в" names something other
+// than a place he could ask the weather for.
+func isWeatherNonPlace(word string) bool {
+	if weatherRooms[word] {
+		return true
+	}
+	if _, ok := router.WeekdayIndex(word); ok {
+		return true
+	}
+	for _, w := range lexicon.PartsOfDay() {
+		if word == w || morph.SameWord(word, w) {
+			return true
+		}
+	}
+	for _, w := range lexicon.NotPlaceAfterV() {
+		if word == w {
+			return true
+		}
+	}
+	return false
 }
 
 // extractWeatherLocation returns the place he named, or the configured default
@@ -63,7 +93,7 @@ func extractWeatherLocation(u, defaultLoc string) string {
 	}
 	place := strings.TrimSpace(m[1])
 	first := strings.ToLower(strings.Fields(place)[0])
-	if weatherNonPlaces[first] {
+	if isWeatherNonPlace(first) {
 		return defaultLoc
 	}
 	return place

cmd/mavend/weatherq_test.go

@@ -29,6 +29,13 @@ func TestExtractWeatherLocation(t *testing.T) {
 		// the house sensors and the day words answer elsewhere.
 		{"тепло в комнате?", "Berlin", "Berlin"},
 		{"какая погода в выходные", "Berlin", "Berlin"},
+		// The cases the three private copies of the lexicon were short by
+		// (V-581): a weekday in a case the old map did not list, a part of the
+		// day in one it did not list, and "в общем".
+		{"какая погода в среде", "Berlin", "Berlin"},
+		{"какая погода в воскресеньях", "Berlin", "Berlin"},
+		{"какая погода в понедельникам", "Berlin", "Berlin"},
+		{"какая погода в общем", "Berlin", "Berlin"},
 	}
 	for _, c := range cases {
 		if got := extractWeatherLocation(c.utterance, c.def); got != c.want {

cmd/mavpoll/main.go

@@ -77,6 +77,21 @@ func run(args []string) error {
 	if *netdataURL == "" && *kumaURL == "" && *wgIface == "" && *zenTokenFile == "" {
 		return fmt.Errorf("nothing to poll: set -netdata, -kuma, -wg and/or -zenmoney-token-file")
 	}
+	// A bad duration or an empty -wg-cmd used to get past start and kill the
+	// poller on the first tick — time.NewTicker panics on a non-positive
+	// interval, and pollWg indexed field 0 of an empty command. A zero -timeout
+	// is worse than a crash: http.Client reads it as "no deadline", so one
+	// wedged source stalls every other source behind it forever. Refuse all
+	// three here, where the operator sees the message.
+	if *interval <= 0 {
+		return fmt.Errorf("-interval must be positive, got %s", *interval)
+	}
+	if *timeout <= 0 {
+		return fmt.Errorf("-timeout must be positive, got %s", *timeout)
+	}
+	if *wgIface != "" && strings.TrimSpace(*wgCmd) == "" {
+		return fmt.Errorf("-wg-cmd is empty but -wg is set")
+	}
 
 	zen, err := newZenClient(*zenTokenFile, *zenURL, *timeout)
 	if err != nil {
@@ -283,9 +298,19 @@ const (
 // `wg show` needs CAP_NET_ADMIN; run mavpoll with the cap or set -wg-cmd "sudo wg".
 func (p *poller) pollWg(ctx context.Context) error {
 	fields := strings.Fields(p.wgCmd)
+	if len(fields) == 0 {
+		return fmt.Errorf("wg command is empty")
+	}
 	args := append(fields[1:], "show", p.wgIface, "latest-handshakes")
 	out, err := exec.CommandContext(ctx, fields[0], args...).Output()
 	if err != nil {
+		// wg says why it refused on stderr — usually a missing CAP_NET_ADMIN or
+		// an interface that does not exist. Output() drops that, leaving a log
+		// line that reads "exit status 1" and diagnoses nothing.
+		var ee *exec.ExitError
+		if errors.As(err, &ee) && len(ee.Stderr) > 0 {
+			return fmt.Errorf("run %s: %w: %s", p.wgCmd, err, strings.TrimSpace(string(ee.Stderr)))
+		}
 		return fmt.Errorf("run %s: %w", p.wgCmd, err)
 	}
 	maxTs := parseMaxHandshake(string(out))
@@ -552,6 +577,11 @@ func isNoFact(err error) bool {
 
 // maxBodyBytes caps what a source can make the poller hold. Kuma's whole
 // metrics page is a few hundred kilobytes, so 4 MiB is slack, not a budget.
+//
+// Hitting the cap is an error, not a shorter body. A truncated kuma page parses
+// cleanly right up to the cut, and every monitor past it reads as deleted — the
+// poller would write "unknown" over live services and the down-rule would go
+// quiet. Reading one byte past the cap is how we tell full from truncated.
 const maxBodyBytes = 4 << 20
 
 func (p *poller) get(ctx context.Context, url, basicUser string) ([]byte, error) {
@@ -567,12 +597,15 @@ func (p *poller) get(ctx context.Context, url, basicUser string) ([]byte, error)
 		return nil, err
 	}
 	defer resp.Body.Close()
-	body, err := io.ReadAll(io.LimitReader(resp.Body, maxBodyBytes))
+	body, err := io.ReadAll(io.LimitReader(resp.Body, maxBodyBytes+1))
 	if err != nil {
 		return nil, err
 	}
 	if resp.StatusCode != http.StatusOK {
 		return nil, fmt.Errorf("GET %s: %s", url, resp.Status)
 	}
+	if len(body) > maxBodyBytes {
+		return nil, fmt.Errorf("GET %s: body over %d bytes", url, maxBodyBytes)
+	}
 	return body, nil
 }

cmd/mavpoll/main_test.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"encoding/json"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -212,3 +213,59 @@ func TestRunRequiresSomethingToPoll(t *testing.T) {
 		t.Errorf("err = %v, want a 'nothing to poll' refusal", err)
 	}
 }
+
+// A flag value that would kill the poller later is refused at start, before it
+// dials core: a non-positive interval panics time.NewTicker on the first tick, a
+// zero timeout means http.Client waits forever, and an empty wg command used to
+// index field 0 of an empty slice.
+func TestRunRefusesFlagsThatCrashLater(t *testing.T) {
+	cases := []struct {
+		name string
+		args []string
+		want string
+	}{
+		{"zero interval", []string{"-interval", "0"}, "-interval must be positive"},
+		{"negative interval", []string{"-interval", "-5s"}, "-interval must be positive"},
+		{"zero timeout", []string{"-timeout", "0"}, "-timeout must be positive"},
+		{"empty wg command", []string{"-wg", "wg0", "-wg-cmd", " "}, "-wg-cmd is empty"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			args := append([]string{"-socket", "/tmp/nope.sock"}, c.args...)
+			err := run(args)
+			if err == nil || !strings.Contains(err.Error(), c.want) {
+				t.Errorf("err = %v, want %q", err, c.want)
+			}
+		})
+	}
+}
+
+// pollWg refuses an empty command rather than panicking on fields[0].
+func TestPollWgEmptyCommand(t *testing.T) {
+	p := &poller{core: &factCore{}, wgIface: "wg0", wgCmd: ""}
+	if err := p.pollWg(context.Background()); err == nil {
+		t.Error("want an error, got a poll that ran something")
+	}
+}
+
+// A body at the cap is a truncated body, and a truncated kuma page reads as
+// "every monitor past the cut was deleted". Refuse it instead of parsing it.
+func TestGetRefusesTruncatedBody(t *testing.T) {
+	big := strings.Repeat("x", maxBodyBytes+64)
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		io.WriteString(w, big)
+	}))
+	defer srv.Close()
+	p := &poller{http: srv.Client()}
+	if _, err := p.get(context.Background(), srv.URL, ""); err == nil {
+		t.Error("want an over-size refusal, got a silently truncated body")
+	}
+	small := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		io.WriteString(w, "ok")
+	}))
+	defer small.Close()
+	body, err := p.get(context.Background(), small.URL, "")
+	if err != nil || string(body) != "ok" {
+		t.Errorf("get = %q, %v; want the whole small body", body, err)
+	}
+}

cmd/mavsttd/whisper_handler.go

@@ -22,6 +22,18 @@ import (
 // to it before sending, so it's also the rate the silence gate assumes.
 const whisperSampleRate = 16000
 
+// whisperThreads — greedy decode is single-pass and this is a laptop CPU
+// (homesrv), not a server box; 4 was picked to leave headroom for the rest
+// of the daemons sharing the machine, not measured against a latency target.
+const whisperThreads = 4
+
+// noSpeechFloor — whisper's own no_speech_prob past this point means the
+// segment it transcribed is not speech (the model still emits token
+// probabilities for silence/noise, so a high avgLogProb-derived confidence
+// can coexist with a segment that should be zero). Read as "at least 90%
+// sure this was not speech."
+const noSpeechFloor = 0.9
+
 type whisperHandler struct {
 	ctx    *C.struct_whisper_context
 	minMs  int     // clips shorter than this are dropped (hallucination bait)
@@ -101,7 +113,7 @@ func (h *whisperHandler) Transcribe(ctx context.Context, req worker.TranscribeRe
 	params.print_realtime = false
 	params.print_timestamps = false
 	params.print_special = false
-	params.n_threads = C.int(4)
+	params.n_threads = C.int(whisperThreads)
 	params.single_segment = true
 
 	lang := C.CString(req.Lang)
@@ -162,7 +174,7 @@ func (h *whisperHandler) Transcribe(ctx context.Context, req worker.TranscribeRe
 	}
 
 	noSpeechProb := float64(C.whisper_full_get_segment_no_speech_prob(h.ctx, 0))
-	if noSpeechProb > 0.9 {
+	if noSpeechProb > noSpeechFloor {
 		confidence = 0
 	}
 

cmd/mavttsd/piper_handler.go

@@ -116,18 +116,27 @@ func (h *piperHandler) Synthesize(ctx context.Context, req worker.SynthesizeReq)
 	}, nil
 }
 
-// resample22050To16000 converts raw 16-bit PCM from 22050 Hz to 16000 Hz
-// using linear interpolation.
+// piperSampleRate is the rate piper's onnx voices render at (ru_RU-irina and
+// the other models this daemon has been pointed at). targetSampleRate is the
+// canonical maven wire rate (audio.PCM16kMono) that every downstream
+// consumer — playback, the voice wire, whisper on the way back in — expects.
+const (
+	piperSampleRate  = 22050
+	targetSampleRate = 16000
+)
+
+// resample22050To16000 converts raw 16-bit PCM from piperSampleRate to
+// targetSampleRate using linear interpolation.
 func resample22050To16000(input []byte) []byte {
 	if len(input) < 2 {
 		return nil
 	}
 
 	nSamples := len(input) / 2
-	outSamples := int(float64(nSamples) * 16000.0 / 22050.0)
+	outSamples := int(float64(nSamples) * float64(targetSampleRate) / float64(piperSampleRate))
 	output := make([]byte, outSamples*2)
 
-	ratio := 22050.0 / 16000.0
+	ratio := float64(piperSampleRate) / float64(targetSampleRate)
 
 	for i := 0; i < outSamples; i++ {
 		srcPos := float64(i) * ratio

cmd/mavweb/events.html

@@ -14,8 +14,13 @@ memory only, so a restart empties this.</div>
 <div class=scroll><table class=mono>
 <tr><th>noticed<th>happened<th>source<th>kind<th>pri<th>what<th>detail</tr>
 {{range .Events}}<tr>
-<td>{{.NoticedAt.Format "02.01 15:04:05"}}</td>
-<td class=gray>{{.OccurredAt.Format "02.01 15:04:05"}}</td>
+<!-- Both columns in his clock (V-469 on /reminders, same rule here). NoticedAt
+     is the bus's local instant, OccurredAt is whatever zone the source used —
+     the store hands back UTC and internal/rss parses a pubDate to UTC — so
+     rendering them raw put two zones side by side in the same row and made a
+     feed item look hours older than it was. -->
+<td>{{.NoticedAt.Local.Format "02.01 15:04:05"}}</td>
+<td class=gray>{{.OccurredAt.Local.Format "02.01 15:04:05"}}</td>
 <td class=gray>{{.Source}}</td>
 <td class=gray>{{.Kind}}</td>
 <td class=gray>{{.Priority}}</td>

cmd/mavweb/events_test.go

@@ -46,7 +46,8 @@ func TestEventsPageRendersTheJournal(t *testing.T) {
 		t.Fatalf("status = %d, want 200", w.Code)
 	}
 	body := w.Body.String()
-	for _, want := range []string{"rss:tech", "Вышло ядро 6.19", "ambient:notif", "10:00-11:00 планёрка", "01.08 10:00:00"} {
+	occurred := time.Date(2026, 8, 1, 10, 0, 0, 0, time.UTC).Local().Format("02.01 15:04:05")
+	for _, want := range []string{"rss:tech", "Вышло ядро 6.19", "ambient:notif", "10:00-11:00 планёрка", occurred} {
 		if !strings.Contains(body, want) {
 			t.Errorf("page does not mention %q", want)
 		}
@@ -89,6 +90,38 @@ func TestEventsPageWithoutCore(t *testing.T) {
 	}
 }
 
+// awayFromLocal returns a zone three hours off whatever this machine runs in,
+// so a test can tell "rendered in his clock" apart from "rendered in whatever
+// zone the value arrived in" without depending on TZ.
+func awayFromLocal() *time.Location {
+	_, off := time.Now().Zone()
+	return time.FixedZone("away", off+3*60*60)
+}
+
+func TestEventsPageRendersBothTimesInLocalZone(t *testing.T) {
+	// OccurredAt carries the source's zone — the store hands back UTC and
+	// internal/rss parses a pubDate to UTC — while NoticedAt is the bus's local
+	// instant. Rendered raw, the two columns of one row were in two zones and a
+	// feed item read hours older than it was.
+	away := awayFromLocal()
+	occurred := time.Date(2026, 8, 1, 7, 15, 0, 0, time.UTC).In(away)
+	noticed := occurred.Add(2 * time.Minute)
+	core := &eventsCore{events: []ipc.IntakeEvent{{
+		Source: "rss:tech", Kind: "note", Title: "Вышло ядро 6.19", Priority: "low",
+		OccurredAt: occurred, NoticedAt: noticed,
+	}}}
+	body := getEvents(t, core).Body.String()
+	const layout = "02.01 15:04:05"
+	for _, ts := range []time.Time{occurred, noticed} {
+		if !strings.Contains(body, ts.Local().Format(layout)) {
+			t.Errorf("page does not render %s in his clock (%s)", ts, ts.Local().Format(layout))
+		}
+		if strings.Contains(body, ts.In(away).Format(layout)) {
+			t.Errorf("page rendered %s in the source's zone", ts)
+		}
+	}
+}
+
 func TestEventsPageEscapesIntakeText(t *testing.T) {
 	// Titles come from outside — a feed headline, a notification. They are shown
 	// on a page and must never be able to inject markup into it.

cmd/mavweb/morning.html

@@ -8,7 +8,10 @@
 <div class=scroll><table class=mono>
 <tr><th>at<th>kind<th>what</tr>
 {{range .Items}}<tr>
-<td>{{.At.Format "15:04"}}</td>
+<!-- In his clock. A plan item's At is a calendar fact's Ts or a reminder's
+     FireTs, and the store hands both back as UTC, so the raw hour printed a
+     reminder here at an hour /reminders did not agree with (V-469). -->
+<td>{{.At.Local.Format "15:04"}}</td>
 <td class=gray>{{.Kind}}</td>
 <td>{{if .Uncertain}}<span class=hint title="relayed notification, not a calendar read">похоже,</span> {{end}}{{.Text}}</td>
 </tr>{{end}}

cmd/mavweb/morning_test.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/kami/maven/internal/ipc"
+)
+
+// morningCore serves a canned checklist and day plan.
+type morningCore struct {
+	ipc.UnimplementedCoreAPI
+	status []ipc.MorningRoutineStatus
+	plan   ipc.DayPlan
+}
+
+func (c *morningCore) MorningStatus(context.Context) ([]ipc.MorningRoutineStatus, error) {
+	return c.status, nil
+}
+
+func (c *morningCore) DayPlan(context.Context) (ipc.DayPlan, error) { return c.plan, nil }
+
+func TestMorningRendersPlanTimesInLocalZone(t *testing.T) {
+	// A plan item's At is a calendar fact's Ts or a reminder's FireTs, and the
+	// store hands both back as UTC. Printed raw, /morning named an hour for a
+	// reminder that /reminders — which does call Local — disagreed with.
+	away := awayFromLocal()
+	at := time.Date(2026, 8, 1, 9, 0, 0, 0, time.UTC).In(away)
+	core := &morningCore{plan: ipc.DayPlan{
+		Date:  at,
+		Items: []ipc.DayPlanItem{{At: at, Text: "выпить таблетки", Kind: "reminder"}},
+	}}
+	w := httptest.NewRecorder()
+	handleMorning(w, httptest.NewRequest(http.MethodGet, "/morning", nil), core)
+	if w.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", w.Code)
+	}
+	body := w.Body.String()
+	if !strings.Contains(body, at.Local().Format("15:04")) {
+		t.Errorf("plan item not rendered in his clock (%s): %s", at.Local().Format("15:04"), body)
+	}
+	if strings.Contains(body, at.In(away).Format("15:04")) {
+		t.Errorf("plan item rendered in the stored zone: %s", body)
+	}
+}

cmd/mavweb/tasks.go

@@ -300,11 +300,15 @@ func promoteCandidate(ctx context.Context, core ipc.CoreAPI, r *http.Request, id
 	if err := core.SetTaskFields(ctx, id, doneWhen, blockedOn); err != nil {
 		return "", err
 	}
-	if due != nil {
-		wgt, err := formWeight(r)
-		if err != nil {
-			return "", err
-		}
+	wgt, err := formWeight(r)
+	if err != nil {
+		return "", err
+	}
+	// The importance select is posted whether or not a date is. This ran under
+	// `if due != nil`, so confirming a candidate as "срочно" with no deadline
+	// dropped the word on the floor — the row came back normal and nothing said
+	// why. A promote with neither field set still writes nothing.
+	if due != nil || wgt != 0 {
 		if err := core.EditTask(ctx, id, text, due, wgt); err != nil {
 			return "", err
 		}

cmd/mavweb/tasks_test.go

@@ -32,6 +32,31 @@ type fakeTaskCore struct {
 	statusErr error
 
 	promoted bool
+
+	// The promote path's two extra writes.
+	fields   []any
+	edits    []editCall
+	editErr  error
+	fieldErr error
+}
+
+// editCall records one EditTask, so a test can say what the form actually sent
+// down rather than only that the promotion succeeded.
+type editCall struct {
+	ID     int64
+	Text   string
+	Due    *time.Time
+	Weight int
+}
+
+func (f *fakeTaskCore) EditTask(_ context.Context, id int64, text string, due *time.Time, weight int) error {
+	f.edits = append(f.edits, editCall{id, text, due, weight})
+	return f.editErr
+}
+
+func (f *fakeTaskCore) SetTaskFields(_ context.Context, id int64, doneWhen, blockedOn string) error {
+	f.fields = append(f.fields, []any{id, doneWhen, blockedOn})
+	return f.fieldErr
 }
 
 func (f *fakeTaskCore) ListTasks(_ context.Context, status string) ([]ipc.Task, error) {
@@ -220,6 +245,49 @@ func TestApplyTaskPostCarriesWeight(t *testing.T) {
 	}
 }
 
+// Confirming a candidate posts the importance select whether or not a date is
+// set. The weight write hung off `if due != nil`, so "срочно" with no deadline
+// was read off the form and thrown away, and the row came back normal.
+func TestPromoteCandidateCarriesWeightWithoutADueDate(t *testing.T) {
+	core := &fakeTaskCore{}
+	form := url.Values{
+		"action": {"promote"}, "id": {"4"}, "text": {"продлить страховку"},
+		"done_when": {"полис на руках"}, "weight": {"3"},
+	}
+	req := httptest.NewRequest(http.MethodPost, "/tasks", strings.NewReader(form.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	handleTasks(httptest.NewRecorder(), req, core)
+
+	if len(core.edits) != 1 {
+		t.Fatalf("edits = %+v, want the weight written once", core.edits)
+	}
+	if core.edits[0].Weight != 3 || core.edits[0].ID != 4 {
+		t.Errorf("edit = %+v, want id 4 at weight 3", core.edits[0])
+	}
+	if core.edits[0].Due != nil {
+		t.Errorf("edit invented a due date: %v", core.edits[0].Due)
+	}
+	if core.statusVal != "open" {
+		t.Errorf("status = %q, want the candidate promoted", core.statusVal)
+	}
+}
+
+// A promote with neither field set still writes nothing: the row is unchanged
+// apart from its status, and an EditTask here would be a no-op that can fail.
+func TestPromoteCandidateWithNoDateAndNoWeightDoesNotEdit(t *testing.T) {
+	core := &fakeTaskCore{}
+	form := url.Values{
+		"action": {"promote"}, "id": {"4"}, "text": {"продлить страховку"},
+		"done_when": {"полис на руках"}, "weight": {"0"},
+	}
+	req := httptest.NewRequest(http.MethodPost, "/tasks", strings.NewReader(form.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	handleTasks(httptest.NewRecorder(), req, core)
+	if len(core.edits) != 0 {
+		t.Errorf("edits = %+v, want none", core.edits)
+	}
+}
+
 // Out of range clamps rather than 400s; a non-number is a real client error.
 func TestApplyTaskPostClampsWeight(t *testing.T) {
 	core := &fakeTaskCore{created: true}

docs/evals/2026-08-06-fact-parser.md

@@ -0,0 +1,247 @@
+# The fact parser: closed classes against the substring stems they replaced
+
+Measured 2026-08-06 at 22edc3c and its parent 0445693, on the corpus in
+`internal/router/factparser_corpus_test.go`. Dated file: it is not edited after
+today, and a newer number is a new file.
+
+V-586 rewrote `DefaultFactParser` off hand-written Russian stems onto six closed
+classes in `internal/lexicon`. Its commit message reported 64/91 on the RU
+routing fixture, unchanged. That number does not bear on the change: the fixture
+holds three fact cases and all three miss on intent, so the parser is never
+reached. This file measures the parser directly, and runs the LLM arm the
+original commit skipped.
+
+**The rewrite is better on the utterances it was designed for and no worse on
+the ones it was not.** True positives go 35/40 to 39/40, misfires rejected go
+8/15 to 14/15. What neither version has is coverage: of 36 plausible utterances
+whose word is in no lexicon set, the substring parser caught 3 by accident and
+the closed-class parser catches 0. That is the honest headline. The word list
+did not shrink the vocabulary — it never had one — it made the boundary visible.
+
+## The corpus
+
+91 cases, three classes. **True positives** are sentences the owner would say,
+with the key that must be written. **Misfires** are sentences the substring
+parser wrote a fact for and should not have, including the three hard negatives
+the rewrite was argued on. **False negatives** are sentences a reasonable person
+would say whose word is in no set at all; `want` is the key a human would
+assign, and the ship parser is expected to miss them. They are the measurement
+of what a closed class costs, not a bug list.
+
+The old parser is carried in the test file as `legacyFactParse`, copied verbatim
+from 0445693, so the comparison reruns:
+
+```sh
+deps/go/go/bin/go test -run TestFactParserCorpus -v ./internal/router/
+```
+
+## Score
+
+| | true positives | misfires rejected | false-negative cases recovered |
+|---|---|---|---|
+| old (substring stems, 0445693) | 35/40 | 8/15 | 3/36 |
+| **new (closed classes, 22edc3c)** | **39/40** | **14/15** | **0/36** |
+
+Sixteen cases disagree. Eleven of them the rewrite wins, three it loses, and two
+are cases neither gets.
+
+**Won.** Every misfire the commit message named — `душа болит`, `в комнате
+душно`, `это была беда`, `наша победа`, `на душе легко` — plus `водитель пилота
+ждёт`, where two stems in one sentence made the old water arm fire. And five true
+positives the stems simply did not list: `перекусил`, `передохнул`, `отдыхаю`,
+`пойду спать`, `i showered`. Morphology buys those; a stem list would need a new
+entry for each.
+
+**Lost.** `допил воду` is a real regression and the only failing true positive.
+The vendored dictionary lemmatises `допил` to `допилить`, to finish sawing —
+exactly the collision `drink_verbs` already carries `пил` and `пили` as surface
+forms to dodge, left unhandled for the prefixed form. `допить` is in the set and
+the sentence still misses. It is flagged `broken` in the corpus rather than
+fixed, because this branch measures.
+
+`был в душе` and `после душа полегчало` are the price of matching the shower set
+exactly. The dictionary makes `душ` and `душа` one word, so a lemma test cannot
+tell a shower from a soul; exact matching keeps `на душе легко` out and loses
+the oblique cases of the real noun with it. The old parser got both by accident,
+along with the soul. That trade is right — writing a shower fact when he said
+his soul feels light is worse than missing one — but it is a trade and the two
+rows are what it costs.
+
+`недоспал` is the third loss and the least defensible: the old substring `спал`
+caught it, and `недоспать` is in no set.
+
+**Neither.** `обеденный перерыв отменили` — a cancelled lunch break — is a fact
+for both parsers, `meal` for the old one off the adjective and `break` for the
+new one off `перерыв`. Nothing in either design reads the cancellation.
+`дрых до обеда` is scored `meal` by both, because the meal arm runs first and
+`обеда` is in it, which is not wrong so much as beside the point.
+
+## The false-negative surface
+
+This is the half the routing fixture cannot see and the half that decides
+whether the design holds. 36 cases, 0 recovered:
+
+- **water** — `выпил чаю`, `глотнул воды`, `хлебнул воды`, `выпил стакан`,
+  `i hydrated`, `finished my bottle of water`. The water arm needs a noun AND a
+  verb, so an elided noun or an unlisted verb drops the whole capture.
+- **meal** — `ем суп`, `съел бутерброд`, `наелся`, `пожрал`, `полдник был`,
+  `snack`, `supper`, `brunch`, `i eat now`. `есть` is deliberately absent for
+  `есть новости по бэкапу`, and `ем`, its most ordinary spoken form, goes with it.
+- **shower** — `помылся`, `сходил в ванную`, `искупался`, `i am showering`,
+  plus the two oblique cases above.
+- **break** — `сделал передышку`, `перекур`, `полежал немного`, `сделал паузу`,
+  `i took five`, `resting now`.
+- **sleep** — `вздремнул`, `прикорнул`, `дрых`, `недоспал`, `лёг в двенадцать`,
+  `сон был короткий`, `i napped`, `took a nap`.
+
+None of these are exotic. They are the second and third word a person reaches
+for, and every one of them is a fact the owner stated and Maven silently did not
+record. A silent miss is the worst failure mode this parser has: he said it, she
+heard it, nothing was written, and nothing told him.
+
+## The routing fixture, LLM arm
+
+The arm 22edc3c skipped. `MAVEN_LLM_URL` points the harness at any llama-server;
+the previous run reported none reachable, which was the shell's `HTTP_PROXY` and
+not the network. Run against **gemma-4-12B-it-qat-UD-Q4_K_XL on the workstation
+at `192.168.1.105:8080`**, the same box as the 02-08 measurement, with
+`NO_PROXY=192.168.1.105`:
+
+```sh
+NO_PROXY=192.168.1.105 no_proxy=192.168.1.105 \
+  make eval-models MAVEN_LLM_URL=http://192.168.1.105:8080
+```
+
+| | full | intent-only | p50 |
+|---|---|---|---|
+| llm-only, 0445693 | 51.6% (47/91) | 82.4% | — |
+| llm-only, 22edc3c | 52.7% (48/91) | 83.5% | 341ms |
+| cascade+llm, 0445693 | 85.7% (78/91) | 93.4% | — |
+| **cascade+llm, 22edc3c** | **86.8% (79/91)** | **94.5%** | 334ms |
+
+One case either way, both directions, and the failing set is identical between
+the two commits. That is run-to-run variance on a sampling model, not a signal.
+The parser change is invisible to the routing fixture on the LLM arm for the
+same reason it is invisible on the classifier arm: the three fact cases miss on
+intent and the parser is never called. Do not read these rows as evidence about
+the parser. They are evidence that the fixture cannot answer the question, which
+is why the corpus above exists.
+
+## Verdict
+
+The closed-class rewrite holds up as a rewrite. It is strictly better than what
+it replaced on both classes anyone argued about, and the one regression
+(`допил`) and one bad trade (the oblique `душ`) are both dictionary collisions
+rather than design faults.
+
+It does not hold up as an answer. A closed class is the right mechanism for a
+set that is actually closed — interrogatives, weekdays, cardinals — and
+"the words a person uses to say he ate" is not that set. The corpus puts a
+number on it: 36 ordinary sentences, 0 recovered, and every new one costs a
+lexicon edit by whoever notices. The three mechanisms CLAUDE.md names do not
+contain the right one for this job. The embedder-topic mechanism is the closest
+fit and is wrong too, because this is slot extraction rather than aboutness.
+
+This is a case for the V-546 slot-tagging head. Self-care facts are a bounded
+key space (five keys) over unbounded surface forms, which is exactly what a BIO
+tagger on e5-small is for: it generalises to `вздремнул` without anyone adding
+`вздремнуть` to a list, and max softmax gives the confidence the parser's
+hardcoded `true` does not have. Until it lands, the closed classes are the
+correct floor and the 36 rows above are the size of the gap they leave.
+
+## The corpus, case by case
+
+| utterance | class | want | old (substring) | new (closed class) |
+|---|---|---|---|---|
+| `выпил стакан воды` | tp | water | water | water |
+| `попил воды` | tp | water | water | water |
+| `я попил водички` | tp | water | water | water |
+| `пью воду` | tp | water | water | water |
+| `воду пил уже` | tp | water | water | water |
+| `допил воду` | tp | water | water | — **≠** |
+| `запил таблетку водой` | tp | water | water | water |
+| `drank water` | tp | water | water | water |
+| `i drank some water` | tp | water | water | water |
+| `поужинал` | tp | meal | meal | meal |
+| `я пообедал` | tp | meal | meal | meal |
+| `позавтракал кашей` | tp | meal | meal | meal |
+| `перекусил бутербродом` | tp | meal | — | meal **≠** |
+| `покушал` | tp | meal | meal | meal |
+| `поел супа` | tp | meal | meal | meal |
+| `обед был в час` | tp | meal | meal | meal |
+| `ужинать буду позже` | tp | meal | meal | meal |
+| `i ate` | tp | meal | meal | meal |
+| `had lunch` | tp | meal | meal | meal |
+| `dinner done` | tp | meal | meal | meal |
+| `принял душ` | tp | shower | shower | shower |
+| `сходил в душ` | tp | shower | shower | shower |
+| `душ принят` | tp | shower | shower | shower |
+| `ополоснулся душем` | tp | shower | shower | shower |
+| `took a shower` | tp | shower | shower | shower |
+| `i showered` | tp | shower | — | shower **≠** |
+| `сделал перерыв` | tp | break | break | break |
+| `отдохнул полчаса` | tp | break | break | break |
+| `передохнул немного` | tp | break | — | break **≠** |
+| `отдыхаю` | tp | break | — | break **≠** |
+| `был перерыв на обед` | tp | meal | meal | meal |
+| `took a break` | tp | break | break | break |
+| `спал восемь часов` | tp | sleep | sleep | sleep |
+| `спала плохо` | tp | sleep | sleep | sleep |
+| `поспал днём` | tp | sleep | sleep | sleep |
+| `выспался наконец` | tp | sleep | sleep | sleep |
+| `проспал будильник` | tp | sleep | sleep | sleep |
+| `пойду спать` | tp | sleep | — | sleep **≠** |
+| `slept 8 hours` | tp | sleep | sleep | sleep |
+| `i slept badly` | tp | sleep | sleep | sleep |
+| `пилот сказал что вылет через час` | misfire | — | — | — |
+| `водитель уже подъехал` | misfire | — | — | — |
+| `надо заводить машину` | misfire | — | — | — |
+| `душа болит` | misfire | — | shower | — **≠** |
+| `в комнате душно` | misfire | — | shower | — **≠** |
+| `это была беда` | misfire | — | meal | — **≠** |
+| `наша победа` | misfire | — | meal | — **≠** |
+| `пила лежит в гараже` | misfire | — | — | — |
+| `водитель пилота ждёт` | misfire | — | water | — **≠** |
+| `обеденный перерыв отменили` | misfire | — | meal | break **≠** |
+| `есть новости по бэкапу базы` | misfire | — | — | — |
+| `напоминания на завтра есть` | misfire | — | — | — |
+| `на душе легко` | misfire | — | shower | — **≠** |
+| `пилил доску весь вечер` | misfire | — | — | — |
+| `поставь будильник на завтра` | misfire | — | — | — |
+| `выпил чаю` | fn | water | — | — |
+| `глотнул воды` | fn | water | — | — |
+| `хлебнул воды` | fn | water | — | — |
+| `воды хлебнул из бутылки` | fn | water | — | — |
+| `выпил стакан` | fn | water | — | — |
+| `i hydrated` | fn | water | — | — |
+| `finished my bottle of water` | fn | water | — | — |
+| `ем суп` | fn | meal | — | — |
+| `съел бутерброд` | fn | meal | — | — |
+| `наелся` | fn | meal | — | — |
+| `пожрал` | fn | meal | — | — |
+| `полдник был` | fn | meal | — | — |
+| `i had a snack` | fn | meal | — | — |
+| `having supper` | fn | meal | — | — |
+| `brunch was good` | fn | meal | — | — |
+| `i eat now` | fn | meal | — | — |
+| `был в душе` | fn | shower | shower | — **≠** |
+| `после душа полегчало` | fn | shower | shower | — **≠** |
+| `помылся` | fn | shower | — | — |
+| `сходил в ванную` | fn | shower | — | — |
+| `искупался` | fn | shower | — | — |
+| `i am showering` | fn | shower | — | — |
+| `сделал передышку` | fn | break | — | — |
+| `перекур` | fn | break | — | — |
+| `полежал немного` | fn | break | — | — |
+| `сделал паузу` | fn | break | — | — |
+| `i took five` | fn | break | — | — |
+| `resting now` | fn | break | — | — |
+| `вздремнул` | fn | sleep | — | — |
+| `прикорнул на диване` | fn | sleep | — | — |
+| `дрых до обеда` | fn | sleep | meal | meal |
+| `недоспал` | fn | sleep | sleep | — **≠** |
+| `лёг в двенадцать` | fn | sleep | — | — |
+| `сон был короткий` | fn | sleep | — | — |
+| `i napped` | fn | sleep | — | — |
+| `took a nap` | fn | sleep | — | — |
+`≠` marks a disagreement. `—` is no fact written.

docs/evals/2026-08-06-reminder-completeness-on-the-box.md

@@ -0,0 +1,94 @@
+# The reminder completeness rule, measured on the box
+
+Measured 2026-08-06 at 02:34 local, on homesrv, master `59cc882`, immediately after V-577
+and V-579 merged as #231. Probe is `POST /api/chat` through mavweb, which is the same
+`handleText` seam the mic and telegram use.
+
+## The rule being measured
+
+The owner ruled it the same night. A reminder commits only when three things are answered:
+what, what time, and what day. Anything missing is asked for. Every time question opens by
+stating the clock.
+
+He gave two examples and confirmed two derived cases when asked.
+
+## Result: the rule holds on all four
+
+| said | what | time | day | reply |
+|---|---|---|---|---|
+| `напомни завтра в 3 заказать цветы` | yes | no part of day | yes | `Сейчас 02:34. Это утра или вечера?` |
+| `напомни в 9 вечера разгрузить стиралку` | yes | yes | no | `Сейчас 02:34. В какой день?` |
+| `напомни завтра в 15:00 позвонить врачу` | yes | yes | yes | `хорошо, напомню завтра в 15:00.` |
+| `напомни через час выключить духовку` | yes | yes | yes | `хорошо, напомню сегодня в 03:34.` |
+
+Row two is the one worth noting. `в 9 вечера` is unambiguous as a clock time and is still
+asked about, because the day is missing. Today being a valid reading is not enough.
+
+## The invented clock is gone
+
+Last night the worst failure was silent. A reminder was written at the current minute and
+nothing said so.
+
+```text
+напомни забрать посылку   ->  Сейчас 02:34. Когда?
+что у меня сегодня?       ->  на 06.08.2026 ничего нет, на какое время поставить напоминание?   [s=calendar]
+в 15                      ->  Сейчас 02:34. В какой день?
+```
+
+Measured last night, the second turn answered nothing and wrote a reminder at the clock.
+The question now reaches the calendar and the parked question resumes on the same reply.
+
+The root cause was one step earlier than filed. `ownContent("что у меня сегодня?")` returns
+empty, because every token is frame. `что` is an interrogative, `у` a frame word, `меня`
+filler, `сегодня` a day offset. So `needsRoute` said no and no route was computed at all.
+The turn fell through to answering the parked question. The extractor read `сегодня`, and
+the date parser answered a bare day word with that day at the current minute.
+
+So this was not a claimant beating the route. It was a claimant running where the route was
+never asked for.
+
+## Two defects the probe found
+
+**V-592, invented content.** `я выпил воды` came back as
+`Проверила, что ты выпел стакан воды`. `выпел` is not a Russian word and `стакан` was never
+said. The arbitration around it is correct: the aside is taken, the parked question resumes,
+nothing is dropped. Only the content is wrong. Whether the store agrees with the sentence is
+not yet known. That answer decides whether this is a phrasing defect or a capture defect.
+
+**V-593, an unacknowledged partial answer.** `на 9` then `на завтра` produces the same ask
+twice, byte-identical.
+
+```text
+а, да, прости - на 9  ->  Сейчас 02:34. Это утра или вечера?
+на завтра             ->  Сейчас 02:34. Это утра или вечера?
+```
+
+The behaviour is right, since the part of day is missing both times. The wording gives him
+no evidence he was heard, which is the failure mode the V-558 family exists to remove.
+
+## The pinned acceptance transcript is now superseded
+
+The transcript the owner wrote has her guess a reading and accept `на завтра` as the last
+turn:
+
+```text
+me:     а, да, прости - на 9.
+maven:  сейчас 15:23 - на 9 сегодня вечером?
+me:     на завтра.
+maven:  напомню.
+```
+
+Under the rule he later ruled, `на 9` plus `на завтра` still names no part of day. So she
+must ask a third time rather than commit. The transcript and the rule disagree, and the rule
+is the newer statement. Offering a reading, as that transcript does, remains allowed and is
+not required. The implementation asks `Это утра или вечера?` and offers none.
+
+## Regression checked
+
+A new request still drops the old one out loud. That is the behaviour the owner kept when he
+rejected the silent drop for side queries.
+
+```text
+напомни позвонить маме          ->  Сейчас 02:34. Когда?
+напомни завтра в 9 купить молоко ->  Прошлую просьбу отпускаю. Сейчас 02:34. Это утра или вечера?
+```

docs/plans/20-two-artifacts-and-neither-is-spring.md

@@ -0,0 +1,411 @@
+# Two artifacts, and neither one is Spring
+
+Proposal. V-585. Related umbrella V-558, and the design collected in
+`docs/plans/19-dialogue-arbitration.md`.
+
+## Verdict
+
+**Thesis one holds for four seams and fails for one.** Four are one shape: the routing
+cascade, the query source chain, the pre-route resolver ladder, the digestion tick. Reach
+selection is not. It maps severity and presence to a set of channels. It has no claimants and
+no losers.
+
+**Thesis two holds.** An arbitration kernel is a package and a convention inside one program.
+It is not a framework. A framework whose only client is the codebase it came from is that
+codebase with more ceremony.
+
+**The answer is two artifacts of different sizes.** One package inside Maven, built from
+`internal/claim` and `internal/decision`. Both already exist and neither is wired. One small
+library across the four services, holding the correlation id, the headers, the timeout policy
+and the named gap. Neither is Spring. The daemons must not get a third.
+
+**The strongest finding is the duplication, not the shape.** Three structural holes make a
+route untrustworthy. They are written out by hand in three files, for three consumers, with
+three return types. `gateLLMDecision` flattens them to a float. `vetoOf` re-derives them as a
+sentence. `thinReason` re-derives them again as a trace string. That is what having no common
+unit costs, and it is countable in lines rather than in taste.
+
+## The five seams, tested
+
+### 1. The routing cascade. The shape, ordered by hand.
+
+The claimant is `router.Grammar` (`internal/router/stage0.go:19`). It holds a name, a regex
+and a `Build` that may still decline. A claim is a regex match plus `ok` from `Build`.
+
+Ordering is the append order in `buildRouter` (`cmd/mavend/voicewire.go:384`). Twelve appends.
+Each one carries a comment arguing its position against its neighbours. First match wins at
+confidence 1.0.
+
+Below stage 0 the two engines are alternatives, not rivals. The classifier runs only when the
+router is nil or errored. Inside the classifier the order is cosine score, and the top three
+are recorded.
+
+Losers are recorded and change nothing. `noteGrammarOutcomes`
+(`internal/router/decisiontrace.go:56`) separates a grammar that did not match from one whose
+`Build` declined. Everything past the winner is marked `NeverAsked`.
+
+### 2. The query source chain. The shape, ordered by hand, with a boundary in it.
+
+The claimant is `querySource` (`cmd/mavend/actions_query.go:45`), a name and one function
+returning `(string, bool)`. Twenty-four of them sit in one slice literal, walked in order. The
+comment on the slice says the order is load-bearing. It is right.
+
+This seam carries something the others do not. The personal boundary at line 139 is a stop,
+not an answer. Everything above it reads the owner's data. Everything below reads the world. A
+question about him that reaches the boundary ends there.
+
+### 3. The pre-route resolver ladder. The shape, and the one that hurts.
+
+Seven rungs, each returning `(reply string, handled bool)`. Ordering is the order of the `if`
+statements in `runTurn` (`cmd/mavend/voice.go:258`). The roster in `preRouteLadder`
+(`cmd/mavend/decisiontrace.go:33`) is kept by hand, and its own comment admits nothing
+enforces the correspondence.
+
+The recurring bug lives here. A rung claims before the utterance is routed. So the claimant
+with the earliest and strongest trigger is the one that knows least about what was said. V-560
+fixed half of it. It computes the route once, before the ladder, and lets the clarify resolver
+read it. The other rungs still decide without reading it.
+
+### 4. The digestion tick. The shape, and the only one already done right.
+
+This corrects the brief. `loop.Tick` (`internal/loop/loop.go:85`) is not a first-to-claim
+walk. It is an arbitration with a declared comparator.
+
+- The claimant is `loop.Rule`. Its `Predicate` says whether it wants the turn.
+- The gate is separate from the claim. `Gate` (`loop.go:21`) checks snooze, cooldown, quiet
+  hours, calendar busy, presence and missing data. `ExplainGate` names which one blocked.
+- The comparator is data, not position. Max severity wins, and ties break on name.
+  `DefaultRules` states outright that slice order is not load-bearing.
+- Losers are recorded with what they lost to. `ExplainTick` (`internal/loop/explain.go:86`)
+  fills `LostTo`, and rewrites the previous best when a higher severity displaces it.
+- Losers get a second life. `DigestEligible` (`loop.go:129`) decides which suppressed
+  candidates are bundled for later. It refuses cooldown and snooze, because neither is
+  restraint.
+
+Every property the kernel wants already exists here, on five rules. The kernel argues that the
+other three seams should look like this one. It does not need a new idea.
+
+### 5. Reach selection. Not the shape.
+
+`ChannelsFor` (`internal/delivery/channel.go:73`) takes severity and presence and returns a
+slice of channels. Nothing claims. Nothing passes. Nothing loses. Every channel in the
+returned slice sends, so there is not even one winner.
+
+Naming the sinks claimants would be the forced abstraction. It would also hide the property
+this table has and the ladders lack. It is total, it is pure, and every cell is covered by
+`TestChannelsForEveryTableCell`.
+
+One thing in the dispatcher does re-decide. `ErrVoiceNoSession` means the presence guess was
+wrong, so the remaining channel list is replaced with the away table
+(`internal/delivery/dispatcher.go:188`). That is a retry on new evidence, not a contest. Leave
+it alone.
+
+### What else has the shape
+
+`fillMatchedSlots` (`internal/router/router.go:212`) arbitrates per slot. A matched value
+always wins, and the extractor fills only what was left empty. That is the coverage-first rule
+the kernel proposes, written once for four slots.
+
+`bestRecall` and the topic veto pick between a fact and a note by score with a margin. That
+one is a real score comparison, and it should stay one.
+
+## The abstractions
+
+Three, not four. The straw man had `Claimant`, `Claim`, `Arbiter` and `Record`. Drop
+`Claimant`.
+
+**`claim.Claim`, evidence rather than a verdict.** It exists at `internal/claim/claim.go`,
+built and tested, imported by one function that nothing calls. It carries `Consumed` and
+`Unexplained` for coverage, an ordinal `Band`, and a `Veto` string that keeps the reason a
+float threw away. Coverage is compared before band. That is the fix for the Rome failure,
+where a parked reminder ate the whole utterance while explaining none of it.
+
+**`decision.Record`, the trace.** It exists at `internal/decision/decision.go` and it is wired
+everywhere. It separates won, declined, lost on score, thinned, merged and never asked. The
+last one is the valuable one. A claimant that never looked reads identically to one that looked and
+passed. That is what hardcoded order hides.
+
+**`Arbiter`, the thing that does not exist.** One function. It takes a set of claims and a
+comparator, returns a winner, and notes the rest. `loop.Tick` is that function, specialised to
+rules. Generalising it is the proposal.
+
+**Against a `Claimant` interface.** Every seam already rejected one, for the same reason.
+`querySource` is a struct of one function because the sources are methods on one handler with
+no state. An interface would mean one empty type per source. `confirmResolver` is the same
+shape, and `loop.Rule` is a struct with a closure. An interface would buy a shared name and
+cost twenty-four empty types. The claimants stay what they are. Each seam builds `claim.Claim`
+values at its own edge, which is what `router.ClaimOf` already does.
+
+## What ordering becomes
+
+Ordering becomes a comparator plus a rank, and the rank is data.
+
+Today ordering is position in a slice, and position is invisible in the record. Add a rung to
+`runTurn`, forget `preRouteLadder`, and the rung vanishes from the trace. The roster's own
+comment admits nothing enforces it.
+
+The proposal is smaller than a dependency graph. A claimant declares a rank. The arbiter sorts
+by coverage, then band, then rank. Rank breaks the tie that evidence cannot break.
+
+**A dependency graph is the wrong tool.** The real constraints are pairwise and local. Day
+plan before calendar. Praxis before the capture marker. Narrative last. A graph turns those
+into edges and then needs a topological sort whose output nobody can read. The twelve comments
+in `buildRouter` would become twelve edges with the arguments deleted. Keep the arguments.
+
+**Two claimants at the same rank must be an error, caught at wiring time.** Not at turn time.
+The registry is built once at boot, so a duplicate rank is a boot failure naming both
+claimants. Falling back to slice order on a tie would restore the invisible ordering the
+kernel exists to remove.
+
+**The roster stops being hand-kept.** A claimant registered with the arbiter is on the roster
+by construction. That deletes the `preRouteLadder` failure mode outright.
+
+## What it buys
+
+**It deletes three copies of one test.** The three structural holes appear in
+`gateLLMDecision` (`internal/router/router.go:271`), in `vetoOf`
+(`internal/router/claim.go:101`), and in `thinReason` (`internal/router/decisiontrace.go:28`).
+Three files, three return types, one rule. A fourth consumer would write it a fourth time.
+With a claim carrying `Veto`, the rule is written once. The float, the sentence and the trace
+string all derive from it. This one is worth the work on its own.
+
+**It makes the recurring bug expressible.** Rome, V-567 and V-577 are one defect. The claimant
+that knows least holds the earliest trigger. Coverage-first arbitration states the fix once,
+in `MoreSpecificThan`. A parked clarify explaining zero tokens of "какая сейчас погода в
+Риме?" loses to a weather claim explaining all of them. Nobody has to encode that a parked
+clarify is less trustworthy than a grammar.
+
+**The limit.** The kernel prevents the class only where the losing claimant
+computes low coverage. Rome, V-567 and V-577 all qualify. Each is a stateful claimant
+swallowing an utterance it explains none of. A claimant that matches a substring does explain
+those tokens, and coverage does not catch it. V-567's substring match is that case from the
+other side. Coverage there has to be measured against the whole utterance rather than the
+matched span. `claimSpans` already does that, in the safe direction. So the kernel
+prevents most of the class and describes the rest. Claiming more would be dishonest.
+
+**It makes contention countable.** Today it is not. The 91-case fixture draws two stage-0
+grammars exactly once, at `ru-query-019`, and both route the same intent. Nobody knows whether
+contention is rare or whether the fixture omits it. An arbiter that sees every claim can
+count.
+
+**What it does not buy.** No accuracy point comes from this alone. Every number in
+`docs/evals/2026-08-05-routing-resident-model.md` is reachable without it. The kernel is a
+place to put the fix, not the fix.
+
+## What it costs
+
+Every seam rewritten is a chance to break a measured number.
+
+Re-measure the 91-case routing fixture. The baseline is 75.8% full and 80.2% intent-only at
+p50 1.19s, in `docs/evals/2026-08-05-routing-resident-model.md`. Judge against the classifier
+and the resident model, because those are what always answer.
+
+Re-measure Praxis reach. The baseline is 27/30 overall, 11/12 Praxis and 5/5 lifecycle, in
+`docs/evals/2026-08-05-praxis-reach.md`. The Praxis grammars are the only path to Praxis, so a
+reordering that demotes them costs every point.
+
+Re-run the nine-scenario interleave probe in `docs/evals/2026-08-06-claimant-interleave.md`.
+Six of nine pass today. That probe measures exactly what this proposal is for.
+
+Re-run the dialogue contract tests from V-563. They are whole multi-turn traces, and the only
+tests that cover the ladder as a ladder.
+
+Latency is the cheap part. A stage-0 query costs 3.7µs. One claim per claimant adds two slices
+and a token split, on a path whose p50 is over a second.
+
+The real cost is the arguments. Twenty-three comments across `buildRouter` and `querySources`
+explain why each entry sits where it does. A migration that turns them into rank integers and
+drops the prose destroys the only documentation the ordering has.
+
+## Migration order
+
+**Step one, no behaviour change. Delete the duplication.** Make `vetoOf` the single definition
+of the three structural holes. Have `gateLLMDecision` and `thinReason` read it. One rule,
+three consumers, no new abstraction. Re-measure the routing fixture and nothing else. This is
+worth landing whether or not the rest does.
+
+**Step two, the proof. Arbitrate the pre-route ladder.** Smallest seam, seven rungs, and the
+one with the measured defect. Each resolver returns a claim instead of a bool. The arbiter
+compares coverage, then band, then rank. The roster comes from the registry. The proof is the
+interleave probe reaching nine of nine with the routing fixture unmoved.
+
+**Step three, the query source chain.** Twenty-four sources, most of which already compute a
+match span. The personal boundary does not become a ranked claimant. It stays a hard stop, and
+the arbiter runs above it and below it separately. Re-measure Praxis reach and the search and
+Kiwix fallback.
+
+**Step four, stage 0, or not at all.** Twelve grammar groups whose order encodes twelve
+arguments, scoring 20/20 on the fixture. Most to lose, least to gain. Defer it until steps two
+and three have sat in the deploy long enough to break something.
+
+**`loop.Tick` moves last or never.** It already has the comparator, the gate with reasons, the
+loser trace and the loser rescue. Rewriting it to call a generic arbiter risks the digest path
+to gain a shared name.
+
+## What must not be in the kernel
+
+**Authorization.** This is the hard line. CLAUDE.md is explicit that LLM output is not
+authorization, and that a confirmation binds capability id, target entity, arguments,
+requester and expiry (`cmd/mavend/confirm.go`). A generic arbiter turns many opinions into
+one winner. That is the wrong shape for a binding. Make confirm a claimant with a rank and a band, and a claim that scored higher could take the
+turn from it. The binding would be softened into a comparison. Confirm may report to the record. It must not compete in the
+arbiter.
+
+The same rule covers the Hexis path. Free text never reaches a mutating call, and resolution
+happens against Nexus. Neither is a contest, so neither is arbitration.
+
+**The personal boundary.** Same reason, different currency. The boundary is not the most
+specific claimant. It is a stop. A boundary that can lose to a higher-coverage claim is not a
+boundary. The failure is the owner's notes reaching a search engine.
+
+**Confidence as a float.** The band exists because the measurement said a calibrated float is
+not available. The classifier scores 62% correct below its median and 62% above, over a spread
+0.083 wide. Its top-two margin has a p50 of 0.009
+(`docs/plans/19-dialogue-arbitration.md`). A kernel with a `Score float64` on the claim invites
+every claimant to invent one. When V-546 lands a softmax head with a calibrated probability,
+that number is read beside the bands, not squeezed inside them.
+
+**Slot extraction and validation.** `fillMatchedSlots` runs after a winner exists, and slot
+validation against the action schema is V-562. Both ask whether a claim is well formed. Neither
+asks which claim wins.
+
+## The second artifact: the ecosystem client
+
+The kernel is Maven's alone. The one thing here with plural clients by construction is the
+contract between the four services. Maven implements its side of it twice and a half.
+
+### Is the contract uniform today? No.
+
+Nexus and Praxis share one implementation. `ecosystemHTTP` (`cmd/mavend/ecosystem.go:62`) is
+embedded in both, so both get the same 10 second timeout, the same `setHeaders`, the same
+typed `ecosystemError`, and the same correlation key. Hexis is a separate client in another
+repository, vendored at `vendor/github.com/kami/hexis/pkg/client`, and it agrees on some of
+that and not the rest.
+
+Eleven divergences. Four of them are defects rather than style, and each is filed on its own:
+V-587 the 401, V-588 the unnamed Praxis service, V-590 the uncorrelated discovery hop, V-591
+the unsent causation id. They are ranked in that order, worst first, and none of them waits on
+this proposal. V-587 is the only one that makes the owner check the wrong thing.
+
+**A Hexis 401 is spoken as an outage.** Nexus and Praxis return `*ecosystemError` with
+`Unauthorized()`, `ContractMismatch()` and `Unreachable()` classifiers
+(`cmd/mavend/ecosystem.go:144`). Hexis returns `fmt.Errorf` strings
+(`hexis/pkg/client/client.go:157`). So `unauthorizedEcosystemError`
+(`cmd/mavend/ecosystem_acts.go:549`) does `errors.As` and always gets false for Hexis. The
+owner hears "Hexis is down" when the truth is that Hexis refused the credential. The comment
+at `ecosystem_acts.go:32` says that conflation must not happen.
+
+**The Hexis discovery hop is uncorrelated.** Hexis carries its own context key
+(`client.go:81`), invisible to Maven's. The bridge is a manual second stamp at
+`ecosystem.go:546`. `discoverCapabilities` (`ecosystem.go:527`) does not do it, and discovery
+runs before execute, so that call goes out with no correlation id. The doc comment above it
+claims the opposite.
+
+**Causation is computed and never sent.** `causationID` is derived at
+`ecosystem_acts.go:771`. Hexis supports `X-Causation-ID` (`client.go:147`). Nothing passes it.
+
+**A Praxis failure names no service.** `ecosystemGap` (`ecosystem_acts.go:36`) is the shared
+named-gap helper, and Nexus and Hexis call it. Praxis returns per-verb Russian strings instead
+(`ecosystem_acts.go:62`, `:73`, `:84`, `:95`). There is no `servicePraxis` constant. A Praxis
+outage and a Praxis 403 both say "не получилось", with the service unnamed.
+
+The rest are real but smaller. Hexis sends no `X-Requested-By: maven` and no `Accept` header,
+so Hexis cannot attribute a read call to Maven at all. Its timeout is 30 seconds against
+Maven's 10, which Maven cannot change from here. Its success predicate is `>= 400` where the
+shared client uses `!= 200`. `withToken` is duplicated verbatim per client because the
+embedded struct cannot return the concrete type. The version constant `"v1"` is defined twice,
+in two repositories, with nothing keeping the two equal.
+
+### Would a shared library have plural clients?
+
+**Partly verifiable, and the honest answer is that two of the three cannot be checked from
+here.**
+
+Hexis is verified. It is a Go module consumed through a `replace` directive, and it already
+publishes a Go client library that Maven imports. That is an existence proof that the pattern
+works for one of them.
+
+Praxis is suggested and not proven. Two comments reference Go paths in its repository
+(`cmd/mavend/factenrichment.go:4`, `cmd/mavend/ecosystem.go:365`). Nothing here compiles
+against it.
+
+Nexus is unverifiable from this repository. There is an HTTP base URL and some JSON shapes,
+and no language signal at all.
+
+So the claim that a shared library would have plural clients rests on one confirmed adopter
+and two assumptions. Do not present it as settled. The cheaper test is to fix Maven's side first,
+in Maven. Offer the package outward once it has proven itself on one caller.
+
+### What belongs in it
+
+The straw man is right, with one addition.
+
+- The correlation id, minted once per action, with one context key that all clients read. The
+  two-key split is the cause of the uncorrelated discovery hop.
+- Causation, since one of the three already supports it and the value is already computed.
+- The version header and `X-Requested-By`.
+- The timeout policy, as one number rather than 10 in one repository and 30 in another.
+- A typed error with the three classifiers, so a refused credential never speaks as an outage.
+- The named gap shape, so no client invents its own vocabulary the way Praxis did.
+
+### What must stay out
+
+**Authorization, for the second time and the same reason.** The confirmation binding is
+Maven's. It binds capability id, target entity, arguments, requester and expiry, and it lives
+in `cmd/mavend/confirm.go`. A shared client that offered a policy hook would invite each
+service to supply its own, and the binding would become configuration. Free text never reaches
+a mutating Hexis call, and entity resolution stays in Nexus. Neither belongs in a transport
+library.
+
+Retry stays out too, or nearly. The only retry Maven has is Nexus enrichment at the worker
+layer, with backoff from one minute to one hour (`cmd/mavend/factenrichment.go:49`). It is
+there because enrichment is a background job with no listener. A turn cannot retry, because
+the owner is standing there. A transport-level retry in a shared library would hide a
+second budget behind a turn that already has a name for failing.
+
+## The daemons must not get a framework
+
+The instinct is right, and half the work is already done in a way that shows why.
+
+Transport is shared and abstracted. `ipc.Dial` (`internal/ipc/client.go:94`) and `ipc.Listen`
+(`internal/ipc/server.go:202`) both go through `netaddr`. A bare path is a unix socket with
+`SO_PEERCRED` identity. A `tcp://host:port?token=...` address binds a network listener with a
+mandatory token. Callers pass a string and never branch on scheme. That seam made the
+workstation offload a deployment rather than a build. It is a library, it has nine clients in
+this repository, and it earns its weight.
+
+Startup is not shared, and should not be. There are twelve binaries under `cmd/`, each with a
+hand-written `main`, and no common lifecycle package. `cmd/mavend/main.go` runs 830 lines. The
+reason is visible in it. The daemon can boot **locked**, with no store at all, and wire its
+components later from inside an unlock handler. Thirteen subsystem pointers are pre-declared
+nil (`main.go:236`) and filled on one of two paths. The whole graph is built a second time
+inside the unlock path (`main.go:478`). A container owning object lifecycle would have to model
+a graph whose nodes do not exist at boot and may never exist.
+
+The deeper reason is a design property. Every daemon degrades alone, and every ecosystem
+client is nil unless configured. A wiring framework's job is to fail loudly when a dependency
+is missing. Maven needs the opposite: a missing dependency is a named gap in one answer and a
+working daemon everywhere else. An abstraction over startup would trade that property for a
+shorter `main`.
+
+The duplicated locked and unlocked wiring in `mavend` is a real defect and worth fixing. Fix it
+by extracting one function in that file. That is not a framework.
+
+## The honest comparison
+
+Spring and Django own object lifecycle and request handling for applications they have never
+seen. That is where the weight is paid for. The abstraction is general because the clients are
+unknown.
+
+Maven is one application, on one box, with one user. Its clients are known, there are nine of
+them, and they are in this repository. A framework here would be an abstraction with a census.
+
+So the right unit is a shared package and a convention. That is a smaller and more defensible
+claim. The evidence for its size is that both halves already exist in that form, and nobody
+called them a framework. `internal/ipc` is a shared package and a convention, and it carried
+the daemons off the box. `internal/decision` is a shared package and a convention, and it made
+the losers readable in one release. `internal/claim` is the third, written and waiting for a
+caller.
+
+The thing to disagree with: **the answer is two artifacts of different sizes. A package inside
+Maven, a library across the four services, and neither one is Spring.**

internal/audio/audio_test.go

@@ -82,6 +82,38 @@ func TestWAVRoundTrip(t *testing.T) {
 	}
 }
 
+// A LIST chunk sitting between fmt and data is common (arecord and ffmpeg both
+// write one), and its payload is free text that can spell "data". The parser
+// walks chunk headers, so the text is skipped and the real samples are read.
+func TestPCMFromWAVSkipsLISTChunk(t *testing.T) {
+	t.Parallel()
+	pcm := []byte{1, 0, 2, 0, 3, 0, 4, 0}
+	list := []byte("LIST")
+	payload := []byte("INFOICMTdata is not here")
+	list = binary.LittleEndian.AppendUint32(list, uint32(len(payload)))
+	list = append(list, payload...)
+
+	plain, err := WAVFromPCM(PCM16kMono, pcm)
+	if err != nil {
+		t.Fatalf("WAVFromPCM: %v", err)
+	}
+	wav := append([]byte{}, plain[:36]...)
+	wav = append(wav, list...)
+	wav = append(wav, plain[36:]...)
+	binary.LittleEndian.PutUint32(wav[4:8], uint32(len(wav)-8))
+
+	f, got, err := PCMFromWAV(wav)
+	if err != nil {
+		t.Fatalf("PCMFromWAV: %v", err)
+	}
+	if !f.IsValid() {
+		t.Fatalf("parsed format invalid: %+v", f)
+	}
+	if !bytes.Equal(got, pcm) {
+		t.Fatalf("PCM mismatch: got %v, want %v", got, pcm)
+	}
+}
+
 func TestPCMFromWAVRejectsNonCanonical(t *testing.T) {
 	t.Parallel()
 	// too short

internal/audio/pcmwav.go

@@ -36,6 +36,10 @@ const wavHeaderSize = 44
 // raw PCM samples (little-endian int16 as bytes). A non-canonical blob is
 // rejected with ErrNotCanonicalPCM; the format mismatch is logged at the seam
 // so the caller surfaces it, not a hidden silent downmix.
+//
+// The returned PCM aliases wav rather than copying it, because a recording is
+// large and the caller already owns the bytes. A caller that keeps the PCM past
+// the life of wav, or that reuses wav as a read buffer, must copy first.
 func PCMFromWAV(wav []byte) (Format, []byte, error) {
 	if len(wav) < wavHeaderSize {
 		return Format{}, nil, fmt.Errorf("audio: wav too short: %d bytes", len(wav))
@@ -61,17 +65,13 @@ func PCMFromWAV(wav []byte) (Format, []byte, error) {
 		return Format{}, nil, fmt.Errorf("%w: channels=%d bits=%d (want 1/16)", ErrNotCanonicalPCM, channels, bitsPerSample)
 	}
 	// data chunk: the spec mandates it appears right after fmt, but real
-	// recorders sometimes append extra chunks (LIST, fact). Find the "data"
-	// chunk by scanning; require it within the region we'd expect.
-	dataIdx := -1
-	for i := wavHeaderSize - 8; i+8 <= len(wav) && i < wavHeaderSize+4096; i++ {
-		if string(wav[i:i+4]) == "data" {
-			dataIdx = i
-			break
-		}
-	}
-	if dataIdx < 0 {
-		return Format{}, nil, fmt.Errorf("%w: no data chunk", ErrNotCanonicalPCM)
+	// recorders sometimes append extra chunks (LIST, fact). Walk the chunk
+	// headers rather than scanning for the four bytes "data", because those
+	// bytes occur inside a LIST/INFO payload as ordinary text and a byte scan
+	// would take the middle of a comment for a chunk header.
+	dataIdx, err := findDataChunk(wav)
+	if err != nil {
+		return Format{}, nil, err
 	}
 	dataSize := binary.LittleEndian.Uint32(wav[dataIdx+4 : dataIdx+8])
 	body := wav[dataIdx+8:]
@@ -90,6 +90,24 @@ func PCMFromWAV(wav []byte) (Format, []byte, error) {
 	return f, body, nil
 }
 
+// findDataChunk returns the offset of the "data" chunk header, walking the
+// chunk list that starts after the 16-byte fmt chunk. Chunks are word-aligned,
+// so an odd size carries one pad byte the next header sits behind.
+func findDataChunk(wav []byte) (int, error) {
+	for pos := wavHeaderSize - 8; pos+8 <= len(wav); {
+		size := int(binary.LittleEndian.Uint32(wav[pos+4 : pos+8]))
+		if string(wav[pos:pos+4]) == "data" {
+			return pos, nil
+		}
+		next := pos + 8 + size + size%2
+		if next <= pos || next > len(wav) {
+			break
+		}
+		pos = next
+	}
+	return 0, fmt.Errorf("%w: no data chunk", ErrNotCanonicalPCM)
+}
+
 // WAVFromPCM wraps raw 16-bit mono PCM bytes in a canonical 44-byte WAV
 // header so the result can be written to disk and played with `aplay`.
 // Used by the reference client to write the TTS reply; not on the wire.
@@ -115,7 +133,7 @@ const WAVHeaderSize = wavHeaderSize
 // avoiding.
 func WAVHeader(format Format, n int) ([]byte, error) {
 	if !format.IsValid() {
-		return nil, fmt.Errorf("audio: WAVFromPCM: %w: %+v", ErrNotCanonicalPCM, format)
+		return nil, fmt.Errorf("audio: WAVHeader: %w: %+v", ErrNotCanonicalPCM, format)
 	}
 	out := make([]byte, wavHeaderSize)
 	// RIFF header

internal/calendar/calendar.go

@@ -140,6 +140,12 @@ const EventKeyPrefix = "calendar_event_"
 //
 // An end at or before the start is read as crossing midnight, so a 23:30-00:15
 // meeting covers the quarter hour it actually covers.
+//
+// Both readings are built with time.Date rather than added to midnight as a
+// duration. A day is 23 or 25 hours wide on the two DST changeovers, so
+// midnight plus fourteen hours is 13:00 or 15:00 on those days, and the busy
+// gate would then read a 14:00 meeting an hour off. The same goes for the
+// midnight crossing, which is AddDate and not a 24-hour add.
 func FactSpan(key, value string, loc *time.Location) (start, end time.Time, ok bool) {
 	if !strings.HasPrefix(key, EventKeyPrefix) {
 		return time.Time{}, time.Time{}, false
@@ -172,10 +178,11 @@ func FactSpan(key, value string, loc *time.Location) (start, end time.Time, ok b
 	if !ok1 || !ok2 {
 		return time.Time{}, time.Time{}, false
 	}
-	start = day.Add(time.Duration(sh)*time.Hour + time.Duration(sm)*time.Minute)
-	end = day.Add(time.Duration(eh)*time.Hour + time.Duration(em)*time.Minute)
+	y, mo, d := day.Date()
+	start = time.Date(y, mo, d, sh, sm, 0, 0, loc)
+	end = time.Date(y, mo, d, eh, em, 0, 0, loc)
 	if !end.After(start) {
-		end = end.Add(24 * time.Hour)
+		end = end.AddDate(0, 0, 1)
 	}
 	return start, end, true
 }

internal/calendar/ical.go

@@ -66,7 +66,7 @@ func ParseICalDay(body []byte, now time.Time) []Event {
 // Reports false for all-day events and parse failures.
 func parseVEVENT(block string, loc *time.Location) (Event, bool) {
 	var e Event
-	for _, line := range strings.Split(block, "\n") {
+	for _, line := range strings.Split(unfold(block), "\n") {
 		line = strings.TrimSpace(line)
 		switch {
 		case strings.HasPrefix(line, "DTSTART"):
@@ -78,9 +78,9 @@ func parseVEVENT(block string, loc *time.Location) (Event, bool) {
 				e.End = t
 			}
 		case strings.HasPrefix(line, "SUMMARY"):
-			e.Summary = afterColon(line)
+			e.Summary = unescapeText(afterColon(line))
 		case strings.HasPrefix(line, "UID"):
-			e.UID = afterColon(line)
+			e.UID = unescapeText(afterColon(line))
 		}
 	}
 	if e.Start.IsZero() || e.End.IsZero() {
@@ -89,6 +89,48 @@ func parseVEVENT(block string, loc *time.Location) (Event, bool) {
 	return e, true
 }
 
+// unfold undoes RFC 5545 content-line folding, where a long property is split
+// with a CRLF and the continuation begins with one space or tab.
+//
+// It runs before the block is split into lines, because splitting first and
+// trimming each line destroys the leading space that marks a continuation. A
+// server folds at 75 octets and a Russian summary is two bytes a letter, so
+// "Еженедельная планёрка с командой" crosses the limit easily — without this
+// the tail of the summary was read as an unknown property and dropped, and the
+// event was filed under a truncated name.
+func unfold(block string) string {
+	if !strings.Contains(block, "\n ") && !strings.Contains(block, "\n\t") {
+		return block
+	}
+	return strings.NewReplacer("\r\n ", "", "\r\n\t", "", "\n ", "", "\n\t", "").Replace(block)
+}
+
+// unescapeText reverses the RFC 5545 TEXT escaping escapeText applies. Without
+// it a summary a server wrote as "Обед\, потом созвон" reaches the day plan
+// with the backslash still in it, and FactKey folds that literal into the key.
+func unescapeText(s string) string {
+	if !strings.Contains(s, `\`) {
+		return s
+	}
+	var b strings.Builder
+	b.Grow(len(s))
+	for i := 0; i < len(s); i++ {
+		if s[i] != '\\' || i+1 >= len(s) {
+			b.WriteByte(s[i])
+			continue
+		}
+		i++
+		switch s[i] {
+		case 'n', 'N':
+			b.WriteByte('\n')
+		default:
+			// ";", ",", "\\" and anything else a writer escaped needlessly.
+			b.WriteByte(s[i])
+		}
+	}
+	return b.String()
+}
+
 func afterColon(line string) string {
 	if i := strings.Index(line, ":"); i >= 0 {
 		return strings.TrimSpace(line[i+1:])

internal/calendar/ical_render_test.go

@@ -61,6 +61,44 @@ func TestRenderICalEscapesInjection(t *testing.T) {
 	}
 }
 
+// A folded SUMMARY is one property, not a property plus a dropped tail. Servers
+// fold at 75 octets and a Russian summary is two bytes a letter.
+func TestParseICalUnfoldsAndUnescapes(t *testing.T) {
+	body := []byte("BEGIN:VEVENT\r\n" +
+		"UID:u1\r\n" +
+		"DTSTART:20260703T130000Z\r\n" +
+		"DTEND:20260703T140000Z\r\n" +
+		"SUMMARY:Еженедельная планёрка\\, потом\r\n  созвон\r\n" +
+		"END:VEVENT\r\n")
+	from := time.Date(2026, 7, 3, 0, 0, 0, 0, time.UTC)
+	events := ParseICal(body, from, from.AddDate(0, 0, 1))
+	if len(events) != 1 {
+		t.Fatalf("got %d events, want 1", len(events))
+	}
+	if want := "Еженедельная планёрка, потом созвон"; events[0].Summary != want {
+		t.Errorf("Summary = %q, want %q", events[0].Summary, want)
+	}
+}
+
+// A day is 23 hours wide where DST starts, so a wall clock reading has to be
+// built with time.Date and never as midnight plus a duration.
+func TestFactSpanAcrossDSTStart(t *testing.T) {
+	loc, err := time.LoadLocation("Europe/Berlin")
+	if err != nil {
+		t.Skipf("no tzdata for Europe/Berlin: %v", err)
+	}
+	start, end, ok := FactSpan("calendar_event_20260329_Planerka", "Planerka @ 14:00-15:00", loc)
+	if !ok {
+		t.Fatal("FactSpan reported not ok")
+	}
+	if start.Hour() != 14 || start.Minute() != 0 {
+		t.Errorf("start = %s, want a 14:00 wall clock", start)
+	}
+	if end.Hour() != 15 {
+		t.Errorf("end = %s, want a 15:00 wall clock", end)
+	}
+}
+
 func TestReminderEventEmptyPayload(t *testing.T) {
 	e := ReminderEvent(3, time.Date(2026, 8, 1, 9, 0, 0, 0, time.UTC), "   ", 0)
 	if e.Summary != "напоминание" {

internal/capture/capture.go

@@ -626,6 +626,9 @@ func windowBytes(f audio.Format, window time.Duration) int64 {
 	if bps <= 0 || f.SampleRate <= 0 || window <= 0 {
 		return 0
 	}
-	per := int64(window.Seconds()) * bytesPerSecond(f)
+	// Fractional seconds count. Truncating the window to whole seconds turned
+	// any sub-second window into zero bytes, which the caller reads as "no
+	// window" and answers by handing the transcriber the entire meeting at once.
+	per := int64(window.Seconds() * float64(bytesPerSecond(f)))
 	return per - per%bps
 }

internal/capture/summarize.go

@@ -193,9 +193,7 @@ func ChunkText(text string, maxRunes int) []string {
 			// Oversized sentence: emit what is buffered, then cut this one on
 			// word boundaries.
 			flush()
-			for _, piece := range splitWords(sr, maxRunes) {
-				out = append(out, piece)
-			}
+			out = append(out, splitWords(sr, maxRunes)...)
 			continue
 		}
 		if len(cur)+len(sr) > maxRunes {

internal/claim/claim.go

@@ -2,8 +2,8 @@
 // utterance (V-565, umbrella V-558, design in
 // docs/plans/19-dialogue-arbitration.md).
 //
-// Maven's cascade has roughly ten stage-0 grammars, seven router intents,
-// twenty-two query sources and four stateful pre-emptors, and every one of them
+// Maven's cascade has twenty-two stage-0 grammars, seven router intents,
+// twenty-two query sources and seven stateful pre-emptors, and every one of them
 // answers "is this mine?" alone. None can answer "is this more mine than
 // yours?", because their scores are not comparable: stage 0 asserts 1.0 by
 // fiat, the classifier reports a cosine, the LLM router derives one from
@@ -56,8 +56,9 @@ const (
 	// BandStructural — the claimant read the whole sentence and produced a
 	// complete route, every slot its intent requires filled. The LLM router at
 	// full confidence, and a stateful claimant holding a pending question.
-	// Below BandAnchored on purpose: the four stateful claimants pre-empt
-	// unconditionally today, and that is the V-558 defect.
+	// Below BandAnchored on purpose: the stateful claimants pre-empt
+	// unconditionally today, and that is the V-558 defect. There are seven of
+	// them and preRouteLadder in cmd/mavend/decisiontrace.go is the roster.
 	BandStructural
 
 	// BandAnchored — a literal pattern anchored in the utterance matched, and

internal/config/config.go

@@ -15,6 +15,7 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	"log"
 	"os"
 	"path/filepath"
 	"time"
@@ -329,7 +330,15 @@ func Load(path string) (*Config, error) {
 	// Expand ${VAR} or $VAR patterns from environment variables. This lets
 	// secrets live in env (docker-compose env_file) rather than the config
 	// file committed to git.
-	expanded := os.ExpandEnv(string(b))
+	expanded, missing := expandEnv(string(b))
+	if len(missing) > 0 {
+		// An unset variable expands to "", which every block reads as "not
+		// configured" and none of them complains about. That is the intended
+		// behaviour and it stays: CI parses this same file with no secrets
+		// present. What was missing is the line telling the operator which
+		// capability he just turned off by forgetting an env file.
+		log.Printf("config: %s references unset environment variables %v — those settings are empty, so whatever they configure is off", path, missing)
+	}
 	var c Config
 	if err := json.Unmarshal([]byte(expanded), &c); err != nil {
 		return nil, fmt.Errorf("config: parse %s: %w", path, err)
@@ -341,6 +350,23 @@ func Load(path string) (*Config, error) {
 	return &c, nil
 }
 
+// expandEnv is os.ExpandEnv plus the names it could not resolve, each reported
+// once and in the order the file mentions them. A variable set to the empty
+// string counts as set: the operator wrote it down, so he meant it.
+func expandEnv(s string) (string, []string) {
+	var missing []string
+	seen := map[string]bool{}
+	out := os.Expand(s, func(name string) string {
+		v, ok := os.LookupEnv(name)
+		if !ok && !seen[name] {
+			seen[name] = true
+			missing = append(missing, name)
+		}
+		return v
+	})
+	return out, missing
+}
+
 func (c *Config) applyDefaults() {
 	if c.IntakeJournal == 0 {
 		c.IntakeJournal = DefaultIntakeJournal

internal/crawl/crawl.go

@@ -57,6 +57,16 @@ var (
 	ErrFetchStatus = errors.New("crawl: the server answered with an error status")
 )
 
+// StatusError is ErrFetchStatus with the code the server actually sent. The
+// adapter builds it; isServerError reads Code rather than the message, so a
+// reworded error can no longer turn a 503 robots.txt into permission to crawl.
+type StatusError struct{ Code int }
+
+func (e *StatusError) Error() string {
+	return fmt.Sprintf("crawl: the server answered with status %d", e.Code)
+}
+func (e *StatusError) Unwrap() error { return ErrFetchStatus }
+
 // Fetcher is the guarded HTTP door (internal/webfetch adapted by the daemon). An
 // interface so this package constructs no http.Client of its own and can be
 // tested without a network.
@@ -233,16 +243,15 @@ func (c *Crawler) markFetched(host string) {
 	c.mu.Unlock()
 }
 
-// isServerError — a 5xx rather than any other non-2xx. The adapter formats the
-// status into the message, which is the only place it survives.
+// isServerError — a 5xx rather than any other non-2xx. A status the adapter
+// could not recover reads as 0 and is not a server error, which keeps the
+// standard's "404 means allow" as the default for an unknown.
 func isServerError(err error) bool {
-	s := err.Error()
-	for _, code := range []string{" 50", " 51", " 52", " 53"} {
-		if strings.Contains(s, code) {
-			return true
-		}
+	var se *StatusError
+	if !errors.As(err, &se) {
+		return false
 	}
-	return false
+	return se.Code >= 500 && se.Code <= 599
 }
 
 // Hash is the dedup key for a crawl result: the sha256 of the extracted text,

internal/crawl/politeness_test.go

@@ -79,7 +79,7 @@ func TestPage_ABrokenRobotsServerIsNotPermissionToCrawl(t *testing.T) {
 	// way to resolve an unknown.
 	f := &timedFetcher{
 		pages: map[string]Response{"https://example.org/a": {Body: []byte("<html><body>a</body></html>")}},
-		errs:  map[string]error{"https://example.org/robots.txt": fmt.Errorf("%w: 503", ErrFetchStatus)},
+		errs:  map[string]error{"https://example.org/robots.txt": &StatusError{Code: 503}},
 	}
 	c := New(f, Config{UserAgent: "Maven/1.0"})
 	if _, err := c.Page(context.Background(), "https://example.org/a"); !errors.Is(err, ErrFetchStatus) {

internal/decision/ring.go

@@ -19,6 +19,13 @@ type Ring struct {
 func NewRing() *Ring { return &Ring{} }
 
 // Push adds one finished record and drops the oldest past the bound.
+//
+// The dropped pointers are cleared before the reslice. Resliceing alone moves
+// the window forward and leaves the evicted records addressable from the
+// backing array, so up to ringSize turns he had already aged out stayed in
+// memory until the next append reallocated. That is a leak anywhere and it is
+// the wrong one here, because the reason this store is memory-only is that his
+// words should not outlive the diagnosis.
 func (r *Ring) Push(rec *Record) {
 	if r == nil || rec == nil {
 		return
@@ -26,8 +33,11 @@ func (r *Ring) Push(rec *Record) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	r.recs = append(r.recs, rec)
-	if len(r.recs) > ringSize {
-		r.recs = r.recs[len(r.recs)-ringSize:]
+	if drop := len(r.recs) - ringSize; drop > 0 {
+		for i := 0; i < drop; i++ {
+			r.recs[i] = nil
+		}
+		r.recs = r.recs[drop:]
 	}
 }
 

internal/delivery/telegramsink/telegramsink.go

@@ -172,21 +172,49 @@ func (s *Sink) Send(ctx context.Context, d delivery.Sendable) error {
 		return fmt.Errorf("telegramsink: sendMessage: %w", s.redact(err))
 	}
 	defer resp.Body.Close()
-	rb, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
+	rb, _ := io.ReadAll(io.LimitReader(resp.Body, maxRespBytes))
 
 	// telegram returns 200 with ok=true on success; non-2xx with ok=false +
 	// error_code + description on failure. parse the body either way so a 200
 	// with ok=false (shouldn't happen, but the API reserves that) still surfaces.
 	var tr telegramResp
-	if jsonErr := json.Unmarshal(rb, &tr); jsonErr == nil && !tr.Ok {
+	jsonErr := json.Unmarshal(rb, &tr)
+	if jsonErr == nil && !tr.Ok {
 		return fmt.Errorf("telegramsink: telegram returned error %d: %s", tr.ErrorCode, strings.TrimSpace(tr.Description))
 	}
 	if resp.StatusCode/100 != 2 {
-		return fmt.Errorf("telegramsink: telegram returned %d: %s", resp.StatusCode, strings.TrimSpace(string(rb)))
+		return fmt.Errorf("telegramsink: telegram returned %d: %s", resp.StatusCode, snippet(rb))
+	}
+	// A 2xx whose body is not the bot API's envelope did not come from the bot
+	// API. The normal path here is the relay: this box reaches telegram through
+	// an HTTP/SOCKS5 proxy, and a proxy that is up but cannot reach
+	// api.telegram.org answers 200 with an HTML page of its own. Reading that as
+	// a delivered message is the worst outcome the sink has — the dispatcher
+	// writes a 'sent' outbox row, MarkSent restarts the repeat clock, and the
+	// sev4 alarm that never arrived goes quiet for a whole interval. Only
+	// ok=true is a send.
+	if jsonErr != nil {
+		return fmt.Errorf("telegramsink: telegram returned %d with a body that is not the bot API envelope (not a confirmed send): %s", resp.StatusCode, snippet(rb))
 	}
 	return nil
 }
 
+// maxRespBytes caps the response read — the body is wire-controlled and the
+// relay in front of it is not telegram. It is far above any sendMessage
+// envelope (a few hundred bytes; the result echoes one short away message),
+// because a truncated body no longer parses and now reads as a failed send.
+const maxRespBytes = 64 << 10
+
+// snippet trims a response body down to something an error line can carry. A
+// relay's HTML page is measured in kilobytes and none of it belongs in the log.
+func snippet(rb []byte) string {
+	s := strings.TrimSpace(string(rb))
+	if len(s) > 200 {
+		return s[:200] + "…"
+	}
+	return s
+}
+
 // sendMessageURL — the bot API path. the token is in the URL path
 // (https://api.telegram.org/bot<token>/sendMessage); telegram does not accept
 // it anywhere else. the URL is built per-send from the resolved base and never

internal/delivery/telegramsink/telegramsink_test.go

@@ -291,6 +291,66 @@ func TestSendReturnsErrorOnTelegramError(t *testing.T) {
 	}
 }
 
+// A relay that is up but cannot reach api.telegram.org answers 200 with a page
+// of its own. That is not a delivered message, and calling it one silences a
+// sev4 alarm for a full repeat interval.
+func TestSendRefusesA200ThatIsNotTheBotAPIEnvelope(t *testing.T) {
+	rs := newRecordingServer(t, http.StatusOK, `<html><body>proxy: upstream unreachable</body></html>`)
+	srv := httptest.NewServer(rs.handler())
+	defer srv.Close()
+
+	sink, _ := New(sinkCfg(srv.URL))
+	err := sink.Send(context.Background(), nudgeSendable(loop.Sev4, "down"))
+	if err == nil {
+		t.Fatal("want error on a 200 that is not the bot API envelope")
+	}
+	if !strings.Contains(err.Error(), "not a confirmed send") {
+		t.Fatalf("error should say the send is unconfirmed, got: %v", err)
+	}
+}
+
+// The success path must stay a success: ok=true on 200 is a send.
+func TestSendAcceptsOkTrue(t *testing.T) {
+	rs := newRecordingServer(t, http.StatusOK, `{"ok":true,"result":{"message_id":7}}`)
+	srv := httptest.NewServer(rs.handler())
+	defer srv.Close()
+
+	sink, _ := New(sinkCfg(srv.URL))
+	if err := sink.Send(context.Background(), nudgeSendable(loop.Sev4, "down")); err != nil {
+		t.Fatalf("want success on ok=true, got: %v", err)
+	}
+}
+
+// A body long enough to have been truncated by the old 4096-byte cap still
+// parses, so a real send is not reported as a failure.
+func TestSendAcceptsAnOversizedButValidEnvelope(t *testing.T) {
+	rs := newRecordingServer(t, http.StatusOK,
+		`{"ok":true,"result":{"message_id":7,"text":"`+strings.Repeat("x", 8000)+`"}}`)
+	srv := httptest.NewServer(rs.handler())
+	defer srv.Close()
+
+	sink, _ := New(sinkCfg(srv.URL))
+	if err := sink.Send(context.Background(), nudgeSendable(loop.Sev4, "down")); err != nil {
+		t.Fatalf("want success on a large ok=true envelope, got: %v", err)
+	}
+}
+
+// The error line carries a snippet, not the relay's whole page.
+func TestSendErrorDoesNotCarryTheWholeBody(t *testing.T) {
+	rs := newRecordingServer(t, http.StatusBadGateway, strings.Repeat("z", 5000))
+	srv := httptest.NewServer(rs.handler())
+	defer srv.Close()
+
+	sink, _ := New(sinkCfg(srv.URL))
+	err := sink.Send(context.Background(), nudgeSendable(loop.Sev4, "down"))
+	if err == nil {
+		t.Fatal("want error on 502")
+	}
+	if len(err.Error()) > 500 {
+		t.Fatalf("error line should be trimmed, got %d bytes", len(err.Error()))
+	}
+}
+
 func TestSendReturnsErrorOnNon2xx(t *testing.T) {
 	rs := newRecordingServer(t, http.StatusBadGateway, "bad gateway")
 	srv := httptest.NewServer(rs.handler())

internal/delivery/voicesink/voicesink.go

@@ -34,7 +34,6 @@ import (
 	"log"
 	"time"
 
-	"github.com/kami/maven/internal/audio"
 	"github.com/kami/maven/internal/delivery"
 	"github.com/kami/maven/internal/tts"
 	"github.com/kami/maven/internal/ttsnorm"
@@ -102,9 +101,3 @@ func (s *Sink) Send(ctx context.Context, send delivery.Sendable) error {
 	}
 	return nil
 }
-
-// keep audio import honest (used in Send's audio.PCM check indirect via
-// Format.IsValid which is a method on the imported audio.Format). The alias
-// below keeps the import alive even if a future refactor moves the only
-// reference. Today, the synthesizer's audio.Audio directly flows through.
-var _ = audio.PCM16kMono

internal/dialogue/clarify.go

@@ -31,9 +31,14 @@ type PendingQuestion struct {
 	Slots     Slots  // what it already filled
 	Missing   []Slot // what is still empty, in the order to ask about
 	Utterance string // the user's original raw words
-	Asked     time.Time
-	TTL       time.Duration
-	Attempts  int // questions already asked
+	// WhenText is every answer he has given about the time, joined in the order
+	// he gave them. Kept apart from Utterance because the utterance is the
+	// reminder's payload, and because a time answer has to be read against the
+	// request rather than alone: "завтра" names a day for an hour said earlier.
+	WhenText string
+	Asked    time.Time
+	TTL      time.Duration
+	Attempts int // questions already asked
 	// MaxAttempts caps Attempts. 0 ⇒ DefaultMaxAttempts.
 	MaxAttempts int
 }
@@ -99,11 +104,14 @@ type ClarifyStore struct {
 // reply can carry.
 const MaxStackDepth = 2
 
+// DefaultClarifyTTL — how long a parked question stays his answer to give.
+// Short, like confirmTTL in voice.go: a clarifying question is a same-breath
+// gesture, and a stale one should not eat a later utterance.
+const DefaultClarifyTTL = 90 * time.Second
+
 func NewClarifyStore(defaultTTL time.Duration) *ClarifyStore {
 	if defaultTTL <= 0 {
-		// Short, like confirmTTL in voice.go: a clarifying question is a
-		// same-breath gesture, a stale one should not eat a later utterance.
-		defaultTTL = 90 * time.Second
+		defaultTTL = DefaultClarifyTTL
 	}
 	return &ClarifyStore{
 		stacks:     make(map[string][]*PendingQuestion),
@@ -146,9 +154,15 @@ func (s *ClarifyStore) Push(id string, q *PendingQuestion) *PendingQuestion {
 	return dropped
 }
 
-// Peek returns the live question on top, or nil when there is none. Expired
-// entries below it are left alone: TakeExpired is what reports those, and
-// dropping one here would be the silent death this store is careful about.
+// Peek returns the live question on top, or nil when there is none. An expired
+// top takes the whole stack with it, exactly as Pop does: the clock that killed
+// it has been running for everything underneath too.
+//
+// That drop is silent, which is the death this store is otherwise careful
+// about, so TakeExpired has to run BEFORE Peek on a turn — it is what counts the
+// dropped questions and tells him they are gone. cmd/mavend/voice.go calls
+// clarifyExpiredNotice first for that reason, and reordering the two makes the
+// notice unreachable rather than wrong.
 func (s *ClarifyStore) Peek(id string, now time.Time) *PendingQuestion {
 	s.mu.RLock()
 	stack := s.stacks[id]

internal/dialogue/session.go

@@ -87,9 +87,14 @@ type SessionStore struct {
 	persist    SessionPersister // may be nil: memory only (tests, no-store paths)
 }
 
+// DefaultSessionTTL — how long a turn stays available to inherit from. Longer
+// than DefaultClarifyTTL because this is not a question waiting on an answer:
+// it is the last thing said, and a follow-up may land after a real pause.
+const DefaultSessionTTL = 2 * time.Minute
+
 func NewSessionStore(defaultTTL time.Duration) *SessionStore {
 	if defaultTTL <= 0 {
-		defaultTTL = 2 * time.Minute
+		defaultTTL = DefaultSessionTTL
 	}
 	return &SessionStore{
 		sessions:   make(map[string]*Session),

internal/email/charset.go

@@ -1,5 +1,7 @@
 package email
 
+import "strings"
+
 // windows-1251 (and its ASCII-compatible low half) is decoded here rather than
 // pulled in from x/text.
 //
@@ -35,14 +37,19 @@ var cp1251High = [128]rune{
 
 // decodeCP1251 maps each byte through the table. Every byte has a defined
 // meaning in this charset, so decoding cannot fail.
+//
+// It writes into a Builder rather than collecting runes: a []rune of the whole
+// body is four bytes a character and was then copied again into the string, so
+// a 1 MiB cp1251 mail allocated about 6 MiB to produce roughly 2.
 func decodeCP1251(b []byte) string {
-	out := make([]rune, 0, len(b))
+	var out strings.Builder
+	out.Grow(len(b))
 	for _, c := range b {
 		if c < 0x80 {
-			out = append(out, rune(c))
+			out.WriteByte(c)
 			continue
 		}
-		out = append(out, cp1251High[c-0x80])
+		out.WriteRune(cp1251High[c-0x80])
 	}
-	return string(out)
+	return out.String()
 }

internal/email/message.go

@@ -18,6 +18,7 @@
 package email
 
 import (
+	"bytes"
 	"encoding/base64"
 	"fmt"
 	"io"
@@ -57,7 +58,10 @@ type Message struct {
 // through, because a subject line alone is often the whole task ("Счёт за
 // интернет"). Only a message whose headers cannot be read at all is an error.
 func ParseMessage(uid uint32, raw []byte) (Message, error) {
-	m, err := mail.ReadMessage(strings.NewReader(string(raw)))
+	// bytes.NewReader, not strings.NewReader(string(raw)): the conversion copied
+	// the whole message, and MaxMessageBytes lets that be 2 MiB per mail on a box
+	// already holding the resident model.
+	m, err := mail.ReadMessage(bytes.NewReader(raw))
 	if err != nil {
 		return Message{}, fmt.Errorf("email: parse message: %w", err)
 	}
@@ -82,6 +86,23 @@ func ParseMessage(uid uint32, raw []byte) (Message, error) {
 // wholesale — an attachment is a file, not a sentence, and reading one would
 // mean parsing arbitrary formats from the network.
 func plaintextBody(contentType, encoding string, body io.Reader) (string, error) {
+	return plaintextBodyAt(contentType, encoding, body, 0)
+}
+
+// MaxMIMEDepth — how deep the MIME tree is walked.
+//
+// The nesting comes off the wire, so the recursion depth is the sender's to
+// pick: a boundary line is a few bytes, and one message inside MaxMessageBytes
+// can declare tens of thousands of multipart levels. Real mail is three deep
+// (mixed, then alternative, then related), so a message past this is malformed
+// or hostile and truncating the walk costs a body nobody was going to read.
+const MaxMIMEDepth = 12
+
+// plaintextBodyAt is plaintextBody carrying the current nesting depth.
+func plaintextBodyAt(contentType, encoding string, body io.Reader, depth int) (string, error) {
+	if depth > MaxMIMEDepth {
+		return "", nil
+	}
 	mediaType, params, err := mime.ParseMediaType(contentType)
 	if contentType == "" || err != nil {
 		// No Content-Type at all is legal and means text/plain; a broken one is
@@ -94,7 +115,7 @@ func plaintextBody(contentType, encoding string, body io.Reader) (string, error)
 		if boundary == "" {
 			return "", fmt.Errorf("email: multipart without boundary")
 		}
-		plain, html, err := multipartText(multipart.NewReader(body, boundary))
+		plain, html, err := multipartText(multipart.NewReader(body, boundary), depth+1)
 		if err != nil {
 			return "", err
 		}
@@ -124,7 +145,7 @@ func plaintextBody(contentType, encoding string, body io.Reader) (string, error)
 // contribute either kind. Folding a nested level's answer into one string put
 // HTML-derived text in the plain bucket, and a real text/plain sibling later in
 // the message was then thrown away by the "plain is already set" guard.
-func multipartText(mr *multipart.Reader) (plain, html string, err error) {
+func multipartText(mr *multipart.Reader, depth int) (plain, html string, err error) {
 	for {
 		part, err := mr.NextPart()
 		if err == io.EOF {
@@ -143,8 +164,8 @@ func multipartText(mr *multipart.Reader) (plain, html string, err error) {
 		switch {
 		case strings.HasPrefix(mediaType, "multipart/"):
 			var np, nh string
-			if b := params["boundary"]; b != "" {
-				np, nh, _ = multipartText(multipart.NewReader(part, b))
+			if b := params["boundary"]; b != "" && depth <= MaxMIMEDepth {
+				np, nh, _ = multipartText(multipart.NewReader(part, b), depth+1)
 			}
 			part.Close()
 			if plain == "" {
@@ -154,7 +175,7 @@ func multipartText(mr *multipart.Reader) (plain, html string, err error) {
 				html = nh
 			}
 		default:
-			text, terr := plaintextBody(ct, part.Header.Get("Content-Transfer-Encoding"), part)
+			text, terr := plaintextBodyAt(ct, part.Header.Get("Content-Transfer-Encoding"), part, depth)
 			part.Close()
 			if terr != nil || strings.TrimSpace(text) == "" {
 				continue

internal/email/message_test.go

@@ -1,6 +1,7 @@
 package email
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -143,6 +144,24 @@ func TestParseTruncatesLongBody(t *testing.T) {
 	}
 }
 
+// Nesting depth comes off the wire, so a hostile message must not get to pick
+// the recursion depth. The walk stops and the headers still come through.
+func TestParseMessageBoundsMIMEDepth(t *testing.T) {
+	var b strings.Builder
+	b.WriteString("Subject: deep\r\nMIME-Version: 1.0\r\n")
+	for i := 0; i < MaxMIMEDepth+20; i++ {
+		fmt.Fprintf(&b, "Content-Type: multipart/mixed; boundary=\"b%d\"\r\n\r\n--b%d\r\n", i, i)
+	}
+	b.WriteString("Content-Type: text/plain\r\n\r\nглубоко\r\n")
+	msg, err := ParseMessage(7, []byte(b.String()))
+	if err != nil {
+		t.Fatalf("ParseMessage: %v", err)
+	}
+	if msg.Subject != "deep" {
+		t.Errorf("Subject = %q, want the headers to survive", msg.Subject)
+	}
+}
+
 func TestCollapseSqueezesBlankLines(t *testing.T) {
 	got := collapse("  a  b \r\n\r\n\r\n\r\n  c  \r\n")
 	if got != "a b\n\nc" {

internal/ipc/wire.go

@@ -131,9 +131,15 @@ const (
 	codeInternal        = "internal"
 )
 
-// codeOf maps a server-side sentinel to its wire code. Anything not matched
-// is codeInternal — we never leak internal Go error text to a module; it
-// gets a generic "internal" and the daemon logs the real error server-side.
+// codeOf maps a server-side sentinel to its wire code. Anything not matched is
+// codeInternal.
+//
+// This used to claim the text of an unmatched error stays server-side. It does
+// not: rpcErr below ships err.Error() for codeInternal and codeBadParams,
+// deliberately, because on those two codes the text is the whole diagnostic and
+// a module has no other way to see it. Worth knowing before putting a secret in
+// an error string, and worth knowing twice on a tcp seam, where that string
+// leaves the box.
 func codeOf(err error) string {
 	switch {
 	case err == nil:

internal/kiwix/client.go

@@ -39,11 +39,16 @@ type Client struct {
 	http *http.Client
 }
 
+// clientTimeout — the whole request, search or article. The server is on the
+// same box (see the package doc), so this is slack for a cold ZIM read, not a
+// budget tuned against a flaky link the way websearch.DefaultTimeout is.
+const clientTimeout = 10 * time.Second
+
 // New makes a client for a Kiwix base URL like http://127.0.0.1:8034.
 func New(baseURL string) *Client {
 	return &Client{
 		base: strings.TrimRight(baseURL, "/"),
-		http: &http.Client{Timeout: 10 * time.Second},
+		http: &http.Client{Timeout: clientTimeout},
 	}
 }
 

internal/lexicon/lexicon.go

@@ -62,10 +62,10 @@ func mustLoad() lexiconFile {
 	}
 	for _, name := range []string{
 		"interrogatives", "capture_verbs", "narrative_requests", "cardinals", "ordinals",
-		"day_offsets", "weekdays", "months_genitive", "hours_spoken",
+		"day_offsets", "weekdays", "weekdays_english", "months_genitive", "hours_spoken",
 		"not_place_after_v", "parts_of_day", "reminder_verbs", "half_hour",
 		"filler_particles", "task_done_words", "task_drop_words",
-		"confirm_yes", "confirm_no",
+		"confirm_yes", "confirm_no", "hour_units", "minute_units",
 	} {
 		s, ok := f.Sets[name]
 		if !ok || (len(s.Words) == 0 && len(s.Values) == 0) {
@@ -135,11 +135,68 @@ func ConfirmNo() []string { return words("confirm_no") }
 // TaskDropWords — see TaskDoneWords.
 func TaskDropWords() []string { return words("task_drop_words") }
 
+// WaterNouns and DrinkVerbs are the two halves of a water fact: he has to name
+// the drink and the drinking, because "вода" alone is a word about water and
+// "выпил" alone does not say what. The other four self-care sets need only one
+// word each. All six are matched over tokens by lemma — except ShowerWords, see
+// its own note.
+func WaterNouns() []string { return words("water_nouns") }
+
+// DrinkVerbs — see WaterNouns.
+func DrinkVerbs() []string { return words("drink_verbs") }
+
+// MealWords returns the nouns and verbs of having eaten.
+func MealWords() []string { return words("meal_words") }
+
+// ShowerWords returns the shower noun. Match these EXACTLY and not by lemma:
+// the dictionary makes "душ" and "душа" one word, and only one of them is a
+// shower. The set's note says why exact matching costs nothing here.
+func ShowerWords() []string { return words("shower_words") }
+
+// BreakWords returns the noun and verbs of taking a break.
+func BreakWords() []string { return words("break_words") }
+
+// SleepWords returns the verbs of having slept.
+func SleepWords() []string { return words("sleep_words") }
+
 // SlotValueFrame returns the words that can surround a bare slot value without
 // making the utterance a request of its own. A caller strips these (along with
 // the numbers and the other closed time sets) to see whether an utterance
 // carries any content beside the value it was asked for. See the set's note.
-func SlotValueFrame() []string { return words("slot_value_frame") }
+// The hour and the minute nouns are part of the frame and are kept in their own
+// sets, so there is one copy of each closed class rather than a copy per caller.
+func SlotValueFrame() []string {
+	out := words("slot_value_frame")
+	out = append(out, HourUnits()...)
+	out = append(out, MinuteUnits()...)
+	return out
+}
+
+// HourUnits returns every form of the hour noun, and MinuteUnits every form of
+// the minute noun. One home for each, because four router sets used to list the
+// hour and all four stopped at "часу" (V-609). A caller folding time words into
+// one set reads these; a caller asking about a single word reads IsHourUnit or
+// IsMinuteUnit.
+func HourUnits() []string { return words("hour_units") }
+
+// MinuteUnits — see HourUnits.
+func MinuteUnits() []string { return words("minute_units") }
+
+// IsHourUnit reports whether a word is the hour noun in any form.
+func IsHourUnit(word string) bool { return inSet("hour_units", word) }
+
+// IsMinuteUnit reports whether a word is the minute noun in any form.
+func IsMinuteUnit(word string) bool { return inSet("minute_units", word) }
+
+func inSet(set, word string) bool {
+	w := norm(word)
+	for _, s := range ru.Sets[set].Words {
+		if w == s {
+			return true
+		}
+	}
+	return false
+}
 
 // DialogueCancel returns the ways he calls off the request Maven is assembling.
 // Distinct from TaskDropWords, which abandons an item that already exists.
@@ -283,6 +340,20 @@ func DayOffsetIn(text string) (int, bool) {
 // Go's time.Weekday. An index off the end returns "".
 func Weekday(i int) string { return at("weekdays", i) }
 
+// Weekdays returns the seven Russian names in one slice, Sunday first, for a
+// caller matching a token against all of them rather than rendering one. Only
+// the nominative is here: every other case lemmatises to it, so an oblique form
+// is morph's question and not a second list (V-581).
+func Weekdays() []string { return words("weekdays") }
+
+// WeekdayEnglish reports the Go time.Weekday index an English weekday names,
+// singular or plural. English needs the list that Russian does not, because the
+// vendored dictionary is Russian and leaves "mondays" as it found it.
+func WeekdayEnglish(word string) (int, bool) {
+	n, ok := ru.Sets["weekdays_english"].Values[norm(word)]
+	return n, ok
+}
+
 // MonthGenitive returns the month name a date takes — "10 июля", not "июль".
 // The set is 1-indexed, so MonthGenitive(int(t.Month())) is the whole call.
 func MonthGenitive(m int) string { return at("months_genitive", m) }

internal/lexicon/lexicon_ru_v1.json

@@ -56,13 +56,13 @@
       }
     },
     "cardinals": {
-      "note": "Number words as spoken, with the gender variants Russian requires (один/одна/одно and два/две agree with the noun that follows) and the oblique forms, because a spoken time declines: \"в семь\", \"к семи\", \"около семи\" are three forms of one hour (Vikunja #530). Values are the number itself. Twenties and up are compounds and are read as their parts, so only the round members are listed.",
+      "note": "Number words as spoken, with the gender variants Russian requires (один/одна/одно and два/две agree with the noun that follows) and the oblique forms, because a spoken time declines: \"в семь\", \"к семи\", \"около семи\" are three forms of one hour (Vikunja #530). Values are the number itself. Twenties and up are compounds and are read as their parts, so only the round members are listed. From five up one oblique form serves the genitive, dative and prepositional, so \"пяти\" is the whole set; one to four decline separately and carry the dative and instrumental of their own, because \"к двум часам\" and \"к трём\" are hours he says (V-581).",
       "values": {
         "ноль": 0, "нуль": 0, "zero": 0,
-        "один": 1, "одна": 1, "одно": 1, "одного": 1, "одной": 1, "одну": 1, "one": 1,
-        "два": 2, "две": 2, "двух": 2, "two": 2,
-        "три": 3, "трёх": 3, "трех": 3, "three": 3,
-        "четыре": 4, "четырёх": 4, "четырех": 4, "four": 4,
+        "один": 1, "одна": 1, "одно": 1, "одного": 1, "одной": 1, "одну": 1, "одному": 1, "одним": 1, "one": 1,
+        "два": 2, "две": 2, "двух": 2, "двум": 2, "двумя": 2, "two": 2,
+        "три": 3, "трёх": 3, "трех": 3, "трём": 3, "трем": 3, "тремя": 3, "three": 3,
+        "четыре": 4, "четырёх": 4, "четырех": 4, "четырём": 4, "четырем": 4, "четырьмя": 4, "four": 4,
         "пять": 5, "пяти": 5, "five": 5,
         "шесть": 6, "шести": 6, "six": 6,
         "семь": 7, "семи": 7, "seven": 7,
@@ -111,6 +111,18 @@
         "четверг", "пятница", "суббота"
       ]
     },
+    "weekdays_english": {
+      "note": "The English weekday names with their Go time.Weekday index, plus the plural a habit is spoken in (\"on mondays\"). English is listed as words where Russian is not, because the vendored dictionary is Russian: it lemmatises \"пятницу\" to \"пятница\" on its own and leaves \"mondays\" alone (V-581). So the Russian side of a weekday match is grammar and the English side is data.",
+      "values": {
+        "sunday": 0, "sundays": 0,
+        "monday": 1, "mondays": 1,
+        "tuesday": 2, "tuesdays": 2,
+        "wednesday": 3, "wednesdays": 3,
+        "thursday": 4, "thursdays": 4,
+        "friday": 5, "fridays": 5,
+        "saturday": 6, "saturdays": 6
+      }
+    },
     "months_genitive": {
       "note": "The form a date takes: \"10 июля\", not \"июль\". 1-indexed, so slot 0 is empty and month numbers need no arithmetic.",
       "words": [
@@ -198,6 +210,20 @@
         "передумал", "передумала", "неактуально"
       ]
     },
+    "hour_units": {
+      "note": "Every form of the hour noun, Russian and English (V-609). One home for a closed class that four router sets used to list separately, and all four stopped at \"часу\": \"напомни к двум часам\" lost its hour and the reminder was left asking \"Когда?\". Russian declines, so the dative plural is as ordinary a way to say an hour as the accusative singular. A caller that folds time words into one set reads HourUnits; a caller asking about one word reads IsHourUnit.",
+      "words": [
+        "час", "часа", "часов", "часу", "часам", "часами", "часах",
+        "hour", "hours"
+      ]
+    },
+    "minute_units": {
+      "note": "Every form of the minute noun, Russian and English (V-609). Same class as hour_units one noun over, and it had the same gap: the dative plural \"минутам\" was missing everywhere \"минут\" and \"минуты\" were present.",
+      "words": [
+        "минута", "минуты", "минуту", "минут", "минуте", "минутам", "минутами", "минутах",
+        "minute", "minutes"
+      ]
+    },
     "slot_value_frame": {
       "note": "The words that can stand around a bare slot value without making the utterance a request of its own (Vikunja #560). Prepositions, hedges and the nouns a spoken time is built from: strip these, the numbers, the interrogatives, the filler particles and the other time sets, and whatever is left is the utterance's OWN content. \"а что если в 11:00\" leaves nothing and is an answer; \"какая сейчас погода в Риме\" leaves \"погода\" and \"Риме\" and is not. Closed because each part of it is closed — Russian has a fixed list of prepositions, and a clock is built from a fixed list of nouns. It is not a stopword list: a word goes in only if it can never be the thing he is asking about.",
       "words": [
@@ -205,10 +231,10 @@
         "at", "on", "in", "by", "to", "till", "until", "after", "before", "about", "for",
         "нет", "не", "да", "ага", "угу", "ой", "ох", "тогда", "лучше", "может", "можно", "наверное", "наверно", "пожалуй", "точнее", "скорее", "если", "пусть", "прости", "извини", "слушай", "значит", "как-то", "типа", "вообще-то",
         "no", "yes", "yeah", "ok", "okay", "sorry", "maybe", "actually", "rather", "then", "well",
-        "час", "часа", "часов", "часу", "часам", "минут", "минута", "минуты", "минуту", "минутах", "полдень", "полночь", "полдня",
+        "полдень", "полночь", "полдня",
         "утра", "утро", "утру", "дня", "день", "днями", "вечера", "вечер", "вечеру", "ночи", "ночь", "ночью",
         "сейчас", "теперь", "сегодняшний", "ближайший", "ближайшее",
-        "hour", "hours", "minute", "minutes", "noon", "midnight", "am", "pm", "oclock", "now"
+        "noon", "midnight", "am", "pm", "oclock", "now"
       ]
     },
     "dialogue_cancel": {
@@ -226,6 +252,50 @@
         "yes", "yeah", "yep", "yup", "ok", "okay", "sure", "confirm", "affirmative"
       ]
     },
+    "water_nouns": {
+      "note": "The water noun, in the forms he drinks it in, plus English (V-586). Closed because it is one noun: Russian gives it six cases and two numbers and that is the whole list. Both \"вода\" and \"водой\" are listed even though one declension covers both, because the vendored dictionary lemmatises \"воды\" to \"вод\" and \"водой\" to \"вода\" — two lemmas for one noun, so the set has to name both or a caller matching by lemma misses half of them. Matched over tokens with morph.SameWord, never as a substring: the \"вод\" this replaced fired on \"водитель\" and \"заводить\".",
+      "words": [
+        "вода", "водой", "водичка", "water"
+      ]
+    },
+    "drink_verbs": {
+      "note": "Drinking, in the aspects and prefixes he speaks (V-586). Closed in the sense that matters: these are the verbs that make a water noun a water FACT, and the list is her vocabulary rather than a discovery about Russian. \"пил\" and \"пили\" are listed as surface forms because the dictionary lemmatises them to \"пила\", the saw; the perfective forms lemmatise correctly and one member each covers them. Whole tokens only — the substring \"пил\" this replaced fired on \"пилот\".",
+      "words": [
+        "пить", "пил", "пили", "пей", "выпить", "попить", "допить", "запить",
+        "drink", "drank", "drinking"
+      ]
+    },
+    "meal_words": {
+      "note": "Eating: the meal nouns and the verbs of having one (V-586). Closed the same way capture_verbs is — these are the words that write a meal fact, decided here. The verbs are listed in the infinitive because that is the lemma the dictionary returns, so \"поужинал\" and \"позавтракал\" match without their own entries. \"есть\" and \"ел\" are deliberately ABSENT: \"есть\" is also the existential, and \"есть новости по бэкапу\" is a question rather than a meal. The English \"ate\" carried a guard against \"backup\" when this was a substring test; over tokens the guard is unnecessary.",
+      "words": [
+        "обед", "обедать", "пообедать",
+        "ужин", "ужинать", "поужинать",
+        "завтрак", "завтракать", "позавтракать",
+        "еда", "перекус", "перекусить",
+        "поесть", "кушать", "покушать",
+        "meal", "ate", "lunch", "dinner", "breakfast"
+      ]
+    },
+    "shower_words": {
+      "note": "The shower, and the one set here matched EXACTLY rather than by lemma (V-586). The dictionary lemmatises \"душ\" to \"душа\", so a lemma test cannot tell a shower from a soul, and \"на душе легко\" is not a fact about washing. The accusative of an inanimate noun is its nominative, so \"принял душ\" and \"сходил в душ\" are both the bare form and exact matching loses nothing he actually says. The substring this replaced also fired on \"душно\".",
+      "words": [
+        "душ", "душем", "shower", "showered"
+      ]
+    },
+    "break_words": {
+      "note": "Taking a break, noun and verb (V-586). Closed like meal_words and for the same reason. \"отдых\" and \"отдыхать\" are both listed because the noun and the verb are separate lemmas; the perfective \"отдохнул\" lemmatises to \"отдохнуть\".",
+      "words": [
+        "перерыв", "отдых", "отдыхать", "отдохнуть", "передохнуть",
+        "break", "rest"
+      ]
+    },
+    "sleep_words": {
+      "note": "Sleeping (V-586). The imperfective surface forms \"спал\" and \"спала\" are listed because the dictionary lemmatises them to \"спасть\", a different verb, and one entry for the pair is the honest fix; the prefixed forms lemmatise consistently and their infinitives cover them. \"сон\" is absent: the noun names a dream as readily as a night's sleep, and it was not in the pattern this replaces either.",
+      "words": [
+        "спать", "спал", "поспать", "поспал", "проспать", "выспаться",
+        "sleep", "slept", "sleeping"
+      ]
+    },
     "confirm_no": {
       "note": "The answers that decline a parked confirm. Same matching rule as confirm_yes and the same reason. The multi-word members are here rather than assembled by a caller because \"надо\" alone is not an answer and \"не надо\" is the opposite of one: the two must land on opposite sides, and only the phrase says which. \"не\" on its own is NOT a member — \"не забудь купить хлеб\" is a reminder, not a refusal.",
       "words": [

internal/lexicon/lexicon_test.go

@@ -36,6 +36,46 @@ func TestClosedSetsAreComplete(t *testing.T) {
 	if _, ok := Cardinal("бэкап"); ok {
 		t.Error("Cardinal must not answer for a word that is not a number")
 	}
+
+	// A spoken hour declines, and one to four decline further than the rest:
+	// "к двум часам" and "к трём" are hours, and only the dative says so (V-581).
+	for _, tc := range []struct {
+		word string
+		want int
+	}{
+		{"одному", 1}, {"двум", 2}, {"двумя", 2}, {"трём", 3}, {"трем", 3},
+		{"четырём", 4}, {"четырем", 4}, {"пяти", 5}, {"семи", 7},
+	} {
+		if got, ok := Cardinal(tc.word); !ok || got != tc.want {
+			t.Errorf("Cardinal(%q) = %d, %v; want %d, true", tc.word, got, ok, tc.want)
+		}
+	}
+}
+
+// TestWeekdaysAreOneList — the second copy of a closed class is the bug (V-581).
+// Weekdays lived in four files outside this one, so the list is handed out whole
+// and the English forms, which the Russian dictionary cannot lemmatise, are here.
+func TestWeekdaysAreOneList(t *testing.T) {
+	days := Weekdays()
+	if len(days) != 7 || days[0] != "воскресенье" || days[1] != "понедельник" {
+		t.Fatalf("Weekdays() = %v; want the seven, Sunday first", days)
+	}
+	for i, name := range days {
+		if Weekday(i) != name {
+			t.Errorf("Weekdays()[%d] = %q, but Weekday(%d) = %q", i, name, i, Weekday(i))
+		}
+	}
+	for _, tc := range []struct {
+		word string
+		want int
+	}{{"sunday", 0}, {"monday", 1}, {"mondays", 1}, {"Friday", 5}, {"saturdays", 6}} {
+		if got, ok := WeekdayEnglish(tc.word); !ok || got != tc.want {
+			t.Errorf("WeekdayEnglish(%q) = %d, %v; want %d, true", tc.word, got, ok, tc.want)
+		}
+	}
+	if _, ok := WeekdayEnglish("понедельник"); ok {
+		t.Error("WeekdayEnglish answered for a Russian word; that side is morph's")
+	}
 }
 
 // TestDayOffsetHasNoOrderingTrap — the defect a lookup removes. The callers this

internal/llm/remote.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"log"
 	"net/http"
+	"sync"
 	"sync/atomic"
 	"time"
 )
@@ -46,6 +47,7 @@ type Pair struct {
 	interval time.Duration
 	http     *http.Client
 	stop     chan struct{}
+	stopOnce sync.Once
 }
 
 // ErrRemoteUnavailable — the workstation model was required and is not
@@ -107,13 +109,11 @@ func (p *Pair) Start(ctx context.Context) {
 	}()
 }
 
-// Stop ends the prober. Idempotent.
+// Stop ends the prober. Idempotent, and safe from two goroutines at once. The
+// check-then-close it replaced let both callers see an open channel and the
+// second close panicked, which turned a shutdown race into a crash.
 func (p *Pair) Stop() {
-	select {
-	case <-p.stop:
-	default:
-		close(p.stop)
-	}
+	p.stopOnce.Do(func() { close(p.stop) })
 }
 
 // Available reports whether the workstation will take work right now. It reads
@@ -170,7 +170,9 @@ func (p *Pair) Complete(ctx context.Context, r Req) (string, error) {
 	}
 	why := "workstation down"
 	if p.Available() {
-		out, err := p.remote.Complete(ctx, r)
+		rctx, cancel := remoteBudget(ctx)
+		out, err := p.remote.Complete(rctx, r)
+		cancel()
 		if err == nil {
 			log.Print("llm: served by the workstation model")
 			return out, nil
@@ -184,6 +186,30 @@ func (p *Pair) Complete(ctx context.Context, r Req) (string, error) {
 	return p.floor.Complete(ctx, r)
 }
 
+// remoteBudget bounds the workstation attempt so the floor still has time to
+// answer. A turn carrying a deadline used to hand the whole of it to the
+// remote, so a workstation that accepted the connection and then hung ate the
+// budget and the fallback ran on an already-expired context: the floor
+// returned the deadline error and the turn broke on the workstation being
+// slow, which docs/offload.md says must never happen. Half is the split
+// because both halves have to be able to finish, and there is no reason to
+// prefer either one when the remote is the part that failed.
+//
+// A context with no deadline is left alone. The remote client's own timeout
+// (workstation.timeout, 90s by default) bounds it there, and shortening that
+// silently would change the configured budget.
+func remoteBudget(ctx context.Context) (context.Context, context.CancelFunc) {
+	dl, ok := ctx.Deadline()
+	if !ok {
+		return ctx, func() {}
+	}
+	left := time.Until(dl)
+	if left <= 0 {
+		return ctx, func() {}
+	}
+	return context.WithTimeout(ctx, left/2)
+}
+
 // CompleteRemote runs r on the workstation or refuses. It never falls back,
 // because for a world question the resident 1.7B does not answer worse, it
 // invents. Callers turn ErrRemoteUnavailable into a named gap.

internal/llm/remote_test.go

@@ -154,6 +154,48 @@ func TestRemoteErrorMidRequestFallsBack(t *testing.T) {
 	}
 }
 
+// A workstation that accepts the connection and then hangs must not spend the
+// whole turn budget. It used to: the remote got the caller's context unchanged,
+// so the fallback ran on an expired one and the floor returned the deadline
+// error instead of an answer. The turn broke on the workstation being slow,
+// which is the one outcome docs/offload.md rules out.
+func TestHangingRemoteLeavesTheFloorABudget(t *testing.T) {
+	var floorHits atomic.Int64
+	// released, not r.Context().Done(): httptest.Server.Close waits for the
+	// handler, and a handler that only watches the request context can outlive
+	// the test when the client hangs up without the server noticing.
+	released := make(chan struct{})
+	hang := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		select {
+		case <-released:
+		case <-r.Context().Done():
+		}
+	}))
+	defer hang.Close()
+	defer close(released)
+	floor := completionServer(t, "floor", &floorHits)
+	up := &atomic.Bool{}
+	up.Store(true)
+	health := healthServer(t, up)
+
+	p := NewPair(New(hang.URL, time.Minute), New(floor.URL, time.Minute), health.URL, time.Hour)
+	p.Start(context.Background())
+	defer p.Stop()
+	if !waitFor(t, p.Available) {
+		t.Fatal("prober never saw the remote come up")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 400*time.Millisecond)
+	defer cancel()
+	out, err := p.Complete(ctx, Req{User: "привет"})
+	if err != nil {
+		t.Fatalf("complete: %v", err)
+	}
+	if out != "floor" || floorHits.Load() != 1 {
+		t.Fatalf("out = %q, floor hits = %d", out, floorHits.Load())
+	}
+}
+
 // The naming half of the degradation rule. A world question must not be handed
 // to the resident model, because it answers by inventing.
 func TestCompleteRemoteNamesTheGap(t *testing.T) {

internal/mcp/client.go

@@ -257,7 +257,16 @@ func (c *Client) call(ctx context.Context, method string, params any, out any) e
 	if resp.Error != nil {
 		return fmt.Errorf("mcp: %s: %s: %w", c.name, method, resp.Error)
 	}
-	if out == nil || len(resp.Result) == 0 {
+	// A frame carrying our id and neither result nor error is not an answer.
+	// The HTTP transport already refuses one; the stdio transport does not, and
+	// without this check the refusal depended on which door the server was
+	// behind. Letting it through is the one failure that lies: tools/call
+	// returns an empty string and a nil error, so the act is recorded as done
+	// and the tool never ran.
+	if len(resp.Result) == 0 {
+		return fmt.Errorf("mcp: %s: %s: response carries neither result nor error", c.name, method)
+	}
+	if out == nil {
 		return nil
 	}
 	if err := json.Unmarshal(resp.Result, out); err != nil {

internal/mcp/manager.go

@@ -525,10 +525,16 @@ func (m *Manager) Resources(ctx context.Context) []Resource {
 
 // ReadResource reads one resource from one server.
 func (m *Manager) ReadResource(ctx context.Context, server, uri string) (string, error) {
-	cl, cfg, _, _, _ := m.lookup(server, "")
-	if cl == nil {
+	cl, cfg, _, configured, _ := m.lookup(server, "")
+	if !configured {
 		return "", fmt.Errorf("%w: %s", ErrNoServer, server)
 	}
+	// A configured server that is merely down is not an unknown server. Call
+	// already keeps the two apart; reporting ErrNoServer here tells a caller
+	// the resource can never exist, when the truth is "not right now".
+	if cl == nil {
+		return "", fmt.Errorf("%w: %s", ErrNotConnected, server)
+	}
 	cctx, cancel := context.WithTimeout(ctx, cfg.Timeout)
 	defer cancel()
 	return cl.ReadResource(cctx, uri)

internal/mcp/mcp_test.go

@@ -641,3 +641,59 @@ func TestReconnectBackoffGrows(t *testing.T) {
 		t.Fatalf("first retry = %v, want %v", c.backoff(), DefaultReconnectEvery)
 	}
 }
+
+// emptyFrameTransport answers the handshake normally and then replies to every
+// later call with a well-formed frame carrying our id and nothing else — no
+// result, no error. That is the answer a partially-implemented server gives,
+// and it is the one that lies: without a check it reads as success.
+type emptyFrameTransport struct{ handshaken bool }
+
+func (t *emptyFrameTransport) Call(ctx context.Context, req *rpcRequest) (*rpcResponse, error) {
+	id := req.ID
+	if !t.handshaken {
+		t.handshaken = true
+		raw, _ := json.Marshal(map[string]any{
+			"protocolVersion": ProtocolVersion,
+			"serverInfo":      map[string]any{"name": "empty", "version": "0"},
+		})
+		return &rpcResponse{JSONRPC: "2.0", ID: &id, Result: raw}, nil
+	}
+	return &rpcResponse{JSONRPC: "2.0", ID: &id}, nil
+}
+
+func (t *emptyFrameTransport) Notify(context.Context, string, any) error { return nil }
+func (t *emptyFrameTransport) Close() error                             { return nil }
+
+func TestResultlessResponseIsNotSuccess(t *testing.T) {
+	c := newClient("empty", &emptyFrameTransport{})
+	if err := c.Initialize(context.Background()); err != nil {
+		t.Fatalf("initialize: %v", err)
+	}
+	out, err := c.CallTool(context.Background(), "break_thing", map[string]any{"q": "x"})
+	if err == nil {
+		t.Fatalf("a frame with neither result nor error must not read as success (got %q)", out)
+	}
+	if out != "" {
+		t.Fatalf("out = %q", out)
+	}
+	if _, err := c.ListTools(context.Background()); err == nil {
+		t.Fatal("tools/list with no result must be an error, not an empty catalogue")
+	}
+}
+
+func TestReadResourceOnDownServerIsNotConnected(t *testing.T) {
+	// A url server with no poster factory: configured, validated, never dialed.
+	m, err := NewManager(nil, []ServerConfig{{
+		Name: "down", URL: "http://example.test/mcp", Enabled: true,
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	m.Connect(context.Background())
+	if _, err := m.ReadResource(context.Background(), "down", "note://one"); !errors.Is(err, ErrNotConnected) {
+		t.Fatalf("err = %v, want ErrNotConnected", err)
+	}
+	if _, err := m.ReadResource(context.Background(), "nosuch", "note://one"); !errors.Is(err, ErrNoServer) {
+		t.Fatalf("err = %v, want ErrNoServer", err)
+	}
+}

internal/media/store.go

@@ -265,6 +265,16 @@ func (s *Store) Put(kind Kind, mime, source string, data []byte) (Blob, error) {
 		}
 	}
 
+	// Every return past the reservation has to give it back, so the defer owns
+	// that rather than each error path: a path that forgot over-counted the
+	// store until the next Open re-walked the directory.
+	stored := false
+	defer func() {
+		if fresh && !stored {
+			s.release(b.Size)
+		}
+	}()
+
 	// The sidecar goes first. Written second, a full disk or a crash between
 	// the two left the bytes on disk with no sidecar, and List only sees
 	// sidecars, so Prune could never collect them: Put returned an error and an
@@ -274,11 +284,9 @@ func (s *Store) Put(kind Kind, mime, source string, data []byte) (Blob, error) {
 	}
 	if err := writeFile(blobPath, data); err != nil {
 		_ = os.Remove(metaPath)
-		if fresh {
-			s.release(b.Size)
-		}
 		return Blob{}, err
 	}
+	stored = true
 	return b, nil
 }
 
@@ -331,12 +339,22 @@ func (s *Store) PutFile(kind Kind, mime, source, src string) (Blob, error) {
 			return Blob{}, err
 		}
 	}
+	// Same reasoning as Put: the reservation is released by one defer, not by
+	// whichever error path remembered to.
+	stored := false
+	defer func() {
+		if fresh && !stored {
+			s.release(b.Size)
+		}
+	}()
+
 	if err := writeMeta(metaPath, b); err != nil {
 		return Blob{}, err
 	}
 	if !fresh {
 		// Same bytes already here. Drop the spool copy.
 		_ = os.Remove(src)
+		stored = true
 		return b, nil
 	}
 	if err := os.Chmod(src, filePerm); err != nil {
@@ -344,9 +362,9 @@ func (s *Store) PutFile(kind Kind, mime, source, src string) (Blob, error) {
 	}
 	if err := os.Rename(src, blobPath); err != nil {
 		_ = os.Remove(metaPath)
-		s.release(b.Size)
 		return Blob{}, fmt.Errorf("media: move spool: %w", err)
 	}
+	stored = true
 	return b, nil
 }
 

internal/media/store_test.go

@@ -287,6 +287,73 @@ func TestPutLeavesNothingWhenTheBytesCannotBeWritten(t *testing.T) {
 	}
 }
 
+// An over-counted store answers ErrStoreFull while the disk has room, and only
+// the next Open corrects it. So every failed write has to give its reservation
+// back, not just the one that remembered to.
+func TestPutReleasesTheBudgetWhenTheSidecarCannotBeWritten(t *testing.T) {
+	s := testStore(t)
+	data := []byte("no sidecar for this")
+	blockSidecar(t, s, KindImage, data)
+	if _, err := s.Put(KindImage, "image/png", "web:upload", data); err == nil {
+		t.Fatal("put must fail")
+	}
+	if s.Total() != 0 {
+		t.Errorf("total = %d, want the failed put not counted", s.Total())
+	}
+}
+
+func TestPutFileReleasesTheBudgetWhenTheSidecarCannotBeWritten(t *testing.T) {
+	s := testStore(t)
+	data := []byte("no sidecar for this either")
+	blockSidecar(t, s, KindAudio, data)
+	src := filepath.Join(t.TempDir(), "capture.wav")
+	if err := os.WriteFile(src, data, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := s.PutFile(KindAudio, "audio/wav", "meeting", src); err == nil {
+		t.Fatal("put file must fail")
+	}
+	if s.Total() != 0 {
+		t.Errorf("total = %d, want the failed put not counted", s.Total())
+	}
+}
+
+// The chmod arm is PutFile's alone: Put never touches a spool file.
+func TestPutFileReleasesTheBudgetWhenTheSpoolCannotBeChmodded(t *testing.T) {
+	if os.Geteuid() == 0 {
+		t.Skip("root can chmod a file it does not own")
+	}
+	// A symlink to a file owned by somebody else. Stat and the hash follow it
+	// and succeed; chmod follows it too and is refused.
+	src := filepath.Join(t.TempDir(), "capture.wav")
+	if err := os.Symlink("/etc/hosts", src); err != nil {
+		t.Fatal(err)
+	}
+	info, err := os.Stat(src)
+	if err != nil || info.Size() == 0 {
+		t.Skip("no readable /etc/hosts to point at")
+	}
+	s := testStore(t)
+	if _, err := s.PutFile(KindAudio, "audio/wav", "meeting", src); err == nil {
+		t.Fatal("put file must fail")
+	}
+	if s.Total() != 0 {
+		t.Errorf("total = %d, want the failed put not counted", s.Total())
+	}
+}
+
+// blockSidecar puts a directory where the sidecar for data has to go, so
+// writeMeta fails while the blob path is still free.
+func blockSidecar(t *testing.T, s *Store, kind Kind, data []byte) {
+	t.Helper()
+	sum := sha256.Sum256(data)
+	id := hex.EncodeToString(sum[:])
+	bucket := filepath.Join(s.dir, string(kind), id[:2])
+	if err := os.MkdirAll(filepath.Join(bucket, id+".json"), 0o700); err != nil {
+		t.Fatal(err)
+	}
+}
+
 // The per-blob cap bounds one call and nothing bounded their sum. 64 MiB per
 // call times unlimited calls inside a seven-day window fills the disk mavend's
 // database lives on.

internal/morning/morning.go

@@ -104,14 +104,22 @@ func OptionalOnly(missing []Item) []Item {
 }
 
 // Validate reports the first structural problem with a routine set: missing
-// name/items, an unparseable HH:MM, an inverted window, a duplicate item key
-// within a routine, or an out-of-range weekday. Called at config load so a
-// typo surfaces at startup, not as a silently-broken checklist at runtime.
+// name/items, an unparseable HH:MM, an inverted window, a duplicate routine or
+// item key, or an out-of-range weekday. Called at config load so a typo
+// surfaces at startup, not as a silently-broken checklist at runtime.
+//
+// Routine names must be unique because Due keys its once-a-day map by name. Two
+// routines sharing one would take turns suppressing each other's nudge.
 func Validate(routines []Routine) error {
+	names := make(map[string]bool, len(routines))
 	for _, r := range routines {
 		if r.Name == "" {
 			return fmt.Errorf("morning: name is required")
 		}
+		if names[r.Name] {
+			return fmt.Errorf("morning routine %q: duplicate name", r.Name)
+		}
+		names[r.Name] = true
 		if len(r.Items) == 0 {
 			return fmt.Errorf("morning routine %q: at least one item is required", r.Name)
 		}
@@ -177,6 +185,17 @@ func Evaluate(r Routine, facts map[string]store.Fact, now time.Time) Status {
 	return st
 }
 
+// missing lists the items of r with no evidence in [start, now].
+func missing(r Routine, facts map[string]store.Fact, start, now time.Time) []Item {
+	var out []Item
+	for _, it := range r.Items {
+		if !evidenced(it, facts, start, now) {
+			out = append(out, it)
+		}
+	}
+	return out
+}
+
 // Outstanding reports the items of a routine that today has no evidence for,
 // whether or not the window is still open. Evaluate answers "what is missing
 // right now" and goes silent the moment the window closes; the day plan asks a
@@ -191,13 +210,7 @@ func Outstanding(r Routine, facts map[string]store.Fact, now time.Time) []Item {
 	if !ok || now.Before(start) {
 		return nil
 	}
-	var missing []Item
-	for _, it := range r.Items {
-		if !evidenced(it, facts, start, now) {
-			missing = append(missing, it)
-		}
-	}
-	return missing
+	return missing(r, facts, start, now)
 }
 
 // Due returns the routines that have reached their nudge time today with at
@@ -222,24 +235,19 @@ func Due(routines []Routine, facts map[string]store.Fact, last map[string]time.T
 		if !ok || now.Before(nudgeAt) {
 			continue
 		}
-		var missing []Item
-		for _, it := range r.Items {
-			if !evidenced(it, facts, start, now) {
-				missing = append(missing, it)
-			}
-		}
+		skipped := missing(r, facts, start, now)
 		// A day where only the optional items were skipped is a fine day, and
 		// nagging about it is what teaches him to stop listening (Vikunja
 		// #473). The optional ones still travel in Missing so the message can
 		// mention them when it is being sent anyway.
-		if len(Required(missing)) == 0 {
+		if len(Required(skipped)) == 0 {
 			continue
 		}
 		if prev, seen := last[r.Name]; seen && sameDay(prev, now) {
 			continue
 		}
 		last[r.Name] = now
-		out = append(out, Candidate{Routine: r, Missing: missing})
+		out = append(out, Candidate{Routine: r, Missing: skipped})
 	}
 	return out
 }
@@ -284,13 +292,21 @@ func sameDay(a, b time.Time) bool {
 	return ay == by && am == bm && ad == bd
 }
 
+// parseHHMM reads a five-character "HH:MM". Every digit is checked as a digit:
+// arithmetic alone lets a stray character cancel out, so "2 :00" used to load
+// as 04:00 and Validate passed the typo it exists to catch.
 func parseHHMM(s string) (hour, min int, ok bool) {
 	if len(s) != 5 || s[2] != ':' {
 		return 0, 0, false
 	}
+	for _, i := range [4]int{0, 1, 3, 4} {
+		if s[i] < '0' || s[i] > '9' {
+			return 0, 0, false
+		}
+	}
 	h := int(s[0]-'0')*10 + int(s[1]-'0')
 	m := int(s[3]-'0')*10 + int(s[4]-'0')
-	if h < 0 || h > 23 || m < 0 || m > 59 {
+	if h > 23 || m > 59 {
 		return 0, 0, false
 	}
 	return h, m, true

internal/morning/morning_test.go

@@ -56,6 +56,19 @@ func TestValidate(t *testing.T) {
 	if err := Validate([]Routine{bad}); err == nil {
 		t.Fatal("expected error for duplicate item key")
 	}
+
+	// Due keys its once-a-day map by name, so two routines sharing one would
+	// suppress each other's nudge instead of both firing.
+	if err := Validate([]Routine{r, r}); err == nil {
+		t.Fatal("expected error for duplicate routine name")
+	}
+
+	// Arithmetic alone let a stray character cancel out: "2 :00" read as 04:00.
+	bad = r
+	bad.WindowStart = "2 :00"
+	if err := Validate([]Routine{bad}); err == nil {
+		t.Fatal("expected error for a non-digit in window_start")
+	}
 }
 
 func TestEvaluateInactiveOutsideWindow(t *testing.T) {

internal/morning/plan.go

@@ -52,10 +52,13 @@ type PlanEntry struct {
 // Plan — the ordered day. Date is the calendar day it describes. Rest marks a
 // plan trimmed by After, which changes what an empty one means: a day with
 // nothing on it and a day whose last item has passed are different answers.
+// More counts what Next dropped off the end, so the sentence can say that more
+// remains instead of implying the day ends after the third line.
 type Plan struct {
 	Date  time.Time
 	Items []PlanEntry
 	Rest  bool
+	More  int
 }
 
 // BuildPlan orders everything known about the day Now falls on: calendar
@@ -113,12 +116,12 @@ func BuildPlan(routines []Routine, facts map[string]store.Fact, events, reminder
 func checklistEntries(routines []Routine, facts map[string]store.Fact, now time.Time) []PlanEntry {
 	var out []PlanEntry
 	for _, r := range routines {
-		missing := Outstanding(r, facts, now)
-		if len(missing) == 0 {
+		left := Outstanding(r, facts, now)
+		if len(left) == 0 {
 			continue
 		}
-		labels := make([]string, 0, len(missing))
-		for _, it := range missing {
+		labels := make([]string, 0, len(left))
+		for _, it := range left {
 			label := it.Label
 			if label == "" {
 				label = it.Key
@@ -142,13 +145,24 @@ func checklistEntries(routines []Routine, facts map[string]store.Fact, now time.
 	return out
 }
 
+// NextSpoken — how many entries "что дальше?" reads aloud. Three, for the same
+// reason the feed reads three headlines: the answer is spoken once and cannot be
+// scrolled back, and a list longer than a breath is not an answer, it is a
+// recital. Asked at 04:45 on a day with 43 entries, the trim below removes
+// nothing — everything is still ahead — so the cap is what makes "дальше" mean
+// next rather than today (V-618).
+const NextSpoken = 3
+
 // After returns the part of the plan that has not happened yet — the answer to
 // "что дальше?" as opposed to "какие планы на сегодня?". The Date is kept, so an
 // empty result still knows which day it is empty for.
+//
+// Strictly after: an entry at exactly now is the thing happening, not the thing
+// next.
 func (p Plan) After(now time.Time) Plan {
 	out := Plan{Date: p.Date, Rest: true}
 	for _, it := range p.Items {
-		if it.At.Before(now) {
+		if !it.At.After(now) {
 			continue
 		}
 		out.Items = append(out.Items, it)
@@ -156,10 +170,30 @@ func (p Plan) After(now time.Time) Plan {
 	return out
 }
 
+// Next is After with a spoken cap — what "что дальше?" actually answers with.
+// The overflow is counted rather than dropped, because "дальше: 10:00 …" with
+// forty entries hidden behind it is a false picture of the day.
+func (p Plan) Next(now time.Time, n int) Plan {
+	out := p.After(now)
+	if n > 0 && len(out.Items) > n {
+		out.More = len(out.Items) - n
+		out.Items = out.Items[:n]
+	}
+	return out
+}
+
 // FormatRU renders the plan as maven says it. Feminine self-reference,
 // informal address, no pet names — and no exhortation: she reads the day back,
 // she does not tell him to get on with it.
+//
+// Every hour is read in the plan's own zone — Date's, which BuildPlan sets from
+// the asking clock. Printed raw, an hour read whatever zone its instant arrived
+// in: an event or a reminder comes off the store as UTC, while a checklist line
+// is built local, so one spoken sentence named two zones. This is the voice
+// path, so that is what the owner heard (V-614); the same defect on the two web
+// pages was V-612.
 func (p Plan) FormatRU() string {
+	zone := p.Date.Location()
 	if len(p.Items) == 0 {
 		// "что дальше?" after the last item of the day. The day was not empty,
 		// it is over, and saying it was empty is a false statement about a day
@@ -171,14 +205,28 @@ func (p Plan) FormatRU() string {
 	}
 	parts := make([]string, len(p.Items))
 	for i, it := range p.Items {
-		line := fmt.Sprintf("%s — %s", it.At.Format("15:04"), it.Text)
+		line := fmt.Sprintf("%s — %s", it.At.In(zone).Format("15:04"), it.Text)
 		if it.Uncertain {
 			line = say.S(say.PlanUncertain, map[string]string{"line": line})
 		}
 		parts[i] = line
 	}
+	items := strings.Join(parts, "; ")
+	// The rest of the day is a different sentence, not a shorter day plan. It
+	// carries no date — he asked what is next, and he knows which day he is in —
+	// and it says out loud when there is more behind the cap.
+	if p.Rest {
+		if p.More > 0 {
+			return say.S(say.PlanNextMore, map[string]string{
+				"items": items,
+				"n":     fmt.Sprint(p.More),
+				"word":  say.CountWord(p.More, "дело", "дела", "дел"),
+			})
+		}
+		return say.S(say.PlanNext, map[string]string{"items": items})
+	}
 	return say.S(say.PlanDay, map[string]string{
 		"date":  p.Date.Format("02.01.2006"),
-		"items": strings.Join(parts, "; "),
+		"items": items,
 	})
 }

internal/morning/plan_test.go

@@ -1,6 +1,7 @@
 package morning
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 	"time"
@@ -151,6 +152,37 @@ func TestPlanFormatRU(t *testing.T) {
 	}
 }
 
+// One spoken sentence names one clock. An event and a reminder come off the
+// store as UTC and a checklist line is built in the asking clock's zone, so the
+// raw Format printed the two halves of one sentence in two zones (V-614). The
+// zones here are three hours off whatever this machine runs in, so the test
+// tells "read in his clock" apart from "read in the zone the instant arrived
+// in" under TZ=UTC as well.
+func TestPlanFormatRUReadsEveryHourInThePlansZone(t *testing.T) {
+	_, off := time.Now().Zone()
+	away := time.FixedZone("away", off+3*60*60)
+
+	stored := time.Date(2026, 8, 3, 14, 0, 0, 0, time.UTC)
+	p := Plan{
+		Date: time.Date(2026, 8, 3, 0, 0, 0, 0, away),
+		Items: []PlanEntry{
+			{At: stored, Text: "Планёрка", Kind: PlanEvent},
+			{At: planAt(time.Date(2026, 8, 3, 0, 0, 0, 0, away), 10, 30),
+				Text: "утро — осталось: витамины", Kind: PlanChecklist},
+		},
+	}
+	got := p.FormatRU()
+	if want := stored.In(away).Format("15:04"); !strings.Contains(got, want) {
+		t.Errorf("the event is not read in the plan's zone (%s): %q", want, got)
+	}
+	if bad := stored.Format("15:04"); strings.Contains(got, bad) {
+		t.Errorf("the event is read in the zone it was stored in (%s): %q", bad, got)
+	}
+	if !strings.Contains(got, "10:30") {
+		t.Errorf("the checklist line moved zone: %q", got)
+	}
+}
+
 func TestPlanAfter(t *testing.T) {
 	p, now := planFixture(t)
 	rest := p.After(planAt(now, 11, 0))
@@ -171,6 +203,84 @@ func TestPlanAfter(t *testing.T) {
 	}
 }
 
+// nextFixture — a day with more entries than the cap, built in a zone three
+// hours off UTC so the test fails under TZ=UTC as well as under the machine's
+// own zone if the plan ever renders in the wrong one.
+func nextFixture(t *testing.T) (Plan, time.Time) {
+	t.Helper()
+	zone := time.FixedZone("MSK", 3*60*60)
+	now := time.Date(2026, 8, 3, 4, 45, 0, 0, zone)
+	var events []PlanEntry
+	for _, hhmm := range [][2]int{{5, 45}, {10, 0}, {14, 0}, {18, 30}, {21, 12}} {
+		events = append(events, PlanEntry{
+			At:   planAt(now, hhmm[0], hhmm[1]),
+			Text: fmt.Sprintf("событие %02d:%02d", hhmm[0], hhmm[1]),
+			Kind: PlanEvent,
+		})
+	}
+	return BuildPlan(nil, nil, events, nil, now), now
+}
+
+// "что дальше?" asked at 04:45 on a day with everything still ahead. The trim
+// removes nothing there, so before V-618 she read the whole day out loud.
+func TestPlanNextCapsWhatIsSpoken(t *testing.T) {
+	p, now := nextFixture(t)
+	got := p.Next(now, NextSpoken).FormatRU()
+	want := "дальше: 05:45 — событие 05:45; 10:00 — событие 10:00; " +
+		"14:00 — событие 14:00. и ещё 2 дела до конца дня."
+	if got != want {
+		t.Errorf("got  %q\nwant %q", got, want)
+	}
+	// No date: he asked what is next, not what day it is.
+	if strings.Contains(got, "03.08.2026") {
+		t.Errorf("rest-of-day answer stamps a date: %q", got)
+	}
+}
+
+// Nothing hidden means nothing claimed hidden.
+func TestPlanNextWithinTheCapSaysNoMore(t *testing.T) {
+	p, now := nextFixture(t)
+	got := p.Next(planAt(now, 15, 0), NextSpoken).FormatRU()
+	want := "дальше: 18:30 — событие 18:30; 21:12 — событие 21:12"
+	if got != want {
+		t.Errorf("got  %q\nwant %q", got, want)
+	}
+}
+
+// The whole-day question is not narrowed: same plan, no trim, no cap.
+func TestPlanWholeDayIsNotNarrowed(t *testing.T) {
+	p, _ := nextFixture(t)
+	got := p.FormatRU()
+	if n := strings.Count(got, "событие"); n != 5 {
+		t.Errorf("whole day read %d of 5 entries: %q", n, got)
+	}
+	if !strings.HasPrefix(got, "план на 03.08.2026: ") {
+		t.Errorf("whole day lost its date: %q", got)
+	}
+}
+
+// The empty case says the day is over rather than returning an empty sentence,
+// and it does not say the day was empty.
+func TestPlanNextEmptySaysSo(t *testing.T) {
+	p, now := nextFixture(t)
+	got := p.Next(planAt(now, 23, 30), NextSpoken).FormatRU()
+	if got != "на сегодня больше ничего не запланировано." {
+		t.Errorf("got %q", got)
+	}
+}
+
+// An entry at exactly the asking minute is what is happening, not what is next.
+func TestPlanNextIsStrictlyAfterNow(t *testing.T) {
+	p, now := nextFixture(t)
+	rest := p.Next(planAt(now, 5, 45), NextSpoken)
+	if len(rest.Items) != 3 || rest.Items[0].At.Hour() != 10 {
+		t.Errorf("got %+v", rest.Items)
+	}
+	if rest.More != 1 {
+		t.Errorf("More = %d, want 1", rest.More)
+	}
+}
+
 // The plan says what today still has not got done, and a closed window does not
 // make a skipped routine untrue. Evaluate reports Active only inside the
 // window, so keying the checklist line off it meant the one thing the plan can

internal/netaddr/netaddr.go

@@ -31,6 +31,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"time"
 
 	"golang.org/x/sys/unix"
@@ -154,31 +155,78 @@ func clientHandshake(c net.Conn, token string) error {
 // Listener wraps a net.Listener so Accept performs the token check for a tcp
 // seam. A connection that fails the check is closed and never surfaces, so
 // the protocol above this layer only ever sees authorized peers.
+//
+// A unix seam takes none of that machinery: Accept delegates straight to the
+// wrapped listener, which is what it did before the token existed.
 type Listener struct {
 	net.Listener
 	addr Addr
+
+	start     sync.Once
+	closeOnce sync.Once
+	conns     chan net.Conn
+	errc      chan error // buffered 1, re-armed so every Accept sees the error
+	done      chan struct{}
 }
 
 // Accept returns the next authorized connection. Unauthorized peers are
 // dropped and Accept keeps waiting: a bad token is a rejected stranger, not a
 // reason to stop serving.
+//
+// Each tcp handshake runs in its own goroutine rather than inline here. A peer
+// that connects and then says nothing holds its greeting open for
+// handshakeTimeout, and inline that peer stalls every other connection for
+// five seconds — one silent stranger was enough to freeze the seam.
 func (l *Listener) Accept() (net.Conn, error) {
+	if l.addr.IsUnix() {
+		return l.Listener.Accept()
+	}
+	l.start.Do(func() { go l.acceptLoop() })
+	select {
+	case c := <-l.conns:
+		return c, nil
+	case err := <-l.errc:
+		l.errc <- err
+		return nil, err
+	}
+}
+
+// acceptLoop takes connections off the wrapped listener and greets each one
+// concurrently. It ends on the first listener error, which every later Accept
+// then reports.
+func (l *Listener) acceptLoop() {
 	for {
 		c, err := l.Listener.Accept()
 		if err != nil {
-			return nil, err
+			select {
+			case l.errc <- err:
+			case <-l.done:
+			}
+			return
 		}
-		if l.addr.IsUnix() {
-			return c, nil
-		}
-		if err := serverHandshake(c, l.addr.Token); err != nil {
-			_ = c.Close()
-			continue
-		}
-		return c, nil
+		go l.greet(c)
 	}
 }
 
+func (l *Listener) greet(c net.Conn) {
+	if err := serverHandshake(c, l.addr.Token); err != nil {
+		_ = c.Close()
+		return
+	}
+	select {
+	case l.conns <- c:
+	case <-l.done:
+		_ = c.Close()
+	}
+}
+
+// Close stops the listener and releases any connection still waiting to be
+// handed to Accept.
+func (l *Listener) Close() error {
+	l.closeOnce.Do(func() { close(l.done) })
+	return l.Listener.Close()
+}
+
 // Addr reports the parsed seam address this listener was built from.
 func (l *Listener) SeamAddr() Addr { return l.addr }
 
@@ -236,7 +284,7 @@ func Listen(a Addr) (*Listener, error) {
 		if err != nil {
 			return nil, err
 		}
-		return &Listener{Listener: ln, addr: a}, nil
+		return wrap(ln, a), nil
 	}
 	if a.Token == "" {
 		return nil, fmt.Errorf("netaddr: listen %s: tcp seam requires a token", a)
@@ -245,7 +293,17 @@ func Listen(a Addr) (*Listener, error) {
 	if err != nil {
 		return nil, fmt.Errorf("netaddr: listen %s: %w", a, err)
 	}
-	return &Listener{Listener: ln, addr: a}, nil
+	return wrap(ln, a), nil
+}
+
+func wrap(ln net.Listener, a Addr) *Listener {
+	return &Listener{
+		Listener: ln,
+		addr:     a,
+		conns:    make(chan net.Conn),
+		errc:     make(chan error, 1),
+		done:     make(chan struct{}),
+	}
 }
 
 func listenUnix(path string) (net.Listener, error) {

internal/netaddr/netaddr_test.go

@@ -5,6 +5,7 @@ import (
 	"net"
 	"path/filepath"
 	"testing"
+	"time"
 )
 
 // A scheme-less address must stay unix. Every deploy in the tree writes a bare
@@ -140,6 +141,41 @@ func TestTCPUngreetedPeerDoesNotKillTheListener(t *testing.T) {
 	}
 }
 
+// A peer that connects and never speaks must not hold the seam. The greeting
+// it owes is bounded by handshakeTimeout, so serving it on the accept path
+// costs every later connection those five seconds.
+func TestTCPSilentPeerDoesNotStallTheSeam(t *testing.T) {
+	ln, addr := listenLoopback(t, "s3cret")
+	defer ln.Close()
+	go echoOnce(ln)
+
+	mute, err := net.Dial("tcp", addr.Address)
+	if err != nil {
+		t.Fatalf("mute dial: %v", err)
+	}
+	defer mute.Close()
+
+	done := make(chan string, 1)
+	go func() {
+		c, err := Dial(addr)
+		if err != nil {
+			done <- "dial: " + err.Error()
+			return
+		}
+		defer c.Close()
+		done <- roundTrip(t, c, "still here")
+	}()
+
+	select {
+	case got := <-done:
+		if got != "still here" {
+			t.Fatalf("got %q", got)
+		}
+	case <-time.After(handshakeTimeout / 2):
+		t.Fatal("a silent peer stalled the listener")
+	}
+}
+
 // A tcp seam with no token is a misconfiguration, and it must fail at bind
 // rather than serve the owner's turns to anyone who connects.
 func TestTCPListenRequiresToken(t *testing.T) {

internal/netscan/netscan.go

@@ -33,6 +33,7 @@ import (
 	"net/netip"
 	"os"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -323,7 +324,7 @@ scan:
 			go func(addr string, port int) {
 				defer wg.Done()
 				defer func() { <-sem }()
-				if s.dial(ctx, net.JoinHostPort(addr, itoa(port)), s.cfg.Timeout) {
+				if s.dial(ctx, net.JoinHostPort(addr, strconv.Itoa(port)), s.cfg.Timeout) {
 					results <- result{addr: addr, ports: []int{port}}
 				}
 			}(addr, port)
@@ -371,8 +372,6 @@ scan:
 	return Result{Hosts: out, Truncated: truncated}, nil
 }
 
-func itoa(n int) string { return fmt.Sprintf("%d", n) }
-
 func dialTCP(ctx context.Context, addr string, timeout time.Duration) bool {
 	d := net.Dialer{Timeout: timeout}
 	ctx, cancel := context.WithTimeout(ctx, timeout)

internal/persona/persona.go

@@ -17,6 +17,8 @@ import (
 	"fmt"
 	"strings"
 	"time"
+
+	"github.com/kami/maven/internal/lexicon"
 )
 
 // Facts — the optional, deployment-specific half of the block. All fields may
@@ -34,12 +36,10 @@ type Facts struct {
 	Tools    bool // at least one shell act is on the allowlist
 }
 
-var ruWeekdays = [...]string{"воскресенье", "понедельник", "вторник", "среда", "четверг", "пятница", "суббота"}
-
-var ruMonths = [...]string{
-	"января", "февраля", "марта", "апреля", "мая", "июня",
-	"июля", "августа", "сентября", "октября", "ноября", "декабря",
-}
+// The weekday and month names are closed classes and live in internal/lexicon,
+// which indexes weekdays from Sunday the way time.Weekday does and months from
+// one. This file used to carry its own copies, making four copies of the twelve
+// months in the tree after cmd/mavend/ruwords.go gave up its own (Vikunja #525).
 
 // Block renders the context block for one turn. Russian even in front of the
 // English prompts: the rules it states are Russian grammar (ты/тебя, feminine
@@ -61,7 +61,7 @@ func (f Facts) Block(now time.Time) string {
 	}
 
 	b.WriteString(fmt.Sprintf("Сейчас: %s, %d %s %d, %02d:%02d (местное время).\n",
-		ruWeekdays[int(now.Weekday())], now.Day(), ruMonths[int(now.Month())-1], now.Year(),
+		lexicon.Weekday(int(now.Weekday())), now.Day(), lexicon.MonthGenitive(int(now.Month())), now.Year(),
 		now.Hour(), now.Minute()))
 
 	b.WriteString("Умеешь: " + strings.Join(f.can(), "; ") +

internal/phraser/ack_ru_v1.json

@@ -5,7 +5,8 @@
     "What she says after storing something he said, and what she says when storing it failed. Edit the wording here, no Go changes needed.",
     "Rules: she is feminine about herself, he is a man addressed as ты. Never вы/вас/ваш, never он/его about him. No pet names.",
     "He hears these many times a day, so most entries carry variants: identical wording is what makes a confirmation stop registering as one.",
-    "Placeholders: {key} {value} the fact he stated, {fn} the action, {text} the task title. His data is interpolated Go-side — the file holds the frame, never his words.",
+    "Placeholders: {key} {value} the fact he stated, {fn} the action, {text} the task title or, in ack_fact_echo, his own sentence. His data is interpolated Go-side — the file holds the frame, never his words.",
+    "ack_fact_echo is the one entry with a single variant, deliberately: what varies in it is his own sentence, which is different every time, and the frame around it is what the simulator scenarios read back.",
     "An acknowledgement confirms and stops. It does not ask a follow-up question and it does not editorialise about what he stored."
   ],
   "entries": {
@@ -18,6 +19,10 @@
     "ack_fact_kv": {
       "variants": ["отметила: {key} = {value}", "записала: {key} — {value}", "запомнила: {key} — {value}"]
     },
+    "ack_fact_echo": {
+      "fixed": true,
+      "variants": ["записала: {text}"]
+    },
     "ack_note": {
       "variants": ["сохранила заметку.", "заметка сохранена.", "записала в заметки."]
     },

internal/phraser/acks.go

@@ -15,6 +15,7 @@ import (
 	_ "embed"
 	"log"
 	"math/rand"
+	"strings"
 	"sync"
 
 	"github.com/kami/maven/internal/say"
@@ -33,6 +34,7 @@ const (
 	AckFact          = "ack_fact"
 	AckFactKey       = "ack_fact_key"
 	AckFactValue     = "ack_fact_kv"
+	AckFactEcho      = "ack_fact_echo"
 	AckNote          = "ack_note"
 	AckReminder      = "ack_reminder"
 	AckAct           = "ack_act"
@@ -58,7 +60,7 @@ const (
 
 // ackKeys — every key the code requires the file to define.
 var ackKeys = []string{
-	AckFact, AckFactKey, AckFactValue, AckNote, AckReminder, AckAct,
+	AckFact, AckFactKey, AckFactValue, AckFactEcho, AckNote, AckReminder, AckAct,
 	AckTask, AckTaskUrgent, AckTaskDuplicate, AckNudge, AckSnooze, AckGeneric,
 	AckQuietOn, AckQuietOff,
 	FailFact, FailFactUnparsed, FailNote, FailReminder, FailReminderTime,
@@ -71,6 +73,7 @@ var ackFloor = map[string]string{
 	AckFact:          "записала факт.",
 	AckFactKey:       "отметила: {key}",
 	AckFactValue:     "отметила: {key} = {value}",
+	AckFactEcho:      "записала: {text}",
 	AckNote:          "сохранила заметку.",
 	AckReminder:      "напомню.",
 	AckAct:           "ок, записала действие: {fn}",
@@ -109,6 +112,7 @@ func LoadAcks(src rand.Source) (*Acks, error) {
 	// captured, which reads as a successful save of nothing.
 	for _, req := range []struct{ key, ph string }{
 		{AckFactKey, "{key}"}, {AckFactValue, "{key}"}, {AckFactValue, "{value}"},
+		{AckFactEcho, "{text}"},
 		{AckAct, "{fn}"}, {AckTask, "{text}"}, {AckTaskUrgent, "{text}"},
 	} {
 		if err := d.RequirePlaceholder(req.key, req.ph); err != nil {
@@ -157,6 +161,26 @@ func DefaultAcks() *Acks {
 // Ack — one acknowledgement line, the way every caller says it.
 func Ack(key string, vars map[string]string) string { return DefaultAcks().Say(key, vars) }
 
+// FactAck — the confirmation for a captured fact, in the words he used (V-592).
+//
+// It is a deck line with his sentence dropped into it, and there is no
+// generation anywhere on this path. Asking a 1.7B to say his sentence back
+// produced "Проверила, что ты выпел стакан воды" for "я выпил воды": a non-word
+// for the verb, a glass he never mentioned — lifted straight out of the example
+// in ReplySystemPrompt — and a claim to have checked something. The fact store
+// held key=water value="drank" throughout, so nothing was mis-captured and
+// everything after the capture was invented.
+//
+// An empty utterance falls back to the contentless line rather than confirming
+// a capture of nothing.
+func FactAck(utterance string) string {
+	utterance = strings.TrimSpace(utterance)
+	if utterance == "" {
+		return Ack(AckFact, nil)
+	}
+	return Ack(AckFactEcho, map[string]string{"text": utterance})
+}
+
 // IsAck reports whether text is a line key could have produced. For the daemon
 // tests, which can no longer compare against one literal.
 func IsAck(key string, vars map[string]string, text string) bool {

internal/phraser/eval/checks.go

@@ -126,6 +126,17 @@ func checkLength(body string) Result {
 // correct, "я напомнил" is not. Both directions matter, which is why this is a
 // windowed scan around "я" and not a bare search for masculine endings.
 
+// minInflectedRunes — the shortest a word can be and still carry one of the
+// verb/adjective endings this file matches (masculine -л, feminine -ла, …).
+// Below this length a suffix match would be coincidence, not grammar.
+const minInflectedRunes = 3
+
+// selfRefWindow — how many words past a self-reference marker ("я"/"ты", …)
+// still count as belonging to that reference before the sentence has moved
+// on. Same window on both the forward scan after "я" and the backward scans
+// in governedByYou and hersNotHis.
+const selfRefWindow = 3
+
 var wordRE = regexp.MustCompile(`[\p{Cyrillic}]+|[,.;:!?…—-]`)
 
 // secondPerson — pronouns that end the self-reference window. Everything after
@@ -154,7 +165,7 @@ var masculinePredicative = map[string]bool{
 // ends in -л AND is a form of a verb (Vikunja #526). Every noun the list held is
 // correctly not a verb, and so are the ones it had not got round to.
 func masculinePast(w string) bool {
-	if len([]rune(w)) < 3 {
+	if len([]rune(w)) < minInflectedRunes {
 		return false
 	}
 	if !strings.HasSuffix(w, "л") && !strings.HasSuffix(w, "лся") {
@@ -172,7 +183,7 @@ func checkFeminine(body string) Result {
 		// Scan the next few words. Stop at punctuation or at a second-person
 		// pronoun: past that point the sentence is about him and masculine is
 		// correct.
-		for j := i + 1; j < len(words) && j <= i+3; j++ {
+		for j := i + 1; j < len(words) && j <= i+selfRefWindow; j++ {
 			nw := words[j]
 			if len(nw) == 1 && !unicode.Is(unicode.Cyrillic, []rune(nw)[0]) {
 				break
@@ -259,7 +270,7 @@ var notFeminineVerb = map[string]bool{
 // femininePast reports whether a word looks like a feminine past-tense verb:
 // "отдыхала", "поела", "выспалась".
 func femininePast(w string) bool {
-	if len([]rune(w)) < 3 || notFeminineVerb[w] {
+	if len([]rune(w)) < minInflectedRunes || notFeminineVerb[w] {
 		return false
 	}
 	return strings.HasSuffix(w, "ла") || strings.HasSuffix(w, "лась")
@@ -268,7 +279,7 @@ func femininePast(w string) bool {
 // looksFeminineNoun — a crude guard against "зарядка была": a word right before
 // the verb that ends in "а"/"я" and is not itself a verb is probably the subject.
 func looksFeminineNoun(w string) bool {
-	if femininePast(w) || len([]rune(w)) < 3 {
+	if femininePast(w) || len([]rune(w)) < minInflectedRunes {
 		return false
 	}
 	return strings.HasSuffix(w, "а") || strings.HasSuffix(w, "я")
@@ -307,7 +318,7 @@ func checkHisGender(body string) Result {
 // hersNotHis — the verb is Maven's own if "я" comes shortly before it, or if the
 // thing she did was done to him ("напомнила тебе", "проверила за тебя").
 func hersNotHis(words []string, i int) bool {
-	for j := i - 1; j >= 0 && j >= i-3; j-- {
+	for j := i - 1; j >= 0 && j >= i-selfRefWindow; j-- {
 		if words[j] == "я" {
 			return true
 		}
@@ -368,12 +379,10 @@ func prevWord(words []string, i int) string {
 //     after the pronoun and is flagged wrongly.
 //   - any noun earlier in the message counts as an antecedent, even when it is
 //     not one ("после обеда он не ел", "выпей воды, он не пил" — both missed).
-//     Verbs and time words no longer count, which covers the usual nudge, but a
-//     plain noun before the pronoun still blinds it. The
-//     common time words are stoplisted so the usual nudge opening does not
-//     blind it, but a message with any other noun in front still slips through.
-//     This is the check's real hole; widening it further would start flagging
-//     legitimate third-party messages, so it stops here.
+//     Verbs and the common time words are stoplisted so the usual nudge opening
+//     does not blind it, but a message with any other noun in front still
+//     slips through. This is the check's real hole; widening it further would
+//     start flagging legitimate third-party messages, so it stops here.
 //   - a message that opens with "ты" and only later slips into "он" is missed,
 //     because "ты" itself is skipped but the words around it are not.
 //   - formal address outside these endings (short adjectives, "вашими" style
@@ -400,10 +409,14 @@ var prepositions = map[string]bool{
 	"под": true, "про": true, "без": true, "для": true, "через": true,
 }
 
+// minPluralVerbRunes — the -ите/-ете/-йте/-ьте endings pluralVerb matches are
+// three runes on their own, so anything shorter can't carry a stem plus one.
+const minPluralVerbRunes = 5
+
 // pluralVerb reports whether a word looks like a plural/formal verb form:
 // "приходите", "выпейте", "забудьте", "хотите".
 func pluralVerb(w string) bool {
-	if len([]rune(w)) < 5 {
+	if len([]rune(w)) < minPluralVerbRunes {
 		return false
 	}
 	return strings.HasSuffix(w, "ите") || strings.HasSuffix(w, "ете") ||
@@ -443,7 +456,7 @@ var notAnAntecedent = map[string]bool{
 // slipped through with "попробуй" taken for the person being talked about).
 func looksVerb(w string) bool {
 	r := []rune(w)
-	if len(r) < 3 {
+	if len(r) < minInflectedRunes {
 		return false
 	}
 	for _, suf := range []string{
@@ -681,11 +694,11 @@ func checkEllipsis(body string) Result {
 }
 
 // governedByYou reports whether "ты" stands close enough in front of the verb
-// at index i to be its subject. Three words, the same window checkFeminine's
-// first pass uses after "я", and it stops at a first-person pronoun so "ты
-// просил, я напомнил" still trips.
+// at index i to be its subject. selfRefWindow words, the same window
+// checkFeminine's first pass uses after "я", and it stops at a first-person
+// pronoun so "ты просил, я напомнил" still trips.
 func governedByYou(words []string, i int) bool {
-	for j := i - 1; j >= 0 && j >= i-3; j-- {
+	for j := i - 1; j >= 0 && j >= i-selfRefWindow; j-- {
 		switch words[j] {
 		case "ты":
 			return true

internal/phraser/failure_test.go

@@ -78,3 +78,36 @@ func TestEmptyKnowledgeAnswerIsAnError(t *testing.T) {
 		t.Errorf("error = %v; want it to name the empty response", err)
 	}
 }
+
+// The other two paths, which had no such guard. The evidence branch of
+// PhraseQuery and PhraseChat both returned ("", nil) off a server that produced
+// no tokens — an empty answer reported as a successful phrasing. The daemon's
+// callers check for the empty string and paper over it; the eval does not, and
+// scored a silent model as bad phrasing rather than as a failure.
+func TestEmptyAnswerIsAnErrorOnEveryPath(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.Write([]byte(`{"choices":[{"message":{"content":""}}]}`))
+	}))
+	t.Cleanup(srv.Close)
+	p := NewLLMPhraserAt(srv.URL, Config{})
+
+	t.Run("evidence", func(t *testing.T) {
+		got, err := p.PhraseQuery(context.Background(), "сколько воды я выпил", []string{"два литра"})
+		if err == nil {
+			t.Fatal("an empty response scored as an answer")
+		}
+		if !isFallback(t, fbQuerySources, "два литра", got) {
+			t.Errorf("fallback text = %q, want a %q variant", got, fbQuerySources)
+		}
+	})
+	t.Run("chat", func(t *testing.T) {
+		got, err := p.PhraseChat(context.Background(), "как дела", nil)
+		if err == nil {
+			t.Fatal("an empty response scored as an answer")
+		}
+		if !isFallback(t, fbChat, "", got) {
+			t.Errorf("fallback text = %q, want a %q variant", got, fbChat)
+		}
+	})
+}

internal/phraser/llmphraser.go

@@ -299,6 +299,16 @@ func (p *LLMPhraser) PhraseQuery(ctx context.Context, utterance string, notes []
 	if text != "" {
 		return text, nil
 	}
+	if raw == "" {
+		// Same guard the knowledge branch above has had since it was written,
+		// and this branch did not: the server answered and the model wrote
+		// nothing, which returned ("", nil) — an empty answer reported as a
+		// successful phrasing. The daemon's callers happen to check for the
+		// empty string, so it read as a silent fallback there; the eval scored
+		// it as bad phrasing rather than as the failure it is, and nothing on
+		// either path logged that the model had produced no tokens.
+		return SourcesFallback(strings.Join(notes, "; ")), errEmptyResponse
+	}
 	return raw, nil
 }
 
@@ -375,7 +385,13 @@ func (p *LLMPhraser) PhraseChat(ctx context.Context, utterance string, history [
 	if i := strings.IndexByte(resp, '\n'); i >= 0 {
 		resp = resp[:i]
 	}
-	return strings.TrimSpace(resp), nil
+	if resp = strings.TrimSpace(resp); resp == "" {
+		// The model was up and wrote nothing. Same rule as PhraseQuery: the
+		// fallback keeps the turn alive and the failure stays visible, rather
+		// than ("", nil) telling the caller the chat path succeeded.
+		return ChatFallback(), fmt.Errorf("phrase chat: %w", errEmptyResponse)
+	}
+	return resp, nil
 }
 
 func (p *LLMPhraser) PhraseReminder(ctx context.Context, d loop.ReminderDecision) (delivery.PhrasedReminder, error) {
@@ -414,11 +430,9 @@ func (p *LLMPhraser) PhraseReminder(ctx context.Context, d loop.ReminderDecision
 	if mood == "" {
 		mood = "neutral"
 	}
-	summary := body
-	if len(summary) > 60 {
-		summary = summary[:57] + "..."
-	}
-	return delivery.PhrasedReminder{Decision: d, Body: body, Summary: summary, Mood: mood}, nil
+	return delivery.PhrasedReminder{
+		Decision: d, Body: body, Summary: reminderSummary(body), Mood: mood,
+	}, nil
 }
 
 func (p *LLMPhraser) chat(ctx context.Context, userPrompt string) (string, error) {

internal/phraser/persona_floor_test.go

@@ -0,0 +1,316 @@
+package phraser
+
+// The persona guard for the Go floor strings.
+//
+// internal/phraser/eval/fallbacks_test.go already scores everything Variants()
+// returns — that is the JSON decks. What it cannot see is the floor UNDER those
+// decks: the hardFloor/ackFloor/queryFloor/actFloor/confirmFloor maps and the
+// literals in nudge_llm.go, which are what she says when the JSON is unusable or
+// when the model is unreachable. Those are exactly the moments the model is not
+// doing the talking, so leaving them unscored left the persona unchecked when it
+// was most load-bearing (Vikunja #621).
+//
+// Two tests here, and the second one is the point:
+//
+//   - TestGoFloorPersona scores the floor corpus on the same checks.
+//   - TestGoFloorCoverage walks the package source with go/ast and fails on any
+//     Russian string literal that neither reached the corpus nor sits inside a
+//     declaration declared prompt-side. A hand-written list of strings would rot
+//     the first time somebody adds one; a hand-written list of PROMPT BUILDERS
+//     does not, because the default for a new literal is "must be scored".
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io/fs"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+	"unicode"
+
+	"github.com/kami/maven/internal/loop"
+	"github.com/kami/maven/internal/phraser/eval"
+	"github.com/kami/maven/internal/store"
+)
+
+// personaChecks — the checks that apply to a floor line.
+//
+// The same three the non-goals section names (feminine self-reference, how she
+// addresses him, no pet names), plus lang: an English floor line is unusable out
+// loud. No hisgender, for the reason eval/fallbacks_test.go gives — her own
+// feminine verb near "тебе" is correct and that check reads it as addressing him
+// as a woman. No length, because a floor line composed from his own data has no
+// bounded length, and no ontopic/mood, which need a fixture case.
+var personaChecks = map[string]bool{
+	eval.CheckLang:     true,
+	eval.CheckFeminine: true,
+	eval.CheckAddress:  true,
+	eval.CheckCringe:   true,
+}
+
+var floorPlaceholderRE = regexp.MustCompile(`\{[a-z_]+\}`)
+
+// formatVerbRE — the fmt verbs a floor line is composed with, so the coverage
+// test compares the Russian either side of them and not the verb.
+var formatVerbRE = regexp.MustCompile(`%[+\-# 0-9.]*[a-zA-Z]`)
+
+// floorLine — one scored string and where it came from, so a failure names the
+// map or the function to go and edit.
+type floorLine struct {
+	origin string
+	text   string
+}
+
+// floorCorpus — every line the Go floor can produce. Maps are read whole, so a
+// new entry in one is scored without touching this file; the composing functions
+// are CALLED rather than scraped, so their glue text is scored in place.
+func floorCorpus() []floorLine {
+	var out []floorLine
+	add := func(origin, text string) {
+		if strings.TrimSpace(text) != "" {
+			out = append(out, floorLine{origin, text})
+		}
+	}
+	for name, m := range map[string]map[string]string{
+		"fallbacks.go hardFloor":      hardFloor,
+		"acks.go ackFloor":            ackFloor,
+		"query.go queryFloor":         queryFloor,
+		"acts.go actFloor":            actFloor,
+		"confirm.go confirmFloor":     confirmFloor,
+		"nudge_llm.go fallbackNudges": fallbackNudges,
+	} {
+		for key, text := range m {
+			add(name+"["+key+"]", text)
+		}
+	}
+
+	// fallbackNudge composes three of its four arms in Go. Drive every rule name
+	// the maps know, one it does not, and the down-services arm.
+	rules := map[string]bool{"": true, "unknown_rule": true}
+	for name := range fallbackNudges {
+		rules[name] = true
+	}
+	for name := range ruleTopics {
+		rules[name] = true
+	}
+	for name := range ruleKeywords {
+		rules[name] = true
+	}
+	for name := range rules {
+		c := loop.Candidate{}
+		c.Rule.Name = name
+		add(fmt.Sprintf("nudge_llm.go fallbackNudge(%q)", name), fallbackNudge(c))
+	}
+	// The keyword arm again, through a rule name shaped "family:keyword", which
+	// is where ruleKeyword's second branch lives.
+	c := loop.Candidate{}
+	c.Rule.Name = "custom:зарядку"
+	add("nudge_llm.go fallbackNudge(custom)", fallbackNudge(c))
+
+	// The keywords themselves. A rule that has both a keyword and a fallback
+	// line never reaches the keyword arm, but the map is edited as one thing and
+	// the next rule may have only the keyword, so score every value.
+	for rule, kw := range ruleKeywords {
+		add("nudge_llm.go ruleKeywords["+rule+"]", "Напоминаю: "+kw+".")
+	}
+
+	// The down-services arm, which needs a service actually reading down.
+	down := loop.Candidate{}
+	down.Rule.Name = "service_down"
+	down.State.Facts = map[string]store.Fact{
+		loop.ServiceDownPrefix + "gitea": {
+			Key:    loop.ServiceDownPrefix + "gitea",
+			Value:  `"down"`,
+			Source: loop.ServiceDownSource,
+			Ts:     time.Now(),
+		},
+	}
+	add("nudge_llm.go fallbackNudge(down services)", fallbackNudge(down))
+
+	// The spoken duration words. Both functions are pure and bounded, so scoring
+	// their whole range beats scraping the literals out of the switch.
+	for m := 0; m <= 60*30; m += 7 {
+		d := time.Duration(m) * time.Minute
+		add("nudge_llm.go ruDur", ruDur(d))
+		add("nudge_templates.go ruSinceWords", ruSinceWords(d))
+	}
+	for h := 0; h <= hoursSpoken; h++ {
+		add("nudge_templates.go hourPlural", hourPlural(h))
+		add("nudge_templates.go hourWord", hourWord(h))
+	}
+	return out
+}
+
+// TestGoFloorPersona scores every line the Go floor can say.
+func TestGoFloorPersona(t *testing.T) {
+	corpus := floorCorpus()
+	if len(corpus) == 0 {
+		t.Fatal("no floor lines — the corpus builder found nothing to score")
+	}
+	for _, line := range corpus {
+		// A placeholder stands for his own words and carries no persona.
+		body := floorPlaceholderRE.ReplaceAllString(line.text, "вода")
+		for _, r := range eval.RunChecks(eval.Case{}, body, "neutral") {
+			if personaChecks[r.Name] && !r.Pass {
+				t.Errorf("%s: %q fails %s: %s", line.origin, line.text, r.Name, r.Detail)
+			}
+		}
+	}
+}
+
+// promptDecls — declarations whose Russian is written FOR the model, not for
+// him. They are excluded by name, not by string, so adding a line inside one of
+// them stays excluded and adding a line anywhere else fails the coverage test.
+//
+// Every name here is asserted to still exist, so a rename fails loudly instead
+// of silently widening the exemption.
+var promptDecls = map[string]string{
+	"ReplySystemPrompt": "the system prompt for the reply model",
+	"replyContext":      "renders the decision FOR the model, never spoken",
+	"ruleTopics":        "situation descriptions fed to the nudge prompt",
+	"ruleTopic":         "same, plus the two prefixes it composes",
+	"buildNudgePrompt":  "the nudge prompt itself",
+	"chatUserMessage":   "the history block handed to the model",
+	"PhraseReminder":    "the reminder prompt; its reply is scored, its prompt is not",
+}
+
+// promptFiles — files whose whole job is prompt text. Asserted to exist, same
+// reason as promptDecls.
+var promptFiles = map[string]string{
+	"prompts.go": "every literal in it is a prompt",
+}
+
+func hasCyrillic(s string) bool {
+	for _, r := range s {
+		if unicode.Is(unicode.Cyrillic, r) {
+			return true
+		}
+	}
+	return false
+}
+
+// TestGoFloorCoverage — the guard that survives the next person.
+//
+// It reads the package source and requires every Russian string literal to be
+// one of two things: reachable in floorCorpus (so TestGoFloorPersona scored it),
+// or inside a declaration named above as prompt-side. There is no third answer
+// and no way to add a floor string that quietly gets neither.
+func TestGoFloorCoverage(t *testing.T) {
+	var scored []string
+	for _, line := range floorCorpus() {
+		scored = append(scored, line.text)
+	}
+	// A literal is covered when every Russian piece of it shows up in something
+	// the corpus scored. Pieces, not the whole string, because a format string
+	// ("%d ч") and a concatenation fragment ("Не отвечает: ") only ever reach him
+	// with the surrounding value filled in.
+	covered := func(lit string) bool {
+		for _, part := range formatVerbRE.Split(lit, -1) {
+			part = strings.TrimSpace(part)
+			if part == "" || !hasCyrillic(part) {
+				continue
+			}
+			found := false
+			for _, s := range scored {
+				if strings.Contains(s, part) {
+					found = true
+					break
+				}
+			}
+			if !found {
+				return false
+			}
+		}
+		return true
+	}
+
+	fset := token.NewFileSet()
+	pkgs, err := parser.ParseDir(fset, ".", func(fi fs.FileInfo) bool {
+		return !strings.HasSuffix(fi.Name(), "_test.go")
+	}, 0)
+	if err != nil {
+		t.Fatalf("parse package: %v", err)
+	}
+	pkg, ok := pkgs["phraser"]
+	if !ok {
+		t.Fatal("package phraser did not parse — the coverage guard cannot run")
+	}
+
+	seenDecl := map[string]bool{}
+	seenFile := map[string]bool{}
+	for path, file := range pkg.Files {
+		base := path[strings.LastIndexByte(path, '/')+1:]
+		if _, exempt := promptFiles[base]; exempt {
+			seenFile[base] = true
+			continue
+		}
+		for _, decl := range file.Decls {
+			names := declNames(decl)
+			skip := false
+			for _, n := range names {
+				if _, ok := promptDecls[n]; ok {
+					seenDecl[n] = true
+					skip = true
+				}
+			}
+			if skip {
+				continue
+			}
+			ast.Inspect(decl, func(n ast.Node) bool {
+				bl, ok := n.(*ast.BasicLit)
+				if !ok || bl.Kind != token.STRING {
+					return true
+				}
+				lit, err := strconv.Unquote(bl.Value)
+				if err != nil || !hasCyrillic(lit) {
+					return true
+				}
+				if !covered(lit) {
+					t.Errorf("%s: Russian literal %q is spoken by nothing the persona guard scores.\n"+
+						"Either reach it from floorCorpus in persona_floor_test.go, or — if it is written "+
+						"for the model rather than for him — name its declaration in promptDecls.",
+						fset.Position(bl.Pos()), lit)
+				}
+				return true
+			})
+		}
+	}
+	for name, why := range promptDecls {
+		if !seenDecl[name] {
+			t.Errorf("promptDecls names %q (%s) and no such declaration exists — "+
+				"a rename left the exemption open", name, why)
+		}
+	}
+	for base, why := range promptFiles {
+		if !seenFile[base] {
+			t.Errorf("promptFiles names %q (%s) and no such file exists", base, why)
+		}
+	}
+}
+
+// declNames — the names a top-level declaration binds, so a prompt-side var,
+// const or func can be matched whatever kind it is.
+func declNames(decl ast.Decl) []string {
+	switch d := decl.(type) {
+	case *ast.FuncDecl:
+		return []string{d.Name.Name}
+	case *ast.GenDecl:
+		var out []string
+		for _, spec := range d.Specs {
+			switch s := spec.(type) {
+			case *ast.ValueSpec:
+				for _, n := range s.Names {
+					out = append(out, n.Name)
+				}
+			case *ast.TypeSpec:
+				out = append(out, s.Name.Name)
+			}
+		}
+		return out
+	}
+	return nil
+}

internal/phraser/phraser.go

@@ -115,11 +115,32 @@ func (s *Stub) PhraseReminder(_ context.Context, d loop.ReminderDecision) (deliv
 	if text == "" {
 		text = "reminder"
 	}
-	summary := text
-	if len(summary) > 60 {
-		summary = summary[:57] + "..."
+	// Mood, for the same reason PhraseNudge sets it: the Stub is a production
+	// fallback, so it owes the output contract a value. This one was left at the
+	// zero value, which is not one of the five moods.
+	return delivery.PhrasedReminder{
+		Decision: d, Body: text, Summary: reminderSummary(text), Mood: "neutral",
+	}, nil
+}
+
+// summaryLimit — how much of a reminder goes to the away channels.
+const summaryLimit = 60
+
+// reminderSummary shortens a reminder body to the away-channel summary.
+//
+// Counted in runes. Both copies of this counted bytes — `len(s) > 60` and
+// `s[:57]` — and on a Russian reminder that is wrong twice. A Cyrillic letter is
+// two bytes, so the cut fell at about 28 letters rather than 60; and byte 57
+// lands inside a letter about half the time, so the summary ended in half a
+// rune. That is not cosmetic: Sendable.Summary is the text voicesink hands to
+// piper and the text the telegram sink posts, so the broken byte was spoken and
+// sent.
+func reminderSummary(body string) string {
+	r := []rune(body)
+	if len(r) <= summaryLimit {
+		return body
 	}
-	return delivery.PhrasedReminder{Decision: d, Body: text, Summary: summary}, nil
+	return string(r[:summaryLimit-3]) + "..."
 }
 
 // phraseNudge — the per-rule templates. each reads the context the predicate

internal/phraser/phraser_test.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 	"testing"
 	"time"
+	"unicode/utf8"
 
 	"github.com/kami/maven/internal/delivery"
 	"github.com/kami/maven/internal/dialogue"
@@ -185,6 +186,34 @@ func TestPhraseReminderTruncatesLongSummary(t *testing.T) {
 	}
 }
 
+// The same truncation, in the language she actually speaks. The test above is
+// ASCII, which is what let the byte arithmetic stand: `len(s) > 60` and `s[:57]`
+// cut a Russian reminder at about 28 letters instead of 60, and landed inside a
+// letter about half the time. Summary is what voicesink hands to piper and what
+// the telegram sink posts, so half a rune was spoken and sent.
+func TestPhraseReminderSummaryCountsRunesNotBytes(t *testing.T) {
+	long := "позвонить маме и забрать посылку из пункта выдачи на соседней улице до восьми вечера"
+	rd := loop.ReminderDecision{
+		Reminder: store.Reminder{Payload: `{"text":"` + long + `"}`},
+		State:    loop.State{Now: time.Now().UTC()},
+	}
+	pr, _ := NewStub().PhraseReminder(context.Background(), rd)
+	if !utf8.ValidString(pr.Summary) {
+		t.Fatalf("summary is not valid UTF-8, it was cut mid-letter: %q", pr.Summary)
+	}
+	if n := utf8.RuneCountInString(pr.Summary); n > summaryLimit {
+		t.Fatalf("summary = %d runes, want at most %d: %q", n, summaryLimit, pr.Summary)
+	}
+	// The cut must be near the limit, not near half of it. A byte count would
+	// stop at 28 letters here.
+	if n := utf8.RuneCountInString(pr.Summary); n < summaryLimit-5 {
+		t.Fatalf("summary = %d runes, cut far too early — counted in bytes? %q", n, pr.Summary)
+	}
+	if pr.Mood == "" {
+		t.Error("Mood is empty; the Stub is a production fallback and owes the contract a mood")
+	}
+}
+
 func TestPhraseReminderNonJSONPayload(t *testing.T) {
 	// a payload that isn't JSON → the phraser falls back to the raw string.
 	rd := loop.ReminderDecision{

internal/phraser/replier.go

@@ -30,8 +30,13 @@ const replyTimeout = 60 * time.Second
 
 // ReplySystemPrompt — the reactive confirmation contract: one short Russian
 // sentence, feminine self-reference, informal address, no question.
+//
+// The example is deliberately contentless. It used to be "Записала, что ты
+// выпил стакан воды.", and the model copied the glass into a real reply about
+// water he never described that way (V-592). An example carrying a plausible
+// completion of the input is an invitation to reuse it.
 const ReplySystemPrompt = `Ты — Maven, домашняя ассистентка (о себе — в женском роде). Владелец — мужчина, говоришь с ним на "ты", в единственном числе; никогда не "вы"/"ваш" и не "он"/"его". Подтверди действие РОВНО ОДНИМ коротким предложением (≤120 символов), по-русски, спокойно и без официальных формулировок. Не задавай вопросов, не повторяй слова, не добавляй ничего после точки. Отвечай ТОЛЬКО одним объектом JSON с полями "response" (текст) и "mood" (ровно одно из: neutral, happy, thinking, tired, confused).
-Пример: {"response": "Записала, что ты выпил стакан воды.", "mood": "neutral"}
+Пример: {"response": "Хорошо, напомню.", "mood": "neutral"}
 Никогда не пиши "..." в поле response.`
 
 // Replier phrases reactive confirmations with the resident model. It has no

internal/router/calendar.go

@@ -35,16 +35,14 @@ var dayPlanWords = []string{
 // answer today and stamp it with today's date, which is a wrong answer where
 // falling through is only a terse one.
 //
-// The weekday names are here as a refusal, not as a feature. "какие планы на
-// понедельник?" carries no other-day token in the сегодня family and does carry
-// "планы", so the plan used to claim it and recite today.
+// A weekday is a refusal too, and it is not in this list: IsDayPlanQuery asks
+// WeekdayIndex, so every case of every name refuses rather than the nine forms
+// that used to be written out here (V-581). "какие планы на понедельник?"
+// carries no other-day token in the сегодня family and does carry "планы", so
+// the plan used to claim it and recite today.
 var otherDayWords = []string{
 	"завтра", "послезавтра", "вчера", "позавчера",
 	"tomorrow", "yesterday",
-	"понедельник", "вторник", "среду", "среда", "четверг", "пятницу", "пятница",
-	"субботу", "суббота", "воскресенье",
-	"понедельника", "вторника", "четверга", "пятницы", "субботы", "воскресенья",
-	"monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday",
 	"неделю", "неделя", "недели", "неделе",
 	"выходные", "выходных", "выходным",
 	"месяц", "месяца", "месяце",
@@ -69,6 +67,9 @@ func IsDayPlanQuery(text string) bool {
 	}
 	toks := planTokens(text)
 	for _, t := range toks {
+		if _, ok := WeekdayIndex(t); ok {
+			return false
+		}
 		for _, w := range otherDayWords {
 			if t == w {
 				return false

internal/router/dateparser.go

@@ -45,17 +45,28 @@ try:
     now = datetime.fromisoformat(sys.argv[2])
     # Pre-process: replace Russian time qualifiers with AM/PM.
     # Handles "9 утра", "10 часов утра", "3 часа дня" etc.
-    text = re.sub(r'(\d+)\s+(?:час(?:а|ов)?\s+)?утра\b', r'\1 am', text, flags=re.IGNORECASE)
-    text = re.sub(r'(\d+)\s+(?:час(?:а|ов)?\s+)?вечера\b', r'\1 pm', text, flags=re.IGNORECASE)
-    text = re.sub(r'(\d+)\s+(?:час(?:а|ов)?\s+)?дня\b', r'\1 pm', text, flags=re.IGNORECASE)
-    text = re.sub(r'(\d+)\s+(?:час(?:а|ов)?\s+)?ночи\b', r'\1 am', text, flags=re.IGNORECASE)
+    text = re.sub(r'(\d+)\s+(?:час(?:а|ов|у|ам)?\s+)?утра\b', r'\1 am', text, flags=re.IGNORECASE)
+    text = re.sub(r'(\d+)\s+(?:час(?:а|ов|у|ам)?\s+)?вечера\b', r'\1 pm', text, flags=re.IGNORECASE)
+    text = re.sub(r'(\d+)\s+(?:час(?:а|ов|у|ам)?\s+)?дня\b', r'\1 pm', text, flags=re.IGNORECASE)
+    text = re.sub(r'(\d+)\s+(?:час(?:а|ов|у|ам)?\s+)?ночи\b', r'\1 am', text, flags=re.IGNORECASE)
     # A bare hour after a preposition is dropped on the floor by dateparser:
     # "завтра в 7" resolves to tomorrow at the CURRENT clock, and "завтра в 7
     # часов" is read as seven hours from now. Only a qualifier (already an
     # am/pm above) or a colon makes it read the hour, so give it the colon.
     # English "at 7" fails identically, so both prepositions are rewritten.
-    text = re.sub(r'(?<![\w:])(в|во|at)\s+([01]?\d|2[0-3])(?:\s+час(?:а|ов)?)?(?![\d:.\w])',
-                  lambda m: '%s %02d:00' % (m.group(1), int(m.group(2))), text, flags=re.IGNORECASE)
+    # "на 9" is the same hour said with the other preposition, and it was not
+    # read at all until V-579: "в 9" set the reminder and "на 9" did not.
+    # "к двум часам" is a third preposition and the dative that goes with it,
+    # and it was read as no time at all until V-609.
+    # The preposition is normalised as well as the hour (V-610). dateparser
+    # joins a day word to a clock through "в" and through no other Russian
+    # preposition, so "завтра к 03:00 pm" loses the clock and resolves to
+    # tomorrow at the CURRENT minute. "на" was silently losing it the same way.
+    def _at(m):
+        prep = 'at' if m.group(1).lower() in ('at', 'by') else 'в'
+        return '%s %02d:00' % (prep, int(m.group(2)))
+    text = re.sub(r'(?<![\w:])(в|во|на|к|ко|at|by)\s+([01]?\d|2[0-3])(?:\s+час(?:а|ов|у|ам)?)?(?![\d:.\w])',
+                  _at, text, flags=re.IGNORECASE)
     settings = {'PREFER_DATES_FROM': 'future', 'RELATIVE_BASE': now}
     # Two-step: search_dates finds the date substring in text,
     # parse() gets the time right (search_dates mishandles AM/PM).

internal/router/factparser_corpus_test.go

@@ -0,0 +1,286 @@
+package router
+
+import (
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// The fact-parser corpus (V-586). DefaultFactParser is the only thing standing
+// between a spoken sentence and a written self-care fact, and until this file
+// it was covered by a handful of examples chosen by whoever last edited it. The
+// RU routing fixture does not cover it either: it holds three fact cases and
+// all three miss on intent, so the parser is never reached and a parser change
+// scores as "unchanged".
+//
+// So the corpus is here, and it scores BOTH implementations: the closed-class
+// parser that ships, and legacyFactParse below, a faithful copy of the
+// hand-written substring version 22edc3c replaced. The table is the measurement
+// — see docs/evals/2026-08-06-fact-parser.md for the numbers as of that day.
+//
+// Three case classes, and the third is the point:
+//
+//	true positive  — a sentence he would say, with the key it must write.
+//	misfire        — a sentence the substring parser wrote a fact for and
+//	                 should not have. want is "".
+//	false-negative — a sentence he would plausibly say whose word is in NO
+//	                 lexicon set. want is the key a human would assign, and
+//	                 the ship parser is EXPECTED to miss it. These measure the
+//	                 cost of the word-list design, not a bug in it.
+//
+// Nothing here asserts a score. A closed class is a decision about vocabulary
+// and the bar belongs in a dated eval, not in an assertion that turns every
+// vocabulary edit into a red test. What it does fail on is a regression in the
+// two classes that are not judgement calls: a true positive that stops matching
+// and a misfire that starts.
+
+type factCase struct {
+	utterance string
+	want      string // "" — no fact
+	class     string // "tp", "misfire", "fn"
+	broken    bool   // ship parser is known to get this wrong; see the 06-08 eval
+	note      string
+}
+
+var factCorpus = []factCase{
+	// ---- water, true positives -------------------------------------------
+	{"выпил стакан воды", "water", "tp", false, ""},
+	{"попил воды", "water", "tp", false, ""},
+	{"я попил водички", "water", "tp", false, ""},
+	{"пью воду", "water", "tp", false, ""},
+	{"воду пил уже", "water", "tp", false, ""},
+	{"допил воду", "water", "tp", true, "REGRESSION: the dictionary lemmatises допил to допилить, to finish sawing — the same saw collision drink_verbs already carries пил for, unfixed for the prefixed form"},
+	{"запил таблетку водой", "water", "tp", false, ""},
+	{"drank water", "water", "tp", false, ""},
+	{"i drank some water", "water", "tp", false, ""},
+
+	// ---- meal, true positives --------------------------------------------
+	{"поужинал", "meal", "tp", false, ""},
+	{"я пообедал", "meal", "tp", false, ""},
+	{"позавтракал кашей", "meal", "tp", false, ""},
+	{"перекусил бутербродом", "meal", "tp", false, ""},
+	{"покушал", "meal", "tp", false, ""},
+	{"поел супа", "meal", "tp", false, ""},
+	{"обед был в час", "meal", "tp", false, ""},
+	{"ужинать буду позже", "meal", "tp", false, ""},
+	{"i ate", "meal", "tp", false, ""},
+	{"had lunch", "meal", "tp", false, ""},
+	{"dinner done", "meal", "tp", false, ""},
+
+	// ---- shower, true positives ------------------------------------------
+	{"принял душ", "shower", "tp", false, ""},
+	{"сходил в душ", "shower", "tp", false, ""},
+	{"душ принят", "shower", "tp", false, ""},
+	{"ополоснулся душем", "shower", "tp", false, ""},
+	{"took a shower", "shower", "tp", false, ""},
+	{"i showered", "shower", "tp", false, ""},
+
+	// ---- break, true positives -------------------------------------------
+	{"сделал перерыв", "break", "tp", false, ""},
+	{"отдохнул полчаса", "break", "tp", false, ""},
+	{"передохнул немного", "break", "tp", false, ""},
+	{"отдыхаю", "break", "tp", false, ""},
+	{"был перерыв на обед", "meal", "tp", false, "meal wins the switch; both keys are true of the sentence"},
+	{"took a break", "break", "tp", false, ""},
+
+	// ---- sleep, true positives -------------------------------------------
+	{"спал восемь часов", "sleep", "tp", false, ""},
+	{"спала плохо", "sleep", "tp", false, "she may report her own; the parser is speaker-agnostic"},
+	{"поспал днём", "sleep", "tp", false, ""},
+	{"выспался наконец", "sleep", "tp", false, ""},
+	{"проспал будильник", "sleep", "tp", false, ""},
+	{"пойду спать", "sleep", "tp", false, ""},
+	{"slept 8 hours", "sleep", "tp", false, ""},
+	{"i slept badly", "sleep", "tp", false, ""},
+
+	// ---- misfires 22edc3c set out to reject -------------------------------
+	{"пилот сказал что вылет через час", "", "misfire", false, "substring пил"},
+	{"водитель уже подъехал", "", "misfire", false, "substring вод"},
+	{"надо заводить машину", "", "misfire", false, "substring вод"},
+	{"душа болит", "", "misfire", false, "substring душ"},
+	{"в комнате душно", "", "misfire", false, "substring душ"},
+	{"это была беда", "", "misfire", false, "substring еда"},
+	{"наша победа", "", "misfire", false, "substring еда"},
+	{"пила лежит в гараже", "", "misfire", false, "substring пил"},
+	{"водитель пилота ждёт", "", "misfire", false, "both stems in one sentence — the old water arm fires"},
+	{"обеденный перерыв отменили", "", "misfire", true, "neither parser gets this: the old one writes meal off the adjective, the new one writes break off перерыв. A cancelled break is not a break taken."},
+
+	// ---- hard negatives that decide the design ----------------------------
+	{"есть новости по бэкапу базы", "", "misfire", false, "есть is the existential, not a meal"},
+	{"напоминания на завтра есть", "", "misfire", false, "завтра carries завтрак as a substring"},
+	{"на душе легко", "", "misfire", false, "душе is the soul, and also the prepositional of душ"},
+	{"пилил доску весь вечер", "", "misfire", false, ""},
+	{"поставь будильник на завтра", "", "misfire", false, "завтра again, no meal"},
+
+	// ---- false negatives: words in no lexicon set -------------------------
+	// Water.
+	{"выпил чаю", "water", "fn", false, "hydration by any liquid; чай is in no set"},
+	{"глотнул воды", "water", "fn", false, "глотнуть is not a drink verb"},
+	{"хлебнул воды", "water", "fn", false, "хлебнуть is not a drink verb"},
+	{"воды хлебнул из бутылки", "water", "fn", false, ""},
+	{"выпил стакан", "water", "fn", false, "the noun is elided; he says this"},
+	{"i hydrated", "water", "fn", false, "hydrate is in no set"},
+	{"finished my bottle of water", "water", "fn", false, "no drink verb in the English set"},
+
+	// Meal.
+	{"ем суп", "meal", "fn", false, "есть is deliberately absent, and this is the cost"},
+	{"съел бутерброд", "meal", "fn", false, "съесть is in no set"},
+	{"наелся", "meal", "fn", false, "наесться is in no set"},
+	{"пожрал", "meal", "fn", false, "coarse but spoken"},
+	{"полдник был", "meal", "fn", false, "полдник is in no set"},
+	{"i had a snack", "meal", "fn", false, "snack is in no set"},
+	{"having supper", "meal", "fn", false, "supper is in no set"},
+	{"brunch was good", "meal", "fn", false, "brunch is in no set"},
+	{"i eat now", "meal", "fn", false, "eat is in no set — only ate is"},
+
+	// Shower.
+	{"был в душе", "shower", "fn", false, "prepositional; anyExact cannot take it without taking the soul"},
+	{"после душа полегчало", "shower", "fn", false, "genitive, same collision"},
+	{"помылся", "shower", "fn", false, "помыться is in no set"},
+	{"сходил в ванную", "shower", "fn", false, "ванная is in no set"},
+	{"искупался", "shower", "fn", false, "искупаться is in no set"},
+	{"i am showering", "shower", "fn", false, "showering is not a member and the set is exact-matched"},
+
+	// Break.
+	{"сделал передышку", "break", "fn", false, "передышка is in no set"},
+	{"перекур", "break", "fn", false, "перекур is in no set"},
+	{"полежал немного", "break", "fn", false, "полежать is in no set"},
+	{"сделал паузу", "break", "fn", false, "пауза is in no set"},
+	{"i took five", "break", "fn", false, "idiomatic, in no set"},
+	{"resting now", "break", "fn", false, "resting is not a member and rest is matched by lemma only"},
+
+	// Sleep.
+	{"вздремнул", "sleep", "fn", false, "вздремнуть is in no set"},
+	{"прикорнул на диване", "sleep", "fn", false, "прикорнуть is in no set"},
+	{"дрых до обеда", "sleep", "fn", false, "дрыхнуть is in no set — and обед makes this a MEAL for both parsers"},
+	{"недоспал", "sleep", "fn", false, "недоспать is in no set"},
+	{"лёг в двенадцать", "sleep", "fn", false, "лечь is in no set"},
+	{"сон был короткий", "sleep", "fn", false, "сон deliberately absent"},
+	{"i napped", "sleep", "fn", false, "nap is in no set"},
+	{"took a nap", "sleep", "fn", false, "break matches nothing here either"},
+}
+
+// legacyFactParse — DefaultFactParser exactly as it stood at 22edc3c's parent
+// (0445693), copied here so the corpus scores the trade rather than describing
+// it. Do not fix it. It is a frozen baseline, and the day it stops being worth
+// comparing against, delete it and the two-column table with it.
+func legacyFactParse(utterance string) (string, string, bool) {
+	s := strings.ToLower(strings.TrimSpace(utterance))
+	hasRoot := func(root string) bool { return strings.Contains(s, root) }
+	containsWord := func(w string) bool {
+		for _, tok := range strings.Fields(s) {
+			if tok == w {
+				return true
+			}
+		}
+		return false
+	}
+	switch {
+	case (containsWord("water") && containsWord("drank")) ||
+		(hasRoot("вод") && (hasRoot("пил") || hasRoot("пью") || hasRoot("пей"))):
+		return "water", `"drank"`, true
+	case containsWord("meal") || (containsWord("ate") && !containsWord("backup")) || containsWord("lunch") || containsWord("dinner") ||
+		hasRoot("поел") || hasRoot("поесть") || hasRoot("куша") || hasRoot("обед") || hasRoot("ужин") || hasRoot("завтрак") || hasRoot("еда"):
+		return "meal", `"ate"`, true
+	case containsWord("shower") || hasRoot("душ"):
+		return "shower", `"took"`, true
+	case containsWord("break") || hasRoot("перерыв") || hasRoot("отдох"):
+		return "break", `"took"`, true
+	case containsWord("slept") || containsWord("sleep") ||
+		hasRoot("спал") || hasRoot("выспал"):
+		if v, ok := parseDurationValue(afterWord(s, "slept")); ok {
+			return "sleep", strconv.Quote(v), true
+		}
+		return "sleep", `"slept"`, true
+	}
+	return "", "", false
+}
+
+// TestFactParserCorpus scores both parsers over the corpus and prints the
+// side-by-side. Run it with -v; the table is the output.
+func TestFactParserCorpus(t *testing.T) {
+	type tally struct{ tpHit, tpMiss, misfire, misfireOK, fnHit, fnMiss int }
+	var now, old tally
+
+	var rows []string
+	rows = append(rows, "| utterance | class | want | old (substring) | new (closed class) |")
+	rows = append(rows, "|---|---|---|---|---|")
+
+	score := func(key string, ok bool, c factCase, tl *tally) string {
+		got := ""
+		if ok {
+			got = key
+		}
+		switch c.class {
+		case "tp":
+			if got == c.want {
+				tl.tpHit++
+			} else {
+				tl.tpMiss++
+			}
+		case "misfire":
+			if got == c.want {
+				tl.misfireOK++
+			} else {
+				tl.misfire++
+			}
+		case "fn":
+			if got == c.want {
+				tl.fnHit++
+			} else {
+				tl.fnMiss++
+			}
+		}
+		if got == "" {
+			return "—"
+		}
+		return got
+	}
+
+	for _, c := range factCorpus {
+		nk, _, nok := DefaultFactParser{}.Parse(c.utterance)
+		ok, _, ook := legacyFactParse(c.utterance)
+		gotNew := score(nk, nok, c, &now)
+		gotOld := score(ok, ook, c, &old)
+		want := c.want
+		if want == "" {
+			want = "—"
+		}
+		mark := ""
+		if gotOld != gotNew {
+			mark = " **≠**"
+		}
+		rows = append(rows, "| `"+c.utterance+"` | "+c.class+" | "+want+" | "+gotOld+" | "+gotNew+mark+" |")
+	}
+
+	line := func(name string, tl tally) string {
+		return name +
+			": true positives " + strconv.Itoa(tl.tpHit) + "/" + strconv.Itoa(tl.tpHit+tl.tpMiss) +
+			", misfires rejected " + strconv.Itoa(tl.misfireOK) + "/" + strconv.Itoa(tl.misfireOK+tl.misfire) +
+			", false-negative cases recovered " + strconv.Itoa(tl.fnHit) + "/" + strconv.Itoa(tl.fnHit+tl.fnMiss)
+	}
+	t.Log("\n" + strings.Join(rows, "\n") + "\n\n" + line("old (substring)", old) + "\n" + line("new (closed class)", now))
+
+	// The two regressions that are not judgement calls.
+	for _, c := range factCorpus {
+		k, _, ok := DefaultFactParser{}.Parse(c.utterance)
+		got := ""
+		if ok {
+			got = k
+		}
+		if c.class == "fn" {
+			continue
+		}
+		if c.broken {
+			// Recorded as wrong on 06-08. If it starts passing, someone fixed
+			// it and the flag is now a lie — say so rather than staying green.
+			if got == c.want {
+				t.Errorf("%q now returns %q as wanted — drop its broken flag", c.utterance, got)
+			}
+			continue
+		}
+		if got != c.want {
+			t.Errorf("%s %q: got %q, want %q (%s)", c.class, c.utterance, got, c.want, c.note)
+		}
+	}
+}

internal/router/habit.go

@@ -27,26 +27,10 @@ var habitMarkers = []string{
 	"typically", "normally",
 }
 
-// weekdayWords — every form of a weekday name maven needs to recognise,
-// including the "по …ам" plural the question is usually phrased in.
-var weekdayWords = map[string]time.Weekday{
-	"понедельник": time.Monday, "понедельникам": time.Monday,
-	"вторник": time.Tuesday, "вторникам": time.Tuesday,
-	"среда": time.Wednesday, "среду": time.Wednesday, "средам": time.Wednesday,
-	"четверг": time.Thursday, "четвергам": time.Thursday,
-	"пятница": time.Friday, "пятницу": time.Friday, "пятницам": time.Friday,
-	"суббота": time.Saturday, "субботу": time.Saturday, "субботам": time.Saturday,
-	"воскресенье": time.Sunday, "воскресеньям": time.Sunday,
-	"воскресенья": time.Sunday, "воскресенью": time.Sunday,
-	"воскресеньем": time.Sunday, "воскресеньях": time.Sunday,
-	"monday": time.Monday, "mondays": time.Monday,
-	"tuesday": time.Tuesday, "tuesdays": time.Tuesday,
-	"wednesday": time.Wednesday, "wednesdays": time.Wednesday,
-	"thursday": time.Thursday, "thursdays": time.Thursday,
-	"friday": time.Friday, "fridays": time.Friday,
-	"saturday": time.Saturday, "saturdays": time.Saturday,
-	"sunday": time.Sunday, "sundays": time.Sunday,
-}
+// The weekday a habit question names comes from WeekdayIndex, not from a map
+// here. This file used to keep its own declension table, which had "воскресеньях"
+// and no "средах" — a list of forms is finished by whoever last thought of one,
+// and a dictionary is not (V-581).
 
 // weekendWords — the weekend as one unit. "что я обычно делаю по выходным?"
 // has a habit marker and names days, but no weekday name is in it, so it used
@@ -77,7 +61,7 @@ func ParseHabitQuery(text string) (HabitQuery, bool) {
 		return HabitQuery{}, false
 	}
 	for _, t := range toks {
-		if wd, ok := weekdayWords[t]; ok {
+		if wd, ok := WeekdayIndex(t); ok {
 			return HabitQuery{Weekday: wd, HasWeekday: true}, true
 		}
 		if weekendWords[t] {

internal/router/hourunit_test.go

@@ -0,0 +1,74 @@
+package router
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// TestDativePluralHourIsAnHour — "напомни к двум часам позвонить маме" reached
+// the daemon with no time at all and she asked the open "Когда?", while "к трём"
+// one word over read fine (V-609). The word that lost it was "часам", the dative
+// plural of "час", which four separate hour sets in this package left out.
+func TestDativePluralHourIsAnHour(t *testing.T) {
+	const s = "напомни к двум часам позвонить маме"
+	if !MentionsTime(s) {
+		t.Errorf("MentionsTime(%q) = false; the sentence names two o'clock", s)
+	}
+	if !NamesAnHour(s) {
+		t.Errorf("NamesAnHour(%q) = false; the sentence names two o'clock", s)
+	}
+	if got, want := SpellOutDigits(s), "напомни к 2 часам позвонить маме"; got != want {
+		t.Errorf("SpellOutDigits(%q) = %q, want %q", s, got, want)
+	}
+	// The slot itself, which is what the daemon reads. It was empty, so
+	// whenGapOf named the hour missing and she asked "Когда?".
+	now := time.Date(2026, 8, 6, 3, 39, 0, 0, time.UTC)
+	ex := Extractor{Time: StubDateTimeParser{}}
+	got := ex.Extract(context.Background(), IntentReminder, s, now)
+	if !got.HasTime {
+		t.Fatalf("the hour was spoken, so the slot must be filled: %+v", got)
+	}
+	if h := got.Time.Hour(); h != 2 && h != 14 {
+		t.Errorf("fire time = %s, want two o'clock in one half of the day or the other", got.Time.Format("15:04"))
+	}
+}
+
+// TestHourUnitReachesEverySite — the four sets that read the hour noun now read
+// one lexicon key, so a form added there is a form all four know. "часам" is the
+// form that was missing from every one of them.
+func TestHourUnitReachesEverySite(t *testing.T) {
+	for _, w := range []string{"час", "часа", "часов", "часу", "часам"} {
+		if !numeralContext[w] {
+			t.Errorf("numeralContext is missing %q", w)
+		}
+		if !hourMarkers[w] {
+			t.Errorf("hourMarkers is missing %q", w)
+		}
+		if !timeMarkers[w] {
+			t.Errorf("timeMarkers is missing %q", w)
+		}
+		if _, ok := unitToDuration(2, w); !ok {
+			t.Errorf("unitToDuration does not know %q", w)
+		}
+	}
+}
+
+// TestMinuteUnitHasTheSameForms — the same defect one noun over: "минутам" was
+// missing everywhere "минут" and "минуты" were present.
+func TestMinuteUnitHasTheSameForms(t *testing.T) {
+	for _, w := range []string{"минут", "минуты", "минуту", "минутам"} {
+		if !numeralContext[w] {
+			t.Errorf("numeralContext is missing %q", w)
+		}
+		if !hourMarkers[w] {
+			t.Errorf("hourMarkers is missing %q", w)
+		}
+		if !timeMarkers[w] {
+			t.Errorf("timeMarkers is missing %q", w)
+		}
+		if _, ok := unitToDuration(20, w); !ok {
+			t.Errorf("unitToDuration does not know %q", w)
+		}
+	}
+}

internal/router/kpreposition_test.go

@@ -0,0 +1,172 @@
+package router
+
+import (
+	"context"
+	"os/exec"
+	"testing"
+	"time"
+)
+
+// probeNow is the clock the five sentences below were measured against on the
+// box at 03:53 on 2026-08-06, right after #252 deployed. Three of them wrote a
+// reminder for 03:53 itself, which is the current minute and not an hour anyone
+// said (V-610).
+var probeNow = time.Date(2026, 8, 6, 3, 53, 0, 0, time.Local)
+
+// kProbe — the five sentences, with what each must resolve to. The two that
+// already worked are here so that fixing "к" cannot cost "в".
+var kProbe = []struct {
+	text string
+	// day is the offset from probeNow's date, hour is the fire hour.
+	day     int
+	hour    int
+	whyItIs string
+}{
+	{
+		text:    "напомни завтра в три часа дня позвонить врачу",
+		day:     1,
+		hour:    15,
+		whyItIs: "в plus a spoken hour and a qualifier resolves, and did before #252",
+	},
+	{
+		text:    "напомни завтра в 15:00 позвонить врачу",
+		day:     1,
+		hour:    15,
+		whyItIs: "a written clock resolves, and did before #252",
+	},
+	{
+		text:    "напомни завтра к трём часам дня позвонить врачу",
+		day:     1,
+		hour:    15,
+		whyItIs: "к names the same hour в does, and wrote 03:53 after #252",
+	},
+	{
+		text:    "напомни сегодня к пяти часам вечера позвонить врачу",
+		day:     0,
+		hour:    17,
+		whyItIs: "the same defect on today and on the oblique пяти",
+	},
+	{
+		text:    "напомни завтра к трём часам позвонить врачу",
+		day:     1,
+		hour:    3,
+		whyItIs: "no qualifier, so the hour reads as spoken and the daemon asks which half",
+	},
+}
+
+// TestKPrepositionHourStub — the probe against the floor parser, which answers
+// on every box whether or not python is installed.
+func TestKPrepositionHourStub(t *testing.T) {
+	ex := Extractor{Time: StubDateTimeParser{}}
+	for _, c := range kProbe {
+		t.Run(c.text, func(t *testing.T) {
+			got := ex.Extract(context.Background(), IntentReminder, c.text, probeNow)
+			if !got.HasTime {
+				t.Fatalf("time slot empty: %s", c.whyItIs)
+			}
+			checkFire(t, got.Time, c.day, c.hour, c.whyItIs)
+		})
+	}
+}
+
+// TestKPrepositionHourPython — the same probe against the production parser.
+// Skips where python3 or dateparser is missing, as the rest of this package's
+// python tests do.
+func TestKPrepositionHourPython(t *testing.T) {
+	requirePython(t)
+	p := NewPythonDateParser()
+	ex := Extractor{Time: p}
+	for _, c := range kProbe {
+		t.Run(c.text, func(t *testing.T) {
+			got := ex.Extract(context.Background(), IntentReminder, c.text, probeNow)
+			if !got.HasTime {
+				t.Fatalf("time slot empty: %s", c.whyItIs)
+			}
+			checkFire(t, got.Time, c.day, c.hour, c.whyItIs)
+		})
+	}
+}
+
+func checkFire(t *testing.T, fire time.Time, dayOffset, hour int, why string) {
+	t.Helper()
+	if fire.Hour() != hour || fire.Minute() != 0 {
+		t.Errorf("fire = %s, want %02d:00 — %s", fire.Format("2006-01-02 15:04"), hour, why)
+	}
+	if fire.Minute() == probeNow.Minute() && fire.Hour() == probeNow.Hour() {
+		t.Errorf("fire = %s, which is the clock at the moment of the turn and not an hour he said", fire.Format("15:04"))
+	}
+	want := probeNow.AddDate(0, 0, dayOffset)
+	if fire.Year() != want.Year() || fire.Month() != want.Month() || fire.Day() != want.Day() {
+		t.Errorf("fire = %s, want the %s — %s", fire.Format("2006-01-02"), want.Format("2006-01-02"), why)
+	}
+}
+
+// TestUnresolvedHourLeavesTheSlotEmpty — the durable half. A parser that read
+// the day and took the minute off the clock must not fill the time slot, no
+// matter which preposition lost the hour. This is the whole class the "к" case
+// was one member of.
+func TestUnresolvedHourLeavesTheSlotEmpty(t *testing.T) {
+	ex := Extractor{Time: clockEchoParser{}}
+	for _, s := range []string{
+		"напомни завтра к трём часам дня позвонить врачу",
+		"напомни завтра в три часа дня позвонить врачу",
+		"напомни завтра на девять позвонить врачу",
+		"напомни сегодня к пяти часам вечера позвонить врачу",
+	} {
+		got := ex.Extract(context.Background(), IntentReminder, s, probeNow)
+		if got.HasTime {
+			t.Errorf("Extract(%q) filled the slot with %s, which is the current minute; she has to ask", s, got.Time.Format("15:04"))
+		}
+	}
+}
+
+// TestSpokenMinutesSurviveTheRefusal — the three shapes that name a minute of
+// their own, and an hour that happens to be the hour it is spoken in. Refusing
+// on the whole instant instead of on the minute would cost every one of these,
+// and ru-rem-006 in the routing fixture is the case that says so.
+func TestSpokenMinutesSurviveTheRefusal(t *testing.T) {
+	noon := time.Date(2026, 7, 30, 12, 0, 0, 0, time.UTC)
+	ex := Extractor{Time: StubDateTimeParser{}}
+	for _, c := range []struct {
+		text string
+		hour int
+		min  int
+	}{
+		{"напомни послезавтра в 12 забрать заказ", 12, 0},
+		{"разбуди меня в 6:30", 6, 30},
+		{"напомни в половине восьмого выпить таблетку", 7, 30},
+		{"напомни без четверти восемь выходить", 7, 45},
+	} {
+		got := ex.Extract(context.Background(), IntentReminder, c.text, noon)
+		if !got.HasTime {
+			t.Errorf("Extract(%q) left the slot empty; he said the time", c.text)
+			continue
+		}
+		if got.Time.Hour() != c.hour || got.Time.Minute() != c.min {
+			t.Errorf("Extract(%q) = %s, want %02d:%02d", c.text, got.Time.Format("15:04"), c.hour, c.min)
+		}
+	}
+}
+
+// TestIntervalKeepsTheCurrentMinute — an interval is measured from now and may
+// land on now's own minute, so the refusal above must not reach it.
+func TestIntervalKeepsTheCurrentMinute(t *testing.T) {
+	ex := Extractor{Time: StubDateTimeParser{}}
+	got := ex.Extract(context.Background(), IntentReminder, "напомни через час позвонить врачу", probeNow)
+	if !got.HasTime {
+		t.Fatal("через час names one instant and answers the hour and the day together")
+	}
+	if want := probeNow.Add(time.Hour); !got.Time.Equal(want) {
+		t.Errorf("fire = %s, want %s", got.Time.Format("15:04"), want.Format("15:04"))
+	}
+}
+
+func requirePython(t *testing.T) {
+	t.Helper()
+	if _, err := exec.LookPath("python3"); err != nil {
+		t.Skip("python3 not on PATH — skipping dateparser tests")
+	}
+	if err := exec.Command("python3", "-c", "import dateparser").Run(); err != nil {
+		t.Skip("python dateparser not installed — skipping dateparser tests")
+	}
+}

internal/router/numwords.go

@@ -34,12 +34,21 @@ func numeralDigit(word string) (string, bool) {
 // 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,
+var numeralContext = buildNumeralContext()
+
+func buildNumeralContext() map[string]bool {
+	m := map[string]bool{
+		"в": true, "во": true, "к": true, "около": true, "на": true,
+		"утра": true, "вечера": true, "дня": true, "ночи": true,
+		"at": true, "by": true,
+	}
+	for _, w := range lexicon.HourUnits() {
+		m[w] = true
+	}
+	for _, w := range lexicon.MinuteUnits() {
+		m[w] = true
+	}
+	return m
 }
 
 // SpellOutDigits rewrites spoken numbers as digits so the date parsers see the

internal/router/slots.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/kami/maven/internal/lexicon"
+	"github.com/kami/maven/internal/morph"
 )
 
 // DateTimeParser — resolves relative→absolute AT CAPTURE ("in 4h" → now+4h),
@@ -55,7 +56,12 @@ func (e Extractor) Extract(ctx context.Context, intent Intent, utterance string,
 	switch intent {
 	case IntentReminder:
 		if e.Time != nil {
-			if t, ok, err := e.Time.Parse(ctx, utterance, now); err == nil && ok {
+			// ResolvedTheHour is the gate, not the parser's ok (V-577, V-579,
+			// V-610). A sentence that names a day and no hour parses to that day
+			// at the current minute, and so does one whose hour the parser could
+			// not read. Filling the slot with either invents the answer she asked
+			// for. Left empty, the daemon asks.
+			if t, ok, err := e.Time.Parse(ctx, utterance, now); err == nil && ok && ResolvedTheHour(utterance, t) {
 				s.Time = t
 				s.HasTime = true
 			}
@@ -118,23 +124,22 @@ type DefaultFactParser struct{}
 
 func (DefaultFactParser) Parse(utterance string) (string, string, bool) {
 	s := strings.ToLower(strings.TrimSpace(utterance))
-	// Maven is ru-first (voice, tts). Each case carries the English tokens AND
-	// Russian stems — matched by prefix (hasStem) because Russian inflects
-	// (воды/воду/вода share "вод"), so exact-token matching would miss most
-	// real utterances and silently drop the capture.
+	toks := strings.Fields(s)
+	// Maven is ru-first (voice, tts), and Russian inflects, so the words each
+	// case reads are closed classes in internal/lexicon and the inflection is
+	// morph's job (V-586). What stood here was a fourth mechanism: hand-written
+	// stems matched as substrings, so "пилот" was drinking, "водитель" was
+	// water, "душно" was a shower and "победа" was a meal.
 	switch {
-	case (containsWord(s, "water") && containsWord(s, "drank")) ||
-		(hasRoot(s, "вод") && (hasRoot(s, "пил") || hasRoot(s, "пью") || hasRoot(s, "пей"))):
+	case anyLemma(toks, lexicon.WaterNouns()) && anyLemma(toks, lexicon.DrinkVerbs()):
 		return "water", `"drank"`, true
-	case containsWord(s, "meal") || (containsWord(s, "ate") && !containsWord(s, "backup")) || containsWord(s, "lunch") || containsWord(s, "dinner") ||
-		hasRoot(s, "поел") || hasRoot(s, "поесть") || hasRoot(s, "куша") || hasRoot(s, "обед") || hasRoot(s, "ужин") || hasRoot(s, "завтрак") || hasRoot(s, "еда"):
+	case anyLemma(toks, lexicon.MealWords()):
 		return "meal", `"ate"`, true
-	case containsWord(s, "shower") || hasRoot(s, "душ"):
+	case anyExact(toks, lexicon.ShowerWords()):
 		return "shower", `"took"`, true
-	case containsWord(s, "break") || hasRoot(s, "перерыв") || hasRoot(s, "отдох"):
+	case anyLemma(toks, lexicon.BreakWords()):
 		return "break", `"took"`, true
-	case containsWord(s, "slept") || containsWord(s, "sleep") ||
-		hasRoot(s, "спал") || hasRoot(s, "выспал"):
+	case anyLemma(toks, lexicon.SleepWords()):
 		if v, ok := parseDurationValue(afterWord(s, "slept")); ok {
 			return "sleep", strconv.Quote(v), true
 		}
@@ -143,18 +148,31 @@ func (DefaultFactParser) Parse(utterance string) (string, string, bool) {
 	return "", "", false
 }
 
-// hasRoot — substring match on the whole utterance. Russian inflects with BOTH
-// prefixes and suffixes (вы-пил, по-пил, пил-и), so a prefix test misses the
-// verb; the root as a substring catches all forms. A rare over-match (пил in
-// пилот) is fine at this floor. ponytail: substring roots over a morphology lib
-// until misfires actually bite.
-func hasRoot(s, root string) bool { return strings.Contains(s, root) }
+// anyLemma reports whether any token is one of the set's words, in any case or
+// tense. Exact equality first because morph falls back to it without the
+// dictionary, and because a member the dictionary lemmatises oddly is carried
+// in the set as its surface form.
+func anyLemma(toks []string, set []string) bool {
+	for _, tok := range toks {
+		t := cleanWord(tok)
+		for _, w := range set {
+			if t == w || morph.SameWord(t, w) {
+				return true
+			}
+		}
+	}
+	return false
+}
 
-// containsWord — whole-token membership (avoids "breakfast" matching "break").
-func containsWord(s, w string) bool {
-	for _, tok := range strings.Fields(s) {
-		if tok == w {
-			return true
+// anyExact is anyLemma without the grammar, for a set whose members share a
+// lemma with a word that means something else. Only ShowerWords needs it.
+func anyExact(toks []string, set []string) bool {
+	for _, tok := range toks {
+		t := cleanWord(tok)
+		for _, w := range set {
+			if t == w {
+				return true
+			}
 		}
 	}
 	return false
@@ -171,6 +189,15 @@ func afterWord(s, w string) string {
 	return ""
 }
 
+// hourPrepositions — the words a spoken hour sits behind. Five, and no more:
+// the lexicon's frame set is much wider, and a word goes in here only when the
+// number after it is an hour of the day rather than a count of anything.
+//
+// "к" and "ко" joined the three on V-609. "напомни к двум часам" named an hour
+// and parsed to nothing, so the reminder reached the daemon with no time and she
+// asked the open question about an hour he had just said.
+var hourPrepositions = map[string]bool{"в": true, "во": true, "на": true, "к": true, "ко": true}
+
 // StubDateTimeParser — a tiny relative/absolute parser standing in for
 // `dateparser` until the i18n module lands. Handles "in Nh"/"in Nm"/"in Ns" and
 // "at HH:MM" / "HH:MM". The production path replaces this wholesale; the
@@ -210,18 +237,27 @@ func (StubDateTimeParser) Parse(_ context.Context, text string, now time.Time) (
 	// 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).
+	//
+	// "на" and "во" frame a spoken hour the same way, and until V-579 only "в"
+	// did: "в 9" set the reminder and "на 9" was not read at all.
 	for i := 0; i+1 < len(toks); i++ {
-		if toks[i] != "в" {
+		if !hourPrepositions[toks[i]] {
 			continue
 		}
 		t, ok := parseClock(toks[i+1], now)
 		if !ok {
 			continue
 		}
-		if i+2 < len(toks) {
-			t = applyRuQualifier(t, toks[i+2], now)
+		// The qualifier is looked for anywhere in the sentence, not only right
+		// after the hour. It arrives on its own turn when she asks which half of
+		// the day he meant, and "на 9" plus "вечера" is one time (V-579).
+		if qual := ruQualifierIn(toks); qual != "" {
+			t = applyRuQualifier(t, qual, now)
 		}
-		return t, true, nil
+		// A day word anywhere in the sentence moves the hour onto that day. This
+		// scan runs before the calendar one below, so without this "напомни
+		// завтра в 15:00" landed today and V-579 asks about exactly that gap.
+		return applyRuDayShift(t, toks, now), true, nil
 	}
 
 	// "через <N> <unit>" / "через <unit>" (bare = 1) / "через полчаса".
@@ -307,6 +343,10 @@ func sortDescByLen(ss []string) {
 // parseClock — "7", "7:30" → today at that time; if already past today, roll
 // to tomorrow (a "wake me 7" at 8pm fires tomorrow 7). Used by the stub scan.
 func parseClock(clock string, now time.Time) (time.Time, bool) {
+	// Speech arrives with its punctuation attached: "на 9." ends a sentence and
+	// still names nine o'clock (V-579). The colon is kept, since it is the one
+	// mark that is part of a clock.
+	clock = strings.Trim(clock, ".,!?;")
 	parts := strings.SplitN(clock, ":", 2)
 	h, err := strconv.Atoi(parts[0])
 	if err != nil || h < 0 || h > 23 {
@@ -376,10 +416,18 @@ func leadingWordNumber(s string) (int, string, bool) {
 }
 
 func unitToDuration(n int, unit string) (time.Duration, bool) {
-	switch unit {
-	case "h", "hour", "hours", "hr", "hrs":
+	// The hour and the minute nouns are closed classes with one home in the
+	// lexicon, and the list here used to be short of the oblique forms (V-609).
+	if lexicon.IsHourUnit(unit) {
 		return time.Duration(n) * time.Hour, true
-	case "m", "min", "mins", "minute", "minutes":
+	}
+	if lexicon.IsMinuteUnit(unit) {
+		return time.Duration(n) * time.Minute, true
+	}
+	switch unit {
+	case "h", "hr", "hrs":
+		return time.Duration(n) * time.Hour, true
+	case "m", "min", "mins":
 		return time.Duration(n) * time.Minute, true
 	case "s", "sec", "secs", "second", "seconds":
 		return time.Duration(n) * time.Second, true
@@ -387,10 +435,6 @@ func unitToDuration(n int, unit string) (time.Duration, bool) {
 	case "day", "days":
 		return time.Duration(n) * 24 * time.Hour, true
 	// Russian units (inflected forms)
-	case "час", "часа", "часов":
-		return time.Duration(n) * time.Hour, true
-	case "минута", "минуты", "минут":
-		return time.Duration(n) * time.Minute, true
 	case "день", "дня", "дней":
 		return time.Duration(n) * 24 * time.Hour, true
 	case "неделя", "недели", "недель":
@@ -416,18 +460,22 @@ func parseDurationValue(s string) (string, bool) {
 }
 
 // AnaphoraResolver resolves pronouns like "это", "он", "она" to the prior
-// turn's key entity. Returns a (key, value) pair the prior fact carried,
-// or ("", "", false) when no pronoun is detected.
+// turn's key entity. Returns the matched pronoun's class as ref, or
+// ("", false) when no pronoun is detected — the caller cross-references ref
+// against the prior turn's own slots, this type holds no state of its own.
 type AnaphoraResolver struct{}
 
 // Resolve checks if text contains an anaphoric reference to a prior turn's
 // entity. For MVP this handles the common Russian pronouns:
-//   - "это" / "этого" / "этому" / "этим" / "этом" → "this" (most common)
+//   - "это" / "этого" / "этому" / "этим" / "этом" / "эти" / "эта" → "this"
+//     (most common)
 //   - "он" / "его" / "ему" / "ним" → "he/it", masc
 //   - "она" / "её" / "ей" / "ней" → "she/it", fem
 //   - "оно" → "it", neuter
+//   - "тот" / "та" / "то" / "те" → "that"
+//   - "мой" and its declined forms → "mine"
 //
-// Returns the matching pronoun type for cross-referencing with prior slots.
+// Returns the matching pronoun class for cross-referencing with prior slots.
 func (AnaphoraResolver) Resolve(text string) (ref string, ok bool) {
 	s := strings.ToLower(strings.TrimSpace(text))
 	toks := strings.Fields(s)
@@ -480,6 +528,39 @@ func midnight(now time.Time, days int) time.Time {
 //
 // The date is recomputed rather than shifted, so an hour that parseClock
 // already pushed to tomorrow does not land two days out.
+// applyRuDayShift moves an hour onto the day the sentence names, if it names
+// one. The hour is kept exactly as read: the day word says which day and says
+// nothing about when in it.
+// ruQualifierIn returns the first part-of-day word in the sentence, or "".
+func ruQualifierIn(toks []string) string {
+	for _, tok := range toks {
+		switch cleanWord(tok) {
+		case "утра", "вечера", "дня", "ночи":
+			return cleanWord(tok)
+		}
+	}
+	return ""
+}
+
+func applyRuDayShift(t time.Time, toks []string, now time.Time) time.Time {
+	for _, tok := range toks {
+		days := 0
+		switch cleanWord(tok) {
+		case "сегодня":
+			days = 0
+		case "завтра":
+			days = 1
+		case "послезавтра":
+			days = 2
+		default:
+			continue
+		}
+		base := now.AddDate(0, 0, days)
+		return time.Date(base.Year(), base.Month(), base.Day(), t.Hour(), t.Minute(), 0, 0, now.Location())
+	}
+	return t
+}
+
 func applyRuQualifier(t time.Time, qualifier string, now time.Time) time.Time {
 	h := t.Hour()
 	switch strings.Trim(strings.ToLower(qualifier), ".,!?;:") {

internal/router/slots_ru_test.go

@@ -23,6 +23,24 @@ func TestDefaultFactParserRU(t *testing.T) {
 		{"немного отдохнул", "break", true},
 		{"поспал шесть часов", "sleep", true},
 		{"перезапусти nginx", "", false}, // an act, not a fact
+		// Inflections the substring stems caught and a lemma test must keep.
+		{"только что выпил кружку воды", "water", true},
+		{"воды попил наконец", "water", true},
+		{"пью воду", "water", true},
+		{"поужинал", "meal", true},
+		{"отметь что я позавтракал овсянкой", "meal", true},
+		{"сходил в душ", "shower", true},
+		{"отдыхал час", "break", true},
+		{"выспался", "sleep", true},
+		// Misfires the substring stems accepted. Rejecting them is the point of
+		// V-586: none of these is a fact about his day.
+		{"я пилот", "", false},
+		{"водитель приехал", "", false},
+		{"надо заводить машину", "", false},
+		{"у меня душа болит", "", false},
+		{"в комнате душно", "", false},
+		{"это была беда", "", false},
+		{"победа наша", "", false},
 	}
 	for _, c := range cases {
 		k, _, ok := p.Parse(c.utterance)

internal/router/stage0.go

@@ -292,16 +292,15 @@ func narrativeQueryBuild(m []string) (Decision, bool) {
 	if chatNarrativeTopics.MatchString(m[0]) {
 		return Decision{}, false
 	}
-	for _, t := range planTokens(topic) {
-		for _, v := range captureVerbs {
-			if t == v {
-				return Decision{}, false
-			}
+	toks := planTokens(topic)
+	for _, v := range captureVerbs {
+		if hasTok(toks, v) {
+			return Decision{}, false
 		}
-		for _, v := range entertainmentNouns {
-			if t == v {
-				return Decision{}, false
-			}
+	}
+	for _, v := range entertainmentNouns {
+		if hasTok(toks, v) {
+			return Decision{}, false
 		}
 	}
 	return Decision{

internal/router/timementions.go

@@ -3,6 +3,7 @@ package router
 import (
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/kami/maven/internal/lexicon"
 	"github.com/kami/maven/internal/morph"
@@ -81,6 +82,201 @@ func NamesADay(text string) bool {
 	return false
 }
 
+// NamesAnHour reports whether the sentence names a time of day or an interval
+// away from now: a written clock, a numeral, a half or quarter past, or one of
+// the words an interval is built from. A day word alone is not one — "завтра"
+// says which day and says nothing about when in it.
+//
+// It is the gate on the reminder's time slot (V-577, V-579). A time slot that
+// names no hour is never filled, it is asked about. Both parsers answer a bare
+// day word with that day at the current minute, so "что у меня сегодня?" set a
+// reminder at 01:28 and "на завтра" set one at 01:38 — the minute he happened
+// to be speaking, in a request that never named one. The stub answers with
+// midnight instead, which is a different invented hour and no better.
+//
+// Same discipline as MentionsTime above: every signal is a closed lexicon class
+// or a digit, so this reads data and decides nothing about meaning.
+func NamesAnHour(text string) bool {
+	toks := strings.Fields(strings.ToLower(text))
+	for i, raw := range toks {
+		tok := cleanWord(raw)
+		if isDigitClock(tok) || isAllDigits(tok) {
+			return true
+		}
+		if _, ok := numeralDigit(tok); ok {
+			return true
+		}
+		if hourMarkers[tok] {
+			return true
+		}
+		if _, _, ok := halfPastAt(toks, i); ok {
+			return true
+		}
+		if _, _, _, ok := quarterToAt(toks, i); ok {
+			return true
+		}
+	}
+	return false
+}
+
+// ResolvedTheHour reports whether a parse read the hour the sentence names,
+// rather than inheriting the clock it was handed as its relative base.
+//
+// It is the second half of the gate NamesAnHour opens (V-610). NamesAnHour asks
+// whether an hour was spoken and cannot ask whether it was read, so a
+// preposition the parser half knew wrote a reminder at 03:53 for "напомни
+// завтра к трём часам дня" and confirmed it as if it were the hour he said. A
+// wrong instant she states as fact is worse than a question, because he stops
+// thinking about it.
+//
+// The tell is the minute. A spoken hour lands on the hour, and the only three
+// shapes that name a minute of their own are a written clock, a half hour and a
+// quarter to. A parse that came back with any other minute took it from the
+// clock it was handed, whatever hour it put in front of it. An interval is
+// exempt, because it is measured from now and lands wherever the arithmetic
+// says.
+//
+// Comparing the whole instant to now would be the obvious test and it is the
+// wrong one: "напомни послезавтра в 12" resolves to 12:00 and the fixture's
+// reference clock is 12:00, so an hour he did say would read as an hour nobody
+// did.
+func ResolvedTheHour(text string, t time.Time) bool {
+	if !NamesAnHour(text) {
+		return false
+	}
+	if NamesAnInterval(text) || t.Minute() == 0 {
+		return true
+	}
+	return namesTheMinute(text)
+}
+
+// namesTheMinute reports whether the sentence says which minute of the hour it
+// means, in any of the three ways it can.
+func namesTheMinute(text string) bool {
+	toks := strings.Fields(strings.ToLower(text))
+	for i, raw := range toks {
+		if isDigitClock(cleanWord(raw)) {
+			return true
+		}
+		if _, _, ok := halfPastAt(toks, i); ok {
+			return true
+		}
+		if _, _, _, ok := quarterToAt(toks, i); ok {
+			return true
+		}
+	}
+	return false
+}
+
+// NamesAnInterval reports whether the sentence measures the time from now
+// instead of naming it: "через час", "через 10 минут", "in 30 minutes".
+//
+// An interval resolves to one instant, so it answers the hour and the day
+// together and nothing about it is ambiguous. Callers that ask which day or
+// which nine o'clock have to skip it (V-579).
+func NamesAnInterval(text string) bool {
+	for _, raw := range strings.Fields(strings.ToLower(text)) {
+		switch cleanWord(raw) {
+		case "через", "спустя", "in":
+			return true
+		}
+	}
+	return false
+}
+
+// HourIsAmbiguous reports whether the hour named could be either half of the
+// day: "в 3" is three in the afternoon or three at night, and only he knows
+// which (V-579, owner's rule of 2026-08-06).
+//
+// Three things settle it and any one is enough. A qualifier - "вечера", "pm",
+// "полдень" - says which half. A written clock says it by being written. An
+// hour above twelve says it by arithmetic. An interval names no hour at all.
+func HourIsAmbiguous(text string) bool {
+	if NamesAnInterval(text) {
+		return false
+	}
+	toks := strings.Fields(strings.ToLower(text))
+	for _, raw := range toks {
+		tok := cleanWord(raw)
+		if hourQualifiers[tok] || isDigitClock(tok) {
+			return false
+		}
+	}
+	for _, raw := range toks {
+		tok := cleanWord(raw)
+		d, ok := numeralDigit(tok)
+		if !ok && isAllDigits(tok) {
+			d, ok = tok, true
+		}
+		if !ok {
+			continue
+		}
+		n, err := strconv.Atoi(d)
+		if err == nil && n >= 1 && n <= 12 {
+			return true
+		}
+	}
+	return false
+}
+
+// hourQualifiers — the words that pin an hour to one half of the day. Closed,
+// and every member is a lexicon class or the two English markers.
+var hourQualifiers = buildHourQualifiers()
+
+func buildHourQualifiers() map[string]bool {
+	m := map[string]bool{
+		"утра": true, "вечера": true, "дня": true, "ночи": true,
+		"полдень": true, "полночь": true, "полудня": true,
+		"am": true, "pm": true, "noon": true, "midnight": true,
+	}
+	for _, w := range lexicon.PartsOfDay() {
+		m[w] = true
+	}
+	return m
+}
+
+func isAllDigits(tok string) bool {
+	if tok == "" {
+		return false
+	}
+	for _, r := range tok {
+		if r < '0' || r > '9' {
+			return false
+		}
+	}
+	return true
+}
+
+// hourMarkers — timeMarkers minus the day words and the weekdays, which name a
+// day and not an hour, and minus "сейчас", which IS the clock and so can never
+// be the evidence that the clock was meant.
+var hourMarkers = buildHourMarkers()
+
+func buildHourMarkers() map[string]bool {
+	m := map[string]bool{
+		"утра": true, "вечера": true, "дня": true, "ночи": true,
+		"через": true, "спустя": true, "полчаса": true,
+		"полдень": true, "полночь": true,
+		"am": true, "pm": true, "noon": true, "midnight": true, "in": true,
+	}
+	for _, w := range lexicon.HourUnits() {
+		m[w] = true
+	}
+	for _, w := range lexicon.MinuteUnits() {
+		m[w] = true
+	}
+	for _, w := range lexicon.PartsOfDay() {
+		m[w] = true
+	}
+	for _, w := range lexicon.HalfHourWords() {
+		m[w] = true
+	}
+	for w := range minutesTo {
+		m[w] = true
+	}
+	return m
+}
+
 // isMonth reports whether the token is a month name. The lexicon holds the
 // genitive, which is the form a spoken date uses: "10 июля".
 func isMonth(tok string) bool {
@@ -92,16 +288,34 @@ func isMonth(tok string) bool {
 	return false
 }
 
-// isWeekday reports whether the token is a day of the week in any case. The
-// lexicon lists the nominative, and "в пятницу" is what a reminder says, so the
-// match is by lemma — grammar is morph's job, not a second word list.
-func isWeekday(tok string) bool {
-	for i := 0; i < 7; i++ {
-		if morph.SameWord(tok, lexicon.Weekday(i)) {
-			return true
+// WeekdayIndex reports which day of the week a token names, in any case and in
+// either language, or false when it names none.
+//
+// One matcher for the whole daemon (V-581). Four files used to keep a weekday
+// list of their own and each one was short in a different direction: the habit
+// map had "воскресеньях" but no "средах", the plan refusal had "среду" but not
+// "среде", and cmd/mavend matched the STEM "сред" with strings.Contains, so
+// "среди" and "средство" read as Wednesday. The lexicon lists the nominative,
+// every Russian case lemmatises to it, and only English needs its forms written
+// out — the vendored dictionary is Russian and leaves "mondays" alone.
+func WeekdayIndex(tok string) (time.Weekday, bool) {
+	t := strings.ToLower(strings.TrimSpace(tok))
+	if n, ok := lexicon.WeekdayEnglish(t); ok {
+		return time.Weekday(n), true
+	}
+	for i, name := range lexicon.Weekdays() {
+		if morph.SameWord(t, name) {
+			return time.Weekday(i), true
 		}
 	}
-	return false
+	return 0, false
+}
+
+// isWeekday reports whether the token is a day of the week, when the caller
+// does not need to know which one.
+func isWeekday(tok string) bool {
+	_, ok := WeekdayIndex(tok)
+	return ok
 }
 
 // timeMarkers — the words that name a time on their own: the qualifiers that
@@ -113,11 +327,15 @@ var timeMarkers = buildTimeMarkers()
 func buildTimeMarkers() map[string]bool {
 	m := map[string]bool{
 		"утра": true, "вечера": true, "дня": true, "ночи": true,
-		"часа": true, "часов": true, "час": true, "часу": true,
-		"минут": true, "минуты": true, "минуту": true,
 		"через": true, "полчаса": true, "сейчас": true,
 		"am": true, "pm": true, "noon": true, "midnight": true,
 	}
+	for _, w := range lexicon.HourUnits() {
+		m[w] = true
+	}
+	for _, w := range lexicon.MinuteUnits() {
+		m[w] = true
+	}
 	for _, w := range lexicon.PartsOfDay() {
 		m[w] = true
 	}