mavend: group the recall fields into one wiring struct (V-433)

The review comment asked for basic DI. The answer is the idiom voice.go
already had for capabilities — a cohesive *Wiring struct — applied to a
group that is not a capability toggle, plus the decision written down so
it is a rule and not a habit.

recallWiring holds the embedder, the vector store, the personal boundary
and the two numbers that gate an answer. They sat in three places on
reactiveHandler, with the gate numbers a hundred lines from the store
they gate. Its zero value means no recall, so it is a value, not a
pointer like the optional-capability groups.

dataStore stays out of it. patterns.go, ecosystem_acts.go and confirm.go
use it, so it is not part of this cluster.

docs/handler-wiring.md records the choice, rejects a container or a
wire-style generator outright, defers narrow per-handler interfaces to
the package split that would justify them, and states the constraint the
task named: a wiring change does not ride a feature PR.

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

CLAUDE.md

@@ -32,7 +32,11 @@ See `docs/rearchitecture.md` for the target architecture, `docs/design.md` for t
 GPU and the workstation has 16GB of VRAM. So the resident model, STT and TTS become preferred
 remotes with a floor on homesrv. The workstation is never assumed up. Fall back silently when
 it would only do the job better. Name the gap when the 1.7B cannot do it at all. The embedder
-stays on homesrv permanently, because it backs that floor. Read `docs/offload.md` before
+stays on homesrv permanently, because it backs that floor. It is multilingual-e5-small,
+quantized and asymmetric — `EmbedQuery` and `EmbedPassage` apply the `query:`/`passage:`
+prefixes it was trained with, and calling plain `Embed` on a note is a bug. It replaced
+MiniLM and bought ten points of recall@1 and 2.5× the speed; see
+`docs/evals/2026-08-04-recall-e5-small.md`. Read `docs/offload.md` before
 touching a daemon seam or adding a model caller. Vikunja #483 is the umbrella, #484 to #487
 are the work.
 
@@ -229,8 +233,11 @@ world questions, so she needs to read external sources. What replaces it:
 
 ## Web UI conventions
 
-Server-rendered pages share `cmd/mavweb/static/ui.css` (served at `/ui.css`) and the `nav`
-partial (`navHTML` in `cmd/mavweb/main.go`, `{{template "nav" "<active-page>"}}`). No
+Server-rendered pages share `cmd/mavweb/static/ui.css` (served at `/ui.css`) and the shell
+partial in `cmd/mavweb/shell.html`: a page opens with `{{template "shellTop" "<page-key>"}}`
+and closes with `{{template "shellBottom"}}`, and the key marks the active sidebar link.
+Every page is its own embedded `.html` file next to `main.go` — no page markup lives in Go,
+and the sidebar is data (`sidebarSections`, `pageIcon`) the template renders. No
 per-page `<style>` beyond true one-offs. Wrap every table in `<div class=scroll>` so wide
 data pans on a phone. Local preview + headless screenshot recipe is in `AGENTS.md`.
 

Makefile

@@ -197,7 +197,7 @@ deps-piper:
 # multilingual-e5-small: an asymmetric retrieval model. It is trained to match
 # a short question against a longer passage, which is what note recall is.
 # The quantized file is the one we download, deploy and measure — see
-# docs/evals/2026-07-31-recall.md.
+# docs/evals/2026-08-04-recall-e5-small.md for what the swap bought.
 EMBEDDER_DIR := $(shell pwd)/models/embedder/multilingual-e5-small
 EMBEDDER_MODEL_URL := https://huggingface.co/Xenova/multilingual-e5-small/resolve/main/onnx/model_quantized.onnx
 EMBEDDER_TOKENIZER_URL := https://huggingface.co/Xenova/multilingual-e5-small/resolve/main/tokenizer.json

cmd/mavend/actions_fact.go

@@ -73,11 +73,11 @@ func (h *reactiveHandler) actionFact(ctx context.Context, dec router.Decision) s
 	// hears; storing the utterance meant recall answered with his own sentence
 	// rather than the value. The utterance stays alongside as provenance —
 	// readable on /trace, never the answer and never embedded.
-	if h.memStore != nil {
+	if h.recall.memStore != nil {
 		text := store.FactRecallText(dec.Slots.Key, dec.Slots.Value)
-		if vec, err := router.EmbedPassage(ctx, h.embedder, text); err != nil {
+		if vec, err := router.EmbedPassage(ctx, h.recall.embedder, text); err != nil {
 			log.Printf("voice: embed fact for memory: %v", err)
-		} else if err := h.memStore.Insert(ctx, "fact:"+dec.Slots.Key+":"+strconv.FormatInt(now.Unix(), 10), vec, map[string]string{
+		} else if err := h.recall.memStore.Insert(ctx, "fact:"+dec.Slots.Key+":"+strconv.FormatInt(now.Unix(), 10), vec, map[string]string{
 			"source":    "voice",
 			"type":      "fact",
 			"text":      text,

cmd/mavend/actions_note.go

@@ -20,7 +20,7 @@ func (h *reactiveHandler) actionNote(ctx context.Context, dec router.Decision) s
 	// embed the note text with the same model the classifier uses, persist
 	// via CoreAPI (source=tap:voice). Semantic recall lives in `notes`, not
 	// facts — no predicate reads it (spec's two-memory split).
-	vec, err := router.EmbedPassage(ctx, h.embedder, dec.Utterance)
+	vec, err := router.EmbedPassage(ctx, h.recall.embedder, dec.Utterance)
 	if err != nil {
 		log.Printf("voice: embed note: %v", err)
 		return "не получилось сохранить заметку."
@@ -33,8 +33,8 @@ func (h *reactiveHandler) actionNote(ctx context.Context, dec router.Decision) s
 	}
 	// Insert into long-term memory (best-effort, must not fail the note write).
 	// text/ts in the meta make a Search hit self-describing (see bestRecall).
-	if h.memStore != nil {
-		if err := h.memStore.Insert(ctx, "note:"+strconv.FormatInt(noteID, 10), vec, map[string]string{
+	if h.recall.memStore != nil {
+		if err := h.recall.memStore.Insert(ctx, "note:"+strconv.FormatInt(noteID, 10), vec, map[string]string{
 			"source": "voice",
 			"type":   "note",
 			"text":   dec.Utterance,

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
@@ -401,7 +406,7 @@ func (h *reactiveHandler) queryWeather(ctx context.Context, t *queryTurn) (strin
 // sources below both need, run once, in the position it always ran in. It
 // only claims the turn when the embedder fails.
 func (h *reactiveHandler) queryEmbed(ctx context.Context, t *queryTurn) (string, bool) {
-	vec, err := router.EmbedQuery(ctx, h.embedder, t.dec.Utterance)
+	vec, err := router.EmbedQuery(ctx, h.recall.embedder, t.dec.Utterance)
 	if err != nil {
 		log.Printf("voice: embed query: %v", err)
 		return "не получилось найти ответ.", true
@@ -421,15 +426,15 @@ func (h *reactiveHandler) queryEmbed(ctx context.Context, t *queryTurn) (string,
 // gate, was the bug — the set of questions Maven answers is unchanged, only
 // which memory gets to answer them.
 func (h *reactiveHandler) queryMemory(ctx context.Context, t *queryTurn) (string, bool) {
-	if h.memStore == nil {
+	if h.recall.memStore == nil {
 		return "", false
 	}
-	hits, herr := h.memStore.Search(ctx, t.vec, 3)
+	hits, herr := h.recall.memStore.Search(ctx, t.vec, 3)
 	if herr != nil {
 		log.Printf("voice: memory search: %v", herr)
 		return "", false
 	}
-	hit, ok := bestRecall(hits, h.queryMinScore, h.queryMinMargin)
+	hit, ok := bestRecall(hits, h.recall.minScore, h.recall.minMargin)
 	if !ok {
 		return "", false
 	}
@@ -474,7 +479,7 @@ func (h *reactiveHandler) queryNotes(ctx context.Context, t *queryTurn) (string,
 	for i, n := range notes {
 		noteScores[i] = n.Score
 	}
-	if !memory.ConfidentScores(noteScores, h.queryMinScore, h.queryMinMargin) {
+	if !memory.ConfidentScores(noteScores, h.recall.minScore, h.recall.minMargin) {
 		return "", false
 	}
 	// Same topic veto as queryMemory above: the best note must be about what
@@ -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.recall.boundary.load(ctx, h.recall.embedder)
+	if personal, world, ok := h.recall.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.recall.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,92 @@ 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, ""))
+}
+
+// TestARestartExpiresTheParkedQuestion pins the Vikunja #385 decision: the
+// question dies with the process, and she does not claim to have let it go —
+// the words that follow are routed as a fresh request. Restarting is modelled
+// the way the daemon does it, by building a second handler over the same store.
+func TestARestartExpiresTheParkedQuestion(t *testing.T) {
+	h, _, _ := newClarifyHandler(t)
+	ctx := voiceCtx()
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
+		t.Fatal("expected a question before the restart")
+	}
+
+	restarted, _, _ := newClarifyHandler(t)
+	if _, handled := restarted.resolveClarifyAnswer(ctx, "в 11:00"); handled {
+		t.Fatal("a question parked before the restart must not eat the next utterance")
+	}
+	if notice := restarted.clarifyExpiredNotice(ctx); notice != "" {
+		t.Fatalf("notice = %q, want silence: nothing survived to expire", notice)
+	}
+}

cmd/mavend/ecosystem_acts.go

@@ -514,11 +514,14 @@ func (h *reactiveHandler) handleHexisAct(ctx context.Context, dec router.Decisio
 
 	// Resolve the utterance text as an entity reference through Nexus. An
 	// ambiguous match must stop and clarify — never guess a mutation target.
+	// The name comes from entityReferenceText, not straight from the Text slot:
+	// the model transliterates Latin names as it routes (Vikunja #476).
+	subject := entityReferenceText(dec)
 	started := h.now()
-	entityID, displayName, ambiguous, err := h.ecosystem.resolveEntityReference(ctx, dec.Slots.Text, nil)
+	entityID, displayName, ambiguous, err := h.ecosystem.resolveEntityReference(ctx, subject, nil)
 	if err != nil {
 		h.recordEcosystemTrace(ctx, "nexus", "resolve", traceStatusForError(err), started,
-			mergeFields(traceErrorFields(err), map[string]any{"subject": redactSubject(dec.Slots.Text)}))
+			mergeFields(traceErrorFields(err), map[string]any{"subject": redactSubject(subject)}))
 		if unauthorizedEcosystemError(err) {
 			return "экосистема отклоняет доступ, проверь токен."
 		}
@@ -535,7 +538,7 @@ func (h *reactiveHandler) handleHexisAct(ctx context.Context, dec router.Decisio
 	}
 	if entityID == "" {
 		h.recordEcosystemTrace(ctx, "nexus", "resolve", traceNotFound, started,
-			map[string]any{"subject": redactSubject(dec.Slots.Text)})
+			map[string]any{"subject": redactSubject(subject)})
 		return ""
 	}
 	h.recordEcosystemTrace(ctx, "nexus", "resolve", traceOK, started,
@@ -569,10 +572,21 @@ func (h *reactiveHandler) handleHexisAct(ctx context.Context, dec router.Decisio
 	}
 	verbLower := strings.ToLower(verb)
 
+	// With no allowlisted fn the verb is a whole phrase ("restart status muzick
+	// indexer"), which no capability name ever contains. Read it the other way
+	// round then: the phrase is the haystack and the capability name is what we
+	// look for in it (Vikunja #476). Only when the fn slot is empty — a matched
+	// fn is a single verb and containment already means what it says.
+	loose := !dec.Slots.HasFn
 	var matches []*hexisclient.Capability
 	for i, c := range caps {
-		if strings.Contains(strings.ToLower(c.Name), verbLower) ||
-			(c.Description != "" && strings.Contains(strings.ToLower(c.Description), verbLower)) {
+		name := strings.ToLower(c.Name)
+		hit := strings.Contains(name, verbLower) ||
+			(c.Description != "" && strings.Contains(strings.ToLower(c.Description), verbLower))
+		if loose && name != "" && strings.Contains(verbLower, name) {
+			hit = true
+		}
+		if hit {
 			matches = append(matches, &caps[i])
 		}
 	}
@@ -632,3 +646,29 @@ func (h *reactiveHandler) execHexis(ctx context.Context, capID, capName, entityI
 	})
 	return "команда выполнена для " + displayName + "."
 }
+
+// hexisBeforeClarify gives an entity-shaped act one chance at Hexis before she
+// asks what to do.
+//
+// The stage-3 gate thins an act that never matched an allowlisted fn, so
+// "перезапусти muzick indexer" was answered with "Что сделать?" and the Hexis
+// path was never entered — the capability existed and no utterance could reach
+// it (Vikunja #476). Hexis is exactly where an act with no local fn belongs:
+// the verb is matched against the capabilities Hexis registers for the entity,
+// not against the allowlist.
+//
+// Narrow on purpose. Only an act, only when the fn slot is still empty, and
+// only when Hexis is wired — a box with no ecosystem asks the question it
+// always asked. A "" back means Nexus knew no such entity or Hexis had no
+// matching capability, and then she asks after all. Authority is unchanged:
+// resolution stops on ambiguity and a mutating capability still goes through
+// the spoken confirm in handleHexisAct.
+func (h *reactiveHandler) hexisBeforeClarify(ctx context.Context, dec router.Decision) string {
+	if h.ecosystem == nil || h.ecosystem.hexis == nil {
+		return ""
+	}
+	if dec.Intent != router.IntentAct || dec.Slots.HasFn || dec.Slots.Text == "" {
+		return ""
+	}
+	return h.handleHexisAct(ctx, dec)
+}

cmd/mavend/entityname.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"regexp"
+	"strings"
+	"unicode"
+
+	"github.com/kami/maven/internal/router"
+)
+
+// latinRun matches a run of Latin-script words — the shape a service, host or
+// project name takes in a Russian sentence. Digits, dot, dash and underscore
+// ride along because "muzick-indexer" and "nginx.conf" are one name, not two.
+var latinRun = regexp.MustCompile(`[A-Za-z][A-Za-z0-9._-]*(?:\s+[A-Za-z][A-Za-z0-9._-]*)*`)
+
+// hasLatin reports whether s carries a Latin letter.
+func hasLatin(s string) bool {
+	for _, r := range s {
+		if unicode.In(r, unicode.Latin) {
+			return true
+		}
+	}
+	return false
+}
+
+// entityReferenceText is the name Nexus is asked to resolve.
+//
+// Normally that is the router's Text slot, which is the verb phrase the model
+// wrote. But the resident model rewrites a Russian utterance as it routes, and
+// on the way it transliterates: "перезапусти muzick indexer" came back as
+// "перезагрузить музик индексер" (Vikunja #476). Nexus is then asked for a
+// service nobody has ever named, so the act cannot resolve its target even
+// with every gate open.
+//
+// The recovery is deliberately narrow. Only when the utterance holds a Latin
+// run and the model's Text holds none has a name certainly been rewritten —
+// then the longest Latin run in his own words is the reference. Anything else
+// keeps the Text slot, so an English utterance and a Russian entity name are
+// both untouched. Un-transliterating the Cyrillic back is not attempted: the
+// surface form he said is right there, and guessing at a reverse mapping would
+// invent a second name to be wrong about.
+func entityReferenceText(dec router.Decision) string {
+	text := dec.Slots.Text
+	if hasLatin(text) || !hasLatin(dec.Utterance) {
+		return text
+	}
+	longest := ""
+	for _, m := range latinRun.FindAllString(dec.Utterance, -1) {
+		if len(m) > len(longest) {
+			longest = m
+		}
+	}
+	longest = strings.TrimSpace(longest)
+	// A single stray letter is not a name.
+	if len(longest) < 2 {
+		return text
+	}
+	return longest
+}

cmd/mavend/entityname_test.go

@@ -0,0 +1,133 @@
+package main
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/kami/maven/internal/router"
+)
+
+// TestEntityReferenceText pins when his own words win over the model's.
+func TestEntityReferenceText(t *testing.T) {
+	for _, tc := range []struct {
+		name      string
+		utterance string
+		text      string
+		want      string
+	}{
+		{
+			name:      "the model transliterated the name",
+			utterance: "перезапусти muzick indexer",
+			text:      "перезагрузить музик индексер",
+			want:      "muzick indexer",
+		},
+		{
+			name:      "it kept the name, so nothing to repair",
+			utterance: "перезапусти muzick indexer",
+			text:      "перезагрузить muzick indexer",
+			want:      "перезагрузить muzick indexer",
+		},
+		{
+			name:      "an all-Russian entity name is not a rewrite",
+			utterance: "перезапусти домашний сервер",
+			text:      "перезагрузить домашний сервер",
+			want:      "перезагрузить домашний сервер",
+		},
+		{
+			name:      "an English turn never enters the recovery",
+			utterance: "restart muzick indexer",
+			text:      "restart muzick indexer",
+			want:      "restart muzick indexer",
+		},
+		{
+			name:      "the longest Latin run is the name",
+			utterance: "а перезапусти-ка nginx на muzick-indexer, пожалуйста",
+			text:      "перезагрузить нгинкс",
+			want:      "muzick-indexer",
+		},
+		{
+			name:      "one stray letter is not a name",
+			utterance: "перезапусти сервер a",
+			text:      "перезагрузить сервер",
+			want:      "перезагрузить сервер",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			dec := router.Decision{Utterance: tc.utterance, Slots: router.Slots{Text: tc.text}}
+			if got := entityReferenceText(dec); got != tc.want {
+				t.Fatalf("entityReferenceText = %q, want %q", got, tc.want)
+			}
+		})
+	}
+}
+
+// TestNexusIsAskedForTheNameHeSaid — the defect end to end (Vikunja #476): the
+// router hands over a transliterated Text, and Nexus must still be asked about
+// the service that exists.
+func TestNexusIsAskedForTheNameHeSaid(t *testing.T) {
+	ctx := context.Background()
+	nexus := newFakeNexus(t, fixtureNexusResolved("ent_muzick", "Muzick indexer", "service"))
+	hexis := newFakeHexis(t, restartCaps(), fixtureHexisExecuted("exec_1", "succeeded"))
+	h := ecoHandler(t, nexus, nil, hexis)
+
+	dec := router.Decision{
+		Utterance: "перезапусти muzick indexer",
+		Intent:    router.IntentAct,
+		Slots:     router.Slots{Text: "перезагрузить музик индексер", Fn: "restart", HasFn: true},
+	}
+	h.handleHexisAct(ctx, dec)
+
+	reqs := nexus.Requests()
+	if len(reqs) == 0 {
+		t.Fatal("nexus was never asked")
+	}
+	body := string(reqs[0].Body)
+	if !strings.Contains(body, "muzick indexer") {
+		t.Fatalf("nexus resolve body = %s, want the name he said", body)
+	}
+}
+
+// TestAnEntityActReachesHexisInsteadOfAsking — the second half of #476. The
+// stage-3 gate thins an act with no allowlisted fn, and that question used to
+// be the whole turn, so the Hexis path was unreachable from voice or chat.
+func TestAnEntityActReachesHexisInsteadOfAsking(t *testing.T) {
+	ctx := context.Background()
+	nexus := newFakeNexus(t, fixtureNexusResolved("ent_muzick", "Muzick indexer", "service"))
+	hexis := newFakeHexis(t, restartCaps(), fixtureHexisExecuted("exec_1", "succeeded"))
+	h := ecoHandler(t, nexus, nil, hexis)
+
+	dec := router.Decision{
+		Utterance: "перезапусти muzick indexer",
+		Intent:    router.IntentAct,
+		Stage:     3,
+		Clarify:   true,
+		Slots:     router.Slots{Text: "restart status muzick indexer"},
+	}
+	reply := h.hexisBeforeClarify(ctx, dec)
+	if reply == "" {
+		t.Fatal("a resolvable entity act must reach hexis rather than fall through to the question")
+	}
+	if hexis.Count("", "/api/v1") == 0 {
+		t.Fatal("hexis was never contacted")
+	}
+}
+
+// TestClarifyStillAsksWithoutHexis — the narrowing. No ecosystem, no change:
+// she asks exactly what she asked before.
+func TestClarifyStillAsksWithoutHexis(t *testing.T) {
+	h, _, _ := newClarifyHandler(t)
+	dec := router.Decision{
+		Utterance: "перезапусти muzick indexer",
+		Intent:    router.IntentAct,
+		Stage:     3,
+		Clarify:   true,
+		Slots:     router.Slots{Text: "перезагрузить музик индексер"},
+	}
+	if reply := h.hexisBeforeClarify(context.Background(), dec); reply != "" {
+		t.Fatalf("no hexis must mean no reply, got %q", reply)
+	}
+	if _, asked := h.askClarify(voiceCtx(), dec); !asked {
+		t.Fatal("she must still ask what to do")
+	}
+}

cmd/mavend/fact_subject_test.go

@@ -28,11 +28,10 @@ func TestApplyAction_FactCapture_QueuesEntityResolution(t *testing.T) {
 
 	h := &reactiveHandler{
 		api:       api,
-		embedder:  emb,
+		recall:    recallWiring{embedder: emb, memStore: memory.NewInMemoryStore()},
 		router:    rtr,
 		replier:   voice.NewStubReplier(),
 		now:       func() time.Time { return now },
-		memStore:  memory.NewInMemoryStore(),
 		dataStore: st,
 	}
 

cmd/mavend/factgate_test.go

@@ -19,11 +19,10 @@ func newFactGateHandler(t *testing.T, now time.Time) (*reactiveHandler, ipc.Core
 	emb := router.NewHashEmbedder(1024)
 	h := &reactiveHandler{
 		api:       api,
-		embedder:  emb,
+		recall:    recallWiring{embedder: emb, memStore: memory.NewInMemoryStore()},
 		router:    buildRouter(emb, tool.NewMatcher(api), 0.55, nil),
 		replier:   voice.NewStubReplier(),
 		now:       func() time.Time { return now },
-		memStore:  memory.NewInMemoryStore(),
 		dataStore: st,
 	}
 	return h, api
@@ -44,7 +43,7 @@ func TestActionFact_QuestionIsNotWritten(t *testing.T) {
 	if _, err := api.LatestFact(ctx, "go_version"); err == nil {
 		t.Fatal("a question was stored as a fact about him")
 	}
-	hits, err := h.memStore.Search(ctx, mustEmbedPassage(t, h, "какая последняя версия языка Go?"), 3)
+	hits, err := h.recall.memStore.Search(ctx, mustEmbedPassage(t, h, "какая последняя версия языка Go?"), 3)
 	if err != nil {
 		t.Fatalf("memory search: %v", err)
 	}
@@ -81,7 +80,7 @@ func TestActionFact_ExplicitCaptureStillWrites(t *testing.T) {
 	// #493: what recall reads back is the fact, not the sentence he said.
 	// queryMemory returns a fact's text verbatim, so the utterance sitting here
 	// meant "запиши что я пил воду" was the answer to "когда я пил воду?".
-	hits, err := h.memStore.Search(ctx, mustEmbedPassage(t, h, "вода"), 3)
+	hits, err := h.recall.memStore.Search(ctx, mustEmbedPassage(t, h, "вода"), 3)
 	if err != nil {
 		t.Fatalf("memory search: %v", err)
 	}
@@ -117,7 +116,7 @@ func TestFactConfidence(t *testing.T) {
 
 func mustEmbedPassage(t *testing.T, h *reactiveHandler, text string) []float32 {
 	t.Helper()
-	vec, err := router.EmbedQuery(context.Background(), h.embedder, text)
+	vec, err := router.EmbedQuery(context.Background(), h.recall.embedder, text)
 	if err != nil {
 		t.Fatalf("embed %q: %v", text, err)
 	}

cmd/mavend/feeds_test.go

@@ -29,12 +29,12 @@ func buildFeedHandler(t *testing.T, feedsOn bool, notes ...ipc.Note) *reactiveHa
 		}
 	}
 	return &reactiveHandler{
-		api:      ipc.NewStoreAPI(st),
-		replier:  voice.NewStubReplier(),
-		phraser:  phraser.NewStub(),
-		now:      func() time.Time { return now },
-		feedsOn:  feedsOn,
-		embedder: nil,
+		api:     ipc.NewStoreAPI(st),
+		replier: voice.NewStubReplier(),
+		phraser: phraser.NewStub(),
+		now:     func() time.Time { return now },
+		feedsOn: feedsOn,
+		recall:  recallWiring{embedder: nil},
 	}
 }
 

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{recall: recallWiring{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.recall.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/query_recall_test.go

@@ -85,15 +85,17 @@ func buildRecallHandler(t *testing.T, question string, mems []recallCase) (*reac
 
 	phr := &recordingPhraser{Stub: phraser.NewStub()}
 	h := &reactiveHandler{
-		api:             ipc.NewStoreAPI(st),
-		embedder:        emb,
+		api: ipc.NewStoreAPI(st),
+		recall: recallWiring{
+			embedder:  emb,
+			memStore:  mem,
+			minScore:  0.55,
+			minMargin: 0.008,
+		},
 		replier:         voice.NewStubReplier(),
 		phraser:         phr,
 		now:             func() time.Time { return now },
-		memStore:        mem,
 		dataStore:       st,
-		queryMinScore:   0.55,
-		queryMinMargin:  0.008,
 		weatherProvider: nil,
 	}
 	return h, phr

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"
 )
@@ -24,11 +26,10 @@ func TestReactiveNotesReminders(t *testing.T) {
 
 	h := &reactiveHandler{
 		api:       api,
-		embedder:  emb,
+		recall:    recallWiring{embedder: emb, memStore: memory.NewInMemoryStore()},
 		router:    rtr,
 		replier:   voice.NewStubReplier(),
 		now:       func() time.Time { return now },
-		memStore:  memory.NewInMemoryStore(),
 		dataStore: st,
 	}
 
@@ -85,3 +86,37 @@ 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,
+		recall:    recallWiring{embedder: emb, memStore: memory.NewInMemoryStore()},
+		router:    buildRouter(emb, matcher, 0.55, nil),
+		replier:   voice.NewStubReplier(),
+		now:       func() time.Time { return now },
+		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/recall.go

@@ -1,6 +1,9 @@
 package main
 
-import "github.com/kami/maven/internal/memory"
+import (
+	"github.com/kami/maven/internal/memory"
+	"github.com/kami/maven/internal/router"
+)
 
 // bestRecall is the read side of the long-term memory store: the top hit when
 // it clears the confidence gate. The index holds BOTH notes and facts, and
@@ -23,3 +26,34 @@ func bestRecall(results []memory.Result, minScore, minMargin float64) (memory.Re
 	}
 	return results[0], true
 }
+
+// recallWiring — the recall subsystem's dependencies, held as one group on
+// reactiveHandler (Vikunja #433). It is the worked example for the wiring
+// decision in docs/handler-wiring.md: cohesive groups of fields, not thirty
+// loose ones, so a handler names what it needs and the package can be split
+// later without exporting the whole struct.
+//
+// The zero value is usable and means "no recall": no embedder, no vector
+// store, and a gate that is never consulted because nothing is ever searched.
+type recallWiring struct {
+	// embedder — reused for note write/query (same model as the classifier).
+	embedder router.Embedder
+
+	// memStore — the vector index over notes and facts.
+	memStore memory.Store
+
+	// 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
+
+	// minScore — the note-recall confidence gate. Top cosine below this ⇒
+	// "I don't know" instead of a guess. Tuned for the ONNX embedder; a knob,
+	// not load-bearing math (same posture as the presence thresholds). Set by
+	// wireVoice from VoiceConfig; default 0.55.
+	minScore float64
+
+	// minMargin — the second half of that gate: how far the top hit must beat
+	// the runner-up. 0 ⇒ margin off.
+	minMargin float64
+}

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

@@ -428,20 +428,22 @@ func newSimWorld(t *testing.T, sc scenario) *simWorld {
 	rtr := buildRouter(emb, matcher, config.DefaultRouterThreshold, router.NewLLMRouter(scripted))
 
 	w.handler = &reactiveHandler{
-		stt:                simTranscriber{},
-		tts:                simSynthesizer{},
-		router:             rtr,
-		embedder:           emb,
+		stt:    simTranscriber{},
+		tts:    simSynthesizer{},
+		router: rtr,
+		recall: recallWiring{
+			embedder:  emb,
+			memStore:  st.VectorMemory(),
+			minScore:  config.DefaultQueryMinScore,
+			minMargin: config.DefaultQueryMinMargin,
+		},
 		api:                api,
 		matcher:            matcher,
 		tools:              tool.NewExecutor(api, 5*time.Second),
 		phraser:            phraser.NewStub(),
 		replier:            newLLMReplier(scripted, nil),
 		now:                clock.Now,
-		memStore:           st.VectorMemory(),
 		dataStore:          st,
-		queryMinScore:      config.DefaultQueryMinScore,
-		queryMinMargin:     config.DefaultQueryMinMargin,
 		timeParser:         router.StubDateTimeParser{},
 		dialogueSessions:   dialogue.NewSessionStore(time.Hour),
 		clarifyStore:       dialogue.NewClarifyStore(time.Hour),
@@ -1043,3 +1045,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

@@ -10,22 +10,17 @@ package main
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"log"
 	"os"
 	"path/filepath"
-	"strings"
 	"sync"
 	"time"
 
-	"github.com/kami/maven/internal/calendar"
 	"github.com/kami/maven/internal/config"
 	"github.com/kami/maven/internal/delivery"
-	"github.com/kami/maven/internal/ipc"
 	"github.com/kami/maven/internal/loop"
 	"github.com/kami/maven/internal/morning"
-	"github.com/kami/maven/internal/pattern"
 	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/routine"
 	"github.com/kami/maven/internal/store"
@@ -315,597 +310,6 @@ func (t *tickLoop) repeatPhrase(rule string) (body, summary string) {
 	return pn.Body, pn.Summary
 }
 
-// shouldQueue — true when digest is enabled and the candidate's severity is
-// at or below the configured ceiling.
-func (t *tickLoop) shouldQueue(cand *loop.Candidate) bool {
-	return t.digestCfg != nil && t.digestCfg.Enabled &&
-		cand.Severity <= loop.Severity(t.digestCfg.SeverityCeiling)
-}
-
-// queueNudge — phrases the candidate and appends it to the digest queue.
-// Deduplicates by rule name: if the same rule is already queued, this is a
-// no-op (the first fire within the window is the one that counts).
-func (t *tickLoop) queueNudge(ctx context.Context, cand *loop.Candidate, _ loop.State, now time.Time) {
-	for _, q := range t.digestQ {
-		if q.Rule == cand.Rule.Name {
-			return // already queued
-		}
-	}
-	pn, err := t.phraser.PhraseNudge(ctx, *cand)
-	if err != nil {
-		log.Printf("tick: phrase nudge %s: %v", cand.Rule.Name, err)
-		return
-	}
-	t.digestQ = append(t.digestQ, QueuedNudge{
-		Rule:     cand.Rule.Name,
-		Severity: int(cand.Severity),
-		Body:     pn.Body,
-		Key:      cand.Rule.Name,
-		QueuedAt: now,
-	})
-	t.cachePhrase(pn)
-}
-
-// maybeFlush — flushes the digest queue if the window has elapsed since the
-// first item or the queue reached MaxItems.
-func (t *tickLoop) maybeFlush(ctx context.Context, now time.Time, state loop.State) {
-	if t.digestCfg == nil || !t.digestCfg.Enabled || len(t.digestQ) == 0 {
-		return
-	}
-	first := t.digestQ[0]
-	if now.Sub(first.QueuedAt) >= time.Duration(t.digestCfg.Window) ||
-		len(t.digestQ) >= t.digestCfg.MaxItems {
-		t.flushDigest(ctx, now, state)
-	}
-}
-
-// flushDigest — concatenates queued nudge bodies into a single digest
-// notification and dispatches it. Clears the queue after a successful send.
-// The digest uses the max severity among queued items for routing.
-func (t *tickLoop) flushDigest(ctx context.Context, now time.Time, state loop.State) {
-	if len(t.digestQ) == 0 {
-		return
-	}
-
-	var b strings.Builder
-	maxSev := 0
-	for i, q := range t.digestQ {
-		if i > 0 {
-			b.WriteString(" · ")
-		}
-		b.WriteString(q.Body)
-		if q.Severity > maxSev {
-			maxSev = q.Severity
-		}
-	}
-	body := b.String()
-	summary := fmt.Sprintf("%d pending notifications", len(t.digestQ))
-
-	cand := loop.Candidate{
-		Rule: loop.Rule{
-			Name:     "digest",
-			Severity: loop.Severity(maxSev),
-		},
-		Severity: loop.Severity(maxSev),
-		State:    state,
-	}
-	pn := delivery.PhrasedNudge{
-		Candidate: cand,
-		Body:      body,
-		Summary:   summary,
-	}
-	t.cachePhrase(pn)
-	if _, err := t.dispatcher.DispatchNudge(ctx, pn, now); err != nil {
-		// keep the queue — the next tick's maybeFlush re-attempts.
-		log.Printf("tick: dispatch digest: %v", err)
-		return
-	}
-	t.digestQ = nil
-}
-
-// detectPatterns runs the pattern detector proactively over every
-// action+object pair that has ever produced an event, independent of
-// whichever fact write (or channel) last touched it (Vikunja #43). This is
-// what makes pattern inference actually proactive: it fires on the daemon's
-// own schedule reading accumulated history, not only as a side effect of a
-// live voice turn.
-//
-// Idempotence and noise are handled by the store, not here — this function
-// is safe to call every tick:
-//   - Same pattern, tick after tick: detectAndPropose's LookupProposedRoutine
-//     check plus proposed_routines' UNIQUE(action, object) constraint (with
-//     CreateProposedRoutine's ON CONFLICT DO NOTHING) mean a pair that
-//     already has a row — in ANY status — produces no second row and no log
-//     spam beyond the one line at genuine creation.
-//   - A DISMISSED proposal must never come back. DismissProposedRoutine flips
-//     status in place; the row is never deleted. So the same Lookup check
-//     that stops a duplicate "proposed" also stops a "dismissed" one from
-//     resurrecting — there is nothing tick-specific to get right here beyond
-//     calling the same shared path the voice route already used.
-//
-// By default this only creates a row for the /routines page to show: it does
-// not notify, ring, or speak. Detection is not the same act as disturbing him
-// about it, and Maven is "not a nag, not autonomous" (CLAUDE.md). Announcing
-// is opt-in through the pattern_proposals config block — see announceProposal
-// for the restraints that apply even then. A proposal only starts producing
-// recurring nudges once he accepts it (fireAcceptedRoutines).
-func (t *tickLoop) detectPatterns(ctx context.Context, now time.Time, state loop.State) {
-	pairs, err := t.store.DistinctEventPairs(ctx)
-	if err != nil {
-		log.Printf("tick: distinct event pairs: %v", err)
-		return
-	}
-	announced := false
-	for _, p := range pairs {
-		r, _, err := detectAndPropose(ctx, t.store, p.Action, p.Object, now)
-		if err != nil {
-			log.Printf("tick: detect pattern %s/%s: %v", p.Action, p.Object, err)
-			continue
-		}
-		if r == nil {
-			continue // no stable pattern, or already proposed/accepted/dismissed
-		}
-		log.Printf("tick: proposed routine: %s/%s every %.1f days", r.Action, r.Object, r.IntervalDays)
-		// One announcement per tick at most, whatever the scan turned up. The
-		// rest are on /routines; they are not lost, they are just not shouted.
-		// Nor are they queued: the row now exists, so no later tick re-detects
-		// them and they are never announced. See announceProposal.
-		if announced {
-			continue
-		}
-		announced = t.announceProposal(ctx, r, now, state)
-	}
-}
-
-// announceProposal offers a freshly inferred routine through the ordinary
-// care-delivery path, if announcing is switched on at all. Returns true when
-// something was actually sent.
-//
-// Everything here is restraint. The feature is off unless configured; when on
-// it is sev1 (the lowest severity, so quiet hours, away presence and snooze
-// all suppress it via loop.Gate exactly like a care nudge); it is spaced by
-// proposalCfg.Cooldown across every pair, not per pair; and a suppressed or
-// dropped announcement is NOT retried — the cooldown clock advances only on a
-// real send, but the proposal row already exists, so the next tick will not
-// re-detect it and nothing queues up behind it. A missed announcement means
-// he reads it on /routines instead, which is the whole point of the page.
-//
-// What the cooldown is and is not. detectAndPropose returns non-nil only for a
-// newly created row, so a pair gets exactly one chance to be spoken: the tick
-// that first proposes it. Combined with one announcement per tick, the first
-// tick over a populated history announces one pattern and permanently silences
-// every other pattern found in the same pass. That is the intent, not an
-// oversight — an inferred routine is not worth a second attempt at his
-// attention, and /routines lists all of them. So the cooldown does not drain a
-// backlog. It only spaces announcements of genuinely new pairs discovered on
-// later ticks. If it should ever become "one per day until each is mentioned",
-// that needs a queue rather than this counter.
-//
-// Cooldown gets its default here as well as in applyDefaults. That is
-// deliberate: a tickLoop assembled directly in a test never goes through Load,
-// and an unspaced announcer is not what those tests mean to exercise.
-//
-// The body is the detector's own literal Russian phrasing (pattern.PhraseRoutine
-// — "ты заправляешь поилку раз в 7 дней — напоминать?"), not LLM-generated, so
-// an inferred routine cannot arrive worded as something Maven never observed.
-func (t *tickLoop) announceProposal(ctx context.Context, r *pattern.ProposedRoutine, now time.Time, state loop.State) bool {
-	if !t.proposalCfg.AnnounceProposals() {
-		return false
-	}
-	cooldown := time.Duration(t.proposalCfg.Cooldown)
-	if cooldown <= 0 {
-		cooldown = config.DefaultProposalCooldown
-	}
-	if !t.lastProposalAt.IsZero() && now.Sub(t.lastProposalAt) < cooldown {
-		return false
-	}
-
-	rule := loop.Rule{Name: "proposal:" + r.Action + " " + r.Object, Severity: loop.Sev1}
-	if !loop.Gate(state, rule) {
-		return false
-	}
-	body := pattern.PhraseRoutine(r)
-	pn := delivery.PhrasedNudge{
-		Candidate: loop.Candidate{Rule: rule, Severity: rule.Severity, State: state},
-		Body:      body,
-		Summary:   body,
-	}
-	sent, err := t.dispatcher.DispatchNudge(ctx, pn, now)
-	if err != nil {
-		log.Printf("tick: announce proposal %s/%s: %v", r.Action, r.Object, err)
-		return false
-	}
-	if len(sent) == 0 {
-		return false // routing dropped it — /routines still has it.
-	}
-	t.lastProposalAt = now
-	return true
-}
-
-// digestExpiry — how long a gate-suppressed care nudge stays worth
-// resurfacing. 24h: these are daily-cadence rules (water/meal/break run on
-// hour-scale cooldowns and re-derive from facts that reset every day), so a
-// digest entry that outlives one full day is describing a day that's already
-// over — "you skipped a break yesterday" said tomorrow evening is noise, not
-// news. Bounding at one day also means a digest can never silently span a
-// weekend of quiet hours into an unbounded backlog.
-const digestExpiry = 24 * time.Hour
-
-// maxDigestSpokenItems — the bundle read-out is capped so "batched, not
-// dropped" cannot regress into "she dumps twelve things on me the moment I
-// walk in" — a digest that nags in bulk is worse than the drops it replaced.
-// Anything beyond the cap is still marked drained (it did get its moment;
-// the cap limits WORDS, not whether it counted) and folded into a trailing
-// count instead of being spoken in full.
-const maxDigestSpokenItems = 3
-
-// enqueueSuppressedDigest scans this tick's trace for care candidates the
-// gate blocked for a genuine restraint reason and durably records the
-// digest-eligible ones (loop.DigestEligible). Phrasing happens once, here,
-// at enqueue time — not re-derived at drain time — the same way queueNudge
-// phrases once and caches, so a rule suppressed for hours isn't re-prompting
-// the LLM every tick it stays blocked (EnqueueDigestEntry's rule+body dedupe
-// makes repeat calls here harmless, but skipping the phrase call entirely
-// when a pending entry already exists avoids the LLM round-trip too).
-func (t *tickLoop) enqueueSuppressedDigest(ctx context.Context, trace *loop.TickTrace, state loop.State, now time.Time) {
-	if trace == nil {
-		return
-	}
-	for _, tr := range trace.RuleTraces {
-		if !tr.PredicateResult || tr.GateResult {
-			continue // didn't want to fire, or wasn't suppressed
-		}
-		if !loop.DigestEligible(tr.Severity, tr.GateBlockedBy) {
-			continue
-		}
-		rule := loop.Rule{Name: tr.RuleName, Severity: tr.Severity}
-		cand := loop.Candidate{Rule: rule, Severity: tr.Severity, State: state}
-		pn, err := t.phraser.PhraseNudge(ctx, cand)
-		if err != nil {
-			log.Printf("tick: phrase digest candidate %s: %v", tr.RuleName, err)
-			continue
-		}
-		expires := now.Add(digestExpiry)
-		if _, deduped, err := t.store.EnqueueDigestEntry(ctx, tr.RuleName, int(tr.Severity), pn.Body, now, expires); err != nil {
-			log.Printf("tick: enqueue digest entry %s: %v", tr.RuleName, err)
-		} else if deduped {
-			// same suppressed nudge already pending — nothing new to say.
-			continue
-		}
-	}
-}
-
-// expireStaleDigest sweeps entries past their expiry once per tick — cheap
-// bookkeeping, mirrors ReconcileStaleDeliveryAttempts's shape.
-func (t *tickLoop) expireStaleDigest(ctx context.Context, now time.Time) {
-	n, err := t.store.ExpireStaleDigestEntries(ctx, now)
-	if err != nil {
-		log.Printf("tick: expire stale digest entries: %v", err)
-		return
-	}
-	if n > 0 {
-		log.Printf("tick: expired %d stale digest entr(y/ies) unspoken", n)
-	}
-}
-
-// maybeDrainDigest speaks the pending digest bundle once the gate's
-// suppression reasons have actually cleared — quiet hours over, back from
-// away, out of the meeting. Draining while still suppressed would just be a
-// second way to nag through quiet hours; the bundle waits for the same "is
-// it allowed right now" condition a live nudge already waits for.
-func (t *tickLoop) maybeDrainDigest(ctx context.Context, state loop.State, now time.Time) {
-	if state.QuietHours || state.CalendarBusy || state.Presence == store.Away {
-		return
-	}
-	entries, err := t.store.PendingDigestEntries(ctx, now)
-	if err != nil {
-		log.Printf("tick: pending digest entries: %v", err)
-		return
-	}
-	if len(entries) == 0 {
-		return
-	}
-
-	spoken := entries
-	extra := 0
-	if len(spoken) > maxDigestSpokenItems {
-		spoken = entries[:maxDigestSpokenItems]
-		extra = len(entries) - maxDigestSpokenItems
-	}
-	var b strings.Builder
-	maxSev := 0
-	for i, e := range spoken {
-		if i > 0 {
-			b.WriteString(" · ")
-		}
-		b.WriteString(e.Body)
-		if e.Severity > maxSev {
-			maxSev = e.Severity
-		}
-	}
-	if extra > 0 {
-		fmt.Fprintf(&b, " · и ещё %d", extra)
-	}
-	body := b.String()
-	summary := fmt.Sprintf("%d отложенных уведомлений", len(entries))
-
-	cand := loop.Candidate{
-		Rule:     loop.Rule{Name: "digest", Severity: loop.Severity(maxSev)},
-		Severity: loop.Severity(maxSev),
-		State:    state,
-	}
-	pn := delivery.PhrasedNudge{Candidate: cand, Body: body, Summary: summary}
-	t.cachePhrase(pn)
-	if _, err := t.dispatcher.DispatchNudge(ctx, pn, now); err != nil {
-		log.Printf("tick: dispatch digest bundle: %v", err)
-		return // leave entries pending; retried next tick
-	}
-	ids := make([]int64, len(entries))
-	for i, e := range entries {
-		ids[i] = e.ID
-	}
-	if err := t.store.DrainDigestEntries(ctx, ids, now); err != nil {
-		log.Printf("tick: drain digest entries: %v", err)
-	}
-}
-
-// routinesFromConfig maps the config's routine blocks to the engine type.
-// Validation (cron parses, name/body present, severity defaulted) already ran
-// in config.Load, so this is a pure field copy.
-func routinesFromConfig(rc []config.RoutineConfig) []routine.Routine {
-	if len(rc) == 0 {
-		return nil
-	}
-	out := make([]routine.Routine, len(rc))
-	for i, r := range rc {
-		out[i] = routine.Routine{Name: r.Name, Cron: r.Cron, Body: r.Body, Severity: r.Severity}
-	}
-	return out
-}
-
-// fireRoutines dispatches the routines whose cron schedule crossed since their
-// last fire. Each is delivered as a nudge through the normal routing table
-// (ChannelsFor(severity, presence)) with a "routine:"-prefixed rule name so it
-// can't collide with a care rule in the feedback autotuner. A dispatch failure
-// logs and continues — one bad send must not skip the rest, and routine.Due has
-// already advanced the last-fire time so a transient failure drops that fire
-// rather than replaying it every tick (a routine is clockwork, not an alarm —
-// no repeat-til-ack).
-func (t *tickLoop) fireRoutines(ctx context.Context, now time.Time, state loop.State) {
-	for _, r := range routine.Due(t.routines, t.routineLast, now) {
-		pn := delivery.PhrasedNudge{
-			Candidate: loop.Candidate{
-				Rule:     loop.Rule{Name: "routine:" + r.Name, Severity: loop.Severity(r.Severity)},
-				Severity: loop.Severity(r.Severity),
-				State:    state,
-			},
-			Body:    r.Body,
-			Summary: r.Body,
-		}
-		if _, err := t.dispatcher.DispatchNudge(ctx, pn, now); err != nil {
-			log.Printf("tick: dispatch routine %s: %v", r.Name, err)
-		}
-	}
-}
-
-// fireAcceptedRoutines nudges about the routines the user accepted, once per
-// interval (Vikunja #366). Accepting used to create a single reminder, so a
-// non-weekly routine fired once and went quiet forever; the schedule lives in
-// the proposed_routines row now and the loop re-reads it every tick.
-//
-// A routine is a care-class nudge and goes through the restraint gate like any
-// other: quiet hours, away presence and snooze all suppress it. Reminders bypass
-// that gate; routines must not. A suppressed nudge is NOT marked fired, so it
-// goes out on the next tick that the gate allows — one nudge, held, not dropped
-// and not repeated.
-//
-// The body is literal text built from the detected action and object, not
-// LLM-phrased, so a routine can't hallucinate. It nudges; it never acts.
-func (t *tickLoop) fireAcceptedRoutines(ctx context.Context, now time.Time, state loop.State) {
-	rows, err := t.store.ListAcceptedRoutines(ctx)
-	if err != nil {
-		log.Printf("tick: list accepted routines: %v", err)
-		return
-	}
-	accepted := make([]routine.Accepted, 0, len(rows))
-	for _, r := range rows {
-		if r.AcceptedTs == nil {
-			continue // accepted before the schedule column existed — no clock to start from.
-		}
-		accepted = append(accepted, routine.Accepted{
-			ID:           r.ID,
-			Name:         r.Action + " " + r.Object,
-			IntervalDays: r.IntervalDays,
-			Accepted:     *r.AcceptedTs,
-			LastFired:    r.LastFiredTs,
-		})
-	}
-
-	for _, a := range routine.DueAccepted(accepted, now) {
-		rule := loop.Rule{Name: "routine:" + a.Name, Severity: loop.Sev1}
-		if !loop.Gate(state, rule) {
-			continue
-		}
-		body := "пора: " + a.Name
-		pn := delivery.PhrasedNudge{
-			Candidate: loop.Candidate{Rule: rule, Severity: rule.Severity, State: state},
-			Body:      body,
-			Summary:   body,
-		}
-		sent, err := t.dispatcher.DispatchNudge(ctx, pn, now)
-		if err != nil {
-			log.Printf("tick: dispatch accepted routine %d: %v", a.ID, err)
-			continue
-		}
-		if len(sent) == 0 {
-			continue // routing dropped it — leave it due.
-		}
-		if err := t.store.MarkRoutineFired(ctx, a.ID, now); err != nil {
-			log.Printf("tick: mark routine %d fired: %v", a.ID, err)
-		}
-	}
-}
-
-// fireMorningRoutines checks each configured checklist against today's facts
-// and dispatches a nag listing exactly what's still missing, at most once per
-// routine per calendar day. Fact reads happen here (not in loop.Gatherer)
-// because the item↔fact-key mapping is morning-routine-specific, not a rule
-// concern — pulling it into the shared gather path would leak that mapping
-// into loop's "rules declare wanted keys" contract. Bodies are literal
-// operator text (item labels joined), not LLM-phrased, same rationale as
-// cron routines: deterministic, can't hallucinate a checklist item.
-func (t *tickLoop) fireMorningRoutines(ctx context.Context, now time.Time, state loop.State) {
-	if len(t.morningRoutines) == 0 {
-		return
-	}
-	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, ", "))
-		pn := delivery.PhrasedNudge{
-			Candidate: loop.Candidate{
-				Rule:     loop.Rule{Name: "morning:" + cand.Routine.Name, Severity: loop.Severity(cand.Routine.Severity)},
-				Severity: loop.Severity(cand.Routine.Severity),
-				State:    state,
-			},
-			Body:    body,
-			Summary: body,
-		}
-		if _, err := t.dispatcher.DispatchNudge(ctx, pn, now); err != nil {
-			log.Printf("tick: dispatch morning routine %s: %v", cand.Routine.Name, err)
-		}
-	}
-}
-
-// 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
-// disagree about what evidence exists.
-func (t *tickLoop) gatherMorningFacts(ctx context.Context) map[string]store.Fact {
-	keys := make(map[string]struct{})
-	for _, r := range t.morningRoutines {
-		for _, it := range r.Items {
-			keys[it.FactKey] = struct{}{}
-		}
-	}
-	facts := make(map[string]store.Fact, len(keys))
-	for k := range keys {
-		f, err := t.store.LatestFact(ctx, k)
-		if err == nil {
-			facts[k] = f
-			continue
-		}
-		if err != store.ErrNoFact {
-			log.Printf("tick: morning: latest fact %s: %v", k, err)
-		}
-	}
-	return facts
-}
-
-// morningStatus is the read-only "what's missing" query the web UI (and
-// eventually a voice query) calls. Pure recompute over the current facts —
-// no dedupe/nudge-time gating, unlike fireMorningRoutines: this answers
-// "state right now," not "should we nag."
-func (t *tickLoop) morningStatus(ctx context.Context, now time.Time) []ipc.MorningRoutineStatus {
-	if len(t.morningRoutines) == 0 {
-		return nil
-	}
-	facts := t.gatherMorningFacts(ctx)
-	out := make([]ipc.MorningRoutineStatus, 0, len(t.morningRoutines))
-	for _, r := range t.morningRoutines {
-		st := morning.Evaluate(r, facts, now)
-		done := make(map[string]bool, len(st.Completed))
-		for _, it := range st.Completed {
-			done[it.Key] = true
-		}
-		items := make([]ipc.MorningRoutineItem, len(r.Items))
-		for i, it := range r.Items {
-			items[i] = ipc.MorningRoutineItem{Key: it.Key, Label: it.Label, Done: done[it.Key]}
-		}
-		out = append(out, ipc.MorningRoutineStatus{
-			Name:        r.Name,
-			Active:      st.Active,
-			WindowStart: r.WindowStart,
-			WindowEnd:   r.WindowEnd,
-			Items:       items,
-		})
-	}
-	return out
-}
-
-// dayPlan is the read-only "what does today hold" query (Vikunja #128). It is
-// the impure half of morning.BuildPlan: it reads the calendar events, the
-// pending reminders and the checklist facts, and the pure builder orders them.
-//
-// It never dispatches. Asking for the plan is a query like any other; the only
-// unprompted delivery in maven stays with the morning nudge and the
-// dispatcher's policy.
-func (t *tickLoop) dayPlan(ctx context.Context, now time.Time) ipc.DayPlan {
-	y, m, d := now.Date()
-	dayStart := time.Date(y, m, d, 0, 0, 0, 0, now.Location())
-	dayEnd := dayStart.AddDate(0, 0, 1)
-
-	var events []morning.PlanEntry
-	facts, err := t.store.CalendarEvents(ctx, dayStart, dayEnd)
-	if err != nil {
-		log.Printf("tick: day plan: calendar events: %v", err)
-	}
-	for _, f := range facts {
-		events = append(events, morning.PlanEntry{
-			At: f.Ts,
-			// The plan prints the hour itself, so the "@ 14:00-14:30" tail the
-			// fact value carries would say it twice.
-			Text: calendar.FactSummary(f.Value),
-			Kind: morning.PlanEvent,
-			// Provenance below a calendar read (an ambient relay, #126) is
-			// hedged rather than recited as fact.
-			Uncertain: f.Confidence < 1.0,
-		})
-	}
-
-	var reminders []morning.PlanEntry
-	rems, err := t.store.PendingReminders(ctx, dayStart, dayEnd)
-	if err != nil {
-		log.Printf("tick: day plan: pending reminders: %v", err)
-	}
-	for _, r := range rems {
-		if r.Status != store.ReminderPending {
-			continue
-		}
-		fire := r.NextFireTs
-		if fire.IsZero() {
-			fire = r.FireTs
-		}
-		reminders = append(reminders, morning.PlanEntry{
-			At:   fire,
-			Text: r.Text(),
-			Kind: morning.PlanReminder,
-		})
-	}
-
-	var checklistFacts map[string]store.Fact
-	if len(t.morningRoutines) > 0 {
-		checklistFacts = t.gatherMorningFacts(ctx)
-	}
-	plan := morning.BuildPlan(t.morningRoutines, checklistFacts, events, reminders, now)
-
-	out := ipc.DayPlan{Date: plan.Date, Spoken: plan.FormatRU()}
-	out.Items = make([]ipc.DayPlanItem, len(plan.Items))
-	for i, it := range plan.Items {
-		out.Items[i] = ipc.DayPlanItem{
-			At:        it.At,
-			Text:      it.Text,
-			Kind:      string(it.Kind),
-			Uncertain: it.Uncertain,
-		}
-	}
-	return out
-}
-
 // tune — the feedback auto-tuner's impure step. runs on a slow cadence
 // (autotuneInterval, see run) so it doesn't write a fact every tick. for each
 // rule:
@@ -978,101 +382,3 @@ func (t *tickLoop) trace() *loop.TickTrace {
 	defer t.mu.Unlock()
 	return t.lastTrace
 }
-
-// daemonAPI wraps a store-backed CoreAPI and overrides TickTrace with the
-// daemon's in-memory tick trace cache.
-type daemonAPI struct {
-	ipc.CoreAPI
-	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
-	getMCPServers    func() []ipc.MCPServerStatus
-	getEvents        func(n int) []ipc.IntakeEvent
-}
-
-// RecentEvents — the unified intake journal (Vikunja #283). Empty, not an
-// error, when no bus was wired: "nothing has arrived" and "the journal is off"
-// look the same to a reader on purpose, because neither is a fault and the
-// page renders both as an empty table.
-func (d *daemonAPI) RecentEvents(ctx context.Context, n int) ([]ipc.IntakeEvent, error) {
-	if d.getEvents == nil {
-		return nil, nil
-	}
-	return d.getEvents(n), nil
-}
-
-func (d *daemonAPI) Chat(ctx context.Context, text string) (string, error) {
-	if d.chatFn == nil {
-		return "", errors.New("mavend: chat not available")
-	}
-	return d.chatFn(ctx, text), nil
-}
-
-// MCPServers — the configured MCP servers and their health (Vikunja #251).
-// Empty, not an error, when the mcp block is absent: "not configured" is the
-// default state and the web surface renders it as such.
-func (d *daemonAPI) MCPServers(ctx context.Context) ([]ipc.MCPServerStatus, error) {
-	if d.getMCPServers == nil {
-		return nil, nil
-	}
-	return d.getMCPServers(), nil
-}
-
-func (d *daemonAPI) TickTrace(ctx context.Context) (ipc.TickTrace, error) {
-	trace := d.getTrace()
-	if trace == nil {
-		return ipc.TickTrace{}, nil
-	}
-	return toIPCTickTrace(*trace), nil
-}
-
-func (d *daemonAPI) MorningStatus(ctx context.Context) ([]ipc.MorningRoutineStatus, error) {
-	if d.getMorningStatus == nil {
-		return nil, errors.New("mavend: morning status not available")
-	}
-	return d.getMorningStatus(ctx), nil
-}
-
-func (d *daemonAPI) DayPlan(ctx context.Context) (ipc.DayPlan, error) {
-	if d.getDayPlan == nil {
-		return ipc.DayPlan{}, errors.New("mavend: day plan not available")
-	}
-	return d.getDayPlan(ctx), nil
-}
-
-func toIPCTickTrace(t loop.TickTrace) ipc.TickTrace {
-	rules := make([]ipc.RuleTrace, len(t.RuleTraces))
-	for i, r := range t.RuleTraces {
-		rules[i] = toIPCRuleTrace(r)
-	}
-	return ipc.TickTrace{
-		Now:    t.Now,
-		Winner: t.Winner,
-		Rules:  rules,
-	}
-}
-
-func toIPCRuleTrace(r loop.RuleTrace) ipc.RuleTrace {
-	return ipc.RuleTrace{
-		RuleName:        r.RuleName,
-		Severity:        int(r.Severity),
-		PredicateResult: r.PredicateResult,
-		GateResult:      r.GateResult,
-		GateBlockedBy:   r.GateBlockedBy,
-		GateDetail:      toIPCGateDetail(r.GateDetail),
-		WasSelected:     r.WasSelected,
-		LostTo:          r.LostTo,
-	}
-}
-
-func toIPCGateDetail(d loop.GateDetail) ipc.GateDetail {
-	return ipc.GateDetail{
-		SnoozeUntil:      d.SnoozeUntil,
-		CooldownUntil:    d.CooldownUntil,
-		QuietHours:       d.QuietHours,
-		CalendarBusy:     d.CalendarBusy,
-		Presence:         d.Presence,
-		InertKeysMissing: d.InertKeysMissing,
-	}
-}

cmd/mavend/tick_api.go

@@ -0,0 +1,111 @@
+// mavend/tick_api.go — the daemonAPI read surface over the tick loop.
+//
+// Split out of tick.go, move-only (Vikunja #422). What mavweb asks the daemon
+// for, and the loop-to-ipc conversions those answers need.
+package main
+
+import (
+	"context"
+	"errors"
+
+	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/loop"
+)
+
+// daemonAPI wraps a store-backed CoreAPI and overrides TickTrace with the
+// daemon's in-memory tick trace cache.
+type daemonAPI struct {
+	ipc.CoreAPI
+	getTrace         func() *loop.TickTrace
+	getMorningStatus func(ctx context.Context) []ipc.MorningRoutineStatus
+	getDayPlan       func(ctx context.Context) ipc.DayPlan
+	chatFn           func(ctx context.Context, conversation, text string) string
+	getMCPServers    func() []ipc.MCPServerStatus
+	getEvents        func(n int) []ipc.IntakeEvent
+}
+
+// RecentEvents — the unified intake journal (Vikunja #283). Empty, not an
+// error, when no bus was wired: "nothing has arrived" and "the journal is off"
+// look the same to a reader on purpose, because neither is a fault and the
+// page renders both as an empty table.
+func (d *daemonAPI) RecentEvents(ctx context.Context, n int) ([]ipc.IntakeEvent, error) {
+	if d.getEvents == nil {
+		return nil, nil
+	}
+	return d.getEvents(n), nil
+}
+
+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, conversation, text), nil
+}
+
+// MCPServers — the configured MCP servers and their health (Vikunja #251).
+// Empty, not an error, when the mcp block is absent: "not configured" is the
+// default state and the web surface renders it as such.
+func (d *daemonAPI) MCPServers(ctx context.Context) ([]ipc.MCPServerStatus, error) {
+	if d.getMCPServers == nil {
+		return nil, nil
+	}
+	return d.getMCPServers(), nil
+}
+
+func (d *daemonAPI) TickTrace(ctx context.Context) (ipc.TickTrace, error) {
+	trace := d.getTrace()
+	if trace == nil {
+		return ipc.TickTrace{}, nil
+	}
+	return toIPCTickTrace(*trace), nil
+}
+
+func (d *daemonAPI) MorningStatus(ctx context.Context) ([]ipc.MorningRoutineStatus, error) {
+	if d.getMorningStatus == nil {
+		return nil, errors.New("mavend: morning status not available")
+	}
+	return d.getMorningStatus(ctx), nil
+}
+
+func (d *daemonAPI) DayPlan(ctx context.Context) (ipc.DayPlan, error) {
+	if d.getDayPlan == nil {
+		return ipc.DayPlan{}, errors.New("mavend: day plan not available")
+	}
+	return d.getDayPlan(ctx), nil
+}
+
+func toIPCTickTrace(t loop.TickTrace) ipc.TickTrace {
+	rules := make([]ipc.RuleTrace, len(t.RuleTraces))
+	for i, r := range t.RuleTraces {
+		rules[i] = toIPCRuleTrace(r)
+	}
+	return ipc.TickTrace{
+		Now:    t.Now,
+		Winner: t.Winner,
+		Rules:  rules,
+	}
+}
+
+func toIPCRuleTrace(r loop.RuleTrace) ipc.RuleTrace {
+	return ipc.RuleTrace{
+		RuleName:        r.RuleName,
+		Severity:        int(r.Severity),
+		PredicateResult: r.PredicateResult,
+		GateResult:      r.GateResult,
+		GateBlockedBy:   r.GateBlockedBy,
+		GateDetail:      toIPCGateDetail(r.GateDetail),
+		WasSelected:     r.WasSelected,
+		LostTo:          r.LostTo,
+	}
+}
+
+func toIPCGateDetail(d loop.GateDetail) ipc.GateDetail {
+	return ipc.GateDetail{
+		SnoozeUntil:      d.SnoozeUntil,
+		CooldownUntil:    d.CooldownUntil,
+		QuietHours:       d.QuietHours,
+		CalendarBusy:     d.CalendarBusy,
+		Presence:         d.Presence,
+		InertKeysMissing: d.InertKeysMissing,
+	}
+}

cmd/mavend/tick_digest.go

@@ -0,0 +1,233 @@
+// mavend/tick_digest.go — the digest queue.
+//
+// Split out of tick.go, move-only (Vikunja #422). A nudge below the severity
+// ceiling is held here instead of spoken, flushed as one batch on the window,
+// and drained by hand when he asks. Everything about batching lives here.
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strings"
+	"time"
+
+	"github.com/kami/maven/internal/delivery"
+	"github.com/kami/maven/internal/loop"
+	"github.com/kami/maven/internal/store"
+)
+
+// shouldQueue — true when digest is enabled and the candidate's severity is
+// at or below the configured ceiling.
+func (t *tickLoop) shouldQueue(cand *loop.Candidate) bool {
+	return t.digestCfg != nil && t.digestCfg.Enabled &&
+		cand.Severity <= loop.Severity(t.digestCfg.SeverityCeiling)
+}
+
+// queueNudge — phrases the candidate and appends it to the digest queue.
+// Deduplicates by rule name: if the same rule is already queued, this is a
+// no-op (the first fire within the window is the one that counts).
+func (t *tickLoop) queueNudge(ctx context.Context, cand *loop.Candidate, _ loop.State, now time.Time) {
+	for _, q := range t.digestQ {
+		if q.Rule == cand.Rule.Name {
+			return // already queued
+		}
+	}
+	pn, err := t.phraser.PhraseNudge(ctx, *cand)
+	if err != nil {
+		log.Printf("tick: phrase nudge %s: %v", cand.Rule.Name, err)
+		return
+	}
+	t.digestQ = append(t.digestQ, QueuedNudge{
+		Rule:     cand.Rule.Name,
+		Severity: int(cand.Severity),
+		Body:     pn.Body,
+		Key:      cand.Rule.Name,
+		QueuedAt: now,
+	})
+	t.cachePhrase(pn)
+}
+
+// maybeFlush — flushes the digest queue if the window has elapsed since the
+// first item or the queue reached MaxItems.
+func (t *tickLoop) maybeFlush(ctx context.Context, now time.Time, state loop.State) {
+	if t.digestCfg == nil || !t.digestCfg.Enabled || len(t.digestQ) == 0 {
+		return
+	}
+	first := t.digestQ[0]
+	if now.Sub(first.QueuedAt) >= time.Duration(t.digestCfg.Window) ||
+		len(t.digestQ) >= t.digestCfg.MaxItems {
+		t.flushDigest(ctx, now, state)
+	}
+}
+
+// flushDigest — concatenates queued nudge bodies into a single digest
+// notification and dispatches it. Clears the queue after a successful send.
+// The digest uses the max severity among queued items for routing.
+func (t *tickLoop) flushDigest(ctx context.Context, now time.Time, state loop.State) {
+	if len(t.digestQ) == 0 {
+		return
+	}
+
+	var b strings.Builder
+	maxSev := 0
+	for i, q := range t.digestQ {
+		if i > 0 {
+			b.WriteString(" · ")
+		}
+		b.WriteString(q.Body)
+		if q.Severity > maxSev {
+			maxSev = q.Severity
+		}
+	}
+	body := b.String()
+	summary := fmt.Sprintf("%d pending notifications", len(t.digestQ))
+
+	cand := loop.Candidate{
+		Rule: loop.Rule{
+			Name:     "digest",
+			Severity: loop.Severity(maxSev),
+		},
+		Severity: loop.Severity(maxSev),
+		State:    state,
+	}
+	pn := delivery.PhrasedNudge{
+		Candidate: cand,
+		Body:      body,
+		Summary:   summary,
+	}
+	t.cachePhrase(pn)
+	if _, err := t.dispatcher.DispatchNudge(ctx, pn, now); err != nil {
+		// keep the queue — the next tick's maybeFlush re-attempts.
+		log.Printf("tick: dispatch digest: %v", err)
+		return
+	}
+	t.digestQ = nil
+}
+
+// digestExpiry — how long a gate-suppressed care nudge stays worth
+// resurfacing. 24h: these are daily-cadence rules (water/meal/break run on
+// hour-scale cooldowns and re-derive from facts that reset every day), so a
+// digest entry that outlives one full day is describing a day that's already
+// over — "you skipped a break yesterday" said tomorrow evening is noise, not
+// news. Bounding at one day also means a digest can never silently span a
+// weekend of quiet hours into an unbounded backlog.
+const digestExpiry = 24 * time.Hour
+
+// maxDigestSpokenItems — the bundle read-out is capped so "batched, not
+// dropped" cannot regress into "she dumps twelve things on me the moment I
+// walk in" — a digest that nags in bulk is worse than the drops it replaced.
+// Anything beyond the cap is still marked drained (it did get its moment;
+// the cap limits WORDS, not whether it counted) and folded into a trailing
+// count instead of being spoken in full.
+const maxDigestSpokenItems = 3
+
+// enqueueSuppressedDigest scans this tick's trace for care candidates the
+// gate blocked for a genuine restraint reason and durably records the
+// digest-eligible ones (loop.DigestEligible). Phrasing happens once, here,
+// at enqueue time — not re-derived at drain time — the same way queueNudge
+// phrases once and caches, so a rule suppressed for hours isn't re-prompting
+// the LLM every tick it stays blocked (EnqueueDigestEntry's rule+body dedupe
+// makes repeat calls here harmless, but skipping the phrase call entirely
+// when a pending entry already exists avoids the LLM round-trip too).
+func (t *tickLoop) enqueueSuppressedDigest(ctx context.Context, trace *loop.TickTrace, state loop.State, now time.Time) {
+	if trace == nil {
+		return
+	}
+	for _, tr := range trace.RuleTraces {
+		if !tr.PredicateResult || tr.GateResult {
+			continue // didn't want to fire, or wasn't suppressed
+		}
+		if !loop.DigestEligible(tr.Severity, tr.GateBlockedBy) {
+			continue
+		}
+		rule := loop.Rule{Name: tr.RuleName, Severity: tr.Severity}
+		cand := loop.Candidate{Rule: rule, Severity: tr.Severity, State: state}
+		pn, err := t.phraser.PhraseNudge(ctx, cand)
+		if err != nil {
+			log.Printf("tick: phrase digest candidate %s: %v", tr.RuleName, err)
+			continue
+		}
+		expires := now.Add(digestExpiry)
+		if _, deduped, err := t.store.EnqueueDigestEntry(ctx, tr.RuleName, int(tr.Severity), pn.Body, now, expires); err != nil {
+			log.Printf("tick: enqueue digest entry %s: %v", tr.RuleName, err)
+		} else if deduped {
+			// same suppressed nudge already pending — nothing new to say.
+			continue
+		}
+	}
+}
+
+// expireStaleDigest sweeps entries past their expiry once per tick — cheap
+// bookkeeping, mirrors ReconcileStaleDeliveryAttempts's shape.
+func (t *tickLoop) expireStaleDigest(ctx context.Context, now time.Time) {
+	n, err := t.store.ExpireStaleDigestEntries(ctx, now)
+	if err != nil {
+		log.Printf("tick: expire stale digest entries: %v", err)
+		return
+	}
+	if n > 0 {
+		log.Printf("tick: expired %d stale digest entr(y/ies) unspoken", n)
+	}
+}
+
+// maybeDrainDigest speaks the pending digest bundle once the gate's
+// suppression reasons have actually cleared — quiet hours over, back from
+// away, out of the meeting. Draining while still suppressed would just be a
+// second way to nag through quiet hours; the bundle waits for the same "is
+// it allowed right now" condition a live nudge already waits for.
+func (t *tickLoop) maybeDrainDigest(ctx context.Context, state loop.State, now time.Time) {
+	if state.QuietHours || state.CalendarBusy || state.Presence == store.Away {
+		return
+	}
+	entries, err := t.store.PendingDigestEntries(ctx, now)
+	if err != nil {
+		log.Printf("tick: pending digest entries: %v", err)
+		return
+	}
+	if len(entries) == 0 {
+		return
+	}
+
+	spoken := entries
+	extra := 0
+	if len(spoken) > maxDigestSpokenItems {
+		spoken = entries[:maxDigestSpokenItems]
+		extra = len(entries) - maxDigestSpokenItems
+	}
+	var b strings.Builder
+	maxSev := 0
+	for i, e := range spoken {
+		if i > 0 {
+			b.WriteString(" · ")
+		}
+		b.WriteString(e.Body)
+		if e.Severity > maxSev {
+			maxSev = e.Severity
+		}
+	}
+	if extra > 0 {
+		fmt.Fprintf(&b, " · и ещё %d", extra)
+	}
+	body := b.String()
+	summary := fmt.Sprintf("%d отложенных уведомлений", len(entries))
+
+	cand := loop.Candidate{
+		Rule:     loop.Rule{Name: "digest", Severity: loop.Severity(maxSev)},
+		Severity: loop.Severity(maxSev),
+		State:    state,
+	}
+	pn := delivery.PhrasedNudge{Candidate: cand, Body: body, Summary: summary}
+	t.cachePhrase(pn)
+	if _, err := t.dispatcher.DispatchNudge(ctx, pn, now); err != nil {
+		log.Printf("tick: dispatch digest bundle: %v", err)
+		return // leave entries pending; retried next tick
+	}
+	ids := make([]int64, len(entries))
+	for i, e := range entries {
+		ids[i] = e.ID
+	}
+	if err := t.store.DrainDigestEntries(ctx, ids, now); err != nil {
+		log.Printf("tick: drain digest entries: %v", err)
+	}
+}

cmd/mavend/tick_morning.go

@@ -0,0 +1,197 @@
+// mavend/tick_morning.go — the morning checklist and the day plan.
+//
+// Split out of tick.go, move-only (Vikunja #422). One window per configured
+// routine, nudging once at the end for what is still open, plus the read
+// surfaces /morning renders.
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strings"
+	"time"
+
+	"github.com/kami/maven/internal/calendar"
+	"github.com/kami/maven/internal/delivery"
+	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/loop"
+	"github.com/kami/maven/internal/morning"
+	"github.com/kami/maven/internal/store"
+)
+
+// fireMorningRoutines checks each configured checklist against today's facts
+// and dispatches a nag listing exactly what's still missing, at most once per
+// routine per calendar day. Fact reads happen here (not in loop.Gatherer)
+// because the item↔fact-key mapping is morning-routine-specific, not a rule
+// concern — pulling it into the shared gather path would leak that mapping
+// into loop's "rules declare wanted keys" contract. Bodies are literal
+// operator text (item labels joined), not LLM-phrased, same rationale as
+// cron routines: deterministic, can't hallucinate a checklist item.
+func (t *tickLoop) fireMorningRoutines(ctx context.Context, now time.Time, state loop.State) {
+	if len(t.morningRoutines) == 0 {
+		return
+	}
+	facts := t.gatherMorningFacts(ctx)
+
+	for _, cand := range morning.Due(t.morningRoutines, facts, t.morningLast, now) {
+		body := morningNudgeBody(cand)
+		pn := delivery.PhrasedNudge{
+			Candidate: loop.Candidate{
+				Rule:     loop.Rule{Name: "morning:" + cand.Routine.Name, Severity: loop.Severity(cand.Routine.Severity)},
+				Severity: loop.Severity(cand.Routine.Severity),
+				State:    state,
+			},
+			Body:    body,
+			Summary: body,
+		}
+		if _, err := t.dispatcher.DispatchNudge(ctx, pn, now); err != nil {
+			log.Printf("tick: dispatch morning routine %s: %v", cand.Routine.Name, err)
+		}
+	}
+}
+
+// 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
+// disagree about what evidence exists.
+func (t *tickLoop) gatherMorningFacts(ctx context.Context) map[string]store.Fact {
+	keys := make(map[string]struct{})
+	for _, r := range t.morningRoutines {
+		for _, it := range r.Items {
+			keys[it.FactKey] = struct{}{}
+		}
+	}
+	facts := make(map[string]store.Fact, len(keys))
+	for k := range keys {
+		f, err := t.store.LatestFact(ctx, k)
+		if err == nil {
+			facts[k] = f
+			continue
+		}
+		if err != store.ErrNoFact {
+			log.Printf("tick: morning: latest fact %s: %v", k, err)
+		}
+	}
+	return facts
+}
+
+// morningStatus is the read-only "what's missing" query the web UI (and
+// eventually a voice query) calls. Pure recompute over the current facts —
+// no dedupe/nudge-time gating, unlike fireMorningRoutines: this answers
+// "state right now," not "should we nag."
+func (t *tickLoop) morningStatus(ctx context.Context, now time.Time) []ipc.MorningRoutineStatus {
+	if len(t.morningRoutines) == 0 {
+		return nil
+	}
+	facts := t.gatherMorningFacts(ctx)
+	out := make([]ipc.MorningRoutineStatus, 0, len(t.morningRoutines))
+	for _, r := range t.morningRoutines {
+		st := morning.Evaluate(r, facts, now)
+		done := make(map[string]bool, len(st.Completed))
+		for _, it := range st.Completed {
+			done[it.Key] = true
+		}
+		items := make([]ipc.MorningRoutineItem, len(r.Items))
+		for i, it := range r.Items {
+			items[i] = ipc.MorningRoutineItem{Key: it.Key, Label: it.Label, Done: done[it.Key]}
+		}
+		out = append(out, ipc.MorningRoutineStatus{
+			Name:        r.Name,
+			Active:      st.Active,
+			WindowStart: r.WindowStart,
+			WindowEnd:   r.WindowEnd,
+			Items:       items,
+		})
+	}
+	return out
+}
+
+// dayPlan is the read-only "what does today hold" query (Vikunja #128). It is
+// the impure half of morning.BuildPlan: it reads the calendar events, the
+// pending reminders and the checklist facts, and the pure builder orders them.
+//
+// It never dispatches. Asking for the plan is a query like any other; the only
+// unprompted delivery in maven stays with the morning nudge and the
+// dispatcher's policy.
+func (t *tickLoop) dayPlan(ctx context.Context, now time.Time) ipc.DayPlan {
+	y, m, d := now.Date()
+	dayStart := time.Date(y, m, d, 0, 0, 0, 0, now.Location())
+	dayEnd := dayStart.AddDate(0, 0, 1)
+
+	var events []morning.PlanEntry
+	facts, err := t.store.CalendarEvents(ctx, dayStart, dayEnd)
+	if err != nil {
+		log.Printf("tick: day plan: calendar events: %v", err)
+	}
+	for _, f := range facts {
+		events = append(events, morning.PlanEntry{
+			At: f.Ts,
+			// The plan prints the hour itself, so the "@ 14:00-14:30" tail the
+			// fact value carries would say it twice.
+			Text: calendar.FactSummary(f.Value),
+			Kind: morning.PlanEvent,
+			// Provenance below a calendar read (an ambient relay, #126) is
+			// hedged rather than recited as fact.
+			Uncertain: f.Confidence < 1.0,
+		})
+	}
+
+	var reminders []morning.PlanEntry
+	rems, err := t.store.PendingReminders(ctx, dayStart, dayEnd)
+	if err != nil {
+		log.Printf("tick: day plan: pending reminders: %v", err)
+	}
+	for _, r := range rems {
+		if r.Status != store.ReminderPending {
+			continue
+		}
+		fire := r.NextFireTs
+		if fire.IsZero() {
+			fire = r.FireTs
+		}
+		reminders = append(reminders, morning.PlanEntry{
+			At:   fire,
+			Text: r.Text(),
+			Kind: morning.PlanReminder,
+		})
+	}
+
+	var checklistFacts map[string]store.Fact
+	if len(t.morningRoutines) > 0 {
+		checklistFacts = t.gatherMorningFacts(ctx)
+	}
+	plan := morning.BuildPlan(t.morningRoutines, checklistFacts, events, reminders, now)
+
+	out := ipc.DayPlan{Date: plan.Date, Spoken: plan.FormatRU()}
+	out.Items = make([]ipc.DayPlanItem, len(plan.Items))
+	for i, it := range plan.Items {
+		out.Items[i] = ipc.DayPlanItem{
+			At:        it.At,
+			Text:      it.Text,
+			Kind:      string(it.Kind),
+			Uncertain: it.Uncertain,
+		}
+	}
+	return out
+}

cmd/mavend/tick_routines.go

@@ -0,0 +1,234 @@
+// mavend/tick_routines.go — pattern detection and the routines that fire.
+//
+// Split out of tick.go, move-only (Vikunja #422). Configured routines, the
+// routines he accepted on /routines, and the tick-side detector that proposes
+// new ones.
+package main
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"github.com/kami/maven/internal/config"
+	"github.com/kami/maven/internal/delivery"
+	"github.com/kami/maven/internal/loop"
+	"github.com/kami/maven/internal/pattern"
+	"github.com/kami/maven/internal/routine"
+)
+
+// detectPatterns runs the pattern detector proactively over every
+// action+object pair that has ever produced an event, independent of
+// whichever fact write (or channel) last touched it (Vikunja #43). This is
+// what makes pattern inference actually proactive: it fires on the daemon's
+// own schedule reading accumulated history, not only as a side effect of a
+// live voice turn.
+//
+// Idempotence and noise are handled by the store, not here — this function
+// is safe to call every tick:
+//   - Same pattern, tick after tick: detectAndPropose's LookupProposedRoutine
+//     check plus proposed_routines' UNIQUE(action, object) constraint (with
+//     CreateProposedRoutine's ON CONFLICT DO NOTHING) mean a pair that
+//     already has a row — in ANY status — produces no second row and no log
+//     spam beyond the one line at genuine creation.
+//   - A DISMISSED proposal must never come back. DismissProposedRoutine flips
+//     status in place; the row is never deleted. So the same Lookup check
+//     that stops a duplicate "proposed" also stops a "dismissed" one from
+//     resurrecting — there is nothing tick-specific to get right here beyond
+//     calling the same shared path the voice route already used.
+//
+// By default this only creates a row for the /routines page to show: it does
+// not notify, ring, or speak. Detection is not the same act as disturbing him
+// about it, and Maven is "not a nag, not autonomous" (CLAUDE.md). Announcing
+// is opt-in through the pattern_proposals config block — see announceProposal
+// for the restraints that apply even then. A proposal only starts producing
+// recurring nudges once he accepts it (fireAcceptedRoutines).
+func (t *tickLoop) detectPatterns(ctx context.Context, now time.Time, state loop.State) {
+	pairs, err := t.store.DistinctEventPairs(ctx)
+	if err != nil {
+		log.Printf("tick: distinct event pairs: %v", err)
+		return
+	}
+	announced := false
+	for _, p := range pairs {
+		r, _, err := detectAndPropose(ctx, t.store, p.Action, p.Object, now)
+		if err != nil {
+			log.Printf("tick: detect pattern %s/%s: %v", p.Action, p.Object, err)
+			continue
+		}
+		if r == nil {
+			continue // no stable pattern, or already proposed/accepted/dismissed
+		}
+		log.Printf("tick: proposed routine: %s/%s every %.1f days", r.Action, r.Object, r.IntervalDays)
+		// One announcement per tick at most, whatever the scan turned up. The
+		// rest are on /routines; they are not lost, they are just not shouted.
+		// Nor are they queued: the row now exists, so no later tick re-detects
+		// them and they are never announced. See announceProposal.
+		if announced {
+			continue
+		}
+		announced = t.announceProposal(ctx, r, now, state)
+	}
+}
+
+// announceProposal offers a freshly inferred routine through the ordinary
+// care-delivery path, if announcing is switched on at all. Returns true when
+// something was actually sent.
+//
+// Everything here is restraint. The feature is off unless configured; when on
+// it is sev1 (the lowest severity, so quiet hours, away presence and snooze
+// all suppress it via loop.Gate exactly like a care nudge); it is spaced by
+// proposalCfg.Cooldown across every pair, not per pair; and a suppressed or
+// dropped announcement is NOT retried — the cooldown clock advances only on a
+// real send, but the proposal row already exists, so the next tick will not
+// re-detect it and nothing queues up behind it. A missed announcement means
+// he reads it on /routines instead, which is the whole point of the page.
+//
+// What the cooldown is and is not. detectAndPropose returns non-nil only for a
+// newly created row, so a pair gets exactly one chance to be spoken: the tick
+// that first proposes it. Combined with one announcement per tick, the first
+// tick over a populated history announces one pattern and permanently silences
+// every other pattern found in the same pass. That is the intent, not an
+// oversight — an inferred routine is not worth a second attempt at his
+// attention, and /routines lists all of them. So the cooldown does not drain a
+// backlog. It only spaces announcements of genuinely new pairs discovered on
+// later ticks. If it should ever become "one per day until each is mentioned",
+// that needs a queue rather than this counter.
+//
+// Cooldown gets its default here as well as in applyDefaults. That is
+// deliberate: a tickLoop assembled directly in a test never goes through Load,
+// and an unspaced announcer is not what those tests mean to exercise.
+//
+// The body is the detector's own literal Russian phrasing (pattern.PhraseRoutine
+// — "ты заправляешь поилку раз в 7 дней — напоминать?"), not LLM-generated, so
+// an inferred routine cannot arrive worded as something Maven never observed.
+func (t *tickLoop) announceProposal(ctx context.Context, r *pattern.ProposedRoutine, now time.Time, state loop.State) bool {
+	if !t.proposalCfg.AnnounceProposals() {
+		return false
+	}
+	cooldown := time.Duration(t.proposalCfg.Cooldown)
+	if cooldown <= 0 {
+		cooldown = config.DefaultProposalCooldown
+	}
+	if !t.lastProposalAt.IsZero() && now.Sub(t.lastProposalAt) < cooldown {
+		return false
+	}
+
+	rule := loop.Rule{Name: "proposal:" + r.Action + " " + r.Object, Severity: loop.Sev1}
+	if !loop.Gate(state, rule) {
+		return false
+	}
+	body := pattern.PhraseRoutine(r)
+	pn := delivery.PhrasedNudge{
+		Candidate: loop.Candidate{Rule: rule, Severity: rule.Severity, State: state},
+		Body:      body,
+		Summary:   body,
+	}
+	sent, err := t.dispatcher.DispatchNudge(ctx, pn, now)
+	if err != nil {
+		log.Printf("tick: announce proposal %s/%s: %v", r.Action, r.Object, err)
+		return false
+	}
+	if len(sent) == 0 {
+		return false // routing dropped it — /routines still has it.
+	}
+	t.lastProposalAt = now
+	return true
+}
+
+// routinesFromConfig maps the config's routine blocks to the engine type.
+// Validation (cron parses, name/body present, severity defaulted) already ran
+// in config.Load, so this is a pure field copy.
+func routinesFromConfig(rc []config.RoutineConfig) []routine.Routine {
+	if len(rc) == 0 {
+		return nil
+	}
+	out := make([]routine.Routine, len(rc))
+	for i, r := range rc {
+		out[i] = routine.Routine{Name: r.Name, Cron: r.Cron, Body: r.Body, Severity: r.Severity}
+	}
+	return out
+}
+
+// fireRoutines dispatches the routines whose cron schedule crossed since their
+// last fire. Each is delivered as a nudge through the normal routing table
+// (ChannelsFor(severity, presence)) with a "routine:"-prefixed rule name so it
+// can't collide with a care rule in the feedback autotuner. A dispatch failure
+// logs and continues — one bad send must not skip the rest, and routine.Due has
+// already advanced the last-fire time so a transient failure drops that fire
+// rather than replaying it every tick (a routine is clockwork, not an alarm —
+// no repeat-til-ack).
+func (t *tickLoop) fireRoutines(ctx context.Context, now time.Time, state loop.State) {
+	for _, r := range routine.Due(t.routines, t.routineLast, now) {
+		pn := delivery.PhrasedNudge{
+			Candidate: loop.Candidate{
+				Rule:     loop.Rule{Name: "routine:" + r.Name, Severity: loop.Severity(r.Severity)},
+				Severity: loop.Severity(r.Severity),
+				State:    state,
+			},
+			Body:    r.Body,
+			Summary: r.Body,
+		}
+		if _, err := t.dispatcher.DispatchNudge(ctx, pn, now); err != nil {
+			log.Printf("tick: dispatch routine %s: %v", r.Name, err)
+		}
+	}
+}
+
+// fireAcceptedRoutines nudges about the routines the user accepted, once per
+// interval (Vikunja #366). Accepting used to create a single reminder, so a
+// non-weekly routine fired once and went quiet forever; the schedule lives in
+// the proposed_routines row now and the loop re-reads it every tick.
+//
+// A routine is a care-class nudge and goes through the restraint gate like any
+// other: quiet hours, away presence and snooze all suppress it. Reminders bypass
+// that gate; routines must not. A suppressed nudge is NOT marked fired, so it
+// goes out on the next tick that the gate allows — one nudge, held, not dropped
+// and not repeated.
+//
+// The body is literal text built from the detected action and object, not
+// LLM-phrased, so a routine can't hallucinate. It nudges; it never acts.
+func (t *tickLoop) fireAcceptedRoutines(ctx context.Context, now time.Time, state loop.State) {
+	rows, err := t.store.ListAcceptedRoutines(ctx)
+	if err != nil {
+		log.Printf("tick: list accepted routines: %v", err)
+		return
+	}
+	accepted := make([]routine.Accepted, 0, len(rows))
+	for _, r := range rows {
+		if r.AcceptedTs == nil {
+			continue // accepted before the schedule column existed — no clock to start from.
+		}
+		accepted = append(accepted, routine.Accepted{
+			ID:           r.ID,
+			Name:         r.Action + " " + r.Object,
+			IntervalDays: r.IntervalDays,
+			Accepted:     *r.AcceptedTs,
+			LastFired:    r.LastFiredTs,
+		})
+	}
+
+	for _, a := range routine.DueAccepted(accepted, now) {
+		rule := loop.Rule{Name: "routine:" + a.Name, Severity: loop.Sev1}
+		if !loop.Gate(state, rule) {
+			continue
+		}
+		body := "пора: " + a.Name
+		pn := delivery.PhrasedNudge{
+			Candidate: loop.Candidate{Rule: rule, Severity: rule.Severity, State: state},
+			Body:      body,
+			Summary:   body,
+		}
+		sent, err := t.dispatcher.DispatchNudge(ctx, pn, now)
+		if err != nil {
+			log.Printf("tick: dispatch accepted routine %d: %v", a.ID, err)
+			continue
+		}
+		if len(sent) == 0 {
+			continue // routing dropped it — leave it due.
+		}
+		if err := t.store.MarkRoutineFired(ctx, a.ID, now); err != nil {
+			log.Printf("tick: mark routine %d fired: %v", a.ID, err)
+		}
+	}
+}

cmd/mavend/tick_test.go

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

cmd/mavend/voice.go

@@ -55,7 +55,6 @@ import (
 	"github.com/kami/maven/internal/crawl"
 	"github.com/kami/maven/internal/dialogue"
 	"github.com/kami/maven/internal/ipc"
-	"github.com/kami/maven/internal/memory"
 	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/store"
@@ -72,10 +71,16 @@ import (
 // safe (the wired stt/tts/router/api all are); called from per-conn
 // goroutines on the voice.Server.
 type reactiveHandler struct {
-	stt      stt.Transcriber
-	tts      tts.Synthesizer
-	router   *router.Router
-	embedder router.Embedder // reused for note write/query (same model as the classifier)
+	stt    stt.Transcriber
+	tts    tts.Synthesizer
+	router *router.Router
+
+	// recall — the note-and-fact recall subsystem: the embedder, the vector
+	// store it writes into, the personal boundary, and the two numbers that
+	// gate an answer. Grouped rather than spread across the handler because a
+	// handler that recalls needs all five and a handler that does not needs
+	// none of them (Vikunja #433, docs/handler-wiring.md).
+	recall recallWiring
 	// 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.
@@ -119,18 +124,8 @@ type reactiveHandler struct {
 	weatherProvider weather.Provider
 	weatherLocation string // default location for weather queries
 
-	memStore  memory.Store
 	dataStore *store.Store // direct store access for event extraction + pattern detection
 
-	// queryMinScore — the note-recall confidence gate. Top cosine below this ⇒
-	// "I don't know" instead of a guess. Tuned for the ONNX embedder; a knob, not
-	// load-bearing math (same posture as the presence thresholds). Set by
-	// wireVoice from VoiceConfig; default 0.55.
-	queryMinScore float64
-	// queryMinMargin — the second half of that gate: how far the top hit must
-	// beat the runner-up. 0 ⇒ margin off.
-	queryMinMargin float64
-
 	// timeParser — used as a fallback for stage-0 reminder grammar matches
 	// (where the extractor didn't run). Shared with the router's extractor.
 	// The production dateparser will replace StubDateTimeParser here too.
@@ -216,9 +211,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 +246,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 +342,10 @@ 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 reply := h.hexisBeforeClarify(ctx, dec); reply != "" {
+			return withNotice(expiredNotice, reply)
+		}
+		if question, asked := h.askClarify(ctx, dec); asked {
 			return withNotice(expiredNotice, question)
 		}
 	}

cmd/mavend/voicewire.go

@@ -238,7 +238,10 @@ func wireVoice(cfg *config.Config, coreAPI ipc.CoreAPI, phr phraser.Phraser, mem
 	// ----- dialogue (multi-turn slot carry-over; 2-min follow-up window) -----
 	// Store-backed when the daemon passes a store, so a restart mid-conversation
 	// keeps the thread (Vikunja #363). Sessions past their TTL are dropped on
-	// load, never revived. Clarify's parked question stays in memory only.
+	// load, never revived. Clarify's parked question stays in memory only, and
+	// that is a decision rather than an omission (Vikunja #385, docs/design.md):
+	// a restart expires it, so the thread comes back and the open question does
+	// not.
 	var dialogueSessions *dialogue.SessionStore
 	if dataStore != nil {
 		dialogueSessions = dialogue.NewPersistentSessionStore(2*time.Minute, dataStore)
@@ -259,19 +262,18 @@ func wireVoice(cfg *config.Config, coreAPI ipc.CoreAPI, phr phraser.Phraser, mem
 
 	// ----- the handler (the reactive path; closes over stt / tts / router / coreAPI / memory) -----
 	h := &reactiveHandler{
-		stt:      transcriber,
-		tts:      synthesizer,
-		router:   rtr,
-		embedder: emb,
-		api:      coreAPI,
-		tools:    exec,
-		matcher:  matcher,
-		replier:  replier,
-		phraser:  phr,
-		now:      time.Now,
-		feedsOn:  cfg.Feeds != nil,
-		home:     w.home,
-		netscan:  w.netscan,
+		stt:     transcriber,
+		tts:     synthesizer,
+		router:  rtr,
+		api:     coreAPI,
+		tools:   exec,
+		matcher: matcher,
+		replier: replier,
+		phraser: phr,
+		now:     time.Now,
+		feedsOn: cfg.Feeds != nil,
+		home:    w.home,
+		netscan: w.netscan,
 		// nil unless `crawl.on_demand` is on: reading a page he names is a
 		// capability, and capabilities are off unless configured.
 		crawler: onDemandCrawler(cfg),
@@ -280,18 +282,21 @@ func wireVoice(cfg *config.Config, coreAPI ipc.CoreAPI, phr phraser.Phraser, mem
 		search: wireSearch(cfg),
 		// nil unless a `kiwix` block names a server. Same swap-aware client the
 		// router and replier use, so the rewriter follows a model swap.
-		kiwix:            wireKiwix(cfg, llmClient),
-		weatherProvider:  weatherProvider,
-		weatherLocation:  weatherLocation,
-		memStore:         memStore,
+		kiwix:           wireKiwix(cfg, llmClient),
+		weatherProvider: weatherProvider,
+		weatherLocation: weatherLocation,
+		recall: recallWiring{
+			embedder:  emb,
+			memStore:  memStore,
+			minScore:  cfg.Voice.QueryMinScore,
+			minMargin: cfg.Voice.QueryMinMargin,
+		},
 		dataStore:        dataStore,
 		dialogueSessions: dialogueSessions,
 		clarifyStore:     clarifyStore,
 		// 0 here (unset config) ⇒ the dialogue default.
 		clarifyMaxAttempts: cfg.Voice.ClarifyMaxAttempts,
 		extractor:          router.Extractor{Time: timeParser, Acts: matcher, Facts: router.DefaultFactParser{}},
-		queryMinScore:      cfg.Voice.QueryMinScore,
-		queryMinMargin:     cfg.Voice.QueryMinMargin,
 		timeParser:         timeParser,
 		ecosystem:          eco,
 	}
@@ -380,6 +385,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 +403,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 +455,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/mavpoll/main.go

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

cmd/mavpoll/main_test.go

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

cmd/mavweb/ambient_test.go

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

cmd/mavweb/chat.html

@@ -0,0 +1,24 @@
+{{template "shellTop" "chat"}}
+<h1>Chat</h1>
+<section class=card>
+{{if .Error}}<div class="msg msg-err">{{.Error}}</div>{{end}}
+<div class="scroll chat-scroll" id=chatHistory>
+{{range .Messages}}
+  <div class="chat-msg {{.Role}}"><strong>{{if eq .Role "user"}}you{{else}}maven{{end}}:</strong> {{.Text}}</div>
+{{else}}
+  <div class=empty>
+    <svg class=icon width="20" height="20"><use href="/ethos-icons.svg#i-message"/></svg>
+    <div>start a conversation</div>
+  </div>
+{{end}}
+</div>
+<form method=post action=/api/chat class=chat-form>
+  <input type=text name=text class=input-wide placeholder="type a message..." required autofocus>
+  <button class=btn>send</button>
+</form>
+</section>
+<script>
+var ch = document.getElementById('chatHistory');
+if(ch) ch.scrollTop = ch.scrollHeight;
+</script>
+{{template "shellBottom"}}

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

@@ -75,6 +75,23 @@ var morningHTML string
 //go:embed events.html
 var eventsHTML string
 
+//go:embed tools.html
+var toolsHTML string
+
+//go:embed routines.html
+var routinesHTML string
+
+//go:embed chat.html
+var chatPageHTML string
+
+// shellHTML — the shell partial every page is wrapped in: "shellTop", the
+// "sidebar" it calls, and "shellBottom". It used to be two Go string constants
+// with the sidebar assembled by a strings.Builder, which is the one piece of
+// markup that was still concatenated in Go.
+//
+//go:embed shell.html
+var shellHTML string
+
 // ── Ethos Workstation Shell ──
 //
 // Two template pieces that wrap every page:
@@ -135,74 +152,40 @@ var sidebarSections = []struct {
 	},
 }
 
-func sidebarActive(url, key string, activeKey string) string {
-	if key == activeKey {
-		return `class="active"`
-	}
-	return ""
-}
-
-// sidebarHTML renders the sidebar navigation given the active page key.
-func sidebarHTML(active string) template.HTML {
-	var b strings.Builder
-	for _, sec := range sidebarSections {
-		b.WriteString(`<div class=sidebar-section>`)
-		b.WriteString(`<div class=sidebar-label>`)
-		b.WriteString(sec.Label)
-		b.WriteString(`</div>`)
-		for _, p := range sec.Pages {
-			cls := ""
-			if p.Key == active {
-				cls = ` class="active"`
-			}
-			b.WriteString(`<a href="`)
-			b.WriteString(p.URL)
-			b.WriteString(`"`)
-			b.WriteString(cls)
-			b.WriteString(`><span class=icon>`)
-			b.WriteString(pageIcon(p.Key))
-			b.WriteString(`</span><span>`)
-			b.WriteString(p.Label)
-			b.WriteString(`</span></a>`)
-		}
-		b.WriteString(`</div>`)
-	}
-	return template.HTML(b.String())
-}
-
-// pageIcon returns an ethos-icons.svg <use> reference for the given page.
+// pageIcon returns the ethos-icons.svg symbol id for the given page. The
+// sidebar template wraps it in the <use> reference.
 func pageIcon(key string) string {
 	switch key {
 	case "dash":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-grid"/></svg>`
+		return "i-grid"
 	case "history":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-clock"/></svg>`
+		return "i-clock"
 	case "trace":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-wave"/></svg>`
+		return "i-wave"
 	case "notifications":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-bell"/></svg>`
+		return "i-bell"
 	case "tasks":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-grid"/></svg>`
+		return "i-grid"
 	case "reminders":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-calendar"/></svg>`
+		return "i-calendar"
 	case "routines":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-repeat"/></svg>`
+		return "i-repeat"
 	case "morning":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-calendar"/></svg>`
+		return "i-calendar"
 	case "chat":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-message"/></svg>`
+		return "i-message"
 	case "voice":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-mic"/></svg>`
+		return "i-mic"
 	case "ecosystem":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-grid"/></svg>`
+		return "i-grid"
 	case "tools":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-settings"/></svg>`
+		return "i-settings"
 	case "models":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-wave"/></svg>`
+		return "i-wave"
 	case "passkey":
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-lock"/></svg>`
+		return "i-lock"
 	default:
-		return `<svg class=icon width="14" height="14"><use href="/ethos-icons.svg#i-search"/></svg>`
+		return "i-search"
 	}
 }
 
@@ -242,63 +225,12 @@ func pageTitle(key string) string {
 	}
 }
 
-// shellTopHTML opens the shell and renders the top bar + sidebar.
-// Usage: {{template "shellTop" "<page-key>"}}
-const shellTopHTML = `{{define "shellTop"}}<!doctype html><meta charset=utf-8>
-<meta name=viewport content="width=device-width,initial-scale=1,viewport-fit=cover">
-<meta name=theme-color content="#14110D">
-<link rel=manifest href=/manifest.json>
-<title>maven · {{pageTitle .}}</title>
-<link rel=stylesheet href=/ui.css>
-<div class=shell data-app=maven>
-  <header class=topbar>
-    <div class=breadcrumbs>
-      <span class=current>{{pageTitle .}}</span>
-    </div>
-    <div class=topbar-actions>
-      <div class=search-trigger onclick="window.__openSearch()" role=button tabindex=0>
-        <svg class=icon width="13" height="13"><use href="/ethos-icons.svg#i-search"/></svg>
-        Search
-        <span class=kbd-hint>Ctrl+/</span>
-      </div>
-      <button class=icon-btn onclick="window.__openPalette()" title="Command Palette (Ctrl+K)" aria-label="Command Palette">
-        <svg class=icon width="15" height="15"><use href="/ethos-icons.svg#i-grid"/></svg>
-      </button>
-      <span class=conn-status>
-        <span class="dot online" id=connDot></span>
-      </span>
-    </div>
-  </header>
-  <div class=shell-body>
-    <aside class=sidebar>
-      {{sidebarHTML .}}
-    </aside>
-    <main class=content>
-{{end}}`
-
-// shellBottomHTML closes the content area, inspector, and shell.
-// Usage: {{template "shellBottom"}}
-const shellBottomHTML = `{{define "shellBottom"}}
-    </main>
-    <aside class=inspector id=inspector>
-      <div class=inspector-inner>
-        <div class=inspector-header>
-          <span id=inspectorTitle>Details</span>
-          <button class=inspector-close onclick="closeInspector()" aria-label="Close inspector">&times;</button>
-        </div>
-        <div class=inspector-body id=inspectorBody></div>
-      </div>
-    </aside>
-  </div>
-</div>
-<script src=/mavweb.js></script>
-{{end}}`
-
 // shellFuncs returns the FuncMap shared by every server-rendered page template.
 func shellFuncs() template.FuncMap {
 	return template.FuncMap{
-		"pageTitle":   pageTitle,
-		"sidebarHTML": sidebarHTML,
+		"pageTitle":       pageTitle,
+		"pageIcon":        pageIcon,
+		"sidebarSections": func() any { return sidebarSections },
 		"ago": func(t time.Time) string {
 			if t.IsZero() {
 				return "never"
@@ -313,21 +245,21 @@ func shellFuncs() template.FuncMap {
 // a small fetch loop refreshes the tables in place. html/template escapes the
 // user text in facts/nudges. Read-only: browses the append-only store via
 // CoreAPI, never writes — the store IS the audit trail, this just shows it.
-var dashTmpl = template.Must(template.New("dash").Funcs(shellFuncs()).Parse(shellTopHTML + dashHTML + shellBottomHTML))
+var dashTmpl = template.Must(template.New("dash").Funcs(shellFuncs()).Parse(shellHTML + dashHTML))
 
 // ecosystemTmpl — read-only view of the Nexus/Praxis/Hexis siblings, whose only
 // human surface is here (they ship no web UI of their own).
-var ecosystemTmpl = template.Must(template.New("ecosystem").Funcs(shellFuncs()).Parse(shellTopHTML + ecosystemHTML + shellBottomHTML))
+var ecosystemTmpl = template.Must(template.New("ecosystem").Funcs(shellFuncs()).Parse(shellHTML + ecosystemHTML))
 
 // eventsTmpl — the unified intake journal (Vikunja #283), read-only. Same
 // shape as trace.html and morning.html: server-rendered, refreshed on reload.
-var eventsTmpl = template.Must(template.New("events").Funcs(shellFuncs()).Parse(shellTopHTML + eventsHTML + shellBottomHTML))
+var eventsTmpl = template.Must(template.New("events").Funcs(shellFuncs()).Parse(shellHTML + eventsHTML))
 
 // morningTmpl — read-only view of today's checklist state per configured
 // morning routine (internal/morning). Same shape as trace.html: a plain
 // server-rendered page, refreshed on reload — no live-update loop, since
 // checklist state changes on the scale of minutes, not seconds.
-var morningTmpl = template.Must(template.New("morning").Funcs(shellFuncs()).Parse(shellTopHTML + morningHTML + shellBottomHTML))
+var morningTmpl = template.Must(template.New("morning").Funcs(shellFuncs()).Parse(shellHTML + morningHTML))
 
 func noCache(h http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -747,107 +679,23 @@ var toolsTmpl = template.Must(template.New("tools").Funcs(func() template.FuncMa
 	m := shellFuncs()
 	m["join"] = strings.Join
 	return m
-}()).Parse(shellTopHTML + toolsHTML + shellBottomHTML))
+}()).Parse(shellHTML + toolsHTML))
 
-const toolsHTML = `{{template "shellTop" "tools"}}
-<h1>Tools</h1>
-<p class=hint>enabling requires step-up — <a href=/auth/passkey>assert a passkey</a> first.</p>
-{{if .Msg}}<div class="msg msg-ok">{{.Msg}}</div>{{end}}
-<section class=card>
-<h2 class=card-title>proposed <span class=badge>{{len .Proposed}}</span></h2>
-{{if .Proposed}}<p class=hint>maven drafted these from acts she couldn't run. Fill the command (argv, space-separated) and enable. A row in an <code>mcp:</code> scope came from an MCP server and already knows what it calls — check the command, then enable.</p>
-<div class=scroll><table><tr><th>name</th><th>scope</th><th>from utterance</th><th>enable as</th></tr>
-{{range .Proposed}}<tr>
-<td><code>{{.Name}}</code></td><td><span class=badge>{{.Scope}}</span></td><td>{{.Utterance}}</td>
-<td><form method=post action=/tools>
-<input type=hidden name=name value="{{.Name}}">
-<input type=hidden name=scope value="{{.Scope}}">
-<input type=hidden name=action value=enable>
-<input type=text name=cmd class=input-wide placeholder="systemctl restart" value="{{join .Cmd " "}}" required>
-<label><input type=checkbox name=destructive {{if .Destructive}}checked{{end}}> destructive</label>
-<button class=btn>enable</button></form>
-<form method=post action=/tools class=inline-form>
-<input type=hidden name=name value="{{.Name}}">
-<input type=hidden name=action value=dismiss>
-<button class="btn btn-muted">dismiss</button></form></td>
-</tr>{{end}}</table></div>
-{{else}}<div class=empty>
-  <svg class=icon width="20" height="20"><use href="/ethos-icons.svg#i-search"/></svg>
-  <div>no proposed tools</div>
-  <div class=hint>maven will propose tools here when she needs help running an action</div>
-</div>{{end}}
-</section>
-<section class=card>
-<h2 class=card-title>enabled <span class=badge>{{len .Enabled}}</span></h2>
-{{if .Enabled}}<div class=scroll><table><tr><th>name</th><th>scope</th><th>command</th><th></th><th></th></tr>
-{{range .Enabled}}<tr><td><code>{{.Name}}</code></td><td><span class=badge>{{.Scope}}</span></td><td><code>{{join .Cmd " "}}</code></td>
-<td>{{if .Destructive}}<span class=red>destructive</span>{{end}}</td>
-<td><form method=post action=/tools class=inline-form>
-<input type=hidden name=name value="{{.Name}}">
-<input type=hidden name=scope value="{{.Scope}}">
-<input type=hidden name=action value=disable>
-<button class=btn>disable</button></form></td></tr>{{end}}</table></div>
-{{else}}<div class=empty>
-  <svg class=icon width="20" height="20"><use href="/ethos-icons.svg#i-settings"/></svg>
-  <div>no tools enabled</div>
-  <div class=hint>enable proposed tools above, or ask maven to configure one</div>
-</div>{{end}}
-</section>
-<section class=card>
-<h2 class=card-title>MCP servers <span class=badge>{{len .MCP}}</span></h2>
-{{if .MCP}}<p class=hint>servers she connects OUT to. Their tools appear above as proposals — a configured server is a place she may look, not a capability she has. A <code>stdio</code> target is a process on this box; an <code>http</code> one on a loopback or LAN address is inside the network, so treat its tools accordingly.</p>
-<div class=scroll><table><tr><th>name</th><th>transport</th><th>target</th><th>state</th><th>tools</th></tr>
-{{range .MCP}}<tr><td><code>{{.Name}}</code></td><td><span class=badge>{{.Transport}}</span></td><td><code>{{.Target}}</code></td>
-<td>{{if .Connected}}connected{{if .Server}} — {{.Server}}{{end}}{{else}}<span class=red>down</span>{{if .Err}} — {{.Err}}{{end}}{{end}}</td>
-<td>{{.Tools}}</td></tr>{{end}}</table></div>
-{{else}}<div class=empty>
-  <svg class=icon width="20" height="20"><use href="/ethos-icons.svg#i-settings"/></svg>
-  <div>no MCP servers configured</div>
-  <div class=hint>add an <code>mcp.servers</code> block to mavend.json to let her use an external tool server</div>
-</div>{{end}}
-</section>
-{{template "shellBottom"}}`
+var historyTmpl = template.Must(template.New("history").Funcs(shellFuncs()).Parse(shellHTML + historyHTML))
 
-// routinesHTML — proposed routine review surface. One row per thing maven
+var notificationsTmpl = template.Must(template.New("notifications").Funcs(shellFuncs()).Parse(shellHTML + notificationsHTML))
+
+var remindersTmpl = template.Must(template.New("reminders").Funcs(shellFuncs()).Parse(shellHTML + remindersHTML))
+
+var passkeyTmpl = template.Must(template.New("passkey").Funcs(shellFuncs()).Parse(shellHTML + passkeyPageHTML))
+
+var voiceTmpl = template.Must(template.New("voice").Funcs(shellFuncs()).Parse(shellHTML + voiceHTML))
+
+var tasksTmpl = template.Must(template.New("tasks").Funcs(shellFuncs()).Parse(shellHTML + tasksHTML))
+
+// routinesTmpl — the proposed-routine review surface. One row per thing maven
 // noticed, in her words, with at most two actions: accept or dismiss.
-const routinesHTML = `{{template "shellTop" "routines"}}
-<h1>Routines</h1>
-{{if .Msg}}<div class="msg msg-ok">{{.Msg}}</div>{{end}}
-<section class=card>
-<h2 class=card-title>noticed <span class=badge>{{len .Proposed}}</span></h2>
-{{if .Proposed}}<div class=scroll><table><tr><th>maven noticed</th><th>when</th><th></th><th></th></tr>
-{{range .Proposed}}<tr>
-<td>{{.Phrase}}</td><td class=muted>{{.Noticed}}</td>
-<td><form method=post action=/routines class=inline-form>
-<input type=hidden name=id value="{{.ID}}">
-<input type=hidden name=action value=accept>
-<button class=btn>accept</button></form></td>
-<td><form method=post action=/routines class=inline-form>
-<input type=hidden name=id value="{{.ID}}">
-<input type=hidden name=action value=dismiss>
-<button class="btn btn-muted">dismiss</button></form></td>
-</tr>{{end}}</table></div>
-{{else}}<div class=empty>
-  <svg class=icon width="20" height="20"><use href="/ethos-icons.svg#i-wave"/></svg>
-  <div>no proposed routines</div>
-  <div class=hint>maven will propose routines here when she detects a recurring pattern</div>
-</div>{{end}}
-</section>
-{{template "shellBottom"}}`
-
-var historyTmpl = template.Must(template.New("history").Funcs(shellFuncs()).Parse(shellTopHTML + historyHTML + shellBottomHTML))
-
-var notificationsTmpl = template.Must(template.New("notifications").Funcs(shellFuncs()).Parse(shellTopHTML + notificationsHTML + shellBottomHTML))
-
-var remindersTmpl = template.Must(template.New("reminders").Funcs(shellFuncs()).Parse(shellTopHTML + remindersHTML + shellBottomHTML))
-
-var passkeyTmpl = template.Must(template.New("passkey").Funcs(shellFuncs()).Parse(shellTopHTML + passkeyPageHTML + shellBottomHTML))
-
-var voiceTmpl = template.Must(template.New("voice").Funcs(shellFuncs()).Parse(shellTopHTML + voiceHTML + shellBottomHTML))
-
-var tasksTmpl = template.Must(template.New("tasks").Funcs(shellFuncs()).Parse(shellTopHTML + tasksHTML + shellBottomHTML))
-
-var routinesTmpl = template.Must(template.New("routines").Funcs(shellFuncs()).Parse(shellTopHTML + routinesHTML + shellBottomHTML))
+var routinesTmpl = template.Must(template.New("routines").Funcs(shellFuncs()).Parse(shellHTML + routinesHTML))
 
 var traceTmpl = template.Must(template.New("trace").Funcs(func() template.FuncMap {
 	m := shellFuncs()
@@ -859,7 +707,7 @@ var traceTmpl = template.Must(template.New("trace").Funcs(func() template.FuncMa
 	}
 	m["join"] = strings.Join
 	return m
-}()).Parse(shellTopHTML + traceHTML + shellBottomHTML))
+}()).Parse(shellHTML + traceHTML))
 
 func handleHistory(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
 	if core == nil {
@@ -893,12 +741,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)
@@ -1125,9 +1020,10 @@ func fmtTaskDate(t *time.Time) string {
 	return t.Local().Format("02 Jan")
 }
 
-// routineRow is one line on the page: what maven noticed, in her words, and
-// how long ago she noticed it.
-type routineRow struct {
+// routineView is one line on the page: what maven noticed, in her words, and
+// how long ago she noticed it. A view model, not a database row — the template
+// never formats an interval or a timestamp itself.
+type routineView struct {
 	ID      int64
 	Phrase  string
 	Noticed string
@@ -1189,23 +1085,23 @@ func handleRoutines(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI, se
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
 	if err := routinesTmpl.Execute(w, struct {
 		Msg      string
-		Proposed []routineRow
-	}{msg, routineRows(proposed)}); err != nil {
+		Proposed []routineView
+	}{msg, toRoutineViews(proposed)}); err != nil {
 		log.Printf("routines render: %v", err)
 	}
 }
 
-// routineRows turns the wire rows into display rows. The phrase comes from
+// toRoutineViews turns the wire rows into view models. The phrase comes from
 // pattern.PhraseRoutine so the page says the same thing maven's voice says.
-func routineRows(rs []ipc.ProposedRoutine) []routineRow {
-	out := make([]routineRow, 0, len(rs))
+func toRoutineViews(rs []ipc.ProposedRoutine) []routineView {
+	out := make([]routineView, 0, len(rs))
 	for _, r := range rs {
 		p := pattern.ProposedRoutine{Action: r.Action, Object: r.Object, IntervalDays: r.IntervalDays}
 		noticed := "just now"
 		if r.CreatedTs > 0 {
 			noticed = time.Since(time.UnixMilli(r.CreatedTs)).Round(time.Minute).String() + " ago"
 		}
-		out = append(out, routineRow{ID: r.ID, Phrase: pattern.PhraseRoutine(&p), Noticed: noticed})
+		out = append(out, routineView{ID: r.ID, Phrase: pattern.PhraseRoutine(&p), Noticed: noticed})
 	}
 	return out
 }
@@ -1602,32 +1498,7 @@ func handlePTT(w http.ResponseWriter, r *http.Request, voiceAddr string, session
 
 // chatTmpl — plain text conversation interface. No JS: form POSTs to /api/chat
 // and the handler redirects back to /chat with the response.
-var chatTmpl = template.Must(template.New("chat").Funcs(shellFuncs()).Parse(shellTopHTML + chatPageHTML + shellBottomHTML))
-
-const chatPageHTML = `{{template "shellTop" "chat"}}
-<h1>Chat</h1>
-<section class=card>
-{{if .Error}}<div class="msg msg-err">{{.Error}}</div>{{end}}
-<div class="scroll chat-scroll" id=chatHistory>
-{{range .Messages}}
-  <div class="chat-msg {{.Role}}"><strong>{{if eq .Role "user"}}you{{else}}maven{{end}}:</strong> {{.Text}}</div>
-{{else}}
-  <div class=empty>
-    <svg class=icon width="20" height="20"><use href="/ethos-icons.svg#i-message"/></svg>
-    <div>start a conversation</div>
-  </div>
-{{end}}
-</div>
-<form method=post action=/api/chat class=chat-form>
-  <input type=text name=text class=input-wide placeholder="type a message..." required autofocus>
-  <button class=btn>send</button>
-</form>
-</section>
-<script>
-var ch = document.getElementById('chatHistory');
-if(ch) ch.scrollTop = ch.scrollHeight;
-</script>
-{{template "shellBottom"}}`
+var chatTmpl = template.Must(template.New("chat").Funcs(shellFuncs()).Parse(shellHTML + chatPageHTML))
 
 // handleChatPage renders the chat conversation page.
 func handleChatPage(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
@@ -1678,7 +1549,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/models.go

@@ -31,7 +31,7 @@ type modelController interface {
 	SwapModel(ctx context.Context, req ipc.SwapModelReq) (ipc.SwapModelResp, error)
 }
 
-var modelsTmpl = template.Must(template.New("models").Funcs(shellFuncs()).Parse(shellTopHTML + modelsHTML + shellBottomHTML))
+var modelsTmpl = template.Must(template.New("models").Funcs(shellFuncs()).Parse(shellHTML + modelsHTML))
 
 const modelsHTML = `{{template "shellTop" "models"}}
 <h1>Resident model</h1>

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>

cmd/mavweb/routines.html

@@ -0,0 +1,24 @@
+{{template "shellTop" "routines"}}
+<h1>Routines</h1>
+{{if .Msg}}<div class="msg msg-ok">{{.Msg}}</div>{{end}}
+<section class=card>
+<h2 class=card-title>noticed <span class=badge>{{len .Proposed}}</span></h2>
+{{if .Proposed}}<div class=scroll><table><tr><th>maven noticed</th><th>when</th><th></th><th></th></tr>
+{{range .Proposed}}<tr>
+<td>{{.Phrase}}</td><td class=muted>{{.Noticed}}</td>
+<td><form method=post action=/routines class=inline-form>
+<input type=hidden name=id value="{{.ID}}">
+<input type=hidden name=action value=accept>
+<button class=btn>accept</button></form></td>
+<td><form method=post action=/routines class=inline-form>
+<input type=hidden name=id value="{{.ID}}">
+<input type=hidden name=action value=dismiss>
+<button class="btn btn-muted">dismiss</button></form></td>
+</tr>{{end}}</table></div>
+{{else}}<div class=empty>
+  <svg class=icon width="20" height="20"><use href="/ethos-icons.svg#i-wave"/></svg>
+  <div>no proposed routines</div>
+  <div class=hint>maven will propose routines here when she detects a recurring pattern</div>
+</div>{{end}}
+</section>
+{{template "shellBottom"}}

cmd/mavweb/shell.html

@@ -0,0 +1,49 @@
+{{define "shellTop"}}<!doctype html><meta charset=utf-8>
+<meta name=viewport content="width=device-width,initial-scale=1,viewport-fit=cover">
+<meta name=theme-color content="#14110D">
+<link rel=manifest href=/manifest.json>
+<title>maven · {{pageTitle .}}</title>
+<link rel=stylesheet href=/ui.css>
+<div class=shell data-app=maven>
+  <header class=topbar>
+    <div class=breadcrumbs>
+      <span class=current>{{pageTitle .}}</span>
+    </div>
+    <div class=topbar-actions>
+      <div class=search-trigger onclick="window.__openSearch()" role=button tabindex=0>
+        <svg class=icon width="13" height="13"><use href="/ethos-icons.svg#i-search"/></svg>
+        Search
+        <span class=kbd-hint>Ctrl+/</span>
+      </div>
+      <button class=icon-btn onclick="window.__openPalette()" title="Command Palette (Ctrl+K)" aria-label="Command Palette">
+        <svg class=icon width="15" height="15"><use href="/ethos-icons.svg#i-grid"/></svg>
+      </button>
+      <span class=conn-status>
+        <span class="dot online" id=connDot></span>
+      </span>
+    </div>
+  </header>
+  <div class=shell-body>
+    <aside class=sidebar>
+{{template "sidebar" .}}
+    </aside>
+    <main class=content>
+{{end}}{{/* sidebar — the section list, with the active page's link marked. The dot
+     argument is the page key the page passed to shellTop. */}}{{define "sidebar"}}{{$active := .}}{{range sidebarSections}}<div class=sidebar-section><div class=sidebar-label>{{.Label}}</div>
+{{- range .Pages}}<a href="{{.URL}}"{{if eq .Key $active}} class="active"{{end}}><span class=icon><svg class=icon width="14" height="14"><use href="/ethos-icons.svg#{{pageIcon .Key}}"/></svg></span><span>{{.Label}}</span></a>
+{{- end}}</div>
+{{end}}{{end}}{{define "shellBottom"}}
+    </main>
+    <aside class=inspector id=inspector>
+      <div class=inspector-inner>
+        <div class=inspector-header>
+          <span id=inspectorTitle>Details</span>
+          <button class=inspector-close onclick="closeInspector()" aria-label="Close inspector">&times;</button>
+        </div>
+        <div class=inspector-body id=inspectorBody></div>
+      </div>
+    </aside>
+  </div>
+</div>
+<script src=/mavweb.js></script>
+{{end}}

cmd/mavweb/tools.html

@@ -0,0 +1,58 @@
+{{template "shellTop" "tools"}}
+<h1>Tools</h1>
+<p class=hint>enabling requires step-up — <a href=/auth/passkey>assert a passkey</a> first.</p>
+{{if .Msg}}<div class="msg msg-ok">{{.Msg}}</div>{{end}}
+<section class=card>
+<h2 class=card-title>proposed <span class=badge>{{len .Proposed}}</span></h2>
+{{if .Proposed}}<p class=hint>maven drafted these from acts she couldn't run. Fill the command (argv, space-separated) and enable. A row in an <code>mcp:</code> scope came from an MCP server and already knows what it calls — check the command, then enable.</p>
+<div class=scroll><table><tr><th>name</th><th>scope</th><th>from utterance</th><th>enable as</th></tr>
+{{range .Proposed}}<tr>
+<td><code>{{.Name}}</code></td><td><span class=badge>{{.Scope}}</span></td><td>{{.Utterance}}</td>
+<td><form method=post action=/tools>
+<input type=hidden name=name value="{{.Name}}">
+<input type=hidden name=scope value="{{.Scope}}">
+<input type=hidden name=action value=enable>
+<input type=text name=cmd class=input-wide placeholder="systemctl restart" value="{{join .Cmd " "}}" required>
+<label><input type=checkbox name=destructive {{if .Destructive}}checked{{end}}> destructive</label>
+<button class=btn>enable</button></form>
+<form method=post action=/tools class=inline-form>
+<input type=hidden name=name value="{{.Name}}">
+<input type=hidden name=action value=dismiss>
+<button class="btn btn-muted">dismiss</button></form></td>
+</tr>{{end}}</table></div>
+{{else}}<div class=empty>
+  <svg class=icon width="20" height="20"><use href="/ethos-icons.svg#i-search"/></svg>
+  <div>no proposed tools</div>
+  <div class=hint>maven will propose tools here when she needs help running an action</div>
+</div>{{end}}
+</section>
+<section class=card>
+<h2 class=card-title>enabled <span class=badge>{{len .Enabled}}</span></h2>
+{{if .Enabled}}<div class=scroll><table><tr><th>name</th><th>scope</th><th>command</th><th></th><th></th></tr>
+{{range .Enabled}}<tr><td><code>{{.Name}}</code></td><td><span class=badge>{{.Scope}}</span></td><td><code>{{join .Cmd " "}}</code></td>
+<td>{{if .Destructive}}<span class=red>destructive</span>{{end}}</td>
+<td><form method=post action=/tools class=inline-form>
+<input type=hidden name=name value="{{.Name}}">
+<input type=hidden name=scope value="{{.Scope}}">
+<input type=hidden name=action value=disable>
+<button class=btn>disable</button></form></td></tr>{{end}}</table></div>
+{{else}}<div class=empty>
+  <svg class=icon width="20" height="20"><use href="/ethos-icons.svg#i-settings"/></svg>
+  <div>no tools enabled</div>
+  <div class=hint>enable proposed tools above, or ask maven to configure one</div>
+</div>{{end}}
+</section>
+<section class=card>
+<h2 class=card-title>MCP servers <span class=badge>{{len .MCP}}</span></h2>
+{{if .MCP}}<p class=hint>servers she connects OUT to. Their tools appear above as proposals — a configured server is a place she may look, not a capability she has. A <code>stdio</code> target is a process on this box; an <code>http</code> one on a loopback or LAN address is inside the network, so treat its tools accordingly.</p>
+<div class=scroll><table><tr><th>name</th><th>transport</th><th>target</th><th>state</th><th>tools</th></tr>
+{{range .MCP}}<tr><td><code>{{.Name}}</code></td><td><span class=badge>{{.Transport}}</span></td><td><code>{{.Target}}</code></td>
+<td>{{if .Connected}}connected{{if .Server}} — {{.Server}}{{end}}{{else}}<span class=red>down</span>{{if .Err}} — {{.Err}}{{end}}{{end}}</td>
+<td>{{.Tools}}</td></tr>{{end}}</table></div>
+{{else}}<div class=empty>
+  <svg class=icon width="20" height="20"><use href="/ethos-icons.svg#i-settings"/></svg>
+  <div>no MCP servers configured</div>
+  <div class=hint>add an <code>mcp.servers</code> block to mavend.json to let her use an external tool server</div>
+</div>{{end}}
+</section>
+{{template "shellBottom"}}

deploy/mavend.json

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

@@ -223,6 +223,30 @@ Not alternatives — layers:
 Router contract: `[{"intent":<enum>, key?, value?, text?, verb?}, ...]` over
 7 intents (`fact, reminder, note, query, act, chat, system`).
 
+#### A restart expires a parked question
+
+Decided 2026-08-04 (Vikunja #385). The follow-up dialogue session survives a
+restart; the clarify question parked behind it does not, and neither do the
+three yes/no confirms in `voice.go`. `ClarifyStore` stays in memory.
+
+Three reasons, in the order they settle it:
+
+- The clock stops meaning anything. A parked question carries a 90s TTL and an
+  attempt count. A restart is a gap of unknown length, so a restored question is
+  either already dead or pretending to be young.
+- Restoring the question restores the request behind it. He asked for something,
+  she asked back, and then the daemon went away. Acting on that minutes later,
+  against words he has probably given up on, is the misroute the stage 3 gate
+  exists to avoid.
+- She does not announce it either. The expiry notice needs to know a question
+  was parked, and knowing that across a restart means storing it. One sentence,
+  in the rare window where he speaks within 90s of a restart, does not pay for a
+  marker that outlives the thing it describes. His next words route fresh, which
+  is the correct answer with or without the notice.
+
+So the notice stays what it is: the in-process TTL case, where she really did
+wait and really did let go.
+
 ### save-where — the two-memory routing axis
 
 One discriminator: **does the loop evaluate a predicate against it?**
@@ -365,6 +389,29 @@ lives in `source`; rules trust provenance.
   `source=poll:healthcheck`. A compromised poller must not be able to forge a
   trigger.
 
+#### A fact per monitor, not an aggregate
+
+mavpoll writes one fact per kuma monitor, keyed `service_down:<monitor name>`.
+It used to fold the whole gauge into a single boolean, and the nudge could then
+only say that something on homesrv was down. That is not something he can act
+on, so the rule shipped disabled.
+
+Three things follow from the split:
+
+- The key set is no longer known at wiring time. A rule declares
+  `WantPrefixes` and the gatherer resolves the family per tick, which is the
+  only prefix read in the loop.
+- Pausing a monitor in kuma silences that monitor. Under the aggregate it
+  silenced nothing, because some other monitor kept the boolean at "down".
+- A monitor deleted in kuma would keep its last fact reading "down" forever, so
+  mavpoll marks a vanished monitor "unknown". No rule fires on "unknown".
+
+The rule is also edge-triggered: it fires on a transition it has not already
+nudged about (`State.NudgedSince`). A polled fact is written only when the
+value changes, but the predicate reads the current value, so without the edge
+check a service that stays down qualifies on every tick and cooldown is the
+only brake.
+
 ### Presence — concrete scoring
 
 **Combiner — noisy-OR, not weighted sum.** These are independent-ish positive

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.

docs/evals/2026-08-04-recall-e5-small.md

@@ -0,0 +1,88 @@
+# Note recall after the e5-small swap — 04-08-2026
+
+Closes Vikunja #371, which asked for the swap and for this re-measurement. The embedder is no
+longer paraphrase-multilingual-MiniLM-L12-v2. It is **multilingual-e5-small**, quantized, with the
+`query:` / `passage:` prefixes it was trained with (`internal/router/onnxembedder.go`,
+`EmbedQuery` / `EmbedPassage`). `deploy/mavend.json` loads
+`models/embedder/multilingual-e5-small/model_quantized.onnx`, which is the same file `make
+download-embedder` fetches and the same file this run measured.
+
+- Fixture + scorer: `internal/memory/recalleval/` — 32 cases now, not 30
+- Reproduce: `make eval-recall`
+- Commit: `b6abb19`
+- Gate as deployed: `query_min_score` 0.55, `query_min_margin` 0.008
+
+The fixture grew since 31-07, so the case counts are not comparable row for row. The percentages
+are.
+
+## Results
+
+| | 31-07 MiniLM (onnx) | 04-08 e5-small (onnx) |
+|---|---|---|
+| **recall@1** | 60.0% (15/25) | **70.4% (19/27)** |
+| recall@3 | 80.0% (20/25) | **85.2% (23/27)** |
+| **answered after the gate** | 48.0% (12/25) | **63.0% (17/27)** |
+| **false recall** | 1/5 (20%) | **0/5** |
+| wrong note on top / tie on top | 10 / 0 | 8 / 0 |
+| ranked first, then silenced by the gate | 3 | 2 |
+| `hard` cases passed | 2/11 | 5/12 |
+| RU / EN passed | 13/24 / 3/6 | 18/26 / 4/6 |
+| latency p50 / p95 / max | 59ms / 148ms / 194ms | **23ms / 41ms / 62ms** |
+
+The hash ratchet CI runs is unchanged in kind and still answers nothing after the gate: recall@1
+37.0%, recall@3 74.1%, 0/27 answered, 0/5 false. It is lexical and exists so CI has a deterministic
+floor. Never compare a hash number to an ONNX one.
+
+## Findings
+
+### 1. The swap paid on every axis at once, including latency
+
+Ten points of recall@1, fifteen points of *answered*, the one false recall gone, and it is 2.5×
+faster because the quantized e5-small is 118MB against the 470MB fp32 file the old config loaded.
+Finding 3 of the 31-07 eval predicted the recall half and said nothing about speed; the speed came
+from fixing the second half of that finding, which was that the deployed path loaded a different
+file than the download target.
+
+The concrete case that eval named is fixed. "из-за чего кончилось место" no longer returns the
+guitar-chords filler note. It now returns a homelab note, `n2` at 0.884, and the wanted note is
+still not in the top 3 — so the query moved from absurd to merely wrong. That is the shape of what
+is left.
+
+### 2. The score distributions still overlap. The margin is what separates them
+
+This is the part of #371's premise that did not come true. Right-note-first top-1 scores run
+0.791 / 0.857 / 0.890 (min / median / max). Must-stay-silent top-1 scores run 0.795 / 0.815 /
+0.835. The silent cases sit *inside* the answering range, so no value of `query_min_score` keeps
+every real recall and rejects every false one — the same verdict as 31-07, at a higher and tighter
+band of scores.
+
+What separates them is the second-place gap. Margin top1-top2 for a right first hit: median 0.024.
+For a must-be-silent case: median 0.002, max 0.019. A false recall is a note that beats its
+neighbours by nothing, because nothing in the store is about the question. The sweep:
+
+| margin | answered | false recall |
+|---|---|---|
+| 0.000 | 18/27 (67%) | 3/5 |
+| 0.005 | 17/27 (63%) | 1/5 |
+| **0.008 (deployed)** | **17/27 (63%)** | **0/5** |
+| 0.010 | 15/27 (56%) | 0/5 |
+| 0.015 | 12/27 (44%) | 0/5 |
+
+0.008 is the knee: it is the smallest margin that silences all five, and the next step up costs two
+real answers for nothing. The score gate contributes almost nothing on its own — every value from
+0.00 to 0.70 answers the same 18 and admits the same 3 — so `query_min_score` is now close to inert
+and the margin is the live dial. Leave both where they are; #412 is where a further sweep belongs.
+
+### 3. What is left is a retrieval problem, not a gate problem
+
+Eight cases put the wrong note on top, and the failures cluster: `hard` 5/12, `preference` 5/9,
+`homelab` 8/13. Four of the eight have the right note in the top 3, so a reranker would collect
+them; the other four do not, so nothing downstream can. Two more rank first and are silenced by the
+margin — `en-hard-024` at 0.826 with margin 0.023, and `ru-home-026` at 0.846 with margin 0.001,
+which is a genuine near-tie against a second note that is also plausible.
+
+Preference queries are the weakest class in a way that is not about the model. "когда запускать
+резервное копирование" and "как мне присылать оповещения" both return a fact, not the note that
+states the preference. Facts and notes are searched in one pass since #373, so a confidently-scored
+fact wins a question that a note answers better. That is a ranking policy question and it belongs
+in its own task, not in a threshold.

docs/handler-wiring.md

@@ -0,0 +1,62 @@
+# How reactiveHandler is wired
+
+*Last verified: 2026-08-04 @ b6abb19. Living doc: correct it in place, do not append.*
+
+The decision Vikunja #433 asked for, and the rule that follows from it.
+
+## The decision
+
+**Group the fields into cohesive wiring structs. No container, no generator, no
+framework.** `reactiveHandler` (`cmd/mavend/voice.go`) stays the one type the voice
+server talks to. What changes is that a capability arrives as one named group, not as
+four more loose fields on a struct that already had thirty.
+
+The pattern was already in the file before this was written down: `searchWiring`,
+`kiwixWiring`, `homeWiring`, `netWiring` and `ecosystemWiring` are all this shape, each
+`nil` when the capability is off. #433 makes it the rule rather than a habit, and adds
+the case the habit had missed — a group that is not a capability toggle.
+
+## The worked example
+
+`recallWiring` (`cmd/mavend/recall.go`) holds the five things the recall path needs:
+the embedder, the vector store, the personal boundary, and the score and margin that
+gate an answer. They used to sit in three separate places on the handler with the two
+gate numbers a hundred lines away from the store they gate.
+
+Its zero value means "no recall", which is why it is a value and not a pointer. The
+`*Wiring` types that model an optional capability stay pointers, because `nil` is how
+"not configured" is spelled and a zero-valued search client would be a client pointed at
+nothing.
+
+## Why not the alternatives
+
+**Narrow consumer-side interfaces at each handler** is the more idiomatic Go answer and
+it is not rejected, only deferred. It is the right move at the point a handler is pulled
+into its own package, because that is when the import direction starts to matter. Doing
+it first would mean writing an interface per handler against a struct nobody can pass
+anywhere, which is churn bought against a package split that has not happened.
+
+**A container or a wire-style generator** is rejected outright. This is one binary with
+one composition root (`wireVoice` in `cmd/mavend/voicewire.go`). Generated wiring would
+add a build step and a layer of indirection to solve a problem that is currently one
+composite literal long, and it would make the "is this capability configured" question
+harder to answer by reading, which is the question this file is mostly about.
+
+## What this unlocks
+
+The reason `cmd/mavend/` cannot split into `mavend/actions/` today is that every action
+handler is a method on a struct with thirty unexported fields: moving handlers to a
+subdirectory means exporting all of them or inventing an interface to pass through. That
+was the answer given on the tick.go and voice.go splits, and it is still true. Grouping
+is the step that makes it false later — a handler that takes `recallWiring` and nothing
+else can move without the other twenty-five fields following it.
+
+## The rule
+
+**A wiring change does not ride a feature PR.** The voice.go and tick.go splits were
+safe to merge because the moved code diffed identical, line for line. A regrouping that
+touches the confirm gate or the act allowlist is its own change, reviewed on its own, or
+it is not reviewable at all.
+
+New capability, new group. A capability that adds four fields to `reactiveHandler`
+instead of one struct is the thing this decision exists to stop.

docs/rearchitecture.md

@@ -1,6 +1,6 @@
 # Maven — Re-architecture (Qwen3 resident model, revised 2026-07-18)
 
-*Last verified: 2026-08-02 @ 7079a24. Living doc: correct it in place, do not append.*
+*Last verified: 2026-08-04 @ b6abb19. Living doc: correct it in place, do not append.*
 
 > Supersedes the classifier-first routing model. Agreed in a design session
 > after diagnosing that homesrv deploys with a **stub phraser** (no LLM
@@ -40,8 +40,10 @@ utterance
   are deferred until the main feature set is complete.
 - **Embedder demoted from router to tool** — it now backs `memory.search`
   (RAG) and gives the router a cheap "similar past notes/intents" hint. The
-  router no longer depends on it clearing a threshold. Upgrade MiniLM → bge-m3
-  for better RU retrieval later (model swap, not architecture).
+  router no longer depends on it clearing a threshold. The MiniLM upgrade is
+  done: it is multilingual-e5-small, asymmetric, with the `query:`/`passage:`
+  prefixes (Vikunja #371, `docs/evals/2026-08-04-recall-e5-small.md`). A
+  further swap is a model swap, not architecture (Vikunja #412).
 
 ### Router output
 - Constrained structured JSON action `{tool, args, escalate}` — NOT free-form

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/ambient.go

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

internal/calendar/ambient_test.go

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

internal/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

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

@@ -57,6 +57,14 @@ func (q *PendingQuestion) CanAsk() bool {
 
 // ClarifyStore holds the parked questions. Same shape and locking as
 // SessionStore: keyed by dialogue id, expired entries dropped on read.
+//
+// Memory only, deliberately, unlike SessionStore — a restart expires every
+// parked question and she does not announce that it happened (Vikunja #385,
+// written down in docs/design.md). The 90s TTL and the attempt count measure a
+// pause in one conversation, and a restart is a gap of unknown length, so a
+// restored question would either be dead already or lying about its age. His
+// next words route fresh, which is the right answer with or without a notice.
+// Do not give this store a persister without re-arguing that.
 type ClarifyStore struct {
 	mu         sync.RWMutex
 	questions  map[string]*PendingQuestion

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"`
@@ -653,127 +678,6 @@ type acceptProposedRoutineReq struct {
 	ID int64 `json:"id"`
 }
 
-// CoreAPI — what core exposes to modules. One Go interface, satisfied by:
-//   - the in-process store adapter (server.go storeAPI) — used by the daemon
-//     for modules that live in-process for now (router, delivery) and by tests,
-//   - the socket-backed server's dispatcher (which delegates to a CoreAPI),
-//   - the client proxy (client.go) — same interface, over the wire.
-//
-// So a module imports ipc, holds a CoreAPI, and is agnostic to whether it's
-// been wired in-process (tests / daemon-embedded) or socketed (full topology).
-// That swappability is the seam the auth layer will insert into without
-// touching the module code.
-type CoreAPI interface {
-	WriteFact(ctx context.Context, req WriteFactReq) (int64, error)
-	LatestFact(ctx context.Context, key string) (Fact, error)
-	LatestFactBySource(ctx context.Context, key, source string) (Fact, error)
-	Since(ctx context.Context, key string, now time.Time) (time.Duration, error)
-	Presence(ctx context.Context) (Presence, error)
-	CreateReminder(ctx context.Context, fire time.Time, payload, cron string) (int64, error)
-	MarkReminder(ctx context.Context, id int64, status string) error
-	ListReminders(ctx context.Context, n int) ([]Reminder, error)
-	RecordNudge(ctx context.Context, rule, channel, message string, ts time.Time) (int64, error)
-	ResolveNudge(ctx context.Context, id int64, outcome string, ts time.Time) error
-	RecentOutcomes(ctx context.Context, rule string, n int) ([]string, error)
-	RecentFacts(ctx context.Context, n int) ([]Fact, error)
-	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)
-
-	// RecentEcosystemTraces reads the ecosystem call log, which lives in its
-	// own table so machine-rate traces never crowd out human-rate facts.
-	RecentEcosystemTraces(ctx context.Context, n int) ([]EcosystemTrace, error)
-	WriteNote(ctx context.Context, ts time.Time, text string, embedding []float32, source string) (int64, error)
-	QueryNotes(ctx context.Context, embedding []float32, k int) ([]Note, error)
-	RecentNotes(ctx context.Context, n int) ([]Note, error)
-	// RecentNotesFromSource — the newest n notes whose source starts with
-	// prefix. Notes Maven read rather than heard (rss:, crawl:) are excluded
-	// from recall, so this is the only way to reach them, and it keeps the feed
-	// answer from being crowded out of a fixed window by his own notes.
-	RecentNotesFromSource(ctx context.Context, prefix string, n int) ([]Note, error)
-
-	// ProposeTool drafts an inert 'proposed' tool scaffold (maven-callable);
-	// returns whether a new proposal was written. EnableTool fills cmd +
-	// destructive and flips status to 'enabled'. DisableTool reverts an
-	// enabled tool back to proposed (it stays in the store, won't run).
-	// Enable/DisableTool gate at AuthStepUp (allowlist mutation, human-only);
-	// ProposeTool is maven-callable (no step-up — she has no passkey).
-	// LookupTool/ListTools read them.
-	// scope defaults to "homelab" when empty.
-	ProposeTool(ctx context.Context, name, utterance, scope string, ts time.Time) (bool, error)
-	EnableTool(ctx context.Context, name string, cmd []string, destructive bool, scope string, ts time.Time) error
-	DisableTool(ctx context.Context, name string) error
-	DeleteTool(ctx context.Context, name string) error
-	LookupTool(ctx context.Context, name string) (Tool, error)
-	ListTools(ctx context.Context, status string) ([]Tool, error)
-	RevertFact(ctx context.Context, key string) (int64, error)
-
-	// ListProposedRoutines returns proposed routines, newest first.
-	ListProposedRoutines(ctx context.Context) ([]ProposedRoutine, error)
-	// DismissProposedRoutine flips a proposed routine to 'dismissed'.
-	DismissProposedRoutine(ctx context.Context, id int64) error
-	// AcceptProposedRoutine flips a proposed routine to 'accepted'. The tick
-	// loop takes the schedule from there — no reminder is created (Vikunja #366).
-	AcceptProposedRoutine(ctx context.Context, id int64) error
-
-	// CaptureTask records a task. See CaptureTaskReq — this is the single
-	// intake seam for the voice path, the web form and the future email
-	// extractor. Idempotent per live normalised text; the response says
-	// whether a row was actually created.
-	CaptureTask(ctx context.Context, req CaptureTaskReq) (CaptureTaskResp, error)
-	// ListTasks returns tasks in one status, newest first. "" is every row,
-	// "live" is candidate + open (outstanding work).
-	ListTasks(ctx context.Context, status string) ([]Task, error)
-	// SetTaskStatus moves a task forward once: candidate→open|dropped,
-	// open→done|dropped. Any other move is refused.
-	SetTaskStatus(ctx context.Context, id int64, status string, ts time.Time, by string) error
-
-	// TickTrace returns the most recent tick's rule trace. The daemon caches
-	// this after every tick; the store adapter returns an error (trace is not
-	// persisted — it's a daemon-level cache).
-	TickTrace(ctx context.Context) (TickTrace, error)
-
-	// MorningStatus returns each configured morning routine's current
-	// checklist state (see internal/morning): active today/now, which items
-	// are done, which are still missing. The store adapter returns an error
-	// (morning routines are daemon-config, not persisted) — same shape as
-	// TickTrace.
-	MorningStatus(ctx context.Context) ([]MorningRoutineStatus, error)
-
-	// MCPServers reports the configured MCP servers and their health
-	// (Vikunja #251). Read-only introspection for /tools — there is no
-	// "call this tool" method on purpose: an MCP tool runs through the same
-	// allowlist, confirm turn and act path as any other tool, and a second
-	// mutation path would be a second thing to get wrong. Empty when the
-	// mcp config block is absent, which is the default.
-	MCPServers(ctx context.Context) ([]MCPServerStatus, error)
-
-	// DayPlan returns today's ordered plan — calendar events, pending
-	// reminders and any morning checklist still outstanding (see
-	// internal/morning.BuildPlan) — plus the spoken RU rendering of it.
-	// Read-only: asking for the plan never dispatches or schedules anything.
-	// The store adapter returns an error (the plan needs the daemon's routine
-	// config) — same shape as TickTrace and MorningStatus.
-	DayPlan(ctx context.Context) (DayPlan, error)
-
-	// 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)
-
-	// RecentEvents returns the daemon's unified intake journal, newest first
-	// (Vikunja #283) — one envelope per thing that arrived, whatever direction
-	// it came from: a relayed notification, a mail candidate, a feed item, a
-	// changed page, a spend, a presence probe.
-	//
-	// Read-only and daemon-cached, the same shape as TickTrace and DayPlan:
-	// the store adapter returns an error, because the journal is a bounded
-	// in-memory ring and not a table. Its contents are a window over intake,
-	// never the durable record — that is still the fact, note or task the
-	// intake path wrote.
-	RecentEvents(ctx context.Context, n int) ([]IntakeEvent, error)
-}
-
 // IntakeEvent — one entry of the unified intake journal on the wire. Mirrors
 // event.Event field for field; the ipc package does not import internal/event
 // so the wire shape stays independent of the in-process type.

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/coreapi.go

@@ -0,0 +1,194 @@
+package ipc
+
+import (
+	"context"
+	"time"
+)
+
+// CoreAPI and the eight domain interfaces it composes (Vikunja #408).
+//
+// It used to be one flat block of forty methods, and the cost of that shape
+// was paid three times over: every method added an arm to the dispatcher, a
+// stub to the daemon's locked API, and a stub to every test double. Two of
+// those three are already gone — the dispatcher is a table (methodTable in
+// server.go), and UnimplementedCoreAPI took the padding out of the doubles and
+// out of lockedAPI, which no longer exists.
+//
+// What was left is the interface itself, and this file is that half. CoreAPI
+// is unchanged as a type: the same forty methods, in the same order, so the
+// wire contract, the client proxy and the store adapter are all untouched.
+// What it gains is a named seam per domain, so a caller that only reads facts
+// can say FactAPI and a reader can see which cluster a method belongs to
+// without counting lines.
+//
+// Add a method to the domain it belongs to, not to CoreAPI.
+
+// FactAPI — the fact store: write, read the current value, read history, and
+// undo. Presence sits here because it is a hysteresis view over presence
+// facts, not a store of its own.
+type FactAPI interface {
+	WriteFact(ctx context.Context, req WriteFactReq) (int64, error)
+	LatestFact(ctx context.Context, key string) (Fact, error)
+	LatestFactBySource(ctx context.Context, key, source string) (Fact, error)
+	Since(ctx context.Context, key string, now time.Time) (time.Duration, error)
+	Presence(ctx context.Context) (Presence, error)
+	RecentFacts(ctx context.Context, n int) ([]Fact, error)
+	RecentActiveFactsByKind(ctx context.Context, kind string, n int) ([]Fact, error)
+	CalendarEvents(ctx context.Context, from, to time.Time) ([]Fact, error)
+	RevertFact(ctx context.Context, key string) (int64, error)
+}
+
+// ReminderAPI — scheduled sends the owner asked for.
+type ReminderAPI interface {
+	CreateReminder(ctx context.Context, fire time.Time, payload, cron string) (int64, error)
+	MarkReminder(ctx context.Context, id int64, status string) error
+	ListReminders(ctx context.Context, n int) ([]Reminder, error)
+}
+
+// NudgeAPI — proactive sends Maven proposed, their outcomes, and the outbox
+// they went out through.
+type NudgeAPI interface {
+	RecordNudge(ctx context.Context, rule, channel, message string, ts time.Time) (int64, error)
+	ResolveNudge(ctx context.Context, id int64, outcome string, ts time.Time) error
+	RecentOutcomes(ctx context.Context, rule string, n int) ([]string, 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)
+}
+
+// NoteAPI — free text he captured, plus the embedded recall over it.
+type NoteAPI interface {
+	WriteNote(ctx context.Context, ts time.Time, text string, embedding []float32, source string) (int64, error)
+	QueryNotes(ctx context.Context, embedding []float32, k int) ([]Note, error)
+	RecentNotes(ctx context.Context, n int) ([]Note, error)
+	// RecentNotesFromSource — the newest n notes whose source starts with
+	// prefix. Notes Maven read rather than heard (rss:, crawl:) are excluded
+	// from recall, so this is the only way to reach them, and it keeps the feed
+	// answer from being crowded out of a fixed window by his own notes.
+	RecentNotesFromSource(ctx context.Context, prefix string, n int) ([]Note, error)
+}
+
+// ToolAPI — the capability allowlist and its read side.
+//
+// ProposeTool drafts an inert 'proposed' tool scaffold (maven-callable);
+// returns whether a new proposal was written. EnableTool fills cmd +
+// destructive and flips status to 'enabled'. DisableTool reverts an
+// enabled tool back to proposed (it stays in the store, won't run).
+// Enable/DisableTool gate at AuthStepUp (allowlist mutation, human-only);
+// ProposeTool is maven-callable (no step-up — she has no passkey).
+// LookupTool/ListTools read them.
+// scope defaults to "homelab" when empty.
+type ToolAPI interface {
+	ProposeTool(ctx context.Context, name, utterance, scope string, ts time.Time) (bool, error)
+	EnableTool(ctx context.Context, name string, cmd []string, destructive bool, scope string, ts time.Time) error
+	DisableTool(ctx context.Context, name string) error
+	DeleteTool(ctx context.Context, name string) error
+	LookupTool(ctx context.Context, name string) (Tool, error)
+	ListTools(ctx context.Context, status string) ([]Tool, error)
+
+	// MCPServers reports the configured MCP servers and their health
+	// (Vikunja #251). Read-only introspection for /tools — there is no
+	// "call this tool" method on purpose: an MCP tool runs through the same
+	// allowlist, confirm turn and act path as any other tool, and a second
+	// mutation path would be a second thing to get wrong. Empty when the
+	// mcp config block is absent, which is the default.
+	MCPServers(ctx context.Context) ([]MCPServerStatus, error)
+}
+
+// RoutineAPI — the shapes of his day: routines Maven noticed and proposed, the
+// morning checklist, and today's plan.
+//
+// MorningStatus and DayPlan are daemon-computed rather than stored, so the
+// store adapter returns an error for both — the same shape as TickTrace.
+type RoutineAPI interface {
+	// ListProposedRoutines returns proposed routines, newest first.
+	ListProposedRoutines(ctx context.Context) ([]ProposedRoutine, error)
+	// DismissProposedRoutine flips a proposed routine to 'dismissed'.
+	DismissProposedRoutine(ctx context.Context, id int64) error
+	// AcceptProposedRoutine flips a proposed routine to 'accepted'. The tick
+	// loop takes the schedule from there — no reminder is created (Vikunja #366).
+	AcceptProposedRoutine(ctx context.Context, id int64) error
+
+	// MorningStatus returns each configured morning routine's current
+	// checklist state (see internal/morning): active today/now, which items
+	// are done, which are still missing.
+	MorningStatus(ctx context.Context) ([]MorningRoutineStatus, error)
+
+	// DayPlan returns today's ordered plan — calendar events, pending
+	// reminders and any morning checklist still outstanding (see
+	// internal/morning.BuildPlan) — plus the spoken RU rendering of it.
+	// Read-only: asking for the plan never dispatches or schedules anything.
+	DayPlan(ctx context.Context) (DayPlan, error)
+}
+
+// TaskAPI — outstanding work, whatever surface it arrived from.
+type TaskAPI interface {
+	// CaptureTask records a task. See CaptureTaskReq — this is the single
+	// intake seam for the voice path, the web form and the future email
+	// extractor. Idempotent per live normalised text; the response says
+	// whether a row was actually created.
+	CaptureTask(ctx context.Context, req CaptureTaskReq) (CaptureTaskResp, error)
+	// ListTasks returns tasks in one status, newest first. "" is every row,
+	// "live" is candidate + open (outstanding work).
+	ListTasks(ctx context.Context, status string) ([]Task, error)
+	// SetTaskStatus moves a task forward once: candidate→open|dropped,
+	// open→done|dropped. Any other move is refused.
+	SetTaskStatus(ctx context.Context, id int64, status string, ts time.Time, by string) error
+}
+
+// SystemAPI — what the daemon knows about itself, plus the one method that
+// runs a whole turn.
+type SystemAPI interface {
+	// TickTrace returns the most recent tick's rule trace. The daemon caches
+	// this after every tick; the store adapter returns an error (trace is not
+	// persisted — it's a daemon-level cache).
+	TickTrace(ctx context.Context) (TickTrace, error)
+
+	// RecentEcosystemTraces reads the ecosystem call log, which lives in its
+	// own table so machine-rate traces never crowd out human-rate facts.
+	RecentEcosystemTraces(ctx context.Context, n int) ([]EcosystemTrace, error)
+
+	// RecentEvents returns the daemon's unified intake journal, newest first
+	// (Vikunja #283) — one envelope per thing that arrived, whatever direction
+	// it came from: a relayed notification, a mail candidate, a feed item, a
+	// changed page, a spend, a presence probe.
+	//
+	// Read-only and daemon-cached, the same shape as TickTrace and DayPlan:
+	// the store adapter returns an error, because the journal is a bounded
+	// in-memory ring and not a table. Its contents are a window over intake,
+	// never the durable record — that is still the fact, note or task the
+	// intake path wrote.
+	RecentEvents(ctx context.Context, n int) ([]IntakeEvent, error)
+
+	// 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).
+	//
+	// 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)
+}
+
+// CoreAPI — what core exposes to modules. One Go interface, satisfied by:
+//   - the in-process store adapter (storeapi.go) — used by the daemon
+//     for modules that live in-process for now (router, delivery) and by tests,
+//   - the socket-backed server's dispatcher (which delegates to a CoreAPI),
+//   - the client proxy (client.go) — same interface, over the wire.
+//
+// So a module imports ipc, holds a CoreAPI, and is agnostic to whether it's
+// been wired in-process (tests / daemon-embedded) or socketed (full topology).
+// That swappability is the seam the auth layer inserts into without touching
+// the module code.
+type CoreAPI interface {
+	FactAPI
+	ReminderAPI
+	NudgeAPI
+	NoteAPI
+	ToolAPI
+	RoutineAPI
+	TaskAPI
+	SystemAPI
+}

internal/ipc/frame.go

@@ -36,6 +36,13 @@ const maxFrame = 4 << 20
 // (we read the length but not the body), so the caller must close it.
 var ErrFrameTooLarge = errors.New("ipc: frame too large")
 
+// The framing is hand-rolled and it stays that way (Vikunja #410): ninety
+// lines, readable on the wire with socat, and every standard replacement
+// brings schema machinery this boundary does not want. The condition is that
+// it is defended by tests rather than inherited untested — truncated header,
+// truncated body, partial reads, frame boundaries and a non-JSON body all
+// live in frame_test.go.
+//
 // writeFrame encodes v as JSON and frames it as a 4-byte big-endian length
 // prefix + body. length-prefixed JSON (not a tighter binary schema) is the
 // deferred-but-picked wire format: debuggable with `socat`/`nc`, trivial to

internal/ipc/frame_test.go

@@ -0,0 +1,142 @@
+package ipc
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"io"
+	"testing"
+)
+
+// The framing is hand-rolled, and it is the protocol all nine daemons depend
+// on, so a bug in it is a bug everywhere (Vikunja #410). The review asked
+// whether to replace it with something standard. It stays: length-prefixed
+// JSON over a unix socket is ninety lines, it is readable with socat, and the
+// alternatives (net/rpc, gRPC, a codec library) all buy schema machinery this
+// boundary does not want. What was wrong was inheriting it untested. These
+// are the paths a real socket produces that the round-trip test never does.
+
+// A short header is not EOF. EOF means the peer closed cleanly between
+// frames, which the server treats as a normal disconnect; a header that stops
+// halfway is a truncated frame and must be reported as an error, or a peer
+// that dies mid-write looks like one that hung up politely.
+func TestReadFrameTruncatedHeader(t *testing.T) {
+	var v any
+	err := readFrame(bytes.NewReader([]byte{0, 0, 4}), &v)
+	if err == nil {
+		t.Fatal("a three-byte header must fail")
+	}
+	if errors.Is(err, io.EOF) {
+		t.Fatalf("err = %v, want a truncation error, not EOF", err)
+	}
+}
+
+// A header promising more body than follows. Same reasoning: the frame never
+// arrived, so it must not decode into a zero value the caller then trusts.
+func TestReadFrameTruncatedBody(t *testing.T) {
+	var buf bytes.Buffer
+	var hdr [4]byte
+	binary.BigEndian.PutUint32(hdr[:], 32)
+	buf.Write(hdr[:])
+	buf.WriteString(`{"m":"pi`)
+
+	var got map[string]string
+	if err := readFrame(&buf, &got); err == nil {
+		t.Fatal("a body shorter than its prefix must fail")
+	}
+	if len(got) != 0 {
+		t.Errorf("decoded %v from a truncated frame", got)
+	}
+}
+
+// Nothing at all is EOF, and only this is.
+func TestReadFrameEmptyIsEOF(t *testing.T) {
+	var v any
+	if err := readFrame(bytes.NewReader(nil), &v); !errors.Is(err, io.EOF) {
+		t.Fatalf("err = %v, want io.EOF", err)
+	}
+}
+
+// byteAtATime returns one byte per Read, which is what a socket is allowed to
+// do and what a bytes.Reader never does. readFrame uses io.ReadFull for both
+// the header and the body; this is the test that would fail if either turned
+// into a bare Read.
+type byteAtATime struct {
+	b []byte
+	i int
+}
+
+func (r *byteAtATime) Read(p []byte) (int, error) {
+	if r.i >= len(r.b) {
+		return 0, io.EOF
+	}
+	if len(p) == 0 {
+		return 0, nil
+	}
+	p[0] = r.b[r.i]
+	r.i++
+	return 1, nil
+}
+
+func TestReadFrameReassemblesPartialReads(t *testing.T) {
+	type payload struct {
+		Msg string `json:"m"`
+		N   int    `json:"n"`
+	}
+	want := payload{Msg: "привет", N: 7}
+	var buf bytes.Buffer
+	if err := writeFrame(&buf, want); err != nil {
+		t.Fatalf("writeFrame: %v", err)
+	}
+
+	var got payload
+	if err := readFrame(&byteAtATime{b: buf.Bytes()}, &got); err != nil {
+		t.Fatalf("readFrame: %v", err)
+	}
+	if got != want {
+		t.Fatalf("got %+v, want %+v", got, want)
+	}
+}
+
+// Two frames written back to back must come back as two frames. A reader that
+// consumed more than one frame's body would desynchronize the connection, and
+// the symptom would be a reply attributed to the wrong request.
+func TestReadFrameStopsAtTheFrameBoundary(t *testing.T) {
+	var buf bytes.Buffer
+	for _, m := range []string{"first", "second"} {
+		if err := writeFrame(&buf, map[string]string{"m": m}); err != nil {
+			t.Fatalf("writeFrame: %v", err)
+		}
+	}
+	r := &byteAtATime{b: buf.Bytes()}
+	for _, want := range []string{"first", "second"} {
+		var got map[string]string
+		if err := readFrame(r, &got); err != nil {
+			t.Fatalf("readFrame(%s): %v", want, err)
+		}
+		if got["m"] != want {
+			t.Fatalf("got %q, want %q", got["m"], want)
+		}
+	}
+	var extra map[string]string
+	if err := readFrame(r, &extra); !errors.Is(err, io.EOF) {
+		t.Fatalf("after two frames: err = %v, want io.EOF", err)
+	}
+}
+
+// A body that is not JSON is an error, not a zero value. The peer is either
+// broken or not speaking this protocol; either way the caller must not read
+// on as though it decoded.
+func TestReadFrameRejectsNonJSONBody(t *testing.T) {
+	var buf bytes.Buffer
+	var hdr [4]byte
+	body := []byte("not json at all")
+	binary.BigEndian.PutUint32(hdr[:], uint32(len(body)))
+	buf.Write(hdr[:])
+	buf.Write(body)
+
+	var got map[string]string
+	if err := readFrame(&buf, &got); err == nil {
+		t.Fatal("a non-JSON body must fail")
+	}
+}

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/maperr_test.go

@@ -0,0 +1,148 @@
+package ipc
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io/fs"
+	"strings"
+	"testing"
+
+	"github.com/kami/maven/internal/store"
+)
+
+// mapErr turns a store sentinel into its wire twin so a module can errors.Is
+// without importing internal/store. The design is right and the failure mode is
+// quiet: add a sentinel to store, forget the switch, and the client gets an
+// untyped error that no caller can branch on. These two tests are the alarm.
+
+// mapErrPairs — every store sentinel that has a wire twin, and the twin.
+var mapErrPairs = []struct {
+	name  string // the store identifier, for the coverage test below
+	from  error
+	wants error
+}{
+	{"ErrNoFact", store.ErrNoFact, ErrNoFact},
+	{"ErrConfidence", store.ErrConfidence, ErrConfidence},
+	{"ErrVoidsMissing", store.ErrVoidsMissing, ErrVoidsMissing},
+	{"ErrNudgeNotFound", store.ErrNudgeNotFound, ErrNudgeNotFound},
+	{"ErrNudgeOutcome", store.ErrNudgeOutcome, ErrNudgeOutcome},
+	{"ErrReminderNotFound", store.ErrReminderNotFound, ErrReminderNotFound},
+	{"ErrReminderState", store.ErrReminderState, ErrReminderState},
+	{"ErrToolNotFound", store.ErrToolNotFound, ErrToolNotFound},
+}
+
+// unmappedStoreErrors — store sentinels that deliberately have no wire twin,
+// each with the reason it stays store-side. A new sentinel is in neither list
+// and fails TestMapErrCoversEveryStoreSentinel, which is the point: whether a
+// module can branch on an error is a decision, not a default.
+var unmappedStoreErrors = map[string]string{
+	"ErrKeyLen":  "unlock path — the key never crosses CoreAPI",
+	"ErrDecrypt": "unlock path — the key never crosses CoreAPI",
+
+	"ErrToolCmd": "write-side validation of an allowlist mutation; the caller is the owner at a step-up, not a module branching on the verdict",
+
+	"ErrProposedRoutineNotFound": "no module branches on a routine id that vanished; accept and dismiss are owner clicks",
+	"ErrProposedRoutineExists":   "the propose path already reports 'nothing new' through its bool return",
+	"ErrRoutineStatus":           "an unknown status is a caller bug, not a state a module recovers from",
+
+	"ErrTaskNotFound": "the task surfaces re-list rather than branch",
+	"ErrTaskEmpty":    "input validation — the surface refuses empty text before it gets here",
+	"ErrTaskStatus":   "an illegal status move is a caller bug; the surface offers only legal ones",
+}
+
+// The mapping itself, through a wrap, because every real caller wraps.
+func TestMapErrMapsEveryPair(t *testing.T) {
+	for _, p := range mapErrPairs {
+		got := mapErr(fmt.Errorf("storeapi: %w", p.from))
+		if got != p.wants {
+			t.Errorf("mapErr(store.%s) = %v, want %v", p.name, got, p.wants)
+		}
+	}
+}
+
+// Anything mapErr does not recognise passes through untouched. A module that
+// cannot branch on an error must still see the original text.
+func TestMapErrPassesUnknownThrough(t *testing.T) {
+	if mapErr(nil) != nil {
+		t.Error("mapErr(nil) must stay nil")
+	}
+	own := fmt.Errorf("socket closed")
+	if got := mapErr(own); got != own {
+		t.Errorf("mapErr(%v) = %v, want the same error back", own, got)
+	}
+}
+
+// The parity half: every exported sentinel in internal/store is either mapped
+// or listed with a reason. Read off the source, so a sentinel added in a file
+// this package never touches still trips it.
+func TestMapErrCoversEveryStoreSentinel(t *testing.T) {
+	mapped := map[string]bool{}
+	for _, p := range mapErrPairs {
+		mapped[p.name] = true
+	}
+
+	for _, name := range storeSentinelNames(t) {
+		if mapped[name] || unmappedStoreErrors[name] != "" {
+			continue
+		}
+		t.Errorf("store.%s is a new sentinel with no verdict: add it to mapErr and mapErrPairs, "+
+			"or to unmappedStoreErrors with the reason a module cannot branch on it", name)
+	}
+}
+
+// storeSentinelNames reads internal/store for exported package-level error
+// values: `var ErrX = errors.New(...)`, inside a block or on its own.
+func storeSentinelNames(t *testing.T) []string {
+	t.Helper()
+	fset := token.NewFileSet()
+	pkgs, err := parser.ParseDir(fset, "../store", func(fi fs.FileInfo) bool {
+		return !strings.HasSuffix(fi.Name(), "_test.go")
+	}, 0)
+	if err != nil {
+		t.Fatalf("parse internal/store: %v", err)
+	}
+	var out []string
+	for _, pkg := range pkgs {
+		for _, f := range pkg.Files {
+			for _, d := range f.Decls {
+				gd, ok := d.(*ast.GenDecl)
+				if !ok || gd.Tok != token.VAR {
+					continue
+				}
+				for _, spec := range gd.Specs {
+					vs, ok := spec.(*ast.ValueSpec)
+					if !ok {
+						continue
+					}
+					for i, n := range vs.Names {
+						if !strings.HasPrefix(n.Name, "Err") || !n.IsExported() {
+							continue
+						}
+						if i < len(vs.Values) && isErrorsNew(vs.Values[i]) {
+							out = append(out, n.Name)
+						}
+					}
+				}
+			}
+		}
+	}
+	if len(out) < len(mapErrPairs) {
+		t.Fatalf("found %d sentinels in internal/store, fewer than the %d already mapped — the scan is broken, not the store", len(out), len(mapErrPairs))
+	}
+	return out
+}
+
+func isErrorsNew(e ast.Expr) bool {
+	call, ok := e.(*ast.CallExpr)
+	if !ok {
+		return false
+	}
+	sel, ok := call.Fun.(*ast.SelectorExpr)
+	if !ok || sel.Sel.Name != "New" {
+		return false
+	}
+	id, ok := sel.X.(*ast.Ident)
+	return ok && id.Name == "errors"
+}

internal/ipc/server.go

@@ -2,9 +2,7 @@ package ipc
 
 import (
 	"context"
-	"database/sql"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"log"
 	"net"
@@ -13,430 +11,9 @@ import (
 	"time"
 
 	"github.com/kami/maven/internal/netaddr"
-	"github.com/kami/maven/internal/store"
 	"golang.org/x/sys/unix"
 )
 
-// storeAPI — adapts *store.Store to CoreAPI. The daemon constructs one of
-// these inside the core process; the socket Server calls it through the
-// CoreAPI interface, so over-the-wire and in-process callers behave
-// identically. The translation here is the only place store sentinels cross
-// the wire: store.ErrNoFact becomes ipc.ErrNoFact, etc. — keeping the module
-// view of errors stable regardless of transport.
-type storeAPI struct {
-	s *store.Store
-}
-
-// NewStoreAPI wraps a *store.Store as a CoreAPI. The store is the sqlcipher-
-// unlocked handle held ONLY in core's address space; this adapter never
-// returns it to a caller — core mediates.
-func NewStoreAPI(s *store.Store) CoreAPI { return &storeAPI{s: s} }
-
-func (a *storeAPI) WriteFact(ctx context.Context, req WriteFactReq) (int64, error) {
-	var voids sql.NullInt64
-	if req.VoidsID != nil {
-		voids = sql.NullInt64{Int64: *req.VoidsID, Valid: true}
-	}
-	id, err := a.s.WriteFactAboutSubject(ctx, req.Ts, store.FactKind(req.Kind), req.Key, req.Subject, req.Value, req.Source, req.Confidence, voids)
-	return id, mapErr(err)
-}
-
-func (a *storeAPI) LatestFact(ctx context.Context, key string) (Fact, error) {
-	f, err := a.s.LatestFact(ctx, key)
-	if err != nil {
-		return Fact{}, mapErr(err)
-	}
-	return toFact(f), nil
-}
-
-func (a *storeAPI) LatestFactBySource(ctx context.Context, key, source string) (Fact, error) {
-	f, err := a.s.LatestFactBySource(ctx, key, source)
-	if err != nil {
-		return Fact{}, mapErr(err)
-	}
-	return toFact(f), nil
-}
-
-func (a *storeAPI) Since(ctx context.Context, key string, now time.Time) (time.Duration, error) {
-	d, err := a.s.Since(ctx, key, now)
-	return d, mapErr(err)
-}
-
-func (a *storeAPI) Presence(ctx context.Context) (Presence, error) {
-	b, score, upd, err := a.s.LoadPresenceState(ctx)
-	if err != nil {
-		return Presence{}, fmt.Errorf("ipc: load presence: %w", err)
-	}
-	return Presence{Bucket: Bucket(b), Score: score, Updated: upd}, nil
-}
-
-func (a *storeAPI) CreateReminder(ctx context.Context, fire time.Time, payload, cron string) (int64, error) {
-	id, err := a.s.CreateReminder(ctx, fire, payload, cron)
-	return id, mapErr(err)
-}
-
-func (a *storeAPI) MarkReminder(ctx context.Context, id int64, status string) error {
-	return mapErr(a.s.MarkReminder(ctx, id, status))
-}
-
-func (a *storeAPI) ListReminders(ctx context.Context, n int) ([]Reminder, error) {
-	rs, err := a.s.ListReminders(ctx, n)
-	if err != nil {
-		return nil, mapErr(err)
-	}
-	out := make([]Reminder, len(rs))
-	for i, r := range rs {
-		out[i] = toReminder(r)
-	}
-	return out, nil
-}
-
-func (a *storeAPI) RescheduleReminder(ctx context.Context, id int64, now time.Time) error {
-	return mapErr(a.s.RescheduleReminder(ctx, id, now))
-}
-
-func (a *storeAPI) RecordNudge(ctx context.Context, rule, channel, message string, ts time.Time) (int64, error) {
-	id, err := a.s.RecordNudge(ctx, rule, channel, message, ts)
-	return id, mapErr(err)
-}
-
-func (a *storeAPI) ResolveNudge(ctx context.Context, id int64, outcome string, ts time.Time) error {
-	return mapErr(a.s.ResolveNudge(ctx, id, outcome, ts))
-}
-
-func (a *storeAPI) RecentOutcomes(ctx context.Context, rule string, n int) ([]string, error) {
-	out, err := a.s.RecentOutcomes(ctx, rule, n)
-	return out, mapErr(err)
-}
-
-func (a *storeAPI) RecentFacts(ctx context.Context, n int) ([]Fact, error) {
-	fs, err := a.s.RecentFacts(ctx, n)
-	if err != nil {
-		return nil, mapErr(err)
-	}
-	out := make([]Fact, len(fs))
-	for i, f := range fs {
-		out[i] = toFact(f)
-	}
-	return out, nil
-}
-
-func (a *storeAPI) RecentActiveFactsByKind(ctx context.Context, kind string, n int) ([]Fact, error) {
-	fs, err := a.s.RecentActiveFactsByKind(ctx, store.FactKind(kind), n)
-	if err != nil {
-		return nil, mapErr(err)
-	}
-	out := make([]Fact, len(fs))
-	for i, f := range fs {
-		out[i] = toFact(f)
-	}
-	return out, nil
-}
-
-func (a *storeAPI) CalendarEvents(ctx context.Context, from, to time.Time) ([]Fact, error) {
-	fs, err := a.s.CalendarEvents(ctx, from, to)
-	if err != nil {
-		return nil, mapErr(err)
-	}
-	out := make([]Fact, len(fs))
-	for i, f := range fs {
-		out[i] = toFact(f)
-	}
-	return out, nil
-}
-
-func (a *storeAPI) RecentEcosystemTraces(ctx context.Context, n int) ([]EcosystemTrace, error) {
-	trs, err := a.s.RecentEcosystemTraces(ctx, n)
-	if err != nil {
-		return nil, mapErr(err)
-	}
-	out := make([]EcosystemTrace, len(trs))
-	for i, tr := range trs {
-		out[i] = EcosystemTrace{
-			ID: tr.ID, Ts: tr.Ts, Service: tr.Service, Operation: tr.Operation,
-			Status: tr.Status, DurationMs: tr.DurationMs, CorrelationID: tr.CorrelationID,
-			CausationID: tr.CausationID, HTTPStatus: tr.HTTPStatus, Fields: tr.Fields,
-		}
-	}
-	return out, nil
-}
-
-func (a *storeAPI) RecentNudges(ctx context.Context, n int) ([]Nudge, error) {
-	ns, err := a.s.RecentNudges(ctx, n)
-	if err != nil {
-		return nil, mapErr(err)
-	}
-	out := make([]Nudge, len(ns))
-	for i, ng := range ns {
-		out[i] = toNudge(ng)
-	}
-	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)
-}
-
-func (a *storeAPI) QueryNotes(ctx context.Context, embedding []float32, k int) ([]Note, error) {
-	ns, err := a.s.QueryNotes(ctx, embedding, k)
-	if err != nil {
-		return nil, mapErr(err)
-	}
-	out := make([]Note, len(ns))
-	for i, n := range ns {
-		out[i] = toNote(n)
-	}
-	return out, nil
-}
-
-func (a *storeAPI) RecentNotesFromSource(ctx context.Context, prefix string, n int) ([]Note, error) {
-	ns, err := a.s.RecentNotesFromSource(ctx, prefix, n)
-	if err != nil {
-		return nil, mapErr(err)
-	}
-	out := make([]Note, len(ns))
-	for i, note := range ns {
-		out[i] = toNote(note)
-	}
-	return out, nil
-}
-
-func (a *storeAPI) RecentNotes(ctx context.Context, n int) ([]Note, error) {
-	ns, err := a.s.RecentNotes(ctx, n)
-	if err != nil {
-		return nil, mapErr(err)
-	}
-	out := make([]Note, len(ns))
-	for i, note := range ns {
-		out[i] = toNote(note)
-	}
-	return out, nil
-}
-
-func (a *storeAPI) ProposeTool(ctx context.Context, name, utterance, scope string, ts time.Time) (bool, error) {
-	ok, err := a.s.ProposeTool(ctx, name, utterance, scope, ts)
-	return ok, mapErr(err)
-}
-
-func (a *storeAPI) EnableTool(ctx context.Context, name string, cmd []string, destructive bool, scope string, ts time.Time) error {
-	return mapErr(a.s.EnableTool(ctx, name, cmd, destructive, scope, ts))
-}
-
-func (a *storeAPI) DisableTool(ctx context.Context, name string) error {
-	return mapErr(a.s.DisableTool(ctx, name))
-}
-
-func (a *storeAPI) LookupTool(ctx context.Context, name string) (Tool, error) {
-	t, err := a.s.LookupTool(ctx, name)
-	if err != nil {
-		return Tool{}, mapErr(err)
-	}
-	return toTool(t), nil
-}
-
-func (a *storeAPI) RevertFact(ctx context.Context, key string) (int64, error) {
-	_, newID, err := a.s.VoidLatestFact(ctx, key, "feedback", time.Now())
-	return newID, mapErr(err)
-}
-
-func (a *storeAPI) Chat(ctx context.Context, text string) (string, error) {
-	return "", errors.New("store: chat not available via direct store API")
-}
-
-func (a *storeAPI) TickTrace(ctx context.Context) (TickTrace, error) {
-	return TickTrace{}, errors.New("store: tick trace not available via direct store API")
-}
-
-func (a *storeAPI) MorningStatus(ctx context.Context) ([]MorningRoutineStatus, error) {
-	return nil, errors.New("store: morning status not available via direct store API")
-}
-
-// RecentEvents — same shape as TickTrace: the intake journal is a bounded ring
-// in the daemon's memory, not a table, so a bare store cannot serve it.
-func (a *storeAPI) RecentEvents(ctx context.Context, n int) ([]IntakeEvent, error) {
-	return nil, errors.New("store: intake events not available via direct store API")
-}
-
-func (a *storeAPI) MCPServers(ctx context.Context) ([]MCPServerStatus, error) {
-	return nil, nil // no manager behind a bare store: nothing configured
-}
-
-func (a *storeAPI) DayPlan(ctx context.Context) (DayPlan, error) {
-	return DayPlan{}, errors.New("store: day plan not available via direct store API")
-}
-
-func (a *storeAPI) ListTools(ctx context.Context, status string) ([]Tool, error) {
-	ts, err := a.s.ListTools(ctx, status)
-	if err != nil {
-		return nil, mapErr(err)
-	}
-	out := make([]Tool, len(ts))
-	for i, t := range ts {
-		out[i] = toTool(t)
-	}
-	return out, nil
-}
-
-func (a *storeAPI) DeleteTool(ctx context.Context, name string) error {
-	return mapErr(a.s.DeleteTool(ctx, name))
-}
-
-func (a *storeAPI) CaptureTask(ctx context.Context, req CaptureTaskReq) (CaptureTaskResp, error) {
-	res, err := a.s.CaptureTask(ctx, store.Task{
-		CreatedTs:  req.Ts,
-		Text:       req.Text,
-		Source:     req.Source,
-		Evidence:   req.Evidence,
-		ExternalID: req.ExternalID,
-		Status:     req.Status,
-		Due:        req.Due,
-		Weight:     req.Weight,
-	})
-	if err != nil {
-		return CaptureTaskResp{}, mapErr(err)
-	}
-	return CaptureTaskResp{ID: res.ID, Created: res.Created, Promoted: res.Promoted}, nil
-}
-
-func (a *storeAPI) ListTasks(ctx context.Context, status string) ([]Task, error) {
-	ts, err := a.s.ListTasks(ctx, status)
-	if err != nil {
-		return nil, mapErr(err)
-	}
-	out := make([]Task, len(ts))
-	for i, t := range ts {
-		out[i] = Task{
-			ID:         t.ID,
-			CreatedTs:  t.CreatedTs,
-			Text:       t.Text,
-			Source:     t.Source,
-			Evidence:   t.Evidence,
-			ExternalID: t.ExternalID,
-			Status:     t.Status,
-			Due:        t.Due,
-			Weight:     t.Weight,
-			Resolved:   t.ResolvedTs,
-			ResolvedBy: t.ResolvedBy,
-		}
-	}
-	return out, nil
-}
-
-func (a *storeAPI) SetTaskStatus(ctx context.Context, id int64, status string, ts time.Time, by string) error {
-	return mapErr(a.s.SetTaskStatus(ctx, id, status, ts, by))
-}
-
-func (a *storeAPI) ListProposedRoutines(ctx context.Context) ([]ProposedRoutine, error) {
-	rs, err := a.s.ListProposedRoutines(ctx)
-	if err != nil {
-		return nil, mapErr(err)
-	}
-	out := make([]ProposedRoutine, len(rs))
-	for i, r := range rs {
-		out[i] = ProposedRoutine{
-			ID:           r.ID,
-			Action:       r.Action,
-			Object:       r.Object,
-			IntervalDays: r.IntervalDays,
-			Status:       r.Status,
-			CreatedTs:    r.CreatedTs.UnixMilli(),
-		}
-		if r.ReminderID != nil {
-			out[i].ReminderID = r.ReminderID
-		}
-	}
-	return out, nil
-}
-
-func (a *storeAPI) DismissProposedRoutine(ctx context.Context, id int64) error {
-	return mapErr(a.s.DismissProposedRoutine(ctx, id))
-}
-
-func (a *storeAPI) AcceptProposedRoutine(ctx context.Context, id int64) error {
-	return mapErr(a.s.AcceptProposedRoutine(ctx, id, time.Now().UTC()))
-}
-
-func toTool(t store.Tool) Tool {
-	return Tool{
-		Name: t.Name, Scope: t.Scope, Cmd: t.Cmd, Destructive: t.Destructive,
-		Status: t.Status, Utterance: t.Utterance, Created: t.CreatedTs, Updated: t.UpdatedTs,
-	}
-}
-
-func toReminder(r store.Reminder) Reminder {
-	return Reminder{
-		ID:         r.ID,
-		CreatedTs:  r.CreatedTs,
-		FireTs:     r.FireTs,
-		NextFireTs: r.NextFireTs,
-		Payload:    r.Payload,
-		Status:     r.Status,
-		Cron:       r.Cron,
-	}
-}
-
-func toNote(n store.Note) Note {
-	return Note{ID: n.ID, Ts: n.Ts, Text: n.Text, Source: n.Source, Score: n.Score}
-}
-
-func toNudge(n store.Nudge) Nudge {
-	out := Nudge{
-		ID: n.ID, Ts: n.Ts, Rule: n.Rule, Channel: n.Channel,
-		Message: n.Message, Outcome: n.Outcome,
-	}
-	if n.OutcomeTs.Valid {
-		v := n.OutcomeTs.Int64
-		out.OutcomeTs = &v
-	}
-	return out
-}
-
-func toFact(f store.Fact) Fact {
-	out := Fact{
-		ID:         f.ID,
-		Ts:         f.Ts,
-		Kind:       string(f.Kind),
-		Key:        f.Key,
-		Value:      f.Value,
-		Source:     f.Source,
-		Confidence: f.Confidence,
-	}
-	if f.VoidsID.Valid {
-		v := f.VoidsID.Int64
-		out.VoidsID = &v
-	}
-	return out
-}
-
-// mapErr — store sentinel ↔ ipc sentinel. An unrecognized store error is
-// wrapped but not mapped (server-side dispatch surfaces it as codeInternal,
-// keeping internal text off the wire except to the daemon log).
-func mapErr(err error) error {
-	if err == nil {
-		return nil
-	}
-	switch {
-	case errors.Is(err, store.ErrNoFact):
-		return ErrNoFact
-	case errors.Is(err, store.ErrConfidence):
-		return ErrConfidence
-	case errors.Is(err, store.ErrVoidsMissing):
-		return ErrVoidsMissing
-	case errors.Is(err, store.ErrNudgeNotFound):
-		return ErrNudgeNotFound
-	case errors.Is(err, store.ErrNudgeOutcome):
-		return ErrNudgeOutcome
-	case errors.Is(err, store.ErrReminderNotFound):
-		return ErrReminderNotFound
-	case errors.Is(err, store.ErrReminderState):
-		return ErrReminderState
-	case errors.Is(err, store.ErrToolNotFound):
-		return ErrToolNotFound
-	}
-	return err
-}
-
 // Server — the core side of the boundary. Listens on a unix domain socket,
 // accepts module connections, frames requests to a CoreAPI and responses back.
 // One Server per daemon process; concurrent connections are handled in their
@@ -863,6 +440,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 +561,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/storeapi.go

@@ -0,0 +1,455 @@
+// ipc/storeapi.go — the sqlite-backed CoreAPI.
+//
+// Split out of server.go, move-only (Vikunja #423). server.go was two
+// unrelated things: this adapter, and the dispatcher that calls it over the
+// socket. Nothing here knows there is a wire.
+package ipc
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/kami/maven/internal/store"
+)
+
+// storeAPI — adapts *store.Store to CoreAPI. The daemon constructs one of
+// these inside the core process; the socket Server calls it through the
+// CoreAPI interface, so over-the-wire and in-process callers behave
+// identically. The translation here is the only place store sentinels cross
+// the wire: store.ErrNoFact becomes ipc.ErrNoFact, etc. — keeping the module
+// view of errors stable regardless of transport.
+type storeAPI struct {
+	s *store.Store
+}
+
+// NewStoreAPI wraps a *store.Store as a CoreAPI. The store is the sqlcipher-
+// unlocked handle held ONLY in core's address space; this adapter never
+// returns it to a caller — core mediates.
+func NewStoreAPI(s *store.Store) CoreAPI { return &storeAPI{s: s} }
+
+func (a *storeAPI) WriteFact(ctx context.Context, req WriteFactReq) (int64, error) {
+	var voids sql.NullInt64
+	if req.VoidsID != nil {
+		voids = sql.NullInt64{Int64: *req.VoidsID, Valid: true}
+	}
+	id, err := a.s.WriteFactAboutSubject(ctx, req.Ts, store.FactKind(req.Kind), req.Key, req.Subject, req.Value, req.Source, req.Confidence, voids)
+	return id, mapErr(err)
+}
+
+func (a *storeAPI) LatestFact(ctx context.Context, key string) (Fact, error) {
+	f, err := a.s.LatestFact(ctx, key)
+	if err != nil {
+		return Fact{}, mapErr(err)
+	}
+	return toFact(f), nil
+}
+
+func (a *storeAPI) LatestFactBySource(ctx context.Context, key, source string) (Fact, error) {
+	f, err := a.s.LatestFactBySource(ctx, key, source)
+	if err != nil {
+		return Fact{}, mapErr(err)
+	}
+	return toFact(f), nil
+}
+
+func (a *storeAPI) Since(ctx context.Context, key string, now time.Time) (time.Duration, error) {
+	d, err := a.s.Since(ctx, key, now)
+	return d, mapErr(err)
+}
+
+func (a *storeAPI) Presence(ctx context.Context) (Presence, error) {
+	b, score, upd, err := a.s.LoadPresenceState(ctx)
+	if err != nil {
+		return Presence{}, fmt.Errorf("ipc: load presence: %w", err)
+	}
+	return Presence{Bucket: Bucket(b), Score: score, Updated: upd}, nil
+}
+
+func (a *storeAPI) CreateReminder(ctx context.Context, fire time.Time, payload, cron string) (int64, error) {
+	id, err := a.s.CreateReminder(ctx, fire, payload, cron)
+	return id, mapErr(err)
+}
+
+func (a *storeAPI) MarkReminder(ctx context.Context, id int64, status string) error {
+	return mapErr(a.s.MarkReminder(ctx, id, status))
+}
+
+func (a *storeAPI) ListReminders(ctx context.Context, n int) ([]Reminder, error) {
+	rs, err := a.s.ListReminders(ctx, n)
+	if err != nil {
+		return nil, mapErr(err)
+	}
+	out := make([]Reminder, len(rs))
+	for i, r := range rs {
+		out[i] = toReminder(r)
+	}
+	return out, nil
+}
+
+func (a *storeAPI) RescheduleReminder(ctx context.Context, id int64, now time.Time) error {
+	return mapErr(a.s.RescheduleReminder(ctx, id, now))
+}
+
+func (a *storeAPI) RecordNudge(ctx context.Context, rule, channel, message string, ts time.Time) (int64, error) {
+	id, err := a.s.RecordNudge(ctx, rule, channel, message, ts)
+	return id, mapErr(err)
+}
+
+func (a *storeAPI) ResolveNudge(ctx context.Context, id int64, outcome string, ts time.Time) error {
+	return mapErr(a.s.ResolveNudge(ctx, id, outcome, ts))
+}
+
+func (a *storeAPI) RecentOutcomes(ctx context.Context, rule string, n int) ([]string, error) {
+	out, err := a.s.RecentOutcomes(ctx, rule, n)
+	return out, mapErr(err)
+}
+
+func (a *storeAPI) RecentFacts(ctx context.Context, n int) ([]Fact, error) {
+	fs, err := a.s.RecentFacts(ctx, n)
+	if err != nil {
+		return nil, mapErr(err)
+	}
+	out := make([]Fact, len(fs))
+	for i, f := range fs {
+		out[i] = toFact(f)
+	}
+	return out, nil
+}
+
+func (a *storeAPI) RecentActiveFactsByKind(ctx context.Context, kind string, n int) ([]Fact, error) {
+	fs, err := a.s.RecentActiveFactsByKind(ctx, store.FactKind(kind), n)
+	if err != nil {
+		return nil, mapErr(err)
+	}
+	out := make([]Fact, len(fs))
+	for i, f := range fs {
+		out[i] = toFact(f)
+	}
+	return out, nil
+}
+
+func (a *storeAPI) CalendarEvents(ctx context.Context, from, to time.Time) ([]Fact, error) {
+	fs, err := a.s.CalendarEvents(ctx, from, to)
+	if err != nil {
+		return nil, mapErr(err)
+	}
+	out := make([]Fact, len(fs))
+	for i, f := range fs {
+		out[i] = toFact(f)
+	}
+	return out, nil
+}
+
+func (a *storeAPI) RecentEcosystemTraces(ctx context.Context, n int) ([]EcosystemTrace, error) {
+	trs, err := a.s.RecentEcosystemTraces(ctx, n)
+	if err != nil {
+		return nil, mapErr(err)
+	}
+	out := make([]EcosystemTrace, len(trs))
+	for i, tr := range trs {
+		out[i] = EcosystemTrace{
+			ID: tr.ID, Ts: tr.Ts, Service: tr.Service, Operation: tr.Operation,
+			Status: tr.Status, DurationMs: tr.DurationMs, CorrelationID: tr.CorrelationID,
+			CausationID: tr.CausationID, HTTPStatus: tr.HTTPStatus, Fields: tr.Fields,
+		}
+	}
+	return out, nil
+}
+
+func (a *storeAPI) RecentNudges(ctx context.Context, n int) ([]Nudge, error) {
+	ns, err := a.s.RecentNudges(ctx, n)
+	if err != nil {
+		return nil, mapErr(err)
+	}
+	out := make([]Nudge, len(ns))
+	for i, ng := range ns {
+		out[i] = toNudge(ng)
+	}
+	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)
+}
+
+func (a *storeAPI) QueryNotes(ctx context.Context, embedding []float32, k int) ([]Note, error) {
+	ns, err := a.s.QueryNotes(ctx, embedding, k)
+	if err != nil {
+		return nil, mapErr(err)
+	}
+	out := make([]Note, len(ns))
+	for i, n := range ns {
+		out[i] = toNote(n)
+	}
+	return out, nil
+}
+
+func (a *storeAPI) RecentNotesFromSource(ctx context.Context, prefix string, n int) ([]Note, error) {
+	ns, err := a.s.RecentNotesFromSource(ctx, prefix, n)
+	if err != nil {
+		return nil, mapErr(err)
+	}
+	out := make([]Note, len(ns))
+	for i, note := range ns {
+		out[i] = toNote(note)
+	}
+	return out, nil
+}
+
+func (a *storeAPI) RecentNotes(ctx context.Context, n int) ([]Note, error) {
+	ns, err := a.s.RecentNotes(ctx, n)
+	if err != nil {
+		return nil, mapErr(err)
+	}
+	out := make([]Note, len(ns))
+	for i, note := range ns {
+		out[i] = toNote(note)
+	}
+	return out, nil
+}
+
+func (a *storeAPI) ProposeTool(ctx context.Context, name, utterance, scope string, ts time.Time) (bool, error) {
+	ok, err := a.s.ProposeTool(ctx, name, utterance, scope, ts)
+	return ok, mapErr(err)
+}
+
+func (a *storeAPI) EnableTool(ctx context.Context, name string, cmd []string, destructive bool, scope string, ts time.Time) error {
+	return mapErr(a.s.EnableTool(ctx, name, cmd, destructive, scope, ts))
+}
+
+func (a *storeAPI) DisableTool(ctx context.Context, name string) error {
+	return mapErr(a.s.DisableTool(ctx, name))
+}
+
+func (a *storeAPI) LookupTool(ctx context.Context, name string) (Tool, error) {
+	t, err := a.s.LookupTool(ctx, name)
+	if err != nil {
+		return Tool{}, mapErr(err)
+	}
+	return toTool(t), nil
+}
+
+func (a *storeAPI) RevertFact(ctx context.Context, key string) (int64, error) {
+	_, newID, err := a.s.VoidLatestFact(ctx, key, "feedback", time.Now())
+	return newID, mapErr(err)
+}
+
+func (a *storeAPI) Chat(ctx context.Context, conversation, text string) (string, error) {
+	return "", errors.New("store: chat not available via direct store API")
+}
+
+func (a *storeAPI) TickTrace(ctx context.Context) (TickTrace, error) {
+	return TickTrace{}, errors.New("store: tick trace not available via direct store API")
+}
+
+func (a *storeAPI) MorningStatus(ctx context.Context) ([]MorningRoutineStatus, error) {
+	return nil, errors.New("store: morning status not available via direct store API")
+}
+
+// RecentEvents — same shape as TickTrace: the intake journal is a bounded ring
+// in the daemon's memory, not a table, so a bare store cannot serve it.
+func (a *storeAPI) RecentEvents(ctx context.Context, n int) ([]IntakeEvent, error) {
+	return nil, errors.New("store: intake events not available via direct store API")
+}
+
+func (a *storeAPI) MCPServers(ctx context.Context) ([]MCPServerStatus, error) {
+	return nil, nil // no manager behind a bare store: nothing configured
+}
+
+func (a *storeAPI) DayPlan(ctx context.Context) (DayPlan, error) {
+	return DayPlan{}, errors.New("store: day plan not available via direct store API")
+}
+
+func (a *storeAPI) ListTools(ctx context.Context, status string) ([]Tool, error) {
+	ts, err := a.s.ListTools(ctx, status)
+	if err != nil {
+		return nil, mapErr(err)
+	}
+	out := make([]Tool, len(ts))
+	for i, t := range ts {
+		out[i] = toTool(t)
+	}
+	return out, nil
+}
+
+func (a *storeAPI) DeleteTool(ctx context.Context, name string) error {
+	return mapErr(a.s.DeleteTool(ctx, name))
+}
+
+func (a *storeAPI) CaptureTask(ctx context.Context, req CaptureTaskReq) (CaptureTaskResp, error) {
+	res, err := a.s.CaptureTask(ctx, store.Task{
+		CreatedTs:  req.Ts,
+		Text:       req.Text,
+		Source:     req.Source,
+		Evidence:   req.Evidence,
+		ExternalID: req.ExternalID,
+		Status:     req.Status,
+		Due:        req.Due,
+		Weight:     req.Weight,
+	})
+	if err != nil {
+		return CaptureTaskResp{}, mapErr(err)
+	}
+	return CaptureTaskResp{ID: res.ID, Created: res.Created, Promoted: res.Promoted}, nil
+}
+
+func (a *storeAPI) ListTasks(ctx context.Context, status string) ([]Task, error) {
+	ts, err := a.s.ListTasks(ctx, status)
+	if err != nil {
+		return nil, mapErr(err)
+	}
+	out := make([]Task, len(ts))
+	for i, t := range ts {
+		out[i] = Task{
+			ID:         t.ID,
+			CreatedTs:  t.CreatedTs,
+			Text:       t.Text,
+			Source:     t.Source,
+			Evidence:   t.Evidence,
+			ExternalID: t.ExternalID,
+			Status:     t.Status,
+			Due:        t.Due,
+			Weight:     t.Weight,
+			Resolved:   t.ResolvedTs,
+			ResolvedBy: t.ResolvedBy,
+		}
+	}
+	return out, nil
+}
+
+func (a *storeAPI) SetTaskStatus(ctx context.Context, id int64, status string, ts time.Time, by string) error {
+	return mapErr(a.s.SetTaskStatus(ctx, id, status, ts, by))
+}
+
+func (a *storeAPI) ListProposedRoutines(ctx context.Context) ([]ProposedRoutine, error) {
+	rs, err := a.s.ListProposedRoutines(ctx)
+	if err != nil {
+		return nil, mapErr(err)
+	}
+	out := make([]ProposedRoutine, len(rs))
+	for i, r := range rs {
+		out[i] = ProposedRoutine{
+			ID:           r.ID,
+			Action:       r.Action,
+			Object:       r.Object,
+			IntervalDays: r.IntervalDays,
+			Status:       string(r.Status),
+			CreatedTs:    r.CreatedTs.UnixMilli(),
+		}
+		if r.ReminderID != nil {
+			out[i].ReminderID = r.ReminderID
+		}
+	}
+	return out, nil
+}
+
+func (a *storeAPI) DismissProposedRoutine(ctx context.Context, id int64) error {
+	return mapErr(a.s.DismissProposedRoutine(ctx, id))
+}
+
+func (a *storeAPI) AcceptProposedRoutine(ctx context.Context, id int64) error {
+	return mapErr(a.s.AcceptProposedRoutine(ctx, id, time.Now().UTC()))
+}
+
+func toTool(t store.Tool) Tool {
+	return Tool{
+		Name: t.Name, Scope: t.Scope, Cmd: t.Cmd, Destructive: t.Destructive,
+		Status: t.Status, Utterance: t.Utterance, Created: t.CreatedTs, Updated: t.UpdatedTs,
+	}
+}
+
+func toReminder(r store.Reminder) Reminder {
+	return Reminder{
+		ID:         r.ID,
+		CreatedTs:  r.CreatedTs,
+		FireTs:     r.FireTs,
+		NextFireTs: r.NextFireTs,
+		Payload:    r.Payload,
+		Status:     r.Status,
+		Cron:       r.Cron,
+	}
+}
+
+func toNote(n store.Note) Note {
+	return Note{ID: n.ID, Ts: n.Ts, Text: n.Text, Source: n.Source, Score: n.Score}
+}
+
+func toNudge(n store.Nudge) Nudge {
+	out := Nudge{
+		ID: n.ID, Ts: n.Ts, Rule: n.Rule, Channel: n.Channel,
+		Message: n.Message, Outcome: n.Outcome,
+	}
+	if n.OutcomeTs.Valid {
+		v := n.OutcomeTs.Int64
+		out.OutcomeTs = &v
+	}
+	return out
+}
+
+func toFact(f store.Fact) Fact {
+	out := Fact{
+		ID:         f.ID,
+		Ts:         f.Ts,
+		Kind:       string(f.Kind),
+		Key:        f.Key,
+		Value:      f.Value,
+		Source:     f.Source,
+		Confidence: f.Confidence,
+	}
+	if f.VoidsID.Valid {
+		v := f.VoidsID.Int64
+		out.VoidsID = &v
+	}
+	return out
+}
+
+// mapErr — store sentinel ↔ ipc sentinel. An unrecognized store error is
+// wrapped but not mapped (server-side dispatch surfaces it as codeInternal,
+// keeping internal text off the wire except to the daemon log).
+func mapErr(err error) error {
+	if err == nil {
+		return nil
+	}
+	switch {
+	case errors.Is(err, store.ErrNoFact):
+		return ErrNoFact
+	case errors.Is(err, store.ErrConfidence):
+		return ErrConfidence
+	case errors.Is(err, store.ErrVoidsMissing):
+		return ErrVoidsMissing
+	case errors.Is(err, store.ErrNudgeNotFound):
+		return ErrNudgeNotFound
+	case errors.Is(err, store.ErrNudgeOutcome):
+		return ErrNudgeOutcome
+	case errors.Is(err, store.ErrReminderNotFound):
+		return ErrReminderNotFound
+	case errors.Is(err, store.ErrReminderState):
+		return ErrReminderState
+	case errors.Is(err, store.ErrToolNotFound):
+		return ErrToolNotFound
+	}
+	return err
+}

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/loop/explain_test.go

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

internal/loop/gate_test.go

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

internal/loop/gather.go

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

internal/loop/gather_test.go

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

internal/loop/loop_test.go

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

internal/loop/rules.go

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

internal/loop/rules_test.go

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

internal/loop/state.go

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

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

internal/phraser/phraser.go

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

internal/phraser/phraser_test.go

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