phraser: say "даже не знаю, что сказать" when there is nothing to say (V-397)

Review of #108: "поговорили." reads as a summary of a conversation that did
not happen. One exported constant now, so the Stub, the LLMPhraser fallback
and the daemon all say the same thing.

internal/voice/replier.go keeps its own copy — that is the separate replier
seam, not this one.

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

Makefile

@@ -16,7 +16,7 @@ PIPER_BIN     := $(shell pwd)/deps/piper/piper
 PIPER_MODEL   := $(shell pwd)/models/tts/ru_RU-irina-medium.onnx
 PIPER_ESPEAK  := $(shell pwd)/deps/piper/espeak-ng-data
 
-.PHONY: simulate stt-fixtures test-stt-golden all build build-stt build-tts build-daemon build-client build-waked build-web build-poll build-caldav clean test fmt-check vet run-stt run-tts run-web download-embedder deps-go deps-sentinel tidy eval-router eval-recall eval-phrasing eval-models build-gpud
+.PHONY: simulate stt-fixtures test-stt-golden all build build-stt build-tts build-daemon build-client build-waked build-web build-poll build-caldav clean test fmt-check vet run-stt run-tts run-web download-embedder deps-go eval-router eval-recall eval-phrasing eval-models build-gpud
 
 all: build
 
@@ -74,7 +74,7 @@ run-web: build-web
 # base.Tool(), which only stats pkg/tool and exits. So build them in once here.
 GO_TARBALL := go$(GO_VERSION).linux-amd64.tar.gz
 GO_SHA256  := 9e9b755d63b36acf30c12a9a3fc379243714c1c6d3dd72861da637f336ebb35b
-deps-go: deps-sentinel
+deps-go:
 	@mkdir -p deps/go
 	cd deps/go && curl -fLO 'https://go.dev/dl/$(GO_TARBALL)'
 	cd deps/go && echo '$(GO_SHA256)  $(GO_TARBALL)' | sha256sum -c -
@@ -84,25 +84,6 @@ deps-go: deps-sentinel
 	done
 	$(GO) version
 
-# deps/go.mod — the sentinel that stops the module walk at deps/ (Vikunja #454).
-# The vendored toolchain lives inside the module tree, so `go mod tidy` walked
-# Go's own compiler-error fixtures and died on files that are malformed on
-# purpose ("unicode//utf8": double slash). A nested module is not part of the
-# parent, so one three-line file ends the walk. deps/ is gitignored, so it is
-# generated here rather than committed, and every target that populates deps/
-# writes it.
-deps-sentinel:
-	@mkdir -p deps
-	@printf 'module github.com/kami/maven/deps\n\ngo 1.21\n' > deps/go.mod
-
-# Run the tidy the sentinel makes possible. Not part of `test`: it rewrites
-# go.mod, and a build target that edits the module file is a surprise.
-# vendor/ is committed, so a tidy that drops a requirement must be followed by
-# a re-vendor or the next build fails on "inconsistent vendoring".
-tidy: deps-sentinel
-	GOTOOLCHAIN=local GOFLAGS=-mod=mod $(GO) mod tidy
-	GOTOOLCHAIN=local GOFLAGS=-mod=mod $(GO) mod vendor
-
 # fmt-check fails if any file needs gofmt. docs/design.md has always said `make
 # test` gates on gofmt and vet; it did not, so nine files quietly drifted.
 # Run `gofmt -w` on whatever this prints.
@@ -197,7 +178,7 @@ run-tts: build-tts
 		./mavttsd -socket /tmp/maven/tts.sock \
 			-piper $(PIPER_BIN) -model $(PIPER_MODEL) -espeak_data $(PIPER_ESPEAK)
 
-deps: deps-sentinel deps-whisper deps-piper
+deps: deps-whisper deps-piper
 
 deps-whisper:
 	cd deps/whisper.cpp && cmake -B build -DCMAKE_BUILD_TYPE=Release \

cmd/mavend/actions.go

@@ -40,6 +40,7 @@ import (
 	"context"
 	"log"
 
+	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 )
 
@@ -57,14 +58,15 @@ var actionHandlers = map[router.Intent]func(*reactiveHandler, context.Context, r
 func (h *reactiveHandler) actionChat(ctx context.Context, dec router.Decision) string {
 	// Conversational: build history from dialogue session (prior user turns)
 	// and let the LLM respond from general knowledge + context.
-	if h.phraser == nil {
-		return "поговорили."
-	}
 	history := h.chatHistory()
+	// The phraser hands back its own fallback text alongside the error, so the
+	// turn survives a dead server and the failure still reaches the log.
 	reply, err := h.phraser.PhraseChat(ctx, dec.Utterance, history)
 	if err != nil {
 		log.Printf("voice: chat: %v", err)
-		return "поговорили."
+	}
+	if reply == "" {
+		return phraser.ChatFallback
 	}
 	return reply
 }

cmd/mavend/actions_fact.go

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

cmd/mavend/actions_query.go

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

cmd/mavend/actions_reminder.go

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

cmd/mavend/attentionq.go

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

cmd/mavend/attentionq_test.go

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

cmd/mavend/clarify.go

@@ -33,10 +33,19 @@ var wantedSlots = map[router.Intent][]dialogue.Slot{
 	router.IntentAct:      {dialogue.SlotFn},
 }
 
-// The questions themselves live in clarifytemplates.go, one list per slot,
-// picked by attempt (Vikunja #457). The first ask is the short one this map
-// used to hold; a re-ask says it differently, because a question he already
-// failed to answer is the worst one to repeat unchanged.
+// clarifyQuestions — one short question per missing slot.
+//
+// These are fixed templates, not model output. The resident model is a 0.8B; it
+// would wander, and a question whose wording changes every time is harder to
+// answer than a blunt one that always reads the same. They are infinitive
+// questions, so there is no gender agreement to get wrong; the feminine
+// self-reference lives in the reply she gives when she drops the request.
+var clarifyQuestions = map[dialogue.Slot]string{
+	dialogue.SlotTime: "Когда?",
+	dialogue.SlotText: "О чём напомнить?",
+	dialogue.SlotKey:  "Что записать?",
+	dialogue.SlotFn:   "Что сделать?",
+}
 
 // clarifyGaveUp — she is out of questions and still does not have the slot. She
 // says so out loud: dropping the request in silence would leave him thinking it
@@ -97,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(ctx context.Context) string {
+func (h *reactiveHandler) clarifyExpiredNotice() string {
 	if h.clarifyStore == nil {
 		return ""
 	}
-	if !h.clarifyStore.TakeExpired(dialogueIDOf(ctx), h.now()) {
+	if !h.clarifyStore.TakeExpired(voiceDialogueID, h.now()) {
 		return ""
 	}
 	log.Printf("voice: clarify — parked question expired, telling him and routing the words fresh")
@@ -138,7 +147,7 @@ func clarifyQuestion(dec router.Decision) (dialogue.Slot, string, bool) {
 	if len(missing) == 0 {
 		return "", "", false
 	}
-	q, ok := clarifyQuestionFor(missing[0], 1)
+	q, ok := clarifyQuestions[missing[0]]
 	if !ok {
 		return "", "", false
 	}
@@ -148,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(ctx context.Context, dec router.Decision) (string, bool) {
+func (h *reactiveHandler) askClarify(dec router.Decision) (string, bool) {
 	if h.clarifyStore == nil {
 		return "", false
 	}
@@ -156,7 +165,7 @@ func (h *reactiveHandler) askClarify(ctx context.Context, dec router.Decision) (
 	if !ok {
 		return "", false
 	}
-	h.clarifyStore.Put(dialogueIDOf(ctx), &dialogue.PendingQuestion{
+	h.clarifyStore.Put(voiceDialogueID, &dialogue.PendingQuestion{
 		Intent:      dialogue.Intent(dec.Intent),
 		Slots:       toDialogueSlots(dec.Slots),
 		Missing:     []dialogue.Slot{slot},
@@ -183,7 +192,7 @@ func (h *reactiveHandler) resolveClarifyAnswer(ctx context.Context, text string)
 	if h.clarifyStore == nil {
 		return "", false
 	}
-	q := h.clarifyStore.Get(dialogueIDOf(ctx), h.now())
+	q := h.clarifyStore.Get(voiceDialogueID, h.now())
 	if q == nil {
 		return "", false
 	}
@@ -197,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(ctx, q, merged, text), true
+		return h.reaskOrGiveUp(q, merged, text), true
 	}
-	h.clarifyStore.Delete(dialogueIDOf(ctx))
+	h.clarifyStore.Delete(voiceDialogueID)
 
 	// 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
@@ -208,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(ctx, q, intent, merged); asked {
+	if reply, asked := h.askRemainingGap(q, intent, merged); asked {
 		return reply, true
 	}
 
@@ -252,18 +261,16 @@ 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(ctx context.Context, q *dialogue.PendingQuestion, intent router.Intent, merged dialogue.Slots) (string, bool) {
+func (h *reactiveHandler) askRemainingGap(q *dialogue.PendingQuestion, intent router.Intent, merged dialogue.Slots) (string, bool) {
 	remaining := dialogue.StillMissing(wantedSlots[intent], merged)
 	if len(remaining) == 0 {
 		return "", false
 	}
-	// Attempts+1 is the question she is about to ask, and the budget is shared
-	// with the re-ask path, so the second gap is worded like a second try.
-	question, ok := clarifyQuestionFor(remaining[0], q.Attempts+1)
+	question, ok := clarifyQuestions[remaining[0]]
 	if !ok || !q.CanAsk() {
 		return "", false
 	}
-	h.clarifyStore.Put(dialogueIDOf(ctx), &dialogue.PendingQuestion{
+	h.clarifyStore.Put(voiceDialogueID, &dialogue.PendingQuestion{
 		Intent:      q.Intent,
 		Slots:       merged,
 		Missing:     []dialogue.Slot{remaining[0]},
@@ -280,13 +287,13 @@ func (h *reactiveHandler) askRemainingGap(ctx context.Context, q *dialogue.Pendi
 // reaskOrGiveUp handles an answer that left the gap open: ask the same question
 // again while she has attempts left, otherwise say she did not understand and
 // let the request go. Never returns "" — a mute give-up reads as "done".
-func (h *reactiveHandler) reaskOrGiveUp(ctx context.Context, q *dialogue.PendingQuestion, merged dialogue.Slots, text string) string {
+func (h *reactiveHandler) reaskOrGiveUp(q *dialogue.PendingQuestion, merged dialogue.Slots, text string) string {
 	question := ""
 	if len(q.Missing) > 0 {
-		question, _ = clarifyQuestionFor(q.Missing[0], q.Attempts+1)
+		question = clarifyQuestions[q.Missing[0]]
 	}
 	if question == "" || !q.CanAsk() {
-		h.clarifyStore.Delete(dialogueIDOf(ctx))
+		h.clarifyStore.Delete(voiceDialogueID)
 		log.Printf("voice: clarify — gave up on %v after %d question(s), answer was %q", q.Missing, q.Attempts, text)
 		return clarifyGaveUp
 	}
@@ -295,7 +302,7 @@ func (h *reactiveHandler) reaskOrGiveUp(ctx context.Context, q *dialogue.Pending
 	q.Slots = merged
 	q.Attempts++
 	q.Asked = h.now()
-	h.clarifyStore.Put(dialogueIDOf(ctx), q)
+	h.clarifyStore.Put(voiceDialogueID, 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(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме"))
+	question, asked := h.askClarify(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(ctx, clarifyDec(router.IntentFact, router.Slots{Text: "запиши"}, "запиши")); !asked {
+	if _, asked := h.askClarify(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(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
+	if _, asked := h.askClarify(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(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
+	if _, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
 		t.Fatal("expected a first question")
 	}
 	// Two more unclear answers ⇒ two more questions (3 asks in total).
@@ -156,14 +156,8 @@ func TestClarifyAsksThreeTimesThenSaysSo(t *testing.T) {
 		if !handled {
 			t.Fatalf("answer %d must be consumed as an answer", i)
 		}
-		// The wording changes with the attempt (Vikunja #457): repeating a
-		// question he already failed to answer is the worst way to ask it.
-		want, _ := clarifyQuestionFor(dialogue.SlotTime, i)
-		if reply != want {
-			t.Fatalf("attempt %d should ask again as %q, got %q", i, want, reply)
-		}
-		if first, _ := clarifyQuestionFor(dialogue.SlotTime, 1); reply == first {
-			t.Fatalf("attempt %d repeated the first wording: %q", i, reply)
+		if reply != "Когда?" {
+			t.Fatalf("attempt %d should ask again, got %q", i, reply)
 		}
 		if h.clarifyStore.Get(voiceDialogueID, h.now()) == nil {
 			t.Fatalf("attempt %d must leave the question armed", i)
@@ -191,7 +185,7 @@ func TestClarifyMaxAttemptsIsConfigurable(t *testing.T) {
 	h, _, _ := newClarifyHandler(t)
 	h.clarifyMaxAttempts = 1
 
-	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
+	if _, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
 		t.Fatal("expected a question")
 	}
 	if reply, handled := h.resolveClarifyAnswer(ctx, "ну не знаю"); !handled || reply != clarifyGaveUp {
@@ -205,7 +199,7 @@ func TestClarifyRestatedAnswerWins(t *testing.T) {
 	ctx := context.Background()
 	h, st, _ := newClarifyHandler(t)
 
-	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме")); !asked {
+	if _, asked := h.askClarify(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:
@@ -238,7 +232,7 @@ func TestClarifiedActOffAllowlistIsStillRefused(t *testing.T) {
 	h, st, _ := newClarifyHandler(t)
 	marker := filepath.Join(t.TempDir(), "not-allowed-ran")
 
-	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentAct, router.Slots{Text: "сделай это"}, "сделай это")); !asked {
+	if _, asked := h.askClarify(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)
@@ -266,7 +260,7 @@ func TestClarifiedDestructiveActStillNeedsConfirm(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentAct, router.Slots{Text: "сделай это"}, "сделай это")); !asked {
+	if _, asked := h.askClarify(clarifyDec(router.IntentAct, router.Slots{Text: "сделай это"}, "сделай это")); !asked {
 		t.Fatal("expected a question")
 	}
 	reply, handled := h.resolveClarifyAnswer(ctx, "delete_backups")
@@ -290,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(context.Background(), dec); asked {
+		if question, asked := h.askClarify(dec); asked {
 			t.Fatalf("intent %s should keep the canned reply, got %q", dec.Intent, question)
 		}
 	}
@@ -302,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 := withDialogueID(context.Background(), dialogueIDFor(sourceText, ""))
+	ctx := context.Background()
 	h, _, now := newClarifyHandler(t)
 	emb := router.NewHashEmbedder(1024)
 	h.embedder = emb
 	h.router = buildRouter(emb, h.matcher, 0.55, nil)
 
-	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
+	if _, asked := h.askClarify(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(textDialogueID, h.now()) != nil {
+	if h.clarifyStore.Get(voiceDialogueID, 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)
 	}
 }
@@ -346,7 +340,7 @@ func TestClarifyAsksAboutTheSecondGapToo(t *testing.T) {
 	ctx := context.Background()
 	h, st, _ := newClarifyHandler(t)
 
-	question, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{}, "напомни"))
+	question, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{}, "напомни"))
 	if !asked || question != "О чём напомнить?" {
 		t.Fatalf("expected the subject question, got %q asked=%v", question, asked)
 	}
@@ -355,11 +349,8 @@ func TestClarifyAsksAboutTheSecondGapToo(t *testing.T) {
 	if !handled {
 		t.Fatal("the answer must be consumed as an answer")
 	}
-	// Second gap, second attempt, so it is the second wording of the time
-	// question — the attempt budget is shared between the two paths.
-	want, _ := clarifyQuestionFor(dialogue.SlotTime, 2)
-	if reply != want {
-		t.Fatalf("a filled subject with no time must ask about the time as %q, got %q", want, reply)
+	if reply != "Когда?" {
+		t.Fatalf("a filled subject with no time must ask about the time, got %q", reply)
 	}
 	q := h.clarifyStore.Get(voiceDialogueID, h.now())
 	if q == nil {
@@ -389,7 +380,7 @@ func TestClarifySecondGapRespectsTheAttemptCap(t *testing.T) {
 	h, _, _ := newClarifyHandler(t)
 	h.clarifyMaxAttempts = 1
 
-	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{}, "напомни")); !asked {
+	if _, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{}, "напомни")); !asked {
 		t.Fatal("expected the subject question")
 	}
 	reply, handled := h.resolveClarifyAnswer(ctx, "позвонить маме")
@@ -420,9 +411,8 @@ func TestClarifyProseHoldsThePersona(t *testing.T) {
 		eval.CheckCringe:    true,
 	}
 	lines := append([]string{clarifyGaveUp}, clarifyExpiredVariants...)
-	lines = append(lines, clarifyMissedVariants...)
-	for _, variants := range clarifyQuestionVariants {
-		lines = append(lines, variants...)
+	for _, q := range clarifyQuestions {
+		lines = append(lines, q)
 	}
 	for _, line := range lines {
 		for _, r := range eval.RunChecks(eval.Case{}, line, "neutral") {
@@ -450,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 := withDialogueID(context.Background(), dialogueIDFor(sourceText, ""))
+	ctx := context.Background()
 	h, _, now := newClarifyHandler(t)
 
-	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked {
+	if _, asked := h.askClarify(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
@@ -461,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)
 	}
@@ -471,96 +461,7 @@ func TestExpiryNoticeSurvivesAConfirmTurn(t *testing.T) {
 	if h.pending != nil {
 		t.Fatal("the confirm must still have been consumed")
 	}
-	if h.clarifyStore.Get(textDialogueID, h.now()) != nil {
+	if h.clarifyStore.Get(voiceDialogueID, 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)
-	}
-	// The hour is the fire time, not a word in the body: the body is what she
-	// says at the hour, and the time expression is stripped out of it
-	// (Vikunja #469). Clobbering the parked request would show up here as a
-	// reminder that fires at some other time than the one he asked for.
-	if got := reminders[0].FireTs.UTC(); !got.Equal(at.UTC()) {
-		t.Fatalf("the answer clobbered the original request: fires at %v, want %v", got, at.UTC())
-	}
-}
-
-// 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/clarifytemplates.go

@@ -1,109 +0,0 @@
-package main
-
-import (
-	"github.com/kami/maven/internal/dialogue"
-	"github.com/kami/maven/internal/router"
-)
-
-// The clarify copy deck (Vikunja #457).
-//
-// Every clarify turn used to say one sentence per gap, and a re-ask repeated
-// that sentence word for word. A question he already failed to answer is the
-// worst one to ask again unchanged: the second wording is the one that tells
-// him which part she missed.
-//
-// Fixed templates, not model output, for the reason clarifyQuestions has always
-// given: the resident model would wander, and a question whose wording changes
-// at random is harder to answer than a blunt one. What changes here is that the
-// wording varies with the attempt rather than with a die roll — the first ask is
-// short, the second names the gap, the third spells it out.
-//
-// No schema_version, unlike internal/phraser/nudge_templates.go. These are Go
-// constants compiled into the daemon, so there is no file that can drift out of
-// step with the code that reads it.
-//
-// Persona holds: infinitive and imperative questions, so there is no gender
-// agreement to get wrong, "ты" throughout, and no pet names.
-var clarifyQuestionVariants = map[dialogue.Slot][]string{
-	dialogue.SlotTime: {
-		"Когда?",
-		"Во сколько напомнить?",
-		"Скажи время — например, «в семь вечера» или «через час».",
-	},
-	dialogue.SlotText: {
-		"О чём напомнить?",
-		"Что сказать тебе в это время?",
-		"Скажи одной фразой, о чём напомнить.",
-	},
-	dialogue.SlotKey: {
-		"Что записать?",
-		"Что именно отметить?",
-		"Назови, что записать — например, «выпил воды».",
-	},
-	dialogue.SlotFn: {
-		"Что сделать?",
-		"Какое действие выполнить?",
-		"Назови действие — я умею только то, что ты мне разрешил.",
-	},
-}
-
-// clarifyQuestionFor picks the wording for this attempt. attempt is 1-based, as
-// PendingQuestion.Attempts counts it; anything past the list uses the last and
-// most explicit phrasing rather than wrapping round to the short one, because
-// wrapping would ask the same short question he has already not answered.
-//
-// Deterministic on purpose, unlike clarifyExpiredLine: an expiry notice is the
-// same statement however it is worded, and a re-ask is not.
-func clarifyQuestionFor(slot dialogue.Slot, attempt int) (string, bool) {
-	variants, ok := clarifyQuestionVariants[slot]
-	if !ok || len(variants) == 0 {
-		return "", false
-	}
-	i := attempt - 1
-	if i < 0 {
-		i = 0
-	}
-	if i >= len(variants) {
-		i = len(variants) - 1
-	}
-	return variants[i], true
-}
-
-// clarifyMissedVariants — she is asking for the whole utterance again, because
-// the gate fired on an intent with nothing identifiable to ask about (note,
-// query, chat, system are not in wantedSlots).
-//
-// Rotated like the expiry lines and for the same reason: this is the line he
-// hears whenever she misses him completely, so it is a line that repeats, and
-// the same sentence every time is what makes a house assistant sound like a
-// kiosk. All of them say the same two things — she did not catch it, and he
-// should say it again — because the wording may vary and the meaning may not.
-var clarifyMissedVariants = []string{
-	"Не совсем поняла — скажи, пожалуйста, ещё раз.",
-	"Я тебя не разобрала. Повтори, пожалуйста.",
-	"Не уловила. Скажи это по-другому?",
-	"Прости, не поняла — попробуй сказать иначе.",
-}
-
-// clarifyMissedFor picks a wording by the utterance itself, so the same words
-// asked twice get the same answer and two different misses sound different.
-//
-// A hash, not rand: a test that drives an utterance twice must not depend on a
-// die roll, and the point of rotating is only that consecutive misses differ.
-func clarifyMissedFor(utterance string) string {
-	var sum int
-	for _, r := range utterance {
-		sum += int(r)
-	}
-	return clarifyMissedVariants[sum%len(clarifyMissedVariants)]
-}
-
-// clarifyMissedLine is the canned reply for a clarify decision she cannot turn
-// into a question. Returns "" for a decision that is not a clarify, so the
-// caller keeps its own reply.
-func clarifyMissedLine(dec router.Decision) string {
-	if !dec.Clarify {
-		return ""
-	}
-	return clarifyMissedFor(dec.Utterance)
-}

cmd/mavend/clarifytemplates_test.go

@@ -1,63 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	"github.com/kami/maven/internal/dialogue"
-	"github.com/kami/maven/internal/router"
-)
-
-// Every slot she can ask about has a wording for every attempt she is allowed,
-// and no two attempts on one slot read the same. A deck with a repeated line is
-// the defect this deck exists to fix (Vikunja #457).
-func TestClarifyQuestionsVaryByAttempt(t *testing.T) {
-	for slot, variants := range clarifyQuestionVariants {
-		seen := map[string]bool{}
-		for _, v := range variants {
-			if v == "" {
-				t.Errorf("%s: empty wording in the deck", slot)
-			}
-			if seen[v] {
-				t.Errorf("%s: repeated wording %q", slot, v)
-			}
-			seen[v] = true
-		}
-		for attempt := 1; attempt <= len(variants); attempt++ {
-			got, ok := clarifyQuestionFor(slot, attempt)
-			if !ok || got != variants[attempt-1] {
-				t.Errorf("%s attempt %d = %q ok=%v, want %q", slot, attempt, got, ok, variants[attempt-1])
-			}
-		}
-	}
-}
-
-// Past the end she keeps the most explicit wording. Wrapping round would ask
-// the short question he has already not answered twice.
-func TestClarifyQuestionPastTheEndKeepsTheLastWording(t *testing.T) {
-	last := clarifyQuestionVariants[dialogue.SlotTime][len(clarifyQuestionVariants[dialogue.SlotTime])-1]
-	for _, attempt := range []int{0, 4, 9} {
-		if got, _ := clarifyQuestionFor(dialogue.SlotTime, attempt); attempt > 1 && got != last {
-			t.Errorf("attempt %d = %q, want the last wording %q", attempt, got, last)
-		}
-	}
-	if _, ok := clarifyQuestionFor("nonesuch", 1); ok {
-		t.Error("an unknown slot must have no question")
-	}
-}
-
-// The missed line is stable for one utterance and absent for a decision that is
-// not a clarify.
-func TestClarifyMissedLine(t *testing.T) {
-	d := router.Decision{Clarify: true, Utterance: "мгм"}
-	first := clarifyMissedLine(d)
-	if first == "" || first != clarifyMissedLine(d) {
-		t.Fatalf("the missed line must be stable for one utterance, got %q", first)
-	}
-	if got := clarifyMissedLine(router.Decision{Intent: router.IntentNote}); got != "" {
-		t.Errorf("a decision that is not a clarify got %q", got)
-	}
-	// The empty utterance still gets a line: she has to say something.
-	if got := clarifyMissedLine(router.Decision{Clarify: true}); got == "" {
-		t.Error("an empty utterance must still be answered out loud")
-	}
-}

cmd/mavend/ecosystem_acts.go

@@ -514,14 +514,11 @@ 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, subject, nil)
+	entityID, displayName, ambiguous, err := h.ecosystem.resolveEntityReference(ctx, dec.Slots.Text, nil)
 	if err != nil {
 		h.recordEcosystemTrace(ctx, "nexus", "resolve", traceStatusForError(err), started,
-			mergeFields(traceErrorFields(err), map[string]any{"subject": redactSubject(subject)}))
+			mergeFields(traceErrorFields(err), map[string]any{"subject": redactSubject(dec.Slots.Text)}))
 		if unauthorizedEcosystemError(err) {
 			return "экосистема отклоняет доступ, проверь токен."
 		}
@@ -538,7 +535,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(subject)})
+			map[string]any{"subject": redactSubject(dec.Slots.Text)})
 		return ""
 	}
 	h.recordEcosystemTrace(ctx, "nexus", "resolve", traceOK, started,
@@ -572,21 +569,10 @@ 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 {
-		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 {
+		if strings.Contains(strings.ToLower(c.Name), verbLower) ||
+			(c.Description != "" && strings.Contains(strings.ToLower(c.Description), verbLower)) {
 			matches = append(matches, &caps[i])
 		}
 	}
@@ -646,29 +632,3 @@ 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

@@ -1,59 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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/factgate_test.go

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

cmd/mavend/feeds_test.go

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

cmd/mavend/followup.go

@@ -1,64 +1,17 @@
 package main
 
 import (
-	"context"
 	"time"
 
 	"github.com/kami/maven/internal/dialogue"
 	"github.com/kami/maven/internal/router"
 )
 
-// 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).
+// 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).
 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/historyq.go

@@ -1,117 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"strings"
-	"time"
-)
-
-// Command history — "что я тебе говорил?", "что ты записала сегодня?"
-// (Vikunja #456).
-//
-// Read-only over the facts that already exist. No new mechanism and no new
-// storage: everything he tapped in is already a row with a source and a
-// timestamp, and this only reads them back.
-
-// historyMarkers — the ways he asks what he told her. Each entry is a pair of
-// substrings that must BOTH appear, because either half alone is a different
-// question: "что я говорил про сервер" is a recall question the notes pass
-// answers better, and "что ты записала" with no "что" is not a question at all.
-var historyMarkers = [][2]string{
-	{"что я", "говорил"},
-	{"что я", "сказал"},
-	{"что я", "рассказ"},
-	{"что ты", "записал"},
-	{"что ты", "запомнил"},
-	{"что я", "отмечал"},
-	{"что я", "отметил"},
-	{"what did i", "tell"},
-	{"what did you", "record"},
-}
-
-// historyRecall — the word that turns a history question into a recall
-// question. "что я говорил про сервер" names a topic, and the notes pass
-// answers a topic far better than a list of the last five facts does.
-var historyRecall = []string{" про ", " об ", " о ", " about "}
-
-// isHistoryQuery reports whether he is asking what he told her.
-func isHistoryQuery(u string) bool {
-	s := " " + strings.ToLower(strings.TrimSpace(u)) + " "
-	if s == "  " {
-		return false
-	}
-	for _, r := range historyRecall {
-		if strings.Contains(s, r) {
-			return false
-		}
-	}
-	for _, pair := range historyMarkers {
-		if strings.Contains(s, pair[0]) && strings.Contains(s, pair[1]) {
-			return true
-		}
-	}
-	return false
-}
-
-// historyScan — how many recent facts are read before filtering. Deliberately
-// larger than historyReadOut: a poller writing every few minutes would
-// otherwise push everything he said out of the window, the same way his own
-// notes used to crowd out the feed headlines.
-const historyScan = 100
-
-// historyReadOut — how many she says out loud. Five is what fits in one spoken
-// breath; the rest are on /history, which is the surface for reading a list.
-const historyReadOut = 5
-
-// historyWindow — how far back "recently" reaches. A day, because the question
-// is about this conversation and not about the archive.
-const historyWindow = 24 * time.Hour
-
-// queryHistory answers what he told her, from the facts he tapped in.
-//
-// Only "tap:" sources. A fact written by a poller, an inference or the ambient
-// relay is a thing she learned, not a thing he said, and reading those back
-// under "что я тебе говорил?" would put words in his mouth.
-//
-// Placed with the other sources that read his own rows and above the recall
-// pass: the notes pass would otherwise answer this from whatever note happens
-// to be nearest, which reads as an answer and is not one.
-func (h *reactiveHandler) queryHistory(ctx context.Context, t *queryTurn) (string, bool) {
-	if !isHistoryQuery(t.dec.Utterance) {
-		return "", false
-	}
-	facts, err := h.api.RecentFacts(ctx, historyScan)
-	if err != nil {
-		log.Printf("voice: history: recent facts: %v", err)
-		return "не получилось посмотреть, что ты говорил.", true
-	}
-	cutoff := h.now().Add(-historyWindow)
-	var said []string
-	for _, f := range facts {
-		if !strings.HasPrefix(f.Source, "tap:") || f.Ts.Before(cutoff) {
-			continue
-		}
-		said = append(said, historyLine(f.Key, f.Value, f.Ts))
-		if len(said) == historyReadOut {
-			break
-		}
-	}
-	if len(said) == 0 {
-		// Claim the turn rather than fall through. "ничего не говорил" is the
-		// true answer, and recall would answer it with an old note instead.
-		return "за последние сутки ты мне ничего такого не говорил.", true
-	}
-	return "ты говорил: " + strings.Join(said, "; "), true
-}
-
-// historyLine — one fact as she says it. The hour and minute, because the day
-// is already bounded by historyWindow and a date would be noise.
-func historyLine(key, value string, ts time.Time) string {
-	what := key
-	if value != "" {
-		what = key + " — " + value
-	}
-	return fmt.Sprintf("%s (%s)", what, ts.Local().Format("15:04"))
-}

cmd/mavend/historyq_test.go

@@ -1,104 +0,0 @@
-package main
-
-import (
-	"context"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/kami/maven/internal/ipc"
-	"github.com/kami/maven/internal/router"
-)
-
-// historyAPI serves a fixed set of recent facts.
-type historyAPI struct {
-	ipc.UnimplementedCoreAPI
-	facts []ipc.Fact
-	calls int
-}
-
-func (a *historyAPI) RecentFacts(context.Context, int) ([]ipc.Fact, error) {
-	a.calls++
-	return a.facts, nil
-}
-
-func historyHandler(now time.Time, facts ...ipc.Fact) (*reactiveHandler, *historyAPI) {
-	api := &historyAPI{facts: facts}
-	return &reactiveHandler{api: api, now: func() time.Time { return now }}, api
-}
-
-func askHistory(h *reactiveHandler, u string) (string, bool) {
-	return h.queryHistory(context.Background(), &queryTurn{
-		dec: router.Decision{Intent: router.IntentQuery, Utterance: u},
-	})
-}
-
-func TestIsHistoryQuery(t *testing.T) {
-	for _, tc := range []struct {
-		text string
-		want bool
-	}{
-		{"что я тебе говорил?", true},
-		{"что ты записала сегодня?", true},
-		{"что я отмечал?", true},
-		// A named topic is a recall question, and the notes pass answers it
-		// better than a list of the last five facts does.
-		{"что я говорил про сервер?", false},
-		{"что у меня сегодня?", false},
-		{"", false},
-	} {
-		if got := isHistoryQuery(tc.text); got != tc.want {
-			t.Errorf("isHistoryQuery(%q) = %v, want %v", tc.text, got, tc.want)
-		}
-	}
-}
-
-func TestHistoryReadsOnlyWhatHeSaid(t *testing.T) {
-	now := time.Date(2026, 8, 4, 20, 0, 0, 0, time.UTC)
-	h, api := historyHandler(now,
-		ipc.Fact{Key: "water", Value: "выпил", Source: "tap:voice", Ts: now.Add(-time.Hour)},
-		// Learned, not said: a poller writing this back under "что я тебе
-		// говорил?" would put words in his mouth.
-		ipc.Fact{Key: "spent_today", Value: "1200", Source: "poll:zenmoney", Ts: now.Add(-time.Hour)},
-		// Older than the window.
-		ipc.Fact{Key: "shower", Value: "принял", Source: "tap:voice", Ts: now.Add(-30 * time.Hour)},
-	)
-	reply, ok := askHistory(h, "что я тебе говорил?")
-	if !ok {
-		t.Fatal("the history question must be claimed before the recall sources")
-	}
-	if !strings.Contains(reply, "water") {
-		t.Errorf("reply = %q, want the fact he tapped in", reply)
-	}
-	if strings.Contains(reply, "spent_today") || strings.Contains(reply, "shower") {
-		t.Errorf("reply = %q, want only what he said inside the window", reply)
-	}
-	if api.calls != 1 {
-		t.Errorf("RecentFacts called %d times, want 1", api.calls)
-	}
-}
-
-// Nothing said is an answer of its own. Falling through would hand the question
-// to recall, which answers it with an old note.
-func TestHistorySaysWhenThereIsNothing(t *testing.T) {
-	now := time.Date(2026, 8, 4, 20, 0, 0, 0, time.UTC)
-	h, _ := historyHandler(now)
-	reply, ok := askHistory(h, "что я тебе говорил?")
-	if !ok || !strings.Contains(reply, "ничего") {
-		t.Fatalf("reply = %q, ok = %v", reply, ok)
-	}
-}
-
-// Five is what fits in one spoken breath; the rest are on /history.
-func TestHistoryStopsAtFive(t *testing.T) {
-	now := time.Date(2026, 8, 4, 20, 0, 0, 0, time.UTC)
-	var facts []ipc.Fact
-	for i := 0; i < 12; i++ {
-		facts = append(facts, ipc.Fact{Key: "k", Value: "v", Source: "tap:voice", Ts: now.Add(-time.Minute)})
-	}
-	h, _ := historyHandler(now, facts...)
-	reply, _ := askHistory(h, "что ты записала?")
-	if got := strings.Count(reply, ";"); got != historyReadOut-1 {
-		t.Fatalf("reply = %q has %d separators, want %d", reply, got, historyReadOut-1)
-	}
-}

cmd/mavend/morning_nudge_test.go

@@ -1,39 +0,0 @@
-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/reactive_notes_test.go

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

cmd/mavend/reminderbody.go

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

cmd/mavend/reminderbody_test.go

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

cmd/mavend/replier_llm.go

@@ -24,12 +24,7 @@ func newLLMReplier(c phraser.Completer, block func() string) *llmReplier {
 // 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 {
-		// The deck, not the stub's single sentence: a clarify she cannot turn
-		// into a question is the line he hears most often when she misses him,
-		// and it used to be the same words every time (Vikunja #457). Still no
-		// model call — this text has to be right every time, and it is not worth
-		// a generation to say something this small.
-		return clarifyMissedLine(d)
+		return r.stub.Reply(d)
 	}
 	out, err := r.p.PhraseReply(context.Background(), d)
 	if err != nil || out == "" {

cmd/mavend/replier_llm_test.go

@@ -37,21 +37,9 @@ func TestLLMReplierFallsBackToStubOnEmpty(t *testing.T) {
 	assertStub(t, r, router.Decision{Intent: router.IntentNote}, "empty llm")
 }
 
-// A clarify never reaches the model, and since Vikunja #457 it is answered from
-// the clarify deck rather than the stub's single sentence.
-func TestLLMReplierClarifyReadsTheDeck(t *testing.T) {
+func TestLLMReplierClarifyUsesStub(t *testing.T) {
 	r := newLLMReplier(stubCompleter{out: "я всё поняла"}, nil)
-	got := r.Reply(router.Decision{Clarify: true, Utterance: "мгм"})
-	if got == "я всё поняла" {
-		t.Fatal("a clarify must not be phrased by the model")
-	}
-	if want := clarifyMissedFor("мгм"); got != want {
-		t.Errorf("on clarify: got %q, want %q", got, want)
-	}
-	// Two different misses do not sound identical.
-	if same := r.Reply(router.Decision{Clarify: true, Utterance: "а"}); same == got {
-		t.Log("two utterances hashed to the same line, which is allowed but should be rare")
-	}
+	assertStub(t, r, router.Decision{Clarify: true}, "clarify")
 }
 
 func assertStub(t *testing.T, r *llmReplier, d router.Decision, what string) {

cmd/mavend/simulator_test.go

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

cmd/mavend/tick.go

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

cmd/mavend/voice.go

@@ -220,9 +220,9 @@ func (h *reactiveHandler) upgradeAPI(api ipc.CoreAPI) {
 // handleText — the core reactive path without stt/tts. Used by the IPC Chat
 // endpoint (and eventually by telegram). Splits out the audio bookends from
 // HandlePushToTalk so text channels share the same routing logic.
-func (h *reactiveHandler) handleText(ctx context.Context, conversation, text string) string {
+func (h *reactiveHandler) handleText(ctx context.Context, text string) string {
 	log.Printf("voice: handleText: %q", text)
-	return h.runTurn(withDialogueID(ctx, dialogueIDFor(sourceText, conversation)), text, sourceText)
+	return h.runTurn(ctx, text, sourceText)
 }
 
 // turnSource — which channel this utterance arrived on, in the same provenance
@@ -255,7 +255,7 @@ func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSour
 	// early. He can be asked a question, walk off, come back and say "да" to a
 	// confirm that is still parked; computing the notice after that return meant
 	// he answered the confirm and never heard that the older request was let go.
-	expiredNotice := h.clarifyExpiredNotice(ctx)
+	expiredNotice := h.clarifyExpiredNotice()
 
 	// 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
@@ -351,10 +351,7 @@ func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSour
 	// and park the request (clarify.go); otherwise the replier's canned reply
 	// stands.
 	if dec.Clarify {
-		if reply := h.hexisBeforeClarify(ctx, dec); reply != "" {
-			return withNotice(expiredNotice, reply)
-		}
-		if question, asked := h.askClarify(ctx, dec); asked {
+		if question, asked := h.askClarify(dec); asked {
 			return withNotice(expiredNotice, question)
 		}
 	}

cmd/mavend/voicewire.go

@@ -238,10 +238,7 @@ 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, 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.
+	// load, never revived. Clarify's parked question stays in memory only.
 	var dialogueSessions *dialogue.SessionStore
 	if dataStore != nil {
 		dialogueSessions = dialogue.NewPersistentSessionStore(2*time.Minute, dataStore)
@@ -382,15 +379,7 @@ func buildRouter(emb router.Embedder, acts router.ActMatcher, threshold float64,
 	// question and must keep reaching replySystem, while "что у меня сегодня"
 	// is an agenda question and must not.
 	grammars = append(grammars, router.AgendaQueryGrammars()...)
-	// Same reason as the agenda rules, for the feeds: "что нового в лентах?"
-	// routed system and answered "пока не умею" (Vikunja #474).
-	grammars = append(grammars, router.FeedQueryGrammar())
 	grammars = append(grammars, router.ReminderGrammar())
-	// Last, and it matches any utterance shape — its Build is the filter. An
-	// explicit capture marker beats the model, which called it an act and
-	// 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,
@@ -404,34 +393,11 @@ func buildRouter(emb router.Embedder, acts router.ActMatcher, threshold float64,
 	})
 }
 
-// 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).
+// 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.
 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
@@ -456,11 +422,11 @@ func seedClassifier(c *router.Classifier) {
 		}
 		total += n
 	}
-	log.Printf("voice: loaded %d seed examples from %s", total, seedPath())
+	log.Printf("voice: loaded %d seed examples from %s", total, seedDir)
 }
 
 func loadSeedFile(c *router.Classifier, intent router.Intent) (int, error) {
-	path := filepath.Join(seedPath(), string(intent)+".txt")
+	path := filepath.Join(seedDir, 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,13 +1,10 @@
 // Package main — weatherq.go holds the weather-query keyword helpers: does
-// 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.
+// 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.
 package main
 
-import (
-	"regexp"
-	"strings"
-)
+import "strings"
 
 // isWeatherQuery returns true if the utterance is about weather.
 func isWeatherQuery(u string) bool {
@@ -22,49 +19,40 @@ func isWeatherQuery(u string) bool {
 		strings.Contains(lower, "temperature")
 }
 
-// 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,
+// 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",
 }
 
-// extractWeatherLocation returns the place he named, or the configured default
+// extractWeatherLocation returns the city 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 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.
+// 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.
 func extractWeatherLocation(u, defaultLoc string) string {
-	m := weatherPlace.FindStringSubmatch(u)
-	if m == nil {
-		return defaultLoc
+	lower := strings.ToLower(u)
+	for substr, name := range weatherCities {
+		if strings.Contains(lower, substr) {
+			return name
+		}
 	}
-	place := strings.TrimSpace(m[1])
-	first := strings.ToLower(strings.Fields(place)[0])
-	if weatherNonPlaces[first] {
-		return defaultLoc
-	}
-	return place
+	return defaultLoc
 }

cmd/mavend/weatherq_test.go

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

cmd/mavend/worldmodel.go

@@ -54,7 +54,11 @@ func (h *reactiveHandler) phraseSource(ctx context.Context, name, utterance stri
 		log.Printf("voice: %s: no world model, reading the source back instead", name)
 		return ""
 	case err != nil:
+		// The resident phraser answers this call with its fallback text and the
+		// error together. Drop the text: these callers hold the passage itself
+		// and read it back better than "вот что я нашла: <passage>" does.
 		log.Printf("voice: %s: phrase: %v", name, err)
+		return ""
 	}
 	return reply
 }

cmd/mavgpud/runner.go

@@ -24,12 +24,7 @@ type runner struct {
 	mu    sync.Mutex
 	cmd   *exec.Cmd
 	ready bool
-	// 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
+	http  *http.Client
 }
 
 func newRunner(bin string, args []string, readyURL string) *runner {
@@ -75,18 +70,13 @@ func (r *runner) start() error {
 	if err := cmd.Start(); err != nil {
 		return err
 	}
-	r.cmd, r.ready, r.yielding = cmd, false, false
+	r.cmd, r.ready = cmd, false
 	log.Printf("mavgpud: started llama-server pid=%d", cmd.Process.Pid)
 	go func() {
 		err := cmd.Wait()
 		r.mu.Lock()
-		yielded := r.yielding
-		r.cmd, r.ready, r.yielding = nil, false, false
+		r.cmd, r.ready = nil, 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
@@ -100,10 +90,6 @@ 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

@@ -1,59 +0,0 @@
-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/mavttsd/main.go

@@ -23,7 +23,6 @@ import (
 	"syscall"
 
 	"github.com/kami/maven/internal/audio"
-	"github.com/kami/maven/internal/tts"
 	"github.com/kami/maven/internal/worker"
 )
 
@@ -40,27 +39,15 @@ func run(args []string) error {
 	model := flag.String("model", "", "path to piper onnx model file")
 	espeakData := flag.String("espeak_data", "", "path to espeak-ng data directory")
 	tashkeelModel := flag.String("tashkeel_model", "", "path to libtashkeel onnx model")
-	lexiconPath := flag.String("lexicon", "", "path to the pronunciation dictionary (json, name to spelling)")
 
 	flag.CommandLine.Parse(args)
 
 	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)
 	defer stop()
 
-	// Read before the handler is built: a dictionary he asked for and that
-	// cannot be read is a startup failure, not a warning. Saying names wrong
-	// in silence is the thing it exists to stop.
-	lex, err := tts.LoadLexicon(*lexiconPath)
-	if err != nil {
-		return err
-	}
-	if lex.Size() > 0 {
-		log.Printf("mavttsd: pronunciation dictionary: %d names from %s", lex.Size(), *lexiconPath)
-	}
-
 	var s worker.Synthesizer
 	if *piperBin != "" && *model != "" {
-		s = newPiperHandler(*piperBin, *model, *espeakData, *tashkeelModel, lex)
+		s = newPiperHandler(*piperBin, *model, *espeakData, *tashkeelModel)
 		log.Printf("mavttsd: using piper tts (%s, model=%s)", *piperBin, *model)
 	} else {
 		log.Printf("mavttsd: no piper/model specified, using stub handler")

cmd/mavttsd/main_test.go

@@ -7,7 +7,6 @@ import (
 	"testing"
 
 	"github.com/kami/maven/internal/audio"
-	"github.com/kami/maven/internal/tts"
 	"github.com/kami/maven/internal/worker"
 )
 
@@ -118,18 +117,3 @@ func abs(n int) int {
 	}
 	return n
 }
-
-// The dictionary that ships in deploy/ must parse and must be non-empty. It is
-// data, so nothing else would catch a trailing comma before the voice did.
-func TestShippedLexiconLoads(t *testing.T) {
-	lex, err := tts.LoadLexicon(filepath.Join("..", "..", "deploy", "tts-lexicon.json"))
-	if err != nil {
-		t.Fatalf("deploy/tts-lexicon.json: %v", err)
-	}
-	if lex.Size() < 10 {
-		t.Errorf("shipped dictionary holds %d names, want the full list", lex.Size())
-	}
-	if got := lex.Apply("задача в Vikunja"); got == "задача в Vikunja" {
-		t.Error("the shipped dictionary did not rewrite a name it lists")
-	}
-}

cmd/mavttsd/piper_handler.go

@@ -9,7 +9,6 @@ import (
 	"os/exec"
 
 	"github.com/kami/maven/internal/audio"
-	"github.com/kami/maven/internal/tts"
 	"github.com/kami/maven/internal/worker"
 )
 
@@ -19,20 +18,15 @@ type piperHandler struct {
 	configPath    string
 	espeakData    string
 	tashkeelModel string
-	// lexicon rewrites service ids and Latin names into the spelling the
-	// Russian voice reads correctly (Vikunja #458). Nil-safe: an unconfigured
-	// dictionary rewrites nothing.
-	lexicon *tts.Lexicon
 }
 
-func newPiperHandler(piperPath, modelPath, espeakData, tashkeelModel string, lexicon *tts.Lexicon) *piperHandler {
+func newPiperHandler(piperPath, modelPath, espeakData, tashkeelModel string) *piperHandler {
 	return &piperHandler{
 		piperPath:     piperPath,
 		modelPath:     modelPath,
 		configPath:    modelPath + ".json",
 		espeakData:    espeakData,
 		tashkeelModel: tashkeelModel,
-		lexicon:       lexicon,
 	}
 }
 
@@ -72,14 +66,7 @@ func (h *piperHandler) Synthesize(ctx context.Context, req worker.SynthesizeReq)
 		return worker.SynthesizeResp{}, fmt.Errorf("piper: start: %w", err)
 	}
 
-	// The dictionary is applied here, at the last edge before the voice: every
-	// caller's text passes through this one point, and nothing upstream has to
-	// know how a name is spelled out loud.
-	text := req.Text
-	if h.lexicon != nil {
-		text = h.lexicon.Apply(text)
-	}
-	if _, err := io.WriteString(stdin, text); err != nil {
+	if _, err := io.WriteString(stdin, req.Text); err != nil {
 		stdin.Close()
 		stdout.Close()
 		_ = cmd.Wait()

cmd/mavweb/handlers_test.go

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

cmd/mavweb/main.go

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

cmd/mavweb/notifications.html

@@ -14,27 +14,5 @@
   <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/reminders.html

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

cmd/mavweb/reminders_test.go

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

deploy/mavgpud.service

@@ -19,10 +19,6 @@ 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

deploy/tts-lexicon.json

@@ -1,30 +0,0 @@
-{
-  "Maven": "Мэйвен",
-  "Nexus": "Нексус",
-  "Praxis": "Праксис",
-  "Hexis": "Хексис",
-  "Vikunja": "Викунья",
-  "SearXNG": "сёрчиксэнджи",
-  "Kiwix": "Кивикс",
-  "Gitea": "Гитея",
-  "Home Assistant": "Хоум Ассистент",
-  "Docker": "Докер",
-  "Telegram": "Телеграм",
-  "ntfy": "энтифай",
-  "homesrv": "хоумсёрв",
-  "workpc": "воркписи",
-  "whisper": "виспер",
-  "piper": "пайпер",
-  "llama-server": "лама сервер",
-  "Qwen": "Квен",
-  "CalDAV": "калдав",
-  "IMAP": "аймап",
-  "API": "эй-пи-ай",
-  "CPU": "си-пи-ю",
-  "GPU": "джи-пи-ю",
-  "RAM": "оперативная память",
-  "SSD": "эс-эс-ди",
-  "uptime": "аптайм",
-  "backup": "бэкап",
-  "deploy": "деплой"
-}

docs/design.md

@@ -223,30 +223,6 @@ 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?**

docs/operations.md

@@ -90,13 +90,6 @@ export LD_LIBRARY_PATH="$ROOT/deps/piper"
 
 Without `-piper` it runs as a stub.
 
-`-lexicon deploy/tts-lexicon.json` adds the pronunciation dictionary: a flat
-JSON object of name to Russian spelling, applied to the text just before piper
-reads it. It is how `Vikunja` is said as a word rather than spelled out, and how
-`SearXNG` and `homesrv` are said at all. Off unless the flag is set; a path that
-is set and unreadable stops mavttsd rather than letting it say names wrong in
-silence. Adding a name needs a restart of mavttsd and nothing else.
-
 ## mavweb — PWA voice bridge (WebSocket ↔ TCP)
 
 No CGo, no deps; builds with stock Go.

go.mod

@@ -15,6 +15,7 @@ require github.com/kami/hexis v0.0.0
 require (
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect
+	github.com/kami/praxis v0.0.0
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
@@ -24,4 +25,8 @@ require (
 	modernc.org/memory v1.11.0 // indirect
 )
 
+replace github.com/kami/praxis v0.0.0 => /home/kami/apps/praxis
+
+replace github.com/kami/nexus v0.0.0 => /home/kami/apps/nexus
+
 replace github.com/kami/hexis v0.0.0 => /home/kami/apps/hexis

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(), "web", "привет")
+	_, err = cli.Chat(context.Background(), "привет")
 	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(), "web", "привет")
+	reply, err := cli.Chat(context.Background(), "привет")
 	if err != nil {
 		t.Fatalf("Chat: %v", err)
 	}
@@ -373,7 +373,7 @@ func (r *recordingAPI) WriteFact(_ context.Context, _ ipc.WriteFactReq) (int64,
 	return int64(r.writes), nil
 }
 
-func (r *recordingAPI) Chat(_ context.Context, _, text string) (string, error) {
+func (r *recordingAPI) Chat(_ context.Context, text string) (string, error) {
 	r.chats++
 	return "echo: " + text, nil
 }

internal/calendar/calendar.go

@@ -18,7 +18,6 @@ import (
 	"sort"
 	"strings"
 	"time"
-	"unicode"
 )
 
 // Fact sources. A calendar event reaches the store as a
@@ -154,20 +153,14 @@ func Overlapping(events []Event, from, to time.Time) []Event {
 	return out
 }
 
-// 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.
+// 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.
 func safeKey(s string) string {
 	var b strings.Builder
 	for _, r := range s {
 		switch {
-		case unicode.IsLetter(r) || unicode.IsDigit(r) || r == '-':
+		case (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '-':
 			b.WriteRune(r)
 		case r == ' ' || r == '_':
 			b.WriteRune('-')

internal/calendar/calendar_test.go

@@ -139,9 +139,6 @@ 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 {
@@ -266,19 +263,3 @@ func TestSourceTrust(t *testing.T) {
 		t.Errorf("Sources() = %v", Sources())
 	}
 }
-
-// Two Russian events on one day must not share a key. They did: safeKey kept
-// ASCII only, so both summaries collapsed to their spaces and the second event
-// overwrote the first in the store (Vikunja #443).
-func TestFactKeyDistinguishesRussianEventsOnOneDay(t *testing.T) {
-	day := time.Date(2026, 8, 4, 0, 0, 0, 0, time.UTC)
-	a := Event{Summary: "Встреча с Аней", Start: day.Add(10 * time.Hour), End: day.Add(11 * time.Hour)}
-	b := Event{Summary: "Обед с мамой", Start: day.Add(13 * time.Hour), End: day.Add(14 * time.Hour)}
-	if FactKeyIn(a, time.UTC) == FactKeyIn(b, time.UTC) {
-		t.Fatalf("both events keyed as %q", FactKeyIn(a, time.UTC))
-	}
-	// The day prefix still has to survive, because the store range-scans on it.
-	if !strings.HasPrefix(FactKeyIn(a, time.UTC), KeyPrefixForDay(day)) {
-		t.Fatalf("key %q lost the day prefix %q", FactKeyIn(a, time.UTC), KeyPrefixForDay(day))
-	}
-}

internal/config/config.go

@@ -601,9 +601,6 @@ 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
@@ -1737,7 +1734,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, Optional: it.Optional}
+			items[j] = morning.Item{Key: it.Key, FactKey: it.FactKey, Label: it.Label}
 		}
 		weekdays := make([]time.Weekday, len(r.Weekdays))
 		for j, w := range r.Weekdays {

internal/dialogue/clarify.go

@@ -57,14 +57,6 @@ 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,19 +60,6 @@ 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 {
@@ -534,12 +521,6 @@ 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"`
@@ -612,14 +593,8 @@ 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"`
-	Conversation string `json:"conversation,omitempty"`
+	Text string `json:"text"`
 }
 type chatResp struct {
 	Reply string `json:"reply"`
@@ -704,9 +679,6 @@ type CoreAPI interface {
 	RecentActiveFactsByKind(ctx context.Context, kind string, n int) ([]Fact, error)
 	CalendarEvents(ctx context.Context, from, to time.Time) ([]Fact, error)
 	RecentNudges(ctx context.Context, n int) ([]Nudge, error)
-	// DeliveryAttempts reads the outbox, newest first. An empty status means
-	// every status (Vikunja #390).
-	DeliveryAttempts(ctx context.Context, status string, n int) ([]DeliveryAttempt, error)
 
 	// RecentEcosystemTraces reads the ecosystem call log, which lives in its
 	// own table so machine-rate traces never crowd out human-rate facts.
@@ -787,12 +759,7 @@ type CoreAPI interface {
 	// Chat routes a text utterance through the reactive handler's core path
 	// (router → dialogue → action → replier) and returns the reply text.
 	// No audio or stt/tts — for text channels (mavweb, telegram).
-	//
-	// 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)
+	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

internal/ipc/client.go

@@ -68,7 +68,6 @@ var readOnlyMethods = map[Method]bool{
 	MethodRecentActiveFacts:     true,
 	MethodCalendarEvents:        true,
 	MethodRecentNudges:          true,
-	MethodDeliveryAttempts:      true,
 	MethodRecentEcoTraces:       true,
 	MethodQueryNotes:            true,
 	MethodRecentNotes:           true,
@@ -374,14 +373,6 @@ 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 {
@@ -632,9 +623,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, conversation, text string) (string, error) {
+func (c *Client) Chat(ctx context.Context, text string) (string, error) {
 	var r chatResp
-	if err := c.call(ctx, MethodChat, chatReq{Text: text, Conversation: conversation}, &r); err != nil {
+	if err := c.call(ctx, MethodChat, chatReq{Text: text}, &r); err != nil {
 		return "", err
 	}
 	return r.Reply, nil

internal/ipc/ipc_test.go

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

internal/ipc/server.go

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

internal/ipc/unimplemented.go

@@ -68,9 +68,6 @@ 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
 }
@@ -144,6 +141,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, conversation, text string) (string, error) {
+func (UnimplementedCoreAPI) Chat(ctx context.Context, text string) (string, error) {
 	return "", ErrNotImplemented
 }

internal/ipc/wire.go

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

internal/memory/recalleval/recalleval.go

@@ -90,44 +90,9 @@ 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,28 +337,3 @@ 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,18 +30,6 @@ 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
@@ -72,37 +60,12 @@ type Status struct {
 }
 
 // Candidate — a routine that's due for its one-per-day nag: the window has
-// 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.
+// reached NudgeAt and at least one item is still unevidenced.
 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
@@ -228,11 +191,7 @@ func Due(routines []Routine, facts map[string]store.Fact, last map[string]time.T
 				missing = append(missing, it)
 			}
 		}
-		// A day where only the optional items were skipped is a fine day, and
-		// nagging about it is what teaches him to stop listening (Vikunja
-		// #473). The optional ones still travel in Missing so the message can
-		// mention them when it is being sent anyway.
-		if len(Required(missing)) == 0 {
+		if len(missing) == 0 {
 			continue
 		}
 		if prev, seen := last[r.Name]; seen && sameDay(prev, now) {

internal/morning/morning_test.go

@@ -182,40 +182,3 @@ 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,31 +53,9 @@ 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
 //
@@ -110,8 +88,8 @@ func Detect(events []Event) (*ProposedRoutine, error) {
 	}
 
 	center := medianFloat(intervals)
-	if center <= 0 || center < MinIntervalDays {
-		return nil, nil // a burst, not a rhythm — see MinIntervalDays
+	if center <= 0 {
+		return nil, nil
 	}
 
 	// Keep the intervals that sit inside the band around the median. The

internal/pattern/detector_test.go

@@ -216,46 +216,3 @@ 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,23 +173,12 @@ 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) || governedByYou(words, i) {
+		if !masculinePast(w) || i+1 >= len(words) {
 			continue
 		}
 		next := words[i+1]
-		aboutHim := next == "тебе" || next == "тебя"
-		if next == "за" && i+2 < len(words) && (words[i+2] == "тебя" || words[i+2] == "тебе") {
-			aboutHim = true
-		}
-		if aboutHim {
+		if next == "тебе" || next == "тебя" || next == "за" {
 			return Result{CheckFeminine, false,
 				fmt.Sprintf("masculine self-reference %q before %q", w, next)}
 		}
@@ -663,19 +652,3 @@ 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,12 +106,6 @@ 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

@@ -78,6 +78,12 @@ type TalkCase struct {
 	Note      string   `json:"note,omitempty"`
 }
 
+// TalkSchemaVersion — the version this loader understands. Separate from the
+// nudge fixture's SchemaVersion: the two fixtures have different shapes and
+// change on different days, and one shared constant would force a bump on the
+// fixture that did not move.
+const TalkSchemaVersion = 1
+
 // TalkFixture — the versioned envelope, same gating as Fixture.
 type TalkFixture struct {
 	SchemaVersion int        `json:"schema_version"`
@@ -92,8 +98,8 @@ func LoadTalk() (TalkFixture, error) {
 	if err := json.Unmarshal(talkFixtureJSON, &f); err != nil {
 		return TalkFixture{}, fmt.Errorf("parse talk fixture: %w", err)
 	}
-	if f.SchemaVersion != SchemaVersion {
-		return TalkFixture{}, fmt.Errorf("talk fixture schema_version %d, want %d", f.SchemaVersion, SchemaVersion)
+	if f.SchemaVersion != TalkSchemaVersion {
+		return TalkFixture{}, fmt.Errorf("talk fixture schema_version %d, want %d", f.SchemaVersion, TalkSchemaVersion)
 	}
 	if len(f.Cases) == 0 {
 		return TalkFixture{}, fmt.Errorf("talk fixture has no cases")

internal/phraser/eval/talk_test.go

@@ -142,19 +142,13 @@ func TestLLMTalkBaseline(t *testing.T) {
 	p := phraser.NewLLMPhraserAt(base, cfg)
 	defer p.Close()
 
-	// Unreachable server is fatal here, not a logged warning, and that differs
-	// from the nudge test on purpose. PhraseNudge returns its errors, so a dead
-	// server there shows up honestly in the Errors column. PhraseChat and
-	// PhraseQuery do NOT: they swallow every failure and return a canned string
-	// ("поговорили.", "не знаю.", "вот что я нашла: …"). So on these three paths
-	// a dead server produces a full report with 0 errors and a terrible score —
-	// a number that looks like bad phrasing and is really no phrasing at all.
-	// Refusing to score without a confirmed model is the only guard available
-	// until the phraser reports its failures (Vikunja #397).
+	// The model id names the run in the report. Since Vikunja #397 every path
+	// returns its errors, so a server that dies mid-run shows up in the Errors
+	// column instead of scoring as bad phrasing — the before-and-after probe that
+	// used to stand in for that is gone.
 	model, err := llm.ModelID(ctx, base)
 	if err != nil {
-		t.Fatalf("no model at %s: %v — refusing to score, these paths hide their errors "+
-			"and would report a plausible-looking result off a dead server", base, err)
+		t.Fatalf("no model at %s: %v", base, err)
 	}
 	t.Logf("scoring model %s at %s", model, base)
 
@@ -169,10 +163,11 @@ func TestLLMTalkBaseline(t *testing.T) {
 	}
 	t.Log("\n" + rep.String() + "\nreplies:\n" + rep.Replies() + "\nfailures:\n" + rep.Failures())
 
-	// And again afterwards: the run takes minutes, and a server that died or got
-	// OOM-killed halfway through would leave the first cases scored and the rest
-	// silently canned. Checking only at the start would not catch that.
-	if _, err := llm.ModelID(ctx, base); err != nil {
-		t.Fatalf("model at %s went away during the run: %v — the score above is not trustworthy", base, err)
+	// A run where nothing was phrased is not a low score, it is no measurement.
+	if rep.Errors == rep.Total {
+		t.Fatalf("every case errored — nothing was measured, the score above is not a phrasing result")
+	}
+	if rep.Errors > 0 {
+		t.Logf("%d/%d cases errored — those are model failures, not phrasing failures", rep.Errors, rep.Total)
 	}
 }

internal/phraser/failure_test.go

@@ -0,0 +1,72 @@
+package phraser
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+// A dead server must be distinguishable from bad phrasing. Both PhraseChat and
+// PhraseQuery keep the turn alive with canned text — ChatFallback, "не знаю.",
+// "вот что я нашла: …" — and every one of those is also a legitimate reply, so
+// the text alone cannot say which happened. The error is the only signal, and
+// before Vikunja #397 it was dropped: the talk scorer reported a full run with
+// zero errors off a server that answered nothing.
+func TestPhrasingReportsTheFailureWithTheFallback(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, "model not loaded", http.StatusServiceUnavailable)
+	}))
+	t.Cleanup(srv.Close)
+	p := NewLLMPhraserAt(srv.URL, Config{})
+
+	cases := []struct {
+		name string
+		call func() (string, error)
+		want string
+	}{
+		{"chat", func() (string, error) {
+			return p.PhraseChat(context.Background(), "как дела", nil)
+		}, ChatFallback},
+		{"knowledge", func() (string, error) {
+			return p.PhraseQuery(context.Background(), "кто написал войну и мир", nil)
+		}, "не знаю."},
+		{"evidence", func() (string, error) {
+			return p.PhraseQuery(context.Background(), "сколько воды я выпил", []string{"два литра"})
+		}, "вот что я нашла: два литра"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got, err := c.call()
+			if err == nil {
+				t.Fatalf("no error from a dead server; the scorer would count this as bad phrasing")
+			}
+			if got != c.want {
+				t.Errorf("fallback text = %q, want %q — the daemon still has to say something", got, c.want)
+			}
+		})
+	}
+}
+
+// An empty answer is a failure too: the server is up and produced no tokens,
+// which is not an answer and must not score as one.
+func TestEmptyKnowledgeAnswerIsAnError(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.Write([]byte(`{"choices":[{"message":{"content":""}}]}`))
+	}))
+	t.Cleanup(srv.Close)
+	p := NewLLMPhraserAt(srv.URL, Config{})
+
+	got, err := p.PhraseQuery(context.Background(), "кто написал войну и мир", nil)
+	if err == nil {
+		t.Fatal("an empty response scored as an answer")
+	}
+	if got != "не знаю." {
+		t.Errorf("fallback text = %q, want \"не знаю.\"", got)
+	}
+	if !strings.Contains(err.Error(), "empty") {
+		t.Errorf("error = %v; want it to name the empty response", err)
+	}
+}

internal/phraser/llmphraser.go

@@ -5,6 +5,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"log"
@@ -26,6 +27,11 @@ import (
 
 var listenRE = regexp.MustCompile(`listening on (https?://\S+)`)
 
+// errEmptyResponse — the server answered and said nothing. Separate from a
+// transport failure: the model is up and produced no tokens, which is still not
+// an answer and must not score as one.
+var errEmptyResponse = errors.New("phraser: empty response from the model")
+
 type LLMPhraser struct {
 	cfg    Config
 	client *http.Client
@@ -428,8 +434,11 @@ func (p *LLMPhraser) PhraseNudge(ctx context.Context, c loop.Candidate) (deliver
 }
 
 // PhraseQuery prompts the LLM with the user's utterance and matching notes to
-// compose a natural answer. Falls back to "вот что я нашла: <notes>" on any
-// LLM error — better to give the raw data than silence.
+// compose a natural answer. On any LLM error it returns the fallback text —
+// "вот что я нашла: <notes>", or "не знаю." with no notes — and the error
+// together. The daemon uses the text and keeps the turn alive; a caller that is
+// measuring counts the failure. Until Vikunja #397 the error was dropped, so a
+// dead server scored as bad phrasing.
 func (p *LLMPhraser) PhraseQuery(ctx context.Context, utterance string, notes []string) (string, error) {
 	// Blank sources are no sources. A caller that hands over one empty string —
 	// a page that fetched to nothing, a snippet trimmed away — used to take the
@@ -439,13 +448,15 @@ func (p *LLMPhraser) PhraseQuery(ctx context.Context, utterance string, notes []
 	if len(notes) == 0 {
 		sys, prompt := p.knowledgePrompt(utterance)
 		resp, err := p.chatWithSystem(ctx, sys, prompt, 768)
-		if err != nil || resp == "" {
-			return "не знаю.", nil
+		if err != nil {
+			return "не знаю.", fmt.Errorf("phrase query (knowledge): %w", err)
+		}
+		if resp == "" {
+			return "не знаю.", errEmptyResponse
 		}
 		text, _, perr := parseResponseMood(resp)
 		if perr != nil {
-			log.Printf("phraser: PhraseQuery: %v", perr)
-			return "не знаю.", nil
+			return "не знаю.", fmt.Errorf("phrase query (knowledge): %w", perr)
 		}
 		if text != "" {
 			return text, nil
@@ -457,13 +468,12 @@ func (p *LLMPhraser) PhraseQuery(ctx context.Context, utterance string, notes []
 	text, _, perr := parseResponseMood(resp)
 	if err != nil || perr != nil {
 		// Read the notes out rather than ship a broken fragment.
-		if perr != nil {
-			log.Printf("phraser: PhraseQuery: %v", perr)
+		cause := err
+		if cause == nil {
+			cause = perr
 		}
-		if len(notes) == 1 {
-			return "вот что я нашла: " + notes[0], nil
-		}
-		return "вот что я нашла: " + strings.Join(notes, "; "), nil
+		return "вот что я нашла: " + strings.Join(notes, "; "),
+			fmt.Errorf("phrase query (evidence): %w", cause)
 	}
 	if text != "" {
 		return text, nil
@@ -472,8 +482,9 @@ func (p *LLMPhraser) PhraseQuery(ctx context.Context, utterance string, notes []
 }
 
 // PhraseChat uses the LLM to respond conversationally, building a multi-turn
-// message array from dialogue history + the current user utterance. Falls back
-// to a simple greeting on any LLM error — better to say something than nothing.
+// message array from dialogue history + the current user utterance. On any LLM
+// error it returns both ChatFallback and the error, on the same rule as
+// PhraseQuery: the fallback keeps the turn alive, the error stays visible.
 func (p *LLMPhraser) PhraseChat(ctx context.Context, utterance string, history []dialogue.Turn) (string, error) {
 	sys := chatSystemPrompt(p.cfg.ContextBlock)
 	msgs := []chatMsg{
@@ -490,13 +501,11 @@ func (p *LLMPhraser) PhraseChat(ctx context.Context, utterance string, history [
 
 	resp, err := p.chatWithMessages(ctx, msgs, 768)
 	if err != nil {
-		log.Printf("phraser: PhraseChat: %v", err)
-		return "поговорили.", nil
+		return ChatFallback, fmt.Errorf("phrase chat: %w", err)
 	}
 	text, _, perr := parseResponseMood(resp)
 	if perr != nil {
-		log.Printf("phraser: PhraseChat: %v", perr)
-		return "поговорили.", nil
+		return ChatFallback, fmt.Errorf("phrase chat: %w", perr)
 	}
 	if text != "" {
 		return text, nil

internal/phraser/phraser.go

@@ -66,11 +66,17 @@ type Stub struct{}
 // NewStub builds the floor phraser. no config — the Stub is stateless.
 func NewStub() *Stub { return &Stub{} }
 
+// ChatFallback — what she says on the chat path when the model gave her
+// nothing to say. It replaced "поговорили.", which reads as a summary of a
+// conversation that did not happen. Said out loud this one is an admission,
+// which is what it is.
+const ChatFallback = "даже не знаю, что сказать."
+
 // PhraseChat returns a stub reply — the LLMPhraser replaces this with a
 // prompted response from the model. The history parameter is accepted but
 // ignored at the stub level (the production impl uses it for multi-turn).
 func (s *Stub) PhraseChat(_ context.Context, _ string, _ []dialogue.Turn) (string, error) {
-	return "поговорили.", nil
+	return ChatFallback, nil
 }
 
 // PhraseQuery returns a deterministic summary of the best matching notes.

internal/phraser/swap_test.go

@@ -215,10 +215,12 @@ func TestSwap_RollbackFailureLeavesNoBackendAndDegrades(t *testing.T) {
 	if _, _, aerr := p.acquire(); !errors.Is(aerr, ErrNoBackend) {
 		t.Errorf("acquire error = %v; want ErrNoBackend", aerr)
 	}
-	// Phrasing degrades to its fallback instead of failing the turn.
+	// Phrasing degrades to its fallback instead of failing the turn, and since
+	// Vikunja #397 it reports the error next to that fallback so a measuring
+	// caller can tell "no model" from "bad phrasing".
 	got, err := p.PhraseChat(context.Background(), "привет", nil)
-	if err != nil {
-		t.Fatalf("PhraseChat after a total failure returned an error: %v", err)
+	if !errors.Is(err, ErrNoBackend) {
+		t.Errorf("PhraseChat error = %v; want ErrNoBackend alongside the fallback", err)
 	}
 	if got == "" {
 		t.Error("PhraseChat returned empty; the fallback must still say something")

internal/router/agenda_test.go

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

internal/router/complaint.go

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

internal/router/complaint_test.go

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

internal/router/dateparser.go

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

internal/router/eval/eval_test.go

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

internal/router/eval/ru_routing_v1.json

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

internal/router/feedgrammar_test.go

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

internal/router/llmrouter.go

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

internal/router/llmrouter_test.go

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

internal/router/numwords.go

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

internal/router/numwords_test.go

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

internal/router/router.go

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

internal/router/slots.go

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

internal/router/stage0.go

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

internal/router/task.go

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

internal/router/task_phrases.json

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

internal/router/task_test.go

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

internal/store/delivery.go

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

internal/store/delivery_test.go

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

internal/store/migrations.go

@@ -208,46 +208,6 @@ ALTER TABLE reminders ADD COLUMN next_fire_ts INTEGER;`, // #2
 	// list_tasks into something that writes without the row changing by one
 	// byte. The fingerprint is the declared shape at approval time, so a
 	// redefinition is a re-approval instead of a silent upgrade.
-	`DELETE FROM facts
-	  WHERE key LIKE 'calendar_event_%'
-	    AND replace(substr(key, 25), '-', '') = '';`,
-	// #18 — drop the calendar keys written while safeKey dropped Cyrillic
-	// (Vikunja #443). Everything after the date prefix was punctuation, so
-	// every Russian event on one day shared one key and only the last one
-	// survived. Deleting rather than rewriting: a calendar fact is derived
-	// data, the next poll writes the day again under keys that identify the
-	// event, and the old rows would otherwise be recited as extra meetings.
-	// The filter is exact — it keeps any key whose summary part still has a
-	// letter or a digit in it.
-
-	// #19 — unstick the routines accepted before the fire-forever fix
-	// (Vikunja #377, follow-up to #366). Accepting used to leave accepted_ts
-	// NULL and a live one-shot reminder behind, and the tick loop skips a row
-	// with no accepted_ts, so every non-weekly routine accepted before that fix
-	// has been silent ever since.
-	//
-	// Three statements, in this order, per stuck row: adopt created_ts as the
-	// acceptance time, cancel the reminder that is still holding the schedule,
-	// then let go of it. Cancelling before clearing matters — clearing first
-	// loses the only pointer to the reminder and leaves it to fire on its own.
-	//
-	// created_ts rather than a fresh timestamp because a migration has no
-	// clock, and because the first interval should be measured from when he
-	// said yes. A routine whose interval has already elapsed nudges on the next
-	// tick, which is what being unstuck looks like.
-	//
-	// Weekly rows are included deliberately. Theirs was the case that kept
-	// working, because the cron reminder reschedules itself — so leaving them
-	// alone would give them both a cron reminder and a tick-loop schedule for
-	// one habit, and he would hear it twice.
-	`UPDATE reminders
-	     SET status = 'cancelled'
-	   WHERE status = 'pending'
-	     AND id IN (SELECT reminder_id FROM proposed_routines
-	                 WHERE status = 'accepted' AND accepted_ts IS NULL AND reminder_id IS NOT NULL);
-	UPDATE proposed_routines
-	     SET accepted_ts = created_ts, reminder_id = NULL
-	   WHERE status = 'accepted' AND accepted_ts IS NULL;`,
 }
 
 // migrate applies every migration with a number greater than the DB's current

internal/store/migrations_test.go

@@ -3,7 +3,6 @@ package store
 import (
 	"context"
 	"testing"
-	"time"
 )
 
 func userVersion(t *testing.T, s *Store) int {
@@ -48,102 +47,3 @@ func TestMigrateAppliesOnceAndIsIdempotent(t *testing.T) {
 		t.Fatalf("after re-migrate user_version = %d, want %d", v, want)
 	}
 }
-
-// Migration #18 clears the calendar keys written while safeKey dropped
-// Cyrillic. Those rows are indistinguishable from real events on read, so
-// leaving them would recite one meeting as several (Vikunja #443).
-func TestCollapsedCalendarKeysAreDropped(t *testing.T) {
-	ctx := context.Background()
-	s := newTestStore(t)
-
-	rows := []string{
-		"calendar_event_20260804_--",             // "Встреча с Аней" under the old rule
-		"calendar_event_20260804_",               // a one-word Russian summary
-		"calendar_event_20260804_Встреча-с-Аней", // the new format
-		"calendar_event_20260804_Standup",        // an ASCII summary, always fine
-	}
-	for _, key := range rows {
-		if _, err := s.db.ExecContext(ctx,
-			`INSERT INTO facts (ts, kind, key, value, source, confidence) VALUES (0, 'env', ?, 'x', 'poll:caldav', 1.0)`,
-			key); err != nil {
-			t.Fatalf("seed %q: %v", key, err)
-		}
-	}
-	if _, err := s.db.ExecContext(ctx, migrations[17]); err != nil {
-		t.Fatalf("migration 18: %v", err)
-	}
-
-	var got int
-	if err := s.db.QueryRowContext(ctx, `SELECT count(*) FROM facts WHERE key LIKE 'calendar_event_%'`).Scan(&got); err != nil {
-		t.Fatal(err)
-	}
-	if got != 2 {
-		t.Fatalf("%d calendar rows left, want the 2 that identify their event", got)
-	}
-}
-
-// TestStuckRoutinesAreBackfilled — routines accepted before the fire-forever
-// fix have accepted_ts NULL and a live reminder, so the tick loop skips them
-// and they have been silent ever since (Vikunja #377). The migration touches
-// live reminders, which is why it is tested against a real store.
-func TestStuckRoutinesAreBackfilled(t *testing.T) {
-	ctx := context.Background()
-	s := newTestStore(t)
-	created := time.Date(2026, 7, 1, 9, 0, 0, 0, time.UTC)
-
-	rem, err := s.CreateReminder(ctx, created.Add(time.Hour), "полить цветы", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	healthy, err := s.CreateReminder(ctx, created.Add(2*time.Hour), "не трогать", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := s.db.ExecContext(ctx,
-		`INSERT INTO proposed_routines (action, object, interval_days, status, created_ts, reminder_id, accepted_ts)
-		 VALUES ('water', 'plants', 7, 'accepted', ?, ?, NULL)`,
-		created.UnixMilli(), rem); err != nil {
-		t.Fatal(err)
-	}
-	// An already-healthy accepted row, and a still-open proposal: neither is
-	// this migration's business.
-	if _, err := s.db.ExecContext(ctx,
-		`INSERT INTO proposed_routines (action, object, interval_days, status, created_ts, accepted_ts)
-		 VALUES ('feed', 'cat', 1, 'accepted', ?, ?)`,
-		created.UnixMilli(), created.UnixMilli()); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := s.db.ExecContext(ctx, migrations[18]); err != nil {
-		t.Fatalf("migration 19: %v", err)
-	}
-
-	accepted, err := s.ListAcceptedRoutines(ctx)
-	if err != nil || len(accepted) != 2 {
-		t.Fatalf("ListAcceptedRoutines = %d rows, err=%v, want 2", len(accepted), err)
-	}
-	stuck := accepted[0]
-	if stuck.Object != "plants" {
-		stuck = accepted[1]
-	}
-	if stuck.AcceptedTs == nil || !stuck.AcceptedTs.Equal(created) {
-		t.Fatalf("accepted_ts = %v, want the creation time", stuck.AcceptedTs)
-	}
-	if stuck.ReminderID != nil {
-		t.Fatalf("reminder_id = %v, want it let go", stuck.ReminderID)
-	}
-	// The reminder it was holding is cancelled, and nothing else is.
-	var status string
-	if err := s.db.QueryRowContext(ctx, `SELECT status FROM reminders WHERE id = ?`, rem).Scan(&status); err != nil {
-		t.Fatal(err)
-	}
-	if status != ReminderCancelled {
-		t.Fatalf("linked reminder status = %q, want cancelled", status)
-	}
-	if err := s.db.QueryRowContext(ctx, `SELECT status FROM reminders WHERE id = ?`, healthy).Scan(&status); err != nil {
-		t.Fatal(err)
-	}
-	if status != "pending" {
-		t.Fatalf("unrelated reminder status = %q, want it untouched", status)
-	}
-}

internal/tts/lexicon.go

@@ -1,128 +0,0 @@
-package tts
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"regexp"
-	"sort"
-	"strings"
-)
-
-// Pronunciation dictionary (Vikunja #458).
-//
-// piper reads a Russian sentence with a Russian voice, and a Latin service id
-// inside that sentence comes out as letters or as noise: "Vikunja" is spelled
-// out, "SearXNG" is unreadable, and "homesrv" is read as if it were a word. The
-// fix is not a code change per name — it is a file of replacements applied to
-// the text before piper sees it.
-//
-// Spelling, not phonemes. piper has no lexicon input of its own here, so the
-// only lever is the text, and the entry for a name is how it should be spelled
-// in Russian for the voice to say it right. That also means a wrong entry is
-// visible: it is a word, and it is read out loud.
-//
-// The dictionary is data, so it ships as a file rather than a table in Go. A
-// name added to it needs no rebuild and no deploy of the daemon that owns the
-// text — only a restart of mavttsd, which is the process that reads it.
-
-// Lexicon rewrites names into the spelling the voice reads correctly.
-//
-// The zero value is usable and rewrites nothing, so a daemon with no dictionary
-// configured behaves exactly as it did before this existed.
-type Lexicon struct {
-	// Rules are held in one alternation rather than as a map, so a text is
-	// scanned once however many entries there are, and the longest name wins
-	// where two overlap ("Home Assistant" before "Home").
-	re *regexp.Regexp
-	// by lower-cased name, because the match is case-insensitive and the
-	// replacement is not derived from what was matched.
-	by map[string]string
-}
-
-// LoadLexicon reads a dictionary file: a flat JSON object of name to spelling.
-//
-//	{"Vikunja": "Викунья", "SearXNG": "сёрчиксэнджи"}
-//
-// An empty path returns an empty Lexicon and no error — the dictionary is off
-// unless configured, like every other optional capability. A path that is set
-// and unreadable IS an error: he asked for it, and silently saying names wrong
-// is the failure this exists to remove.
-func LoadLexicon(path string) (*Lexicon, error) {
-	if strings.TrimSpace(path) == "" {
-		return &Lexicon{}, nil
-	}
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return nil, fmt.Errorf("tts: lexicon %s: %w", path, err)
-	}
-	var entries map[string]string
-	if err := json.Unmarshal(raw, &entries); err != nil {
-		return nil, fmt.Errorf("tts: lexicon %s: %w", path, err)
-	}
-	return NewLexicon(entries), nil
-}
-
-// NewLexicon builds a lexicon from entries already in memory.
-func NewLexicon(entries map[string]string) *Lexicon {
-	names := make([]string, 0, len(entries))
-	by := make(map[string]string, len(entries))
-	for name, say := range entries {
-		name = strings.TrimSpace(name)
-		if name == "" || strings.TrimSpace(say) == "" {
-			continue
-		}
-		names = append(names, name)
-		by[strings.ToLower(name)] = say
-	}
-	if len(names) == 0 {
-		return &Lexicon{}
-	}
-	// Longest first: "Home Assistant" must match before "Home" does, and Go's
-	// regexp alternation is leftmost-first, not longest-match.
-	sort.Slice(names, func(i, j int) bool { return len(names[i]) > len(names[j]) })
-	quoted := make([]string, len(names))
-	for i, n := range names {
-		quoted[i] = regexp.QuoteMeta(n)
-	}
-	// The boundaries are written out rather than left to \b, which is ASCII-only
-	// and never fires next to a Cyrillic letter — so "в Vikunja," would not
-	// match with \b on the left in a Russian sentence.
-	pattern := `(?i)(^|[^\p{L}\p{N}_])(` + strings.Join(quoted, "|") + `)($|[^\p{L}\p{N}_])`
-	return &Lexicon{re: regexp.MustCompile(pattern), by: by}
-}
-
-// Apply rewrites every name in the text. Text with no name in it comes back
-// unchanged and untouched.
-func (l *Lexicon) Apply(text string) string {
-	if l == nil || l.re == nil || text == "" {
-		return text
-	}
-	// Twice, because two names separated by a single space share the character
-	// between them and one pass consumes it: "Nexus Praxis" would leave the
-	// second name alone otherwise.
-	out := l.replaceOnce(text)
-	return l.replaceOnce(out)
-}
-
-func (l *Lexicon) replaceOnce(text string) string {
-	return l.re.ReplaceAllStringFunc(text, func(m string) string {
-		groups := l.re.FindStringSubmatch(m)
-		if groups == nil {
-			return m
-		}
-		say, ok := l.by[strings.ToLower(groups[2])]
-		if !ok {
-			return m
-		}
-		return groups[1] + say + groups[3]
-	})
-}
-
-// Size reports how many names are loaded, for the startup log line.
-func (l *Lexicon) Size() int {
-	if l == nil {
-		return 0
-	}
-	return len(l.by)
-}

internal/tts/lexicon_test.go

@@ -1,85 +0,0 @@
-package tts
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestLexiconRewritesNames(t *testing.T) {
-	lex := NewLexicon(map[string]string{
-		"Vikunja":        "Викунья",
-		"Home Assistant": "Хоум Ассистент",
-		"Home":           "Хоум",
-		"GPU":            "джи-пи-ю",
-	})
-	for _, tc := range []struct{ in, want string }{
-		{"задача в Vikunja готова", "задача в Викунья готова"},
-		// Case-insensitive: the router and the model both change the case of a
-		// name on the way through.
-		{"открой vikunja.", "открой Викунья."},
-		// Longest first, or "Home Assistant" is read as "Хоум Assistant".
-		{"Home Assistant не отвечает", "Хоум Ассистент не отвечает"},
-		// Two names in a row share the space between them, which one pass
-		// would consume.
-		{"GPU GPU", "джи-пи-ю джи-пи-ю"},
-		// Not a word boundary: a name inside a longer token is left alone.
-		{"vikunjaless", "vikunjaless"},
-		{"ничего не совпало", "ничего не совпало"},
-		{"", ""},
-	} {
-		if got := lex.Apply(tc.in); got != tc.want {
-			t.Errorf("Apply(%q) = %q, want %q", tc.in, got, tc.want)
-		}
-	}
-}
-
-// The zero value and an unconfigured path rewrite nothing, so a daemon with no
-// dictionary behaves as it did before this existed.
-func TestLexiconOffByDefault(t *testing.T) {
-	var zero *Lexicon
-	if got := zero.Apply("Vikunja"); got != "Vikunja" {
-		t.Errorf("nil lexicon rewrote %q", got)
-	}
-	lex, err := LoadLexicon("")
-	if err != nil {
-		t.Fatalf("LoadLexicon(\"\"): %v", err)
-	}
-	if lex.Size() != 0 || lex.Apply("Vikunja") != "Vikunja" {
-		t.Errorf("empty path produced a live lexicon of %d names", lex.Size())
-	}
-}
-
-// A path he set and that cannot be read is a startup failure. Saying names
-// wrong in silence is what the dictionary exists to stop.
-func TestLexiconLoadErrors(t *testing.T) {
-	if _, err := LoadLexicon(filepath.Join(t.TempDir(), "nope.json")); err == nil {
-		t.Error("a missing dictionary must be an error")
-	}
-	bad := filepath.Join(t.TempDir(), "bad.json")
-	if err := os.WriteFile(bad, []byte("{not json"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := LoadLexicon(bad); err == nil {
-		t.Error("an unparseable dictionary must be an error")
-	}
-}
-
-func TestLexiconRoundTripsAFile(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "lex.json")
-	if err := os.WriteFile(path, []byte(`{"Praxis":"Праксис","  ":"skipped","Nexus":""}`), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	lex, err := LoadLexicon(path)
-	if err != nil {
-		t.Fatalf("LoadLexicon: %v", err)
-	}
-	// Blank names and blank spellings are dropped: an entry that says nothing
-	// would delete the word it matched.
-	if lex.Size() != 1 {
-		t.Fatalf("Size = %d, want 1", lex.Size())
-	}
-	if got := lex.Apply("Praxis молчит"); got != "Праксис молчит" {
-		t.Errorf("Apply = %q", got)
-	}
-}

internal/weather/openmeteo.go

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

internal/weather/openmeteo_test.go

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

internal/weather/weather.go

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

vendor/modules.txt

@@ -15,6 +15,8 @@ github.com/google/uuid
 # github.com/kami/hexis v0.0.0 => /home/kami/apps/hexis
 ## explicit; go 1.25.5
 github.com/kami/hexis/pkg/client
+# github.com/kami/praxis v0.0.0 => /home/kami/apps/praxis
+## explicit; go 1.23
 # github.com/mattn/go-isatty v0.0.20
 ## explicit; go 1.15
 github.com/mattn/go-isatty
@@ -77,3 +79,4 @@ modernc.org/memory
 modernc.org/sqlite
 modernc.org/sqlite/lib
 modernc.org/sqlite/vtab
+# github.com/kami/nexus v0.0.0 => /home/kami/apps/nexus