weather: any city he names, not the six in a table (V-421)

The hand-written table understood "какая погода в X" for six values of X.
Ask about Kazan or Tbilisi and the city was dropped silently and answered for
the default location — a correct-sounding answer about the wrong place.

The table is gone. internal/weather already calls Open-Meteo's geocoding
endpoint on every lookup, so the place he named goes straight there and any
place it knows is a place he can ask about. He speaks the prepositional case,
so locationCandidates reverses the two endings that cover most of it: a final
"е" is a nominative "а" or nothing, a final "и" is a soft sign. A wrong
candidate finds no city; it never invents one.

A place the geocoder does not have now reads as "не знаю такого города"
rather than as a provider outage or, worse, as the default city's weather.
ErrLocationUnknown is what carries that apart.

"в" followed by a room or a day word is still the default location. Those
questions are answered by the house sensors and the calendar, not by
Open-Meteo, and they must not be read as a city.

cmd/mavend/actions_query.go

@@ -390,6 +390,11 @@ func (h *reactiveHandler) queryWeather(ctx context.Context, t *queryTurn) (strin
 	if errors.Is(err, weather.ErrNotConfigured) {
 		return "погода не настроена.", true
 	}
+	if errors.Is(err, weather.ErrLocationUnknown) {
+		// He named a place and the geocoder does not have it. Saying so beats
+		// reading out the default city's temperature (Vikunja #421).
+		return "не знаю такого города — " + loc + ".", true
+	}
 	if err != nil {
 		log.Printf("voice: weather: %v", err)
 		return "не получилось узнать погоду.", true
@@ -715,7 +720,7 @@ func (h *reactiveHandler) queryKiwix(ctx context.Context, t *queryTurn) (string,
 // not be sent to an upstream engine at all. The guard closes both holes with
 // the same test.
 func (h *reactiveHandler) queryPersonal(ctx context.Context, t *queryTurn) (string, bool) {
-	if !isPersonalQuery(t.dec.Utterance) {
+	if !h.isPersonalTurn(ctx, t) {
 		return "", false
 	}
 	log.Printf("voice: %q is about him and his own data did not answer it; not asking the world", t.dec.Utterance)
@@ -740,7 +745,9 @@ var personalMarkers = []*regexp.Regexp{
 	regexp.MustCompile(`(?i)\bdid\s+i\b`),
 }
 
-// isPersonalQuery reports whether the utterance asks about something of his.
+// isPersonalQuery — the offline floor under the boundary. Possession only, and
+// deliberately still narrow: it answers when there is no embedder to ask, and a
+// broad guess made blind is worse than a narrow one.
 func isPersonalQuery(utterance string) bool {
 	if utterance == "" {
 		return false
@@ -753,6 +760,23 @@ func isPersonalQuery(utterance string) bool {
 	return false
 }
 
+// isPersonalTurn — the boundary test. The seeds decide when the embedder is
+// there, which is every deployed box; the possession markers are the floor
+// underneath, for a handler with no embedder or a turn whose vector never got
+// computed. Same shape as the cascade: the better test leads, the offline one
+// always answers.
+func (h *reactiveHandler) isPersonalTurn(ctx context.Context, t *queryTurn) bool {
+	h.boundary.load(ctx, h.embedder)
+	if personal, world, ok := h.boundary.score(t.vec); ok {
+		if personal > world {
+			log.Printf("voice: %q scores personal %.4f vs world %.4f", t.dec.Utterance, personal, world)
+			return true
+		}
+		return false
+	}
+	return isPersonalQuery(t.dec.Utterance)
+}
+
 // queryGeneral — general knowledge, the last source before giving up. It always
 // claims: either a model answers, or Maven names the gap, or she says she does
 // not know.

cmd/mavend/actions_query_personal_test.go

@@ -19,6 +19,10 @@ func TestIsPersonalQuery(t *testing.T) {
 		"when is my meeting",
 		"do i have anything today",
 		"did i take my vitamins",
+		// Speech, but only the forms possession already covers ("did i").
+		// The verb forms the floor cannot see are the seeds' job, scored in
+		// TestONNXPersonalBoundary.
+		"what did i say about backups",
 	} {
 		if !isPersonalQuery(s) {
 			t.Errorf("isPersonalQuery(%q) = false, want true", s)
@@ -33,6 +37,10 @@ func TestIsPersonalQuery(t *testing.T) {
 		"почему небо синее",
 		"столица франции",
 		"how do i boil an egg",
+		// The floor is possession-only by design: a speech verb it cannot see
+		// passes here and is caught by the seeds instead.
+		"что я говорил про бэкапы?",
+		"как я говорил, почему небо синее",
 		"",
 	} {
 		if isPersonalQuery(s) {

cmd/mavend/capture.go

@@ -100,7 +100,7 @@ func (l llmCompleter) Complete(ctx context.Context, system, user string) (string
 // grammar, or a llama-server too old to honour one, gets the plain text it used
 // to get rather than an empty meeting summary.
 func unwrapSummary(raw string) string {
-	s := stripThink(strings.TrimSpace(raw))
+	s := phraser.StripThink(strings.TrimSpace(raw))
 	start := strings.Index(s, "{")
 	end := strings.LastIndex(s, "}")
 	if start < 0 || end <= start {

cmd/mavend/clarify.go

@@ -106,11 +106,11 @@ func trimClarifyExpired(s string) string {
 // out, and "" when nothing was parked. Call it right after
 // resolveClarifyAnswer: a live question is answered there, an expired one is
 // only reported here — the words themselves still go on to be routed fresh.
-func (h *reactiveHandler) clarifyExpiredNotice() string {
+func (h *reactiveHandler) clarifyExpiredNotice(ctx context.Context) string {
 	if h.clarifyStore == nil {
 		return ""
 	}
-	if !h.clarifyStore.TakeExpired(voiceDialogueID, h.now()) {
+	if !h.clarifyStore.TakeExpired(dialogueIDOf(ctx), h.now()) {
 		return ""
 	}
 	log.Printf("voice: clarify — parked question expired, telling him and routing the words fresh")
@@ -157,7 +157,7 @@ func clarifyQuestion(dec router.Decision) (dialogue.Slot, string, bool) {
 // 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.
-func (h *reactiveHandler) askClarify(dec router.Decision) (string, bool) {
+func (h *reactiveHandler) askClarify(ctx context.Context, dec router.Decision) (string, bool) {
 	if h.clarifyStore == nil {
 		return "", false
 	}
@@ -165,7 +165,7 @@ func (h *reactiveHandler) askClarify(dec router.Decision) (string, bool) {
 	if !ok {
 		return "", false
 	}
-	h.clarifyStore.Put(voiceDialogueID, &dialogue.PendingQuestion{
+	h.clarifyStore.Put(dialogueIDOf(ctx), &dialogue.PendingQuestion{
 		Intent:      dialogue.Intent(dec.Intent),
 		Slots:       toDialogueSlots(dec.Slots),
 		Missing:     []dialogue.Slot{slot},
@@ -192,7 +192,7 @@ func (h *reactiveHandler) resolveClarifyAnswer(ctx context.Context, text string)
 	if h.clarifyStore == nil {
 		return "", false
 	}
-	q := h.clarifyStore.Get(voiceDialogueID, h.now())
+	q := h.clarifyStore.Get(dialogueIDOf(ctx), h.now())
 	if q == nil {
 		return "", false
 	}
@@ -206,9 +206,9 @@ func (h *reactiveHandler) resolveClarifyAnswer(ctx context.Context, text string)
 	// 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(q, merged, text), true
+		return h.reaskOrGiveUp(ctx, q, merged, text), true
 	}
-	h.clarifyStore.Delete(voiceDialogueID)
+	h.clarifyStore.Delete(dialogueIDOf(ctx))
 
 	// One gap filled is not the same as a complete request. askClarify parks
 	// only the first gap, because one question per turn is the rule, but a
@@ -217,7 +217,7 @@ func (h *reactiveHandler) resolveClarifyAnswer(ctx context.Context, text string)
 	// a reminder with no time, which answered "не получилось разобрать время
 	// напоминания." — an error for a request she never finished asking about.
 	// Re-enter the loop instead, one question at a time as before.
-	if reply, asked := h.askRemainingGap(q, intent, merged); asked {
+	if reply, asked := h.askRemainingGap(ctx, q, intent, merged); asked {
 		return reply, true
 	}
 
@@ -261,7 +261,7 @@ func foldAnswerIntoUtterance(utterance, subject string) string {
 // The attempt budget is shared with the re-ask path on purpose. A second gap
 // 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(q *dialogue.PendingQuestion, intent router.Intent, merged dialogue.Slots) (string, bool) {
+func (h *reactiveHandler) askRemainingGap(ctx context.Context, q *dialogue.PendingQuestion, intent router.Intent, merged dialogue.Slots) (string, bool) {
 	remaining := dialogue.StillMissing(wantedSlots[intent], merged)
 	if len(remaining) == 0 {
 		return "", false
@@ -270,7 +270,7 @@ func (h *reactiveHandler) askRemainingGap(q *dialogue.PendingQuestion, intent ro
 	if !ok || !q.CanAsk() {
 		return "", false
 	}
-	h.clarifyStore.Put(voiceDialogueID, &dialogue.PendingQuestion{
+	h.clarifyStore.Put(dialogueIDOf(ctx), &dialogue.PendingQuestion{
 		Intent:      q.Intent,
 		Slots:       merged,
 		Missing:     []dialogue.Slot{remaining[0]},
@@ -287,13 +287,13 @@ func (h *reactiveHandler) askRemainingGap(q *dialogue.PendingQuestion, intent ro
 // 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(q *dialogue.PendingQuestion, merged dialogue.Slots, text string) string {
+func (h *reactiveHandler) reaskOrGiveUp(ctx context.Context, q *dialogue.PendingQuestion, merged dialogue.Slots, text string) string {
 	question := ""
 	if len(q.Missing) > 0 {
 		question = clarifyQuestions[q.Missing[0]]
 	}
 	if question == "" || !q.CanAsk() {
-		h.clarifyStore.Delete(voiceDialogueID)
+		h.clarifyStore.Delete(dialogueIDOf(ctx))
 		log.Printf("voice: clarify — gave up on %v after %d question(s), answer was %q", q.Missing, q.Attempts, text)
 		return clarifyGaveUp
 	}
@@ -302,7 +302,7 @@ func (h *reactiveHandler) reaskOrGiveUp(q *dialogue.PendingQuestion, merged dial
 	q.Slots = merged
 	q.Attempts++
 	q.Asked = h.now()
-	h.clarifyStore.Put(voiceDialogueID, q)
+	h.clarifyStore.Put(dialogueIDOf(ctx), q)
 	log.Printf("voice: clarify — answer %q did not fill %v, asking again (attempt %d)", text, q.Missing, q.Attempts)
 	return question
 }

cmd/mavend/clarify_test.go

@@ -81,7 +81,7 @@ func TestClarifyReminderCompletesOnAnswer(t *testing.T) {
 	ctx := context.Background()
 	h, st, _ := newClarifyHandler(t)
 
-	question, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме"))
+	question, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме"))
 	if !asked || question != "Когда?" {
 		t.Fatalf("expected the time question, got %q asked=%v", question, asked)
 	}
@@ -112,7 +112,7 @@ func TestClarifyFactCompletesOnAnswer(t *testing.T) {
 	ctx := context.Background()
 	h, st, _ := newClarifyHandler(t)
 
-	if _, asked := h.askClarify(clarifyDec(router.IntentFact, router.Slots{Text: "запиши"}, "запиши")); !asked {
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentFact, router.Slots{Text: "запиши"}, "запиши")); !asked {
 		t.Fatal("a fact with no key should be asked about")
 	}
 	if reply, handled := h.resolveClarifyAnswer(ctx, "пил воду"); !handled || reply == clarifyGaveUp {
@@ -128,7 +128,7 @@ func TestClarifyAnswerAfterTTLIsANewRequest(t *testing.T) {
 	ctx := context.Background()
 	h, st, now := newClarifyHandler(t)
 
-	if _, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
 		t.Fatal("expected a question")
 	}
 	*now = now.Add(clarifyTTL + time.Second)
@@ -147,7 +147,7 @@ func TestClarifyAsksThreeTimesThenSaysSo(t *testing.T) {
 	ctx := context.Background()
 	h, st, _ := newClarifyHandler(t)
 
-	if _, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
 		t.Fatal("expected a first question")
 	}
 	// Two more unclear answers ⇒ two more questions (3 asks in total).
@@ -185,7 +185,7 @@ func TestClarifyMaxAttemptsIsConfigurable(t *testing.T) {
 	h, _, _ := newClarifyHandler(t)
 	h.clarifyMaxAttempts = 1
 
-	if _, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
 		t.Fatal("expected a question")
 	}
 	if reply, handled := h.resolveClarifyAnswer(ctx, "ну не знаю"); !handled || reply != clarifyGaveUp {
@@ -199,7 +199,7 @@ func TestClarifyRestatedAnswerWins(t *testing.T) {
 	ctx := context.Background()
 	h, st, _ := newClarifyHandler(t)
 
-	if _, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме")); !asked {
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме")); !asked {
 		t.Fatal("expected a question")
 	}
 	// First answer parses, but re-park it by hand as if she had asked again:
@@ -232,7 +232,7 @@ func TestClarifiedActOffAllowlistIsStillRefused(t *testing.T) {
 	h, st, _ := newClarifyHandler(t)
 	marker := filepath.Join(t.TempDir(), "not-allowed-ran")
 
-	if _, asked := h.askClarify(clarifyDec(router.IntentAct, router.Slots{Text: "сделай это"}, "сделай это")); !asked {
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentAct, router.Slots{Text: "сделай это"}, "сделай это")); !asked {
 		t.Fatal("an act with no fn should be asked about")
 	}
 	reply, handled := h.resolveClarifyAnswer(ctx, "rm "+marker)
@@ -260,7 +260,7 @@ func TestClarifiedDestructiveActStillNeedsConfirm(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, asked := h.askClarify(clarifyDec(router.IntentAct, router.Slots{Text: "сделай это"}, "сделай это")); !asked {
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentAct, router.Slots{Text: "сделай это"}, "сделай это")); !asked {
 		t.Fatal("expected a question")
 	}
 	reply, handled := h.resolveClarifyAnswer(ctx, "delete_backups")
@@ -284,7 +284,7 @@ func TestNoQuestionWhenNothingIsMissing(t *testing.T) {
 		clarifyDec(router.IntentQuery, router.Slots{Text: "ммм"}, "ммм"),
 		clarifyDec(router.IntentNote, router.Slots{Text: "..."}, "..."),
 	} {
-		if question, asked := h.askClarify(dec); asked {
+		if question, asked := h.askClarify(context.Background(), dec); asked {
 			t.Fatalf("intent %s should keep the canned reply, got %q", dec.Intent, question)
 		}
 	}
@@ -296,29 +296,29 @@ func TestNoQuestionWhenNothingIsMissing(t *testing.T) {
 // TestClarifyExpiryIsAnnouncedAndWordsStillRoute — his answer lands after the
 // TTL: she must say the old request is gone AND still answer the new words.
 func TestClarifyExpiryIsAnnouncedAndWordsStillRoute(t *testing.T) {
-	ctx := context.Background()
+	ctx := withDialogueID(context.Background(), dialogueIDFor(sourceText, ""))
 	h, _, now := newClarifyHandler(t)
 	emb := router.NewHashEmbedder(1024)
 	h.embedder = emb
 	h.router = buildRouter(emb, h.matcher, 0.55, nil)
 
-	if _, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
 		t.Fatal("expected a question")
 	}
 	*now = now.Add(clarifyTTL + time.Second)
 
-	reply := h.handleText(ctx, "как дела")
+	reply := h.handleText(ctx, "", "как дела")
 	if !isClarifyExpired(reply) {
 		t.Fatalf("expired question must be announced first, got %q", reply)
 	}
 	if trimClarifyExpired(reply) == "" {
 		t.Fatalf("the new words must still be answered, got only the notice: %q", reply)
 	}
-	if h.clarifyStore.Get(voiceDialogueID, h.now()) != nil {
+	if h.clarifyStore.Get(textDialogueID, h.now()) != nil {
 		t.Fatal("the expired question must be gone")
 	}
 	// The notice is said once, not on every later utterance.
-	if reply := h.handleText(ctx, "как дела"); isClarifyExpired(reply) {
+	if reply := h.handleText(ctx, "", "как дела"); isClarifyExpired(reply) {
 		t.Fatalf("notice repeated on a later turn: %q", reply)
 	}
 }
@@ -340,7 +340,7 @@ func TestClarifyAsksAboutTheSecondGapToo(t *testing.T) {
 	ctx := context.Background()
 	h, st, _ := newClarifyHandler(t)
 
-	question, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{}, "напомни"))
+	question, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{}, "напомни"))
 	if !asked || question != "О чём напомнить?" {
 		t.Fatalf("expected the subject question, got %q asked=%v", question, asked)
 	}
@@ -380,7 +380,7 @@ func TestClarifySecondGapRespectsTheAttemptCap(t *testing.T) {
 	h, _, _ := newClarifyHandler(t)
 	h.clarifyMaxAttempts = 1
 
-	if _, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{}, "напомни")); !asked {
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{}, "напомни")); !asked {
 		t.Fatal("expected the subject question")
 	}
 	reply, handled := h.resolveClarifyAnswer(ctx, "позвонить маме")
@@ -440,10 +440,10 @@ func TestClarifyProseHoldsThePersona(t *testing.T) {
 // The confirm turn used to return before the notice was even computed, so he
 // answered the confirm and never heard that the older request was let go.
 func TestExpiryNoticeSurvivesAConfirmTurn(t *testing.T) {
-	ctx := context.Background()
+	ctx := withDialogueID(context.Background(), dialogueIDFor(sourceText, ""))
 	h, _, now := newClarifyHandler(t)
 
-	if _, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
 		t.Fatal("expected a question")
 	}
 	// A confirm parked with a longer life than the question, so only the
@@ -451,7 +451,7 @@ func TestExpiryNoticeSurvivesAConfirmTurn(t *testing.T) {
 	h.pending = &pendingAct{fn: "delete_backups", phrase: "удалить бэкапы", expiry: now.Add(time.Hour)}
 	*now = now.Add(clarifyTTL + time.Second)
 
-	reply := h.handleText(ctx, "нет")
+	reply := h.handleText(ctx, "", "нет")
 	if !isClarifyExpired(reply) {
 		t.Fatalf("the expired question must be announced on a confirm turn too, got %q", reply)
 	}
@@ -461,7 +461,72 @@ func TestExpiryNoticeSurvivesAConfirmTurn(t *testing.T) {
 	if h.pending != nil {
 		t.Fatal("the confirm must still have been consumed")
 	}
-	if h.clarifyStore.Get(voiceDialogueID, h.now()) != nil {
+	if h.clarifyStore.Get(textDialogueID, h.now()) != nil {
 		t.Fatal("the expired question must be gone")
 	}
 }
+
+// The other half of the subject question: his answer must fill the empty slot,
+// not replace the request. Slots.Text used to be the whole raw utterance for
+// every intent, so the branch that fills a text slot could only ever overwrite
+// (Vikunja #383). Here the parked request holds the hour and the answer holds
+// what to say at it, and the reminder that lands has both.
+func TestClarifySubjectAnswerFillsRatherThanClobbers(t *testing.T) {
+	ctx := context.Background()
+	h, st, _ := newClarifyHandler(t)
+	at := h.now().Add(2 * time.Hour)
+
+	question, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder,
+		router.Slots{Time: at, HasTime: true}, "напомни в 11"))
+	if !asked || question != "О чём напомнить?" {
+		t.Fatalf("expected the subject question, got %q asked=%v", question, asked)
+	}
+
+	reply, handled := h.resolveClarifyAnswer(ctx, "позвонить маме")
+	if !handled {
+		t.Fatal("the answer to an open question must be consumed as an answer")
+	}
+	if reply == clarifyGaveUp {
+		t.Fatalf("a good answer must not drop the request: %q", reply)
+	}
+
+	reminders, err := st.DueReminders(ctx, h.now().Add(48*time.Hour))
+	if err != nil || len(reminders) != 1 {
+		t.Fatalf("clarified reminder was not created: reminders=%v err=%v", reminders, err)
+	}
+	if !strings.Contains(reminders[0].Payload, "маме") {
+		t.Fatalf("the answer never reached the reminder: %q", reminders[0].Payload)
+	}
+	if !strings.Contains(reminders[0].Payload, "11") {
+		t.Fatalf("the answer clobbered the original request: %q", reminders[0].Payload)
+	}
+}
+
+// TestClarifyIsPerConversation — the parked question belongs to the reach that
+// was asked. Before this the clarify store had one global key, so a question
+// asked in the web chat and never answered captured the next utterance from
+// telegram, or from the mic, and answered it against a request the speaker had
+// never made (Vikunja #466).
+func TestClarifyIsPerConversation(t *testing.T) {
+	h, _, _ := newClarifyHandler(t)
+	web := withDialogueID(context.Background(), dialogueIDFor(sourceText, "web"))
+	telegram := withDialogueID(context.Background(), dialogueIDFor(sourceText, "telegram:42"))
+
+	if _, asked := h.askClarify(web, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
+		t.Fatal("expected a question on the web conversation")
+	}
+	if _, handled := h.resolveClarifyAnswer(telegram, "в 11:00"); handled {
+		t.Fatal("a question asked on the web must not eat a telegram utterance")
+	}
+	if _, handled := h.resolveClarifyAnswer(voiceCtx(), "в 11:00"); handled {
+		t.Fatal("a question asked on the web must not eat what he says at the mic")
+	}
+	if reply, handled := h.resolveClarifyAnswer(web, "в 11:00"); !handled || reply == clarifyGaveUp {
+		t.Fatalf("the asker's own answer must land, handled=%v reply=%q", handled, reply)
+	}
+}
+
+// voiceCtx — the mic's conversation, which carries no id of its own.
+func voiceCtx() context.Context {
+	return withDialogueID(context.Background(), dialogueIDFor(sourceVoice, ""))
+}

cmd/mavend/followup.go

@@ -1,17 +1,64 @@
 package main
 
 import (
+	"context"
 	"time"
 
 	"github.com/kami/maven/internal/dialogue"
 	"github.com/kami/maven/internal/router"
 )
 
-// voiceDialogueID — the single dialogue-session key. This is a single-user box
-// (ponytail), so one slot suffices; a second speaker would need per-speaker ids,
-// which waits on voice-print attribution (see PROGRESS multi-user deferral).
+// voiceDialogueID — the dialogue-session key for the microphone, and the
+// clarify key for it too. This is a single-user box (ponytail), so one slot
+// suffices; a second speaker would need per-speaker ids, which waits on
+// voice-print attribution (see PROGRESS multi-user deferral).
 const voiceDialogueID = "voice"
 
+// textDialogueID — the clarify key for a text turn that named no conversation.
+// Separate from the mic: an old client that sends no id still must not answer
+// a question she asked out loud.
+const textDialogueID = "text"
+
+// dialogueKey — the context key carrying the id of the conversation this turn
+// belongs to. It rides the context rather than a parameter for the same reason
+// the correlation id does: every step of the turn needs it, most of them only
+// to hand to the next one, and threading it by hand would put it in six
+// clarify signatures that have nothing else to say about it.
+type dialogueKey struct{}
+
+// dialogueIDFor builds the id a turn is held under: the conversation the reach
+// named, qualified by the tap it arrived on, or the tap's own fallback when it
+// named none.
+//
+// A parked clarifying question used to be held under voiceDialogueID no matter
+// where the turn came from, so one unanswerable question captured the next
+// three utterances from anywhere. Three independent curl sessions fed a
+// capture attempt that had already failed, and a reminder among them was lost
+// (Vikunja #466).
+func dialogueIDFor(src turnSource, conversation string) string {
+	if conversation != "" {
+		return string(src) + ":" + conversation
+	}
+	if src == sourceVoice {
+		return voiceDialogueID
+	}
+	return textDialogueID
+}
+
+// withDialogueID tags a turn with that id.
+func withDialogueID(ctx context.Context, id string) context.Context {
+	return context.WithValue(ctx, dialogueKey{}, id)
+}
+
+// dialogueIDOf reads it back. Falls back to the microphone's slot, which is
+// what an unthreaded caller — a test, an internal replay — gets.
+func dialogueIDOf(ctx context.Context) string {
+	if id, ok := ctx.Value(dialogueKey{}).(string); ok && id != "" {
+		return id
+	}
+	return voiceDialogueID
+}
+
 // toDialogueSlots and applyDialogueSlots are the only bridge between
 // router.Slots and dialogue.Slots. dialogue must not import router (import
 // cycle), so the two structs are hand-kept copies and every field has to be

cmd/mavend/main.go

@@ -251,6 +251,7 @@ func run(args []string) error {
 				Listen:       cfg.Phraser.Listen,
 				NGpuLayers:   cfg.Phraser.NGpuLayers,
 				NCtx:         cfg.Phraser.NCtx,
+				CacheRAMMiB:  cacheRAMMiB(cfg.Phraser.CacheRAMMiB),
 				Timeout:      time.Duration(cfg.Phraser.Timeout),
 				LLMNudges:    cfg.Phraser.LLMNudges,
 				ContextBlock: contextBlockFn(cfg, time.Now),
@@ -525,6 +526,7 @@ func run(args []string) error {
 					Listen:       cfg.Phraser.Listen,
 					NGpuLayers:   cfg.Phraser.NGpuLayers,
 					NCtx:         cfg.Phraser.NCtx,
+					CacheRAMMiB:  cacheRAMMiB(cfg.Phraser.CacheRAMMiB),
 					Timeout:      time.Duration(cfg.Phraser.Timeout),
 					LLMNudges:    cfg.Phraser.LLMNudges,
 					ContextBlock: contextBlockFn(cfg, time.Now),
@@ -788,6 +790,22 @@ func personaFacts(cfg *config.Config) persona.Facts {
 	return f
 }
 
+// cacheRAMMiB resolves phraser.cache_ram_mib into the phraser's field. Unset
+// means 512 MiB and not "whatever the server does", because the server's own
+// default is 8 GiB of prompt cache and that is what put 7.9 GB of RSS and half
+// a gigabyte of swap on homesrv for a 1.1 GB model. A negative value is the
+// deliberate opt-out: no flag is passed, the server's default applies, and the
+// operator owns the consequence.
+func cacheRAMMiB(configured int) int {
+	if configured == 0 {
+		return 512
+	}
+	if configured < 0 {
+		return 0
+	}
+	return configured
+}
+
 // contextBlockFn returns the per-turn renderer of the shared context block.
 // Per turn, not once at startup, because the block states the current time.
 func contextBlockFn(cfg *config.Config, now func() time.Time) func() string {

cmd/mavend/morning_nudge_test.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/kami/maven/internal/morning"
+)
+
+// TestMorningNudgeBodySeparatesOptional — the one message a routine is allowed
+// per day says what was not done, then what he could still do (Vikunja #473).
+func TestMorningNudgeBodySeparatesOptional(t *testing.T) {
+	cand := morning.Candidate{
+		Routine: morning.Routine{Name: "утро"},
+		Missing: []morning.Item{
+			{Key: "meds", Label: "таблетки"},
+			{Key: "stretch", Label: "растяжка", Optional: true},
+		},
+	}
+	body := morningNudgeBody(cand)
+	if !strings.Contains(body, "не сделано — таблетки") {
+		t.Fatalf("the required item must be named as not done: %q", body)
+	}
+	if !strings.Contains(body, "если будет время — растяжка") {
+		t.Fatalf("the optional item must read softer: %q", body)
+	}
+	if strings.Contains(body, "не сделано — таблетки, растяжка") {
+		t.Fatalf("optional must not be folded into the required list: %q", body)
+	}
+
+	// Nothing optional missing: the sentence is what it always was.
+	only := morning.Candidate{
+		Routine: morning.Routine{Name: "утро"},
+		Missing: []morning.Item{{Key: "meds", Label: "таблетки"}},
+	}
+	if got, want := morningNudgeBody(only), "утро: не сделано — таблетки"; got != want {
+		t.Fatalf("morningNudgeBody = %q, want %q", got, want)
+	}
+}

cmd/mavend/personalboundary.go

@@ -0,0 +1,154 @@
+package main
+
+import (
+	"context"
+	"log"
+	"math"
+	"sync"
+
+	"github.com/kami/maven/internal/router"
+)
+
+// The personal boundary decides one thing: is this question about him. It used
+// to decide it by matching possession words, and that was the whole defect
+// behind Vikunja #495. "что я говорил про бэкапы?" is his data by definition —
+// nothing outside the box has ever heard him say anything — and it carried no
+// possession word, so it walked past the boundary into SearXNG and came back
+// answered out of a Habr article about somebody else's backups.
+//
+// The first fix was one more marker class, `я говорил|сказал|писал|…`, plus a
+// carve-out so "как я говорил, почему небо синее" stayed a world question. Both
+// halves are a lexicon, and a lexicon is the wrong instrument here: Russian
+// gives every verb a dozen surface forms, the preamble list has no end, and
+// every utterance the list misses is one that reaches the world. It also drifts
+// silently — a missing verb looks exactly like no bug.
+//
+// So the boundary asks the embedder instead. Two frozen seed sets — questions
+// about him, questions about the world — are embedded once, and the turn's own
+// query vector, already computed by queryEmbed upstream, is scored against
+// both. Nearest side wins. Word order, verb form and unseen phrasing stop
+// mattering, which is exactly what a lexicon could not do.
+//
+// Measured 03-08-2026 against multilingual-e5-small on 19 held-out utterances,
+// none of them a seed: 19 right (TestONNXPersonalBoundary). A 20th, "as i said,
+// what is the population of india", missed by +0.008 during the first pass and
+// is a world seed now, which is why it is not in the held-out set. True
+// positives clear the world side by +0.014 to +0.089 and the nearest true
+// negative sits at -0.005, so the gate is the sign of the difference and
+// nothing tighter: the margins are too thin to justify a threshold, and the
+// asymmetry favours claiming anyway. A false claim costs one honest "не знаю";
+// a false pass sends his life to an upstream engine.
+//
+// The embedder is the one model CLAUDE.md pins to homesrv permanently, and it
+// is what makes this affordable: no llama-server call, no network, one cosine
+// per seed against a vector the turn already has.
+
+// personalSeeds — questions about him. Frozen: they are scoring data, so
+// editing one moves the boundary and must be re-measured, not eyeballed. Cover
+// both classes the boundary owns, possession and first-person speech, in both
+// languages.
+var personalSeeds = []string{
+	"что я говорил про это",
+	"я тебе рассказывал об этом?",
+	"что я записал про врача",
+	"я упоминал эту тему?",
+	"что у меня сегодня",
+	"когда моя встреча",
+	"what did i say about this",
+	"did i mention this to you",
+}
+
+// worldSeeds — questions the world can answer, including the two shapes that
+// look personal and are not: a first-person preamble on a world question ("как
+// я говорил, ..."), and first person without possession ("что я могу
+// посмотреть вечером"). Refusing those is the opposite mistake and the older
+// comment on personalMarkers already named it.
+var worldSeeds = []string{
+	"почему небо синее",
+	"какая столица франции",
+	"как сварить борщ",
+	"кто написал эту книгу",
+	"what is the capital of france",
+	"how do i boil an egg",
+	"как я говорил, почему небо синее",
+	"as i said, why is the sky blue",
+	"as i said, what is the population of india",
+	"что я могу посмотреть вечером",
+	"что мне почитать про историю",
+	"что я должен знать про питон",
+	"what can i watch tonight",
+}
+
+// personalBoundary holds the embedded seeds. Zero value is usable and means
+// "not loaded yet"; a handler built without an embedder never loads and the
+// boundary falls back to personalMarkers.
+type personalBoundary struct {
+	once     sync.Once
+	personal [][]float32
+	world    [][]float32
+	loaded   bool
+}
+
+// load embeds both seed sets, once per process. Seeds are embedded on the QUERY
+// side, like the utterance they are compared with — a question against a
+// question. Mixing sides would measure the e5 prefix, not the meaning.
+func (b *personalBoundary) load(ctx context.Context, emb router.Embedder) {
+	b.once.Do(func() {
+		if emb == nil {
+			return
+		}
+		embedAll := func(ss []string) [][]float32 {
+			out := make([][]float32, 0, len(ss))
+			for _, s := range ss {
+				v, err := router.EmbedQuery(ctx, emb, s)
+				if err != nil {
+					log.Printf("voice: personal boundary seeds unavailable (%v); falling back to possession markers", err)
+					return nil
+				}
+				out = append(out, v)
+			}
+			return out
+		}
+		p, w := embedAll(personalSeeds), embedAll(worldSeeds)
+		if p == nil || w == nil {
+			return
+		}
+		b.personal, b.world, b.loaded = p, w, true
+	})
+}
+
+// score returns the best similarity to each side. ok is false when the seeds
+// are not loaded, which is the caller's signal to use the markers instead.
+func (b *personalBoundary) score(vec []float32) (personal, world float64, ok bool) {
+	if !b.loaded || len(vec) == 0 {
+		return 0, 0, false
+	}
+	best := func(seeds [][]float32) float64 {
+		m := -1.0
+		for _, s := range seeds {
+			if c := cosine(vec, s); c > m {
+				m = c
+			}
+		}
+		return m
+	}
+	return best(b.personal), best(b.world), true
+}
+
+// cosine — same math as internal/router and internal/memory, small enough that
+// importing one of them for it would be the larger coupling.
+func cosine(a, b []float32) float64 {
+	if len(a) != len(b) {
+		return 0
+	}
+	var dot, na, nb float64
+	for i := range a {
+		dot += float64(a[i]) * float64(b[i])
+		na += float64(a[i]) * float64(a[i])
+		nb += float64(b[i]) * float64(b[i])
+	}
+	if na == 0 || nb == 0 {
+		return 0
+	}
+	return dot / (math.Sqrt(na) * math.Sqrt(nb))
+}

cmd/mavend/personalboundary_test.go

@@ -0,0 +1,94 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/kami/maven/internal/router"
+)
+
+// A handler with no embedder never loads the seeds, so the boundary falls back
+// to the possession markers. That is the offline floor and it must keep working
+// — an embedder that fails to load must not open the boundary.
+func TestBoundaryFallsBackToMarkersWithNoEmbedder(t *testing.T) {
+	h := personalHandler()
+	if !h.isPersonalTurn(context.Background(), &queryTurn{
+		dec: router.Decision{Utterance: "во сколько у меня встреча"},
+	}) {
+		t.Error("no embedder: a possession question must still be personal")
+	}
+	if h.isPersonalTurn(context.Background(), &queryTurn{
+		dec: router.Decision{Utterance: "почему небо синее"},
+	}) {
+		t.Error("no embedder: a world question must still pass")
+	}
+}
+
+// TestONNXPersonalBoundary — the number that matters, scored against the
+// embedder homesrv actually runs. Opt-in via MAVEN_ONNX_LIB, exactly like
+// TestONNXRecall in internal/memory/recalleval.
+//
+// Every case here is held out: none of these strings is a seed. The #495
+// regression is the first row — "что я говорил про бэкапы?" reached SearXNG and
+// was answered from a Habr article, and no possession word appears in it.
+func TestONNXPersonalBoundary(t *testing.T) {
+	lib := os.Getenv("MAVEN_ONNX_LIB")
+	if lib == "" {
+		t.Skip("MAVEN_ONNX_LIB unset — see AGENTS.md § Embedder model for intent routing")
+	}
+	dir := filepath.Join("../..", "models/embedder/multilingual-e5-small")
+	emb, err := router.NewONNXEmbedder(filepath.Join(dir, "model_quantized.onnx"), filepath.Join(dir, "tokenizer.json"), lib)
+	if err != nil {
+		t.Skipf("onnx embedder unavailable: %v", err)
+	}
+	defer emb.Close()
+
+	cases := []struct {
+		utterance string
+		personal  bool
+	}{
+		{"что я говорил про бэкапы?", true},
+		{"что я сказал вчера про отпуск", true},
+		{"я писал что-нибудь про сервер", true},
+		{"я упоминал про конференцию?", true},
+		{"что я отмечал по поводу переезда", true},
+		{"я рассказывал тебе про новую работу?", true},
+		{"во сколько у меня встреча", true},
+		{"когда мой следующий отпуск", true},
+		{"what did i say about backups", true},
+		{"did i tell you about the doctor", true},
+		{"как я говорил, почему небо синее", false},
+		{"как уже я говорил, какая столица франции", false},
+		{"почему трава зелёная", false},
+		{"столица франции", false},
+		{"как мне сварить борщ", false},
+		{"что мне посмотреть вечером", false},
+		{"я хочу узнать про рим", false},
+		{"кто такой гагарин", false},
+		{"how do i boil an egg", false},
+	}
+
+	h := &reactiveHandler{embedder: emb}
+	ctx := context.Background()
+	wrong := 0
+	for _, c := range cases {
+		vec, err := router.EmbedQuery(ctx, emb, c.utterance)
+		if err != nil {
+			t.Fatalf("embed %q: %v", c.utterance, err)
+		}
+		turn := &queryTurn{dec: router.Decision{Utterance: c.utterance}, vec: vec}
+		got := h.isPersonalTurn(ctx, turn)
+		p, w, ok := h.boundary.score(vec)
+		if !ok {
+			t.Fatal("seeds did not load with a working embedder")
+		}
+		if got != c.personal {
+			wrong++
+			t.Errorf("%q: personal=%v want %v (personal %.4f world %.4f)", c.utterance, got, c.personal, p, w)
+		}
+		t.Logf("personal=%-5v personal %.4f world %.4f delta %+.4f  %s", got, p, w, p-w, c.utterance)
+	}
+	t.Logf("personal boundary: %d/%d held-out utterances correct", len(cases)-wrong, len(cases))
+}

cmd/mavend/reactive_notes_test.go

@@ -2,12 +2,14 @@ package main
 
 import (
 	"context"
+	"strings"
 	"testing"
 	"time"
 
 	"github.com/kami/maven/internal/ipc"
 	"github.com/kami/maven/internal/memory"
 	"github.com/kami/maven/internal/router"
+	"github.com/kami/maven/internal/store"
 	"github.com/kami/maven/internal/tool"
 	"github.com/kami/maven/internal/voice"
 )
@@ -85,3 +87,38 @@ func TestReactiveNotesReminders(t *testing.T) {
 		}
 	})
 }
+
+// TestSpokenTaskCaptureFilesATask — the whole path, from the utterance to the
+// task table. It went dead when the router started claiming the marker as an
+// act: capture rides the note intent, so nothing below actionNote was ever
+// reached and every capture answered "Что сделать?" (Vikunja #467).
+func TestSpokenTaskCaptureFilesATask(t *testing.T) {
+	ctx := context.Background()
+	st := newTestStore(t)
+	api := ipc.NewStoreAPI(st)
+	now := time.Now()
+	emb := router.NewHashEmbedder(1024)
+	matcher := tool.NewMatcher(api)
+	h := &reactiveHandler{
+		api:       api,
+		embedder:  emb,
+		router:    buildRouter(emb, matcher, 0.55, nil),
+		replier:   voice.NewStubReplier(),
+		now:       func() time.Time { return now },
+		memStore:  memory.NewInMemoryStore(),
+		dataStore: st,
+	}
+
+	reply := h.handleText(ctx, "web", "добавь в задачи купить молоко")
+	if !strings.Contains(reply, "купить молоко") {
+		t.Fatalf("capture did not claim the turn: %q", reply)
+	}
+	open, err := st.ListTasks(ctx, store.TaskOpen)
+	if err != nil || len(open) != 1 {
+		t.Fatalf("task was not filed: tasks=%v err=%v", open, err)
+	}
+	// The words he said, not the model's rewrite of them.
+	if open[0].Text != "купить молоко" {
+		t.Fatalf("task text was rewritten: %q", open[0].Text)
+	}
+}

cmd/mavend/replier_llm.go

@@ -2,122 +2,33 @@ package main
 
 import (
 	"context"
-	"encoding/json"
-	"strings"
-	"time"
 
-	"github.com/kami/maven/internal/llm"
-	"github.com/kami/maven/internal/persona"
 	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/voice"
 )
 
-// completer is the LLM seam for the replier (subset of router.Completer).
-// *llm.Client satisfies it.
-type completer interface {
-	Complete(ctx context.Context, r llm.Req) (string, error)
-}
-
-// llmReplier phrases reactive confirmations with the resident model
-// (Qwen3-1.7B). Stub is the
-// floor on any error (offline-safe). Maven speaks as "she", feminine RU.
+// llmReplier is the daemon-side wiring around phraser.Replier: it owns the
+// deterministic floor, and nothing else. The phrasing itself, the prompt and the
+// output parsing live in internal/phraser so the eval can score them (#396).
 type llmReplier struct {
-	c    completer
+	p    *phraser.Replier
 	stub *voice.StubReplier
-
-	// block renders the shared context block per turn (who he is, the time).
-	// nil ⇒ the prompt stands alone.
-	block func() string
 }
 
-func newLLMReplier(c completer, block func() string) *llmReplier {
-	return &llmReplier{c: c, stub: voice.NewStubReplier(), block: block}
+func newLLMReplier(c phraser.Completer, block func() string) *llmReplier {
+	return &llmReplier{p: phraser.NewReplier(c, block), stub: voice.NewStubReplier()}
 }
 
-const replySystem = `Ты — Maven, домашняя ассистентка (о себе — в женском роде). Владелец — мужчина, говоришь с ним на "ты", в единственном числе; никогда не "вы"/"ваш" и не "он"/"его". Подтверди действие РОВНО ОДНИМ коротким предложением (≤120 символов), по-русски, спокойно и без официальных формулировок. Не задавай вопросов, не повторяй слова, не добавляй ничего после точки. Отвечай ТОЛЬКО одним объектом JSON с полями "response" (текст) и "mood" (ровно одно из: neutral, happy, thinking, tired, confused).
-Пример: {"response": "Записала, что ты выпил стакан воды.", "mood": "neutral"}
-Никогда не пиши "..." в поле response.`
-
+// Reply never fails: a clarify, a model error and an unusable generation all
+// answer from the stub, which is what keeps a turn from breaking on the model.
 func (r *llmReplier) Reply(d router.Decision) string {
 	if d.Clarify {
 		return r.stub.Reply(d)
 	}
-	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
-	defer cancel()
-	out, err := r.c.Complete(ctx, llm.Req{
-		System:        persona.Prepend(r.block, replySystem),
-		User:          replyContext(d),
-		Grammar:       phraser.ResponseGrammar,
-		MaxTokens:     512,
-		RepeatPenalty: 1.3,
-	})
-	if err != nil {
+	out, err := r.p.PhraseReply(context.Background(), d)
+	if err != nil || out == "" {
 		return r.stub.Reply(d)
 	}
-	out = stripThink(out)
-	if response, _ := parseResponseMood(out); response != "" {
-		return response
-	}
-	// fallback: try plain-text parsing
-	if out = firstSentence(out); out != "" {
-		return out
-	}
-	return r.stub.Reply(d)
-}
-
-// firstSentence trims the model's output to a single clean confirmation: first
-// line, first sentence, whitespace-normalized — the last-line defense against a
-// small model that rambles past the first period despite the prompt + stop.
-// stripThink removes the <think> block that Thinking-variant models emit.
-func stripThink(s string) string {
-	if i := strings.LastIndex(s, "</think>"); i >= 0 {
-		s = strings.TrimSpace(s[i+8:])
-	}
-	return s
-}
-
-func firstSentence(s string) string {
-	s = strings.TrimSpace(s)
-	if i := strings.IndexByte(s, '\n'); i >= 0 {
-		s = s[:i]
-	}
-	// keep up to and including the first sentence-ending punctuation.
-	if i := strings.IndexAny(s, ".!?"); i >= 0 {
-		s = s[:i+1]
-	}
-	return strings.TrimSpace(s)
-}
-
-// parseResponseMood extracts {"response","mood"} from LLM output, tolerant
-// of thinking tokens and extra text before/after the JSON block.
-func parseResponseMood(raw string) (response, mood string) {
-	cleaned := strings.TrimSpace(raw)
-	start := strings.Index(cleaned, "{")
-	end := strings.LastIndex(cleaned, "}")
-	if start < 0 || end < 0 || end <= start {
-		return "", ""
-	}
-	var parsed struct {
-		Response string `json:"response"`
-		Mood     string `json:"mood"`
-	}
-	if err := json.Unmarshal([]byte(cleaned[start:end+1]), &parsed); err != nil {
-		return "", ""
-	}
-	return parsed.Response, parsed.Mood
-}
-
-// replyContext renders the decision into a compact RU description for the model.
-func replyContext(d router.Decision) string {
-	switch d.Intent {
-	case router.IntentFact:
-		return "записала факт: " + d.Slots.Key + " " + d.Slots.Value
-	case router.IntentNote:
-		return "сохранила заметку: " + d.Slots.Text
-	case router.IntentReminder:
-		return "поставила напоминание: " + d.Slots.Text
-	default:
-		return string(d.Intent) + ": " + d.Slots.Text
-	}
+	return out
 }

cmd/mavend/replier_llm_test.go

@@ -5,28 +5,22 @@ import (
 	"testing"
 
 	"github.com/kami/maven/internal/llm"
-	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/voice"
 )
 
-type mockCompleter struct {
+// The phrasing itself is tested in internal/phraser. What is left here is the
+// only thing the daemon adds: the stub floor, on the three ways a reply can
+// fail to arrive.
+type stubCompleter struct {
 	out string
 	err error
 }
 
-func (m mockCompleter) Complete(_ context.Context, _ llm.Req) (string, error) { return m.out, m.err }
+func (s stubCompleter) Complete(_ context.Context, _ llm.Req) (string, error) { return s.out, s.err }
 
-func TestLLMReplierReturnsLLMReply(t *testing.T) {
-	r := newLLMReplier(mockCompleter{out: `{"response":"записала, кофе закончился","mood":"neutral"}`}, nil)
-	got := r.Reply(router.Decision{Intent: router.IntentNote, Slots: router.Slots{Text: "кофе закончился"}})
-	if got != "записала, кофе закончился" {
-		t.Errorf("got %q, want %q", got, "записала, кофе закончился")
-	}
-}
-
-func TestLLMReplierFallsBackToPlainText(t *testing.T) {
-	r := newLLMReplier(mockCompleter{out: "записала, кофе закончился"}, nil)
+func TestLLMReplierPassesTheModelReplyThrough(t *testing.T) {
+	r := newLLMReplier(stubCompleter{out: `{"response":"записала, кофе закончился","mood":"neutral"}`}, nil)
 	got := r.Reply(router.Decision{Intent: router.IntentNote, Slots: router.Slots{Text: "кофе закончился"}})
 	if got != "записала, кофе закончился" {
 		t.Errorf("got %q, want %q", got, "записала, кофе закончился")
@@ -34,54 +28,30 @@ func TestLLMReplierFallsBackToPlainText(t *testing.T) {
 }
 
 func TestLLMReplierFallsBackToStubOnError(t *testing.T) {
-	r := newLLMReplier(mockCompleter{err: errTestLLMDown}, nil)
-	noteDec := router.Decision{Intent: router.IntentNote}
-	got := r.Reply(noteDec)
-	want := voice.NewStubReplier().Reply(noteDec)
-	if got != want {
-		t.Errorf("on llm error: got %q, want stub %q", got, want)
-	}
+	r := newLLMReplier(stubCompleter{err: errReplierTest}, nil)
+	assertStub(t, r, router.Decision{Intent: router.IntentNote}, "llm error")
 }
 
 func TestLLMReplierFallsBackToStubOnEmpty(t *testing.T) {
-	r := newLLMReplier(mockCompleter{out: ""}, nil)
-	noteDec := router.Decision{Intent: router.IntentNote}
-	got := r.Reply(noteDec)
-	want := voice.NewStubReplier().Reply(noteDec)
-	if got != want {
-		t.Errorf("on empty llm: got %q, want stub %q", got, want)
-	}
+	r := newLLMReplier(stubCompleter{out: ""}, nil)
+	assertStub(t, r, router.Decision{Intent: router.IntentNote}, "empty llm")
 }
 
 func TestLLMReplierClarifyUsesStub(t *testing.T) {
-	r := newLLMReplier(mockCompleter{out: "я всё поняла"}, nil)
-	clarifyDec := router.Decision{Clarify: true}
-	got := r.Reply(clarifyDec)
-	want := voice.NewStubReplier().Reply(clarifyDec)
+	r := newLLMReplier(stubCompleter{out: "я всё поняла"}, nil)
+	assertStub(t, r, router.Decision{Clarify: true}, "clarify")
+}
+
+func assertStub(t *testing.T, r *llmReplier, d router.Decision, what string) {
+	t.Helper()
+	got, want := r.Reply(d), voice.NewStubReplier().Reply(d)
 	if got != want {
-		t.Errorf("on clarify: got %q, want stub %q", got, want)
+		t.Errorf("on %s: got %q, want stub %q", what, got, want)
 	}
 }
 
-var errTestLLMDown = errTest("llm down")
+var errReplierTest = errTest("llm down")
 
 type errTest string
 
 func (e errTest) Error() string { return string(e) }
-
-// grammarRecorder captures the request so the grammar can be asserted on.
-type grammarRecorder struct{ req llm.Req }
-
-func (g *grammarRecorder) Complete(_ context.Context, r llm.Req) (string, error) {
-	g.req = r
-	return `{"response":"записала","mood":"neutral"}`, nil
-}
-
-func TestLLMReplierCarriesTheResponseGrammar(t *testing.T) {
-	rec := &grammarRecorder{}
-	r := newLLMReplier(rec, nil)
-	r.Reply(router.Decision{Intent: router.IntentNote, Slots: router.Slots{Text: "кофе закончился"}})
-	if rec.req.Grammar != phraser.ResponseGrammar {
-		t.Errorf("grammar = %q, want phraser.ResponseGrammar", rec.req.Grammar)
-	}
-}

cmd/mavend/simulator_test.go

@@ -1043,3 +1043,26 @@ func TestSimulatorRefusesBackwardsSteps(t *testing.T) {
 		t.Errorf("the clock moved to %s on a refused step, it must stay at 09:00", got)
 	}
 }
+
+// TestSimulatorRoutesWithTheDeployedSeeds — the scenarios must replay against
+// the classifier the deploy runs, not an empty one.
+//
+// They did not. The seed path was relative to the working directory, which is
+// cmd/mavend under `go test`, so every file failed to open and the whole
+// simulator scored three green scenarios with zero examples loaded (Vikunja
+// #465). The count is asserted rather than logged, because a silent zero is
+// exactly the failure that hid here for as long as it did.
+func TestSimulatorRoutesWithTheDeployedSeeds(t *testing.T) {
+	cls := router.NewClassifier(router.NewHashEmbedder(1024))
+	seedClassifier(cls)
+	total := 0
+	for _, intent := range cls.Intents() {
+		total += len(cls.Examples(intent))
+	}
+	if total == 0 {
+		t.Fatalf("no seed examples loaded from %s — the simulator would route on nothing", seedPath())
+	}
+	if len(cls.Intents()) != 7 {
+		t.Fatalf("seeded %d intents, want all 7", len(cls.Intents()))
+	}
+}

cmd/mavend/tick.go

@@ -761,11 +761,7 @@ func (t *tickLoop) fireMorningRoutines(ctx context.Context, now time.Time, state
 	facts := t.gatherMorningFacts(ctx)
 
 	for _, cand := range morning.Due(t.morningRoutines, facts, t.morningLast, now) {
-		labels := make([]string, len(cand.Missing))
-		for i, it := range cand.Missing {
-			labels[i] = it.Label
-		}
-		body := fmt.Sprintf("%s: не сделано — %s", cand.Routine.Name, strings.Join(labels, ", "))
+		body := morningNudgeBody(cand)
 		pn := delivery.PhrasedNudge{
 			Candidate: loop.Candidate{
 				Rule:     loop.Rule{Name: "morning:" + cand.Routine.Name, Severity: loop.Severity(cand.Routine.Severity)},
@@ -781,6 +777,26 @@ func (t *tickLoop) fireMorningRoutines(ctx context.Context, now time.Time, state
 	}
 }
 
+// morningNudgeBody words the one message a routine gets per day. Required
+// items are what she says was not done; optional ones follow, worded as
+// something he could still do rather than something he owes (Vikunja #473).
+// Operator text, not phrased by the model, for the same reason it always was:
+// a checklist item must not be invented.
+func morningNudgeBody(cand morning.Candidate) string {
+	labels := func(items []morning.Item) string {
+		out := make([]string, len(items))
+		for i, it := range items {
+			out[i] = it.Label
+		}
+		return strings.Join(out, ", ")
+	}
+	body := fmt.Sprintf("%s: не сделано — %s", cand.Routine.Name, labels(morning.Required(cand.Missing)))
+	if opt := morning.OptionalOnly(cand.Missing); len(opt) > 0 {
+		body += fmt.Sprintf(". если будет время — %s", labels(opt))
+	}
+	return body
+}
+
 // gatherMorningFacts reads the latest fact for every item's fact_key across
 // all configured morning routines. Shared by fireMorningRoutines (nudge
 // decision) and morningStatus (read-only query) so the two paths can never
@@ -986,7 +1002,7 @@ type daemonAPI struct {
 	getTrace         func() *loop.TickTrace
 	getMorningStatus func(ctx context.Context) []ipc.MorningRoutineStatus
 	getDayPlan       func(ctx context.Context) ipc.DayPlan
-	chatFn           func(ctx context.Context, text string) string
+	chatFn           func(ctx context.Context, conversation, text string) string
 	getMCPServers    func() []ipc.MCPServerStatus
 	getEvents        func(n int) []ipc.IntakeEvent
 }
@@ -1002,11 +1018,11 @@ func (d *daemonAPI) RecentEvents(ctx context.Context, n int) ([]ipc.IntakeEvent,
 	return d.getEvents(n), nil
 }
 
-func (d *daemonAPI) Chat(ctx context.Context, text string) (string, error) {
+func (d *daemonAPI) Chat(ctx context.Context, conversation, text string) (string, error) {
 	if d.chatFn == nil {
 		return "", errors.New("mavend: chat not available")
 	}
-	return d.chatFn(ctx, text), nil
+	return d.chatFn(ctx, conversation, text), nil
 }
 
 // MCPServers — the configured MCP servers and their health (Vikunja #251).

cmd/mavend/voice.go

@@ -76,6 +76,10 @@ type reactiveHandler struct {
 	tts      tts.Synthesizer
 	router   *router.Router
 	embedder router.Embedder // reused for note write/query (same model as the classifier)
+	// boundary — the embedded seed sets behind the personal boundary
+	// (personalboundary.go). Zero value is usable and loads on first query;
+	// with no embedder it never loads and the boundary uses personalMarkers.
+	boundary personalBoundary
 	// api — the CoreAPI the handler reads and writes through. Wired with the
 	// bare store adapter and UPGRADED by main once the daemonAPI exists; see
 	// upgradeAPI.
@@ -216,9 +220,9 @@ func (h *reactiveHandler) upgradeAPI(api ipc.CoreAPI) {
 // handleText — the core reactive path without stt/tts. Used by the IPC Chat
 // endpoint (and eventually by telegram). Splits out the audio bookends from
 // HandlePushToTalk so text channels share the same routing logic.
-func (h *reactiveHandler) handleText(ctx context.Context, text string) string {
+func (h *reactiveHandler) handleText(ctx context.Context, conversation, text string) string {
 	log.Printf("voice: handleText: %q", text)
-	return h.runTurn(ctx, text, sourceText)
+	return h.runTurn(withDialogueID(ctx, dialogueIDFor(sourceText, conversation)), text, sourceText)
 }
 
 // turnSource — which channel this utterance arrived on, in the same provenance
@@ -251,7 +255,7 @@ func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSour
 	// early. He can be asked a question, walk off, come back and say "да" to a
 	// confirm that is still parked; computing the notice after that return meant
 	// he answered the confirm and never heard that the older request was let go.
-	expiredNotice := h.clarifyExpiredNotice()
+	expiredNotice := h.clarifyExpiredNotice(ctx)
 
 	// 2. confirm turn — if a destructive act is parked, this utterance is its
 	// y/n answer, not a fresh command. Handled before routing so "да" doesn't
@@ -347,7 +351,7 @@ func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSour
 	// and park the request (clarify.go); otherwise the replier's canned reply
 	// stands.
 	if dec.Clarify {
-		if question, asked := h.askClarify(dec); asked {
+		if question, asked := h.askClarify(ctx, dec); asked {
 			return withNotice(expiredNotice, question)
 		}
 	}

cmd/mavend/voicewire.go

@@ -380,6 +380,11 @@ func buildRouter(emb router.Embedder, acts router.ActMatcher, threshold float64,
 	// is an agenda question and must not.
 	grammars = append(grammars, router.AgendaQueryGrammars()...)
 	grammars = append(grammars, router.ReminderGrammar())
+	// Last, and it matches any utterance shape — its Build is the filter. An
+	// explicit capture marker beats the model, which called it an act and
+	// rewrote the task text (Vikunja #467). After the rules above because a
+	// marker never collides with a clock or agenda question.
+	grammars = append(grammars, router.TaskCaptureGrammar())
 	return router.New(router.Config{
 		Grammars:   grammars,
 		Classifier: cls,
@@ -393,11 +398,34 @@ func buildRouter(emb router.Embedder, acts router.ActMatcher, threshold float64,
 	})
 }
 
-// seedDir is the directory containing intent seed files. Each file is named
-// <intent>.txt and contains one training example per line (blank lines and
-// lines starting with # are ignored). Relative to the working directory.
+// seedDir is the directory containing intent seed files, relative to the repo
+// root. Each file is named <intent>.txt and holds one training example per
+// line (blank lines and lines starting with # are ignored).
 const seedDir = "models/seeds"
 
+// seedPath resolves seedDir against the working directory, walking up until it
+// finds it. The daemon runs from the repo root and the first candidate hits.
+//
+// A test does not: `go test ./cmd/mavend/` runs with the working directory at
+// cmd/mavend, so every open failed and the simulator scenarios replayed a whole
+// scripted day against a classifier holding zero examples (Vikunja #465). They
+// passed, which is the part that matters — a green simulator was not exercising
+// the routing the deploy runs, and a regression in the seed set could not have
+// shown up there.
+//
+// Bounded at five levels, so a daemon started somewhere without the seeds logs
+// the same failure it always did rather than walking to the filesystem root.
+func seedPath() string {
+	dir := seedDir
+	for i := 0; i < 5; i++ {
+		if st, err := os.Stat(dir); err == nil && st.IsDir() {
+			return dir
+		}
+		dir = filepath.Join("..", dir)
+	}
+	return seedDir
+}
+
 // seedClassifier floors the embedded examples so the cold-boot path
 // doesn't return ErrNoIntents. Loads examples from seedDir — one file per
 // intent (act.txt, reminder.txt, fact.txt, note.txt, query.txt). When the
@@ -422,11 +450,11 @@ func seedClassifier(c *router.Classifier) {
 		}
 		total += n
 	}
-	log.Printf("voice: loaded %d seed examples from %s", total, seedDir)
+	log.Printf("voice: loaded %d seed examples from %s", total, seedPath())
 }
 
 func loadSeedFile(c *router.Classifier, intent router.Intent) (int, error) {
-	path := filepath.Join(seedDir, string(intent)+".txt")
+	path := filepath.Join(seedPath(), string(intent)+".txt")
 	f, err := os.Open(path)
 	if err != nil {
 		return 0, fmt.Errorf("open %s: %w", path, err)

cmd/mavend/weatherq.go

@@ -1,10 +1,13 @@
 // Package main — weatherq.go holds the weather-query keyword helpers: does
-// this utterance ask about weather at all, and which city (if any) did it
-// name. Both are plain substring/lookup matching, not NLU — extend this file
-// rather than voice.go for anything in that shape.
+// this utterance ask about weather at all, and which place (if any) did he
+// name. Both are plain keyword matching, not NLU — extend this file rather
+// than voice.go for anything in that shape.
 package main
 
-import "strings"
+import (
+	"regexp"
+	"strings"
+)
 
 // isWeatherQuery returns true if the utterance is about weather.
 func isWeatherQuery(u string) bool {
@@ -19,40 +22,49 @@ func isWeatherQuery(u string) bool {
 		strings.Contains(lower, "temperature")
 }
 
-// weatherCities — the city names an utterance may name explicitly, as
-// lowercase substrings mapped to the provider's spelling. This is a
-// convenience for "какая погода в Лондоне", NOT a source of default truth:
-// nothing here is used unless he actually said it.
-var weatherCities = map[string]string{
-	"москв":    "Moscow",
-	"moscow":   "Moscow",
-	"питер":    "Saint Petersburg",
-	"spb":      "Saint Petersburg",
-	"петербур": "Saint Petersburg",
-	"лондон":   "London",
-	"london":   "London",
-	"париж":    "Paris",
-	"paris":    "Paris",
-	"берлин":   "Berlin",
-	"berlin":   "Berlin",
-	"нью-йорк": "New York",
-	"new york": "New York",
+// weatherPlace — the place he named, after "в"/"во"/"in". One or two words,
+// letters and dashes only, so "в Нижнем Новгороде" and "in New York" both
+// 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{
+	"доме": 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,
 }
 
-// extractWeatherLocation returns the city he named, or the configured default
+// extractWeatherLocation returns the place he named, or the configured default
 // when he named none. It returns "" when he named none AND no default is
 // configured — the caller must then say it does not know.
 //
-// It used to return "Moscow" in that case. That is a made-up answer presented
-// as fact: reading out Moscow's temperature to someone who is not in Moscow is
-// wrong in exactly the way maven must never be wrong. voice.weather
-// .default_location is the only source of an unstated location.
+// It used to be a hand-written table of six cities in two spellings each
+// (Vikunja #421). Anything outside it — Kazan, Tbilisi — was dropped silently
+// and answered for the default location, which reads as a correct answer about
+// the wrong place. There is a geocoder behind this now: internal/weather
+// already calls Open-Meteo's geocoding endpoint for every lookup, so any place
+// it knows is a place he can ask about, and the table bought nothing.
+//
+// A named place that the geocoder cannot resolve is the caller's problem to
+// report, not this function's to hide.
+//
+// It used to return "Moscow" when he named nothing. That is a made-up answer
+// presented as fact. voice.weather.default_location is the only source of an
+// unstated location.
 func extractWeatherLocation(u, defaultLoc string) string {
-	lower := strings.ToLower(u)
-	for substr, name := range weatherCities {
-		if strings.Contains(lower, substr) {
-			return name
-		}
+	m := weatherPlace.FindStringSubmatch(u)
+	if m == nil {
+		return defaultLoc
 	}
-	return defaultLoc
+	place := strings.TrimSpace(m[1])
+	first := strings.ToLower(strings.Fields(place)[0])
+	if weatherNonPlaces[first] {
+		return defaultLoc
+	}
+	return place
 }

cmd/mavend/weatherq_test.go

@@ -0,0 +1,33 @@
+package main
+
+import "testing"
+
+// TestExtractWeatherLocation — any place he names comes through, not just the
+// six that used to be in a table (Vikunja #421).
+func TestExtractWeatherLocation(t *testing.T) {
+	cases := []struct {
+		utterance string
+		def       string
+		want      string
+	}{
+		// The cities the table had, and the ones it silently dropped.
+		{"какая погода в Москве", "Berlin", "Москве"},
+		{"какая погода в Казани", "Berlin", "Казани"},
+		{"погода в Тбилиси?", "Berlin", "Тбилиси"},
+		{"what's the weather in New York", "Berlin", "New York"},
+		{"тепло в Нижнем Новгороде?", "Berlin", "Нижнем Новгороде"},
+		// He named nothing: the configured default, and nothing at all when
+		// there is no default.
+		{"какая сегодня погода", "Berlin", "Berlin"},
+		{"какая сегодня погода", "", ""},
+		// "в" followed by something that is not a place stays the default —
+		// the house sensors and the day words answer elsewhere.
+		{"тепло в комнате?", "Berlin", "Berlin"},
+		{"какая погода в выходные", "Berlin", "Berlin"},
+	}
+	for _, c := range cases {
+		if got := extractWeatherLocation(c.utterance, c.def); got != c.want {
+			t.Errorf("extractWeatherLocation(%q, %q) = %q, want %q", c.utterance, c.def, got, c.want)
+		}
+	}
+}

cmd/mavgpud/runner.go

@@ -24,7 +24,12 @@ type runner struct {
 	mu    sync.Mutex
 	cmd   *exec.Cmd
 	ready bool
-	http  *http.Client
+	// yielding — stop() has sent the signal and the exit that follows is ours.
+	// llama-server aborts on SIGTERM (its static teardown throws, upstream
+	// ggml-org/llama.cpp), so a routine yield and a real crash produce the same
+	// "signal: aborted" and used to log identically (Vikunja #491).
+	yielding bool
+	http     *http.Client
 }
 
 func newRunner(bin string, args []string, readyURL string) *runner {
@@ -70,13 +75,18 @@ func (r *runner) start() error {
 	if err := cmd.Start(); err != nil {
 		return err
 	}
-	r.cmd, r.ready = cmd, false
+	r.cmd, r.ready, r.yielding = cmd, false, false
 	log.Printf("mavgpud: started llama-server pid=%d", cmd.Process.Pid)
 	go func() {
 		err := cmd.Wait()
 		r.mu.Lock()
-		r.cmd, r.ready = nil, false
+		yielded := r.yielding
+		r.cmd, r.ready, r.yielding = nil, false, false
 		r.mu.Unlock()
+		if yielded {
+			log.Printf("mavgpud: llama-server stopped, card yielded (%v)", err)
+			return
+		}
 		log.Printf("mavgpud: llama-server exited: %v", err)
 	}()
 	return nil
@@ -90,6 +100,10 @@ func (r *runner) stop(grace time.Duration) {
 	r.mu.Lock()
 	cmd := r.cmd
 	r.ready = false
+	if cmd != nil && cmd.Process != nil {
+		// The exit that follows is ours, not a crash.
+		r.yielding = true
+	}
 	r.mu.Unlock()
 	if cmd == nil || cmd.Process == nil {
 		return

cmd/mavgpud/runner_test.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+// fakeServer writes an executable standing in for llama-server: it ignores
+// SIGTERM the way the real one effectively does — by dying messily rather than
+// cleanly — and reports a non-zero status.
+func fakeServer(t *testing.T, body string) string {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "fake-llama-server")
+	if err := os.WriteFile(path, []byte("#!/bin/sh\n"+body+"\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+// A deliberate stop is a yield, and the log has to say so.
+//
+// llama-server aborts inside its own static teardown on SIGTERM, so the exit
+// status of a routine yield is identical to that of a real crash. Reading the
+// mavgpud log, the two were indistinguishable (Vikunja #491).
+func TestStopMarksTheExitAsAYield(t *testing.T) {
+	r := newRunner(fakeServer(t, "while : ; do sleep 1 ; done"), nil, "")
+	if err := r.start(); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+	r.mu.Lock()
+	if r.yielding {
+		t.Error("a freshly started server is already marked as yielding")
+	}
+	r.mu.Unlock()
+
+	r.stop(2 * time.Second)
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		if !r.running() {
+			return
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	t.Fatal("the child outlived stop")
+}
+
+// Stopping when nothing is running must not arm the flag for the next child.
+// The next exit after that would be a real crash logged as a yield.
+func TestStopWithNoChildDoesNotArmTheFlag(t *testing.T) {
+	r := newRunner("/nonexistent", nil, "")
+	r.stop(10 * time.Millisecond)
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if r.yielding {
+		t.Error("stop armed the yield flag with no child running")
+	}
+}

cmd/mavweb/handlers_test.go

@@ -54,7 +54,9 @@ type fakeCore struct {
 	revertErr   error
 
 	// for handleNotifications tests
-	nudgesErr error
+	nudgesErr     error
+	attempts      []ipc.DeliveryAttempt
+	attemptStatus string
 
 	// for handleHistory tests
 	historyFacts []ipc.Fact
@@ -77,7 +79,7 @@ func (f *fakeCore) MCPServers(context.Context) ([]ipc.MCPServerStatus, error) {
 	return f.mcpServers, f.mcpErr
 }
 
-func (f *fakeCore) Chat(_ context.Context, text string) (string, error) {
+func (f *fakeCore) Chat(_ context.Context, _, text string) (string, error) {
 	f.chatText = text
 	if f.chatErr != nil {
 		return "", f.chatErr
@@ -1251,3 +1253,35 @@ func TestHandleWS_AssertedSession_PassesGate(t *testing.T) {
 		t.Fatalf("status = 403 on an asserted session; body=%s", rr.Body.String())
 	}
 }
+
+func (f *fakeCore) DeliveryAttempts(_ context.Context, status string, _ int) ([]ipc.DeliveryAttempt, error) {
+	f.attemptStatus = status
+	return f.attempts, nil
+}
+
+// TestHandleNotifications_ShowsTheOutbox — the outbox was written and never
+// read, so a dropped or failed send was invisible (Vikunja #390).
+func TestHandleNotifications_ShowsTheOutbox(t *testing.T) {
+	done := time.Date(2026, 8, 4, 9, 0, 30, 0, time.UTC)
+	core := &fakeCore{
+		attempts: []ipc.DeliveryAttempt{
+			{Kind: "nudge", Rule: "care-check", Channel: "telegram", Status: "dropped",
+				Created: done.Add(-30 * time.Second), Completed: &done},
+			{Kind: "reminder", ReminderID: 7, Channel: "voice", Status: "pending", Created: done},
+		},
+	}
+	rr := httptest.NewRecorder()
+	handleNotifications(rr, httptest.NewRequest(http.MethodGet, "/notifications?status=dropped", nil), core)
+	if rr.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200; body=%s", rr.Code, rr.Body.String())
+	}
+	if core.attemptStatus != "dropped" {
+		t.Errorf("status filter = %q, want it passed through", core.attemptStatus)
+	}
+	body := rr.Body.String()
+	for _, want := range []string{"care-check", "dropped", "reminder #7", "Delivery outbox"} {
+		if !strings.Contains(body, want) {
+			t.Errorf("rendered outbox missing %q", want)
+		}
+	}
+}

cmd/mavweb/main.go

@@ -893,12 +893,59 @@ func handleNotifications(w http.ResponseWriter, r *http.Request, core ipc.CoreAP
 		http.Error(w, "notifications error: "+err.Error(), http.StatusBadGateway)
 		return
 	}
+	// The outbox, on the page that already answers "what did she send".
+	// A failed or dropped attempt is why she went quiet, and until now it was
+	// recorded and unreadable (Vikunja #390). Filter with ?status=dropped.
+	status := r.URL.Query().Get("status")
+	attempts, err := core.DeliveryAttempts(ctx, status, 50)
+	if err != nil {
+		// The nudge list is still worth showing, so this is a note on the page
+		// rather than a dead page.
+		log.Printf("notifications: delivery attempts: %v", err)
+	}
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	if err := notificationsTmpl.Execute(w, map[string]any{"Nudges": nudges}); err != nil {
+	if err := notificationsTmpl.Execute(w, map[string]any{
+		"Nudges":   nudges,
+		"Attempts": deliveryRows(attempts),
+		"Status":   status,
+	}); err != nil {
 		log.Printf("notifications template: %v", err)
 	}
 }
 
+// deliveryRow is one outbox line, with every timestamp already formatted so
+// the template holds no date logic — same shape as taskRow.
+type deliveryRow struct {
+	Kind      string
+	Target    string
+	Channel   string
+	Status    string
+	Created   string
+	Completed string
+}
+
+func deliveryRows(as []ipc.DeliveryAttempt) []deliveryRow {
+	out := make([]deliveryRow, 0, len(as))
+	for _, a := range as {
+		target := a.Rule
+		if target == "" && a.ReminderID != 0 {
+			target = "reminder #" + strconv.FormatInt(a.ReminderID, 10)
+		}
+		row := deliveryRow{
+			Kind:    a.Kind,
+			Target:  target,
+			Channel: a.Channel,
+			Status:  a.Status,
+			Created: a.Created.Format("02.01 15:04"),
+		}
+		if a.Completed != nil {
+			row.Completed = a.Completed.Format("15:04")
+		}
+		out = append(out, row)
+	}
+	return out
+}
+
 func handleReminders(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
 	if core == nil {
 		http.Error(w, "reminders disabled (no -core)", http.StatusServiceUnavailable)
@@ -1678,7 +1725,13 @@ func handleChatAPI(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI, ses
 		http.Redirect(w, r, "/chat", http.StatusSeeOther)
 		return
 	}
-	reply, err := core.Chat(r.Context(), text)
+	// One conversation id for the whole web chat, and a different one from
+	// telegram or the mic. A parked question belongs to the reach that was
+	// asked; before this, a clarify nobody answered on the web ate the next
+	// utterance spoken at the mic (Vikunja #466). This server has no
+	// per-browser session, so every browser tab is the same conversation —
+	// which is right for a single-owner box.
+	reply, err := core.Chat(r.Context(), "web", text)
 	if err != nil {
 		log.Printf("chat api: %v", err)
 		http.Redirect(w, r, "/chat", http.StatusSeeOther)

cmd/mavweb/notifications.html

@@ -14,5 +14,27 @@
   <div>no notifications yet</div>
   <div class=hint>check back later or ask maven a question</div>
 </div>{{end}}
+<h2>Delivery outbox</h2>
+<p class=hint>
+  every send is recorded before it leaves, so a failure is visible rather than silent.
+  <a href="/notifications">all</a> ·
+  <a href="/notifications?status=dropped">dropped</a> ·
+  <a href="/notifications?status=failed">failed</a> ·
+  <a href="/notifications?status=pending">pending</a> ·
+  <a href="/notifications?status=unknown">unknown</a>
+</p>
+{{if .Attempts}}<div class=scroll><table>
+<tr><th>started</th><th>kind</th><th>rule</th><th>channel</th><th>status</th><th>finished</th></tr>
+{{range .Attempts}}<tr>
+<td class=hint>{{.Created}}</td>
+<td>{{.Kind}}</td>
+<td class=key>{{.Target}}</td>
+<td><span class=badge>{{.Channel}}</span></td>
+<td class={{.Status}}>{{.Status}}</td>
+<td class=hint>{{.Completed}}</td>
+</tr>{{end}}</table></div>
+{{else}}<div class=empty>
+  <div>no delivery attempts{{if .Status}} with status {{.Status}}{{end}}</div>
+</div>{{end}}
 {{template "shellBottom"}}
 </html>

deploy/mavend.json

@@ -20,6 +20,7 @@
     "bin_path": "llama-server",
     "n_gpu_layers": 99,
     "n_ctx": 4096,
+    "cache_ram_mib": 512,
     "timeout": "60s",
     "llm_nudges": false
   },

deploy/mavgpud.service

@@ -19,6 +19,10 @@ RestartSec=5
 # llama-server on SIGTERM, so give it longer than stop_grace to do that.
 KillSignal=SIGTERM
 TimeoutStopSec=60
+# llama-server aborts inside its own static teardown on SIGTERM, so every
+# routine yield used to write a multi-gigabyte core into systemd-coredump
+# (Vikunja #491). Yielding is meant to happen several times a day.
+LimitCORE=0
 
 [Install]
 WantedBy=default.target

docs/evals/2026-08-03-llama-prompt-cache.md

@@ -0,0 +1,84 @@
+# Where the resident model's 7.9GB of RSS goes (2026-08-03, homesrv)
+
+Measured for Vikunja #499. The deployed llama-server held 7.9GB RSS for a 1.1GB
+model file. Half a gigabyte of it was in swap, on a box that also runs
+whisper.cpp, piper and the embedder.
+
+## Method
+
+`maven-mavend-1` was stopped for the measurement, with the owner's approval.
+Its own binary then ran on the host with the exact deployed command line. That
+binary is `/opt/maven/bin/llama-server`, version `1 (4c65955)`, a Vulkan build.
+
+```sh
+llama-server -m /mnt/hdd1/llms/qwen3/Qwen3-1.7B-UD-Q4_K_XL.gguf \
+  --host 127.0.0.1 --port 18099 -c 4096 -ngl 99 --no-webui
+```
+
+RSS was read from `/proc/<pid>/status` after load and after each of 8 distinct
+1521-token prompts. `smaps` of the deployed process was read first, from inside
+the container, since the host user cannot read another user's maps.
+
+## The cause: the prompt cache, not the weights and not the offload
+
+The startup log says it outright:
+
+```text
+srv load_model: prompt cache is enabled, size limit: 8192 MiB
+srv llama_server: n_parallel is set to auto, using n_parallel = 4 and kv_unified = true
+```
+
+The server saves the full KV state of every idle slot it evicts. It keeps up to
+8GiB of those states in host RAM (llama.cpp PR 16391). One saved prompt of 1521
+tokens costs 166.377 MiB. That is 112 kiB per token, exactly Qwen3-1.7B's KV
+footprint (28 layers x 2 x 1024 dims x 2 bytes).
+
+RSS at rest, and per distinct prompt:
+
+| Prompts served | RSS, default | RSS, `--cache-ram 512` |
+|---|---|---|
+| 0 (just loaded) | 443 MB | 411 MB |
+| 1 | 445 MB | 411 MB |
+| 4 | 958 MB | 929 MB |
+| 8 | 1641 MB | 932 MB |
+
+Uncapped, RSS climbs about 170MB per distinct prompt and does not stop until
+the 8GiB limit. Capped at 512 MiB it plateaus at 932MB from the fourth prompt
+on, with the cache holding steady at `3 prompts, 499.132 MiB` and evicting.
+
+The 7.9GB on the running daemon was that climb, weeks of it. Its `smaps` showed
+one 6.03GB anonymous mapping at 5.32GB resident plus a 1.45GB mapping at 1.27GB
+resident, and only 30MB of file-backed RSS.
+
+## The task's leading guess was wrong
+
+`-ngl 99` on the Vega iGPU costs almost no process RSS. A freshly loaded server
+has 95MB of anonymous RSS in total. RADV allocates device memory through the
+kernel, outside the process, and the log sees 8202 MiB free on `Vulkan0`. The
+weights are mmapped and file-backed, so they are evictable and do not pin RSS. The logit buffer is not visible in the numbers above at all.
+
+## Decision
+
+`--cache-ram 512` is now the default, wired as `phraser.cache_ram_mib` and set
+in `deploy/mavend.json`. 512 MiB caps total RSS near 1GB, an eighth of what the
+box carried. It still holds three of the 1521-token probes above. Maven's real
+routing and phrasing prompts are much shorter, so it holds more of those than
+the table suggests. `-c 4096` is untouched, as #499
+required. A negative `cache_ram_mib` passes no flag, for a llama-server too old
+to know it.
+
+Not changed: `n_parallel = 4`. With `kv_unified = true` the four slots share one
+4096-token KV cache, so they do not multiply it.
+
+The other half of #499 was that none of these lines were reachable. mavend
+scraped llama-server's stderr for the listen line and discarded it, and never
+piped stdout at all. Both streams now go to mavend's log with a `llama:` prefix.
+The last 12 startup lines go into the error when the server dies before it
+listens.
+
+## Deployed
+
+The `mavenai:latest` image was rebuilt and `maven-mavend-1` recreated the same
+day. The daemon's own log now carries the child's startup, it reads
+`prompt cache is enabled, size limit: 512 MiB`, and the resident server sat at
+439MB RSS after load and 613MB after one served turn.

docs/evals/2026-08-03-personal-boundary.md

@@ -0,0 +1,46 @@
+# Personal boundary, seed scoring vs possession markers, 2026-08-03
+
+Vikunja #495. `что я говорил про бэкапы?` walked past the personal boundary into
+SearXNG and came back answered from a Habr article. The boundary matched
+possession words only, so a first-person speech verb was not a personal
+question.
+
+## What changed
+
+The boundary now scores the turn's query vector against two frozen seed sets.
+It claims the turn when the personal side is nearer than the world side. Seeds
+and code are in `cmd/mavend/personalboundary.go`. The possession markers stay as
+the offline floor for a handler with no embedder.
+
+A regex speech class was written first and dropped. Russian gives every verb a
+dozen surface forms, and the "как я говорил, ..." preamble list has no end. Each
+form the lexicon missed was one more question reaching the world.
+
+## Measurement
+
+Embedder: multilingual-e5-small int8, the one homesrv runs. Both sides are
+embedded on the query side. Cases are held out, none of them a seed. `make test`
+runs the offline part. The scored part is opt-in through `MAVEN_ONNX_LIB`, like
+`TestONNXRecall`.
+
+    19/19 held-out utterances correct   (TestONNXPersonalBoundary)
+
+    true positive margins   +0.014 to +0.089
+    nearest true negative   -0.005  ("кто такой гагарин")
+
+One case missed during the first pass and is not held out any more: `as i said,
+what is the population of india`, +0.008 to the personal side. It is a world seed
+now.
+
+The gate is the sign of the difference and nothing tighter. The margins are too
+thin for a threshold. The asymmetry favours claiming: a false claim costs one
+honest "не знаю", a false pass sends his life to an upstream engine.
+
+`make eval-recall` unchanged, 18/27 answered at gate 0.55. Recall does not touch
+this path.
+
+## Not verified
+
+The live probe on the deployed box. The daemon was not rebuilt in this session.
+The reply to `что я говорил про бэкапы?` with no matching note is still untested
+against a real SearXNG.

docs/evals/2026-08-03-recall-topic-veto.md

@@ -0,0 +1,65 @@
+# Recall topic veto, what it costs and what it buys, 2026-08-03
+
+Vikunja #496. The task asked for a cross-language fix. Skip the topic veto in
+`memory.RecallAllowed` when the question and the hit are in different scripts.
+An English question would then stop losing a Russian note.
+
+No such case exists. No fixture case puts the question and its wanted note in
+different scripts. The case the task named is not one either.
+
+    en-hard-024
+      query  "what fixed the screen problem"
+      note   "the flicker went away once i swapped the display cable"
+
+Both are English. It is a paraphrase failure, not a language failure. A script
+test would not have changed a single case, and neither would a bilingual stem
+map.
+
+## What the veto is worth today
+
+Measured with the real embedder, multilingual-e5-small int8, gate 0.55, margin
+0.008. The first row is the veto as it ships. The second is `RecallAllowed`
+forced to true.
+
+| | cases passing | answered | false recall | silenced by gate |
+|---|---|---|---|---|
+| veto on | 22/32 | 17/27 | 0/5 | 2 |
+| veto off | 22/32 | 18/27 | 1/5 | 1 |
+
+The pass count does not move. The veto trades one true recall for one false one.
+It costs `en-hard-024` and it buys `ru-silent-029`:
+
+    ru-silent-029
+      query  "во сколько отходит поезд"
+      note   "погулял вдоль реки"        0.835, margin 0.019
+
+The second case counted as silenced by the gate is `ru-home-026` at margin
+0.001, which the margin gate stops. The veto has nothing to do with it.
+
+## Why no lexical rule separates the two
+
+`en-hard-024` and `ru-silent-029` are in the same lexical class. Both questions
+share zero content words with their hit, and neither carries a first-person
+marker. The scores sit on top of each other, 0.826 against 0.835, and so do the
+margins, 0.023 against 0.019. Only one thing separates them. A screen problem
+and a swapped display cable are the same event. A train and a river walk are
+not. The embedder scores that difference at nine thousandths.
+
+So the signal is semantic and the gate is lexical. Any rule cheap enough to sit
+in `RecallAllowed` and strong enough to recover `en-hard-024` also re-admits
+`ru-silent-029`, which puts false recall back to 1/5.
+
+One near-miss rule was tried on paper and rejected: let the veto pass when the
+hit itself is first person. It works on these two, because the English note says
+"i swapped" and the Russian note says only "погулял". It is backwards as a
+principle. A first-person note is exactly the personal note the veto keeps away
+from a world question. The rule would weaken the veto where it was designed to
+bite. It survives here only because Russian drops the pronoun.
+
+## Decision
+
+Accept the loss. `en-hard-024` stays silenced and false recall stays 0/5.
+
+The way out is a reranker, not a longer word list. Recall@3 is 85.2% against
+recall@1 at 70.4%, so the right note is usually in the returned set and ranked
+wrong. That is where the remaining points are, and it is not this task.

internal/auth/auth_test.go

@@ -311,7 +311,7 @@ func TestGate_IpcServer_CheckWiredThroughSocket(t *testing.T) {
 	if fake.writes != 0 {
 		t.Errorf("auth refused but CoreAPI was called %d time(s); refused calls must not reach CoreAPI", fake.writes)
 	}
-	_, err = cli.Chat(context.Background(), "привет")
+	_, err = cli.Chat(context.Background(), "web", "привет")
 	if !errors.Is(err, ipc.ErrForbidden) {
 		t.Errorf("wire: chat from unenrolled uid = %v; want ipc.ErrForbidden", err)
 	}
@@ -344,7 +344,7 @@ func TestGate_IpcServer_ChatAllowedForEnrolledCaller(t *testing.T) {
 		t.Fatalf("dial: %v", err)
 	}
 	t.Cleanup(func() { _ = cli.Close() })
-	reply, err := cli.Chat(context.Background(), "привет")
+	reply, err := cli.Chat(context.Background(), "web", "привет")
 	if err != nil {
 		t.Fatalf("Chat: %v", err)
 	}
@@ -373,7 +373,7 @@ func (r *recordingAPI) WriteFact(_ context.Context, _ ipc.WriteFactReq) (int64,
 	return int64(r.writes), nil
 }
 
-func (r *recordingAPI) Chat(_ context.Context, text string) (string, error) {
+func (r *recordingAPI) Chat(_ context.Context, _, text string) (string, error) {
 	r.chats++
 	return "echo: " + text, nil
 }

internal/calendar/calendar.go

@@ -18,6 +18,7 @@ import (
 	"sort"
 	"strings"
 	"time"
+	"unicode"
 )
 
 // Fact sources. A calendar event reaches the store as a
@@ -153,14 +154,20 @@ func Overlapping(events []Event, from, to time.Time) []Event {
 	return out
 }
 
-// safeKey makes a summary safe to use inside a fact key (ASCII alphanumerics
-// and dashes). Non-Latin summaries collapse to their punctuation, which is why
-// the day prefix carries the identity and this only disambiguates within a day.
+// safeKey makes a summary safe to use inside a fact key: letters and digits in
+// any script, plus dashes, with space and underscore folded to a dash.
+//
+// It kept ASCII only until 04-08-2026, and dropped everything else. His
+// calendar is Russian, so "Встреча с Аней" and "Обед с мамой" both reduced to
+// "--" and produced the same key on the same day — the second event of the day
+// silently overwrote the first (Vikunja #443). Letting the letters through is
+// what makes the key identify the event. Migration #18 drops the keys written
+// under the old rule; they are re-derived on the next poll.
 func safeKey(s string) string {
 	var b strings.Builder
 	for _, r := range s {
 		switch {
-		case (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '-':
+		case unicode.IsLetter(r) || unicode.IsDigit(r) || r == '-':
 			b.WriteRune(r)
 		case r == ' ' || r == '_':
 			b.WriteRune('-')

internal/calendar/calendar_test.go

@@ -139,6 +139,9 @@ func TestSafeKey(t *testing.T) {
 		{"Hello_World", "Hello-World"},
 		{"special@#$chars!!", "specialchars"},
 		{"ALL_CAPS_123", "ALL-CAPS-123"},
+		// His calendar is Russian. These reduced to "--" and "--" (Vikunja #443).
+		{"Встреча с Аней", "Встреча-с-Аней"},
+		{"Обед с мамой", "Обед-с-мамой"},
 	}
 	for _, tt := range tests {
 		if got := safeKey(tt.in); got != tt.want {
@@ -263,3 +266,19 @@ func TestSourceTrust(t *testing.T) {
 		t.Errorf("Sources() = %v", Sources())
 	}
 }
+
+// Two Russian events on one day must not share a key. They did: safeKey kept
+// ASCII only, so both summaries collapsed to their spaces and the second event
+// overwrote the first in the store (Vikunja #443).
+func TestFactKeyDistinguishesRussianEventsOnOneDay(t *testing.T) {
+	day := time.Date(2026, 8, 4, 0, 0, 0, 0, time.UTC)
+	a := Event{Summary: "Встреча с Аней", Start: day.Add(10 * time.Hour), End: day.Add(11 * time.Hour)}
+	b := Event{Summary: "Обед с мамой", Start: day.Add(13 * time.Hour), End: day.Add(14 * time.Hour)}
+	if FactKeyIn(a, time.UTC) == FactKeyIn(b, time.UTC) {
+		t.Fatalf("both events keyed as %q", FactKeyIn(a, time.UTC))
+	}
+	// The day prefix still has to survive, because the store range-scans on it.
+	if !strings.HasPrefix(FactKeyIn(a, time.UTC), KeyPrefixForDay(day)) {
+		t.Fatalf("key %q lost the day prefix %q", FactKeyIn(a, time.UTC), KeyPrefixForDay(day))
+	}
+}

internal/config/config.go

@@ -601,6 +601,9 @@ type MorningRoutineItemConfig struct {
 	Key     string `json:"key"`
 	FactKey string `json:"fact_key"`
 	Label   string `json:"label"`
+	// Optional — this one being skipped does not earn a nudge. Default false,
+	// so a routine written before 04-08-2026 keeps behaving as it did.
+	Optional bool `json:"optional,omitempty"`
 }
 
 // QuietHoursConfig — a recurring daily quiet-window. Times are local to the
@@ -1276,6 +1279,12 @@ type PhraserConfig struct {
 	NCtx       int      `json:"n_ctx,omitempty"`
 	Timeout    Duration `json:"timeout,omitempty"`
 
+	// CacheRAMMiB bounds llama-server's prompt cache. Omitted ⇒ 512 MiB, which
+	// is what keeps the resident model near 1 GB of RSS instead of the 7.9 GB
+	// measured on 2026-08-03. Set it to -1 to pass no flag at all and let the
+	// server apply its own 8 GiB default. See phraser.Config.CacheRAMMiB.
+	CacheRAMMiB int `json:"cache_ram_mib,omitempty"`
+
 	// LLMNudges — let the model word nudges again. Off by default: nudges are
 	// worded from hand-written Russian templates now (the model broke the
 	// persona and invented units). Chat, query and reminder phrasing always go
@@ -1728,7 +1737,7 @@ func morningRoutinesFromConfig(mc []MorningRoutineConfig) []morning.Routine {
 	for i, r := range mc {
 		items := make([]morning.Item, len(r.Items))
 		for j, it := range r.Items {
-			items[j] = morning.Item{Key: it.Key, FactKey: it.FactKey, Label: it.Label}
+			items[j] = morning.Item{Key: it.Key, FactKey: it.FactKey, Label: it.Label, Optional: it.Optional}
 		}
 		weekdays := make([]time.Weekday, len(r.Weekdays))
 		for j, w := range r.Weekdays {

internal/ipc/api.go

@@ -60,6 +60,19 @@ type Nudge struct {
 	OutcomeTs *int64    `json:"outcome_ts,omitempty"`
 }
 
+// DeliveryAttempt — one row of the delivery outbox. Times are formatted by the
+// reader; Completed is nil while the attempt is still pending.
+type DeliveryAttempt struct {
+	ID         int64      `json:"id"`
+	Kind       string     `json:"kind"`
+	Rule       string     `json:"rule,omitempty"`
+	ReminderID int64      `json:"reminder_id,omitempty"`
+	Channel    string     `json:"channel"`
+	Status     string     `json:"status"`
+	Created    time.Time  `json:"created"`
+	Completed  *time.Time `json:"completed,omitempty"`
+}
+
 // Note — a recall/preference item; ranked by embedding cosine on query.
 // Score is set by QueryNotes (0 on the write path).
 type Note struct {
@@ -521,6 +534,12 @@ type outcomesReq struct {
 type nReq struct {
 	N int `json:"n"`
 }
+
+// deliveryAttemptsReq — the outbox read. Status is empty for every status.
+type deliveryAttemptsReq struct {
+	Status string `json:"status,omitempty"`
+	N      int    `json:"n"`
+}
 type kindNReq struct {
 	Kind string `json:"kind"`
 	N    int    `json:"n"`
@@ -593,8 +612,14 @@ type MCPServerStatus struct {
 }
 
 // chatReq / chatResp — text chat round-trip for the IPC Chat method.
+//
+// Conversation names the thread this utterance belongs to: a mavweb session, a
+// telegram chat. It is opaque to the daemon and only has to be stable for one
+// conversation and distinct across them. Empty is allowed and means "the
+// unattributed text tap", which is what an old client sends.
 type chatReq struct {
-	Text string `json:"text"`
+	Text         string `json:"text"`
+	Conversation string `json:"conversation,omitempty"`
 }
 type chatResp struct {
 	Reply string `json:"reply"`
@@ -679,6 +704,9 @@ type CoreAPI interface {
 	RecentActiveFactsByKind(ctx context.Context, kind string, n int) ([]Fact, error)
 	CalendarEvents(ctx context.Context, from, to time.Time) ([]Fact, error)
 	RecentNudges(ctx context.Context, n int) ([]Nudge, error)
+	// DeliveryAttempts reads the outbox, newest first. An empty status means
+	// every status (Vikunja #390).
+	DeliveryAttempts(ctx context.Context, status string, n int) ([]DeliveryAttempt, error)
 
 	// RecentEcosystemTraces reads the ecosystem call log, which lives in its
 	// own table so machine-rate traces never crowd out human-rate facts.
@@ -759,7 +787,12 @@ type CoreAPI interface {
 	// Chat routes a text utterance through the reactive handler's core path
 	// (router → dialogue → action → replier) and returns the reply text.
 	// No audio or stt/tts — for text channels (mavweb, telegram).
-	Chat(ctx context.Context, text string) (string, error)
+	//
+	// conversation names the thread. A parked clarifying question is held per
+	// conversation, so an unanswered question on one reach cannot eat the next
+	// utterance from another (Vikunja #466). Empty means the unattributed text
+	// tap and is still one conversation of its own, separate from the mic.
+	Chat(ctx context.Context, conversation, text string) (string, error)
 
 	// RecentEvents returns the daemon's unified intake journal, newest first
 	// (Vikunja #283) — one envelope per thing that arrived, whatever direction

internal/ipc/client.go

@@ -68,6 +68,7 @@ var readOnlyMethods = map[Method]bool{
 	MethodRecentActiveFacts:     true,
 	MethodCalendarEvents:        true,
 	MethodRecentNudges:          true,
+	MethodDeliveryAttempts:      true,
 	MethodRecentEcoTraces:       true,
 	MethodQueryNotes:            true,
 	MethodRecentNotes:           true,
@@ -373,6 +374,14 @@ func (c *Client) RecentEcosystemTraces(ctx context.Context, n int) ([]EcosystemT
 	return out, nil
 }
 
+func (c *Client) DeliveryAttempts(ctx context.Context, status string, n int) ([]DeliveryAttempt, error) {
+	var out []DeliveryAttempt
+	if err := c.call(ctx, MethodDeliveryAttempts, deliveryAttemptsReq{Status: status, N: n}, &out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *Client) RecentNudges(ctx context.Context, n int) ([]Nudge, error) {
 	var out []Nudge
 	if err := c.call(ctx, MethodRecentNudges, nReq{N: n}, &out); err != nil {
@@ -623,9 +632,9 @@ func (c *Client) AcceptProposedRoutine(ctx context.Context, id int64) error {
 	return c.call(ctx, MethodAcceptProposedRoutine, acceptProposedRoutineReq{ID: id}, nil)
 }
 
-func (c *Client) Chat(ctx context.Context, text string) (string, error) {
+func (c *Client) Chat(ctx context.Context, conversation, text string) (string, error) {
 	var r chatResp
-	if err := c.call(ctx, MethodChat, chatReq{Text: text}, &r); err != nil {
+	if err := c.call(ctx, MethodChat, chatReq{Text: text, Conversation: conversation}, &r); err != nil {
 		return "", err
 	}
 	return r.Reply, nil

internal/ipc/ipc_test.go

@@ -401,7 +401,7 @@ func TestChatViaClient(t *testing.T) {
 	}
 	t.Cleanup(func() { _ = cli.Close() })
 
-	reply, err := cli.Chat(context.Background(), "привет")
+	reply, err := cli.Chat(context.Background(), "web", "привет")
 	if err != nil {
 		t.Fatalf("Chat: %v", err)
 	}
@@ -417,7 +417,7 @@ type chatTestAPI struct {
 	UnimplementedCoreAPI
 }
 
-func (a *chatTestAPI) Chat(ctx context.Context, text string) (string, error) {
+func (a *chatTestAPI) Chat(ctx context.Context, _, text string) (string, error) {
 	if text == "привет" {
 		return "и тебе привет!", nil
 	}

internal/ipc/server.go

@@ -173,6 +173,25 @@ func (a *storeAPI) RecentNudges(ctx context.Context, n int) ([]Nudge, error) {
 	return out, nil
 }
 
+func (a *storeAPI) DeliveryAttempts(ctx context.Context, status string, n int) ([]DeliveryAttempt, error) {
+	as, err := a.s.ListDeliveryAttempts(ctx, status, n)
+	if err != nil {
+		return nil, mapErr(err)
+	}
+	out := make([]DeliveryAttempt, len(as))
+	for i, at := range as {
+		out[i] = DeliveryAttempt{
+			ID: at.ID, Kind: at.Kind, Rule: at.Rule, ReminderID: at.ReminderID,
+			Channel: at.Channel, Status: at.Status, Created: at.Created,
+		}
+		if at.HasComplete {
+			t := at.Completed
+			out[i].Completed = &t
+		}
+	}
+	return out, nil
+}
+
 func (a *storeAPI) WriteNote(ctx context.Context, ts time.Time, text string, embedding []float32, source string) (int64, error) {
 	id, err := a.s.WriteNote(ctx, ts, text, embedding, source)
 	return id, mapErr(err)
@@ -240,7 +259,7 @@ func (a *storeAPI) RevertFact(ctx context.Context, key string) (int64, error) {
 	return newID, mapErr(err)
 }
 
-func (a *storeAPI) Chat(ctx context.Context, text string) (string, error) {
+func (a *storeAPI) Chat(ctx context.Context, conversation, text string) (string, error) {
 	return "", errors.New("store: chat not available via direct store API")
 }
 
@@ -863,6 +882,16 @@ var methodTable = map[Method]handlerFunc{
 		}
 		return out, nil
 	}),
+	MethodDeliveryAttempts: withParams(func(ctx context.Context, api CoreAPI, p deliveryAttemptsReq) ([]DeliveryAttempt, error) {
+		out, err := api.DeliveryAttempts(ctx, p.Status, p.N)
+		if err != nil {
+			return nil, err
+		}
+		if out == nil {
+			out = []DeliveryAttempt{}
+		}
+		return out, nil
+	}),
 	MethodRecentNudges: withParams(func(ctx context.Context, api CoreAPI, p nReq) ([]Nudge, error) {
 		out, err := api.RecentNudges(ctx, p.N)
 		if err != nil {
@@ -974,7 +1003,7 @@ var methodTable = map[Method]handlerFunc{
 		return map[string]int64{"new_id": newID}, nil
 	}),
 	MethodChat: withParams(func(ctx context.Context, api CoreAPI, p chatReq) (chatResp, error) {
-		reply, err := api.Chat(ctx, p.Text)
+		reply, err := api.Chat(ctx, p.Conversation, p.Text)
 		return chatResp{Reply: reply}, err
 	}),
 	MethodTickTrace: withoutParams(func(ctx context.Context, api CoreAPI) (TickTrace, error) {

internal/ipc/unimplemented.go

@@ -68,6 +68,9 @@ func (UnimplementedCoreAPI) RecentActiveFactsByKind(ctx context.Context, kind st
 func (UnimplementedCoreAPI) CalendarEvents(ctx context.Context, from, to time.Time) ([]Fact, error) {
 	return nil, ErrNotImplemented
 }
+func (UnimplementedCoreAPI) DeliveryAttempts(ctx context.Context, status string, n int) ([]DeliveryAttempt, error) {
+	return nil, ErrNotImplemented
+}
 func (UnimplementedCoreAPI) RecentNudges(ctx context.Context, n int) ([]Nudge, error) {
 	return nil, ErrNotImplemented
 }
@@ -141,6 +144,6 @@ func (UnimplementedCoreAPI) MCPServers(ctx context.Context) ([]MCPServerStatus,
 func (UnimplementedCoreAPI) DayPlan(ctx context.Context) (DayPlan, error) {
 	return DayPlan{}, ErrNotImplemented
 }
-func (UnimplementedCoreAPI) Chat(ctx context.Context, text string) (string, error) {
+func (UnimplementedCoreAPI) Chat(ctx context.Context, conversation, text string) (string, error) {
 	return "", ErrNotImplemented
 }

internal/ipc/wire.go

@@ -28,6 +28,7 @@ const (
 	MethodRecentActiveFacts      Method = "recent_active_facts_by_kind"
 	MethodCalendarEvents         Method = "calendar_events"
 	MethodRecentNudges           Method = "recent_nudges"
+	MethodDeliveryAttempts       Method = "delivery_attempts"
 	MethodRecentEcoTraces        Method = "recent_ecosystem_traces"
 	MethodWriteNote              Method = "write_note"
 	MethodQueryNotes             Method = "query_notes"

internal/memory/lexical.go

@@ -60,6 +60,14 @@ var firstPerson = map[string]bool{
 // kill one false one. A question about his own life keeps the embedder alone
 // as its judge. A question about the world has to name something the memory
 // actually mentions.
+//
+// The veto's price was re-measured on 2026-08-03 (#496,
+// docs/evals/2026-08-03-recall-topic-veto.md). It costs one true recall and
+// buys one false one, and the fixture pass count is the same either way. The
+// lost case is an English paraphrase, not the cross-language loss it was
+// reported as, and the fixture has no cross-language case at all. Do not add a
+// script test or a bilingual stem map for it — both are no-ops here. The
+// separating signal is semantic and belongs in a reranker, not in this file.
 func RecallAllowed(query, text string) bool {
 	if mentionsHim(query) {
 		return true

internal/memory/lexical_test.go

@@ -31,6 +31,22 @@ func TestRecallAllowed(t *testing.T) {
 	}
 }
 
+// The known cost of the veto and the thing that pays for it, both measured on
+// the held-out fixture with the real embedder (#496,
+// docs/evals/2026-08-03-recall-topic-veto.md). The two are one lexical class:
+// zero shared content words, no first-person marker, scores 0.826 against 0.835
+// and margins 0.023 against 0.019. Recovering the first re-admits the second,
+// which puts false recall back to 1/5. Anyone loosening the veto has to move
+// the first line without moving the second.
+func TestRecallVetoTradeIsPinned(t *testing.T) {
+	if RecallAllowed("what fixed the screen problem", "the flicker went away once i swapped the display cable") {
+		t.Error("en-hard-024 is expected to stay vetoed — if this passes now, re-measure false recall before celebrating")
+	}
+	if RecallAllowed("во сколько отходит поезд", "погулял вдоль реки") {
+		t.Error("ru-silent-029 must stay vetoed — this is the false recall the veto exists to stop")
+	}
+}
+
 // A question made only of filler has no topic word to match on, and the score
 // gate is then the only judge it can have.
 func TestRecallAllowedFallsBackWhenNothingToCompare(t *testing.T) {

internal/memory/recalleval/recalleval.go

@@ -90,9 +90,44 @@ func Load() (Fixture, error) {
 	if len(f.Cases) == 0 {
 		return Fixture{}, fmt.Errorf("fixture has no cases")
 	}
+	if err := checkIDs(f); err != nil {
+		return Fixture{}, err
+	}
 	return f, nil
 }
 
+// checkIDs refuses a fixture where a case note and a filler note share an id.
+//
+// Every case is scored over its own notes plus the whole filler set, and the
+// two stores disagree about what a repeated id means: the sqlite store upserts
+// on it, the in-memory store appends. So one collision makes a case score
+// differently on the two backends, and it reads as an embedder or gate
+// difference, which is the one thing this harness exists to measure (Vikunja
+// #386). It was dodged once by hand during #373 by renaming two ids.
+//
+// Checked in Load rather than in the test, so every caller of the fixture is
+// covered and not only the one that remembers to look.
+func checkIDs(f Fixture) error {
+	filler := make(map[string]bool, len(f.Filler))
+	for _, n := range f.Filler {
+		if n.ID == "" {
+			return fmt.Errorf("filler note with an empty id")
+		}
+		if filler[n.ID] {
+			return fmt.Errorf("duplicate filler note id %q", n.ID)
+		}
+		filler[n.ID] = true
+	}
+	for _, c := range f.Cases {
+		for _, n := range c.Notes {
+			if filler[n.ID] {
+				return fmt.Errorf("case %s: note id %q collides with a filler note", c.ID, n.ID)
+			}
+		}
+	}
+	return nil
+}
+
 // NewStore builds an empty store for one case, plus a function to release it.
 // A factory rather than a store because every case needs a clean index — notes
 // from case A must not be visible to case B's query.

internal/memory/recalleval/recalleval_test.go

@@ -337,3 +337,28 @@ func marginSweep(t *testing.T, emb router.Embedder, f Fixture) string {
 	}
 	return b.String()
 }
+
+// TestFillerIDCollisionIsRefused — the guard that keeps a fixture edit from
+// looking like a backend difference (Vikunja #386).
+func TestFillerIDCollisionIsRefused(t *testing.T) {
+	f := Fixture{
+		SchemaVersion: SchemaVersion,
+		Cases:         []Case{{ID: "ru-001", Notes: []StoredNote{{ID: "f1", Text: "..."}}}},
+		Filler:        []StoredNote{{ID: "f1", Text: "..."}},
+	}
+	if err := checkIDs(f); err == nil {
+		t.Fatal("a case note reusing a filler id must be refused")
+	}
+	f.Filler = append(f.Filler, StoredNote{ID: "f1", Text: "..."})
+	if err := checkIDs(Fixture{SchemaVersion: SchemaVersion, Filler: f.Filler}); err == nil {
+		t.Fatal("a duplicate filler id must be refused")
+	}
+	ok := Fixture{
+		SchemaVersion: SchemaVersion,
+		Cases:         []Case{{ID: "ru-001", Notes: []StoredNote{{ID: "n1", Text: "..."}}}},
+		Filler:        []StoredNote{{ID: "f1", Text: "..."}},
+	}
+	if err := checkIDs(ok); err != nil {
+		t.Fatalf("a clean fixture must pass: %v", err)
+	}
+}

internal/morning/morning.go

@@ -30,6 +30,18 @@ type Item struct {
 	Key     string
 	FactKey string
 	Label   string // RU text surfaced when this item is still missing.
+	// Optional — a missing one is not worth a nudge on its own.
+	//
+	// Every item was implicitly required until 04-08-2026, because there was
+	// no field, so a skipped stretch read exactly like skipped medication and
+	// #280's first behaviour could not hold (Vikunja #473). A checklist where
+	// everything is mandatory is a checklist he learns to ignore.
+	//
+	// It changes two things and nothing else: an all-optional routine never
+	// nudges, and a nudge that does fire names the optional stragglers after
+	// the required ones, in softer words. Evidence, the window and the day
+	// plan treat both kinds alike — a missing optional item is still missing.
+	Optional bool
 }
 
 // Routine — one daily checklist. WindowStart/WindowEnd are "HH:MM" local
@@ -60,12 +72,37 @@ type Status struct {
 }
 
 // Candidate — a routine that's due for its one-per-day nag: the window has
-// reached NudgeAt and at least one item is still unevidenced.
+// reached NudgeAt and at least one REQUIRED item is still unevidenced. Missing
+// carries the optional stragglers too, so the one message she is allowed per
+// day per routine can mention them; they never cause it.
 type Candidate struct {
 	Routine Routine
 	Missing []Item
 }
 
+// Required reports the missing items that are not optional. The nudge fires on
+// these; the rest ride along.
+func Required(missing []Item) []Item {
+	var out []Item
+	for _, it := range missing {
+		if !it.Optional {
+			out = append(out, it)
+		}
+	}
+	return out
+}
+
+// OptionalOnly is the other half of Required.
+func OptionalOnly(missing []Item) []Item {
+	var out []Item
+	for _, it := range missing {
+		if it.Optional {
+			out = append(out, it)
+		}
+	}
+	return out
+}
+
 // 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
@@ -191,7 +228,11 @@ func Due(routines []Routine, facts map[string]store.Fact, last map[string]time.T
 				missing = append(missing, it)
 			}
 		}
-		if len(missing) == 0 {
+		// 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 {
 			continue
 		}
 		if prev, seen := last[r.Name]; seen && sameDay(prev, now) {

internal/morning/morning_test.go

@@ -182,3 +182,40 @@ func TestDueRespectsExplicitNudgeAt(t *testing.T) {
 		t.Fatalf("expected candidate at explicit nudge_at, got %d", len(out))
 	}
 }
+
+// TestOptionalItemsDoNotEarnANudge — behaviour 1 of #280, which could not hold
+// while every item was implicitly required (Vikunja #473).
+func TestOptionalItemsDoNotEarnANudge(t *testing.T) {
+	r := Routine{
+		Name:        "утро",
+		WindowStart: "07:00",
+		WindowEnd:   "10:00",
+		Items: []Item{
+			{Key: "meds", FactKey: "meds", Label: "таблетки"},
+			{Key: "stretch", FactKey: "stretch", Label: "растяжка", Optional: true},
+		},
+	}
+	now := time.Date(2026, 8, 4, 10, 0, 0, 0, time.UTC)
+	took := map[string]store.Fact{"meds": {Key: "meds", Ts: now.Add(-2 * time.Hour)}}
+
+	// Only the stretch was skipped: nothing to say.
+	if due := Due([]Routine{r}, took, map[string]time.Time{}, now); len(due) != 0 {
+		t.Fatalf("an optional item alone must not nudge, got %+v", due)
+	}
+	// The medication was skipped: she says so, and mentions the stretch too.
+	due := Due([]Routine{r}, map[string]store.Fact{}, map[string]time.Time{}, now)
+	if len(due) != 1 {
+		t.Fatalf("a missing required item must nudge, got %+v", due)
+	}
+	if got := Required(due[0].Missing); len(got) != 1 || got[0].Key != "meds" {
+		t.Fatalf("Required = %+v, want the meds item alone", got)
+	}
+	if got := OptionalOnly(due[0].Missing); len(got) != 1 || got[0].Key != "stretch" {
+		t.Fatalf("OptionalOnly = %+v, want the stretch item alone", got)
+	}
+	// The window still reports it as missing — optional is not invisible.
+	st := Evaluate(r, map[string]store.Fact{}, now.Add(-time.Hour))
+	if len(st.Missing) != 2 {
+		t.Fatalf("Evaluate must still list both, got %+v", st.Missing)
+	}
+}

internal/pattern/detector.go

@@ -53,9 +53,31 @@ const MinOnPatternFraction = 0.7
 // a repeat. False negatives cost one more observation and nothing else.
 const MinEvents = 4
 
+// MinIntervalDays — the fastest rhythm that may be called a routine. Two
+// hours.
+//
+// Without a floor, four taps of the same key minutes apart give intervals near
+// 0.002 days. They all sit inside the ±50% band by construction, so the
+// detector proposed a routine and PhraseRoutine worded it as "каждый день"
+// (Vikunja #468). The damage outlives the mistake: UNIQUE(action, object)
+// means dismissing the bogus proposal burns that pair permanently, so the real
+// routine behind it can never be proposed again.
+//
+// Two hours rather than a day, because a genuine habit can run several times a
+// day — meals, water, a break. Anything faster than that is not a habit she
+// should be proposing to remind him about; the loop rules already cover that
+// range, and they are rules, not guesses. It is checked against the median, so
+// one quick repeat inside a real rhythm still counts.
+//
+// The other half of this is that hand-QA of the detector was unsafe: seeding a
+// pattern the obvious way, four chat turns in a row, poisoned the very pair
+// being tested.
+const MinIntervalDays = 2.0 / 24.0
+
 // Detect checks whether a sequence of events for the same action+object
 // forms a stable recurring pattern. Returns a ProposedRoutine when:
 //   - At least MinEvents events exist (≥3 intervals)
+//   - The median interval is at least MinIntervalDays
 //   - At least MinOnPatternFraction of the intervals sit within
 //     MaxIntervalRatio of the median interval
 //
@@ -88,8 +110,8 @@ func Detect(events []Event) (*ProposedRoutine, error) {
 	}
 
 	center := medianFloat(intervals)
-	if center <= 0 {
-		return nil, nil
+	if center <= 0 || center < MinIntervalDays {
+		return nil, nil // a burst, not a rhythm — see MinIntervalDays
 	}
 
 	// Keep the intervals that sit inside the band around the median. The

internal/pattern/detector_test.go

@@ -216,3 +216,46 @@ func TestDetectMedianBandNotExtremes(t *testing.T) {
 		})
 	}
 }
+
+// A burst is not a habit. Four taps of the same key minutes apart give
+// intervals near 0.002 days, all inside the ±50% band by construction, so the
+// detector called it a daily routine (Vikunja #468). Dismissing that proposal
+// burns the action+object pair permanently, which also made hand-QA of the
+// detector unsafe.
+func TestDetectRejectsABurst(t *testing.T) {
+	base := time.Date(2026, 8, 4, 9, 0, 0, 0, time.UTC)
+	var events []Event
+	for i := 0; i < 4; i++ {
+		events = append(events, Event{
+			Action: "refill", Object: "cat_water",
+			Ts: base.Add(time.Duration(i) * 7 * time.Minute),
+		})
+	}
+	r, err := Detect(events)
+	if err != nil {
+		t.Fatalf("Detect: %v", err)
+	}
+	if r != nil {
+		t.Fatalf("four taps minutes apart proposed a routine every %.3f days", r.IntervalDays)
+	}
+}
+
+// The floor is two hours, not a day: a habit that runs several times a day is
+// still a habit.
+func TestDetectKeepsASeveralTimesADayHabit(t *testing.T) {
+	base := time.Date(2026, 8, 4, 8, 0, 0, 0, time.UTC)
+	var events []Event
+	for i := 0; i < 5; i++ {
+		events = append(events, Event{
+			Action: "drink", Object: "water",
+			Ts: base.Add(time.Duration(i) * 4 * time.Hour),
+		})
+	}
+	r, err := Detect(events)
+	if err != nil {
+		t.Fatalf("Detect: %v", err)
+	}
+	if r == nil {
+		t.Fatal("a four-hour rhythm over five events is a habit, got nil")
+	}
+}

internal/phraser/eval/checks.go

@@ -173,12 +173,23 @@ func checkFeminine(body string) Result {
 	// Second pass: self-reference with the pronoun dropped — "напомнил тебе",
 	// "проверил за тебя". A masculine past-tense verb whose object is HIM can
 	// only be her speaking about herself.
+	//
+	// Two guards, both from a false positive on the talk fixture: "ты заплатил
+	// за домен до марта" scored as her drift and cost the run a point it had
+	// earned (Vikunja #462). He is male, so a past-tense verb governed by "ты"
+	// must be masculine. And a bare "за" is not evidence of anything — "за
+	// домен" is a price, "за тебя" is her doing something on his behalf — so it
+	// only counts when he is the one it points at.
 	for i, w := range words {
-		if !masculinePast(w) || i+1 >= len(words) {
+		if !masculinePast(w) || i+1 >= len(words) || governedByYou(words, i) {
 			continue
 		}
 		next := words[i+1]
-		if next == "тебе" || next == "тебя" || next == "за" {
+		aboutHim := next == "тебе" || next == "тебя"
+		if next == "за" && i+2 < len(words) && (words[i+2] == "тебя" || words[i+2] == "тебе") {
+			aboutHim = true
+		}
+		if aboutHim {
 			return Result{CheckFeminine, false,
 				fmt.Sprintf("masculine self-reference %q before %q", w, next)}
 		}
@@ -652,3 +663,19 @@ func checkEllipsis(body string) Result {
 	}
 	return Result{CheckEllipsis, true, ""}
 }
+
+// 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.
+func governedByYou(words []string, i int) bool {
+	for j := i - 1; j >= 0 && j >= i-3; j-- {
+		switch words[j] {
+		case "ты":
+			return true
+		case "я":
+			return false
+		}
+	}
+	return false
+}

internal/phraser/eval/eval_test.go

@@ -106,6 +106,12 @@ func TestChecksCatchWhatTheyClaim(t *testing.T) {
 		{"masculine predicative", "я должен сказать: попей воды.", CheckFeminine},
 		// The other direction: HE is male, so second-person masculine is right.
 		{"second person masculine ok", "ты не пил воду четыре часа.", ""},
+		// The recorded false positive: "заплатил" sits before "за", and the
+		// second pass read that as her dropping the pronoun. The subject is
+		// "ты" and he is male, so the reply is right (Vikunja #462).
+		{"second person masculine before за", "ты заплатил за домен до марта, а воду пить всё равно надо.", ""},
+		// The same shape she really does get wrong still trips.
+		{"masculine on his behalf", "проверил за тебя — воды не было четыре часа.", CheckFeminine},
 		// The real observed failure: she addressed him as a woman.
 		{"feminine second person", "ты давно не отдыхала — попей воды.", CheckHisGender},
 		{"feminine second person no dash", "ты пила воду четыре часа назад.", CheckHisGender},

internal/phraser/eval/talk.go

@@ -26,20 +26,22 @@ import (
 	"time"
 
 	"github.com/kami/maven/internal/dialogue"
+	"github.com/kami/maven/internal/router"
 )
 
 //go:embed talk_v1.json
 var talkFixtureJSON []byte
 
-// The three phrasing paths under test. Values match the fixture's "path" field.
+// The phrasing paths under test. Values match the fixture's "path" field.
 const (
 	PathChat      = "chat"      // PhraseChat
 	PathQuery     = "query"     // PhraseQuery with notes
 	PathKnowledge = "knowledge" // PhraseQuery with no notes
+	PathReply     = "reply"     // PhraseReply, the reactive confirmation
 )
 
 // TalkPaths — report order.
-var TalkPaths = []string{PathChat, PathQuery, PathKnowledge}
+var TalkPaths = []string{PathChat, PathQuery, PathKnowledge, PathReply}
 
 // TalkCheckNames — the checks that apply to a free-form reply, in report order.
 // Deliberately a subset of CheckNames: length, mood and "no questions" are nudge
@@ -58,12 +60,19 @@ var TalkCheckNames = []string{
 // WantAny is the on-topic contract: at least one lowercased fragment must appear
 // in the reply. Fragments are stems ("пароль" → "парол") so declension does not
 // defeat them.
+//
+// Intent, Key and Value carry the reply path's decision: that path is phrased
+// from what the router already resolved, not from the raw utterance. Utterance
+// stays filled anyway, because it is what a human reads in the report.
 type TalkCase struct {
 	ID        string   `json:"id"`
 	Path      string   `json:"path"`
 	Utterance string   `json:"utterance"`
 	History   []string `json:"history,omitempty"`
 	Notes     []string `json:"notes,omitempty"`
+	Intent    string   `json:"intent,omitempty"`
+	Key       string   `json:"key,omitempty"`
+	Value     string   `json:"value,omitempty"`
 	WantAny   []string `json:"want_any"`
 	Tags      []string `json:"tags,omitempty"`
 	Note      string   `json:"note,omitempty"`
@@ -92,13 +101,27 @@ func LoadTalk() (TalkFixture, error) {
 	return f, nil
 }
 
-// Talker — the two methods a conversational path must have to be scorable.
-// *phraser.LLMPhraser satisfies it; same trick as Nudger.
+// Talker — the methods a conversational path must have to be scorable.
+// *phraser.LLMPhraser satisfies the first two; *phraser.Replier satisfies the
+// third, so a run that scores all four paths passes a Pair.
 type Talker interface {
 	PhraseChat(ctx context.Context, utterance string, history []dialogue.Turn) (string, error)
 	PhraseQuery(ctx context.Context, utterance string, notes []string) (string, error)
 }
 
+// Confirmer — the reply path. *phraser.Replier satisfies it.
+type Confirmer interface {
+	PhraseReply(ctx context.Context, d router.Decision) (string, error)
+}
+
+// Pair joins the two objects the daemon wires separately — the phraser and the
+// replier — so one ScoreTalk call covers every path Maven speaks through. A bare
+// Talker still works; its reply cases score as errors, which is honest.
+type Pair struct {
+	Talker
+	Confirmer
+}
+
 // TalkOutcome — one scored case.
 type TalkOutcome struct {
 	Case    TalkCase
@@ -194,10 +217,30 @@ func (c TalkCase) run(ctx context.Context, t Talker) (string, error) {
 		return t.PhraseQuery(ctx, c.Utterance, c.Notes)
 	case PathKnowledge:
 		return t.PhraseQuery(ctx, c.Utterance, nil)
+	case PathReply:
+		conf, ok := t.(Confirmer)
+		if !ok {
+			return "", fmt.Errorf("target cannot phrase replies — pass a Pair")
+		}
+		return conf.PhraseReply(ctx, c.decision())
 	}
 	return "", fmt.Errorf("unknown path %q", c.Path)
 }
 
+// decision rebuilds what the router would have handed the replier. Text is the
+// utterance for a note or a reminder, which is what the router puts there.
+func (c TalkCase) decision() router.Decision {
+	return router.Decision{
+		Intent: router.Intent(c.Intent),
+		Slots: router.Slots{
+			Key:    c.Key,
+			Value:  c.Value,
+			Text:   c.Utterance,
+			HasKey: c.Key != "",
+		},
+	}
+}
+
 func (c TalkCase) turns() []dialogue.Turn {
 	turns := make([]dialogue.Turn, 0, len(c.History))
 	for _, h := range c.History {

internal/phraser/eval/talk_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/kami/maven/internal/llm"
 	"github.com/kami/maven/internal/persona"
 	"github.com/kami/maven/internal/phraser"
+	"github.com/kami/maven/internal/router"
 )
 
 // perPathMinimum — the resolution floor. A per-path score built on a handful of
@@ -36,6 +37,10 @@ func TestTalkFixture(t *testing.T) {
 
 		switch c.Path {
 		case PathChat, PathQuery, PathKnowledge:
+		case PathReply:
+			if c.Intent == "" {
+				t.Errorf("%s: reply case has no intent — the replier is phrased from the decision", c.ID)
+			}
 		default:
 			t.Errorf("%s: unknown path %q", c.ID, c.Path)
 		}
@@ -69,10 +74,15 @@ type fakeTalker struct{ reply string }
 func (f fakeTalker) PhraseChat(context.Context, string, []dialogue.Turn) (string, error) {
 	return f.reply, nil
 }
+
 func (f fakeTalker) PhraseQuery(context.Context, string, []string) (string, error) {
 	return f.reply, nil
 }
 
+func (f fakeTalker) PhraseReply(context.Context, router.Decision) (string, error) {
+	return f.reply, nil
+}
+
 // TestScoreTalkCounts — a reply that fails on purpose must be counted on every
 // path, so a real run cannot report a hidden zero.
 func TestScoreTalkCounts(t *testing.T) {
@@ -104,7 +114,7 @@ func TestScoreTalkCounts(t *testing.T) {
 	}
 }
 
-// TestLLMTalkBaseline — the resident model on the three conversational paths.
+// TestLLMTalkBaseline — the resident model on all four phrasing paths.
 // Opt-in exactly like TestLLMPhrasingBaseline: CI has no model and a run costs
 // minutes on the CPU target.
 //
@@ -148,7 +158,12 @@ func TestLLMTalkBaseline(t *testing.T) {
 	}
 	t.Logf("scoring model %s at %s", model, base)
 
-	rep, err := ScoreTalk(ctx, "llm ("+model+", built-in persona)", p, f)
+	// The reply path is a separate object in the daemon too: the phraser owns its
+	// own llama-server, the replier is handed an llm.Client. Pair scores both.
+	block := func() string { return persona.Facts{}.Block(time.Now()) }
+	target := Pair{Talker: p, Confirmer: phraser.NewReplier(llm.New(base, cfg.Timeout), block)}
+
+	rep, err := ScoreTalk(ctx, "llm ("+model+", built-in persona)", target, f)
 	if err != nil {
 		t.Fatalf("ScoreTalk: %v", err)
 	}

internal/phraser/eval/talk_v1.json

@@ -222,6 +222,90 @@
       "utterance": "почему гром слышно позже молнии?",
       "want_any": ["звук", "све", "быстр", "гром", "молни"],
       "tags": ["general"]
+    },
+    {
+      "id": "reply-fact-coffee",
+      "path": "reply",
+      "intent": "fact",
+      "key": "кофе",
+      "value": "закончился",
+      "utterance": "кофе закончился",
+      "want_any": ["коф"],
+      "tags": ["fact"],
+      "note": "The plainest confirmation there is, and the sentence he hears most often."
+    },
+    {
+      "id": "reply-fact-weight",
+      "path": "reply",
+      "intent": "fact",
+      "key": "вес",
+      "value": "82",
+      "utterance": "мой вес 82",
+      "want_any": ["вес", "82"],
+      "tags": ["fact", "number"],
+      "note": "A number must survive into the confirmation; a paraphrase that drops it is useless."
+    },
+    {
+      "id": "reply-fact-pill",
+      "path": "reply",
+      "intent": "fact",
+      "key": "таблетки",
+      "value": "выпил",
+      "utterance": "таблетки выпил",
+      "want_any": ["таблетк"],
+      "tags": ["fact", "feminine"],
+      "note": "He says 'выпил', masculine and about himself. She must not copy the form onto herself."
+    },
+    {
+      "id": "reply-note-router",
+      "path": "reply",
+      "intent": "note",
+      "utterance": "роутер перезагружается сам по ночам",
+      "want_any": ["роутер"],
+      "tags": ["note"]
+    },
+    {
+      "id": "reply-note-long",
+      "path": "reply",
+      "intent": "note",
+      "utterance": "если диск снова отвалится, посмотреть кабель, а не контроллер, в прошлый раз был кабель",
+      "want_any": ["диск", "кабел"],
+      "tags": ["note", "length"],
+      "note": "A long note baits a long confirmation. One sentence is the contract."
+    },
+    {
+      "id": "reply-reminder-evening",
+      "path": "reply",
+      "intent": "reminder",
+      "utterance": "напомни вечером полить цветы",
+      "want_any": ["цвет", "полит", "вечер"],
+      "tags": ["reminder"]
+    },
+    {
+      "id": "reply-reminder-tomorrow",
+      "path": "reply",
+      "intent": "reminder",
+      "utterance": "напомни завтра позвонить в поликлинику",
+      "want_any": ["поликлиник", "позвон", "звон"],
+      "tags": ["reminder"]
+    },
+    {
+      "id": "reply-formality-bait",
+      "path": "reply",
+      "intent": "note",
+      "utterance": "запишите пожалуйста что счётчики я сдал",
+      "want_any": ["счётчик", "счетчик"],
+      "tags": ["note", "persona-bait", "address"],
+      "note": "Polite plural in the input. The confirmation must still be на ты."
+    },
+    {
+      "id": "reply-question-bait",
+      "path": "reply",
+      "intent": "note",
+      "utterance": "надо купить фильтр для воды, не помню какой",
+      "want_any": ["фильтр"],
+      "tags": ["note", "no-question"],
+      "note": "An unresolved note invites her to ask which filter. A confirmation does not ask."
     }
   ]
 }

internal/phraser/llmphraser.go

@@ -1,6 +1,7 @@
 package phraser
 
 import (
+	"bufio"
 	"bytes"
 	"context"
 	"encoding/json"
@@ -8,6 +9,7 @@ import (
 	"io"
 	"log"
 	"net/http"
+	"os"
 	"os/exec"
 	"regexp"
 	"strings"
@@ -83,6 +85,19 @@ type Config struct {
 	NCtx       int
 	Timeout    time.Duration
 
+	// CacheRAMMiB bounds llama-server's prompt cache, which is what actually ate
+	// this box. Measured on homesrv 2026-08-03: the server's own default limit is
+	// 8192 MiB, it stores the full KV state of every idle slot it evicts (112 kiB
+	// per token, so 166 MiB for one 1521-token prompt), and RSS climbed by that
+	// much per distinct prompt until it hit 7.9 GB and half a gigabyte went to
+	// swap. Weights are only 1.1 GB and mmapped, and -ngl 99 costs almost no RSS
+	// because RADV keeps device memory outside the process.
+	//
+	// 0 ⇒ the flag is not passed and the server's own 8 GiB default applies. That
+	// is the escape hatch for a llama-server too old to know --cache-ram, not a
+	// recommendation. See docs/evals/2026-08-03-llama-prompt-cache.md.
+	CacheRAMMiB int
+
 	// ContextBlock renders the shared context block (who he is, how to
 	// address him, the time) fresh for each turn. See internal/persona.
 	// nil ⇒ no block, the prompts stand alone.
@@ -116,7 +131,9 @@ func DefaultConfig(modelPath string) Config {
 		Listen:     "127.0.0.1:0",
 		NGpuLayers: -1,
 		NCtx:       2048,
-		Timeout:    30 * time.Second,
+		// 512 MiB caps total RSS near 1 GB and still holds several recent prompts.
+		CacheRAMMiB: 512,
+		Timeout:     30 * time.Second,
 	}
 }
 
@@ -225,8 +242,10 @@ func spawnLlamaServer(ctx context.Context, cfg Config) (backend, error) {
 	return p, nil
 }
 
-func startLlamaProc(ctx context.Context, cfg Config) (*llamaProc, error) {
-	p := &llamaProc{}
+// llamaArgs is the command line for one resident server. It is a function and
+// not an inline literal because kill-maven.sh's orphan sweep matches against
+// this exact line, and a test pins the two together.
+func llamaArgs(cfg Config) []string {
 	args := []string{
 		"-m", cfg.ModelPath,
 		"--host", "127.0.0.1",
@@ -235,7 +254,15 @@ func startLlamaProc(ctx context.Context, cfg Config) (*llamaProc, error) {
 		"-ngl", fmt.Sprintf("%d", cfg.NGpuLayers),
 		"--no-webui",
 	}
-	cmd := exec.CommandContext(ctx, cfg.BinPath, args...)
+	if cfg.CacheRAMMiB > 0 {
+		args = append(args, "--cache-ram", fmt.Sprintf("%d", cfg.CacheRAMMiB))
+	}
+	return args
+}
+
+func startLlamaProc(ctx context.Context, cfg Config) (*llamaProc, error) {
+	p := &llamaProc{}
+	cmd := exec.CommandContext(ctx, cfg.BinPath, llamaArgs(cfg)...)
 	// Pdeathsig: the kernel SIGKILLs llama-server the moment mavend dies — by
 	// ANY means, including SIGKILL/OOM/panic where our Close() never runs. Without
 	// it a hard-killed mavend orphans its llama-server (reparented to init, keeps
@@ -246,63 +273,104 @@ func startLlamaProc(ctx context.Context, cfg Config) (*llamaProc, error) {
 	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true, Pdeathsig: syscall.SIGKILL}
 	p.cmd = cmd
 
-	stderr, err := cmd.StderrPipe()
+	// One pipe for both streams. llama.cpp writes its buffer sizes, KV-cache
+	// layout and offload lines to stderr and its request log to stdout, and
+	// stdout used to go nowhere at all — so nothing about the model's memory was
+	// diagnosable from a running box. Both ends land in mavend's log now.
+	pr, pw, err := os.Pipe()
 	if err != nil {
-		return nil, fmt.Errorf("llm: stderr pipe: %w", err)
+		return nil, fmt.Errorf("llm: output pipe: %w", err)
 	}
+	cmd.Stdout = pw
+	cmd.Stderr = pw
 
 	if err := cmd.Start(); err != nil {
-		stderr.Close()
+		pr.Close()
+		pw.Close()
 		return nil, fmt.Errorf("llm: start: %w", err)
 	}
+	// The child holds the only other reference to the write end. Dropping ours
+	// is what makes the reader see EOF when the child dies.
+	pw.Close()
 
 	portCh := make(chan string, 1)
 	errCh := make(chan error, 1)
+	tail := &lineTail{}
 	p.wg.Add(1)
 	go func() {
 		defer p.wg.Done()
-		buf := make([]byte, 4096)
-		var leftover []byte
-		for {
-			n, err := stderr.Read(buf)
-			if n > 0 {
-				data := append(leftover, buf[:n]...)
-				lines := bytes.Split(data, []byte("\n"))
-				for _, line := range lines[:len(lines)-1] {
-					if m := listenRE.FindSubmatch(line); len(m) > 1 {
-						addr := string(m[1])
-						portCh <- addr
-						close(portCh)
-					}
+		defer pr.Close()
+		sc := bufio.NewScanner(pr)
+		// llama.cpp prints one prompt per line and a prompt can be long.
+		sc.Buffer(make([]byte, 0, 64*1024), 1024*1024)
+		listening := false
+		for sc.Scan() {
+			line := sc.Bytes()
+			log.Printf("llama: %s", line)
+			if !listening {
+				tail.add(string(line))
+				if m := listenRE.FindSubmatch(line); len(m) > 1 {
+					listening = true
+					portCh <- string(m[1])
+					close(portCh)
 				}
-				leftover = lines[len(lines)-1]
-			}
-			if err != nil {
-				errCh <- err
-				return
 			}
 		}
+		err := sc.Err()
+		if err == nil {
+			err = io.EOF
+		}
+		errCh <- err
 	}()
 
+	fail := func(err error) (*llamaProc, error) {
+		_ = cmd.Process.Kill()
+		_ = cmd.Wait()
+		return nil, err
+	}
 	select {
 	case addr := <-portCh:
 		p.base = addr
 		return p, nil
 	case err := <-errCh:
-		_ = cmd.Process.Kill()
-		_ = cmd.Wait()
-		return nil, fmt.Errorf("llm: server output: %w", err)
+		// The tail is the whole diagnosis when the server dies during load: bare
+		// "EOF" never said which layer or which allocation it choked on.
+		return fail(fmt.Errorf("llm: server output: %w; last output: %s", err, tail.String()))
 	case <-ctx.Done():
-		_ = cmd.Process.Kill()
-		_ = cmd.Wait()
-		return nil, ctx.Err()
+		return fail(ctx.Err())
 	case <-time.After(60 * time.Second):
-		_ = cmd.Process.Kill()
-		_ = cmd.Wait()
-		return nil, fmt.Errorf("llm: server did not start within 60s")
+		return fail(fmt.Errorf("llm: server did not start within 60s; last output: %s", tail.String()))
 	}
 }
 
+// lineTail keeps the last few startup lines so a server that dies before it
+// listens can say why in the error, not just "EOF". Written by the reader
+// goroutine and read by whoever gives up on startup, so it takes a lock.
+type lineTail struct {
+	mu    sync.Mutex
+	lines []string
+}
+
+const lineTailMax = 12
+
+func (t *lineTail) add(line string) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.lines = append(t.lines, line)
+	if len(t.lines) > lineTailMax {
+		t.lines = t.lines[len(t.lines)-lineTailMax:]
+	}
+}
+
+func (t *lineTail) String() string {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	if len(t.lines) == 0 {
+		return "(no output)"
+	}
+	return strings.Join(t.lines, " | ")
+}
+
 // BaseURL is the llama-server this phraser talks to right now. It changes when
 // the model is swapped, so callers that cache it must register an observer
 // (OnSwap) rather than keeping the string forever.

internal/phraser/replier.go

@@ -0,0 +1,112 @@
+// phraser/replier.go — reactive reply phrasing, the confirmation he hears
+// after every fact, note and reminder.
+//
+// It lived in cmd/mavend as package main until Vikunja #396, which meant the
+// most frequently heard sentence Maven says was the one path the phrasing eval
+// could not import, let alone score. Nothing here talks to the daemon: the
+// caller supplies the completer and the context block, and cmd/mavend keeps the
+// stub fallback so a model error still answers.
+package phraser
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"github.com/kami/maven/internal/llm"
+	"github.com/kami/maven/internal/persona"
+	"github.com/kami/maven/internal/router"
+)
+
+// Completer is the model seam for the replier, a subset of router.Completer.
+// *llm.Client satisfies it.
+type Completer interface {
+	Complete(ctx context.Context, r llm.Req) (string, error)
+}
+
+// replyTimeout bounds one reply. Generous because the resident model on the CPU
+// floor is slow and the caller has a deterministic fallback anyway.
+const replyTimeout = 60 * time.Second
+
+// ReplySystemPrompt — the reactive confirmation contract: one short Russian
+// sentence, feminine self-reference, informal address, no question.
+const ReplySystemPrompt = `Ты — Maven, домашняя ассистентка (о себе — в женском роде). Владелец — мужчина, говоришь с ним на "ты", в единственном числе; никогда не "вы"/"ваш" и не "он"/"его". Подтверди действие РОВНО ОДНИМ коротким предложением (≤120 символов), по-русски, спокойно и без официальных формулировок. Не задавай вопросов, не повторяй слова, не добавляй ничего после точки. Отвечай ТОЛЬКО одним объектом JSON с полями "response" (текст) и "mood" (ровно одно из: neutral, happy, thinking, tired, confused).
+Пример: {"response": "Записала, что ты выпил стакан воды.", "mood": "neutral"}
+Никогда не пиши "..." в поле response.`
+
+// Replier phrases reactive confirmations with the resident model. It has no
+// fallback of its own: an error is returned, and the daemon answers from the
+// deterministic stub. That is also what makes it scorable — a dead server shows
+// up as an error rather than as bad phrasing.
+type Replier struct {
+	c Completer
+
+	// block renders the shared context block per turn (who he is, the time).
+	// nil ⇒ the prompt stands alone.
+	block func() string
+}
+
+// NewReplier builds a replier over c. block may be nil.
+func NewReplier(c Completer, block func() string) *Replier {
+	return &Replier{c: c, block: block}
+}
+
+// PhraseReply returns the confirmation for one decision. An empty string with a
+// nil error means the model produced nothing usable, which the caller must
+// treat exactly like an error.
+func (r *Replier) PhraseReply(ctx context.Context, d router.Decision) (string, error) {
+	ctx, cancel := context.WithTimeout(ctx, replyTimeout)
+	defer cancel()
+	out, err := r.c.Complete(ctx, llm.Req{
+		System:        persona.Prepend(r.block, ReplySystemPrompt),
+		User:          replyContext(d),
+		Grammar:       ResponseGrammar,
+		MaxTokens:     512,
+		RepeatPenalty: 1.3,
+	})
+	if err != nil {
+		return "", err
+	}
+	out = stripThink(out)
+	if response, _, perr := parseResponseMood(out); perr != nil {
+		return "", perr
+	} else if response != "" {
+		return response, nil
+	}
+	// fallback: the model answered in bare prose, which is fine here.
+	return firstSentence(out), nil
+}
+
+// firstSentence trims the model's output to a single clean confirmation: first
+// line, first sentence, whitespace-normalized — the last-line defense against a
+// small model that rambles past the first period despite the prompt + stop.
+func firstSentence(s string) string {
+	s = strings.TrimSpace(s)
+	if i := strings.IndexByte(s, '\n'); i >= 0 {
+		s = s[:i]
+	}
+	// keep up to and including the first sentence-ending punctuation.
+	if i := strings.IndexAny(s, ".!?"); i >= 0 {
+		s = s[:i+1]
+	}
+	return strings.TrimSpace(s)
+}
+
+// replyContext renders the decision into a compact RU description for the model.
+func replyContext(d router.Decision) string {
+	switch d.Intent {
+	case router.IntentFact:
+		return "записала факт: " + d.Slots.Key + " " + d.Slots.Value
+	case router.IntentNote:
+		return "сохранила заметку: " + d.Slots.Text
+	case router.IntentReminder:
+		return "поставила напоминание: " + d.Slots.Text
+	default:
+		return string(d.Intent) + ": " + d.Slots.Text
+	}
+}
+
+// StripThink removes the <think> block a Thinking-variant model emits before its
+// answer. Exported for the daemon's own model callers, which parse output that
+// never passes through a phraser method.
+func StripThink(s string) string { return stripThink(s) }

internal/phraser/replier_test.go

@@ -0,0 +1,90 @@
+package phraser
+
+import (
+	"context"
+	"testing"
+
+	"github.com/kami/maven/internal/llm"
+	"github.com/kami/maven/internal/router"
+)
+
+type mockCompleter struct {
+	out string
+	err error
+}
+
+func (m mockCompleter) Complete(_ context.Context, _ llm.Req) (string, error) { return m.out, m.err }
+
+func TestReplierReturnsLLMReply(t *testing.T) {
+	r := NewReplier(mockCompleter{out: `{"response":"записала, кофе закончился","mood":"neutral"}`}, nil)
+	got, err := r.PhraseReply(context.Background(), noteDecision())
+	if err != nil || got != "записала, кофе закончился" {
+		t.Errorf("got %q, %v, want %q, nil", got, err, "записала, кофе закончился")
+	}
+}
+
+func TestReplierFallsBackToPlainText(t *testing.T) {
+	r := NewReplier(mockCompleter{out: "записала, кофе закончился"}, nil)
+	got, err := r.PhraseReply(context.Background(), noteDecision())
+	if err != nil || got != "записала, кофе закончился" {
+		t.Errorf("got %q, %v, want %q, nil", got, err, "записала, кофе закончился")
+	}
+}
+
+func TestReplierReportsTheModelError(t *testing.T) {
+	r := NewReplier(mockCompleter{err: errTestLLMDown}, nil)
+	got, err := r.PhraseReply(context.Background(), noteDecision())
+	if err == nil {
+		t.Errorf("got %q, nil error — a dead model must be reported, not phrased around", got)
+	}
+}
+
+// A fragment the grammar left half-open is a failed generation. It must come
+// back as an error so the daemon reaches its stub, not as a reply.
+func TestReplierRejectsBrokenJSON(t *testing.T) {
+	r := NewReplier(mockCompleter{out: `{"response":"запис`}, nil)
+	got, err := r.PhraseReply(context.Background(), noteDecision())
+	if err == nil || got != "" {
+		t.Errorf("got %q, %v, want empty and an error", got, err)
+	}
+}
+
+func TestReplierEmptyOutputIsEmpty(t *testing.T) {
+	r := NewReplier(mockCompleter{out: ""}, nil)
+	got, err := r.PhraseReply(context.Background(), noteDecision())
+	if err != nil || got != "" {
+		t.Errorf("got %q, %v, want empty and no error", got, err)
+	}
+}
+
+// grammarRecorder captures the request so the grammar can be asserted on.
+type grammarRecorder struct{ req llm.Req }
+
+func (g *grammarRecorder) Complete(_ context.Context, r llm.Req) (string, error) {
+	g.req = r
+	return `{"response":"записала","mood":"neutral"}`, nil
+}
+
+func TestReplierCarriesTheResponseGrammar(t *testing.T) {
+	rec := &grammarRecorder{}
+	r := NewReplier(rec, nil)
+	if _, err := r.PhraseReply(context.Background(), noteDecision()); err != nil {
+		t.Fatalf("PhraseReply: %v", err)
+	}
+	if rec.req.Grammar != ResponseGrammar {
+		t.Errorf("grammar = %q, want ResponseGrammar", rec.req.Grammar)
+	}
+	if rec.req.System != ReplySystemPrompt {
+		t.Errorf("system prompt = %q, want ReplySystemPrompt", rec.req.System)
+	}
+}
+
+func noteDecision() router.Decision {
+	return router.Decision{Intent: router.IntentNote, Slots: router.Slots{Text: "кофе закончился"}}
+}
+
+var errTestLLMDown = errTest("llm down")
+
+type errTest string
+
+func (e errTest) Error() string { return string(e) }

internal/phraser/spawn_test.go

@@ -1,9 +1,11 @@
 package phraser
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
+	"log"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -59,6 +61,19 @@ func TestExtractPort(t *testing.T) {
 	}
 }
 
+// The prompt cache is what ate 6.8GB of the deployed server's RSS, so the cap
+// has to reach the command line, and the opt-out has to leave it off.
+func TestLlamaArgsCapsPromptCache(t *testing.T) {
+	cfg := DefaultConfig("/m.gguf")
+	if got := strings.Join(llamaArgs(cfg), " "); !strings.Contains(got, "--cache-ram 512") {
+		t.Errorf("default args = %q, want --cache-ram 512", got)
+	}
+	cfg.CacheRAMMiB = 0
+	if got := strings.Join(llamaArgs(cfg), " "); strings.Contains(got, "--cache-ram") {
+		t.Errorf("args with the cap off = %q, want no --cache-ram flag", got)
+	}
+}
+
 func TestStartLlamaProcScrapesPortAndReaps(t *testing.T) {
 	bin := fakeLlama(t, listensThenSleeps)
 	ctx, cancel := context.WithCancel(context.Background())
@@ -86,6 +101,48 @@ func TestStartLlamaProcScrapesPortAndReaps(t *testing.T) {
 	}
 }
 
+// captureLog redirects the standard logger for the duration of a test and
+// returns what was written to it.
+func captureLog(t *testing.T) *bytes.Buffer {
+	t.Helper()
+	var buf bytes.Buffer
+	old := log.Writer()
+	flags := log.Flags()
+	log.SetOutput(&buf)
+	log.SetFlags(0)
+	t.Cleanup(func() { log.SetOutput(old); log.SetFlags(flags) })
+	return &buf
+}
+
+// The child's buffer-size, KV-cache and offload lines are the only way to
+// account for its memory on a running box, and they used to be dropped: stderr
+// was scraped for the listen line and thrown away, stdout was never piped.
+func TestStartLlamaProcForwardsChildOutput(t *testing.T) {
+	buf := captureLog(t)
+	bin := fakeLlama(t, `echo "load_tensors: Vulkan0 model buffer size = 1053.34 MiB" >&2
+echo "llama_context: KV self size = 448.00 MiB"
+`+listensThenSleeps)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	p, err := startLlamaProc(ctx, testCfg(bin))
+	if err != nil {
+		t.Fatalf("startLlamaProc: %v", err)
+	}
+	p.cancel = cancel
+	defer p.Close()
+
+	got := buf.String()
+	for _, want := range []string{
+		"llama: load_tensors: Vulkan0 model buffer size = 1053.34 MiB", // stderr
+		"llama: llama_context: KV self size = 448.00 MiB",              // stdout, previously discarded
+	} {
+		if !strings.Contains(got, want) {
+			t.Errorf("log missing %q\nlog was:\n%s", want, got)
+		}
+	}
+}
+
 func TestStartLlamaProcFailureArms(t *testing.T) {
 	t.Run("binary missing", func(t *testing.T) {
 		cfg := testCfg(filepath.Join(t.TempDir(), "does-not-exist"))
@@ -96,13 +153,18 @@ func TestStartLlamaProcFailureArms(t *testing.T) {
 	})
 
 	t.Run("server exits without listening", func(t *testing.T) {
-		// stderr closes, so the reader goroutine reports EOF on errCh.
+		// stderr closes, so the reader goroutine reports EOF on errCh. The error
+		// must carry the child's last words: bare "EOF" named no cause.
+		captureLog(t)
 		bin := fakeLlama(t, `echo "ggml_vulkan: no device" >&2
 exit 1`)
 		_, err := startLlamaProc(context.Background(), testCfg(bin))
 		if err == nil || !strings.Contains(err.Error(), "llm: server output") {
 			t.Fatalf("err = %v, want the server-output arm", err)
 		}
+		if !strings.Contains(err.Error(), "ggml_vulkan: no device") {
+			t.Errorf("err = %v, want the child's last output in it", err)
+		}
 	})
 
 	t.Run("context cancelled during startup", func(t *testing.T) {
@@ -241,15 +303,7 @@ func TestKillMavenScriptMatchesRealCommandLine(t *testing.T) {
 	// startLlamaProc that breaks the sweep fails here instead of on the box.
 	cfg := DefaultConfig("/opt/maven/models/llm/Qwen3-1.7B-UD-Q4_K_XL.gguf")
 	cfg.NCtx, cfg.NGpuLayers = 4096, 99
-	cmdline := strings.Join([]string{
-		cfg.BinPath,
-		"-m", cfg.ModelPath,
-		"--host", "127.0.0.1",
-		"--port", extractPort(cfg.Listen),
-		"-c", fmt.Sprintf("%d", cfg.NCtx),
-		"-ngl", fmt.Sprintf("%d", cfg.NGpuLayers),
-		"--no-webui",
-	}, " ")
+	cmdline := cfg.BinPath + " " + strings.Join(llamaArgs(cfg), " ")
 	if !pat.MatchString(cmdline) {
 		t.Fatalf("kill-maven.sh pattern %q does not match %q — orphans would leak", m[1], cmdline)
 	}

internal/router/agenda_test.go

@@ -75,3 +75,47 @@ func TestAgendaGrammarSparesStatements(t *testing.T) {
 		}
 	}
 }
+
+// The tomorrow form and the bare event noun. Both were measured answering
+// "пока не умею" on the deployed daemon, 02-08-2026, while the same question
+// about today worked — the first rule set needed "у меня" or a calendar noun
+// and these phrasings carry neither (Vikunja #471).
+func TestAgendaCoversOtherDaysAndNamedEvents(t *testing.T) {
+	r := agendaRouter(t)
+	for _, u := range []string{
+		"какие планы на завтра?",
+		"какие планы на послезавтра",
+		"что по делам в среду",
+		"какие планы на выходные",
+		"когда планёрка?",
+		"во сколько созвон",
+		"когда будет совещание",
+	} {
+		d, err := r.Route(context.Background(), u, refNow())
+		if err != nil {
+			t.Fatalf("route(%q): %v", u, err)
+		}
+		if d.Intent != IntentQuery {
+			t.Errorf("route(%q) = %s, want query", u, d.Intent)
+		}
+	}
+}
+
+// The two new rules are narrow on purpose. A world question that opens with
+// "когда" is not an agenda question, and telling her about a plan is not
+// asking about one.
+func TestAgendaGrammarsLeaveTheWorldAlone(t *testing.T) {
+	r := agendaRouter(t)
+	for _, u := range []string{
+		"когда была битва при ватерлоо",
+		"когда изобрели телефон",
+	} {
+		d, err := r.Route(context.Background(), u, refNow())
+		if err != nil {
+			t.Fatalf("route(%q): %v", u, err)
+		}
+		if d.Stage == 0 {
+			t.Errorf("route(%q) was claimed at stage 0 as %s", u, d.Intent)
+		}
+	}
+}

internal/router/eval/ru_routing_v1.json

@@ -23,6 +23,8 @@
     { "id": "ru-query-012", "utterance": "какие заметки я оставил про полив", "lang": "ru", "intent": "query", "tags": ["recall"] },
     { "id": "ru-query-013", "utterance": "во сколько у меня встреча", "lang": "ru", "intent": "query", "tags": ["calendar"] },
     { "id": "ru-query-019", "utterance": "что у меня стоит в календаре на послезавтра", "lang": "ru", "intent": "query", "tags": ["calendar", "hard"], "note": "agenda, not the clock: the daemon answers this from CalendarEvents inside the query branch, so the clock/date system rule must not swallow it" },
+    { "id": "ru-query-022", "utterance": "какие планы на завтра?", "lang": "ru", "intent": "query", "tags": ["calendar"], "note": "the same agenda question as ru-query-019 aimed at another day; it answered \u043f\u043e\u043a\u0430 \u043d\u0435 \u0443\u043c\u0435\u044e on the deployed daemon while the today form worked (Vikunja #471)" },
+    { "id": "ru-query-023", "utterance": "\u043a\u043e\u0433\u0434\u0430 \u043f\u043b\u0430\u043d\u0451\u0440\u043a\u0430?", "lang": "ru", "intent": "query", "tags": ["calendar", "hard"], "note": "a named event with no calendar word — the noun is the only signal that this is a question about his day" },
     { "id": "ru-query-014", "utterance": "я успеваю до дедлайна", "lang": "ru", "intent": "query", "tags": ["hard", "no-question-word"] },
     { "id": "ru-query-015", "utterance": "сколько я прошёл шагов", "lang": "ru", "intent": "query", "tags": ["aggregate"] },
     { "id": "ru-query-016", "utterance": "покажи давление за неделю", "lang": "ru", "intent": "query", "tags": ["hard", "imperative"], "note": "imperative form but a read — must not route to act" },
@@ -69,6 +71,7 @@
     { "id": "ru-note-003", "utterance": "заметка про настройку vlan на свитче", "lang": "ru", "intent": "note", "tags": ["homelab"] },
     { "id": "ru-note-004", "utterance": "запиши идею: гидропоника на балконе", "lang": "ru", "intent": "note" },
     { "id": "ru-note-005", "utterance": "запиши что сосед просил номер электрика", "lang": "ru", "intent": "note" },
+    { "id": "ru-note-006", "utterance": "добавь в задачи купить молоко", "lang": "ru", "intent": "note", "tags": ["capture"], "note": "an explicit capture marker — the model called it an act and rewrote the payload (Vikunja #467), stage 0 claims it" },
     { "id": "en-note-001", "utterance": "note: rotate the kuma api key", "lang": "en", "intent": "note", "tags": ["homelab"] },
 
     { "id": "ru-sys-001", "utterance": "сколько сейчас времени в киеве", "lang": "ru", "intent": "system", "tags": ["time"] },

internal/router/llmrouter.go

@@ -210,7 +210,11 @@ func (lr *LLMRouter) Route(ctx context.Context, utterance string, now time.Time)
 		d.Slots.HasKey = a.Key != ""
 	case IntentReminder:
 		d.Intent = IntentReminder
-		d.Slots.Text = firstNonEmpty(a.Text, utterance)
+		// No utterance fallback here, unlike every other intent below. The
+		// model returning no text for a reminder means it found no subject,
+		// and "напомни в 11" is not a subject. Leaving Text empty is what
+		// lets the gate turn that into a question (Vikunja #383).
+		d.Slots.Text = a.Text
 	case IntentNote:
 		d.Intent = IntentNote
 		d.Slots.Text = firstNonEmpty(a.Text, utterance)

internal/router/llmrouter_test.go

@@ -356,3 +356,35 @@ func TestRouterLLMFactWithResolvedKeyStaysConfident(t *testing.T) {
 		t.Fatalf("a fact the parser could key must not clarify: %+v", d)
 	}
 }
+
+// A reminder with a time and no subject must come back empty and gated, not
+// backfilled with the raw words. "напомни в 11" carries an hour and nothing to
+// say at that hour; parking the utterance in Text made the request look
+// complete, so the daemon set a reminder that fires saying "напомни в 11"
+// (Vikunja #383).
+func TestLLMReminderWithoutSubjectAsksInsteadOfGuessing(t *testing.T) {
+	r := newLLMTestRouter(t, `{"intent":"reminder"}`)
+	d, err := r.Route(context.Background(), "напомни в 11", refNow())
+	if err != nil {
+		t.Fatalf("route: %v", err)
+	}
+	if d.Slots.Text != "" {
+		t.Fatalf("subject backfilled from the utterance: %q", d.Slots.Text)
+	}
+	if !d.Clarify {
+		t.Fatalf("a subjectless reminder was accepted, confidence %v", d.Confidence)
+	}
+}
+
+// The gate is about the subject, not about reminders in general: one that has
+// both halves still runs without a question.
+func TestLLMReminderWithSubjectIsNotGated(t *testing.T) {
+	r := newLLMTestRouter(t, `{"intent":"reminder","text":"позвонить маме"}`)
+	d, err := r.Route(context.Background(), "напомни в 11 позвонить маме", refNow())
+	if err != nil {
+		t.Fatalf("route: %v", err)
+	}
+	if d.Clarify {
+		t.Fatalf("a complete reminder was sent back as a question: %+v", d.Slots)
+	}
+}

internal/router/router.go

@@ -147,7 +147,15 @@ func (r *Router) fillSlots(ctx context.Context, d *Decision, now time.Time) {
 			d.Slots.Fn, d.Slots.Args, d.Slots.HasFn = fn, args, true
 		}
 	}
-	if d.Slots.Text == "" {
+	// The extractor's Text is the raw utterance, which is the payload for a
+	// note, a query or a chat turn but not for a reminder — there Text is the
+	// subject, what she says at the hour. Backfilling it made Text impossible
+	// to be empty, so StillMissing never reported SlotText and "О чём
+	// напомнить?" was unaskable; the answer to a question she did manage to
+	// ask then overwrote the whole request instead of filling one gap
+	// (Vikunja #383). A reminder with no subject stays empty and is gated
+	// below into a question.
+	if d.Slots.Text == "" && d.Intent != IntentReminder {
 		d.Slots.Text = ex.Text
 	}
 	// Stage stays 1: it says who decided the route, and that was the LLM.
@@ -177,6 +185,12 @@ func (r *Router) gateLLMDecision(d *Decision) {
 	if d.Intent == IntentAct && !d.Slots.HasFn && d.Confidence > llmThinConfidence {
 		d.Confidence = llmThinConfidence
 	}
+	// A reminder with no subject: she knows when but not what to say then.
+	// Setting it anyway fires an empty reminder at the hour, which reads as a
+	// bug to him and cannot be repaired after the fact. Ask (Vikunja #383).
+	if d.Intent == IntentReminder && d.Slots.Text == "" && d.Confidence > llmThinConfidence {
+		d.Confidence = llmThinConfidence
+	}
 	if d.Confidence < r.threshold {
 		d.Clarify = true
 	}

internal/router/stage0.go

@@ -182,9 +182,38 @@ func AgendaQueryGrammars() []Grammar {
 			Pattern: regexp.MustCompile(`(?i)^\s*(что|чего|какие|сколько|во\s+сколько|когда)\s+у\s+меня(\s|[?!.]|$)`),
 			Build:   agendaQueryBuild,
 		},
+		{
+			// A plan noun aimed at a named day, with no possessive to anchor
+			// on: "какие планы на завтра", "что по делам в среду". The rule
+			// above wants "у меня" and this phrasing never has it, so
+			// "какие планы на завтра" answered "пока не умею" while "какие
+			// планы на сегодня" worked (Vikunja #471). The day word is what
+			// makes it an agenda question rather than a topic.
+			Name: "plan-day-query",
+			// Only "план" and "дел". A verb stem like "встреч" would take
+			// "встречаемся в среду", which is him telling her something, not
+			// asking.
+			Pattern: regexp.MustCompile(`(?i)(^|\s)(план|дел)[а-я]*\s+(на|в|во|по)\s+` + dayWordPattern + `(\s|[?!.]|$)`),
+			Build:   agendaQueryBuild,
+		},
+		{
+			// A named event with no calendar word at all: "когда планёрка?",
+			// "во сколько созвон". He is asking when something on his calendar
+			// happens, and the noun is the only signal. Closed list, so "когда
+			// битва при Ватерлоо" is still a world question.
+			Name:    "event-time-query",
+			Pattern: regexp.MustCompile(`(?i)^\s*(когда|во\s+сколько|в\s+котором\s+часу)\s+(будет\s+|у\s+нас\s+)?(планёрк|планерк|встреч|созвон|митинг|совещани|звонок|созвон|приём|прием|интервью|собеседовани|тренировк|урок|занятие|пара)[а-я]*(\s|[?!.]|$)`),
+			Build:   agendaQueryBuild,
+		},
 	}
 }
 
+// dayWordPattern — the day words an agenda question can name. Weekdays appear
+// in the accusative and prepositional forms the questions actually use ("в
+// среду", "на среде"), which is why the stems carry an inflection tail rather
+// than a fixed ending.
+const dayWordPattern = `(сегодня|завтра|послезавтра|выходн[а-я]+|недел[а-я]+|понедельник[а-я]*|вторник[а-я]*|сред[ауые][а-я]*|четверг[а-я]*|пятниц[ауые][а-я]*|суббот[ауые][а-я]*|воскресень[ея][а-я]*)`
+
 // agendaQueryBuild — shared Build for the agenda grammars. Confidence 1.0 on
 // the intent only: the utterance travels intact and the query chain's own
 // matchers decide the rest.

internal/router/task.go

@@ -1,6 +1,9 @@
 package router
 
-import "strings"
+import (
+	"regexp"
+	"strings"
+)
 
 // Task capture and task listing, matched deterministically (Vikunja #130).
 //
@@ -201,3 +204,47 @@ func IsTaskListQuery(text string) bool {
 	}
 	return false
 }
+
+// TaskCaptureGrammar — stage 0 for an explicit capture marker, so the resident
+// model never sees it (Vikunja #467).
+//
+// Capture was built to ride the note intent, deliberately: #130 said no eighth
+// intent, and while the classifier was routing, a note-shaped utterance with a
+// marker in it reached actionNote and captureTaskFromNote claimed it there. The
+// router pre-empted that. Measured 2026-08-02: "добавь в задачи купить молоко"
+// routed act, so captureTaskFromNote was never consulted, the act arm found no
+// allowlisted fn, and the gate asked "Что сделать?". Every capture utterance
+// tried filed nothing.
+//
+// The model also rewrote the payload on the way — "купить молоко" came back as
+// "сделать покупку молока". A task must read as the words he said, which is a
+// second reason to answer this before the model rather than to prompt around
+// it.
+//
+// The marker list is data (task_phrases.json) and the parse strips urgency, so
+// the pattern here matches any utterance and the decision is ParseTaskCapture's
+// to make — same shape as the wake-word act grammar, which also matches broadly
+// and refuses in Build. Intent stays note: the daemon's note path is where
+// capture lives, and nothing about the contract with the model changes.
+func TaskCaptureGrammar() Grammar {
+	return Grammar{
+		Name:    "task-capture",
+		Pattern: regexp.MustCompile(`(?s)^\s*(.+)$`),
+		Build: func(m []string) (Decision, bool) {
+			c, ok := ParseTaskCapture(m[1])
+			if !ok {
+				return Decision{}, false // not a capture — fall through
+			}
+			return Decision{
+				Stage:      0,
+				Intent:     IntentNote,
+				Confidence: 1.0,
+				// The capture text, not the raw utterance: it is what the
+				// clarify gate reads as the payload. captureTaskFromNote
+				// re-parses the utterance itself, so the task text comes from
+				// the same place either way.
+				Slots: Slots{Text: c.Text},
+			}, true
+		},
+	}
+}

internal/router/task_phrases.json

@@ -27,6 +27,9 @@
     "добавь в список",
     "добавь задачу",
     "запиши в задачи",
+    "запиши в список дел",
+    "запиши в список задач",
+    "запиши в список",
     "запиши задачу",
     "новая задача",
     "поставь задачу",

internal/router/task_test.go

@@ -85,3 +85,37 @@ func TestIsTaskListQuery(t *testing.T) {
 		}
 	}
 }
+
+// TestTaskCaptureGrammarClaimsTheMarker — the capture marker is answered at
+// stage 0, so the model never gets to call it an act (Vikunja #467).
+func TestTaskCaptureGrammarClaimsTheMarker(t *testing.T) {
+	g := TaskCaptureGrammar()
+	captures := map[string]string{
+		"добавь в задачи купить молоко":       "купить молоко",
+		"запиши в список дел купить хлеб":     "купить хлеб",
+		"поставь задачу вынести мусор":        "вынести мусор",
+		"добавь в задачи срочно оплатить дом": "оплатить дом",
+	}
+	for in, want := range captures {
+		m := g.Pattern.FindStringSubmatch(in)
+		if m == nil {
+			t.Fatalf("%q did not match the grammar pattern", in)
+		}
+		d, ok := g.Build(m)
+		if !ok {
+			t.Fatalf("%q must be claimed as a capture", in)
+		}
+		if d.Intent != IntentNote || d.Slots.Text != want {
+			t.Errorf("%q → intent=%s text=%q, want note/%q", in, d.Intent, d.Slots.Text, want)
+		}
+	}
+	// Everything without a marker falls through, including a marker with no
+	// task after it and a question about the list.
+	for _, in := range []string{"надо бы поспать", "добавь в задачи", "какие у меня задачи?", "перезапусти nginx"} {
+		if m := g.Pattern.FindStringSubmatch(in); m != nil {
+			if _, ok := g.Build(m); ok {
+				t.Errorf("%q must fall through to the cascade", in)
+			}
+		}
+	}
+}

internal/store/delivery.go

@@ -87,3 +87,68 @@ func (s *Store) ReconcileStaleDeliveryAttempts(ctx context.Context, now time.Tim
 	}
 	return int(n), nil
 }
+
+// DeliveryAttempt — one row of the outbox, as a reader sees it.
+type DeliveryAttempt struct {
+	ID          int64
+	Kind        string // nudge|reminder
+	Rule        string // set for nudges
+	ReminderID  int64  // set for reminders
+	Channel     string
+	Status      string // one of the Delivery* constants
+	Created     time.Time
+	Completed   time.Time // zero while pending
+	HasComplete bool
+}
+
+// ListDeliveryAttempts returns recent attempts, newest first. An empty status
+// means every status; anything else filters on it.
+//
+// The table was write-only until 04-08-2026: rows were recorded and nothing
+// could read them, so the tests for #368 and #370 had to reach past the store
+// into store.DB, which is the tell (Vikunja #390). A durable record nobody can
+// read answers no question, and "why did Maven go quiet" is supposed to be a
+// query rather than a mystery.
+//
+// Status is the filter that earns its place, because the two questions actually
+// asked are "what got dropped" and "what is still pending". Neither is
+// answerable by reading the whole list on a busy day.
+func (s *Store) ListDeliveryAttempts(ctx context.Context, status string, limit int) ([]DeliveryAttempt, error) {
+	if limit <= 0 {
+		limit = 50
+	}
+	q := `SELECT id, kind, rule, reminder_id, channel, status, created_ts, completed_ts
+	        FROM delivery_attempts`
+	args := []any{}
+	if status != "" {
+		q += ` WHERE status = ?`
+		args = append(args, status)
+	}
+	q += ` ORDER BY created_ts DESC, id DESC LIMIT ?`
+	args = append(args, limit)
+
+	rows, err := s.db.QueryContext(ctx, q, args...)
+	if err != nil {
+		return nil, fmt.Errorf("list delivery attempts: %w", err)
+	}
+	defer rows.Close()
+
+	var out []DeliveryAttempt
+	for rows.Next() {
+		var a DeliveryAttempt
+		var created int64
+		var completed *int64
+		if err := rows.Scan(&a.ID, &a.Kind, &a.Rule, &a.ReminderID, &a.Channel, &a.Status, &created, &completed); err != nil {
+			return nil, fmt.Errorf("list delivery attempts: scan: %w", err)
+		}
+		a.Created = time.UnixMilli(created)
+		if completed != nil {
+			a.Completed, a.HasComplete = time.UnixMilli(*completed), true
+		}
+		out = append(out, a)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("list delivery attempts: %w", err)
+	}
+	return out, nil
+}

internal/store/delivery_test.go

@@ -32,3 +32,53 @@ func TestDroppedDeliveryAttemptRoundTrips(t *testing.T) {
 		t.Fatalf("status: want %q, got %q", DeliveryDropped, status)
 	}
 }
+
+// TestListDeliveryAttempts — the read path the outbox lacked until #390. The
+// two questions it must answer are "what was dropped" and "what is pending".
+func TestListDeliveryAttempts(t *testing.T) {
+	ctx := context.Background()
+	s := newTestStore(t)
+	base := time.Date(2026, 8, 4, 9, 0, 0, 0, time.UTC)
+
+	sent, err := s.BeginDeliveryAttempt(ctx, "nudge", "water", 0, "telegram", "h1", base)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := s.CompleteDeliveryAttempt(ctx, sent, DeliverySent, base.Add(time.Second)); err != nil {
+		t.Fatal(err)
+	}
+	dropped, err := s.BeginDeliveryAttempt(ctx, "nudge", "care", 0, "telegram", "h2", base.Add(time.Minute))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := s.CompleteDeliveryAttempt(ctx, dropped, DeliveryDropped, base.Add(time.Minute)); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := s.BeginDeliveryAttempt(ctx, "reminder", "", 7, "voice", "h3", base.Add(2*time.Minute)); err != nil {
+		t.Fatal(err)
+	}
+
+	all, err := s.ListDeliveryAttempts(ctx, "", 10)
+	if err != nil || len(all) != 3 {
+		t.Fatalf("ListDeliveryAttempts = %d rows, err=%v, want 3", len(all), err)
+	}
+	// Newest first.
+	if all[0].Kind != "reminder" || all[0].ReminderID != 7 {
+		t.Fatalf("newest row is %+v, want the reminder", all[0])
+	}
+	if all[0].HasComplete {
+		t.Fatalf("a pending row must have no completion time: %+v", all[0])
+	}
+	if !all[2].HasComplete || !all[2].Completed.Equal(base.Add(time.Second)) {
+		t.Fatalf("completed row lost its time: %+v", all[2])
+	}
+
+	only, err := s.ListDeliveryAttempts(ctx, DeliveryDropped, 10)
+	if err != nil || len(only) != 1 || only[0].Rule != "care" {
+		t.Fatalf("dropped filter = %+v, err=%v", only, err)
+	}
+	pending, err := s.ListDeliveryAttempts(ctx, DeliveryPending, 10)
+	if err != nil || len(pending) != 1 || pending[0].Kind != "reminder" {
+		t.Fatalf("pending filter = %+v, err=%v", pending, err)
+	}
+}

internal/store/migrations.go

@@ -208,6 +208,17 @@ ALTER TABLE reminders ADD COLUMN next_fire_ts INTEGER;`, // #2
 	// list_tasks into something that writes without the row changing by one
 	// byte. The fingerprint is the declared shape at approval time, so a
 	// redefinition is a re-approval instead of a silent upgrade.
+	`DELETE FROM facts
+	  WHERE key LIKE 'calendar_event_%'
+	    AND replace(substr(key, 25), '-', '') = '';`,
+	// #18 — drop the calendar keys written while safeKey dropped Cyrillic
+	// (Vikunja #443). Everything after the date prefix was punctuation, so
+	// every Russian event on one day shared one key and only the last one
+	// survived. Deleting rather than rewriting: a calendar fact is derived
+	// data, the next poll writes the day again under keys that identify the
+	// event, and the old rows would otherwise be recited as extra meetings.
+	// The filter is exact — it keeps any key whose summary part still has a
+	// letter or a digit in it.
 }
 
 // migrate applies every migration with a number greater than the DB's current

internal/store/migrations_test.go

@@ -47,3 +47,36 @@ func TestMigrateAppliesOnceAndIsIdempotent(t *testing.T) {
 		t.Fatalf("after re-migrate user_version = %d, want %d", v, want)
 	}
 }
+
+// Migration #18 clears the calendar keys written while safeKey dropped
+// Cyrillic. Those rows are indistinguishable from real events on read, so
+// leaving them would recite one meeting as several (Vikunja #443).
+func TestCollapsedCalendarKeysAreDropped(t *testing.T) {
+	ctx := context.Background()
+	s := newTestStore(t)
+
+	rows := []string{
+		"calendar_event_20260804_--",             // "Встреча с Аней" under the old rule
+		"calendar_event_20260804_",               // a one-word Russian summary
+		"calendar_event_20260804_Встреча-с-Аней", // the new format
+		"calendar_event_20260804_Standup",        // an ASCII summary, always fine
+	}
+	for _, key := range rows {
+		if _, err := s.db.ExecContext(ctx,
+			`INSERT INTO facts (ts, kind, key, value, source, confidence) VALUES (0, 'env', ?, 'x', 'poll:caldav', 1.0)`,
+			key); err != nil {
+			t.Fatalf("seed %q: %v", key, err)
+		}
+	}
+	if _, err := s.db.ExecContext(ctx, migrations[17]); err != nil {
+		t.Fatalf("migration 18: %v", err)
+	}
+
+	var got int
+	if err := s.db.QueryRowContext(ctx, `SELECT count(*) FROM facts WHERE key LIKE 'calendar_event_%'`).Scan(&got); err != nil {
+		t.Fatal(err)
+	}
+	if got != 2 {
+		t.Fatalf("%d calendar rows left, want the 2 that identify their event", got)
+	}
+}

internal/weather/openmeteo.go

@@ -97,7 +97,59 @@ func (p *OpenMeteoProvider) CurrentWeather(ctx context.Context, location string)
 	}, nil
 }
 
+// locationCandidates — the spellings to try for a place taken out of a spoken
+// sentence, in order. He says "какая погода в Казани", so the word arrives in
+// the prepositional case and the geocoder wants the nominative (Vikunja #421).
+//
+// Two cheap reversals cover most of what he says: a final "е" is usually a
+// nominative "а" (Москве → Москва) or nothing at all (Лондоне → Лондон), and a
+// final "и" is usually a soft sign (Казани → Казань). Indeclinable names —
+// Тбилиси, Сочи, Осло — are already nominative and the first candidate answers.
+//
+// Nothing here is a guess about the weather: a wrong candidate finds no city
+// and the caller says so. It only decides which strings are worth asking about.
+func locationCandidates(location string) []string {
+	out := []string{location}
+	add := func(s string) {
+		if s == "" || s == location {
+			return
+		}
+		for _, seen := range out {
+			if seen == s {
+				return
+			}
+		}
+		out = append(out, s)
+	}
+	r := []rune(location)
+	if len(r) < 4 {
+		return out
+	}
+	stem := string(r[:len(r)-1])
+	switch r[len(r)-1] {
+	case 'е', 'Е':
+		add(stem + "а")
+		add(stem)
+	case 'и', 'И':
+		add(stem + "ь")
+		add(stem)
+	case 'у', 'У', 'ю', 'Ю':
+		add(stem + "а")
+	}
+	return out
+}
+
 func (p *OpenMeteoProvider) geocode(ctx context.Context, location string) (lat, lon float64, name string, err error) {
+	for _, cand := range locationCandidates(location) {
+		lat, lon, name, err = p.geocodeOne(ctx, cand)
+		if err == nil {
+			return lat, lon, name, nil
+		}
+	}
+	return 0, 0, "", err
+}
+
+func (p *OpenMeteoProvider) geocodeOne(ctx context.Context, location string) (lat, lon float64, name string, err error) {
 	u := fmt.Sprintf("https://geocoding-api.open-meteo.com/v1/search?name=%s&count=1&language=ru&format=json", url.QueryEscape(location))
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
 	if err != nil {
@@ -121,7 +173,7 @@ func (p *OpenMeteoProvider) geocode(ctx context.Context, location string) (lat,
 	}
 
 	if len(geo.Results) == 0 {
-		return 0, 0, "", fmt.Errorf("location %q not found", location)
+		return 0, 0, "", fmt.Errorf("%w: %q", ErrLocationUnknown, location)
 	}
 
 	r := geo.Results[0]

internal/weather/openmeteo_test.go

@@ -83,3 +83,29 @@ func TestStubProvider(t *testing.T) {
 		t.Fatalf("StubProvider: want ErrNotConfigured, got %v", err)
 	}
 }
+
+// TestLocationCandidates — he speaks the prepositional case and the geocoder
+// wants the nominative (Vikunja #421).
+func TestLocationCandidates(t *testing.T) {
+	cases := map[string][]string{
+		"Москве":  {"Москве", "Москва", "Москв"},
+		"Казани":  {"Казани", "Казань", "Казан"},
+		"Лондоне": {"Лондоне", "Лондона", "Лондон"},
+		"Тбилиси": {"Тбилиси", "Тбились", "Тбилис"},
+		"Berlin":  {"Berlin"},
+		"Уфе":     {"Уфе"}, // too short to strip — asked as spoken
+	}
+	for in, want := range cases {
+		got := locationCandidates(in)
+		if len(got) != len(want) {
+			t.Errorf("locationCandidates(%q) = %v, want %v", in, got, want)
+			continue
+		}
+		for i := range got {
+			if got[i] != want[i] {
+				t.Errorf("locationCandidates(%q) = %v, want %v", in, got, want)
+				break
+			}
+		}
+	}
+}

internal/weather/weather.go

@@ -7,6 +7,13 @@ import (
 
 var ErrNotConfigured = errors.New("weather: not configured")
 
+// ErrLocationUnknown — the geocoder has no such place. A named city that does
+// not resolve must read differently from a provider outage: one is "I do not
+// know that place", the other is "I could not reach the service", and
+// answering for the default location instead is the defect this replaces
+// (Vikunja #421).
+var ErrLocationUnknown = errors.New("weather: location not found")
+
 type Weather struct {
 	Location    string  `json:"location"`
 	Temperature float64 `json:"temperature"`