Merge PR #115 into task/479 (V-498)

Both shapes carry no question mark and no interrogative, so the model saw
them with nothing deterministic in front and routed both to fact. The fact
gate caught the write and re-ran the turn as a query, so nothing broke —
what they cost was a full model round trip for a decision two patterns can
make offline.

NarrativeQueryGrammars, wired after the agenda rules so that "расскажи,
что у меня сегодня" stays an agenda question. Two exclusions, both learned
from the fixture: a capture verb in the rest of the utterance means he
asked for a note, and an entertainment noun means chat — "расскажи анекдот
про программистов" is ru-chat-003, and my first pattern took it.

The fixture had no case for either shape, which is why they went unnoticed.
Added as ru-query-020 and ru-query-021: classifier+onnx 53/77 → 55/79
(68.8% → 69.6%), both new cases answered at stage 0, false clarifies
unchanged at 0.

cmd/mavend/ack.go

@@ -16,6 +16,7 @@ import (
 	"log"
 
 	"github.com/kami/maven/internal/loop"
+	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/store"
 )
@@ -35,10 +36,10 @@ func (h *reactiveHandler) resolveAck(ctx context.Context, text string, src turnS
 	}
 	if err := h.api.ResolveNudge(ctx, target.ID, store.NudgeActed, now); err != nil {
 		log.Printf("voice: ack nudge %d (%s, %s): %v", target.ID, target.Rule, src, err)
-		return "не получилось отметить.", true
+		return phraser.Ack(phraser.FailAck, nil), true
 	}
 	log.Printf("voice: acked nudge %d (rule %s) from %s", target.ID, target.Rule, src)
-	return "отлично, отметила.", true
+	return phraser.Ack(phraser.AckNudge, nil), true
 }
 
 // ackFromFact — post-action hook, called once the turn's decision has been

cmd/mavend/actions.go

@@ -66,7 +66,7 @@ func (h *reactiveHandler) actionChat(ctx context.Context, dec router.Decision) s
 		log.Printf("voice: chat: %v", err)
 	}
 	if reply == "" {
-		return phraser.ChatFallback
+		return phraser.ChatFallback()
 	}
 	return reply
 }

cmd/mavend/actions_act.go

@@ -6,6 +6,7 @@ import (
 	"log"
 
 	"github.com/kami/maven/internal/mcp"
+	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/tool"
 )
@@ -50,31 +51,31 @@ func (h *reactiveHandler) actionAct(ctx context.Context, dec router.Decision) st
 			// destructive: park it and ask. The next utterance answers.
 			phrase := actPhrase(dec.Slots.Fn, dec.Slots.Args)
 			h.park(dec.Slots.Fn, dec.Slots.Args, phrase)
-			return "выполнить «" + phrase + "»? скажи «да» или «нет»."
+			return phraser.A(phraser.ActConfirm, map[string]string{"name": phrase})
 		case errors.Is(err, tool.ErrNotEnabled):
 			return h.proposeGap(ctx, dec)
 		case errors.Is(err, tool.ErrNotConnected), errors.Is(err, mcp.ErrNotConnected), errors.Is(err, mcp.ErrNoServer):
 			// The row is enabled and the backend is gone. Drafting a proposal
 			// for it (the ErrNotEnabled path) would be answering the wrong
 			// question.
-			return "этот инструмент включён, но сервер, который его выполняет, сейчас не подключён."
+			return phraser.A(phraser.ActServerDown, nil)
 		case errors.Is(err, mcp.ErrToolGone):
-			return "сервер больше не предлагает этот инструмент — я сняла его с разрешённых, посмотри на /tools."
+			return phraser.A(phraser.ActWithdrawn, nil)
 		case errors.Is(err, mcp.ErrNeedsArgs):
 			// An MCP tool that wants named arguments a spoken verb cannot
 			// supply. Guessing them would be a wrong act, so she says so
 			// instead — the tool is still runnable from the authed surface,
 			// where a human types them.
-			return "этому инструменту нужны аргументы, которые я из голоса не соберу — я не буду угадывать."
+			return phraser.A(phraser.ActNeedsArgs, nil)
 		}
 		log.Printf("voice: tool %s: %v", dec.Slots.Fn, err)
 		if out != "" {
-			return "не получилось выполнить команду: " + firstLine(out)
+			return phraser.A(phraser.ActFailOut, map[string]string{"out": firstLine(out)})
 		}
-		return "не получилось выполнить команду."
+		return phraser.A(phraser.ActFail, nil)
 	}
 	if out != "" {
-		return "готово: " + firstLine(out)
+		return phraser.A(phraser.ActDoneOut, map[string]string{"out": firstLine(out)})
 	}
-	return "готово."
+	return phraser.A(phraser.ActDone, nil)
 }

cmd/mavend/actions_fact.go

@@ -6,6 +6,7 @@ import (
 	"strconv"
 
 	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/store"
 )
@@ -14,7 +15,7 @@ import (
 // it for recall, and let pattern detection propose a routine.
 func (h *reactiveHandler) actionFact(ctx context.Context, dec router.Decision) string {
 	if !dec.Slots.HasKey {
-		return "не разобрала, что записать — попробуй иначе."
+		return phraser.Ack(phraser.FailFactUnparsed, nil)
 	}
 	// A question is never a fact about him (#470). "какая последняя версия
 	// языка Go?" used to land here, and the value stored was whatever the
@@ -62,7 +63,7 @@ func (h *reactiveHandler) actionFact(ctx context.Context, dec router.Decision) s
 	factID, err := h.api.WriteFact(ctx, req)
 	if err != nil {
 		log.Printf("voice: write fact: %v", err)
-		return "не получилось сохранить факт."
+		return phraser.Ack(phraser.FailFact, nil)
 	}
 	// Index the fact in long-term memory (best-effort, must not fail the fact
 	// write). Facts aren't in the notes table, so this is the only recall path

cmd/mavend/actions_note.go

@@ -5,6 +5,7 @@ import (
 	"log"
 	"strconv"
 
+	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 )
 
@@ -23,13 +24,13 @@ func (h *reactiveHandler) actionNote(ctx context.Context, dec router.Decision) s
 	vec, err := router.EmbedPassage(ctx, h.embedder, dec.Utterance)
 	if err != nil {
 		log.Printf("voice: embed note: %v", err)
-		return "не получилось сохранить заметку."
+		return phraser.Ack(phraser.FailNote, nil)
 	}
 	noteTs := h.now()
 	noteID, err := h.api.WriteNote(ctx, noteTs, dec.Utterance, vec, "tap:voice")
 	if err != nil {
 		log.Printf("voice: write note: %v", err)
-		return "не получилось сохранить заметку."
+		return phraser.Ack(phraser.FailNote, nil)
 	}
 	// Insert into long-term memory (best-effort, must not fail the note write).
 	// text/ts in the meta make a Search hit self-describing (see bestRecall).

cmd/mavend/actions_query.go

@@ -147,9 +147,9 @@ func (h *reactiveHandler) actionQuery(ctx context.Context, dec router.Decision)
 		// The previous question cannot be re-asked for another day. Saying so
 		// beats "не знаю", which reads as "no data for tomorrow" when the
 		// truth is that she never looked.
-		return "про другой день так не отвечу — спроси целиком."
+		return phraser.Q(phraser.QueryOtherDay, nil)
 	}
-	return "не знаю."
+	return phraser.Q(phraser.QueryUnknown, nil)
 }
 
 // queryFactByKey — when the dialogue layer resolved an anaphoric reference to
@@ -167,11 +167,11 @@ func (h *reactiveHandler) queryFactByKey(ctx context.Context, t *queryTurn) (str
 	if dec.Slots.HasTime {
 		// The query asks about timing — the fact's own timestamp is the
 		// answer it's looking for. Format as a natural reply.
-		return fmt.Sprintf("я записала это %s", formatTime(f.Ts)), true
+		return phraser.Q(phraser.QueryFactWhen, map[string]string{"when": formatTime(f.Ts)}), true
 	}
 	// General fact reference: describe what we know.
 	if dec.Utterance == "" {
-		return fmt.Sprintf("вот что я знаю: %s — %s", dec.Slots.Key, f.Value), true
+		return phraser.Q(phraser.QueryFactValue, map[string]string{"key": dec.Slots.Key, "value": f.Value}), true
 	}
 	// The utterance still carries the question; fall through to normal RAG
 	// with the resolved key in context.
@@ -197,7 +197,7 @@ func (h *reactiveHandler) queryDayPlan(ctx context.Context, t *queryTurn) (strin
 	plan, err := h.api.DayPlan(ctx)
 	if err != nil {
 		log.Printf("voice: day plan: %v", err)
-		return "не получилось собрать план.", true
+		return phraser.Q(phraser.QueryFailPlan, nil), true
 	}
 	if !router.IsRestOfDayQuery(t.dec.Utterance) {
 		return plan.Spoken, true
@@ -242,7 +242,7 @@ func (h *reactiveHandler) queryHabits(ctx context.Context, t *queryTurn) (string
 	facts, err := h.api.RecentActiveFactsByKind(ctx, string(store.KindSelf), habitFactWindow)
 	if err != nil {
 		log.Printf("voice: habits: recent facts: %v", err)
-		return "не получилось посмотреть записи.", true
+		return phraser.Q(phraser.QueryFailNotes, nil), true
 	}
 	obs := make([]memory.Observation, 0, len(facts))
 	for _, f := range facts {
@@ -281,7 +281,7 @@ func (h *reactiveHandler) queryFeeds(ctx context.Context, t *queryTurn) (string,
 		// Claim the turn rather than fall through: "не читаю ленты" is true, and
 		// letting general knowledge answer "что нового?" would be an invented
 		// news bulletin.
-		return "я пока не читаю ленты — они не настроены.", true
+		return phraser.Q(phraser.QueryFeedsOff, nil), true
 	}
 	// By source, not the last 200 notes of any kind: a busy day of voice notes
 	// used to push the newest headline out of the window, and she answered "в
@@ -289,7 +289,7 @@ func (h *reactiveHandler) queryFeeds(ctx context.Context, t *queryTurn) (string,
 	notes, err := h.api.RecentNotesFromSource(ctx, rss.SourcePrefix, feedNoteWindow)
 	if err != nil {
 		log.Printf("voice: feeds: recent notes: %v", err)
-		return "не получилось посмотреть ленты.", true
+		return phraser.Q(phraser.QueryFailFeeds, nil), true
 	}
 	var picked []string
 	for _, n := range notes {
@@ -306,11 +306,11 @@ func (h *reactiveHandler) queryFeeds(ctx context.Context, t *queryTurn) (string,
 	}
 	if len(picked) == 0 {
 		if q.Category != "" {
-			return "по этой теме в лентах пока ничего.", true
+			return phraser.Q(phraser.QueryFeedsTopic, nil), true
 		}
-		return "в лентах пока ничего нового.", true
+		return phraser.Q(phraser.QueryFeedsEmpty, nil), true
 	}
-	return "вот что нового: " + strings.Join(picked, "; "), true
+	return phraser.Q(phraser.QueryFeedsNew, map[string]string{"items": strings.Join(picked, "; ")}), true
 }
 
 // queryCalendar — "что у меня сегодня?", "планы на завтра?"
@@ -324,7 +324,7 @@ func (h *reactiveHandler) queryCalendar(ctx context.Context, t *queryTurn) (stri
 	events, err := h.api.CalendarEvents(ctx, date, date.Add(24*time.Hour))
 	if err != nil {
 		log.Printf("voice: calendar events: %v", err)
-		return "не получилось проверить календарь.", true
+		return phraser.Q(phraser.QueryFailCalendar, nil), true
 	}
 	// Provenance travels with each event. A work meeting relayed off a phone
 	// notification (source ambient:notif, #126) is stored below full confidence
@@ -367,9 +367,12 @@ func (h *reactiveHandler) queryNetwork(ctx context.Context, t *queryTurn) (strin
 		return "", false
 	}
 	if h.netscan == nil {
-		// Fall through, same as queryHome: an unconfigured scanner must not
-		// swallow "сколько устройств в сети?" before recall has looked.
-		return "", false
+		// The recogniser already matched, so this is a question about HIS LAN
+		// and there is no scanner to answer it. Falling through sent it to the
+		// search leg, which answered with a paragraph about routers in general
+		// and put his network question on an upstream engine (Vikunja #479).
+		// A missing capability names itself.
+		return phraser.Q(phraser.QueryNetOff, nil), true
 	}
 	return h.netscan.scanSummary(ctx)
 }
@@ -382,19 +385,23 @@ func (h *reactiveHandler) queryWeather(ctx context.Context, t *queryTurn) (strin
 	if loc == "" {
 		// He named no city and voice.weather.default_location is unset. Saying
 		// so is the only honest answer; picking a city would be inventing one.
-		return "не знаю, для какого города — задай voice.weather.default_location или назови город.", true
+		return phraser.Q(phraser.QueryWeatherWhere, nil), true
 	}
 	ctxWT, cancel := context.WithTimeout(ctx, 5*time.Second)
 	defer cancel()
 	w, err := h.weatherProvider.CurrentWeather(ctxWT, loc)
 	if errors.Is(err, weather.ErrNotConfigured) {
-		return "погода не настроена.", true
+		return phraser.Q(phraser.QueryWeatherOff, nil), true
 	}
 	if err != nil {
 		log.Printf("voice: weather: %v", err)
-		return "не получилось узнать погоду.", true
+		return phraser.Q(phraser.QueryFailWeather, nil), true
 	}
-	return fmt.Sprintf("в %s сейчас %.0f градусов, %s.", w.Location, w.Temperature, w.Condition), true
+	return phraser.Q(phraser.QueryWeatherNow, map[string]string{
+		"location":  w.Location,
+		"temp":      fmt.Sprintf("%.0f", w.Temperature),
+		"condition": w.Condition,
+	}), true
 }
 
 // queryEmbed isn't an answer source — it's the shared cost the two recall
@@ -404,7 +411,7 @@ func (h *reactiveHandler) queryEmbed(ctx context.Context, t *queryTurn) (string,
 	vec, err := router.EmbedQuery(ctx, h.embedder, t.dec.Utterance)
 	if err != nil {
 		log.Printf("voice: embed query: %v", err)
-		return "не получилось найти ответ.", true
+		return phraser.Q(phraser.QueryFailAnswer, nil), true
 	}
 	t.vec = vec
 	return "", false
@@ -473,7 +480,7 @@ func (h *reactiveHandler) queryNotes(ctx context.Context, t *queryTurn) (string,
 	notes, err := h.api.QueryNotes(ctx, t.vec, 5)
 	if err != nil {
 		log.Printf("voice: query notes: %v", err)
-		return "не получилось найти ответ.", true
+		return phraser.Q(phraser.QueryFailAnswer, nil), true
 	}
 	t.notes = notes
 	noteScores := make([]float64, len(notes))
@@ -498,7 +505,7 @@ func (h *reactiveHandler) queryNotes(ctx context.Context, t *queryTurn) (string,
 		log.Printf("voice: phrase query: %v", err)
 	}
 	if reply == "" {
-		reply = "вот что я нашла: " + texts[0]
+		reply = phraser.Q(phraser.QueryFound, map[string]string{"text": texts[0]})
 	}
 	return reply, true
 }
@@ -520,25 +527,24 @@ func (h *reactiveHandler) queryWeb(ctx context.Context, t *queryTurn) (string, b
 		return "", false
 	}
 	if h.crawler == nil {
-		// Fall through. Reading pages is off unless configured, and on a daemon
-		// where it was never turned on the older behaviour is right: the model
-		// answers the question as if the URL had not been said. Announcing a
-		// configuration status is for a capability that exists and failed, not
-		// for one he never asked for.
-		return "", false
+		// He named a URL, so the question is about that page and nothing else
+		// can answer it. The older comment here argued for falling through and
+		// letting the model answer as if the URL had not been said; that is a
+		// guess dressed as an answer (Vikunja #479).
+		return phraser.Q(phraser.QueryPageOff, nil), true
 	}
 	ctxFetch, cancel := context.WithTimeout(ctx, 30*time.Second)
 	defer cancel()
 	page, err := h.crawler.Page(ctxFetch, link)
 	if err != nil {
 		if errors.Is(err, crawl.ErrRobots) {
-			return "эта страница закрыта для чтения — robots.txt не разрешает.", true
+			return phraser.Q(phraser.QueryPageBlocked, nil), true
 		}
 		log.Printf("voice: web: %v", err)
-		return "не получилось прочитать страницу.", true
+		return phraser.Q(phraser.QueryFailPage, nil), true
 	}
 	if page.Text == "" {
-		return "страница открылась, но читать там нечего.", true
+		return phraser.Q(phraser.QueryPageEmpty, nil), true
 	}
 	// The page is handed to the phraser the same way a note is: as context for
 	// the question he actually asked. She answers the question, she does not
@@ -548,7 +554,7 @@ func (h *reactiveHandler) queryWeb(ctx context.Context, t *queryTurn) (string, b
 	if reply == "" {
 		// No phraser (or it failed): read back the top of the page rather than
 		// pretend the fetch did not happen.
-		return "вот что на странице: " + crawl.TrimRunes(page.Text, 300), true
+		return phraser.Q(phraser.QueryPageText, map[string]string{"text": crawl.TrimRunes(page.Text, 300)}), true
 	}
 	return reply, true
 }
@@ -614,7 +620,7 @@ func (h *reactiveHandler) querySearch(ctx context.Context, t *queryTurn) (string
 	if reply == "" {
 		// No phraser, or it failed. Read back the best evidence rather than
 		// pretend the search did not happen.
-		return "вот что я нашла: " + crawl.TrimRunes(resp.Snippets()[0], 300), true
+		return phraser.Q(phraser.QueryFound, map[string]string{"text": crawl.TrimRunes(resp.Snippets()[0], 300)}), true
 	}
 	return reply, true
 }
@@ -695,7 +701,7 @@ func (h *reactiveHandler) queryKiwix(ctx context.Context, t *queryTurn) (string,
 	if reply == "" {
 		// No phraser, or it failed. Read back the best hit rather than pretend
 		// the search did not happen.
-		return "вот что я нашла: " + crawl.TrimRunes(top.Title+" — "+page.Text, 300), true
+		return phraser.Q(phraser.QueryFound, map[string]string{"text": crawl.TrimRunes(top.Title+" — "+page.Text, 300)}), true
 	}
 	return reply, true
 }
@@ -725,7 +731,7 @@ func (h *reactiveHandler) queryPersonal(ctx context.Context, t *queryTurn) (stri
 		return "", false
 	}
 	log.Printf("voice: %q is about him and his own data did not answer it; not asking the world", t.dec.Utterance)
-	return "не знаю — не нашла у тебя такой записи.", true
+	return phraser.Q(phraser.QueryPersonalNone, nil), true
 }
 
 // personalMarkers — first-person POSSESSION, not first person generally.
@@ -793,15 +799,15 @@ func (h *reactiveHandler) queryGeneral(ctx context.Context, t *queryTurn) (strin
 	if h.phraser == nil {
 		// No model of any size. That is not the workstation being asleep, so it
 		// is not that gap: it is simply not knowing.
-		return "не знаю.", true
+		return phraser.Q(phraser.QueryUnknown, nil), true
 	}
 	reply, err := h.phraseWorld(ctx, t.dec.Utterance, nil)
 	if errors.Is(err, phraser.ErrNoWorldModel) {
 		log.Printf("voice: %q needs the world model and it is not available", t.dec.Utterance)
-		return worldGap, true
+		return worldGap(), true
 	}
 	if err != nil || reply == "" {
-		return "не знаю.", true
+		return phraser.Q(phraser.QueryUnknown, nil), true
 	}
 	return reply, true
 }

cmd/mavend/actions_reminder.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"log"
 
+	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 )
 
@@ -21,13 +22,13 @@ func (h *reactiveHandler) actionReminder(ctx context.Context, dec router.Decisio
 			}
 		}
 		if !dec.Slots.HasTime {
-			return "не получилось разобрать время напоминания."
+			return phraser.Ack(phraser.FailReminderTime, nil)
 		}
 	}
 	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 "не получилось поставить напоминание."
+		return phraser.Ack(phraser.FailReminder, nil)
 	}
 	return ""
 }

cmd/mavend/actions_task.go

@@ -5,6 +5,7 @@ import (
 	"log"
 
 	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/store"
 	"github.com/kami/maven/internal/tasks"
@@ -40,18 +41,18 @@ func (h *reactiveHandler) captureTaskFromNote(ctx context.Context, dec router.De
 	})
 	if err != nil {
 		log.Printf("voice: capture task: %v", err)
-		return "не получилось записать задачу.", true
+		return phraser.Ack(phraser.FailTask, nil), true
 	}
 	if resp.Promoted {
 		// It was a candidate Maven derived from something she read, and he has
 		// now said it himself. Saying "уже в списке" here would be answering a
 		// confirmation with a shrug.
-		return "поняла, беру в работу: " + cap.Text, true
+		return phraser.Ack(phraser.AckTaskUrgent, map[string]string{"text": cap.Text}), true
 	}
 	if !resp.Created {
-		return "это уже в списке.", true
+		return phraser.Ack(phraser.AckTaskDuplicate, nil), true
 	}
-	return "записала: " + cap.Text, true
+	return phraser.Ack(phraser.AckTask, map[string]string{"text": cap.Text}), true
 }
 
 // queryTasks — "какие у меня задачи?", "что мне нужно сделать?".

cmd/mavend/actions_task_test.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 )
 
@@ -108,7 +109,7 @@ func TestCaptureTaskFromNoteReportsStoreFailure(t *testing.T) {
 	if !ok {
 		t.Fatal("a failed capture still claims the turn — the note path must not double-write")
 	}
-	if !strings.Contains(reply, "не получилось") {
+	if !phraser.IsAck(phraser.FailTask, nil, reply) {
 		t.Errorf("reply = %q, want an honest failure", reply)
 	}
 }

cmd/mavend/crawls_test.go

@@ -125,13 +125,17 @@ func TestQueryWebPassesWithoutAURL(t *testing.T) {
 	}
 }
 
-// A daemon where page reading was never turned on — the default — answers the
-// question the way it did before the capability existed. Claiming the turn to
-// report a configuration status is for something that exists and failed.
-func TestQueryWebPassesWhenNotConfigured(t *testing.T) {
+// A daemon where page reading was never turned on names the gap. He asked
+// about one page, nothing else on the box can read it, and the old behaviour
+// here was to answer as though the URL had not been said (Vikunja #479).
+func TestQueryWebNamesTheGapWhenNotConfigured(t *testing.T) {
 	h := buildWebHandler(nil)
-	if reply, ok := askWeb(h, "посмотри https://example.org/page"); ok {
-		t.Fatalf("an unconfigured crawler claimed the turn with %q", reply)
+	reply, ok := askWeb(h, "посмотри https://example.org/page")
+	if !ok {
+		t.Fatal("an unconfigured crawler let the page question fall through")
+	}
+	if !phraser.IsQ(phraser.QueryPageOff, nil, reply) {
+		t.Errorf("got %q, want the gap named", reply)
 	}
 }
 
@@ -156,7 +160,7 @@ func TestQueryWebRefusesNonHTML(t *testing.T) {
 	if !ok {
 		t.Fatal("the web source did not claim a question with a URL")
 	}
-	if !strings.Contains(reply, "не получилось") {
+	if !phraser.IsQ(phraser.QueryFailPage, nil, reply) {
 		t.Errorf("reply = %q, want the read-failed answer", reply)
 	}
 }

cmd/mavend/dayplan_test.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/kami/maven/internal/calendar"
 	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/store"
 )
@@ -147,8 +148,8 @@ func TestQueryDayPlanCoreFailure(t *testing.T) {
 	if !ok {
 		t.Fatal("a failed plan read must still answer, not fall through to RAG")
 	}
-	if reply != "не получилось собрать план." {
-		t.Errorf("reply = %q", reply)
+	if !phraser.IsQ(phraser.QueryFailPlan, nil, reply) {
+		t.Errorf("reply = %q, want the honest failure", reply)
 	}
 }
 

cmd/mavend/ecosystem_acts.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	hexisclient "github.com/kami/hexis/pkg/client"
+	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/store"
 )
@@ -144,10 +145,10 @@ func (listAttentionCapability) handle(ctx context.Context, h *reactiveHandler, p
 		log.Printf("ecosystem: praxis attention: %v", err)
 		h.recordEcosystemTrace(ctx, "praxis", "list_attention", traceStatusForError(err),
 			started, traceErrorFields(err))
-		return "не могу сейчас узнать, что требует внимания."
+		return phraser.A(phraser.AttentionFail, nil)
 	}
 	if len(items) == 0 {
-		return "ничего не требует внимания."
+		return phraser.A(phraser.AttentionNone, nil)
 	}
 	h.recordPraxisTrace(ctx, "list_attention", started, map[string]any{"count": len(items)})
 	var parts []string
@@ -175,7 +176,7 @@ func (listAttentionCapability) handle(ctx context.Context, h *reactiveHandler, p
 			}
 		}
 	}
-	return "требует внимания: " + strings.Join(parts, "; ")
+	return phraser.A(phraser.AttentionList, map[string]string{"items": strings.Join(parts, "; ")})
 }
 
 // listChangesCapability reads the recent-changes feed.
@@ -192,10 +193,10 @@ func (listChangesCapability) handle(ctx context.Context, h *reactiveHandler, px
 		log.Printf("ecosystem: praxis changes: %v", err)
 		h.recordEcosystemTrace(ctx, "praxis", "list_changes", traceStatusForError(err),
 			started, traceErrorFields(err))
-		return "не могу сейчас узнать об изменениях."
+		return phraser.A(phraser.ChangesFail, nil)
 	}
 	if len(changes) == 0 {
-		return "нет изменений."
+		return phraser.A(phraser.ChangesNone, nil)
 	}
 	h.recordPraxisTrace(ctx, "list_changes", started, map[string]any{"count": len(changes)})
 	var parts []string
@@ -204,7 +205,7 @@ func (listChangesCapability) handle(ctx context.Context, h *reactiveHandler, px
 		typ, _ := c["change_type"].(string)
 		parts = append(parts, fmt.Sprintf("%s (%s)", title, typ))
 	}
-	return "изменения: " + strings.Join(parts, "; ")
+	return phraser.A(phraser.ChangesList, map[string]string{"items": strings.Join(parts, "; ")})
 }
 
 // entityAttentionCapability answers "what's going on with X" by resolving X to
@@ -230,12 +231,12 @@ func (entityAttentionCapability) handle(ctx context.Context, h *reactiveHandler,
 		subject = dec.Slots.Text
 	}
 	if subject == "" {
-		return "про что именно спросить?"
+		return phraser.A(phraser.EcoAboutWhat, nil)
 	}
 	if h.ecosystem == nil || h.ecosystem.nexus == nil {
 		// Without Nexus there is no canonical ref to scope by. Say so rather
 		// than quietly answering about something else.
-		return "не могу связать это с сущностью — Nexus не настроен."
+		return phraser.A(phraser.EcoNoNexus, nil)
 	}
 
 	started := h.now()
@@ -248,15 +249,15 @@ func (entityAttentionCapability) handle(ctx context.Context, h *reactiveHandler,
 		h.recordEcosystemTrace(ctx, "nexus", "resolve", traceStatusForError(err), started,
 			mergeFields(traceErrorFields(err), map[string]any{"subject": redactSubject(subject)}))
 		if unauthorizedEcosystemError(err) {
-			return "экосистема отклоняет доступ, проверь токен."
+			return phraser.A(phraser.EcoDenied, nil)
 		}
-		return "экосистема недоступна, попробуй ещё раз."
+		return phraser.A(phraser.EcoDown, nil)
 	}
 	if len(ambiguous) > 0 {
-		return "уточни, что именно: " + strings.Join(ambiguous, ", ") + "?"
+		return phraser.A(phraser.EcoAmbiguous, map[string]string{"items": strings.Join(ambiguous, ", ")})
 	}
 	if entityID == "" {
-		return "не знаю такой сущности."
+		return phraser.A(phraser.EcoUnknownEntity, nil)
 	}
 	if displayName == "" {
 		displayName = subject
@@ -268,7 +269,7 @@ func (entityAttentionCapability) handle(ctx context.Context, h *reactiveHandler,
 		log.Printf("ecosystem: praxis attention for %s: %v", entityID, err)
 		h.recordEcosystemTrace(ctx, "praxis", "entity_attention", traceStatusForError(err),
 			queried, mergeFields(traceErrorFields(err), map[string]any{"entity_id": entityID}))
-		return "не могу сейчас узнать, что требует внимания по «" + displayName + "»."
+		return phraser.A(phraser.AttentionFailEntity, map[string]string{"name": displayName})
 	}
 	items, scoped := scopedToEntity(items, entityID)
 	if !scoped {
@@ -279,7 +280,7 @@ func (entityAttentionCapability) handle(ctx context.Context, h *reactiveHandler,
 		log.Printf("ecosystem: praxis returned unscoped items for %s, refusing to answer", entityID)
 		h.recordEcosystemTrace(ctx, "praxis", "entity_attention", traceFailed, queried,
 			map[string]any{"entity_id": entityID, "class": "unscoped_response"})
-		return "не могу сейчас узнать, что требует внимания по «" + displayName + "»."
+		return phraser.A(phraser.AttentionFailEntity, map[string]string{"name": displayName})
 	}
 	h.recordPraxisTrace(ctx, "entity_attention", queried, map[string]any{
 		"entity_id": entityID, "count": len(items),
@@ -303,9 +304,9 @@ func (entityAttentionCapability) handle(ctx context.Context, h *reactiveHandler,
 		parts = append(parts, known)
 	}
 	if len(parts) == 0 {
-		return "по «" + displayName + "» ничего нет."
+		return phraser.A(phraser.AttentionNoneEntity, map[string]string{"name": displayName})
 	}
-	return "по «" + displayName + "»: " + strings.Join(parts, "; ")
+	return phraser.A(phraser.AttentionListEntity, map[string]string{"name": displayName, "items": strings.Join(parts, "; ")})
 }
 
 // scopedToEntity drops items that carry an entity_id other than the one asked
@@ -370,7 +371,7 @@ func (h *reactiveHandler) localFactsForEntity(ctx context.Context, entityID stri
 	if len(parts) == 0 {
 		return ""
 	}
-	out := "я помню: " + strings.Join(parts, ", ")
+	out := phraser.A(phraser.EcoRecall, map[string]string{"items": strings.Join(parts, ", ")})
 	if more {
 		out += ", и это не всё"
 	}
@@ -520,18 +521,18 @@ func (h *reactiveHandler) handleHexisAct(ctx context.Context, dec router.Decisio
 		h.recordEcosystemTrace(ctx, "nexus", "resolve", traceStatusForError(err), started,
 			mergeFields(traceErrorFields(err), map[string]any{"subject": redactSubject(dec.Slots.Text)}))
 		if unauthorizedEcosystemError(err) {
-			return "экосистема отклоняет доступ, проверь токен."
+			return phraser.A(phraser.EcoDenied, nil)
 		}
 		// A genuine Nexus dependency failure, not "no such entity" — stop here
 		// and report degradation rather than silently falling through to the
 		// local command executor (ECOSYSTEM-SPEC.md: services degrade
 		// independently, never a silent all-clear).
-		return "экосистема недоступна, попробуй ещё раз."
+		return phraser.A(phraser.EcoDown, nil)
 	}
 	if len(ambiguous) > 0 {
 		h.recordEcosystemTrace(ctx, "nexus", "resolve", traceAmbig, started,
 			map[string]any{"candidates": len(ambiguous)})
-		return "уточни, что именно: " + strings.Join(ambiguous, ", ") + "?"
+		return phraser.A(phraser.EcoAmbiguous, map[string]string{"items": strings.Join(ambiguous, ", ")})
 	}
 	if entityID == "" {
 		h.recordEcosystemTrace(ctx, "nexus", "resolve", traceNotFound, started,
@@ -550,9 +551,9 @@ func (h *reactiveHandler) handleHexisAct(ctx context.Context, dec router.Decisio
 		h.recordEcosystemTrace(ctx, "hexis", "capabilities", traceStatusForError(err), discovered,
 			mergeFields(traceErrorFields(err), map[string]any{"entity_id": entityID}))
 		if unauthorizedEcosystemError(err) {
-			return "экосистема отклоняет доступ, проверь токен."
+			return phraser.A(phraser.EcoDenied, nil)
 		}
-		return "экосистема недоступна, попробуй ещё раз."
+		return phraser.A(phraser.EcoDown, nil)
 	}
 	h.recordEcosystemTrace(ctx, "hexis", "capabilities", traceOK, discovered,
 		map[string]any{"entity_id": entityID, "count": len(caps)})
@@ -584,7 +585,7 @@ func (h *reactiveHandler) handleHexisAct(ctx context.Context, dec router.Decisio
 		for _, m := range matches {
 			names = append(names, m.Name)
 		}
-		return "какую команду для " + displayName + ": " + strings.Join(names, ", ") + "?"
+		return phraser.A(phraser.ActWhich, map[string]string{"name": displayName, "items": strings.Join(names, ", ")})
 	}
 	matched := matches[0]
 
@@ -602,7 +603,7 @@ func (h *reactiveHandler) handleHexisAct(ctx context.Context, dec router.Decisio
 		h.mu.Unlock()
 		h.recordEcosystemTrace(ctx, "hexis", "confirmation", tracePending, started,
 			map[string]any{"entity_id": entityID, "capability": matched.Name})
-		return "выполнить «" + matched.Name + "» для " + displayName + "? скажи «да» или «нет»."
+		return phraser.A(phraser.ActConfirmEntity, map[string]string{"name": matched.Name, "entity": displayName})
 	}
 
 	return h.execHexis(ctx, matched.ID, matched.Name, entityID, displayName)
@@ -622,7 +623,7 @@ func (h *reactiveHandler) execHexis(ctx context.Context, capID, capName, entityI
 			mergeFields(traceErrorFields(err), map[string]any{
 				"entity_id": entityID, "capability": capName, "causation_id": causationID,
 			}))
-		return "не получилось выполнить команду для " + displayName + "."
+		return phraser.A(phraser.ActFailEntity, map[string]string{"name": displayName})
 	}
 	// One record per hop: the second write this used to make said the same
 	// thing under a different key, in a different shape.
@@ -630,5 +631,5 @@ func (h *reactiveHandler) execHexis(ctx context.Context, capID, capName, entityI
 		"entity_id": entityID, "entity_name": displayName,
 		"capability": capName, "causation_id": causationID,
 	})
-	return "команда выполнена для " + displayName + "."
+	return phraser.A(phraser.ActDoneEntity, map[string]string{"name": displayName})
 }

cmd/mavend/feeds_test.go

@@ -79,7 +79,7 @@ func TestQueryFeedsByCategory(t *testing.T) {
 		t.Fatalf("reply = %q, want only the технологии item", reply)
 	}
 	reply, _ = askFeeds(t, h, "что нового по спорту?")
-	if !strings.Contains(reply, "ничего") {
+	if !phraser.IsQ(phraser.QueryFeedsTopic, nil, reply) {
 		t.Fatalf("reply = %q, want an honest empty answer for an unread category", reply)
 	}
 }
@@ -94,7 +94,7 @@ func TestQueryFeedsOffAndEmptyDiffer(t *testing.T) {
 	}
 	on := buildFeedHandler(t, true)
 	reply, ok = askFeeds(t, on, "что нового в лентах?")
-	if !ok || !strings.Contains(reply, "ничего нового") {
+	if !ok || !phraser.IsQ(phraser.QueryFeedsEmpty, nil, reply) {
 		t.Fatalf("feeds on but empty: reply = %q, ok = %v", reply, ok)
 	}
 }

cmd/mavend/netscan.go

@@ -11,6 +11,7 @@ import (
 	"github.com/kami/maven/internal/config"
 	"github.com/kami/maven/internal/ipc"
 	"github.com/kami/maven/internal/netscan"
+	"github.com/kami/maven/internal/phraser"
 )
 
 // scanBudget — the whole spoken scan, end to end. A voice turn that takes
@@ -106,7 +107,7 @@ func (w *netWiring) scanSummary(ctx context.Context) (string, bool) {
 	res, err := w.scan(ctx)
 	if err != nil {
 		log.Printf("netscan: scan: %v", err)
-		return "не получилось просканировать сеть.", true
+		return phraser.Q(phraser.QueryFailNetscan, nil), true
 	}
 	// A truncated run is not a statement about the LAN. Saying "нашла 6
 	// устройств" after stopping two thirds of the way through the range is a
@@ -116,7 +117,7 @@ func (w *netWiring) scanSummary(ctx context.Context) (string, bool) {
 		tail = ", но успела посмотреть не всю сеть"
 	}
 	if len(res.Hosts) == 0 {
-		return "в сети никого не нашла" + tail + ".", true
+		return phraser.Q(phraser.QueryNetEmpty, map[string]string{"tail": tail}), true
 	}
 	out := fmt.Sprintf("нашла %d %s", len(res.Hosts), hostWord(len(res.Hosts)))
 	if shape := scanShape(res.Hosts); shape != "" {

cmd/mavend/netscan_test.go

@@ -10,6 +10,8 @@ import (
 
 	"github.com/kami/maven/internal/config"
 	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/phraser"
+	"github.com/kami/maven/internal/router"
 )
 
 func TestWireNetScanOffUnlessEnabled(t *testing.T) {
@@ -169,3 +171,22 @@ func TestScanSummarySpeaksACountAndWritesTheAddresses(t *testing.T) {
 		t.Errorf("a repeat question rescanned and rewrote the record (%d notes)", api.n)
 	}
 }
+
+// An unconfigured scanner names the gap instead of declining the turn.
+//
+// Falling through sent "какие устройства в сети?" to the search leg, which
+// answered with a paragraph about routers in general — and put a question about
+// his own LAN on an upstream engine, which the personal boundary exists to
+// prevent (Vikunja #479).
+func TestQueryNetworkNamesTheGapWhenNotConfigured(t *testing.T) {
+	h := &reactiveHandler{}
+	reply, ok := h.queryNetwork(context.Background(), &queryTurn{
+		dec: router.Decision{Utterance: "какие устройства в сети?"},
+	})
+	if !ok {
+		t.Fatal("an unconfigured scanner let the question fall through to search")
+	}
+	if !phraser.IsQ(phraser.QueryNetOff, nil, reply) {
+		t.Errorf("got %q, want the gap named", reply)
+	}
+}

cmd/mavend/query_recall_test.go

@@ -121,8 +121,8 @@ func TestQueryRecallNoteCanWin(t *testing.T) {
 			{text: "выучил пару аккордов", score: 0.50, kind: "note"},
 		})
 		reply := askQuery(t, h, q)
-		if want := "вот что я нашла: молоко стоит в холодильнике"; reply != want {
-			t.Errorf("reply %q, want %q", reply, want)
+		if !phraser.IsSourcesFallback(reply, "молоко стоит в холодильнике") {
+			t.Errorf("reply %q, want the note read back", reply)
 		}
 		// One text, the winning memory's — the answer came from the memory
 		// pass, not from handing the phraser every note in the table.
@@ -151,7 +151,7 @@ func TestQueryRecallNoteCanWin(t *testing.T) {
 			{text: "молоко стоит в холодильнике", score: 0.860, kind: "note"},
 			{text: "молоко закончилось", score: 0.858, kind: "note"},
 		})
-		if reply := askQuery(t, h, q); reply != "не знаю." {
+		if reply := askQuery(t, h, q); !phraser.IsUnknownFallback(reply) {
 			t.Errorf("reply %q, want silence", reply)
 		}
 	})

cmd/mavend/quiet_toggle.go

@@ -11,6 +11,7 @@ import (
 	"unicode"
 
 	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/phraser"
 )
 
 // resolveQuietToggle — pre-route keyword check. Returns (reply, true) when
@@ -32,10 +33,10 @@ func (h *reactiveHandler) resolveQuietToggle(ctx context.Context, text string, s
 		return "", false
 	}
 	val := "false"
-	reply := "тихий режим выключен."
+	reply := phraser.Ack(phraser.AckQuietOff, nil)
 	if on {
 		val = "true"
-		reply = "тихий режим включён. буду реже напоминать."
+		reply = phraser.Ack(phraser.AckQuietOn, nil)
 	}
 	if _, err := h.api.WriteFact(ctx, ipc.WriteFactReq{
 		Ts:         h.now(),
@@ -46,7 +47,7 @@ func (h *reactiveHandler) resolveQuietToggle(ctx context.Context, text string, s
 		Confidence: 1.0,
 	}); err != nil {
 		log.Printf("voice: write quiet_hours: %v", err)
-		return "не получилось переключить тихий режим.", true
+		return phraser.Ack(phraser.FailQuiet, nil), true
 	}
 	return reply, true
 }

cmd/mavend/replier_llm_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/kami/maven/internal/llm"
+	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/voice"
 )
@@ -29,12 +30,12 @@ func TestLLMReplierPassesTheModelReplyThrough(t *testing.T) {
 
 func TestLLMReplierFallsBackToStubOnError(t *testing.T) {
 	r := newLLMReplier(stubCompleter{err: errReplierTest}, nil)
-	assertStub(t, r, router.Decision{Intent: router.IntentNote}, "llm error")
+	assertAck(t, r, router.Decision{Intent: router.IntentNote}, phraser.AckNote, "llm error")
 }
 
 func TestLLMReplierFallsBackToStubOnEmpty(t *testing.T) {
 	r := newLLMReplier(stubCompleter{out: ""}, nil)
-	assertStub(t, r, router.Decision{Intent: router.IntentNote}, "empty llm")
+	assertAck(t, r, router.Decision{Intent: router.IntentNote}, phraser.AckNote, "empty llm")
 }
 
 func TestLLMReplierClarifyUsesStub(t *testing.T) {
@@ -42,6 +43,16 @@ func TestLLMReplierClarifyUsesStub(t *testing.T) {
 	assertStub(t, r, router.Decision{Clarify: true}, "clarify")
 }
 
+// assertAck — the stub picks between variants now, so two calls to it are not
+// expected to match. What must hold is that the reply is a line that entry can
+// produce, which is the same claim without pinning one wording.
+func assertAck(t *testing.T, r *llmReplier, d router.Decision, key, what string) {
+	t.Helper()
+	if got := r.Reply(d); !phraser.IsAck(key, nil, got) {
+		t.Errorf("on %s: got %q, want a %q line", what, got, key)
+	}
+}
+
 func assertStub(t *testing.T, r *llmReplier, d router.Decision, what string) {
 	t.Helper()
 	got, want := r.Reply(d), voice.NewStubReplier().Reply(d)

cmd/mavend/smarthome.go

@@ -4,10 +4,12 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"strconv"
 	"strings"
 	"time"
 
 	"github.com/kami/maven/internal/config"
+	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/smarthome"
 	"github.com/kami/maven/internal/store"
 )
@@ -140,10 +142,10 @@ func (w *homeWiring) homeSummary(ctx context.Context) (string, bool) {
 	ents, err := w.client.States(ctx)
 	if err != nil {
 		log.Printf("smarthome: summary: %v", err)
-		return "не смогла достучаться до дома.", true
+		return phraser.A(phraser.HomeUnreachable, nil), true
 	}
 	if len(ents) == 0 {
-		return "дом ничего не отдаёт.", true
+		return phraser.A(phraser.HomeEmpty, nil), true
 	}
 	var on []string
 	var sensors []string
@@ -177,7 +179,7 @@ func (w *homeWiring) homeSummary(ctx context.Context) (string, bool) {
 		}
 		// Silent truncation on a status read is the same failure as the cap
 		// one layer up: she has to say the list is not the whole list.
-		line := "включено: " + strings.Join(shown, ", ")
+		line := phraser.A(phraser.HomeOn, map[string]string{"items": strings.Join(shown, ", ")})
 		if rest > 0 {
 			line += fmt.Sprintf(" и ещё %d", rest)
 		}
@@ -185,7 +187,10 @@ func (w *homeWiring) homeSummary(ctx context.Context) (string, bool) {
 	case dark > 0 && len(sensors) == 0:
 		// Nothing is on and everything she can see is unreachable. "всё
 		// выключено" would be a claim about the house she cannot make.
-		return fmt.Sprintf("дом молчит: %d %s не отвечают.", dark, hostWord(dark)), true
+		return phraser.A(phraser.HomeDark, map[string]string{
+			"count": strconv.Itoa(dark),
+			"word":  hostWord(dark),
+		}), true
 	default:
 		parts = append(parts, "всё выключено")
 	}

cmd/mavend/snooze.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/store"
 )
 
@@ -51,10 +52,10 @@ func (h *reactiveHandler) resolveSnooze(ctx context.Context, text string, src tu
 	}
 	if err := h.api.ResolveNudge(ctx, target.ID, store.NudgeSnoozed, now); err != nil {
 		log.Printf("voice: snooze nudge %d (%s, %s): %v", target.ID, target.Rule, src, err)
-		return "не получилось отложить.", true
+		return phraser.Ack(phraser.FailSnooze, nil), true
 	}
 	log.Printf("voice: snoozed nudge %d (rule %s) from %s", target.ID, target.Rule, src)
-	return "хорошо, вернусь к этому позже.", true
+	return phraser.Ack(phraser.AckSnooze, nil), true
 }
 
 // pendingNudge — the newest still-pending nudge sent inside snoozeWindow.

cmd/mavend/voicewire.go

@@ -379,6 +379,9 @@ func buildRouter(emb router.Embedder, acts router.ActMatcher, threshold float64,
 	// question and must keep reaching replySystem, while "что у меня сегодня"
 	// is an agenda question and must not.
 	grammars = append(grammars, router.AgendaQueryGrammars()...)
+	// After the agenda rules: "расскажи, что у меня сегодня" is an agenda
+	// question first and a narrative request second (Vikunja #498).
+	grammars = append(grammars, router.NarrativeQueryGrammars()...)
 	grammars = append(grammars, router.ReminderGrammar())
 	return router.New(router.Config{
 		Grammars:   grammars,

cmd/mavend/worldmodel.go

@@ -23,7 +23,11 @@ type worldPhraser interface {
 // question about his meeting came back as a swimming competition in Nottingham.
 // Naming the gap is the rule CLAUDE.md already applies to a sibling service
 // being down.
-const worldGap = "сейчас не могу ответить — большая модель недоступна, а придумывать не хочу."
+//
+// The wording lives in fallbacks_ru_v1.json and is fixed there, not picked from
+// variants: this sentence names one specific gap and must not drift into a
+// general "I don't know".
+func worldGap() string { return phraser.WorldGap() }
 
 // phraseWorld asks the world model, or reports the gap.
 //

cmd/mavend/worldmodel_test.go

@@ -35,7 +35,7 @@ func TestQueryGeneralNamesTheGap(t *testing.T) {
 	if !ok {
 		t.Fatal("queryGeneral passed on the last source in the chain")
 	}
-	if reply != worldGap {
+	if reply != worldGap() {
 		t.Fatalf("reply = %q, want the named gap", reply)
 	}
 	if g.worldCalls != 1 {
@@ -51,7 +51,7 @@ func TestQueryGeneralWithoutAWorldModelIsUnchanged(t *testing.T) {
 	if !ok {
 		t.Fatal("queryGeneral passed on the last source in the chain")
 	}
-	if reply != "не знаю." {
+	if !phraser.IsUnknownFallback(reply) {
 		t.Fatalf("reply = %q, want the Stub's answer", reply)
 	}
 }
@@ -61,12 +61,12 @@ func TestQueryGeneralWithoutAWorldModelIsUnchanged(t *testing.T) {
 // English in it.
 func TestWorldGapIsInPersona(t *testing.T) {
 	for _, bad := range []string{"вы", "ваш", "рад ", "дорогой", "милый"} {
-		if strings.Contains(worldGap, bad) {
-			t.Errorf("the gap phrase contains %q: %s", bad, worldGap)
+		if strings.Contains(worldGap(), bad) {
+			t.Errorf("the gap phrase contains %q: %s", bad, worldGap())
 		}
 	}
-	if strings.ContainsAny(worldGap, "abcdefghijklmnopqrstuvwxyz") {
-		t.Errorf("the gap phrase has Latin letters in it: %s", worldGap)
+	if strings.ContainsAny(worldGap(), "abcdefghijklmnopqrstuvwxyz") {
+		t.Errorf("the gap phrase has Latin letters in it: %s", worldGap())
 	}
 }
 

internal/memory/behavior.go

@@ -3,8 +3,11 @@ package memory
 import (
 	"fmt"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
+
+	"github.com/kami/maven/internal/say"
 )
 
 // Behavioural memory — "what do I usually do?" (Vikunja #254).
@@ -337,13 +340,14 @@ func (p Profile) FormatWeekdayRU(wd time.Weekday) string {
 	day := weekdayRU[int(wd)%7]
 	acts := p.Weekly[wd]
 	if len(acts) > 0 {
-		return fmt.Sprintf("по %s ты обычно %s.", day, joinActivities(acts))
+		return say.S(say.HabitWeekday, map[string]string{"day": day, "items": joinActivities(acts)})
 	}
 	if len(p.Everyday) > 0 {
-		return fmt.Sprintf("по %s у тебя нет ничего особенного — то же, что и в остальные дни: %s.",
-			day, joinActivities(p.Everyday))
+		return say.S(say.HabitWeekdaySame, map[string]string{
+			"day": day, "items": joinActivities(p.Everyday),
+		})
 	}
-	return fmt.Sprintf("по %s я пока не вижу у тебя ничего постоянного.", day)
+	return say.S(say.HabitWeekdayNone, map[string]string{"day": day})
 }
 
 // FormatWeekendRU reads back what distinguishes Saturday and Sunday.
@@ -355,19 +359,17 @@ func (p Profile) FormatWeekendRU() string {
 	sat, sun := p.Weekly[time.Saturday], p.Weekly[time.Sunday]
 	switch {
 	case len(sat) > 0 && len(sun) > 0:
-		return fmt.Sprintf("по субботам ты обычно %s, по воскресеньям — %s.",
-			joinActivities(sat), joinActivities(sun))
+		return say.S(say.HabitWeekendBoth, map[string]string{
+			"sat": joinActivities(sat), "sun": joinActivities(sun),
+		})
 	case len(sat) > 0:
-		return fmt.Sprintf("по субботам ты обычно %s, а по воскресеньям ничего постоянного.",
-			joinActivities(sat))
+		return say.S(say.HabitWeekendSat, map[string]string{"items": joinActivities(sat)})
 	case len(sun) > 0:
-		return fmt.Sprintf("по воскресеньям ты обычно %s, а по субботам ничего постоянного.",
-			joinActivities(sun))
+		return say.S(say.HabitWeekendSun, map[string]string{"items": joinActivities(sun)})
 	case len(p.Everyday) > 0:
-		return fmt.Sprintf("по выходным у тебя нет ничего особенного — то же, что и в остальные дни: %s.",
-			joinActivities(p.Everyday))
+		return say.S(say.HabitWeekendSame, map[string]string{"items": joinActivities(p.Everyday)})
 	}
-	return "по выходным я пока не вижу у тебя ничего постоянного."
+	return say.S(say.HabitWeekendNone, nil)
 }
 
 // FormatOverallRU reads back the habits that hold across the whole week, and
@@ -378,19 +380,23 @@ func (p Profile) FormatWeekendRU() string {
 // a year of them, and only one of those is worth believing.
 func (p Profile) FormatOverallRU() string {
 	if len(p.All) == 0 {
-		return "я ещё не набрала достаточно записей, чтобы говорить о привычках."
+		return say.S(say.HabitOverallNone, nil)
 	}
-	return fmt.Sprintf("обычно ты %s — %s.", joinActivities(p.All), p.spanRU())
+	return say.S(say.HabitOverall, map[string]string{
+		"items": joinActivities(p.All), "span": p.spanRU(),
+	})
 }
 
 // spanRU — "по записям за последние N дней", or a vaguer phrase when the window
 // is too short to name in days.
 func (p Profile) spanRU() string {
 	if p.Since.IsZero() || !p.Until.After(p.Since) {
-		return "по записям за сегодня"
+		return say.S(say.HabitSpanToday, nil)
 	}
 	days := int(p.Until.Sub(p.Since).Hours()/24) + 1
-	return fmt.Sprintf("по записям за последние %d %s", days, pluralDaysRU(days))
+	return say.S(say.HabitSpanDays, map[string]string{
+		"n": strconv.Itoa(days), "word": pluralDaysRU(days),
+	})
 }
 
 // pluralDaysRU — the Russian count form of "день" for n.
@@ -423,14 +429,18 @@ func joinActivities(acts []Activity) string {
 			// come from the model, so an unglossed one is as likely to be
 			// "выпил_воды" as a noun, and "обычно ты выпил_воды около 09:00" is
 			// not a sentence.
-			gloss = fmt.Sprintf("отмечаешь «%s»", strings.ReplaceAll(a.Key, "_", " "))
+			gloss = say.S(say.HabitUnglossed, map[string]string{
+				"key": strings.ReplaceAll(a.Key, "_", " "),
+			})
 		}
 		if !a.HasTypical {
 			parts[i] = gloss
 			continue
 		}
-		parts[i] = fmt.Sprintf("%s около %02d:%02d", gloss,
-			int(a.TypicalAt.Hours()), int(a.TypicalAt.Minutes())%60)
+		parts[i] = say.S(say.HabitAt, map[string]string{
+			"gloss": gloss,
+			"time":  fmt.Sprintf("%02d:%02d", int(a.TypicalAt.Hours()), int(a.TypicalAt.Minutes())%60),
+		})
 	}
 	if len(parts) == 1 {
 		return parts[0]

internal/memory/behavior_test.go

@@ -5,6 +5,8 @@ import (
 	"testing"
 	"time"
 	"unicode"
+
+	"github.com/kami/maven/internal/say"
 )
 
 // habitHistory — n weeks of the same weekday, at the given local time.
@@ -70,7 +72,7 @@ func TestBuildProfileNeedsMoreThanOneDay(t *testing.T) {
 	if len(p.All) != 0 || len(p.Weekly) != 0 {
 		t.Fatalf("one day of rows must produce no habit: %+v / %+v", p.All, p.Weekly)
 	}
-	if got := p.FormatOverallRU(); !strings.Contains(got, "не набрала достаточно") {
+	if got := p.FormatOverallRU(); !say.IsS(say.HabitOverallNone, nil, got) {
 		t.Errorf("empty profile reads %q", got)
 	}
 }
@@ -203,7 +205,9 @@ func TestWeekdayProfileExcludesEverydayHabits(t *testing.T) {
 	// A day with nothing of its own says so rather than reciting water as if
 	// Wednesday were the reason for it.
 	wed := p.FormatWeekdayRU(time.Wednesday)
-	if !strings.Contains(wed, "ничего особенного") || !strings.Contains(wed, "воду") {
+	if !say.IsS(say.HabitWeekdaySame, map[string]string{
+		"day": "средам", "items": "пьёшь воду около 13:30",
+	}, wed) {
 		t.Fatalf("plain weekday readout should say the day is unremarkable and name the daily habits: %q", wed)
 	}
 }

internal/morning/plan.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/kami/maven/internal/say"
 	"github.com/kami/maven/internal/store"
 )
 
@@ -164,17 +165,20 @@ func (p Plan) FormatRU() string {
 		// it is over, and saying it was empty is a false statement about a day
 		// he just lived.
 		if p.Rest {
-			return "на сегодня больше ничего не запланировано."
+			return say.S(say.PlanRestEmpty, nil)
 		}
-		return fmt.Sprintf("на %s ничего не запланировано.", p.Date.Format("02.01.2006"))
+		return say.S(say.PlanDayEmpty, map[string]string{"date": p.Date.Format("02.01.2006")})
 	}
 	parts := make([]string, len(p.Items))
 	for i, it := range p.Items {
 		line := fmt.Sprintf("%s — %s", it.At.Format("15:04"), it.Text)
 		if it.Uncertain {
-			line = "похоже, " + line
+			line = say.S(say.PlanUncertain, map[string]string{"line": line})
 		}
 		parts[i] = line
 	}
-	return fmt.Sprintf("план на %s: %s.", p.Date.Format("02.01.2006"), strings.Join(parts, "; "))
+	return say.S(say.PlanDay, map[string]string{
+		"date":  p.Date.Format("02.01.2006"),
+		"items": strings.Join(parts, "; "),
+	})
 }

internal/phraser/ack_ru_v1.json

@@ -0,0 +1,84 @@
+{
+  "schema_version": 1,
+  "name": "russian capture acknowledgements v1",
+  "notes": [
+    "What she says after storing something he said, and what she says when storing it failed. Edit the wording here, no Go changes needed.",
+    "Rules: she is feminine about herself, he is a man addressed as ты. Never вы/вас/ваш, never он/его about him. No pet names.",
+    "He hears these many times a day, so most entries carry variants: identical wording is what makes a confirmation stop registering as one.",
+    "Placeholders: {key} {value} the fact he stated, {fn} the action, {text} the task title. His data is interpolated Go-side — the file holds the frame, never his words.",
+    "An acknowledgement confirms and stops. It does not ask a follow-up question and it does not editorialise about what he stored."
+  ],
+  "entries": {
+    "ack_fact": {
+      "variants": ["записала факт.", "записала.", "запомнила."]
+    },
+    "ack_fact_key": {
+      "variants": ["отметила: {key}", "записала: {key}", "запомнила: {key}"]
+    },
+    "ack_fact_kv": {
+      "variants": ["отметила: {key} = {value}", "записала: {key} — {value}", "запомнила: {key} — {value}"]
+    },
+    "ack_note": {
+      "variants": ["сохранила заметку.", "заметка сохранена.", "записала в заметки."]
+    },
+    "ack_reminder": {
+      "variants": ["напомню.", "напомню, не забуду.", "хорошо, напомню."]
+    },
+    "ack_act": {
+      "variants": ["ок, записала действие: {fn}", "приняла действие: {fn}"]
+    },
+    "ack_task": {
+      "variants": ["записала: {text}", "добавила в задачи: {text}", "внесла в список: {text}"]
+    },
+    "ack_task_urgent": {
+      "variants": ["поняла, беру в работу: {text}", "поняла, это срочно: {text}"]
+    },
+    "ack_task_duplicate": {
+      "variants": ["это уже в списке.", "такое уже есть в задачах."]
+    },
+    "ack_nudge": {
+      "variants": ["отлично, отметила.", "отметила.", "хорошо, отметила."]
+    },
+    "ack_snooze": {
+      "variants": ["хорошо, вернусь к этому позже.", "ладно, напомню попозже.", "хорошо, отложила."]
+    },
+    "ack_generic": {
+      "variants": ["приняла.", "поняла."]
+    },
+    "quiet_on": {
+      "fixed": true,
+      "variants": ["тихий режим включён. буду реже напоминать."]
+    },
+    "quiet_off": {
+      "fixed": true,
+      "variants": ["тихий режим выключен."]
+    },
+    "fail_fact": {
+      "variants": ["не получилось сохранить факт.", "факт не сохранился."]
+    },
+    "fail_note": {
+      "variants": ["не получилось сохранить заметку.", "заметка не сохранилась."]
+    },
+    "fail_reminder": {
+      "variants": ["не получилось поставить напоминание.", "напоминание не поставилось."]
+    },
+    "fail_reminder_time": {
+      "variants": ["не получилось разобрать время напоминания.", "не поняла, на когда напомнить."]
+    },
+    "fail_task": {
+      "variants": ["не получилось записать задачу.", "задача не записалась."]
+    },
+    "fail_ack": {
+      "variants": ["не получилось отметить.", "не смогла отметить."]
+    },
+    "fail_snooze": {
+      "variants": ["не получилось отложить.", "не смогла отложить."]
+    },
+    "fail_quiet": {
+      "variants": ["не получилось переключить тихий режим.", "тихий режим не переключился."]
+    },
+    "fail_fact_unparsed": {
+      "variants": ["не разобрала, что записать — попробуй иначе.", "не поняла, что записать. скажи иначе?"]
+    }
+  }
+}

internal/phraser/acks.go

@@ -0,0 +1,164 @@
+package phraser
+
+// The capture acknowledgements — what she says after storing something he said,
+// and what she says when storing it failed.
+//
+// They were string literals in eight files under cmd/mavend plus the stub
+// replier in internal/voice. He hears them many times a day, which is exactly
+// why they need variants and exactly why rewording one must not be a rebuild.
+// Same shape as fallbacks_ru_v1.json, on the shared deck (deck.go).
+//
+// His data stays Go-side. The file holds "отметила: {key} = {value}"; the key
+// and the value are interpolated here, so nothing he said lives in the copy.
+
+import (
+	_ "embed"
+	"log"
+	"math/rand"
+	"sync"
+
+	"github.com/kami/maven/internal/say"
+)
+
+//go:embed ack_ru_v1.json
+var ackJSON []byte
+
+// AckSchemaVersion — this family's own version. A file that changes on a
+// different day than the fallbacks cannot share their number (Vikunja #397).
+const AckSchemaVersion = 1
+
+// The entry keys. Namespaced by family, because the floor map behind a nil deck
+// is process-wide.
+const (
+	AckFact          = "ack_fact"
+	AckFactKey       = "ack_fact_key"
+	AckFactValue     = "ack_fact_kv"
+	AckNote          = "ack_note"
+	AckReminder      = "ack_reminder"
+	AckAct           = "ack_act"
+	AckTask          = "ack_task"
+	AckTaskUrgent    = "ack_task_urgent"
+	AckTaskDuplicate = "ack_task_duplicate"
+	AckNudge         = "ack_nudge"
+	AckSnooze        = "ack_snooze"
+	AckGeneric       = "ack_generic"
+	AckQuietOn       = "quiet_on"
+	AckQuietOff      = "quiet_off"
+
+	FailFact         = "fail_fact"
+	FailFactUnparsed = "fail_fact_unparsed"
+	FailNote         = "fail_note"
+	FailReminder     = "fail_reminder"
+	FailReminderTime = "fail_reminder_time"
+	FailTask         = "fail_task"
+	FailAck          = "fail_ack"
+	FailSnooze       = "fail_snooze"
+	FailQuiet        = "fail_quiet"
+)
+
+// ackKeys — every key the code requires the file to define.
+var ackKeys = []string{
+	AckFact, AckFactKey, AckFactValue, AckNote, AckReminder, AckAct,
+	AckTask, AckTaskUrgent, AckTaskDuplicate, AckNudge, AckSnooze, AckGeneric,
+	AckQuietOn, AckQuietOff,
+	FailFact, FailFactUnparsed, FailNote, FailReminder, FailReminderTime,
+	FailTask, FailAck, FailSnooze, FailQuiet,
+}
+
+// ackFloor — the literal each key falls back to when the file is unusable.
+// These are the exact strings that lived in Go before this file existed.
+var ackFloor = say.RegisterFloor(map[string]string{
+	AckFact:          "записала факт.",
+	AckFactKey:       "отметила: {key}",
+	AckFactValue:     "отметила: {key} = {value}",
+	AckNote:          "сохранила заметку.",
+	AckReminder:      "напомню.",
+	AckAct:           "ок, записала действие: {fn}",
+	AckTask:          "записала: {text}",
+	AckTaskUrgent:    "поняла, беру в работу: {text}",
+	AckTaskDuplicate: "это уже в списке.",
+	AckNudge:         "отлично, отметила.",
+	AckSnooze:        "хорошо, вернусь к этому позже.",
+	AckGeneric:       "приняла.",
+	AckQuietOn:       "тихий режим включён. буду реже напоминать.",
+	AckQuietOff:      "тихий режим выключен.",
+
+	FailFact:         "не получилось сохранить факт.",
+	FailFactUnparsed: "не разобрала, что записать — попробуй иначе.",
+	FailNote:         "не получилось сохранить заметку.",
+	FailReminder:     "не получилось поставить напоминание.",
+	FailReminderTime: "не получилось разобрать время напоминания.",
+	FailTask:         "не получилось записать задачу.",
+	FailAck:          "не получилось отметить.",
+	FailSnooze:       "не получилось отложить.",
+	FailQuiet:        "не получилось переключить тихий режим.",
+})
+
+// Acks picks a hand-written Russian acknowledgement. Safe for concurrent use.
+type Acks struct{ d *say.Deck }
+
+// LoadAcks reads the embedded file. Pass a source to make the picking
+// reproducible in tests; nil seeds from the clock.
+func LoadAcks(src rand.Source) (*Acks, error) {
+	d, err := say.Load(ackJSON, AckSchemaVersion, ackKeys, ackFloor, src)
+	if err != nil {
+		return nil, err
+	}
+	// The three entries that exist to read his own words back. A variant
+	// without the placeholder would confirm the capture and drop what was
+	// captured, which reads as a successful save of nothing.
+	for _, req := range []struct{ key, ph string }{
+		{AckFactKey, "{key}"}, {AckFactValue, "{key}"}, {AckFactValue, "{value}"},
+		{AckAct, "{fn}"}, {AckTask, "{text}"}, {AckTaskUrgent, "{text}"},
+	} {
+		if err := d.RequirePlaceholder(req.key, req.ph); err != nil {
+			return nil, err
+		}
+	}
+	return &Acks{d: d}, nil
+}
+
+// deck reads through a nil *Acks, which is the unloadable-file case.
+func (a *Acks) deck() *say.Deck {
+	if a == nil {
+		return nil
+	}
+	return a.d
+}
+
+// Say returns one line for key, with his data filled into the frame. Pass nil
+// when the entry takes none.
+func (a *Acks) Say(key string, vars map[string]string) string {
+	return a.deck().Text(key, vars)
+}
+
+// Variants returns every line the file can produce, for the persona scorer.
+func (a *Acks) Variants() []string { return a.deck().Variants() }
+
+var (
+	ackOnce sync.Once
+	acks    *Acks
+)
+
+// DefaultAcks returns the shared instance, loading it on first use. A broken
+// file logs once and leaves a nil *Acks, which still answers from ackFloor.
+func DefaultAcks() *Acks {
+	ackOnce.Do(func() {
+		a, err := LoadAcks(nil)
+		if err != nil {
+			log.Printf("phraser: acknowledgements unavailable, using the built-in lines: %v", err)
+			return
+		}
+		acks = a
+	})
+	return acks
+}
+
+// Ack — one acknowledgement line, the way every caller says it.
+func Ack(key string, vars map[string]string) string { return DefaultAcks().Say(key, vars) }
+
+// IsAck reports whether text is a line key could have produced. For the daemon
+// tests, which can no longer compare against one literal.
+func IsAck(key string, vars map[string]string, text string) bool {
+	return DefaultAcks().deck().Matches(key, vars, text)
+}

internal/phraser/acts.go

@@ -0,0 +1,186 @@
+package phraser
+
+// The act and smart-home replies — what she says when a capability ran, refused,
+// or could not be reached.
+//
+// Fourth family on the shared deck (deck.go). They were literals in
+// ecosystem_acts.go, actions_act.go and smarthome.go, where a reworded line was
+// a rebuild of the daemon that executes his house.
+//
+// The four outcomes stay four entries. Reporting a refusal with the wording of
+// a success is the one failure mode this family can have, and a shared variant
+// set is how it would happen.
+
+import (
+	_ "embed"
+	"log"
+	"math/rand"
+	"sync"
+
+	"github.com/kami/maven/internal/say"
+)
+
+//go:embed acts_ru_v1.json
+var actJSON []byte
+
+// ActSchemaVersion — this family's own version.
+const ActSchemaVersion = 1
+
+// The entry keys.
+const (
+	ActDone          = "act_done"
+	ActDoneOut       = "act_done_out"
+	ActDoneEntity    = "act_done_entity"
+	ActConfirm       = "act_confirm"
+	ActConfirmEntity = "act_confirm_entity"
+	ActWhich         = "act_which"
+	ActFail          = "act_fail"
+	ActFailOut       = "act_fail_out"
+	ActFailEntity    = "act_fail_entity"
+	ActServerDown    = "act_server_down"
+	ActWithdrawn     = "act_withdrawn"
+	ActNeedsArgs     = "act_needs_args"
+
+	EcoDenied        = "eco_denied"
+	EcoDown          = "eco_down"
+	EcoAmbiguous     = "eco_ambiguous"
+	EcoUnknownEntity = "eco_unknown_entity"
+	EcoNoNexus       = "eco_no_nexus"
+	EcoAboutWhat     = "eco_about_what"
+	EcoRecall        = "eco_recall"
+
+	AttentionNone       = "attention_none"
+	AttentionList       = "attention_list"
+	AttentionFail       = "attention_fail"
+	AttentionNoneEntity = "attention_none_entity"
+	AttentionListEntity = "attention_list_entity"
+	AttentionFailEntity = "attention_fail_entity"
+	ChangesNone         = "changes_none"
+	ChangesList         = "changes_list"
+	ChangesFail         = "changes_fail"
+	HomeUnreachable     = "home_unreachable"
+	HomeEmpty           = "home_empty"
+	HomeOn              = "home_on"
+	HomeDark            = "home_dark"
+)
+
+var actKeys = []string{
+	ActDone, ActDoneOut, ActDoneEntity, ActConfirm, ActConfirmEntity, ActWhich,
+	ActFail, ActFailOut, ActFailEntity, ActServerDown, ActWithdrawn, ActNeedsArgs,
+	EcoDenied, EcoDown, EcoAmbiguous, EcoUnknownEntity, EcoNoNexus, EcoAboutWhat, EcoRecall,
+	AttentionNone, AttentionList, AttentionFail,
+	AttentionNoneEntity, AttentionListEntity, AttentionFailEntity,
+	ChangesNone, ChangesList, ChangesFail,
+	HomeUnreachable, HomeEmpty, HomeOn, HomeDark,
+}
+
+// actFloor — the literal each key falls back to when the file is unusable.
+// These are the exact strings that lived in Go before this file existed.
+var actFloor = say.RegisterFloor(map[string]string{
+	ActDone:          "готово.",
+	ActDoneOut:       "готово: {out}",
+	ActDoneEntity:    "команда выполнена для {name}.",
+	ActConfirm:       "выполнить «{name}»? скажи «да» или «нет».",
+	ActConfirmEntity: "выполнить «{name}» для {entity}? скажи «да» или «нет».",
+	ActWhich:         "какую команду для {name}: {items}?",
+	ActFail:          "не получилось выполнить команду.",
+	ActFailOut:       "не получилось выполнить команду: {out}",
+	ActFailEntity:    "не получилось выполнить команду для {name}.",
+	ActServerDown:    "этот инструмент включён, но сервер, который его выполняет, сейчас не подключён.",
+	ActWithdrawn:     "сервер больше не предлагает этот инструмент — я сняла его с разрешённых, посмотри на /tools.",
+	ActNeedsArgs:     "этому инструменту нужны аргументы, которые я из голоса не соберу — я не буду угадывать.",
+
+	EcoDenied:        "экосистема отклоняет доступ, проверь токен.",
+	EcoDown:          "экосистема недоступна, попробуй ещё раз.",
+	EcoAmbiguous:     "уточни, что именно: {items}?",
+	EcoUnknownEntity: "не знаю такой сущности.",
+	EcoNoNexus:       "не могу связать это с сущностью — Nexus не настроен.",
+	EcoAboutWhat:     "про что именно спросить?",
+	EcoRecall:        "я помню: {items}",
+
+	AttentionNone:       "ничего не требует внимания.",
+	AttentionList:       "требует внимания: {items}",
+	AttentionFail:       "не могу сейчас узнать, что требует внимания.",
+	AttentionNoneEntity: "по «{name}» ничего нет.",
+	AttentionListEntity: "по «{name}»: {items}",
+	AttentionFailEntity: "не могу сейчас узнать, что требует внимания по «{name}».",
+	ChangesNone:         "нет изменений.",
+	ChangesList:         "изменения: {items}",
+	ChangesFail:         "не могу сейчас узнать об изменениях.",
+	HomeUnreachable:     "не смогла достучаться до дома.",
+	HomeEmpty:           "дом ничего не отдаёт.",
+	HomeOn:              "включено: {items}",
+	HomeDark:            "дом молчит: {count} {word} не отвечают.",
+})
+
+// Acts picks a hand-written Russian act reply. Safe for concurrent use.
+type Acts struct{ d *say.Deck }
+
+// LoadActs reads the embedded file. Pass a source to make the picking
+// reproducible in tests; nil seeds from the clock.
+func LoadActs(src rand.Source) (*Acts, error) {
+	d, err := say.Load(actJSON, ActSchemaVersion, actKeys, actFloor, src)
+	if err != nil {
+		return nil, err
+	}
+	// The entries that name what ran or what he has to choose between. A
+	// variant that dropped the name would confirm an act without saying which.
+	for _, req := range []struct{ key, ph string }{
+		{ActDoneOut, "{out}"}, {ActDoneEntity, "{name}"}, {ActFailOut, "{out}"},
+		{ActFailEntity, "{name}"}, {ActConfirm, "{name}"},
+		{ActConfirmEntity, "{name}"}, {ActConfirmEntity, "{entity}"},
+		{ActWhich, "{name}"}, {ActWhich, "{items}"},
+		{EcoAmbiguous, "{items}"}, {EcoRecall, "{items}"},
+		{AttentionList, "{items}"}, {ChangesList, "{items}"}, {HomeOn, "{items}"},
+		{AttentionNoneEntity, "{name}"}, {AttentionListEntity, "{name}"},
+		{AttentionListEntity, "{items}"}, {AttentionFailEntity, "{name}"},
+	} {
+		if err := d.RequirePlaceholder(req.key, req.ph); err != nil {
+			return nil, err
+		}
+	}
+	return &Acts{d: d}, nil
+}
+
+// deck reads through a nil *Acts, which is the unloadable-file case.
+func (a *Acts) deck() *say.Deck {
+	if a == nil {
+		return nil
+	}
+	return a.d
+}
+
+// Say returns one line for key, with the names filled into the frame.
+func (a *Acts) Say(key string, vars map[string]string) string {
+	return a.deck().Text(key, vars)
+}
+
+// Variants returns every line the file can produce, for the persona scorer.
+func (a *Acts) Variants() []string { return a.deck().Variants() }
+
+var (
+	actOnce  sync.Once
+	actsDeck *Acts
+)
+
+// DefaultActs returns the shared instance, loading it on first use. A broken
+// file logs once and leaves a nil *Acts, which still answers from actFloor.
+func DefaultActs() *Acts {
+	actOnce.Do(func() {
+		a, err := LoadActs(nil)
+		if err != nil {
+			log.Printf("phraser: act replies unavailable, using the built-in lines: %v", err)
+			return
+		}
+		actsDeck = a
+	})
+	return actsDeck
+}
+
+// A — one act reply, the way every caller says it.
+func A(key string, vars map[string]string) string { return DefaultActs().Say(key, vars) }
+
+// IsA reports whether text is a line key could have produced, for the tests.
+func IsA(key string, vars map[string]string, text string) bool {
+	return DefaultActs().deck().Matches(key, vars, text)
+}

internal/phraser/acts_ru_v1.json

@@ -0,0 +1,114 @@
+{
+  "schema_version": 1,
+  "name": "russian act and smart-home replies v1",
+  "notes": [
+    "What she says when a capability ran, refused, or could not be reached. Edit the wording here, no Go changes needed.",
+    "Rules: she is feminine about herself, he is a man addressed as ты. Never вы/вас/ваш, never он/его about him. No pet names.",
+    "\"it ran\", \"it was refused\", \"the ecosystem is down\" and \"I could not work out what you meant\" are four different truths. They keep four entries, because one variant set would let a failure report itself as a success.",
+    "Placeholders: {name} an entity or capability the caller resolved, {out} the command's own output, {items} a joined list, {count} a number. Entity names and capability ids are interpolated Go-side.",
+    "fixed: true means exactly one variant and no picking. Used where the wording carries an instruction he has to act on — a confirmation, a pointer at /tools — and for the two lines that report an act as done, because a success report that reworded itself is harder to trust and harder to test."
+  ],
+  "entries": {
+    "act_done": {
+      "fixed": true,
+      "variants": ["готово."]
+    },
+    "act_done_out": {
+      "variants": ["готово: {out}", "сделала: {out}"]
+    },
+    "act_done_entity": {
+      "fixed": true,
+      "variants": ["команда выполнена для {name}."]
+    },
+    "act_confirm": {
+      "fixed": true,
+      "variants": ["выполнить «{name}»? скажи «да» или «нет»."]
+    },
+    "act_confirm_entity": {
+      "fixed": true,
+      "variants": ["выполнить «{name}» для {entity}? скажи «да» или «нет»."]
+    },
+    "act_which": {
+      "variants": ["какую команду для {name}: {items}?"]
+    },
+    "act_fail": {
+      "variants": ["не получилось выполнить команду.", "команда не выполнилась."]
+    },
+    "act_fail_out": {
+      "variants": ["не получилось выполнить команду: {out}"]
+    },
+    "act_fail_entity": {
+      "variants": ["не получилось выполнить команду для {name}.", "команда для {name} не выполнилась."]
+    },
+    "act_server_down": {
+      "variants": ["этот инструмент включён, но сервер, который его выполняет, сейчас не подключён."]
+    },
+    "act_withdrawn": {
+      "fixed": true,
+      "variants": ["сервер больше не предлагает этот инструмент — я сняла его с разрешённых, посмотри на /tools."]
+    },
+    "act_needs_args": {
+      "variants": ["этому инструменту нужны аргументы, которые я из голоса не соберу — я не буду угадывать."]
+    },
+    "eco_denied": {
+      "variants": ["экосистема отклоняет доступ, проверь токен."]
+    },
+    "eco_down": {
+      "variants": ["экосистема недоступна, попробуй ещё раз.", "экосистема не отвечает, попробуй ещё раз."]
+    },
+    "eco_ambiguous": {
+      "variants": ["уточни, что именно: {items}?", "что именно из этого: {items}?"]
+    },
+    "eco_unknown_entity": {
+      "variants": ["не знаю такой сущности.", "такой сущности у меня нет."]
+    },
+    "eco_no_nexus": {
+      "variants": ["не могу связать это с сущностью — Nexus не настроен."]
+    },
+    "eco_about_what": {
+      "variants": ["про что именно спросить?", "про что спросить?"]
+    },
+    "eco_recall": {
+      "variants": ["я помню: {items}"]
+    },
+    "attention_none": {
+      "variants": ["ничего не требует внимания.", "внимания сейчас ничего не требует."]
+    },
+    "attention_list": {
+      "variants": ["требует внимания: {items}"]
+    },
+    "attention_fail": {
+      "variants": ["не могу сейчас узнать, что требует внимания."]
+    },
+    "attention_none_entity": {
+      "variants": ["по «{name}» ничего нет.", "по «{name}» пока пусто."]
+    },
+    "attention_list_entity": {
+      "variants": ["по «{name}»: {items}"]
+    },
+    "attention_fail_entity": {
+      "variants": ["не могу сейчас узнать, что требует внимания по «{name}»."]
+    },
+    "changes_none": {
+      "variants": ["нет изменений.", "изменений нет."]
+    },
+    "changes_list": {
+      "variants": ["изменения: {items}"]
+    },
+    "changes_fail": {
+      "variants": ["не могу сейчас узнать об изменениях."]
+    },
+    "home_unreachable": {
+      "variants": ["не смогла достучаться до дома.", "дом не отвечает."]
+    },
+    "home_empty": {
+      "variants": ["дом ничего не отдаёт.", "дом молчит."]
+    },
+    "home_on": {
+      "variants": ["включено: {items}"]
+    },
+    "home_dark": {
+      "variants": ["дом молчит: {count} {word} не отвечают."]
+    }
+  }
+}

internal/phraser/eval/fallbacks_test.go

@@ -0,0 +1,70 @@
+package eval
+
+import (
+	"math/rand"
+	"strings"
+	"testing"
+
+	"github.com/kami/maven/internal/phraser"
+	"github.com/kami/maven/internal/say"
+)
+
+// TestFallbackPersona scores every line in every hand-written family on the
+// persona checks the nudges already pass. These lines are heard out loud and
+// they live in a JSON file now, so a reworded variant that says "рад" or "вы"
+// would otherwise reach him with nothing in between.
+//
+// Only the persona checks run. Mood and topic belong to a nudge, and these are
+// not nudges.
+func TestFallbackPersona(t *testing.T) {
+	fb, err := phraser.LoadFallbacks(rand.NewSource(20260804))
+	if err != nil {
+		t.Fatalf("LoadFallbacks: %v", err)
+	}
+	// No CheckHisGender. It reads a feminine verb near a second-person pronoun
+	// as addressing him as a woman, which is right for a nudge and wrong here:
+	// "не знаю — не нашла у тебя такой записи" is her own verb in her own
+	// sentence. CheckFeminine still holds her side of the rule.
+	persona := map[string]bool{
+		CheckLang: true, CheckFeminine: true,
+		CheckAddress: true, CheckCringe: true, CheckLength: true,
+	}
+	ack, err := phraser.LoadAcks(rand.NewSource(20260804))
+	if err != nil {
+		t.Fatalf("LoadAcks: %v", err)
+	}
+	qry, err := phraser.LoadQueries(rand.NewSource(20260804))
+	if err != nil {
+		t.Fatalf("LoadQueries: %v", err)
+	}
+	variants := append(fb.Variants(), ack.Variants()...)
+	variants = append(variants, qry.Variants()...)
+	act, err := phraser.LoadActs(rand.NewSource(20260804))
+	if err != nil {
+		t.Fatalf("LoadActs: %v", err)
+	}
+	variants = append(variants, act.Variants()...)
+	sum, err := say.LoadSummaries(rand.NewSource(20260804))
+	if err != nil {
+		t.Fatalf("LoadSummaries: %v", err)
+	}
+	variants = append(variants, sum.Variants()...)
+	if len(variants) == 0 {
+		t.Fatal("no variants — the file loaded empty")
+	}
+	for _, v := range variants {
+		// The placeholders stand for his own words and carry no persona.
+		body := v
+		for _, ph := range []string{"{sources}", "{key}", "{value}", "{fn}", "{text}", "{when}", "{items}",
+			"{location}", "{temp}", "{condition}", "{tail}", "{out}", "{name}",
+			"{entity}", "{count}", "{word}",
+			"{date}", "{line}", "{n}", "{day}", "{sat}", "{sun}", "{span}", "{gloss}", "{time}"} {
+			body = strings.ReplaceAll(body, ph, "вода")
+		}
+		for _, r := range RunChecks(Case{}, body, "neutral") {
+			if persona[r.Name] && !r.Pass {
+				t.Errorf("%q fails %s: %s", v, r.Name, r.Detail)
+			}
+		}
+	}
+}

internal/phraser/failure_test.go

@@ -8,12 +8,19 @@ import (
 	"testing"
 )
 
+// isFallback — the text she says is picked from that entry's variants, so a test
+// pins the entry rather than the wording. Pinning one line would make editing
+// fallbacks_ru_v1.json break Go tests, which is the coupling this file removed.
+func isFallback(t *testing.T, key, sources, got string) bool {
+	t.Helper()
+	return DefaultFallbacks().deck().Matches(key, map[string]string{"sources": sources}, got)
+}
+
 // 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.
+// PhraseQuery keep the turn alive with canned text — and every one of those
+// lines 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)
@@ -22,19 +29,20 @@ func TestPhrasingReportsTheFailureWithTheFallback(t *testing.T) {
 	p := NewLLMPhraserAt(srv.URL, Config{})
 
 	cases := []struct {
-		name string
-		call func() (string, error)
-		want string
+		name    string
+		call    func() (string, error)
+		key     string
+		sources string
 	}{
 		{"chat", func() (string, error) {
 			return p.PhraseChat(context.Background(), "как дела", nil)
-		}, ChatFallback},
+		}, fbChat, ""},
 		{"knowledge", func() (string, error) {
 			return p.PhraseQuery(context.Background(), "кто написал войну и мир", nil)
-		}, "не знаю."},
+		}, fbQueryUnknown, ""},
 		{"evidence", func() (string, error) {
 			return p.PhraseQuery(context.Background(), "сколько воды я выпил", []string{"два литра"})
-		}, "вот что я нашла: два литра"},
+		}, fbQuerySources, "два литра"},
 	}
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
@@ -42,8 +50,8 @@ func TestPhrasingReportsTheFailureWithTheFallback(t *testing.T) {
 			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)
+			if !isFallback(t, c.key, c.sources, got) {
+				t.Errorf("fallback text = %q, want a %q variant — the daemon still has to say something", got, c.key)
 			}
 		})
 	}
@@ -63,8 +71,8 @@ func TestEmptyKnowledgeAnswerIsAnError(t *testing.T) {
 	if err == nil {
 		t.Fatal("an empty response scored as an answer")
 	}
-	if got != "не знаю." {
-		t.Errorf("fallback text = %q, want \"не знаю.\"", got)
+	if !isFallback(t, fbQueryUnknown, "", got) {
+		t.Errorf("fallback text = %q, want a %q variant", got, fbQueryUnknown)
 	}
 	if !strings.Contains(err.Error(), "empty") {
 		t.Errorf("error = %v; want it to name the empty response", err)

internal/phraser/fallbacks.go

@@ -0,0 +1,140 @@
+package phraser
+
+// The phrasing fallbacks — what she says when the model gave her nothing usable.
+//
+// They were four string literals spread across phraser.go, llmphraser.go and
+// cmd/mavend/worldmodel.go. Every one of them is a line he hears out loud, so
+// rewording one was a Go edit, a rebuild and a redeploy for what is product copy.
+//
+// The floor under the floor is deliberate. These strings exist because something
+// already failed, so a broken template file must not be able to take the last
+// words she has: every accessor falls back to the literal it replaced.
+
+import (
+	_ "embed"
+	"log"
+	"math/rand"
+	"sync"
+
+	"github.com/kami/maven/internal/say"
+)
+
+//go:embed fallbacks_ru_v1.json
+var fallbackJSON []byte
+
+// FallbackSchemaVersion — the version this code understands. Its own constant,
+// not shared with the nudge templates or the eval fixtures: two files that change
+// on different days cannot be versioned by one number (Vikunja #397).
+const FallbackSchemaVersion = 1
+
+// The entry keys. Every one of them is read by a method below, so a typo in the
+// file is caught at load rather than at the moment she needs the words.
+const (
+	fbChat         = "chat"
+	fbQueryUnknown = "query_unknown"
+	fbQuerySources = "query_sources"
+	fbWorldGap     = "world_gap"
+)
+
+// fbKeys — every key the code requires the file to define.
+var fbKeys = []string{fbChat, fbQueryUnknown, fbQuerySources, fbWorldGap}
+
+// hardFloor — the literal each key falls back to when the file is unusable.
+// These are the exact strings that lived in Go before this file existed.
+var hardFloor = say.RegisterFloor(map[string]string{
+	fbChat:         "даже не знаю, что сказать.",
+	fbQueryUnknown: "не знаю.",
+	fbQuerySources: "вот что я нашла: {sources}",
+	fbWorldGap:     "сейчас не могу ответить — большая модель недоступна, а придумывать не хочу.",
+})
+
+// Fallbacks picks a hand-written Russian fallback line. Safe for concurrent use.
+type Fallbacks struct{ d *say.Deck }
+
+// LoadFallbacks reads the embedded file. Pass a source to make the picking
+// reproducible in tests; nil seeds from the clock.
+func LoadFallbacks(src rand.Source) (*Fallbacks, error) {
+	d, err := say.Load(fallbackJSON, FallbackSchemaVersion, fbKeys, hardFloor, src)
+	if err != nil {
+		return nil, err
+	}
+	// query_sources is the one entry whose whole job is to read something back.
+	if err := d.RequirePlaceholder(fbQuerySources, "{sources}"); err != nil {
+		return nil, err
+	}
+	return &Fallbacks{d: d}, nil
+}
+
+// deck reads through a nil *Fallbacks, which is the unloadable-file case.
+func (f *Fallbacks) deck() *say.Deck {
+	if f == nil {
+		return nil
+	}
+	return f.d
+}
+
+// Chat — nothing usable came back on the chat path.
+func (f *Fallbacks) Chat() string { return f.deck().Text(fbChat, nil) }
+
+// Unknown — a question she cannot answer and will not guess at.
+func (f *Fallbacks) Unknown() string { return f.deck().Text(fbQueryUnknown, nil) }
+
+// FromSources — read back what she was handed, because phrasing it failed.
+func (f *Fallbacks) FromSources(sources string) string {
+	return f.deck().Text(fbQuerySources, map[string]string{"sources": sources})
+}
+
+// WorldGap — the world model is the one configured to answer and it is not
+// answering. Fixed wording: it names a specific gap, and a variant set here
+// would let "the big model is asleep" drift into "I don't know".
+func (f *Fallbacks) WorldGap() string { return f.deck().Text(fbWorldGap, nil) }
+
+// Variants returns every line the file can produce, for the persona scorer.
+func (f *Fallbacks) Variants() []string { return f.deck().Variants() }
+
+// The process-wide instance. Package-level because these lines are needed on
+// paths that have no phraser to hand — cmd/mavend names the world gap without
+// one — and because a template file that is embedded and validated at load has
+// nothing per-instance to configure.
+var (
+	fallbackOnce sync.Once
+	fallbacks    *Fallbacks
+)
+
+// DefaultFallbacks returns the shared instance, loading it on first use. A
+// broken file logs once and leaves a nil *Fallbacks, which still answers from
+// hardFloor — a daemon must not fail to boot over its own copy deck.
+func DefaultFallbacks() *Fallbacks {
+	fallbackOnce.Do(func() {
+		fb, err := LoadFallbacks(nil)
+		if err != nil {
+			log.Printf("phraser: fallbacks unavailable, using the built-in lines: %v", err)
+			return
+		}
+		fallbacks = fb
+	})
+	return fallbacks
+}
+
+// ChatFallback — what she says when the chat path produced nothing.
+func ChatFallback() string { return DefaultFallbacks().Chat() }
+
+// UnknownFallback — what she says when she has no answer and will not invent one.
+func UnknownFallback() string { return DefaultFallbacks().Unknown() }
+
+// SourcesFallback — read the sources back rather than ship a broken fragment.
+func SourcesFallback(sources string) string { return DefaultFallbacks().FromSources(sources) }
+
+// WorldGap — what he hears when the world model is configured and unreachable.
+func WorldGap() string { return DefaultFallbacks().WorldGap() }
+
+// IsUnknownFallback reports whether text is one of her "I do not know" lines.
+// The daemon tests read it to tell an answer from a shrug.
+func IsUnknownFallback(text string) bool {
+	return DefaultFallbacks().deck().Matches(fbQueryUnknown, nil, text)
+}
+
+// IsSourcesFallback reports whether text is sources read back verbatim.
+func IsSourcesFallback(text, sources string) bool {
+	return DefaultFallbacks().deck().Matches(fbQuerySources, map[string]string{"sources": sources}, text)
+}

internal/phraser/fallbacks_ru_v1.json

@@ -0,0 +1,42 @@
+{
+  "schema_version": 1,
+  "name": "russian phrasing fallbacks v1",
+  "notes": [
+    "What she says when the model gave her nothing usable. Edit the wording here, no Go changes needed.",
+    "Rules: she is feminine about herself, he is a man addressed as ты. Never вы/вас/ваш, never plural imperatives, never он/его about him. No pet names.",
+    "These are heard after a failure, so they stay short and admit the gap. None of them may claim knowledge she does not have.",
+    "Placeholders: {sources} the notes or passages she was handed. A variant whose placeholder has no value is skipped, so every entry needs at least one variant with no placeholder — except query_sources, which exists only to read sources back.",
+    "fixed: true means exactly one variant and no picking. Used where the wording is load-bearing and must not drift between turns."
+  ],
+  "entries": {
+    "chat": {
+      "variants": [
+        "даже не знаю, что сказать.",
+        "не могу найти слов.",
+        "мысль ускользнула, повтори?",
+        "у меня сейчас пусто в голове."
+      ]
+    },
+    "query_unknown": {
+      "variants": [
+        "не знаю.",
+        "не знаю, честно.",
+        "тут я пас.",
+        "не скажу, не знаю."
+      ]
+    },
+    "query_sources": {
+      "variants": [
+        "вот что я нашла: {sources}",
+        "нашла вот это: {sources}",
+        "есть только это: {sources}"
+      ]
+    },
+    "world_gap": {
+      "fixed": true,
+      "variants": [
+        "сейчас не могу ответить — большая модель недоступна, а придумывать не хочу."
+      ]
+    }
+  }
+}

internal/phraser/fallbacks_test.go

@@ -0,0 +1,74 @@
+package phraser
+
+import (
+	"math/rand"
+	"strings"
+	"testing"
+)
+
+// The embedded file must load, or the daemon speaks from hardFloor and nobody
+// finds out until he hears the wrong words.
+func TestFallbacksLoad(t *testing.T) {
+	fb, err := LoadFallbacks(rand.NewSource(1))
+	if err != nil {
+		t.Fatalf("LoadFallbacks: %v", err)
+	}
+	if got := fb.FromSources("два литра"); !strings.Contains(got, "два литра") {
+		t.Errorf("FromSources = %q, want the sources in it", got)
+	}
+	if fb.WorldGap() != hardFloor[fbWorldGap] {
+		t.Errorf("WorldGap = %q, want the fixed wording %q", fb.WorldGap(), hardFloor[fbWorldGap])
+	}
+}
+
+// A broken or missing file must not take her last words away: every accessor
+// answers from the literal it replaced.
+func TestNilFallbacksAnswerFromTheHardFloor(t *testing.T) {
+	var fb *Fallbacks
+	if got := fb.Chat(); got != hardFloor[fbChat] {
+		t.Errorf("Chat = %q, want %q", got, hardFloor[fbChat])
+	}
+	if got := fb.Unknown(); got != hardFloor[fbQueryUnknown] {
+		t.Errorf("Unknown = %q, want %q", got, hardFloor[fbQueryUnknown])
+	}
+	if got := fb.FromSources("два литра"); got != "вот что я нашла: два литра" {
+		t.Errorf("FromSources = %q", got)
+	}
+	if got := fb.WorldGap(); got != hardFloor[fbWorldGap] {
+		t.Errorf("WorldGap = %q", got)
+	}
+}
+
+// Hearing the identical words every time a request fails is how a failure stops
+// registering as one.
+func TestFallbacksDoNotRepeat(t *testing.T) {
+	fb, err := LoadFallbacks(rand.NewSource(7))
+	if err != nil {
+		t.Fatalf("LoadFallbacks: %v", err)
+	}
+	prev := fb.Chat()
+	for i := 0; i < 20; i++ {
+		got := fb.Chat()
+		if got == prev {
+			t.Fatalf("chat repeated %q on turn %d", got, i)
+		}
+		prev = got
+	}
+}
+
+// The acknowledgements load, fill his words into the frame, and answer from the
+// floor when the file is gone.
+func TestAcksLoad(t *testing.T) {
+	a, err := LoadAcks(rand.NewSource(1))
+	if err != nil {
+		t.Fatalf("LoadAcks: %v", err)
+	}
+	got := a.Say(AckFactValue, map[string]string{"key": "вода", "value": "2л"})
+	if !strings.Contains(got, "вода") || !strings.Contains(got, "2л") {
+		t.Errorf("Say(%s) = %q, want his key and value in it", AckFactValue, got)
+	}
+	var nilAcks *Acks
+	if got := nilAcks.Say(AckNote, nil); got != ackFloor[AckNote] {
+		t.Errorf("nil Acks said %q, want the floor %q", got, ackFloor[AckNote])
+	}
+}

internal/phraser/llmphraser.go

@@ -449,14 +449,14 @@ func (p *LLMPhraser) PhraseQuery(ctx context.Context, utterance string, notes []
 		sys, prompt := p.knowledgePrompt(utterance)
 		resp, err := p.chatWithSystem(ctx, sys, prompt, 768)
 		if err != nil {
-			return "не знаю.", fmt.Errorf("phrase query (knowledge): %w", err)
+			return UnknownFallback(), fmt.Errorf("phrase query (knowledge): %w", err)
 		}
 		if resp == "" {
-			return "не знаю.", errEmptyResponse
+			return UnknownFallback(), errEmptyResponse
 		}
 		text, _, perr := parseResponseMood(resp)
 		if perr != nil {
-			return "не знаю.", fmt.Errorf("phrase query (knowledge): %w", perr)
+			return UnknownFallback(), fmt.Errorf("phrase query (knowledge): %w", perr)
 		}
 		if text != "" {
 			return text, nil
@@ -472,7 +472,7 @@ func (p *LLMPhraser) PhraseQuery(ctx context.Context, utterance string, notes []
 		if cause == nil {
 			cause = perr
 		}
-		return "вот что я нашла: " + strings.Join(notes, "; "),
+		return SourcesFallback(strings.Join(notes, "; ")),
 			fmt.Errorf("phrase query (evidence): %w", cause)
 	}
 	if text != "" {
@@ -501,11 +501,11 @@ func (p *LLMPhraser) PhraseChat(ctx context.Context, utterance string, history [
 
 	resp, err := p.chatWithMessages(ctx, msgs, 768)
 	if err != nil {
-		return ChatFallback, fmt.Errorf("phrase chat: %w", err)
+		return ChatFallback(), fmt.Errorf("phrase chat: %w", err)
 	}
 	text, _, perr := parseResponseMood(resp)
 	if perr != nil {
-		return ChatFallback, fmt.Errorf("phrase chat: %w", perr)
+		return ChatFallback(), fmt.Errorf("phrase chat: %w", perr)
 	}
 	if text != "" {
 		return text, nil

internal/phraser/phraser.go

@@ -66,28 +66,19 @@ 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 ChatFallback, nil
+	return ChatFallback(), nil
 }
 
 // PhraseQuery returns a deterministic summary of the best matching notes.
 func (s *Stub) PhraseQuery(_ context.Context, _ string, notes []string) (string, error) {
 	if len(notes) == 0 {
-		return "не знаю.", nil
+		return UnknownFallback(), nil
 	}
-	if len(notes) == 1 {
-		return "вот что я нашла: " + notes[0], nil
-	}
-	return "вот что я нашла: " + strings.Join(notes, "; "), nil
+	return SourcesFallback(strings.Join(notes, "; ")), nil
 }
 
 // Close implements Phraser.Close (no-op for the stub).

internal/phraser/query.go

@@ -0,0 +1,168 @@
+package phraser
+
+// The query answers and gaps — what a query source says when it answers from
+// something other than the model, and what it says when it has nothing.
+//
+// Third family on the shared deck (deck.go), after the fallbacks and the
+// acknowledgements. They were literals spread across actions_query.go and
+// netscan.go, where the largest single site held two dozen of them.
+//
+// QueryUnknown is not the phraser's UnknownFallback, even though the two read
+// the same today. Here she looked and found nothing; there she failed to phrase
+// an answer she had. Two files, two entries, so rewording one leaves the other.
+
+import (
+	_ "embed"
+	"log"
+	"math/rand"
+	"sync"
+
+	"github.com/kami/maven/internal/say"
+)
+
+//go:embed query_ru_v1.json
+var queryJSON []byte
+
+// QuerySchemaVersion — this family's own version.
+const QuerySchemaVersion = 1
+
+// The entry keys.
+const (
+	QueryUnknown      = "query_unknown"
+	QueryOtherDay     = "other_day"
+	QueryPersonalNone = "personal_none"
+	QueryFactWhen     = "fact_when"
+	QueryFactValue    = "fact_value"
+	QueryFound        = "found"
+	QueryPageText     = "page_text"
+	QueryPageBlocked  = "page_blocked"
+	QueryPageEmpty    = "page_empty"
+	QueryFeedsOff     = "feeds_off"
+	QueryFeedsNew     = "feeds_new"
+	QueryFeedsEmpty   = "feeds_empty"
+	QueryFeedsTopic   = "feeds_empty_topic"
+	QueryWeatherNow   = "weather_now"
+	QueryWeatherOff   = "weather_off"
+	QueryWeatherWhere = "weather_nolocation"
+	QueryNetEmpty     = "net_empty"
+	QueryNetOff       = "net_off"
+	QueryPageOff      = "page_off"
+
+	QueryFailPlan     = "fail_plan"
+	QueryFailNotes    = "fail_notes"
+	QueryFailFeeds    = "fail_feeds"
+	QueryFailCalendar = "fail_calendar"
+	QueryFailWeather  = "fail_weather"
+	QueryFailAnswer   = "fail_answer"
+	QueryFailPage     = "fail_page"
+	QueryFailNetscan  = "fail_netscan"
+)
+
+var queryKeys = []string{
+	QueryUnknown, QueryOtherDay, QueryPersonalNone, QueryFactWhen, QueryFactValue,
+	QueryFound, QueryPageText, QueryPageBlocked, QueryPageEmpty,
+	QueryFeedsOff, QueryFeedsNew, QueryFeedsEmpty, QueryFeedsTopic,
+	QueryWeatherNow, QueryWeatherOff, QueryWeatherWhere, QueryNetEmpty, QueryNetOff, QueryPageOff,
+	QueryFailPlan, QueryFailNotes, QueryFailFeeds, QueryFailCalendar,
+	QueryFailWeather, QueryFailAnswer, QueryFailPage, QueryFailNetscan,
+}
+
+// queryFloor — the literal each key falls back to when the file is unusable.
+// These are the exact strings that lived in Go before this file existed.
+var queryFloor = say.RegisterFloor(map[string]string{
+	QueryUnknown:      "не знаю.",
+	QueryOtherDay:     "про другой день так не отвечу — спроси целиком.",
+	QueryPersonalNone: "не знаю — не нашла у тебя такой записи.",
+	QueryFactWhen:     "я записала это {when}",
+	QueryFactValue:    "вот что я знаю: {key} — {value}",
+	QueryFound:        "вот что я нашла: {text}",
+	QueryPageText:     "вот что на странице: {text}",
+	QueryPageBlocked:  "эта страница закрыта для чтения — robots.txt не разрешает.",
+	QueryPageEmpty:    "страница открылась, но читать там нечего.",
+	QueryFeedsOff:     "я пока не читаю ленты — они не настроены.",
+	QueryFeedsNew:     "вот что нового: {items}",
+	QueryFeedsEmpty:   "в лентах пока ничего нового.",
+	QueryFeedsTopic:   "по этой теме в лентах пока ничего.",
+	QueryWeatherNow:   "в {location} сейчас {temp} градусов, {condition}.",
+	QueryWeatherOff:   "погода не настроена.",
+	QueryWeatherWhere: "не знаю, для какого города — задай voice.weather.default_location или назови город.",
+	QueryNetEmpty:     "в сети никого не нашла{tail}.",
+	QueryNetOff:       "сканирование сети не настроено.",
+	QueryPageOff:      "я не читаю страницы — это не настроено.",
+
+	QueryFailPlan:     "не получилось собрать план.",
+	QueryFailNotes:    "не получилось посмотреть записи.",
+	QueryFailFeeds:    "не получилось посмотреть ленты.",
+	QueryFailCalendar: "не получилось проверить календарь.",
+	QueryFailWeather:  "не получилось узнать погоду.",
+	QueryFailAnswer:   "не получилось найти ответ.",
+	QueryFailPage:     "не получилось прочитать страницу.",
+	QueryFailNetscan:  "не получилось просканировать сеть.",
+})
+
+// Queries picks a hand-written Russian query line. Safe for concurrent use.
+type Queries struct{ d *say.Deck }
+
+// LoadQueries reads the embedded file. Pass a source to make the picking
+// reproducible in tests; nil seeds from the clock.
+func LoadQueries(src rand.Source) (*Queries, error) {
+	d, err := say.Load(queryJSON, QuerySchemaVersion, queryKeys, queryFloor, src)
+	if err != nil {
+		return nil, err
+	}
+	// The entries that exist to read something back. A variant without the
+	// placeholder would answer the question by dropping the answer.
+	for _, req := range []struct{ key, ph string }{
+		{QueryFactWhen, "{when}"}, {QueryFactValue, "{key}"}, {QueryFactValue, "{value}"},
+		{QueryFound, "{text}"}, {QueryPageText, "{text}"}, {QueryFeedsNew, "{items}"},
+		{QueryWeatherNow, "{location}"}, {QueryWeatherNow, "{temp}"}, {QueryWeatherNow, "{condition}"},
+	} {
+		if err := d.RequirePlaceholder(req.key, req.ph); err != nil {
+			return nil, err
+		}
+	}
+	return &Queries{d: d}, nil
+}
+
+// deck reads through a nil *Queries, which is the unloadable-file case.
+func (q *Queries) deck() *say.Deck {
+	if q == nil {
+		return nil
+	}
+	return q.d
+}
+
+// Say returns one line for key, with the values filled into the frame.
+func (q *Queries) Say(key string, vars map[string]string) string {
+	return q.deck().Text(key, vars)
+}
+
+// Variants returns every line the file can produce, for the persona scorer.
+func (q *Queries) Variants() []string { return q.deck().Variants() }
+
+var (
+	queryOnce sync.Once
+	queries   *Queries
+)
+
+// DefaultQueries returns the shared instance, loading it on first use. A broken
+// file logs once and leaves a nil *Queries, which still answers from queryFloor.
+func DefaultQueries() *Queries {
+	queryOnce.Do(func() {
+		q, err := LoadQueries(nil)
+		if err != nil {
+			log.Printf("phraser: query lines unavailable, using the built-in ones: %v", err)
+			return
+		}
+		queries = q
+	})
+	return queries
+}
+
+// Q — one query line, the way every caller says it.
+func Q(key string, vars map[string]string) string { return DefaultQueries().Say(key, vars) }
+
+// IsQ reports whether text is a line key could have produced, for the tests.
+func IsQ(key string, vars map[string]string, text string) bool {
+	return DefaultQueries().deck().Matches(key, vars, text)
+}

internal/phraser/query_ru_v1.json

@@ -0,0 +1,101 @@
+{
+  "schema_version": 1,
+  "name": "russian query answers and gaps v1",
+  "notes": [
+    "What a query source says when it answers from something other than the model, and what it says when it has nothing. Edit the wording here, no Go changes needed.",
+    "Rules: she is feminine about herself, he is a man addressed as ты. Never вы/вас/ваш, never он/его about him. No pet names.",
+    "A gap names its own gap. \"the feeds are not configured\", \"the search failed\" and \"I do not know\" are different sentences and must never collapse into one entry.",
+    "query_unknown here is a real answer — she looked and found nothing. The phraser's identical-looking line in fallbacks_ru_v1.json is a failure to phrase. Two files, two entries, on purpose.",
+    "Placeholders: {key} {value} a stored fact, {when} when she wrote it, {items} what she found, {text} a passage, {location} {temp} {condition} the weather.",
+    "fixed: true means exactly one variant and no picking. Used where the wording is load-bearing: the personal boundary, and the refusal to re-ask a question for another day."
+  ],
+  "entries": {
+    "query_unknown": {
+      "variants": ["не знаю.", "не нашла ничего.", "ничего не нашла."]
+    },
+    "other_day": {
+      "fixed": true,
+      "variants": ["про другой день так не отвечу — спроси целиком."]
+    },
+    "personal_none": {
+      "fixed": true,
+      "variants": ["не знаю — не нашла у тебя такой записи."]
+    },
+    "fact_when": {
+      "variants": ["я записала это {when}", "записала это {when}"]
+    },
+    "fact_value": {
+      "variants": ["вот что я знаю: {key} — {value}", "у меня записано: {key} — {value}"]
+    },
+    "found": {
+      "variants": ["вот что я нашла: {text}", "нашла вот это: {text}", "есть такое: {text}"]
+    },
+    "page_text": {
+      "variants": ["вот что на странице: {text}", "на странице вот это: {text}"]
+    },
+    "page_blocked": {
+      "fixed": true,
+      "variants": ["эта страница закрыта для чтения — robots.txt не разрешает."]
+    },
+    "page_empty": {
+      "variants": ["страница открылась, но читать там нечего.", "страница пустая, читать нечего."]
+    },
+    "feeds_off": {
+      "variants": ["я пока не читаю ленты — они не настроены."]
+    },
+    "feeds_new": {
+      "variants": ["вот что нового: {items}", "нового вот что: {items}"]
+    },
+    "feeds_empty": {
+      "variants": ["в лентах пока ничего нового.", "в лентах тихо."]
+    },
+    "feeds_empty_topic": {
+      "variants": ["по этой теме в лентах пока ничего.", "по этой теме в лентах тихо."]
+    },
+    "weather_now": {
+      "variants": ["в {location} сейчас {temp} градусов, {condition}.", "{location}: {temp} градусов, {condition}."]
+    },
+    "weather_off": {
+      "variants": ["погода не настроена."]
+    },
+    "weather_nolocation": {
+      "fixed": true,
+      "variants": ["не знаю, для какого города — задай voice.weather.default_location или назови город."]
+    },
+    "net_off": {
+      "fixed": true,
+      "variants": ["сканирование сети не настроено."]
+    },
+    "page_off": {
+      "fixed": true,
+      "variants": ["я не читаю страницы — это не настроено."]
+    },
+    "net_empty": {
+      "variants": ["в сети никого не нашла{tail}.", "никого в сети не видно{tail}."]
+    },
+    "fail_plan": {
+      "variants": ["не получилось собрать план.", "план не собрался."]
+    },
+    "fail_notes": {
+      "variants": ["не получилось посмотреть записи.", "записи не открылись."]
+    },
+    "fail_feeds": {
+      "variants": ["не получилось посмотреть ленты.", "ленты не открылись."]
+    },
+    "fail_calendar": {
+      "variants": ["не получилось проверить календарь.", "календарь не открылся."]
+    },
+    "fail_weather": {
+      "variants": ["не получилось узнать погоду.", "погода не пришла."]
+    },
+    "fail_answer": {
+      "variants": ["не получилось найти ответ.", "ответ не нашёлся."]
+    },
+    "fail_page": {
+      "variants": ["не получилось прочитать страницу.", "страница не прочиталась."]
+    },
+    "fail_netscan": {
+      "variants": ["не получилось просканировать сеть.", "сеть не просканировалась."]
+    }
+  }
+}

internal/router/agenda_test.go

@@ -75,3 +75,40 @@ func TestAgendaGrammarSparesStatements(t *testing.T) {
 		}
 	}
 }
+
+// The two shapes that carried no question mark and no interrogative, so the
+// model saw them first and called them facts (Vikunja #498).
+func TestNarrativeGrammarsRouteToQuery(t *testing.T) {
+	r := agendaRouter(t)
+	r.grammars = append(r.grammars, NarrativeQueryGrammars()...)
+	for _, u := range []string{
+		"что дальше?",
+		"и что там дальше",
+		"what's next?",
+		"расскажи про битву при Ватерлоо",
+		"объясни как работает дизель",
+		"опиши Ватерлоо",
+	} {
+		d, err := r.Route(context.Background(), u, refNow())
+		if err != nil {
+			t.Fatalf("%q: %v", u, err)
+		}
+		if d.Intent != IntentQuery || d.Stage != 0 {
+			t.Errorf("%q routed intent=%s stage=%d, want query at stage 0", u, d.Intent, d.Stage)
+		}
+	}
+}
+
+// A narrative verb next to a capture verb is him asking for a note. Stage 0
+// declines and the extractor gets its turn.
+func TestNarrativeGrammarLeavesCapturesAlone(t *testing.T) {
+	r := agendaRouter(t)
+	r.grammars = append(r.grammars, NarrativeQueryGrammars()...)
+	d, err := r.Route(context.Background(), "расскажи и запиши что я пил воду", refNow())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if d.Stage == 0 && d.Intent == IntentQuery {
+		t.Errorf("stage 0 claimed a capture: %+v", d)
+	}
+}

internal/router/eval/eval_test.go

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

internal/router/eval/ru_routing_v1.json

@@ -28,6 +28,8 @@
     { "id": "ru-query-016", "utterance": "покажи давление за неделю", "lang": "ru", "intent": "query", "tags": ["hard", "imperative"], "note": "imperative form but a read — must not route to act" },
     { "id": "ru-query-017", "utterance": "чем я занимался в среду", "lang": "ru", "intent": "query", "tags": ["hard", "chat-shaped"] },
     { "id": "ru-query-018", "utterance": "хватает ли места под новые бэкапы", "lang": "ru", "intent": "query", "tags": ["homelab"] },
+    { "id": "ru-query-020", "utterance": "что дальше?", "lang": "ru", "intent": "query", "tags": ["agenda", "hard"], "note": "the rest of the day, with no interrogative the model can read as a question — it routed fact until a stage 0 rule claimed it (V-498)" },
+    { "id": "ru-query-021", "utterance": "расскажи про битву при Ватерлоо", "lang": "ru", "intent": "query", "tags": ["world", "hard"], "note": "a world question phrased as an instruction. It routed fact, and the fact gate had to catch the write (V-498)" },
     { "id": "en-query-001", "utterance": "did I take my vitamins today", "lang": "en", "intent": "query", "tags": ["fact-shaped"] },
     { "id": "en-query-002", "utterance": "how long since the last backup finished", "lang": "en", "intent": "query", "tags": ["temporal"] },
     { "id": "en-query-003", "utterance": "show me this week's weight", "lang": "en", "intent": "query", "tags": ["imperative"] },

internal/router/stage0.go

@@ -185,6 +185,73 @@ func AgendaQueryGrammars() []Grammar {
 	}
 }
 
+// NarrativeQueryGrammars — stage-0 grammars for the two question shapes that
+// carry no question mark and no interrogative, and so reached the resident
+// model with nothing deterministic in front of them (Vikunja #498).
+//
+// Both were routed IntentFact by the model. The fact gate catches the write and
+// re-runs the turn as a query, so nothing breaks today; what they cost is a full
+// model round trip to reach a decision two patterns can make offline, and a
+// wrong row on the routing fixture.
+//
+// Wired after the agenda grammars, which is where their overlap resolves:
+// "расскажи, что у меня сегодня" is claimed here as a query either way.
+func NarrativeQueryGrammars() []Grammar {
+	return []Grammar{
+		{
+			// "что дальше?" — the rest of the day. IsRestOfDayQuery already
+			// recognises it downstream in the query chain, but that runs after
+			// the routing decision, and the routing decision was fact.
+			Name:    "rest-of-day-query",
+			Pattern: regexp.MustCompile(`(?i)(^|\s)(что|чего)\s+(там\s+|потом\s+)?дальше(\s|[?!.]|$)|(^|\s)what'?s?\s+next(\s|[?!.]|$)`),
+			Build:   agendaQueryBuild,
+		},
+		{
+			// "расскажи про X" — a world question phrased as an instruction.
+			// The lexicon is narrativeRequests, already written for the
+			// question-shaped test in question.go.
+			//
+			// Anchored at the start: "запиши что мне рассказали" is a capture,
+			// and a narrative verb buried mid-utterance is not the shape.
+			Name:    "narrative-query",
+			Pattern: regexp.MustCompile(`(?i)^\s*(расскажи|объясни|опиши|перечисли|tell|explain|describe)(\s+(.*))?$`),
+			Build:   narrativeQueryBuild,
+		},
+	}
+}
+
+// entertainmentNouns — what "расскажи" asks for when it is not asking for
+// knowledge. "расскажи анекдот про программистов" is chat: he wants her to make
+// something up, which is the one case where inventing is the right answer
+// (fixture ru-chat-003).
+var entertainmentNouns = []string{
+	"анекдот", "анекдоты", "шутку", "шутки", "историю", "сказку", "сказки",
+	"joke", "jokes", "story",
+}
+
+// narrativeQueryBuild — the narrative shape is a query unless he also said one
+// of the capture verbs, or asked for entertainment. "расскажи и запиши" is him
+// asking for a note, and stage 0 must not take either off the cascade.
+func narrativeQueryBuild(m []string) (Decision, bool) {
+	rest := ""
+	if len(m) > 3 {
+		rest = m[3]
+	}
+	for _, t := range planTokens(rest) {
+		for _, v := range captureVerbs {
+			if t == v {
+				return Decision{}, false
+			}
+		}
+		for _, v := range entertainmentNouns {
+			if t == v {
+				return Decision{}, false
+			}
+		}
+	}
+	return agendaQueryBuild(m)
+}
+
 // agendaQueryBuild — shared Build for the agenda grammars. Confidence 1.0 on
 // the intent only: the utterance travels intact and the query chain's own
 // matchers decide the rest.

internal/say/deck.go

@@ -0,0 +1,184 @@
+package say
+
+// Package say holds the mechanics every family of hand-written Russian lines
+// shares. The families themselves live next to the code that speaks them.
+//
+// Deck — the mechanics every family of hand-written Russian lines shares.
+//
+// A family is one embedded JSON file: schema-versioned, several variants per
+// entry, never the same variant twice running, and a hard floor of Go literals
+// under it so a broken file cannot take her words away. fallbacks.go was the
+// first family (Vikunja #501) and acks.go the second, at which point copying
+// eighty lines of loader per family stopped being defensible.
+//
+// What stays per family: the file, the keys, the floor literals, the accessor
+// names, and any validation only that family can state.
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/rand"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Entry — one line she can say, in as many wordings as the file gives.
+type Entry struct {
+	// Fixed — one variant, never picked between. For wording that must not
+	// drift from turn to turn, like a phrase naming one specific gap.
+	Fixed    bool     `json:"fixed"`
+	Variants []string `json:"variants"`
+}
+
+type file struct {
+	SchemaVersion int              `json:"schema_version"`
+	Name          string           `json:"name"`
+	Notes         []string         `json:"notes"`
+	Entries       map[string]Entry `json:"entries"`
+}
+
+// deck picks a line. Safe for concurrent use. A nil *Deck answers from the
+// floor, which is what an unloadable file leaves behind.
+type Deck struct {
+	mu    sync.Mutex
+	rnd   *rand.Rand
+	last  map[string]string
+	file  file
+	keys  []string
+	floor map[string]string
+}
+
+// loadDeck parses raw, checks the version and every required key, and seeds the
+// picker. Pass a source to make the picking reproducible in tests; nil seeds
+// from the clock.
+func Load(raw []byte, version int, keys []string, floor map[string]string, src rand.Source) (*Deck, error) {
+	var f file
+	if err := json.Unmarshal(raw, &f); err != nil {
+		return nil, fmt.Errorf("parse: %w", err)
+	}
+	if f.SchemaVersion != version {
+		return nil, fmt.Errorf("schema_version %d, want %d", f.SchemaVersion, version)
+	}
+	for _, k := range keys {
+		e, ok := f.Entries[k]
+		if !ok || len(e.Variants) == 0 {
+			return nil, fmt.Errorf("entry %q is missing or empty", k)
+		}
+		if e.Fixed && len(e.Variants) != 1 {
+			return nil, fmt.Errorf("entry %q is fixed but has %d variants", k, len(e.Variants))
+		}
+	}
+	if src == nil {
+		src = rand.NewSource(time.Now().UnixNano())
+	}
+	return &Deck{rnd: rand.New(src), last: map[string]string{}, file: f, keys: keys, floor: floor}, nil
+}
+
+// requirePlaceholder fails the load when a variant of key does not use ph. For
+// an entry whose whole job is to read something back, a variant without the
+// placeholder silently drops it.
+func (d *Deck) RequirePlaceholder(key, ph string) error {
+	for _, v := range d.file.Entries[key].Variants {
+		if !strings.Contains(v, ph) {
+			return fmt.Errorf("%q variant %q does not use %s", key, v, ph)
+		}
+	}
+	return nil
+}
+
+// text returns one variant for key with the placeholders filled in. A nil
+// receiver answers from the floor, so no caller checks whether the file loaded.
+func (d *Deck) Text(key string, vars map[string]string) string {
+	tmpl := ""
+	if d != nil {
+		if e, ok := d.file.Entries[key]; ok && len(e.Variants) > 0 {
+			tmpl = d.pick(key, e)
+		}
+	}
+	if tmpl == "" {
+		tmpl = floorOf(d, key)
+	}
+	return fill(tmpl, vars)
+}
+
+// matches reports whether text is a line key could have produced. A caller that
+// has to recognise one of these lines cannot compare against a literal any more.
+func (d *Deck) Matches(key string, vars map[string]string, text string) bool {
+	if fill(floorOf(d, key), vars) == text {
+		return true
+	}
+	if d == nil {
+		return false
+	}
+	for _, v := range d.file.Entries[key].Variants {
+		if fill(v, vars) == text {
+			return true
+		}
+	}
+	return false
+}
+
+// variants returns every line the file can produce, in key order, for the
+// persona scorer. Stable order so a failure names the same variant twice.
+func (d *Deck) Variants() []string {
+	if d == nil {
+		return nil
+	}
+	var out []string
+	for _, k := range d.keys {
+		out = append(out, d.file.Entries[k].Variants...)
+	}
+	return out
+}
+
+// pick chooses at random, skipping whatever this entry said last time.
+func (d *Deck) pick(key string, e Entry) string {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	choices := e.Variants
+	if len(choices) > 1 {
+		fresh := make([]string, 0, len(choices))
+		for _, v := range choices {
+			if v != d.last[key] {
+				fresh = append(fresh, v)
+			}
+		}
+		if len(fresh) > 0 {
+			choices = fresh
+		}
+	}
+	got := choices[d.rnd.Intn(len(choices))]
+	d.last[key] = got
+	return got
+}
+
+// floorOf reads the Go literal behind key, and works on a nil deck because that
+// is exactly the case it exists for. The per-family map is the source of truth.
+func floorOf(d *Deck, key string) string {
+	if d != nil && d.floor != nil {
+		return d.floor[key]
+	}
+	return deckFloors[key]
+}
+
+// deckFloors — every family's floor literals in one map, so a nil deck still
+// finds them. Families register at init; the keys are namespaced by family.
+var deckFloors = map[string]string{}
+
+func RegisterFloor(floor map[string]string) map[string]string {
+	for k, v := range floor {
+		deckFloors[k] = v
+	}
+	return floor
+}
+
+// fill substitutes {name} for each var. A placeholder with no value is left
+// alone rather than blanked, so a missing value is visible instead of silent.
+func fill(tmpl string, vars map[string]string) string {
+	for k, v := range vars {
+		tmpl = strings.ReplaceAll(tmpl, "{"+k+"}", v)
+	}
+	return tmpl
+}

internal/say/summary.go

@@ -0,0 +1,191 @@
+package say
+
+// The summary sentences — what she says around aggregated data: the morning
+// plan, the ranked task list, and the habits read back out of behaviour records.
+//
+// Fifth family on the deck, and the first one outside internal/phraser. It
+// lives here because its three callers — internal/morning, internal/tasks and
+// internal/memory — sit under phraser in the import graph and cannot reach it.
+//
+// The "I have not seen enough yet" sentences are the load-bearing ones. Three
+// days of taps and a year of them produce the same "обычно ты ...", and only one
+// of those is worth believing, so the empty cases say she has not seen a
+// pattern rather than that he has none.
+
+import (
+	_ "embed"
+	"log"
+	"math/rand"
+	"sync"
+)
+
+//go:embed summary_ru_v1.json
+var summaryJSON []byte
+
+// SummarySchemaVersion — this family's own version.
+const SummarySchemaVersion = 1
+
+// The entry keys.
+const (
+	PlanRestEmpty = "plan_rest_empty"
+	PlanDayEmpty  = "plan_day_empty"
+	PlanDay       = "plan_day"
+	PlanUncertain = "plan_uncertain"
+
+	TasksNone       = "tasks_none"
+	TasksFirst      = "tasks_first"
+	TasksCandidates = "tasks_candidates"
+
+	ReasonOverdue     = "reason_overdue"
+	ReasonOverdueDay  = "reason_overdue_day"
+	ReasonOverdueDays = "reason_overdue_days"
+	ReasonToday       = "reason_today"
+	ReasonTomorrow    = "reason_tomorrow"
+	ReasonInDays      = "reason_in_days"
+	ReasonImportant   = "reason_important"
+	ReasonUrgent      = "reason_urgent"
+	ReasonStale       = "reason_stale"
+
+	HabitWeekday     = "habit_weekday"
+	HabitWeekdaySame = "habit_weekday_same"
+	HabitWeekdayNone = "habit_weekday_none"
+	HabitWeekendBoth = "habit_weekend_both"
+	HabitWeekendSat  = "habit_weekend_sat"
+	HabitWeekendSun  = "habit_weekend_sun"
+	HabitWeekendSame = "habit_weekend_same"
+	HabitWeekendNone = "habit_weekend_none"
+	HabitOverall     = "habit_overall"
+	HabitOverallNone = "habit_overall_none"
+	HabitSpanToday   = "habit_span_today"
+	HabitSpanDays    = "habit_span_days"
+	HabitUnglossed   = "habit_unglossed"
+	HabitAt          = "habit_at"
+)
+
+var summaryKeys = []string{
+	PlanRestEmpty, PlanDayEmpty, PlanDay, PlanUncertain,
+	TasksNone, TasksFirst, TasksCandidates,
+	ReasonOverdue, ReasonOverdueDay, ReasonOverdueDays, ReasonToday, ReasonTomorrow,
+	ReasonInDays, ReasonImportant, ReasonUrgent, ReasonStale,
+	HabitWeekday, HabitWeekdaySame, HabitWeekdayNone,
+	HabitWeekendBoth, HabitWeekendSat, HabitWeekendSun, HabitWeekendSame, HabitWeekendNone,
+	HabitOverall, HabitOverallNone, HabitSpanToday, HabitSpanDays,
+	HabitUnglossed, HabitAt,
+}
+
+// summaryFloor — the literal each key falls back to when the file is unusable.
+// These are the exact strings that lived in Go before this file existed.
+var summaryFloor = RegisterFloor(map[string]string{
+	PlanRestEmpty: "на сегодня больше ничего не запланировано.",
+	PlanDayEmpty:  "на {date} ничего не запланировано.",
+	PlanDay:       "план на {date}: {items}.",
+	PlanUncertain: "похоже, {line}",
+
+	TasksNone:       "задач нет.",
+	TasksFirst:      "сначала: {items}.",
+	TasksCandidates: "ещё я нашла, но ты не подтвердил: {items}.",
+
+	ReasonOverdue:     "просрочено",
+	ReasonOverdueDay:  "просрочено на день",
+	ReasonOverdueDays: "просрочено на {n} дн.",
+	ReasonToday:       "сегодня",
+	ReasonTomorrow:    "завтра",
+	ReasonInDays:      "через {n} дн.",
+	ReasonImportant:   "важно",
+	ReasonUrgent:      "срочно",
+	ReasonStale:       "давно в списке",
+
+	HabitWeekday:     "по {day} ты обычно {items}.",
+	HabitWeekdaySame: "по {day} у тебя нет ничего особенного — то же, что и в остальные дни: {items}.",
+	HabitWeekdayNone: "по {day} я пока не вижу у тебя ничего постоянного.",
+	HabitWeekendBoth: "по субботам ты обычно {sat}, по воскресеньям — {sun}.",
+	HabitWeekendSat:  "по субботам ты обычно {items}, а по воскресеньям ничего постоянного.",
+	HabitWeekendSun:  "по воскресеньям ты обычно {items}, а по субботам ничего постоянного.",
+	HabitWeekendSame: "по выходным у тебя нет ничего особенного — то же, что и в остальные дни: {items}.",
+	HabitWeekendNone: "по выходным я пока не вижу у тебя ничего постоянного.",
+	HabitOverall:     "обычно ты {items} — {span}.",
+	HabitOverallNone: "я ещё не набрала достаточно записей, чтобы говорить о привычках.",
+	HabitSpanToday:   "по записям за сегодня",
+	HabitSpanDays:    "по записям за последние {n} {word}",
+	HabitUnglossed:   "отмечаешь «{key}»",
+	HabitAt:          "{gloss} около {time}",
+})
+
+// Summaries picks a hand-written Russian summary sentence. Safe for concurrent
+// use.
+type Summaries struct{ d *Deck }
+
+// LoadSummaries reads the embedded file. Pass a source to make the picking
+// reproducible in tests; nil seeds from the clock.
+func LoadSummaries(src rand.Source) (*Summaries, error) {
+	d, err := Load(summaryJSON, SummarySchemaVersion, summaryKeys, summaryFloor, src)
+	if err != nil {
+		return nil, err
+	}
+	// The entries that exist to read the aggregate back. A variant without the
+	// placeholder would summarise the data by dropping it.
+	for _, req := range []struct{ key, ph string }{
+		{PlanDayEmpty, "{date}"}, {PlanDay, "{date}"}, {PlanDay, "{items}"},
+		{PlanUncertain, "{line}"},
+		{TasksFirst, "{items}"}, {TasksCandidates, "{items}"},
+		{ReasonOverdueDays, "{n}"}, {ReasonInDays, "{n}"},
+		{HabitWeekday, "{day}"}, {HabitWeekday, "{items}"},
+		{HabitWeekdaySame, "{day}"}, {HabitWeekdaySame, "{items}"},
+		{HabitWeekdayNone, "{day}"},
+		{HabitWeekendBoth, "{sat}"}, {HabitWeekendBoth, "{sun}"},
+		{HabitWeekendSat, "{items}"}, {HabitWeekendSun, "{items}"},
+		{HabitWeekendSame, "{items}"},
+		{HabitOverall, "{items}"}, {HabitOverall, "{span}"},
+		{HabitSpanDays, "{n}"}, {HabitSpanDays, "{word}"},
+		{HabitUnglossed, "{key}"}, {HabitAt, "{gloss}"}, {HabitAt, "{time}"},
+	} {
+		if err := d.RequirePlaceholder(req.key, req.ph); err != nil {
+			return nil, err
+		}
+	}
+	return &Summaries{d: d}, nil
+}
+
+// deck reads through a nil *Summaries, which is the unloadable-file case.
+func (s *Summaries) deck() *Deck {
+	if s == nil {
+		return nil
+	}
+	return s.d
+}
+
+// Say returns one line for key, with the values filled into the frame.
+func (s *Summaries) Say(key string, vars map[string]string) string {
+	return s.deck().Text(key, vars)
+}
+
+// Variants returns every line the file can produce, for the persona scorer.
+func (s *Summaries) Variants() []string { return s.deck().Variants() }
+
+var (
+	summaryOnce sync.Once
+	summaries   *Summaries
+)
+
+// DefaultSummaries returns the shared instance, loading it on first use. A
+// broken file logs once and leaves a nil *Summaries, which still answers from
+// summaryFloor.
+func DefaultSummaries() *Summaries {
+	summaryOnce.Do(func() {
+		s, err := LoadSummaries(nil)
+		if err != nil {
+			log.Printf("say: summary lines unavailable, using the built-in ones: %v", err)
+			return
+		}
+		summaries = s
+	})
+	return summaries
+}
+
+// S — one summary sentence, the way every caller says it.
+func S(key string, vars map[string]string) string { return DefaultSummaries().Say(key, vars) }
+
+// IsS reports whether text is a line key could have produced, for the tests.
+func IsS(key string, vars map[string]string, text string) bool {
+	return DefaultSummaries().deck().Matches(key, vars, text)
+}

internal/say/summary_ru_v1.json

@@ -0,0 +1,141 @@
+{
+  "schema_version": 1,
+  "name": "russian summary sentences v1",
+  "notes": [
+    "The sentences she builds around aggregated data: the morning plan, the ranked task list, and the habits she reads back out of behaviour records.",
+    "Rules: she is feminine about herself, he is a man addressed as ты. Never вы/вас/ваш, never он/его about him. No pet names.",
+    "\"I have not seen enough yet\" and \"there is nothing there\" are different claims, and the habit entries keep the first. Three days of taps do not license a statement about his life, so habit_*_none says she does not see a pattern, never that he has no habits.",
+    "Placeholders: {date} a formatted date, {items} a joined list, {day} a weekday name, {span} the stretch of records a habit claim rests on, {n} a count, {word} a Russian count form built Go-side.",
+    "The count forms (день/дня/дней, задача/задачи/задач) are morphology, not copy. They stay in Go and arrive here through {word}.",
+    "fixed: true means exactly one variant and no picking. Used where the wording is the distinction: the day that is over versus the day that was empty, and the list of tasks he never confirmed."
+  ],
+  "entries": {
+    "plan_rest_empty": {
+      "fixed": true,
+      "variants": ["на сегодня больше ничего не запланировано."]
+    },
+    "plan_day_empty": {
+      "fixed": true,
+      "variants": ["на {date} ничего не запланировано."]
+    },
+    "plan_day": {
+      "fixed": true,
+      "variants": ["план на {date}: {items}."]
+    },
+    "plan_uncertain": {
+      "fixed": true,
+      "variants": ["похоже, {line}"]
+    },
+
+    "tasks_none": {
+      "fixed": true,
+      "variants": ["задач нет."]
+    },
+    "tasks_first": {
+      "fixed": true,
+      "variants": ["сначала: {items}."]
+    },
+    "tasks_candidates": {
+      "fixed": true,
+      "variants": ["ещё я нашла, но ты не подтвердил: {items}."]
+    },
+
+    "reason_overdue": {
+      "fixed": true,
+      "variants": ["просрочено"]
+    },
+    "reason_overdue_day": {
+      "fixed": true,
+      "variants": ["просрочено на день"]
+    },
+    "reason_overdue_days": {
+      "fixed": true,
+      "variants": ["просрочено на {n} дн."]
+    },
+    "reason_today": {
+      "fixed": true,
+      "variants": ["сегодня"]
+    },
+    "reason_tomorrow": {
+      "fixed": true,
+      "variants": ["завтра"]
+    },
+    "reason_in_days": {
+      "fixed": true,
+      "variants": ["через {n} дн."]
+    },
+    "reason_important": {
+      "fixed": true,
+      "variants": ["важно"]
+    },
+    "reason_urgent": {
+      "fixed": true,
+      "variants": ["срочно"]
+    },
+    "reason_stale": {
+      "fixed": true,
+      "variants": ["давно в списке"]
+    },
+
+    "habit_weekday": {
+      "fixed": true,
+      "variants": ["по {day} ты обычно {items}."]
+    },
+    "habit_weekday_same": {
+      "variants": [
+        "по {day} у тебя нет ничего особенного — то же, что и в остальные дни: {items}.",
+        "по {day} всё как обычно — то же, что и в остальные дни: {items}."
+      ]
+    },
+    "habit_weekday_none": {
+      "variants": [
+        "по {day} я пока не вижу у тебя ничего постоянного.",
+        "по {day} у тебя пока ничего постоянного не вижу — записей мало."
+      ]
+    },
+    "habit_weekend_both": {
+      "variants": ["по субботам ты обычно {sat}, по воскресеньям — {sun}."]
+    },
+    "habit_weekend_sat": {
+      "variants": ["по субботам ты обычно {items}, а по воскресеньям ничего постоянного."]
+    },
+    "habit_weekend_sun": {
+      "variants": ["по воскресеньям ты обычно {items}, а по субботам ничего постоянного."]
+    },
+    "habit_weekend_same": {
+      "variants": [
+        "по выходным у тебя нет ничего особенного — то же, что и в остальные дни: {items}.",
+        "по выходным всё как обычно — то же, что и в остальные дни: {items}."
+      ]
+    },
+    "habit_weekend_none": {
+      "variants": [
+        "по выходным я пока не вижу у тебя ничего постоянного.",
+        "по выходным у тебя пока ничего постоянного не вижу — записей мало."
+      ]
+    },
+    "habit_overall": {
+      "variants": ["обычно ты {items} — {span}."]
+    },
+    "habit_overall_none": {
+      "variants": [
+        "я ещё не набрала достаточно записей, чтобы говорить о привычках.",
+        "записей пока мало — на привычки я так не сошлюсь."
+      ]
+    },
+    "habit_span_today": {
+      "variants": ["по записям за сегодня"]
+    },
+    "habit_span_days": {
+      "variants": ["по записям за последние {n} {word}"]
+    },
+    "habit_unglossed": {
+      "fixed": true,
+      "variants": ["отмечаешь «{key}»"]
+    },
+    "habit_at": {
+      "fixed": true,
+      "variants": ["{gloss} около {time}"]
+    }
+  }
+}

internal/say/summary_test.go

@@ -0,0 +1,49 @@
+package say
+
+import (
+	"math/rand"
+	"strings"
+	"testing"
+)
+
+// The file has to load, and every key the code names has to be in it.
+func TestSummariesLoad(t *testing.T) {
+	s, err := LoadSummaries(rand.NewSource(1))
+	if err != nil {
+		t.Fatalf("load: %v", err)
+	}
+	for _, key := range summaryKeys {
+		if got := s.Say(key, nil); got == "" {
+			t.Errorf("%s says nothing", key)
+		}
+	}
+}
+
+// A nil *Summaries is the unloadable-file case, and it must still speak. The
+// habit sentences are the ones that matter here: falling back must not turn
+// "I have not seen enough" into silence.
+func TestNilSummariesAnswerFromTheFloor(t *testing.T) {
+	var s *Summaries
+	if got, want := s.Say(HabitOverallNone, nil), summaryFloor[HabitOverallNone]; got != want {
+		t.Errorf("got %q, want %q", got, want)
+	}
+	if got := s.Say(PlanDay, map[string]string{"date": "03.08.2026", "items": "x"}); !strings.Contains(got, "03.08.2026") {
+		t.Errorf("the floor dropped the date: %q", got)
+	}
+}
+
+// The empty cases claim she has not seen enough, never that he has no habits.
+// Every variant has to hold that line, since the picker treats them as equals.
+func TestHabitGapsSaySheHasNotSeenEnough(t *testing.T) {
+	s, err := LoadSummaries(rand.NewSource(1))
+	if err != nil {
+		t.Fatalf("load: %v", err)
+	}
+	for _, key := range []string{HabitWeekdayNone, HabitWeekendNone, HabitOverallNone} {
+		for _, v := range s.d.file.Entries[key].Variants {
+			if !strings.Contains(v, "пока") && !strings.Contains(v, "ещё") {
+				t.Errorf("%s variant %q reads as a fact about him, not as a gap in her records", key, v)
+			}
+		}
+	}
+}

internal/tasks/rank.go

@@ -19,8 +19,11 @@ package tasks
 import (
 	"fmt"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
+
+	"github.com/kami/maven/internal/say"
 )
 
 // Status values, mirroring internal/store so a caller can rank ipc.Task rows
@@ -117,21 +120,21 @@ func score(it Item, now time.Time) (float64, string) {
 				bonus = scoreOverdueCap
 			}
 			total += scoreOverdue + bonus
-			reason = "просрочено"
+			reason = say.S(say.ReasonOverdue, nil)
 			if late == 1 {
-				reason = "просрочено на день"
+				reason = say.S(say.ReasonOverdueDay, nil)
 			} else if late > 1 {
-				reason = fmt.Sprintf("просрочено на %d дн.", late)
+				reason = say.S(say.ReasonOverdueDays, map[string]string{"n": strconv.Itoa(late)})
 			}
 		case days == 0:
 			total += scoreDueToday
-			reason = "сегодня"
+			reason = say.S(say.ReasonToday, nil)
 		case days == 1:
 			total += scoreDueTomorrow
-			reason = "завтра"
+			reason = say.S(say.ReasonTomorrow, nil)
 		case days <= 7:
 			total += scoreDueWeek
-			reason = fmt.Sprintf("через %d дн.", days)
+			reason = say.S(say.ReasonInDays, map[string]string{"n": strconv.Itoa(days)})
 		default:
 			total += scoreDueLater
 		}
@@ -147,9 +150,9 @@ func score(it Item, now time.Time) (float64, string) {
 			// The rungs get their own words. The reason string is the one place
 			// the ranking explains itself, and reading "важно" back at a task
 			// he flagged "срочно" reports a word he did not say.
-			reason = "важно"
+			reason = say.S(say.ReasonImportant, nil)
 			if w >= MaxWeight {
-				reason = "срочно"
+				reason = say.S(say.ReasonUrgent, nil)
 			}
 		}
 	}
@@ -163,7 +166,7 @@ func score(it Item, now time.Time) (float64, string) {
 			}
 			total += age
 			if reason == "" && weeks >= 2 {
-				reason = "давно в списке"
+				reason = say.S(say.ReasonStale, nil)
 			}
 		}
 	}
@@ -210,22 +213,22 @@ func FormatRU(ranked []Ranked) string {
 		}
 	}
 	if len(open) == 0 && len(cands) == 0 {
-		return "задач нет."
+		return say.S(say.TasksNone, nil)
 	}
 
 	var b strings.Builder
 	if len(open) > 0 {
-		b.WriteString("сначала: ")
-		b.WriteString(joinRU(open, SpokenLimit, true))
-		b.WriteString(".")
+		b.WriteString(say.S(say.TasksFirst, map[string]string{
+			"items": joinRU(open, SpokenLimit, true),
+		}))
 	}
 	if len(cands) > 0 {
 		if b.Len() > 0 {
 			b.WriteString(" ")
 		}
-		b.WriteString("ещё я нашла, но ты не подтвердил: ")
-		b.WriteString(joinRU(cands, SpokenLimit, false))
-		b.WriteString(".")
+		b.WriteString(say.S(say.TasksCandidates, map[string]string{
+			"items": joinRU(cands, SpokenLimit, false),
+		}))
 	}
 	return b.String()
 }

internal/voice/replier.go

@@ -25,7 +25,10 @@
 // the daemon seam (config wiring, no CoreAPI or voice-package change).
 package voice
 
-import "github.com/kami/maven/internal/router"
+import (
+	"github.com/kami/maven/internal/phraser"
+	"github.com/kami/maven/internal/router"
+)
 
 // Replier — the reactive reply phrasing seam. The daemon's reactive handler
 // calls Reply with the router's Decision; the impl produces a terse reply
@@ -60,27 +63,24 @@ func (s *StubReplier) Reply(d router.Decision) string {
 		if !d.Slots.HasFn {
 			return "не могу это сделать — не разобрала действие."
 		}
-		return "ок, записала действие: " + d.Slots.Fn
+		return phraser.Ack(phraser.AckAct, map[string]string{"fn": d.Slots.Fn})
 	case router.IntentReminder:
-		if d.Slots.HasTime {
-			return "напомню."
-		}
-		return "напомню."
+		return phraser.Ack(phraser.AckReminder, nil)
 	case router.IntentFact:
 		if d.Slots.HasKey {
 			if d.Slots.Value != "" {
-				return "отметила: " + d.Slots.Key + " = " + d.Slots.Value
+				return phraser.Ack(phraser.AckFactValue, map[string]string{"key": d.Slots.Key, "value": d.Slots.Value})
 			}
-			return "отметила: " + d.Slots.Key
+			return phraser.Ack(phraser.AckFactKey, map[string]string{"key": d.Slots.Key})
 		}
-		return "записала факт."
+		return phraser.Ack(phraser.AckFact, nil)
 	case router.IntentNote:
-		return "сохранила заметку."
+		return phraser.Ack(phraser.AckNote, nil)
 	case router.IntentQuery:
 		return "поискала в заметках — ничего не нашла."
 	case router.IntentChat:
 		return "поговорили." // stub — LLMReplier replaces this
 	default:
-		return "приняла."
+		return phraser.Ack(phraser.AckGeneric, nil)
 	}
 }