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

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

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

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

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

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

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

CLAUDE.md

@@ -43,7 +43,7 @@ are the work.
 Both halves are wired as of 2026-08-03. Routing and replies prefer the workstation silently
 through `modelSeam`; nudge and reminder phrasing prefer it silently inside the phraser. A
 world question goes through `LLMPhraser.PhraseWorld` and names the gap when the card is not
-free — `worldGap` in `cmd/mavend/worldmodel.go`, which he hears instead of an invented
+free — `worldGap` in `cmd/mavend/worldmodel.go`, which the owner hears instead of an invented
 answer. A box with no `workstation` block behaves exactly as it did before the seam: naming
 a gap requires a gap. The offload table in `docs/offload.md` says which caller is which.
 
@@ -79,7 +79,7 @@ Pure-Go packages (`router`, `memory`, `mavweb`, …) run under a plain `go test
 | `mavttsd` | Text-to-speech (piper subprocess). |
 | `mavwaked` | Wake-word / VAD gate. **Not on homesrv** — see below. |
 | `mavenclient` | Voice loop client (mic → stt → core → tts). **Not on homesrv** — see below. |
-| `mavpoll` | Telegram long-poll reach. |
+| `mavpoll` | Environment poller: netdata alarms, uptime-kuma, zenmoney, wireguard presence. Writes facts, sends nothing. Telegram is `internal/delivery/telegramsink`, not this. |
 | `mavcaldav` | CalDAV calendar sync. |
 | `mavmaild` | Mail reader (IMAP, read-only). Holds the IMAP password; core never sees it. |
 
@@ -90,11 +90,18 @@ protocol; the config in `deploy/mavend.json` (with `${VAR}` env expansion from g
 **Seven of the nine run on homesrv. `mavwaked` and `mavenclient` do not, and that is the
 decision, not an oversight** (Vikunja #463, `docs/plans/17-where-the-voice-loop-runs.md`).
 homesrv has a microphone — it is a laptop — but it is in the wrong room, so a wake-word
-daemon there listens to nobody. They belong on a client machine where he is standing.
-`ipc.Dial` already takes `tcp://host:port?token=...` through the netaddr seam, so nothing
-needs building to allow it, but no such machine exists yet. **The consequence: the wake
-word and the VAD gate are covered by unit tests and by nothing else, and no amount of
-sitting at the box changes that.** Push-to-talk through `/dash` is what QA actually covers.
+daemon there listens to nobody. They belong on a client machine where the owner is standing.
+
+**That machine is workpc** (owner's correction, 2026-08-05). This section used to say no
+such machine existed, which was written when the workstation was only a model host. It is
+where he sits most of the day and it has the microphone. `ipc.Dial` already takes
+`tcp://host:port?token=...` through the netaddr seam, so the two daemons need deploying,
+not building. V-515 is that deployment.
+
+Until they are deployed, **the wake word and the VAD gate are covered by unit tests and by
+nothing else**, and push-to-talk through `/dash` is what QA actually covers. Note that
+deploying them does not by itself prove a wake word: `mavwaked` gates on energy and has no
+keyword model (V-487), so the loop runs open until that lands.
 
 ## The ecosystem: Nexus, Praxis, Hexis
 
@@ -155,6 +162,19 @@ on in deploy** — this section used to say it was wired `nil`, which stopped be
 Cascade order: `stage0.go` exact-match fast-path → LLM router (when non-nil) → classifier
 fallback. Any LLM error falls through to the classifier so a turn never breaks on the model.
 
+**A stage-0 decision is slot-extracted too, since 06-08-2026** (V-572). `fillMatchedSlots`
+in `router.go` runs the stage-2 extractor over whatever a grammar built and fills only the
+slots it left empty — a matched value always wins, because the rule read a literal pattern
+and the extractor guesses. It did not run before, so `ReminderGrammar` handed the daemon
+`HasTime: false` for "напомни в 11:00 позвонить маме" and `missingFor` read the silence as
+absence and asked "Когда?". It applies to every grammar and is inert for all but the
+reminder: `Extract` fills Time, Fn and Key and nothing else, and the query, clock, agenda,
+feed, list, task and narrative rules all emit intents with no such slot. Benchmarked at
+20000x, a stage-0 query costs 3.7µs against 3.9µs before. **`Slots.Text` is deliberately not
+filled** — a grammar that left it empty meant it, and `agendaQueryBuild` hands the query
+chain the utterance itself. Fixture unchanged at 64/91, with "slots deferred to daemon"
+6 → 0.
+
 Measured on the 77-case RU fixture. **Re-measured 2026-08-02: the classifier scores 68.8%
 full accuracy at p50 16.6µs**, not the 36.8% at p50 31ms that stood here from
 `docs/evals/2026-07-31-model-bakeoff.md`. That older figure predates the stage 0 rules and the
@@ -165,6 +185,15 @@ that stood here until 2026-08-02 was contention, not the model.** See `docs/eval
 p50 825ms / p95 1.2s / max 3.0s and the full cascade at p50 0.80-1.04s. Do not plan latency
 work off the bakeoff table.
 
+**Re-measured 2026-08-05 on the fixture as it now stands, 91 cases** (V-320 item 2,
+`docs/evals/2026-08-05-routing-resident-model.md`): cascade + resident model scores
+**75.8% full / 80.2% intent-only at p50 1.19s / p95 1.65s**. That is a new baseline and not
+a movement, because 14 cases were added since the 77-case number above. The model alone
+scores 37.4% full against 61.5% intent-only, and the gap is slots rather than routing: it
+routes `reminder` and leaves the time to the daemon, which is what the contract asks. To
+re-run it, start a **second** llama-server on a fixed host port — the resident one binds
+`--port 0` inside the container and no host process can reach it.
+
 **The numbers above are the homesrv floor, not the ceiling.** With the workstation up, routing
 completes through `llm.Pair` against gemma-4-12b and scores **84.4% full / 93.5% intent-only at
 p50 329ms** — better than the resident model and about 2.5× faster (`docs/evals/2026-08-02-workstation-gemma4-12b.md`,
@@ -227,7 +256,13 @@ llama-server in that run), so judge it again before quoting a cascade number.
 
 Praxis taken off the model, 05-08-2026 (V-516). `PraxisGrammars()`
 (`internal/router/praxis.go`, wired in `buildRouter` before the capture marker because
-"отметь" is a capture verb) fills `Slots.Fn` with a Praxis capability name. Praxis reach
+"отметь" is a capture verb) fills `Slots.Fn` with a Praxis capability name.
+**These grammars are the only path to Praxis, not a faster one.** Measured
+2026-08-05 with the resident model as router (V-517,
+`docs/evals/2026-08-05-reach-llm-router.md`): the model alone reaches Praxis
+**0/12**, the same as the classifier alone, because nothing in the router
+prompt names a Praxis capability and there is no string for it to write.
+Through the cascade it is 11/12. Deleting these rules costs every point. Praxis reach
 was **0/12 and structurally so**: `handlePraxisAct` compares `Slots.Fn` to a capability
 alias, and that slot is filled from the deployment's enabled tool names, which no Praxis
 alias is on. Measured **16/30 → 27/30 overall, praxis 0/12 → 11/12, lifecycle 0/5 → 5/5**
@@ -239,11 +274,32 @@ of the house. A demonstrative ("отметь это как сделанное")
 `h.surfacedItems` only when exactly one item was spoken. Otherwise the turn goes back to
 the cascade rather than transitioning the wrong item.
 
+**Who claimed a turn is now recorded, and so is who did not** (V-564, umbrella
+V-558). Arbitration between the claimants on the utterance stream is order,
+hardcoded in the pre-route resolver ladder, in `buildRouter` and in
+`querySources`. `internal/decision` records one `Record` per turn: every
+claimant, what it would have made the turn, the score it reported, and whether
+it won, declined, lost on score, was thinned by a gate or was **never asked**.
+The record rides the context, the same seam `querysource.go` uses, so a claim
+site cannot change a route and a context with no record costs nothing. It is
+installed in `runTurn`, so the mic, telegram and the web all leave the same
+trail. Storage is a 25-turn in-memory ring on the handler (`decision.Ring`),
+read over `ipc.TurnDecisions` and rendered as the second table on `/trace`.
+Nothing persists: a turn record is read minutes later or never, and his words do
+not belong in a table that outlives the diagnosis. Adding a rung to the ladder
+in `runTurn` means adding its name to `preRouteLadder` in
+`cmd/mavend/decisiontrace.go`, or that rung is silently missing from the record.
+
 ## LLM output contract
 
-All phrasing paths emit `{"response":"...","mood":"..."}` (parsed in `replier_llm.go` and
-`internal/phraser/llmphraser.go`), with fallback to plain text and the legacy
-`{"body","summary"}`. Mood is a fixed enum. Router prompt is a separate contract:
+All phrasing paths emit `{"response":"...","mood":"..."}`, with fallback to plain text when
+the model skips the JSON. **One parser, `parseResponseMood` in
+`internal/phraser/parse.go`**, and every path reaches it: the six `LLMPhraser` methods,
+`PhraseWorld`, and `Replier.PhraseReply`, which `cmd/mavend/replier_llm.go` wraps — that file
+holds the stub fallback and no parsing of its own. The legacy `{"body","summary"}` fallback
+was deleted on 2026-08-06 (V-397): it was the contract before `{"response","mood"}` replaced
+it, no prompt asks for that shape, the GBNF cannot emit it, and no test covered it.
+Mood is a fixed enum. Router prompt is a separate contract:
 `[{"intent":<enum>, key?, value?, text?, verb?}, ...]`, 7 intents (`fact, reminder,
 note, query, act, chat, system`). `llm/check_prompt_parity.py` in the training
 workspace enforces that the Go and relabelling prompts remain identical.
@@ -281,7 +337,7 @@ Seeds are scoring data. Editing one moves a recogniser and must be re-measured a
 Not a nag, not autonomous. Maven's persona is **feminine** — Russian
 self-reference must use feminine forms — `рада`, not `рад`; `поняла`, not `понял`. The owner
 is male and is addressed informally: "ты", singular, never "вы"/"ваш" and never "он"/"его"
-(she talks TO him, not about him). Pet names ("милый", "дорогой") are forbidden; his name
+(she talks TO the owner, not about the owner). Pet names ("милый", "дорогой") are forbidden; the name
 ("Ками") is not. The eval enforces this: `CheckAddress`, `CheckFeminine` and `CheckCringe` in
 `internal/phraser/eval/checks.go`, scored by `make eval-phrasing`.
 
@@ -291,7 +347,7 @@ world questions, so she needs to read external sources. What replaces it:
 
 - **No telemetry, no cloud model, no third-party account.** That part never changes. Nothing
   about Maven is reported to anyone, and inference stays on the box.
-- **His data first, then the world.** Every source that reads his facts, notes, calendar,
+- **The owner's data first, then the world.** Every source that reads the owner's facts, notes, calendar,
   tasks or house runs before anything outside, and the personal boundary sits between them.
   Reading beats recalling for a small model.
 - **In the world, live search leads and the ZIMs are the fallback** (owner's call,
@@ -299,7 +355,7 @@ world questions, so she needs to read external sources. What replaces it:
   homesrv answer when the search is empty, unreachable, or the line is down.
   **Verified with the line down on 2026-08-05** (V-508,
   `docs/evals/2026-08-05-kiwix-offline-fallback.md`): a stopped SearXNG costs nothing,
-  the ZIM answers in the same turn budget. A blackholed host cost 8 seconds he waited
+  the ZIM answers in the same turn budget. A blackholed host cost 8 seconds the owner waited
   through. So the connect phase alone is capped at `dialTimeout` (1.5s), while a slow
   instance that did connect keeps the full 8. **A Russian question reads
   `wikipedia_ru_all_maxi_2026-02` verbatim** through `kiwix.book_ru`. The RU→EN rewriter
@@ -318,8 +374,8 @@ world questions, so she needs to read external sources. What replaces it:
   capabilities. The code default is still off. `deploy/mavend.json` now ships a `search`
   block (owner's call, 2026-08-02), so it is on for this box and deleting the block turns
   it off again.
-- **His notes and facts are never search input.** Looking up why the sky is blue and sending
-  his stored personal notes to an upstream engine are different acts. Only the utterance goes
+- **The owner's notes and facts are never search input.** Looking up why the sky is blue and
+  sending the owner's stored personal notes to an upstream engine are different acts. Only the utterance goes
   out, never the persona block, history, or matched notes.
 
 ## Web UI conventions
@@ -341,6 +397,16 @@ Vikunja is the durable task store. A task holds the goal, the constraints and th
 assumption ledger. Work without a task id is work nobody can resume, so a session that
 has no id asks for one before it starts.
 
+The MCP tool schemas are deferred, so load the four you actually use in ONE call at the
+start of a session rather than one lookup per first use:
+
+```text
+ToolSearch("select:mcp__vikunja__list_tasks,mcp__vikunja__get_task_details,mcp__vikunja__create_task,mcp__vikunja__update_task")
+```
+
+`update_task` carrying a `description` resets `done` to false, so closing a task with a
+write-up takes two calls: the description, then `done: true`.
+
 ## Session workflow
 
 `~/.local/bin/task` owns the branch, the commit identity and the PR. One task, one

cmd/mavcaldav/main.go

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

cmd/mavcaldav/render.go

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

cmd/mavenclient/main.go

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

cmd/mavend/actions_act.go

@@ -24,6 +24,14 @@ func (h *reactiveHandler) actionAct(ctx context.Context, dec router.Decision) st
 		}
 	}
 
+	// The board is Maven's own store, so a spoken status change is answered here
+	// and never offered to an ecosystem client (Vikunja #512). First, because
+	// task_status is on no allowlist and no capability registry: reaching either
+	// of them would answer a turn about his own task list with a gap.
+	if dec.Slots.Fn == router.TaskStatusFn {
+		return h.resolveTaskStatus(ctx, dec)
+	}
+
 	// Praxis ecosystem tools: intercept before the system command executor.
 	if h.ecosystem != nil && h.ecosystem.praxis != nil && dec.Slots.HasFn {
 		if reply := h.handlePraxisAct(ctx, dec); reply != "" {

cmd/mavend/actions_list.go

@@ -95,6 +95,12 @@ func (h *reactiveHandler) removeListItem(ctx context.Context, cap router.ListCap
 	return "", false
 }
 
+// listFloor — the keyword test behind topicList, in the shape turnIsAbout takes.
+func listFloor(u string) bool {
+	_, ok := router.ParseListQuery(u)
+	return ok
+}
+
 // queryList — "что в списке покупок?", "что мне купить?".
 //
 // A query source, so it sits in querySources and either claims the turn or
@@ -102,10 +108,15 @@ func (h *reactiveHandler) removeListItem(ctx context.Context, cap router.ListCap
 // source is: the notes pass would otherwise answer a list question with
 // whatever note is nearest.
 func (h *reactiveHandler) queryList(ctx context.Context, t *queryTurn) (string, bool) {
-	list, ok := router.ParseListQuery(t.dec.Utterance)
-	if !ok || h.dataStore == nil {
+	if h.dataStore == nil {
 		return "", false
 	}
+	// The seeds decide the subject and listQueryPrefixes is the floor behind
+	// them (V-522). Which list he named is a noun lookup either way.
+	if !h.turnIsAbout(ctx, t, topicList, listFloor) {
+		return "", false
+	}
+	list := router.ListNamedIn(t.dec.Utterance)
 	items, err := h.dataStore.ListItems(ctx, list, "")
 	if err != nil {
 		log.Printf("voice: list items: %v", err)

cmd/mavend/actions_note.go

@@ -9,9 +9,24 @@ import (
 	"github.com/kami/maven/internal/router"
 )
 
+// nothingToCorrectReply — what she says to a correction that points at
+// nothing. Filing it would put a sentence in his memory that reads as a fact.
+const nothingToCorrectReply = "не поняла, что поправить. скажи целиком, и я запишу."
+
 // actionNote handles router.IntentNote: embed the note, persist it, and
 // index it for recall.
+//
+// The stored body is dec.Utterance and nothing else (V-576). It is not
+// Slots.Text, not phraser output and not any other model string: a note is
+// durable, the embedder indexes it, and it comes back later as recall in his
+// own words. Phrasing belongs in the spoken confirmation.
 func (h *reactiveHandler) actionNote(ctx context.Context, dec router.Decision) string {
+	// A correction with no referent. Everything that could own one has already
+	// run by here: clarify, confirm and repair are all resolved before routing,
+	// so a fragment reaching the note path has nothing behind it (V-576).
+	if correctionFragment(dec.Utterance) {
+		return nothingToCorrectReply
+	}
 	// An utterance that explicitly files a task is work, not recall, and
 	// belongs in the task store (Vikunja #130). Checked before the embedding
 	// is paid for. Everything else is a note, exactly as before.

cmd/mavend/actions_query.go

@@ -11,6 +11,7 @@ import (
 	"unicode"
 
 	"github.com/kami/maven/internal/crawl"
+	"github.com/kami/maven/internal/decision"
 	"github.com/kami/maven/internal/ipc"
 	"github.com/kami/maven/internal/memory"
 	"github.com/kami/maven/internal/morning"
@@ -87,15 +88,15 @@ var querySources = []querySource{
 	// through every source to the web search (Vikunja #475). Its matcher needs
 	// an attention marker, and it falls through when Praxis is not configured.
 	{name: "attention", answer: (*reactiveHandler).queryAttention},
-	// Before the recall sources too: "сколько я потратил?" is a question about
-	// the money facts the poller wrote, and the notes pass would otherwise
-	// answer it from whatever he once said about spending. Its matcher needs a
-	// money noun plus an actual ask, so "я потратил весь день" is untouched.
 	// Next to "tasks" and for the same reason: "что мне купить?" is a question
 	// about the shopping list, and the recall pass would otherwise answer it
 	// from an old note about the shop. Its matcher needs an explicit list
 	// marker, so "надо бы съездить в магазин" is untouched.
 	{name: "list", answer: (*reactiveHandler).queryList},
+	// Before the recall sources too: "сколько я потратил?" is a question about
+	// the money facts the poller wrote, and the notes pass would otherwise
+	// answer it from whatever he once said about spending. Its matcher needs a
+	// money noun plus an actual ask, so "я потратил весь день" is untouched.
 	{name: "money", answer: (*reactiveHandler).queryMoney},
 	// Also above the recall sources: "что я тебе говорил?" is a question about
 	// the facts he tapped in, and the notes pass would answer it with whatever
@@ -122,6 +123,12 @@ var querySources = []querySource{
 	{name: "network", answer: (*reactiveHandler).queryNetwork},
 	{name: "calendar", answer: (*reactiveHandler).queryCalendar, dateAware: true},
 	{name: "weather", answer: (*reactiveHandler).queryWeather},
+	// A question about her, above the three sources that search his own data
+	// (Vikunja #555). It has no answer anywhere else: below the boundary
+	// SearXNG answers about somebody else's assistant, and above it his notes
+	// answer by proximity — "кто ты" came back from a note of his, measured on
+	// the box, because the recall index has no idea the subject is her.
+	{name: "self", answer: (*reactiveHandler).querySelf},
 	{name: "embed", answer: (*reactiveHandler).queryEmbed},
 	{name: "memory", answer: (*reactiveHandler).queryMemory},
 	{name: "notes", answer: (*reactiveHandler).queryNotes},
@@ -152,8 +159,17 @@ var querySources = []querySource{
 
 func (h *reactiveHandler) actionQuery(ctx context.Context, dec router.Decision) string {
 	t := &queryTurn{dec: dec}
+	// The roster, so the record can say which sources were never reached rather
+	// than leaving them out and letting a reader assume they looked and passed
+	// (V-564). Finish names everyone below the winner.
+	decision.Expect(ctx, decision.StageQuery, querySourceNames())
+	rec := decision.From(ctx)
 	for _, src := range querySources {
 		if dec.Continued && !src.dateAware {
+			rec.Note(decision.Claim{
+				Stage: decision.StageQuery, Claimant: src.name, Outcome: decision.NeverAsked,
+				Reason: "a continuation turn only asks the date-aware sources",
+			})
 			continue
 		}
 		if reply, ok := src.answer(h, ctx, t); ok {
@@ -166,8 +182,16 @@ func (h *reactiveHandler) actionQuery(ctx context.Context, dec router.Decision)
 			// caller asked for one, so /chat can show it (V-539).
 			log.Printf("voice: query claimed by source %q", src.name)
 			noteQuerySource(ctx, src.name)
+			rec.Note(decision.Claim{
+				Stage: decision.StageQuery, Claimant: src.name,
+				Intent: string(dec.Intent), Outcome: decision.Won,
+			})
 			return reply
 		}
+		rec.Note(decision.Claim{
+			Stage: decision.StageQuery, Claimant: src.name, Outcome: decision.Declined,
+			Reason: "it had no answer for this turn",
+		})
 	}
 	if dec.Continued {
 		// The previous question cannot be re-asked for another day. Saying so
@@ -211,7 +235,13 @@ func (h *reactiveHandler) queryFactByKey(ctx context.Context, t *queryTurn) (str
 //
 // Read-only by construction — the plan is assembled and rendered core-side and
 // nothing here schedules or announces. "что дальше?" asks for the rest of the
-// day, so that phrasing trims what has already passed.
+// day, so that phrasing trims what has already passed and reads only the next
+// morning.NextSpoken entries. Trimming alone was not enough: asked early it cuts
+// nothing, and she read 43 entries aloud in one sentence (V-618).
+//
+// "что у меня сегодня?" is a different question and is not narrowed here — it
+// carries no plan word, so IsDayPlanQuery declines it and the calendar source
+// answers the whole day.
 //
 // What surface this belongs on is still open, tracked as Vikunja #431 ("Board
 // surface: Maven holds the work board, runs the intake form, never argues").
@@ -230,16 +260,23 @@ func (h *reactiveHandler) queryDayPlan(ctx context.Context, t *queryTurn) (strin
 	}
 	// Rebuild the pure plan so the rest-of-day rendering is the same code that
 	// rendered the whole day — one formatter, one persona.
-	p := morning.Plan{Date: plan.Date}
+	//
+	// The instants are put back in the asking clock's zone on the way in. They
+	// arrive carrying whatever zone the core read them in — a calendar fact's Ts
+	// and a reminder's FireTs are UTC out of the store — and FormatRU reads the
+	// hours in the plan's own frame, so setting that frame here is what makes
+	// the recital name his clock rather than the store's (V-614).
+	zone := h.now().Location()
+	p := morning.Plan{Date: plan.Date.In(zone)}
 	for _, it := range plan.Items {
 		p.Items = append(p.Items, morning.PlanEntry{
-			At:        it.At,
+			At:        it.At.In(zone),
 			Text:      it.Text,
 			Kind:      morning.PlanKind(it.Kind),
 			Uncertain: it.Uncertain,
 		})
 	}
-	return p.After(h.now()).FormatRU(), true
+	return p.Next(h.now(), morning.NextSpoken).FormatRU(), true
 }
 
 // habitFactWindow — how many recent SELF facts the behaviour profile is counted
@@ -292,6 +329,14 @@ const (
 	feedReadOut    = 3
 )
 
+// feedFloor — the keyword test behind topicFeed, in the one-string shape
+// turnIsAbout takes. router.ParseFeedQuery returns the category too, which the
+// gate has no use for; the caller reads it separately.
+func feedFloor(u string) bool {
+	_, ok := router.ParseFeedQuery(u)
+	return ok
+}
+
 // queryFeeds — "что нового в лентах?", "что нового по технологиям?"
 // (Vikunja #258).
 //
@@ -299,10 +344,13 @@ const (
 // never speaks; asking is the trigger. If that ever changes, the thing that
 // changed is "Maven is not a nag", not a detail of this file.
 func (h *reactiveHandler) queryFeeds(ctx context.Context, t *queryTurn) (string, bool) {
-	q, ok := router.ParseFeedQuery(t.dec.Utterance)
-	if !ok {
+	// The seeds decide the subject; router.ParseFeedQuery is the floor behind
+	// them (V-522). The category still comes from the utterance either way,
+	// because a topic is marked by a preposition and needs no recogniser.
+	if !h.turnIsAbout(ctx, t, topicFeed, feedFloor) {
 		return "", false
 	}
+	category := router.FeedCategoryOf(t.dec.Utterance)
 	if !h.feedsOn {
 		// Claim only when nothing below can read the world. The reason this
 		// source used to claim unconditionally was that general knowledge would
@@ -327,7 +375,7 @@ func (h *reactiveHandler) queryFeeds(ctx context.Context, t *queryTurn) (string,
 	}
 	var picked []string
 	for _, n := range notes {
-		if !router.CategoryMatches(rss.NoteCategory(n.Text), q.Category) {
+		if !router.CategoryMatches(rss.NoteCategory(n.Text), category) {
 			continue
 		}
 		// The note carries title, summary, category tag and link; she reads the
@@ -339,7 +387,7 @@ func (h *reactiveHandler) queryFeeds(ctx context.Context, t *queryTurn) (string,
 		}
 	}
 	if len(picked) == 0 {
-		if q.Category != "" {
+		if category != "" {
 			return phraser.Q(phraser.QueryFeedsTopic, nil), true
 		}
 		return phraser.Q(phraser.QueryFeedsEmpty, nil), true
@@ -360,6 +408,19 @@ func (h *reactiveHandler) queryCalendar(ctx context.Context, t *queryTurn) (stri
 	if isWeatherQuery(t.dec.Utterance) {
 		return "", false
 	}
+	// Weather was one instance of a wider class (Vikunja #552). Naming a day
+	// does not make a question his agenda: "какой сегодня курс доллара" and
+	// "во сколько закат сегодня" both answered "ничего нет", which reads as an
+	// answer about a subject she never looked at. All of them have an answer
+	// in search, and search sits below this source. So the question must ask
+	// about his schedule, not merely name a day.
+	//
+	// A continuation is exempt. "а завтра?" names no agenda and cannot: the
+	// subject was in the turn before it, and this is the only date-aware
+	// source there is.
+	if !t.dec.Continued && !router.IsAgendaQuestion(t.dec.Utterance) {
+		return "", false
+	}
 	date, ok := router.ParseCalendarDate(t.dec.Utterance, h.now())
 	if !ok {
 		return "", false
@@ -380,6 +441,10 @@ func (h *reactiveHandler) queryCalendar(ctx context.Context, t *queryTurn) (stri
 	return f.FormatEntries(entries, date), true
 }
 
+// homeTimeout — the whole house read. Longer than the weather call because the
+// hub is polled over the LAN and answers for every device at once.
+const homeTimeout = 10 * time.Second
+
 // queryHome answers a question about the house. Read-only by construction: it
 // calls States and nothing else, so there is no confirm turn here — the only
 // way to CHANGE something is an enabled allowlist row through tool.Executor.
@@ -396,7 +461,7 @@ func (h *reactiveHandler) queryHome(ctx context.Context, t *queryTurn) (string,
 		// unreachable case is different and homeSummary covers it.
 		return "", false
 	}
-	ctxH, cancel := context.WithTimeout(ctx, 10*time.Second)
+	ctxH, cancel := context.WithTimeout(ctx, homeTimeout)
 	defer cancel()
 	return h.home.homeSummary(ctxH)
 }
@@ -420,6 +485,10 @@ func (h *reactiveHandler) queryNetwork(ctx context.Context, t *queryTurn) (strin
 	return h.netscan.scanSummary(ctx)
 }
 
+// weatherTimeout — one geocode plus one forecast read. He asked a question with
+// a one-line answer, so a provider that is slower than this is a failure.
+const weatherTimeout = 5 * time.Second
+
 func (h *reactiveHandler) queryWeather(ctx context.Context, t *queryTurn) (string, bool) {
 	if !h.turnIsAbout(ctx, t, topicWeather, isWeatherQuery) {
 		return "", false
@@ -430,7 +499,7 @@ func (h *reactiveHandler) queryWeather(ctx context.Context, t *queryTurn) (strin
 		// so is the only honest answer; picking a city would be inventing one.
 		return phraser.Q(phraser.QueryWeatherWhere, nil), true
 	}
-	ctxWT, cancel := context.WithTimeout(ctx, 5*time.Second)
+	ctxWT, cancel := context.WithTimeout(ctx, weatherTimeout)
 	defer cancel()
 	w, err := h.weatherProvider.CurrentWeather(ctxWT, loc)
 	if errors.Is(err, weather.ErrNotConfigured) {
@@ -455,17 +524,53 @@ func (h *reactiveHandler) queryWeather(ctx context.Context, t *queryTurn) (strin
 
 // queryEmbed isn't an answer source — it's the shared cost the two recall
 // sources below both need, run once, in the position it always ran in. It
-// only claims the turn when the embedder fails.
+// never claims the turn.
+//
+// It used to claim on an embedder error, and that made a RAG hint a hard gate
+// over everything below it (V-568): one failing EmbedQuery and the memory, the
+// notes, the boundary, the search, the ZIMs, the named page and the model all
+// answered "не смогла ответить", including the questions search and Kiwix
+// would have answered without ever touching the embedder. A failed embed means
+// this source cannot claim, not that the turn is over — same shape as
+// turnVector in topics.go, which had it right.
 func (h *reactiveHandler) queryEmbed(ctx context.Context, t *queryTurn) (string, bool) {
+	// A topic source above already paid for this one; see turnVector.
+	if len(t.vec) > 0 {
+		return "", false
+	}
 	vec, err := router.EmbedQuery(ctx, h.recall.embedder, t.dec.Utterance)
 	if err != nil {
+		// Logged once, here, and the chain walks on. The two recall sources
+		// below read the empty vector and pass; the boundary drops to its
+		// offline floor.
 		log.Printf("voice: embed query: %v", err)
-		return phraser.Q(phraser.QueryFailAnswer, nil), true
+		return "", false
 	}
 	t.vec = vec
 	return "", false
 }
 
+// memoryRecallWidth and noteRecallWidth — how many candidates each recall pass
+// pulls before the gate reads them. Both are small on purpose: the gate wants a
+// best hit and its runner-up, and every further row is a margin the top match
+// has to beat.
+const (
+	memoryRecallWidth = 3
+	noteRecallWidth   = 5
+)
+
+// recallOnTopic — the topic veto both recall sources apply after the score gate
+// (#470). A memory about his slow network scored high enough to answer "почему
+// небо синее?", because the right-note and must-be-silent score ranges overlap
+// and no threshold sits between them.
+func recallOnTopic(utterance, text string) bool {
+	if memory.RecallAllowed(utterance, text) {
+		return true
+	}
+	log.Printf("voice: recall %q rejected for %q: a world question and no shared topic word", text, utterance)
+	return false
+}
+
 // queryMemory — long-term memory first: ONE search over everything Maven
 // remembers (notes and facts share this index) and ONE confidence gate, so
 // the memory that is clearly the best match answers — a note just as much as
@@ -480,7 +585,13 @@ func (h *reactiveHandler) queryMemory(ctx context.Context, t *queryTurn) (string
 	if h.recall.memStore == nil {
 		return "", false
 	}
-	hits, herr := h.recall.memStore.Search(ctx, t.vec, 3)
+	if len(t.vec) == 0 {
+		// No query vector: the embed above failed or there is no embedder.
+		// Searching on an empty vector is not a search, and its scores are not
+		// a "there is nothing" answer — pass rather than gate the chain.
+		return "", false
+	}
+	hits, herr := h.recall.memStore.Search(ctx, t.vec, memoryRecallWidth)
 	if herr != nil {
 		log.Printf("voice: memory search: %v", herr)
 		return "", false
@@ -490,12 +601,8 @@ func (h *reactiveHandler) queryMemory(ctx context.Context, t *queryTurn) (string
 		return "", false
 	}
 	text := hit.Meta["text"]
-	// The score cleared the gate and the topic still has to match (#470). A
-	// note about his slow network scored high enough to answer "почему небо
-	// синее?", because the right-note and must-be-silent score ranges overlap
-	// and no threshold sits between them.
-	if !memory.RecallAllowed(t.dec.Utterance, text) {
-		log.Printf("voice: recall %q rejected for %q: a world question and no shared topic word", text, t.dec.Utterance)
+	// The score cleared the gate and the topic still has to match.
+	if !recallOnTopic(t.dec.Utterance, text) {
 		return "", false
 	}
 	// A note is phrased in Maven's voice; a fact is read back as it was
@@ -526,10 +633,18 @@ func (h *reactiveHandler) queryMemory(ctx context.Context, t *queryTurn) (string
 // band. See memory.Confident. Failing the gate passes the turn on to general
 // knowledge, which is what "don't read back the runner-up" means here.
 func (h *reactiveHandler) queryNotes(ctx context.Context, t *queryTurn) (string, bool) {
-	notes, err := h.api.QueryNotes(ctx, t.vec, 5)
+	if len(t.vec) == 0 {
+		// Same reason as queryMemory above (V-568): with no query vector this
+		// source could not look, and could-not-look passes.
+		return "", false
+	}
+	notes, err := h.api.QueryNotes(ctx, t.vec, noteRecallWidth)
 	if err != nil {
+		// The store failed, so this source could not look either. It used to
+		// claim here, which stopped the search, the ZIMs and the model from
+		// answering a question that never needed a note (V-568).
 		log.Printf("voice: query notes: %v", err)
-		return phraser.Q(phraser.QueryFailAnswer, nil), true
+		return "", false
 	}
 	t.notes = notes
 	noteScores := make([]float64, len(notes))
@@ -539,10 +654,9 @@ func (h *reactiveHandler) queryNotes(ctx context.Context, t *queryTurn) (string,
 	if !memory.ConfidentScores(noteScores, h.recall.minScore, h.recall.minMargin) {
 		return "", false
 	}
-	// Same topic veto as queryMemory above: the best note must be about what
-	// he asked, not merely the nearest vector in the index.
-	if !memory.RecallAllowed(t.dec.Utterance, notes[0].Text) {
-		log.Printf("voice: note %q rejected for %q: a world question and no shared topic word", notes[0].Text, t.dec.Utterance)
+	// The best note must be about what he asked, not merely the nearest vector
+	// in the index.
+	if !recallOnTopic(t.dec.Utterance, notes[0].Text) {
 		return "", false
 	}
 	texts := make([]string, len(notes))
@@ -564,6 +678,23 @@ func (h *reactiveHandler) queryNotes(ctx context.Context, t *queryTurn) (string,
 // prompt, the persona block and the reply.
 const webPageContextRunes = 1500
 
+// webFetchTimeout — the whole named-page source. Longer than the other outside
+// sources because he named this page himself, so waiting for it is what he asked
+// for, and there is nothing below that can answer instead.
+const webFetchTimeout = 30 * time.Second
+
+// readBackRunes — how much of the evidence is read out when the phraser gave
+// nothing back. It is spoken aloud, so it is a couple of sentences and not a
+// page.
+const readBackRunes = 300
+
+// readBack — what an outside source says when the phraser gave nothing back.
+// The evidence is read out plainly rather than dropped, because the fetch did
+// happen and its result is a better answer than silence.
+func readBack(evidence string) string {
+	return phraser.Q(phraser.QueryFound, map[string]string{"text": crawl.TrimRunes(evidence, readBackRunes)})
+}
+
 // queryWeb — "посмотри https://example.org/x — что там?" (Vikunja #259).
 //
 // It claims a turn ONLY when he named a URL, which is what keeps a fallback from
@@ -582,7 +713,7 @@ func (h *reactiveHandler) queryWeb(ctx context.Context, t *queryTurn) (string, b
 		// guess dressed as an answer (Vikunja #479).
 		return phraser.Q(phraser.QueryPageOff, nil), true
 	}
-	ctxFetch, cancel := context.WithTimeout(ctx, 30*time.Second)
+	ctxFetch, cancel := context.WithTimeout(ctx, webFetchTimeout)
 	defer cancel()
 	page, err := h.crawler.Page(ctxFetch, link)
 	if err != nil {
@@ -603,7 +734,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 phraser.Q(phraser.QueryPageText, map[string]string{"text": crawl.TrimRunes(page.Text, 300)}), true
+		return phraser.Q(phraser.QueryPageText, map[string]string{"text": crawl.TrimRunes(page.Text, readBackRunes)}), true
 	}
 	return reply, true
 }
@@ -669,7 +800,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 phraser.Q(phraser.QueryFound, map[string]string{"text": crawl.TrimRunes(resp.Snippets()[0], 300)}), true
+		return readBack(resp.Snippets()[0]), true
 	}
 	return reply, true
 }
@@ -758,7 +889,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 phraser.Q(phraser.QueryFound, map[string]string{"text": crawl.TrimRunes(top.Title+" — "+page.Text, 300)}), true
+		return readBack(top.Title + " — " + page.Text), true
 	}
 	return reply, true
 }

cmd/mavend/actions_reminder.go

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

cmd/mavend/actions_task.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"log"
+	"strings"
 
 	"github.com/kami/maven/internal/dialogue"
 	"github.com/kami/maven/internal/ipc"
@@ -81,7 +82,95 @@ func (h *reactiveHandler) queryTasks(ctx context.Context, t *queryTurn) (string,
 		cands = append(cands, dialogue.Candidate{Kind: "task", Ref: r.ID, Label: r.Text})
 	}
 	h.offerCandidates(ctx, cands)
-	return tasks.FormatRU(ranked), true
+	reply := tasks.FormatRU(ranked)
+	// The counted shapes, after the list and only when there are any (V-512).
+	// They answer "what is going wrong with this list" without assessing any of
+	// it, and they are said here rather than announced: no tick rule reads them.
+	if stalls := tasks.StallsRU(tasks.Stalls(taskItems(live), h.now())); stalls != "" {
+		if !strings.HasSuffix(reply, ".") {
+			reply += "."
+		}
+		reply += " " + stalls
+	}
+	return reply, true
+}
+
+// resolveTaskStatus moves a task he named out loud (Vikunja #512).
+//
+// The position path already worked: resolveCandidate answers "первую сделал"
+// against the list she just read. This is the other half — naming the task
+// instead of its position, which reached no code at all before the stage-0 rule
+// in internal/router/taskstatus.go filled the fn slot.
+//
+// Three answers besides the move, and none of them guesses. No match says so. A
+// match on more than one asks which, because closing the wrong task is work he
+// never finished being marked done. No task named asks which too, since the
+// router claims the turn without the referent and the list lives here.
+func (h *reactiveHandler) resolveTaskStatus(ctx context.Context, dec router.Decision) string {
+	live, err := h.api.ListTasks(ctx, "live")
+	if err != nil {
+		log.Printf("voice: task status: list: %v", err)
+		return "не получилось посмотреть задачи."
+	}
+	if dec.Slots.Text == "" {
+		return "какую задачу?"
+	}
+	match := matchTaskText(live, dec.Slots.Text)
+	switch len(match) {
+	case 0:
+		return "не нашла такой задачи."
+	case 1:
+	default:
+		return "у тебя несколько подходящих — какую именно?"
+	}
+	pick := match[0]
+	status := dec.Slots.Value
+	// A candidate is work Maven proposed and he never confirmed, and the store
+	// refuses candidate → done: the legal move is to open it first. Saying it is
+	// done IS the confirmation, so both writes happen rather than the turn
+	// naming a gap about a distinction he did not make.
+	if pick.Status == store.TaskCandidate && status == store.TaskDone {
+		if err := h.api.SetTaskStatus(ctx, pick.ID, store.TaskOpen, h.now(), string(sourceVoice)); err != nil {
+			log.Printf("voice: task status: promote %d: %v", pick.ID, err)
+			return "не получилось изменить задачу."
+		}
+	}
+	if err := h.api.SetTaskStatus(ctx, pick.ID, status, h.now(), string(sourceVoice)); err != nil {
+		log.Printf("voice: task status: %d → %s: %v", pick.ID, status, err)
+		return "не получилось изменить задачу."
+	}
+	log.Printf("voice: task %d (%q) → %s", pick.ID, pick.Text, status)
+	if status == store.TaskDropped {
+		return "убрала: " + pick.Text
+	}
+	return "закрыла: " + pick.Text
+}
+
+// matchTaskText finds the live tasks he could have meant.
+//
+// Normalised containment, either direction, over store.NormalizeTaskText — the
+// same key capture dedupes on, so a task he can file twice is a task he can name
+// twice. Either direction because he shortens what he said ("молоко" for
+// "купить молоко") as often as he pads it.
+//
+// Deliberately not fuzzy. A ranked best guess would always return exactly one
+// answer, and the one thing this must be able to say is that it is not sure.
+func matchTaskText(live []ipc.Task, named string) []ipc.Task {
+	want := store.NormalizeTaskText(named)
+	if want == "" {
+		return nil
+	}
+	var out []ipc.Task
+	for _, t := range live {
+		have := store.NormalizeTaskText(t.Text)
+		if have == "" {
+			continue
+		}
+		if strings.Contains(have, want) || strings.Contains(want, have) {
+			out = append(out, t)
+		}
+	}
+	return out
 }
 
 // taskItems maps wire rows onto the ranker's input. Written here rather than in

cmd/mavend/actions_task_test.go

@@ -26,6 +26,9 @@ type taskAPI struct {
 	tasks   []ipc.Task
 	listArg string
 	listErr error
+
+	moved   []setStatusCall
+	moveErr error
 }
 
 func (a *taskAPI) CaptureTask(_ context.Context, req ipc.CaptureTaskReq) (ipc.CaptureTaskResp, error) {
@@ -253,3 +256,87 @@ func TestCaptureTaskFromNoteAcknowledgesAPromotion(t *testing.T) {
 		}
 	}
 }
+
+// setStatusCall — one SetTaskStatus the arm made, in order, so a candidate he
+// says is done can be shown to take both legal moves.
+type setStatusCall struct {
+	id     int64
+	status string
+	by     string
+}
+
+func (a *taskAPI) SetTaskStatus(_ context.Context, id int64, status string, _ time.Time, by string) error {
+	a.moved = append(a.moved, setStatusCall{id: id, status: status, by: by})
+	return a.moveErr
+}
+
+func TestResolveTaskStatusMovesTheNamedTask(t *testing.T) {
+	api := &taskAPI{tasks: []ipc.Task{
+		{ID: 7, Text: "купить молоко", Status: "open"},
+		{ID: 8, Text: "оплатить интернет", Status: "open"},
+	}}
+	h := taskHandler(api)
+	reply := h.resolveTaskStatus(context.Background(), router.Decision{
+		Intent: router.IntentAct,
+		Slots:  router.Slots{Fn: router.TaskStatusFn, HasFn: true, Value: "done", Text: "молоко"},
+	})
+	if api.listArg != "live" {
+		t.Errorf("listed %q, want live — a resolved task cannot be resolved again", api.listArg)
+	}
+	if len(api.moved) != 1 {
+		t.Fatalf("moved %d tasks, want 1: %+v", len(api.moved), api.moved)
+	}
+	if api.moved[0].id != 7 || api.moved[0].status != "done" {
+		t.Errorf("moved %+v, want id 7 → done", api.moved[0])
+	}
+	if !strings.Contains(reply, "купить молоко") {
+		t.Errorf("reply = %q, want the task named back", reply)
+	}
+}
+
+func TestResolveTaskStatusRefusesToGuess(t *testing.T) {
+	cases := []struct {
+		name  string
+		tasks []ipc.Task
+		named string
+		want  string
+	}{
+		{"no match", []ipc.Task{{ID: 7, Text: "купить молоко", Status: "open"}}, "позвонить маме", "не нашла"},
+		{"two matches", []ipc.Task{
+			{ID: 7, Text: "купить молоко", Status: "open"},
+			{ID: 8, Text: "купить молоко и хлеб", Status: "open"},
+		}, "купить молоко", "несколько"},
+		{"none named", []ipc.Task{{ID: 7, Text: "купить молоко", Status: "open"}}, "", "какую"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			api := &taskAPI{tasks: c.tasks}
+			h := taskHandler(api)
+			reply := h.resolveTaskStatus(context.Background(), router.Decision{
+				Slots: router.Slots{Fn: router.TaskStatusFn, HasFn: true, Value: "done", Text: c.named},
+			})
+			if len(api.moved) != 0 {
+				t.Errorf("moved %+v — closing the wrong task is the failure this arm exists to avoid", api.moved)
+			}
+			if !strings.Contains(reply, c.want) {
+				t.Errorf("reply = %q, want it to contain %q", reply, c.want)
+			}
+		})
+	}
+}
+
+func TestResolveTaskStatusOpensACandidateFirst(t *testing.T) {
+	// The store refuses candidate → done. Saying it is done is the confirmation
+	// the candidate was waiting for, so the arm makes both legal moves.
+	api := &taskAPI{tasks: []ipc.Task{{ID: 9, Text: "продлить домен", Status: "candidate"}}}
+	h := taskHandler(api)
+	h.resolveTaskStatus(context.Background(), router.Decision{
+		Slots: router.Slots{Fn: router.TaskStatusFn, HasFn: true, Value: "done", Text: "продлить домен"},
+	})
+	if len(api.moved) != 2 {
+		t.Fatalf("moved %+v, want open then done", api.moved)
+	}
+	if api.moved[0].status != "open" || api.moved[1].status != "done" {
+		t.Errorf("moved %+v, want open then done", api.moved)
+	}
+}

cmd/mavend/calendarq_test.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"context"
+	"testing"
+
+	"github.com/kami/maven/internal/router"
+)
+
+// TestCalendarStepsAsideForTheWorld — the defect (Vikunja #552). Weather was
+// one instance of a wider class, and V-474 fixed only that instance. Every one
+// of these answered "на 05.08.2026 ничего нет" on the deployed daemon, and
+// every one of them has an answer in search, which sits below the calendar.
+func TestCalendarStepsAsideForTheWorld(t *testing.T) {
+	h, api := contQueryHandler()
+	for _, u := range []string{
+		"во сколько закат сегодня",
+		"какой сегодня курс доллара",
+		"какой сегодня праздник",
+		"что интересного произошло сегодня в мире",
+	} {
+		if reply, ok := h.queryCalendar(context.Background(), &queryTurn{
+			dec: router.Decision{Intent: router.IntentQuery, Utterance: u},
+		}); ok {
+			t.Errorf("the calendar claimed %q with %q", u, reply)
+		}
+	}
+	if api.events != 0 {
+		t.Errorf("CalendarEvents called %d times for world questions, want 0", api.events)
+	}
+}
+
+// The other half of the same narrowing: a question about his own day still
+// reaches the calendar, including the one that names no subject at all.
+func TestCalendarStillAnswersHisDay(t *testing.T) {
+	for _, u := range []string{
+		"что у меня сегодня",
+		"во сколько у меня встреча сегодня",
+		"какие встречи завтра",
+		"что в календаре на завтра",
+		"что сегодня?",
+	} {
+		h, _ := contQueryHandler()
+		if _, ok := h.queryCalendar(context.Background(), &queryTurn{
+			dec: router.Decision{Intent: router.IntentQuery, Utterance: u},
+		}); !ok {
+			t.Errorf("the calendar passed on %q", u)
+		}
+	}
+}
+
+// A continuation carries its subject in the turn before it, and the calendar
+// is the only date-aware source, so the narrowing must not reach it.
+func TestCalendarStillAnswersAContinuation(t *testing.T) {
+	h, _ := contQueryHandler()
+	if _, ok := h.queryCalendar(context.Background(), &queryTurn{
+		dec: router.Decision{Intent: router.IntentQuery, Utterance: "а завтра?", Continued: true},
+	}); !ok {
+		t.Error("the calendar passed on a continuation")
+	}
+}

cmd/mavend/clarify.go

@@ -6,6 +6,8 @@ import (
 	"math/rand"
 	"strings"
 	"time"
+	"unicode"
+	"unicode/utf8"
 
 	"github.com/kami/maven/internal/dialogue"
 	"github.com/kami/maven/internal/router"
@@ -65,8 +67,28 @@ var clarifyExpiredVariants = []string{
 	"Столько времени прошло, что я отпустила прошлую просьбу. Скажи заново, если она в силе.",
 }
 
-// clarifyExpiredLine picks one of them at random.
-func clarifyExpiredLine() string {
+// clarifyExpiredPluralVariants — the same notice when TWO parked requests died
+// together (Vikunja #561). Since a side query suspends the flow instead of
+// dropping it, the stack can hold both the flow and the thing he interrupted it
+// with, and TakeExpired drops the whole stack when the top times out. "Прошлую
+// просьбу" would then be a lie about the count: he loses two and hears about
+// one.
+//
+// Two phrasings only, against five for the singular. This fires when he walks
+// off in the middle of an interrupted exchange, which is rarer than walking off
+// in the middle of a plain one, so it repeats less and needs less variety.
+var clarifyExpiredPluralVariants = []string{
+	"Прости, я слишком долго ждала и отпустила обе прошлые просьбы. Если они ещё нужны, скажи заново.",
+	"Я не дождалась ответа и убрала обе прошлые просьбы. Повтори, если они всё ещё нужны.",
+}
+
+// clarifyExpiredLine picks one of them at random. n is how many requests died;
+// anything above one gets the plural wording, because the bound is two today and
+// a third would still be "обе" short of the truth only if MaxStackDepth grew.
+func clarifyExpiredLine(n int) string {
+	if n > 1 {
+		return clarifyExpiredPluralVariants[rand.Intn(len(clarifyExpiredPluralVariants))]
+	}
 	return clarifyExpiredVariants[rand.Intn(len(clarifyExpiredVariants))]
 }
 
@@ -74,23 +96,34 @@ func clarifyExpiredLine() string {
 // notice is glued in front of this turn's reply (see withNotice), so a caller
 // checking for it has to match a prefix, not the whole string.
 func isClarifyExpired(s string) bool {
-	for _, v := range clarifyExpiredVariants {
-		if strings.HasPrefix(s, v) {
-			return true
-		}
-	}
-	return false
+	_, ok := cutClarifyExpired(s)
+	return ok
 }
 
 // trimClarifyExpired strips a leading expiry notice, leaving this turn's actual
 // reply. "" ⇒ the notice was the whole thing.
 func trimClarifyExpired(s string) string {
-	for _, v := range clarifyExpiredVariants {
-		if strings.HasPrefix(s, v) {
-			return strings.TrimSpace(strings.TrimPrefix(s, v))
+	rest, ok := cutClarifyExpired(s)
+	if !ok {
+		return strings.TrimSpace(s)
+	}
+	return rest
+}
+
+// cutClarifyExpired matches either expiry deck as a prefix and returns what
+// follows it. Both decks, since V-561 added the plural line: a caller asking
+// "did she say a request timed out" means the fact, not which wording carried
+// it, and a helper that knew only the singular would read the two-request
+// notice as ordinary reply text.
+func cutClarifyExpired(s string) (string, bool) {
+	for _, deck := range [][]string{clarifyExpiredVariants, clarifyExpiredPluralVariants} {
+		for _, v := range deck {
+			if strings.HasPrefix(s, v) {
+				return strings.TrimSpace(strings.TrimPrefix(s, v)), true
+			}
 		}
 	}
-	return strings.TrimSpace(s)
+	return "", false
 }
 
 // clarifyExpiredNotice returns that line when a parked question had just timed
@@ -101,11 +134,12 @@ func (h *reactiveHandler) clarifyExpiredNotice(ctx context.Context) string {
 	if h.clarifyStore == nil {
 		return ""
 	}
-	if !h.clarifyStore.TakeExpired(dialogueIDOf(ctx), h.now()) {
+	n := h.clarifyStore.TakeExpired(dialogueIDOf(ctx), h.now())
+	if n == 0 {
 		return ""
 	}
-	log.Printf("voice: clarify — parked question expired, telling him and routing the words fresh")
-	return clarifyExpiredLine()
+	log.Printf("voice: clarify — %d parked question(s) expired, telling him and routing the words fresh", n)
+	return clarifyExpiredLine(n)
 }
 
 // withNotice glues the expiry notice in front of this turn's reply. One turn
@@ -121,10 +155,52 @@ func withNotice(notice, reply string) string {
 	return notice + " " + reply
 }
 
+// withResumed puts the resumed question on the END of this turn's reply, where
+// withNotice puts the expiry notice on the front (Vikunja #561).
+//
+// The order is the owner's: "в Риме сейчас ..., на какое время поставить
+// напоминание?" — answer first, then the open question. A question in front of
+// its own answer would read as ignoring what he asked.
+//
+// A statement's full stop is folded into a comma, so the two acts read as one
+// sentence — that is the owner's own punctuation, "в Риме сейчас ..., на какое
+// время поставить напоминание?". An answer that is ITSELF a question keeps its
+// mark and the resume starts a new sentence: she sometimes answers a side query
+// by asking him to say it again, and "переформулировать?, на какое время" folds
+// two questions into one unreadable line.
+//
+// A resume with no answer in front of it is just the question.
+func withResumed(reply, resumed string) string {
+	if resumed == "" {
+		return reply
+	}
+	reply = strings.TrimSpace(reply)
+	if reply == "" {
+		return resumed
+	}
+	if strings.HasSuffix(reply, "?") {
+		return reply + " " + resumed
+	}
+	if trimmed := strings.TrimRight(reply, ".!"); trimmed != "" {
+		reply = trimmed
+	}
+	return reply + ", " + lowerFirst(resumed)
+}
+
+// lowerFirst lowercases the opening rune, so a deck line written as a standalone
+// sentence reads as the second half of one. Only the first rune: "На какое
+// время" must become "на какое время" and nothing else in it may move.
+func lowerFirst(s string) string {
+	for i, r := range s {
+		return string(unicode.ToLower(r)) + s[i+utf8.RuneLen(r):]
+	}
+	return s
+}
+
 // missingFor returns the slots a decision still needs, most important first.
 // Empty ⇒ there is nothing identifiable to ask about.
 func missingFor(dec router.Decision) []dialogue.Slot {
-	return dialogue.StillMissing(wantedSlots[dec.Intent], toDialogueSlots(dec.Slots))
+	return stillMissingFor(dec.Intent, dec.Utterance, toDialogueSlots(dec.Slots))
 }
 
 // clarifyQuestion picks the one question to ask for a clarify decision. Returns
@@ -133,18 +209,32 @@ func missingFor(dec router.Decision) []dialogue.Slot {
 // One question about one thing: if two slots are missing she asks about the
 // first only. Two questions in one breath is an interrogation. The second gap
 // is picked up on the turn after the first one is answered (askRemainingGap).
-func clarifyQuestion(dec router.Decision) (dialogue.Slot, string, bool) {
+func (h *reactiveHandler) clarifyQuestion(dec router.Decision) (dialogue.Slot, string, bool) {
 	missing := missingFor(dec)
 	if len(missing) == 0 {
 		return "", "", false
 	}
-	q, ok := clarifyQuestionFor(missing[0], 1)
+	q, ok := h.questionFor(missing[0], 1, dec.Utterance, toDialogueSlots(dec.Slots), "")
 	if !ok {
 		return "", "", false
 	}
 	return missing[0], q, true
 }
 
+// questionFor picks the wording for one gap. Every slot but the reminder's time
+// reads its deck by attempt; the time asks about whichever of the hour, the half
+// of the day and the day he has not said, and states the clock while it does
+// (V-579).
+//
+// taken is the acknowledgement of what his last turn added, empty when it added
+// nothing and empty for a first ask, which has no turn behind it (V-593).
+func (h *reactiveHandler) questionFor(slot dialogue.Slot, attempt int, utterance string, s dialogue.Slots, taken string) (string, bool) {
+	if slot != dialogue.SlotTime {
+		return clarifyQuestionFor(slot, attempt)
+	}
+	return whenQuestion(whenGapOf(utterance, s.HasTime), attempt, h.now(), taken)
+}
+
 // askClarify parks the request and returns the question to ask instead of the
 // canned "не поняла". Returns ("", false) when there is nothing to ask about, so
 // the caller falls back to the canned reply.
@@ -152,11 +242,16 @@ func (h *reactiveHandler) askClarify(ctx context.Context, dec router.Decision) (
 	if h.clarifyStore == nil {
 		return "", false
 	}
-	slot, question, ok := clarifyQuestion(dec)
+	slot, question, ok := h.clarifyQuestion(dec)
 	if !ok {
 		return "", false
 	}
-	h.clarifyStore.Put(dialogueIDOf(ctx), &dialogue.PendingQuestion{
+	// An act she could not resolve is a refusal, not a question (Vikunja #556).
+	if slot == dialogue.SlotFn {
+		log.Printf("voice: clarify — act %q matched no capability; saying so instead of asking", dec.Utterance)
+		return actNotRecognized, true
+	}
+	q := &dialogue.PendingQuestion{
 		Intent:      dialogue.Intent(dec.Intent),
 		Slots:       toDialogueSlots(dec.Slots),
 		Missing:     []dialogue.Slot{slot},
@@ -165,19 +260,69 @@ func (h *reactiveHandler) askClarify(ctx context.Context, dec router.Decision) (
 		TTL:         clarifyTTL,
 		Attempts:    1, // this ask
 		MaxAttempts: h.clarifyMaxAttempts,
-	})
+	}
+	// Push, not Put, when this turn suspended a flow (Vikunja #561): the side
+	// query needs clarifying of ITS own, and Put would replace the top of the
+	// stack — which is the very question the side query was allowed to interrupt
+	// rather than kill. Push keeps both.
+	//
+	// Push returns whatever the depth bound forced out, and that one has to be
+	// spoken: MaxStackDepth is a promise that every level she keeps is a level
+	// she can name when it dies. It is glued in front, like every other notice
+	// about something let go.
+	rt := turnRouteFrom(ctx)
+	if rt != nil && rt.suspended {
+		if evicted := h.clarifyStore.Push(dialogueIDOf(ctx), q); evicted != nil {
+			log.Printf("voice: clarify — stack full at %d, letting go of the request behind %q", dialogue.MaxStackDepth, evicted.Utterance)
+			rt.dropped = withNotice(rt.dropped, clarifyDropped)
+		}
+		// One question per breath still holds. The side query turned out to need
+		// a question of its own, so THAT is the one she asks; resuming as well
+		// would put two questions in one reply, which is the interrogation
+		// askRemainingGap already refuses to run. The suspended flow keeps its
+		// place underneath and is not lost — if it is never reached it dies on
+		// the TTL, and the expiry notice (now plural-aware) says so.
+		rt.resume = ""
+		log.Printf("voice: clarify — asked about %s for intent=%s, stacked on a suspended flow", slot, dec.Intent)
+		return question, true
+	}
+	h.clarifyStore.Put(dialogueIDOf(ctx), q)
 	log.Printf("voice: clarify — asked about %s for intent=%s", slot, dec.Intent)
 	return question, true
 }
 
-// resolveClarifyAnswer reads an utterance as the answer to a parked question.
-// Returns ("", false) when no live question is parked (or it expired), so the
-// caller routes the utterance normally as a fresh request. Sibling of
-// resolveConfirm and checked in the same place.
+// clarifyCancelled — he called the half-built request off. Said out loud, like
+// every other way it can end: a silent drop reads as "done". Feminine
+// self-reference ("отменила"), as everywhere.
+const clarifyCancelled = "Хорошо, отменила."
+
+// clarifyDropped — he asked for something ELSE instead, so the parked request
+// is gone. Glued in front of the answer to what he actually asked, because
+// nothing may be dropped in silence.
 //
-// The answer is parsed with the same extractor the router uses, for the intent
-// she parked — no second parser. If it still does not fill the gap she asks
-// again, up to MaxAttempts; after that she says out loud that she did not
+// Only new_request and cancel reach this since V-561. A side query used to as
+// well, and the owner rejected it on sight: he asks about the weather in the
+// middle of setting a reminder, and hearing "прошлую просьбу отпускаю" tells him
+// a thing he did not ask to lose has been lost. It had not been — there was
+// simply nowhere to put it. Now there is (ClarifyStore's stack), so a side query
+// suspends and resumes, and apologising for a drop that did not happen is worse
+// than saying nothing.
+const clarifyDropped = "Прошлую просьбу отпускаю."
+
+// resolveClarifyAnswer reads an utterance against the parked question and
+// decides what it IS before deciding what to do with it. Returns ("", false)
+// when the turn is not this resolver's — nothing parked, or the utterance turned
+// out to be a request of its own — so the caller dispatches it normally.
+//
+// The order is the point (Vikunja #560). The utterance is ROUTED first, and the
+// role is read off that decision: a routed decision that stands on its own is
+// not an answer, whatever the extractor found inside it. Before this the
+// extractor decided, so "какая сейчас погода в Риме?" became the time of a
+// reminder on the strength of the word "сейчас".
+//
+// The answer itself is parsed with the same extractor the router uses, for the
+// intent she parked — no second parser. If it still does not fill the gap she
+// asks again, up to MaxAttempts; after that she says out loud that she did not
 // understand. She never drops the request in silence.
 func (h *reactiveHandler) resolveClarifyAnswer(ctx context.Context, text string) (string, bool) {
 	if h.clarifyStore == nil {
@@ -185,19 +330,92 @@ func (h *reactiveHandler) resolveClarifyAnswer(ctx context.Context, text string)
 	}
 	q := h.clarifyStore.Get(dialogueIDOf(ctx), h.now())
 	if q == nil {
-		return "", false
+		return "", false // not_applicable: nothing is pending
 	}
 
 	intent := router.Intent(q.Intent)
 	answer := h.extractor.Extract(ctx, intent, text, h.now())
+
+	var (
+		routed   router.Decision
+		routedOK bool
+	)
+	if needsRoute(text) {
+		routed, routedOK = h.routeForRole(ctx, text)
+	}
+	role := classifyTurnRole(q, text, toDialogueSlots(answer), routed, routedOK)
+	log.Printf("voice: clarify — %q is a %s against %s (routed=%v)", text, role, dialogue.CapabilityFor(q.Intent), routedOK)
+
+	switch role {
+	case roleCancel:
+		h.clarifyStore.Delete(dialogueIDOf(ctx))
+		return clarifyCancelled, true
+	case roleSideQuery:
+		// He asked something of his own WITHOUT leaving the flow. The question
+		// stays exactly where it is — same slot, same attempt, same parked
+		// utterance — and these words go on to be answered as themselves. The
+		// resumed question is then glued onto the back of that answer, so one
+		// reply carries both acts (Vikunja #561).
+		//
+		// No attempt is spent. He answered the side query, not the parked
+		// question, and charging a retry for a turn that was never an answer is
+		// the V-554 shape.
+		h.noteSuspended(ctx, q)
+		return "", false
+	case roleAside:
+		// He stated something in the middle of the flow. Same machinery as a
+		// side query and for the same reason: the words are answered as
+		// themselves, so the note or the fact is stored, and the question comes
+		// back on the end of the same reply (V-577 shape 2). Storing it in
+		// silence and dropping it in silence are both wrong, and dropping it is
+		// what she did.
+		h.noteSuspended(ctx, q)
+		return "", false
+	case roleNewRequest:
+		// He moved on. A parked question used to swallow whatever came next, so
+		// one act she could not fulfil ate the following three turns (Vikunja
+		// #554) and a world question set a reminder for a time nobody asked for
+		// (#558). Drop the question, say so, and let these words be themselves.
+		h.clarifyStore.Delete(dialogueIDOf(ctx))
+		h.noteDropped(ctx)
+		return "", false
+	}
+
 	merged := q.Answer(text, toDialogueSlots(answer))
 	// Fold a newly answered subject into the raw utterance. Downstream actions
 	// phrase from Utterance, not from the text slot — actionReminder stores it
 	// as the reminder payload — so a reminder clarified out of a bare "напомни"
 	// would fire at 11:00 saying "напомни" and nothing else.
 	q.Utterance = foldAnswerIntoUtterance(q.Utterance, merged.Text)
-	if len(dialogue.StillMissing(q.Missing, merged)) > 0 {
-		return h.reaskOrGiveUp(ctx, q, merged, text), true
+	// A fact answers with a key and a value and fills no Text slot at all, so
+	// the fold above leaves the utterance at the bare "запиши" — and that is
+	// what the confirmation now reads back to him (V-592). His raw words are the
+	// only record of what he said, so they are what is folded. Never for a time
+	// question: what he says about when is kept apart in WhenText on purpose,
+	// or the reminder would read the day back at him when it fires.
+	if merged.Text == "" && !asksAboutTime(q.Missing) {
+		q.Utterance = foldAnswerIntoUtterance(q.Utterance, text)
+	}
+	// An answer about the time joins everything else he has said about the time,
+	// and the whole of it is re-read as one request (V-579). "завтра" names the
+	// day of an hour she is already holding, and read alone it names no hour at
+	// all, so the parser would have nothing and she would ask for ever.
+	// What he had already said about the time, read BEFORE this answer joins it.
+	// A re-ask that cannot tell the two apart is the one that repeats itself
+	// byte for byte (V-593).
+	var taken string
+	if asksAboutTime(q.Missing) {
+		before := whenKnownOf(whenTextOf(q), q.Slots.HasTime)
+		q.WhenText = strings.TrimSpace(q.WhenText + " " + text)
+		if t, ok := h.readWhen(ctx, intent, q, text); ok {
+			merged.Time, merged.HasTime = t, true
+		}
+		if before.movedForward(whenKnownOf(whenTextOf(q), merged.HasTime)) {
+			taken = whenTakenLine(text)
+		}
+	}
+	if stillOpen(q.Missing, whenTextOf(q), merged) {
+		return h.reaskOrGiveUp(ctx, q, merged, text, taken), true
 	}
 	h.clarifyStore.Delete(dialogueIDOf(ctx))
 
@@ -226,6 +444,45 @@ func (h *reactiveHandler) resolveClarifyAnswer(ctx context.Context, text string)
 	return h.finishClarified(ctx, dec), true
 }
 
+// noteDropped records that the parked request was let go this turn, so runTurn
+// can say it in front of whatever these words are answered with. Nothing to
+// record outside runTurn — a unit test calling one resolver has no turn to glue
+// a notice onto.
+func (h *reactiveHandler) noteDropped(ctx context.Context) {
+	if rt := turnRouteFrom(ctx); rt != nil {
+		rt.dropped = clarifyDropped
+	}
+}
+
+// noteSuspended keeps the parked question alive across a side query and records
+// the words that bring it back, so runTurn can put them after this turn's answer
+// (Vikunja #561).
+//
+// Two things happen to the question and neither is an attempt. Its clock is
+// restarted, because she is about to ask it again and the 90s TTL measures the
+// pause since she last spoke it — leaving Asked at the original ask would let a
+// flow he is actively working through die of a wait he did not take. And the
+// stack is left exactly as it is: the question is already on top, so suspending
+// it is not a write.
+//
+// A slot with no resumed wording (clarifyResumedFor says so) resumes nothing and
+// says nothing. She must not claim to be holding a question she cannot re-ask.
+func (h *reactiveHandler) noteSuspended(ctx context.Context, q *dialogue.PendingQuestion) {
+	rt := turnRouteFrom(ctx)
+	if rt == nil || len(q.Missing) == 0 {
+		return
+	}
+	question, ok := clarifyResumedFor(q.Missing[0])
+	if !ok {
+		return
+	}
+	q.Asked = h.now()
+	h.clarifyStore.Put(dialogueIDOf(ctx), q)
+	rt.resume = question
+	rt.suspended = true
+	log.Printf("voice: clarify — is its own request; suspending the question about %s and resuming it in the same reply", q.Missing[0])
+}
+
 // foldAnswerIntoUtterance appends an answered subject to the original words,
 // unless they already carry it. "напомни" + "позвонить маме" reads as the
 // request he would have made in one breath. Nothing is appended when the
@@ -253,13 +510,13 @@ func foldAnswerIntoUtterance(utterance, subject string) string {
 // costs a question exactly like a second try at the first one does, so the cap
 // still bounds how many times she can speak before acting or letting go.
 func (h *reactiveHandler) askRemainingGap(ctx context.Context, q *dialogue.PendingQuestion, intent router.Intent, merged dialogue.Slots) (string, bool) {
-	remaining := dialogue.StillMissing(wantedSlots[intent], merged)
+	remaining := stillMissingFor(intent, whenTextOf(q), merged)
 	if len(remaining) == 0 {
 		return "", false
 	}
 	// Attempts+1 is the question she is about to ask, and the budget is shared
 	// with the re-ask path, so the second gap is worded like a second try.
-	question, ok := clarifyQuestionFor(remaining[0], q.Attempts+1)
+	question, ok := h.questionFor(remaining[0], q.Attempts+1, whenTextOf(q), merged, "")
 	if !ok || !q.CanAsk() {
 		return "", false
 	}
@@ -268,6 +525,7 @@ func (h *reactiveHandler) askRemainingGap(ctx context.Context, q *dialogue.Pendi
 		Slots:       merged,
 		Missing:     []dialogue.Slot{remaining[0]},
 		Utterance:   q.Utterance,
+		WhenText:    q.WhenText,
 		Asked:       h.now(),
 		TTL:         clarifyTTL,
 		Attempts:    q.Attempts + 1,
@@ -280,10 +538,12 @@ func (h *reactiveHandler) askRemainingGap(ctx context.Context, q *dialogue.Pendi
 // reaskOrGiveUp handles an answer that left the gap open: ask the same question
 // again while she has attempts left, otherwise say she did not understand and
 // let the request go. Never returns "" — a mute give-up reads as "done".
-func (h *reactiveHandler) reaskOrGiveUp(ctx context.Context, q *dialogue.PendingQuestion, merged dialogue.Slots, text string) string {
+// taken is the acknowledgement of what this answer DID give, empty when it gave
+// nothing (V-593). The give-up line never carries it: it is not another ask.
+func (h *reactiveHandler) reaskOrGiveUp(ctx context.Context, q *dialogue.PendingQuestion, merged dialogue.Slots, text, taken string) string {
 	question := ""
 	if len(q.Missing) > 0 {
-		question, _ = clarifyQuestionFor(q.Missing[0], q.Attempts+1)
+		question, _ = h.questionFor(q.Missing[0], q.Attempts+1, whenTextOf(q), merged, taken)
 	}
 	if question == "" || !q.CanAsk() {
 		h.clarifyStore.Delete(dialogueIDOf(ctx))
@@ -320,20 +580,22 @@ func (h *reactiveHandler) finishClarified(ctx context.Context, dec router.Decisi
 	return reply
 }
 
+// maxCarriedHistory — how many turns of PRIOR history (beyond the immediate
+// last turn) rememberTurn carries forward. The session ends up holding this
+// many plus the one just-finished turn, so callers describing the total
+// depth (chatHistory's doc comment, this one) say "up to 4".
+const maxCarriedHistory = 3
+
 // rememberTurn stores this turn as the dialogue session the next follow-up
 // inherits from, carrying up to 4 prior turns of history for anaphora. Capped so
 // one long conversation can't grow the session unboundedly.
 func (h *reactiveHandler) rememberTurn(ctx context.Context, prev *dialogue.Session, dec router.Decision, now time.Time) {
 	var history []dialogue.Turn
 	if prev != nil {
-		history = append(history, dialogue.Turn{
-			Intent: prev.Intent,
-			Slots:  prev.Slots,
-			Text:   prev.Slots.Text,
-		})
+		history = append(history, sessionAsTurn(prev))
 		maxHist := len(prev.History)
-		if maxHist > 3 {
-			maxHist = 3
+		if maxHist > maxCarriedHistory {
+			maxHist = maxCarriedHistory
 		}
 		history = append(history, prev.History[:maxHist]...)
 	}

cmd/mavend/clarify_test.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/kami/maven/internal/dialogue"
 	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/memory"
 	"github.com/kami/maven/internal/phraser/eval"
 	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/store"
@@ -57,18 +58,26 @@ func TestClarifyQuestionForMissingSlot(t *testing.T) {
 		want  string
 		asked bool
 	}{
-		{"reminder without a time", clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме"), "Когда?", true},
+		{"reminder without a time", clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме"), "Сейчас 09:00. Когда?", true},
 		{"fact without a key", clarifyDec(router.IntentFact, router.Slots{Text: "запиши"}, "запиши"), "Что записать?", true},
 		{"act without a fn", clarifyDec(router.IntentAct, router.Slots{Text: "сделай это"}, "сделай это"), "Что сделать?", true},
 		// A time with nothing to say at that time is still half a reminder, so
 		// the subject is what she asks about — not silence.
 		{"reminder that has a time but no subject", clarifyDec(router.IntentReminder, router.Slots{HasTime: true}, "напомни в 11"), "О чём напомнить?", true},
-		{"reminder that has both", clarifyDec(router.IntentReminder, router.Slots{Text: "позвонить маме", HasTime: true}, "напомни в 11 позвонить маме"), "", false},
+		// A bare hour is half of a day away from being an answer, and she asks
+		// which half rather than picking one (V-579).
+		{"reminder whose hour could be either half of the day", clarifyDec(router.IntentReminder, router.Slots{Text: "позвонить маме", HasTime: true}, "напомни в 11 позвонить маме"), "Сейчас 09:00. Это утра или вечера?", true},
+		{"reminder that has all three", clarifyDec(router.IntentReminder, router.Slots{Text: "позвонить маме", HasTime: true}, "напомни завтра в 15:00 позвонить маме"), "", false},
+		// The owner's own two, confirmed 2026-08-06: an unambiguous time and a
+		// relative one are both complete and are never asked about.
+		{"an interval names the instant by itself", clarifyDec(router.IntentReminder, router.Slots{Text: "позвонить маме", HasTime: true}, "напомни через час позвонить маме"), "", false},
+		{"half an hour is an interval too", clarifyDec(router.IntentReminder, router.Slots{Text: "выключить духовку", HasTime: true}, "напомни через полчаса выключить духовку"), "", false},
 		{"chat is never worth a question", clarifyDec(router.IntentChat, router.Slots{Text: "мгм"}, "мгм"), "", false},
 		{"query is never worth a question", clarifyDec(router.IntentQuery, router.Slots{Text: "а"}, "а"), "", false},
 	}
+	h, _, _ := newClarifyHandler(t)
 	for _, tc := range cases {
-		_, got, asked := clarifyQuestion(tc.dec)
+		_, got, asked := h.clarifyQuestion(tc.dec)
 		if asked != tc.asked || got != tc.want {
 			t.Errorf("%s: got (%q, %v), want (%q, %v)", tc.name, got, asked, tc.want, tc.asked)
 		}
@@ -82,11 +91,13 @@ func TestClarifyReminderCompletesOnAnswer(t *testing.T) {
 	h, st, _ := newClarifyHandler(t)
 
 	question, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме"))
-	if !asked || question != "Когда?" {
+	if !asked || question != "Сейчас 09:00. Когда?" {
 		t.Fatalf("expected the time question, got %q asked=%v", question, asked)
 	}
 
-	reply, handled := h.resolveClarifyAnswer(ctx, "в 11:00")
+	// The answer names the day as well as the hour. A reminder commits on what,
+	// what time and what day, and a dayless hour is asked about (V-579).
+	reply, handled := h.resolveClarifyAnswer(ctx, "сегодня в 11:00")
 	if !handled {
 		t.Fatal("the answer to an open question must be consumed as an answer")
 	}
@@ -158,11 +169,11 @@ func TestClarifyAsksThreeTimesThenSaysSo(t *testing.T) {
 		}
 		// The wording changes with the attempt (Vikunja #457): repeating a
 		// question he already failed to answer is the worst way to ask it.
-		want, _ := clarifyQuestionFor(dialogue.SlotTime, i)
+		want, _ := whenQuestion(whenNoHour, i, h.now(), "")
 		if reply != want {
 			t.Fatalf("attempt %d should ask again as %q, got %q", i, want, reply)
 		}
-		if first, _ := clarifyQuestionFor(dialogue.SlotTime, 1); reply == first {
+		if first, _ := whenQuestion(whenNoHour, 1, h.now(), ""); reply == first {
 			t.Fatalf("attempt %d repeated the first wording: %q", i, reply)
 		}
 		if h.clarifyStore.Get(voiceDialogueID, h.now()) == nil {
@@ -215,10 +226,11 @@ func TestClarifyRestatedAnswerWins(t *testing.T) {
 	if q == nil {
 		t.Fatal("expected an armed question")
 	}
-	first := h.extractor.Extract(ctx, router.IntentReminder, "в 11:00", h.now())
-	q.Slots = q.Answer("в 11:00", toDialogueSlots(first))
+	first := h.extractor.Extract(ctx, router.IntentReminder, "сегодня в 11:00", h.now())
+	q.Slots = q.Answer("сегодня в 11:00", toDialogueSlots(first))
+	q.WhenText = "сегодня в 11:00"
 
-	if reply, handled := h.resolveClarifyAnswer(ctx, "нет, в 15:00"); !handled || reply == clarifyGaveUp {
+	if reply, handled := h.resolveClarifyAnswer(ctx, "нет, сегодня в 15:00"); !handled || reply == clarifyGaveUp {
 		t.Fatalf("the restated answer should complete the request, handled=%v reply=%q", handled, reply)
 	}
 	reminders, err := st.DueReminders(ctx, h.now().Add(48*time.Hour))
@@ -231,34 +243,35 @@ func TestClarifyRestatedAnswerWins(t *testing.T) {
 	}
 }
 
-// TestClarifiedActOffAllowlistIsStillRefused — clarification fills in an
-// argument, it never grants authority.
-func TestClarifiedActOffAllowlistIsStillRefused(t *testing.T) {
+// TestActOffAllowlistIsStillRefused — naming a capability is not being granted
+// one. Since Vikunja #556 an unresolved act no longer parks a question, so this
+// goes through applyAction, which is the only way an act runs.
+func TestActOffAllowlistIsStillRefused(t *testing.T) {
 	ctx := context.Background()
 	h, st, _ := newClarifyHandler(t)
 	marker := filepath.Join(t.TempDir(), "not-allowed-ran")
+	if err := st.EnableTool(ctx, "uptime", []string{"true"}, false, "test", h.now()); err != nil {
+		t.Fatal(err)
+	}
 
-	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentAct, router.Slots{Text: "сделай это"}, "сделай это")); !asked {
-		t.Fatal("an act with no fn should be asked about")
-	}
-	reply, handled := h.resolveClarifyAnswer(ctx, "rm "+marker)
-	if !handled {
-		t.Fatal("the answer should be consumed")
-	}
+	reply := h.applyAction(ctx, router.Decision{
+		Utterance: "rm " + marker,
+		Intent:    router.IntentAct,
+		Slots:     router.Slots{Fn: "rm " + marker, HasFn: true},
+	})
 	if strings.Contains(reply, "готово") {
 		t.Fatalf("an act that is not on the allowlist must not report success: %q", reply)
 	}
 	if _, err := os.Stat(marker); !os.IsNotExist(err) {
 		t.Fatalf("a clarified act off the allowlist ran anyway: %v", err)
 	}
-	if tools, err := st.ListTools(ctx, "enabled"); err != nil || len(tools) != 0 {
-		t.Fatalf("clarify must not enable a tool: tools=%+v err=%v", tools, err)
+	if tools, err := st.ListTools(ctx, "enabled"); err != nil || len(tools) != 1 {
+		t.Fatalf("an act must not enable a tool: tools=%+v err=%v", tools, err)
 	}
 }
 
-// TestClarifiedDestructiveActStillNeedsConfirm — the confirm gate survives the
-// clarify path.
-func TestClarifiedDestructiveActStillNeedsConfirm(t *testing.T) {
+// TestDestructiveActStillNeedsConfirm — the confirm gate stands on the act path.
+func TestDestructiveActStillNeedsConfirm(t *testing.T) {
 	ctx := context.Background()
 	h, st, _ := newClarifyHandler(t)
 	marker := filepath.Join(t.TempDir(), "destructive-ran")
@@ -266,18 +279,16 @@ func TestClarifiedDestructiveActStillNeedsConfirm(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentAct, router.Slots{Text: "сделай это"}, "сделай это")); !asked {
-		t.Fatal("expected a question")
-	}
-	reply, handled := h.resolveClarifyAnswer(ctx, "delete_backups")
-	if !handled {
-		t.Fatal("the answer should be consumed")
-	}
+	reply := h.applyAction(ctx, router.Decision{
+		Utterance: "delete_backups",
+		Intent:    router.IntentAct,
+		Slots:     router.Slots{Fn: "delete_backups", HasFn: true},
+	})
 	if !strings.Contains(reply, "да") || h.pending == nil {
-		t.Fatalf("a clarified destructive act must still park a confirm: reply=%q pending=%+v", reply, h.pending)
+		t.Fatalf("a destructive act must park a confirm: reply=%q pending=%+v", reply, h.pending)
 	}
 	if _, err := os.Stat(marker); !os.IsNotExist(err) {
-		t.Fatalf("a clarified destructive act ran before confirmation: %v", err)
+		t.Fatalf("a destructive act ran before confirmation: %v", err)
 	}
 }
 
@@ -357,7 +368,7 @@ func TestClarifyAsksAboutTheSecondGapToo(t *testing.T) {
 	}
 	// Second gap, second attempt, so it is the second wording of the time
 	// question — the attempt budget is shared between the two paths.
-	want, _ := clarifyQuestionFor(dialogue.SlotTime, 2)
+	want, _ := whenQuestion(whenNoHour, 2, h.now(), "")
 	if reply != want {
 		t.Fatalf("a filled subject with no time must ask about the time as %q, got %q", want, reply)
 	}
@@ -369,7 +380,7 @@ func TestClarifyAsksAboutTheSecondGapToo(t *testing.T) {
 		t.Fatalf("the re-parked question lost the answered subject: %+v", q.Slots)
 	}
 
-	if reply, handled := h.resolveClarifyAnswer(ctx, "в 11:00"); !handled || reply == clarifyGaveUp {
+	if reply, handled := h.resolveClarifyAnswer(ctx, "сегодня в 11:00"); !handled || reply == clarifyGaveUp {
 		t.Fatalf("the time answer must complete the reminder, handled=%v reply=%q", handled, reply)
 	}
 	reminders, err := st.DueReminders(ctx, h.now().Add(48*time.Hour))
@@ -419,7 +430,7 @@ func TestClarifyProseHoldsThePersona(t *testing.T) {
 		eval.CheckAddress:   true,
 		eval.CheckCringe:    true,
 	}
-	lines := append([]string{clarifyGaveUp}, clarifyExpiredVariants...)
+	lines := append([]string{clarifyGaveUp, clarifyCancelled, clarifyDropped}, clarifyExpiredVariants...)
 	lines = append(lines, clarifyMissedVariants...)
 	for _, variants := range clarifyQuestionVariants {
 		lines = append(lines, variants...)
@@ -487,7 +498,7 @@ func TestClarifySubjectAnswerFillsRatherThanClobbers(t *testing.T) {
 	at := h.now().Add(2 * time.Hour)
 
 	question, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder,
-		router.Slots{Time: at, HasTime: true}, "напомни в 11"))
+		router.Slots{Time: at, HasTime: true}, "напомни сегодня в 11 утра"))
 	if !asked || question != "О чём напомнить?" {
 		t.Fatalf("expected the subject question, got %q asked=%v", question, asked)
 	}
@@ -564,3 +575,168 @@ func TestARestartExpiresTheParkedQuestion(t *testing.T) {
 		t.Fatalf("notice = %q, want silence: nothing survived to expire", notice)
 	}
 }
+
+// TestClarifyStepsAsideForItsOwnRequest — Vikunja #554. An act she could not
+// fulfil parked "Что сделать?", and the three turns after it were scored as
+// answers to that question: a world question, then "как дела", then the give-up
+// line. None of them was ever an answer.
+func TestClarifyStepsAsideForItsOwnRequest(t *testing.T) {
+	ctx := context.Background()
+	h, _, _ := newClarifyHandler(t)
+
+	// A reminder, not the act this bug was found on: since Vikunja #556 an act
+	// no longer parks anything, so it can no longer eat the turn after it.
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме")); !asked {
+		t.Fatal("a reminder with no time should be asked about")
+	}
+	if reply, handled := h.resolveClarifyAnswer(ctx, "кто изобрёл телефон"); handled {
+		t.Fatalf("a world question must route as itself, got %q", reply)
+	}
+	// Not eating the turn is `handled == false` above, and that is the whole of
+	// #554. Since V-561 the question also SURVIVES it: a side query suspends the
+	// flow rather than ending it, so the reminder is still there and still on the
+	// attempt it was parked with.
+	q := h.clarifyStore.Get(voiceDialogueID, h.now())
+	if q == nil {
+		t.Fatal("a side query must suspend the parked question, not drop it")
+	}
+	if q.Attempts != 1 {
+		t.Errorf("a turn that was never an answer spent an attempt: %d, want 1", q.Attempts)
+	}
+}
+
+// TestClarifyStillRetriesOnAnAnswerThatMissed — the other half of #554, and the
+// reason the test above is narrow. A bare noun answers nothing either, but it
+// carries no request of its own, so she asks again as before.
+func TestClarifyStillRetriesOnAnAnswerThatMissed(t *testing.T) {
+	ctx := context.Background()
+	h, _, _ := newClarifyHandler(t)
+
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме")); !asked {
+		t.Fatal("expected the time question")
+	}
+	reply, handled := h.resolveClarifyAnswer(ctx, "ага")
+	if !handled || reply == "" {
+		t.Fatalf("a missed answer must still be re-asked, handled=%v reply=%q", handled, reply)
+	}
+	if h.clarifyStore.Get(voiceDialogueID, h.now()) == nil {
+		t.Error("the question must survive a missed answer")
+	}
+}
+
+// TestClarifyQuestionShapedAnswerThatFillsTheGapStillLands — the guard runs only
+// where nothing was filled. "во сколько?" is question-shaped and is also how a
+// time gets said back, so an answer that closes the gap wins whatever its shape.
+func TestClarifyQuestionShapedAnswerThatFillsTheGapStillLands(t *testing.T) {
+	ctx := context.Background()
+	h, st, _ := newClarifyHandler(t)
+
+	if _, asked := h.askClarify(ctx, clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме")); !asked {
+		t.Fatal("expected the time question")
+	}
+	if reply, handled := h.resolveClarifyAnswer(ctx, "а что если сегодня в 11:00"); !handled || reply == clarifyGaveUp {
+		t.Fatalf("an answer that fills the gap must land, handled=%v reply=%q", handled, reply)
+	}
+	if reminders, err := st.DueReminders(ctx, h.now().Add(48*time.Hour)); err != nil || len(reminders) != 1 {
+		t.Fatalf("reminder was not created: reminders=%v err=%v", reminders, err)
+	}
+}
+
+// TestUnresolvedActSaysItDoesNotKnowTheCommand — Vikunja #556. "Что сделать?"
+// has no answer he can give, so an act that matched no capability is refused in
+// one line and nothing is parked. It does not recite what she can do instead.
+func TestUnresolvedActSaysItDoesNotKnowTheCommand(t *testing.T) {
+	ctx := context.Background()
+	h, st, _ := newClarifyHandler(t)
+	// Enabled tools change nothing here: this act matched none of them.
+	if err := st.EnableTool(ctx, "uptime", []string{"true"}, false, "test", h.now()); err != nil {
+		t.Fatal(err)
+	}
+
+	reply, spoken := h.askClarify(ctx, clarifyDec(router.IntentAct, router.Slots{Text: "выключи свет"}, "выключи свет"))
+	if !spoken || reply != actNotRecognized {
+		t.Fatalf("reply = %q spoken=%v, want %q", reply, spoken, actNotRecognized)
+	}
+	if strings.Contains(reply, "uptime") {
+		t.Errorf("reply = %q, want no list of capabilities he did not ask about", reply)
+	}
+	if h.clarifyStore.Get(voiceDialogueID, h.now()) != nil {
+		t.Error("nothing to ask about, so nothing may be parked")
+	}
+}
+
+// newRoutingClarifyHandler wires the real cascade (hash embedder, no model) onto
+// the clarify handler, so a test can drive handleText end to end and see which
+// gate claimed the turn.
+func newRoutingClarifyHandler(t *testing.T) (*reactiveHandler, *store.Store) {
+	t.Helper()
+	h, st, _ := newClarifyHandler(t)
+	h.router = buildRouter(router.NewHashEmbedder(1024), h.matcher, 0.55, nil)
+	h.recall = recallWiring{embedder: router.NewHashEmbedder(1024), memStore: memory.NewInMemoryStore()}
+	return h, st
+}
+
+// TestIncompleteReminderAsksInsteadOfFailing — Vikunja #557. "напомни позвонить"
+// is routed confidently and is still half a request. It used to reach applyAction,
+// fail on the missing time and park nothing, so the "в семь вечера" that followed
+// was routed as a world question and web-searched.
+func TestIncompleteReminderAsksInsteadOfFailing(t *testing.T) {
+	ctx := context.Background()
+	h, st := newRoutingClarifyHandler(t)
+
+	reply := h.handleText(ctx, "web", "напомни позвонить маме")
+	want, _ := whenQuestion(whenNoHour, 1, h.now(), "")
+	if reply != want {
+		t.Fatalf("reply = %q, want the time question %q", reply, want)
+	}
+	if h.clarifyStore.Get(dialogueIDFor(sourceText, "web"), h.now()) == nil {
+		t.Fatal("the request must be parked, or the answer has nowhere to land")
+	}
+	if reply := h.handleText(ctx, "web", "сегодня в семь вечера"); strings.Contains(reply, "нашла") {
+		t.Fatalf("the answer to her own question must not be looked up: %q", reply)
+	}
+	if reminders, err := st.DueReminders(ctx, h.now().Add(48*time.Hour)); err != nil || len(reminders) != 1 {
+		t.Fatalf("the answer did not complete the reminder: reminders=%v err=%v", reminders, err)
+	}
+}
+
+// TestBareCaptureVerbAsksWhatToRecord — the other half of #557. A bare "запиши"
+// went to the resident model as chat, which agreed to a wording change nobody
+// asked for. It is a fact with no key, and that gap has a question.
+func TestBareCaptureVerbAsksWhatToRecord(t *testing.T) {
+	ctx := context.Background()
+	h, _ := newRoutingClarifyHandler(t)
+
+	reply := h.handleText(ctx, "web", "запиши")
+	want, _ := clarifyQuestionFor(dialogue.SlotKey, 1)
+	if reply != want {
+		t.Fatalf("reply = %q, want %q", reply, want)
+	}
+	if h.clarifyStore.Get(dialogueIDFor(sourceText, "web"), h.now()) == nil {
+		t.Fatal("the request must be parked so the next utterance completes it")
+	}
+}
+
+// TestACompleteTurnStillDoesNotAsk — the gate reads a missing slot, not any
+// slot, so a request she can act on must never turn into a question. Checked on
+// the decision rather than through the cascade: what is at stake is the gate's
+// condition, and driving it through the hash embedder would measure routing.
+func TestACompleteTurnStillDoesNotAsk(t *testing.T) {
+	ctx := context.Background()
+	h, _, _ := newClarifyHandler(t)
+
+	complete := []router.Decision{
+		{Intent: router.IntentReminder, Slots: router.Slots{Text: "позвонить маме", HasTime: true}, Utterance: "напомни завтра в 11 утра позвонить маме"},
+		{Intent: router.IntentFact, Slots: router.Slots{Key: "water", Value: "выпил", HasKey: true}, Utterance: "я выпил воды"},
+		{Intent: router.IntentNote, Slots: router.Slots{Text: "купить хлеб"}, Utterance: "запиши купить хлеб"},
+		{Intent: router.IntentQuery, Slots: router.Slots{Text: "что у меня сегодня"}, Utterance: "что у меня сегодня"},
+	}
+	for _, dec := range complete {
+		if gaps := missingFor(dec); len(gaps) > 0 {
+			t.Errorf("%q reads as incomplete: %v", dec.Utterance, gaps)
+		}
+		if reply, asked := h.askClarify(ctx, dec); asked {
+			t.Errorf("%q was answered with a question: %q", dec.Utterance, reply)
+		}
+	}
+}

cmd/mavend/clarifytemplates.go

@@ -40,6 +40,9 @@ var clarifyQuestionVariants = map[dialogue.Slot][]string{
 		"Что именно отметить?",
 		"Назови, что записать — например, «выпил воды».",
 	},
+	// Not spoken since Vikunja #556: askClarify answers actNotRecognized for a
+	// missing capability rather than asking. Kept because clarifyQuestion still
+	// reports the gap, and a re-ask deck with a hole in it is harder to read.
 	dialogue.SlotFn: {
 		"Что сделать?",
 		"Какое действие выполнить?",
@@ -47,6 +50,49 @@ var clarifyQuestionVariants = map[dialogue.Slot][]string{
 	},
 }
 
+// clarifyResumedVariants — the wording for a question coming BACK after a side
+// query took the turn away from it (Vikunja #561).
+//
+// It is not the first question again. "Когда?" works in the same breath as
+// "напомни позвонить маме", because the thing it is about was just said. After
+// a turn about the weather in Rome it does not: he has been thinking about
+// something else, and a bare "Когда?" asks him to remember what she is holding.
+// So the resumed form names the request — "напоминание", "заметка" — and the
+// first form stays short.
+//
+// One wording per slot, not a rotation and not an attempt ladder. A resume does
+// not spend an attempt (that is the point of suspending rather than re-asking),
+// so there is no attempt number to vary on, and this line is heard once per
+// interruption rather than repeatedly.
+//
+// Persona holds: infinitive, so no gender agreement, "ты" nowhere needed, no pet
+// names.
+var clarifyResumedVariants = map[dialogue.Slot]string{
+	dialogue.SlotTime: "На какое время поставить напоминание?",
+	dialogue.SlotText: "Так о чём напомнить?",
+	dialogue.SlotKey:  "Так что записать?",
+	dialogue.SlotFn:   "Так какое действие выполнить?",
+}
+
+// clarifyResumedFor gives the resumed wording for a slot. ("", false) when the
+// slot has none, and the caller then resumes nothing rather than inventing a
+// question — a flow it cannot re-ask is one it must not claim to be holding.
+func clarifyResumedFor(slot dialogue.Slot) (string, bool) {
+	q, ok := clarifyResumedVariants[slot]
+	return q, ok
+}
+
+// actNotRecognized is what an act she cannot run gets (Vikunja #556).
+//
+// The deck used to ask "Что сделать?" instead. That question has no answer he
+// can give: he already said what he wanted, and nothing he repeats will match a
+// capability that is not there. So she asked, failed, asked again and gave up —
+// three turns spent on one refusal. She says it once now, and parks nothing.
+//
+// It does not recite the allowlist. A list of names he did not ask about is not
+// an answer to the thing he did ask about.
+const actNotRecognized = "Такую команду я не знаю."
+
 // clarifyQuestionFor picks the wording for this attempt. attempt is 1-based, as
 // PendingQuestion.Attempts counts it; anything past the list uses the last and
 // most explicit phrasing rather than wrapping round to the short one, because

cmd/mavend/confirm.go

@@ -3,9 +3,13 @@ package main
 import (
 	"context"
 	"log"
+	"slices"
+	"sort"
 	"strings"
 	"time"
+	"unicode"
 
+	"github.com/kami/maven/internal/lexicon"
 	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/router"
 )
@@ -20,6 +24,14 @@ type pendingHexisExec struct {
 	entityID     string
 	displayName  string
 	expiry       time.Time
+
+	// correlationID — the id the proposing turn minted for this action. A
+	// confirm arrives on a later turn with a context of its own, so without
+	// carrying it here the execution recorded a fresh id and no causation at
+	// all, and the resolve, the discovery and the thing they authorised sat in
+	// the trace as unrelated calls. The contract mints one id per action, and
+	// the action began when she asked.
+	correlationID string
 }
 
 // pendingRoutineConfirm — a proposed routine awaiting a spoken y/n to become
@@ -57,10 +69,18 @@ func (h *reactiveHandler) park(fn string, args []string, phrase string) {
 // resolveConfirm interprets an utterance as the answer to a parked destructive
 // act OR a parked routine proposal. Returns (reply, true) when it consumed the
 // utterance as a y/n answer; ("", false) when there's nothing pending (or the
-// parked act expired), so the caller routes the utterance normally. An
-// unrecognised answer cancels the pending and routes normally — a confirm that
-// can't be answered clearly is safer abandoned than left armed.
+// parked act expired), so the caller routes the utterance normally.
+//
+// An utterance that is not clearly yes or no is not an answer at all, so it is
+// handed straight back and the pending stays parked until it expires (V-567).
+// This resolver runs before routing and holds the most dangerous trigger on the
+// box; it may only claim a turn it is certain about.
 func (h *reactiveHandler) resolveConfirm(ctx context.Context, text string) (string, bool) {
+	verdict := classifyConfirm(text)
+	if verdict == confirmUnknown {
+		return "", false
+	}
+
 	h.mu.Lock()
 	defer h.mu.Unlock()
 
@@ -68,16 +88,12 @@ func (h *reactiveHandler) resolveConfirm(ctx context.Context, text string) (stri
 		if !r.claim() {
 			continue
 		}
-		// The slot is already cleared by claim(): every branch below drops the
-		// pending, including the unclear one — a confirm that can't be
-		// answered clearly is safer abandoned than left armed.
-		switch classifyConfirm(text) {
+		// The slot is already cleared by claim().
+		switch verdict {
 		case confirmYes:
 			return r.yes(), true
-		case confirmNo:
-			return r.no(), true
 		default:
-			return "", false
+			return r.no(), true
 		}
 	}
 	return "", false
@@ -136,7 +152,11 @@ func (h *reactiveHandler) confirmResolvers(ctx context.Context) []confirmResolve
 				return hx != nil && !h.now().After(hx.expiry)
 			},
 			yes: func() string {
-				return h.execHexis(ctx, hx.capabilityID, hx.capName, hx.entityID, hx.displayName)
+				execCtx := ctx
+				if hx.correlationID != "" {
+					execCtx = withCorrelationID(execCtx, hx.correlationID)
+				}
+				return h.execHexis(execCtx, hx.capabilityID, hx.capName, hx.entityID, hx.displayName)
 			},
 			no: func() string { return phraser.C(phraser.ConfirmCancelled, nil) },
 		},
@@ -194,23 +214,92 @@ const (
 	confirmNo
 )
 
-// classifyConfirm reads a short ru/en yes-or-no answer. Substring match on the
-// stems so inflections/fillers ("да, давай", "нет, отмени") still land.
+// confirmWords are the two closed sets, tokenized once and ordered
+// longest-first so "не надо" is read before "нет" could claim any of it.
+var (
+	confirmYesPhrases = confirmPhrases(lexicon.ConfirmYes())
+	confirmNoPhrases  = confirmPhrases(lexicon.ConfirmNo())
+)
+
+// confirmPhrases splits each lexicon member into tokens and sorts the result
+// longest-first, so a walk that tries them in order matches the longest member
+// that fits.
+func confirmPhrases(words []string) [][]string {
+	out := make([][]string, 0, len(words))
+	for _, w := range words {
+		if toks := confirmTokens(w); len(toks) > 0 {
+			out = append(out, toks)
+		}
+	}
+	sort.SliceStable(out, func(i, j int) bool { return len(out[i]) > len(out[j]) })
+	return out
+}
+
+// confirmTokens splits an utterance into lowercase word tokens. Punctuation and
+// spacing are separators; an apostrophe is not, because "don't" is one word.
+func confirmTokens(text string) []string {
+	return strings.FieldsFunc(strings.ToLower(text), func(r rune) bool {
+		if r == '\'' || r == '’' {
+			return false
+		}
+		return !unicode.IsLetter(r) && !unicode.IsDigit(r)
+	})
+}
+
+// classifyConfirm reads a short ru/en yes-or-no answer to a parked confirm.
+//
+// The whole utterance must consist of confirmation words and filler, matched as
+// whole tokens against the closed lexicon sets. Anything else is
+// confirmUnknown, which leaves the confirm parked and routes the turn — see
+// resolveConfirm. Both halves of that are the fix for V-567: this used to be a
+// substring test over bare stems, so "погода", "дальше", "надо" and "давление"
+// all read as "да", and "покажи" and "около" read as "ок". A parked destructive
+// act fired on a question about the weather.
+//
+// Requiring the WHOLE utterance is the second half. A leading confirm word does
+// not make a sentence an answer: "давай посмотрим погоду" opens a request, and
+// the only safe reading of a sentence that carries its own subject is that he
+// moved on. Guessing wrong here executes something; guessing wrong the other way
+// asks again.
 func classifyConfirm(text string) confirmVerdict {
-	t := strings.ToLower(strings.TrimSpace(text))
-	// negatives first — "не надо" contains no "да", but check no-stems before
-	// yes so a leading "нет" isn't shadowed.
-	for _, no := range []string{"нет", "не надо", "отмен", "стоп", "no", "cancel", "stop", "don't"} {
-		if strings.Contains(t, no) {
+	tokens := confirmTokens(text)
+	if len(tokens) == 0 {
+		return confirmUnknown
+	}
+	verdict := confirmUnknown
+	for i := 0; i < len(tokens); {
+		// Negatives first: "не надо" and "не хочу" open with a token that is
+		// not itself an answer, and a yes hit must never shadow them.
+		if n := matchConfirm(confirmNoPhrases, tokens[i:]); n > 0 {
 			return confirmNo
 		}
+		if n := matchConfirm(confirmYesPhrases, tokens[i:]); n > 0 {
+			verdict, i = confirmYes, i+n
+			continue
+		}
+		if lexicon.IsFillerParticle(tokens[i]) {
+			i++
+			continue
+		}
+		// A word that is neither an answer nor filler carries a subject of its
+		// own, so this utterance is not an answer to her question.
+		return confirmUnknown
 	}
-	for _, yes := range []string{"да", "ага", "давай", "подтвер", "конечно", "yes", "yeah", "yep", "confirm", "ок", "okay", "ok"} {
-		if strings.Contains(t, yes) {
-			return confirmYes
+	return verdict
+}
+
+// matchConfirm reports the length of the longest phrase matching at the head of
+// tokens, or 0.
+func matchConfirm(phrases [][]string, tokens []string) int {
+	for _, p := range phrases {
+		if len(p) > len(tokens) {
+			continue
+		}
+		if slices.Equal(p, tokens[:len(p)]) {
+			return len(p)
 		}
 	}
-	return confirmUnknown
+	return 0
 }
 
 // actPhrase renders "fn arg1 arg2" for the confirm prompt.

cmd/mavend/confirm_test.go

@@ -0,0 +1,103 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/tool"
+)
+
+// TestClassifyConfirmRejectsSubstrings — V-567. The old matcher tested bare
+// stems with strings.Contains, so every word below answered a question she had
+// asked about something else: "погода", "дальше", "надо" and "давление" carry
+// "да"; "покажи", "около" and "окно" carry "ок". A parked destructive act fired
+// on a question about the weather.
+func TestClassifyConfirmRejectsSubstrings(t *testing.T) {
+	for _, text := range []string{
+		"погода",
+		"какая погода",
+		"что дальше",
+		"надо ещё",
+		"покажи заметки",
+		"около окна",
+		"давление",
+		"давай посмотрим погоду",
+		"не забудь купить хлеб",
+		"окно открыто",
+		"стоит ли брать зонт",
+		"",
+	} {
+		if got := classifyConfirm(text); got != confirmUnknown {
+			t.Errorf("classifyConfirm(%q) = %v, want confirmUnknown", text, got)
+		}
+	}
+}
+
+// TestClassifyConfirmAcceptsAnswers keeps every genuine answer the substring
+// matcher accepted, and pins the pair the fix could most easily get wrong:
+// "надо" is not an answer and "не надо" is the opposite of one.
+func TestClassifyConfirmAcceptsAnswers(t *testing.T) {
+	yes := []string{"да", "Да!", "ага", "давай", "да, давай", "конечно", "подтверждаю", "ну да", "yes", "yeah", "ok", "okay", "confirm"}
+	no := []string{"нет", "Нет.", "не надо", "не нужно", "не сейчас", "отмена", "отмени", "стоп", "нет, отмени", "no", "nope", "cancel", "stop", "don't"}
+
+	for _, text := range yes {
+		if got := classifyConfirm(text); got != confirmYes {
+			t.Errorf("classifyConfirm(%q) = %v, want confirmYes", text, got)
+		}
+	}
+	for _, text := range no {
+		if got := classifyConfirm(text); got != confirmNo {
+			t.Errorf("classifyConfirm(%q) = %v, want confirmNo", text, got)
+		}
+	}
+}
+
+// TestUnrelatedTurnLeavesConfirmParked — the whole point of V-567. An utterance
+// that is not an answer must not execute the parked act, must not consume the
+// turn, and must not disarm the confirm either: the answer he has not given yet
+// is still answerable until it expires.
+func TestUnrelatedTurnLeavesConfirmParked(t *testing.T) {
+	ctx := context.Background()
+	st := newTestStore(t)
+	api := ipc.NewStoreAPI(st)
+	now := time.Date(2026, 8, 6, 9, 0, 0, 0, time.UTC)
+	h := &reactiveHandler{
+		api:       api,
+		dataStore: st,
+		now:       func() time.Time { return now },
+		tools:     tool.NewExecutor(api, time.Second),
+	}
+
+	marker := filepath.Join(t.TempDir(), "destructive-tool-ran")
+	if err := st.EnableTool(ctx, "delete_backups", []string{"touch", marker}, true, "test", h.now()); err != nil {
+		t.Fatal(err)
+	}
+	h.park("delete_backups", nil, "delete_backups")
+
+	if reply, handled := h.resolveConfirm(ctx, "какая погода"); handled {
+		t.Fatalf("the weather question was consumed as a confirm: %q", reply)
+	}
+	if _, err := os.Stat(marker); !os.IsNotExist(err) {
+		t.Fatalf("the parked destructive command ran on an unrelated turn: %v", err)
+	}
+	if h.pending == nil {
+		t.Fatal("the confirm was disarmed by a turn that did not answer it")
+	}
+
+	// It is still answerable, and answering it still runs the act.
+	reply, handled := h.resolveConfirm(ctx, "да")
+	if !handled || !strings.Contains(reply, "готово") {
+		t.Fatalf("the still-parked confirm did not resolve: handled=%v reply=%q", handled, reply)
+	}
+	if _, err := os.Stat(marker); err != nil {
+		t.Fatalf("confirmed destructive command did not run: %v", err)
+	}
+	if h.pending != nil {
+		t.Fatal("the confirm stayed parked after being answered")
+	}
+}

cmd/mavend/crawls.go

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

cmd/mavend/dayplan_test.go

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

cmd/mavend/decisiontrace.go

@@ -0,0 +1,132 @@
+// mavend/decisiontrace.go — the daemon's half of the per-turn decision record.
+//
+// V-564. The router says what the cascade did (internal/router/decisiontrace.go);
+// this file covers the two claimant sets that live in the daemon: the stateful
+// resolvers that run BEFORE routing and pre-empt it unconditionally, and the
+// query source chain that runs after. Those two are where the arbitration is
+// least visible, because both are a hardcoded order of functions that each
+// answer "is this mine?" alone and none of which answers "is this more mine
+// than yours?" (V-558).
+//
+// Recording changes no route. Every helper here is a no-op on a context with no
+// record, which is what every test that does not ask for one gets.
+package main
+
+import (
+	"context"
+
+	"github.com/kami/maven/internal/decision"
+	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/router"
+)
+
+// preRouteLadder — the resolvers runTurn offers the utterance to before the
+// router sees it, in the order they get their say. Kept here as a roster rather
+// than derived from the code, so a resolver that returns early and skips the
+// rest still leaves the rest NAMED in the record: a claimant that never looked
+// and one that looked and passed are the distinction the ordering hides, and
+// they are the difference between a bug in the ladder and a bug in a resolver.
+//
+// Adding a step to runTurn means adding its name here. Nothing enforces that,
+// and nothing should: a missing name costs one line of the record, while a
+// check that walks the ladder would have to run the ladder.
+var preRouteLadder = []string{
+	"confirm", "clarify-answer", "quiet-toggle", "snooze", "ack", "repair", "ordinal",
+}
+
+// notePreRoute records one rung of that ladder and passes its verdict through
+// unchanged, so the call site stays the single `if handled` it already was.
+func notePreRoute(ctx context.Context, name string, handled bool) bool {
+	rec := decision.From(ctx)
+	if rec == nil {
+		return handled
+	}
+	if handled {
+		rec.Note(decision.Claim{
+			Stage: decision.StagePreRoute, Claimant: name, Outcome: decision.Won,
+			Reason: "it pre-empted routing, so the router never saw this turn",
+		})
+		return handled
+	}
+	rec.Note(decision.Claim{
+		Stage: decision.StagePreRoute, Claimant: name, Outcome: decision.Declined,
+		Reason: "nothing of its own was pending",
+	})
+	return handled
+}
+
+// noteTerminal records whoever actually produced the reply, but only if the
+// turn is still unclaimed. A route decides the intent; it does not answer, and
+// on a thinned route or a plain act nothing downstream keeps a scoreboard. So
+// the record would otherwise close with an empty winner, which reads as a lost
+// turn instead of an asked question.
+func noteTerminal(ctx context.Context, claimant string, intent router.Intent, reason string) {
+	decision.From(ctx).NoteIfUnclaimed(decision.Claim{
+		Stage: decision.StageAction, Claimant: claimant,
+		Intent: string(intent), Reason: reason,
+	})
+}
+
+// noteMerge records the follow-up merge, which is the one claimant that edits
+// the winning decision instead of taking the turn from it. It is compared on
+// the four slots the merge can fill, because a Decision holds a slice and is
+// not comparable.
+func noteMerge(ctx context.Context, before, after router.Decision) {
+	rec := decision.From(ctx)
+	if rec == nil {
+		return
+	}
+	changed := before.Slots.HasTime != after.Slots.HasTime ||
+		before.Slots.HasKey != after.Slots.HasKey ||
+		before.Slots.HasFn != after.Slots.HasFn ||
+		before.Slots.Text != after.Slots.Text ||
+		before.Intent != after.Intent
+	if !changed {
+		rec.Note(decision.Claim{
+			Stage: decision.StageMerge, Claimant: "follow-up-merge", Outcome: decision.Declined,
+			Reason: "no slot of this turn was left for a previous one to fill",
+		})
+		return
+	}
+	rec.Note(decision.Claim{
+		Stage: decision.StageMerge, Claimant: "follow-up-merge", Intent: string(after.Intent),
+		Outcome: decision.Merged, Reason: "filled this turn's gaps from the previous turn",
+	})
+}
+
+// turnDecisionsFn — the reader mavweb gets, or nil when voice was never wired.
+// Same shape as intakeEventsFn: the daemon holds the ring, the IPC layer only
+// converts it.
+func turnDecisionsFn(w *voiceWiring) func(int) []ipc.TurnDecision {
+	if w == nil || w.handler == nil || w.handler.decisions == nil {
+		return nil
+	}
+	ring := w.handler.decisions
+	return func(n int) []ipc.TurnDecision {
+		recs := ring.Recent(n)
+		out := make([]ipc.TurnDecision, 0, len(recs))
+		for _, rec := range recs {
+			claims := make([]ipc.TurnClaim, 0, len(rec.Claims))
+			for _, c := range rec.Claims {
+				claims = append(claims, ipc.TurnClaim{
+					Stage: c.Stage, Claimant: c.Claimant, Intent: c.Intent,
+					Score: c.Score, HasScore: c.HasScore,
+					Outcome: c.Outcome, Reason: c.Reason,
+				})
+			}
+			out = append(out, ipc.TurnDecision{
+				Ts: rec.Ts, Utterance: rec.Utterance, Winner: rec.Winner, Claims: claims,
+			})
+		}
+		return out
+	}
+}
+
+// querySourceNames — the query chain's roster, in chain order.
+func querySourceNames() []string {
+	names := make([]string, len(querySources))
+	for i, src := range querySources {
+		names[i] = src.name
+	}
+	return names
+}

cmd/mavend/decisiontrace_test.go

@@ -0,0 +1,163 @@
+package main
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/kami/maven/internal/decision"
+	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/memory"
+	"github.com/kami/maven/internal/router"
+	"github.com/kami/maven/internal/tool"
+	"github.com/kami/maven/internal/voice"
+)
+
+// traceHandler — a handler with the decision ring wired, the same shape the
+// daemon builds in wireVoice.
+func traceHandler(t *testing.T, ring *decision.Ring) *reactiveHandler {
+	t.Helper()
+	st := newTestStore(t)
+	api := ipc.NewStoreAPI(st)
+	now := time.Now()
+	emb := router.NewHashEmbedder(1024)
+	return &reactiveHandler{
+		api:       api,
+		recall:    recallWiring{embedder: emb, memStore: memory.NewInMemoryStore()},
+		router:    buildRouter(emb, tool.NewMatcher(api), 0.55, nil),
+		replier:   voice.NewStubReplier(),
+		now:       func() time.Time { return now },
+		dataStore: st,
+		decisions: ring,
+	}
+}
+
+// findClaim — the first claim for a claimant, or nil.
+func findClaim(rec *decision.Record, claimant string) *decision.Claim {
+	for i := range rec.Claims {
+		if rec.Claims[i].Claimant == claimant {
+			return &rec.Claims[i]
+		}
+	}
+	return nil
+}
+
+// TestTurnRecordNamesWinnerAndLosers — the point of V-564. A turn a stage-0
+// grammar claims must leave a record naming that grammar as the winner, naming
+// a pre-route resolver that declined, and naming the routing engines that were
+// never reached at all. The last of those is the fact the hardcoded ordering
+// hides: "classifier" absent from the record and "classifier" never asked read
+// the same to a human, and only one of them is the truth.
+func TestTurnRecordNamesWinnerAndLosers(t *testing.T) {
+	ring := decision.NewRing()
+	h := traceHandler(t, ring)
+
+	reply := h.handleText(context.Background(), "web", "сколько сейчас времени")
+	if reply == "" {
+		t.Fatal("turn produced no reply")
+	}
+
+	recs := ring.Recent(5)
+	if len(recs) != 1 {
+		t.Fatalf("want 1 record, got %d", len(recs))
+	}
+	rec := recs[0]
+	if rec.Utterance != "сколько сейчас времени" {
+		t.Errorf("utterance = %q", rec.Utterance)
+	}
+	if !strings.HasPrefix(rec.Winner, "stage0:") {
+		t.Errorf("want a stage-0 grammar as the winner, got %q", rec.Winner)
+	}
+
+	// A loser that examined the turn: the confirm resolver ran first and had
+	// nothing pending.
+	confirm := findClaim(rec, "confirm")
+	if confirm == nil || confirm.Outcome != decision.Declined {
+		t.Errorf("confirm claim = %+v, want a decline", confirm)
+	}
+
+	// A loser that never looked: stage 0 answered, so neither routing engine
+	// was reached.
+	for _, name := range []string{"llm-router", "classifier"} {
+		c := findClaim(rec, name)
+		if c != nil && c.Outcome == decision.Won {
+			t.Errorf("%s cannot have won a stage-0 turn: %+v", name, c)
+		}
+	}
+
+	// And every rung of the ladder below the winner is named, not omitted.
+	for _, name := range preRouteLadder {
+		if findClaim(rec, name) == nil {
+			t.Errorf("ladder rung %q is missing from the record", name)
+		}
+	}
+}
+
+// TestRecordingDoesNotChangeTheReply — instrumentation, so a turn with the ring
+// wired and the same turn without it must answer identically. If this ever
+// fails, a claim site is doing more than noting.
+func TestRecordingDoesNotChangeTheReply(t *testing.T) {
+	for _, utt := range []string{
+		"сколько сейчас времени",
+		"запиши что я пил воду",
+		"что у меня сегодня",
+	} {
+		withRing := traceHandler(t, decision.NewRing()).handleText(context.Background(), "web", utt)
+		without := traceHandler(t, nil).handleText(context.Background(), "web", utt)
+		if withRing != without {
+			t.Errorf("%q: recorded reply %q != unrecorded %q", utt, withRing, without)
+		}
+	}
+}
+
+// TestQueryChainRecordsWhoWasNeverAsked — a query source below the claimant is
+// never consulted, and the record must say so rather than leave it out. This is
+// the arm that would have explained the Rome misroute in one read.
+func TestQueryChainRecordsWhoWasNeverAsked(t *testing.T) {
+	ring := decision.NewRing()
+	h := traceHandler(t, ring)
+	h.handleText(context.Background(), "web", "что у меня сегодня")
+
+	rec := ring.Recent(1)[0]
+	var asked, never int
+	for _, c := range rec.Claims {
+		if c.Stage != decision.StageQuery {
+			continue
+		}
+		if c.Outcome == decision.NeverAsked {
+			never++
+		} else {
+			asked++
+		}
+	}
+	if asked == 0 {
+		t.Fatal("no query source reported at all")
+	}
+	if never == 0 {
+		t.Fatal("no query source was recorded as never asked; the chain cannot have run to the end")
+	}
+	if got := len(querySourceNames()); asked+never != got {
+		t.Errorf("record covers %d of %d query sources", asked+never, got)
+	}
+}
+
+// TestTurnDecisionsFnConvertsTheRing — the IPC read path. Nil when voice was
+// never wired, because a box with no turns is an empty page and not an error.
+func TestTurnDecisionsFnConvertsTheRing(t *testing.T) {
+	if fn := turnDecisionsFn(nil); fn != nil {
+		t.Error("no wiring should mean no reader")
+	}
+	ring := decision.NewRing()
+	h := traceHandler(t, ring)
+	h.handleText(context.Background(), "web", "сколько сейчас времени")
+
+	fn := turnDecisionsFn(&voiceWiring{handler: h})
+	if fn == nil {
+		t.Fatal("wired handler produced no reader")
+	}
+	out := fn(10)
+	if len(out) != 1 || out[0].Winner == "" || len(out[0].Claims) == 0 {
+		t.Fatalf("conversion lost the record: %+v", out)
+	}
+}

cmd/mavend/dialogue_contract_test.go

@@ -0,0 +1,807 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"log"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/kami/maven/internal/dialogue"
+	"github.com/kami/maven/internal/memory"
+	"github.com/kami/maven/internal/router"
+	"github.com/kami/maven/internal/store"
+)
+
+// Dialogue contract tests (V-563, child of V-558).
+//
+// Every other clarify test is single-shot: one ask, one answer, one assertion.
+// Three bugs of the same family shipped in two days that way — V-554 (a parked
+// question ate the three turns after it), V-557 (a confidently routed but
+// incomplete reminder parked nothing, so the answer was web-searched) and the
+// Rome case in V-558 (a side question was eaten as the time answer). None of
+// them is visible in one turn. The dialogue path is a state machine, so it can
+// be enumerated instead: whole traces, each with a per-turn expectation and an
+// expected END state — what was written to the store, and what is still parked.
+//
+// Two rules for the rows below.
+//
+// Where today's behaviour is correct, it is asserted. Where it is WRONG, the row
+// carries the CORRECT expectation and is skipped with the Vikunja id that will
+// unskip it. A weakened expectation would be worse than no row: it would pin the
+// bug as the contract.
+//
+// Everything runs on the offline floor — hash embedder, no llama-server, no
+// ONNX, StubDateTimeParser. That has one consequence worth knowing before
+// reading a fire time here: the stub reads "в 11:00" and "через час" and does
+// not read "на 9" or "на завтра", so a trace that needs those is noted where it
+// sits.
+
+// claim — which claimant consumed an utterance. Not asserted: it is derived from
+// the log lines the daemon already emits and printed on every failure, because
+// "the reply differed" does not distinguish a wrong claimant from wrong copy,
+// and that distinction is the whole point of V-558.
+type claim struct {
+	utterance string
+	steps     []string
+}
+
+func (c claim) String() string { return c.utterance + " ⇒ " + strings.Join(c.steps, " → ") }
+
+// claimMarkers — log fragment to claimant name, in the order runTurn checks
+// them. The fragments are the daemon's own words (clarify.go, repair.go,
+// voice.go); a rename there shows up here as an "unclaimed" step rather than a
+// silent mislabel.
+var claimMarkers = []struct{ fragment, name string }{
+	{"parked question expired", "clarify:expired"},
+	{"is its own request", "clarify:stepped-aside"},
+	{"gave up on", "clarify:gave-up"},
+	{"did not fill", "clarify:re-ask"},
+	{"one gap filled", "clarify:ask-second-gap"},
+	{"asked about", "clarify:ask"},
+	{"repair —", "repair"},
+	{"route result: intent=", "route"},
+}
+
+// claimsOf reads the turn's log output and names the claimants that touched it.
+func claimsOf(utterance, logged string) claim {
+	c := claim{utterance: utterance}
+	for _, line := range strings.Split(logged, "\n") {
+		for _, m := range claimMarkers {
+			if strings.Contains(line, m.fragment) {
+				name := m.name
+				if m.name == "route" {
+					name = "route:" + intentInLine(line)
+				}
+				c.steps = append(c.steps, name)
+				break
+			}
+		}
+	}
+	if len(c.steps) == 0 {
+		c.steps = []string{"unclaimed"}
+	}
+	return c
+}
+
+func intentInLine(line string) string {
+	_, rest, ok := strings.Cut(line, "intent=")
+	if !ok {
+		return "?"
+	}
+	intent, _, _ := strings.Cut(rest, " ")
+	return intent
+}
+
+// parkedWant — the question that must be armed after a turn. Attempt matters:
+// a claimant that spends a retry on an utterance that was never an answer is
+// exactly the V-554 shape, and the count is the only place it shows.
+type parkedWant struct {
+	slot    dialogue.Slot
+	attempt int
+	// carries — a substring the parked utterance must still hold, so a re-park
+	// that lost the answered subject fails here rather than three turns later.
+	carries string
+}
+
+// turn — one utterance and everything that must be true right after it.
+type turn struct {
+	say string
+	// wait — the clock moves this far BEFORE the utterance. The only way to
+	// reach the TTL without sleeping.
+	wait time.Duration
+	// question — the reply must be exactly this clarify question, worded for
+	// this attempt. Zero slot ⇒ not checked.
+	question dialogue.Slot
+	attempt  int
+	// gap — which part of the time she is asking about, for a SlotTime question
+	// (V-579). Zero value is the missing hour, which is what she asks first.
+	gap whenGap
+	// took — the words of the PREVIOUS turn that this ask must acknowledge
+	// before asking again (V-593). Empty ⇒ the ask carries no acknowledgement,
+	// which is right for a first ask and for an answer that moved nothing.
+	took string
+	// differs — this reply must not be byte-identical to the one before it. Set
+	// on a re-ask whose turn moved the request forward (V-593).
+	differs    bool
+	contains   []string
+	notContain []string
+	// noQuestion — the reply must not be any clarify question. Used where the
+	// correct behaviour is known but her wording for it is not written yet: a
+	// cancel must not be answered with another question, whatever it does say.
+	noQuestion bool
+	expired    bool // the reply must open with the TTL notice
+	// parked — what is armed after the turn. nil ⇒ nothing may be armed.
+	parked *parkedWant
+}
+
+// endState — what the store holds once the trace is over. Counts and
+// substrings, not rows: a trace is about who claimed what, and a payload
+// substring is enough to catch a request landing under the wrong words.
+type endState struct {
+	reminders []reminderWant
+	factKeys  []string
+	notes     int
+	tasks     []string
+}
+
+type reminderWant struct {
+	payload string // substring of the stored payload
+	fireAt  string // "2006-01-02 15:04" in UTC, "" ⇒ not checked
+}
+
+// trace — a named conversation, its turns, and the end state.
+type trace struct {
+	name  string
+	skip  string // non-empty ⇒ t.Skip: today's behaviour is wrong, this names the fix
+	turns []turn
+	end   endState
+}
+
+// newDialogueHandler — the offline floor with the real cascade and a movable
+// clock: newClarifyHandler's wiring (stub date parser, real fact parser, tool
+// matcher) plus the router newRoutingClarifyHandler builds, and the `now`
+// pointer so a turn can carry a wait.
+func newDialogueHandler(t *testing.T) (*reactiveHandler, *store.Store, *time.Time) {
+	t.Helper()
+	h, st, now := newClarifyHandler(t)
+	// A minute no trace ever says, so "fires at the current clock" is a defect
+	// and never a coincidence (V-577, V-579). checkEnd refuses any reminder
+	// landing on it, and at 09:00 the row that answers "на 9" would trip that.
+	*now = time.Date(2026, 7, 31, 9, 17, 0, 0, time.UTC)
+	h.router = buildRouter(router.NewHashEmbedder(1024), h.matcher, 0.55, nil)
+	h.recall = recallWiring{embedder: router.NewHashEmbedder(1024), memStore: memory.NewInMemoryStore()}
+	return h, st, now
+}
+
+// wantedQuestion builds the question a turn must be answered with, from the
+// same code the daemon asks through. A time question is built from the gap,
+// because she names the clock and asks about the part he left out (V-579).
+func wantedQuestion(tn turn, now time.Time) (string, bool) {
+	if tn.question == dialogue.SlotTime {
+		gap := tn.gap
+		if gap == whenComplete {
+			gap = whenNoHour
+		}
+		return whenQuestion(gap, tn.attempt, now, whenTakenLine(tn.took))
+	}
+	return clarifyQuestionFor(tn.question, tn.attempt)
+}
+
+// runTrace drives one trace through handleText and checks every turn, then the
+// end state. Every failure carries the decision trace so far, so a wrong
+// claimant reads differently from wrong copy.
+func runTrace(t *testing.T, tr trace) {
+	t.Helper()
+	// MAVEN_DIALOGUE_NO_SKIP=1 runs the rows that fail today. That is how
+	// whoever lands V-560, V-561 or V-562 sees their row go green before
+	// deleting its skip, and it is also the check that a skip is still earned:
+	// a row that passes with the skip in place is a fix nobody noticed.
+	if tr.skip != "" && os.Getenv("MAVEN_DIALOGUE_NO_SKIP") == "" {
+		t.Skip(tr.skip)
+	}
+	ctx := context.Background()
+	h, st, now := newDialogueHandler(t)
+	const conversation = "web"
+	id := dialogueIDFor(sourceText, conversation)
+
+	var claims []claim
+	var previous string
+	fail := func(turnIdx int, format string, args ...any) {
+		t.Helper()
+		lines := make([]string, 0, len(claims))
+		for _, c := range claims {
+			lines = append(lines, "    "+c.String())
+		}
+		t.Fatalf("turn %d: "+format+"\n  who claimed what:\n%s",
+			append([]any{turnIdx}, append(args, strings.Join(lines, "\n"))...)...)
+	}
+
+	for i, tn := range tr.turns {
+		if tn.wait > 0 {
+			*now = now.Add(tn.wait)
+		}
+		var logged bytes.Buffer
+		prev := log.Writer()
+		log.SetOutput(&logged)
+		reply := h.handleText(ctx, conversation, tn.say)
+		log.SetOutput(prev)
+		claims = append(claims, claimsOf(tn.say, logged.String()))
+
+		body := reply
+		if tn.expired {
+			if !isClarifyExpired(reply) {
+				fail(i, "reply %q must open with the expiry notice", reply)
+			}
+			body = trimClarifyExpired(reply)
+			// The notice is glued in front of this turn's reply, and both halves
+			// have to survive: the words he just said are routed fresh, and
+			// answering only "I let the old one go" drops them.
+			if body == "" {
+				fail(i, "the notice was the whole reply; the fresh words were never answered")
+			}
+		} else if isClarifyExpired(reply) {
+			fail(i, "reply %q announced an expiry nothing asked for", reply)
+		}
+		if tn.question != "" {
+			want, ok := wantedQuestion(tn, h.now())
+			if !ok {
+				fail(i, "no question exists for slot %s attempt %d", tn.question, tn.attempt)
+			}
+			if body != want {
+				fail(i, "reply %q, want the %s question worded for attempt %d, %q", body, tn.question, tn.attempt, want)
+			}
+		}
+		if tn.noQuestion && isAnyClarifyQuestion(body) {
+			fail(i, "reply %q is another question; this turn is not something to ask about", body)
+		}
+		for _, want := range tn.contains {
+			if !strings.Contains(body, want) {
+				fail(i, "reply %q does not carry %q", body, want)
+			}
+		}
+		for _, unwanted := range tn.notContain {
+			if strings.Contains(body, unwanted) {
+				fail(i, "reply %q carries %q and must not", body, unwanted)
+			}
+		}
+		if tn.differs && reply == previous {
+			fail(i, "reply %q is byte-identical to the one before it, and his turn between them answered part of the gap", reply)
+		}
+		previous = reply
+		checkParked(t, fail, i, h.clarifyStore.Get(id, h.now()), tn.parked)
+	}
+	checkEnd(t, ctx, st, h, tr.end, claims)
+}
+
+// isAnyClarifyQuestion — is this reply one of her clarify questions, at any
+// attempt wording? Reads the templates rather than a list of its own.
+func isAnyClarifyQuestion(reply string) bool {
+	for _, variants := range clarifyQuestionVariants {
+		for _, v := range variants {
+			// HasSuffix, not equality: a question about the time opens with the
+			// clock she is reasoning from (V-579).
+			if strings.HasSuffix(reply, v) {
+				return true
+			}
+		}
+	}
+	// The two questions with no deck behind them, asked when the hour is said
+	// and its half of the day or its day is not.
+	return strings.HasSuffix(reply, "утра или вечера?") || strings.HasSuffix(reply, "В какой день?")
+}
+
+func checkParked(t *testing.T, fail func(int, string, ...any), i int, got *dialogue.PendingQuestion, want *parkedWant) {
+	t.Helper()
+	if want == nil {
+		if got != nil {
+			fail(i, "a question about %v is still armed and nothing should be: %+v", got.Missing, got.Slots)
+		}
+		return
+	}
+	if got == nil {
+		fail(i, "nothing is armed, want a question about %s (attempt %d)", want.slot, want.attempt)
+		return
+	}
+	if len(got.Missing) != 1 || got.Missing[0] != want.slot {
+		fail(i, "armed question is about %v, want %s", got.Missing, want.slot)
+	}
+	if got.Attempts != want.attempt {
+		fail(i, "armed question is on attempt %d, want %d — a retry spent on something that was never an answer is the V-554 shape", got.Attempts, want.attempt)
+	}
+	if want.carries != "" && !strings.Contains(got.Utterance, want.carries) {
+		fail(i, "the parked request no longer carries %q: %q", want.carries, got.Utterance)
+	}
+}
+
+func checkEnd(t *testing.T, ctx context.Context, st *store.Store, h *reactiveHandler, want endState, claims []claim) {
+	t.Helper()
+	lines := make([]string, 0, len(claims))
+	for _, c := range claims {
+		lines = append(lines, "    "+c.String())
+	}
+	trace := "\n  who claimed what:\n" + strings.Join(lines, "\n")
+
+	reminders, err := st.DueReminders(ctx, h.now().Add(14*24*time.Hour))
+	if err != nil {
+		t.Fatalf("DueReminders: %v", err)
+	}
+	if len(reminders) != len(want.reminders) {
+		t.Fatalf("end state: %d reminder(s), want %d: %+v%s", len(reminders), len(want.reminders), reminders, trace)
+	}
+	// No trace may leave a reminder at the current clock, whatever else it
+	// asserts (V-577, V-579). Twice on the box a sentence naming a day and no
+	// hour was completed from time.Now(): "что у меня сегодня?" became 01:28 and
+	// "на завтра" became 01:38. Neither minute was ever spoken, and a row that
+	// only checked the payload would have passed both.
+	for _, r := range reminders {
+		if r.FireTs.In(h.now().Location()).Format("15:04") == h.now().Format("15:04") {
+			t.Fatalf("end state: reminder %q fires at %s, which is the clock — a time slot naming no hour is asked about, never filled from now()%s",
+				r.Payload, r.FireTs.Format("15:04"), trace)
+		}
+	}
+	for i, w := range want.reminders {
+		if !strings.Contains(reminders[i].Payload, w.payload) {
+			t.Fatalf("end state: reminder %d payload %q does not carry %q%s", i, reminders[i].Payload, w.payload, trace)
+		}
+		if w.fireAt != "" {
+			if got := reminders[i].FireTs.UTC().Format("2006-01-02 15:04"); got != w.fireAt {
+				t.Fatalf("end state: reminder %d fires at %s, want %s%s", i, got, w.fireAt, trace)
+			}
+		}
+	}
+
+	facts, err := st.RecentFacts(ctx, 20)
+	if err != nil {
+		t.Fatalf("RecentFacts: %v", err)
+	}
+	if len(facts) != len(want.factKeys) {
+		t.Fatalf("end state: %d fact(s), want %d: %+v%s", len(facts), len(want.factKeys), facts, trace)
+	}
+	for i, key := range want.factKeys {
+		if facts[i].Key != key {
+			t.Fatalf("end state: fact %d is %q, want %q%s", i, facts[i].Key, key, trace)
+		}
+	}
+
+	notes, err := st.RecentNotes(ctx, 20)
+	if err != nil {
+		t.Fatalf("RecentNotes: %v", err)
+	}
+	if len(notes) != want.notes {
+		t.Fatalf("end state: %d note(s), want %d%s", len(notes), want.notes, trace)
+	}
+
+	tasks, err := st.ListTasks(ctx, store.TaskOpen)
+	if err != nil {
+		t.Fatalf("ListTasks: %v", err)
+	}
+	if len(tasks) != len(want.tasks) {
+		t.Fatalf("end state: %d open task(s), want %d: %+v%s", len(tasks), len(want.tasks), tasks, trace)
+	}
+	for i, text := range want.tasks {
+		if !strings.Contains(tasks[i].Text, text) {
+			t.Fatalf("end state: task %d is %q, want it to carry %q%s", i, tasks[i].Text, text, trace)
+		}
+	}
+}
+
+func TestDialogueTraces(t *testing.T) {
+	for _, tr := range dialogueTraces() {
+		tr := tr
+		t.Run(tr.name, func(t *testing.T) { runTrace(t, tr) })
+	}
+}
+
+// dialogueTraces — the fixture. Order is the order the shapes were found, not a
+// dependency: each trace builds its own handler and store.
+func dialogueTraces() []trace {
+	return []trace{
+		// The plain two-turn shape, and the one every other row is a deviation
+		// from: she asks for the time, he gives it, the reminder lands with the
+		// subject he said in the FIRST turn.
+		{
+			// Three turns since V-579, not two. An hour with no day named is
+			// not an answer she can act on: 11:00 today has passed as often as
+			// not, and picking one for him is the invention the whole rule is
+			// against. So she says the clock she is reasoning from and asks
+			// which day.
+			name: "reminder completed over three turns",
+			turns: []turn{
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "маме"}},
+				{say: "в 11:00", question: dialogue.SlotTime, attempt: 2, gap: whenNoDay, took: "в 11:00",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 2, carries: "маме"}},
+				{say: "сегодня", contains: []string{"11:00"}, notContain: []string{"?"}},
+			},
+			end: endState{reminders: []reminderWant{{payload: "позвонить маме", fireAt: "2026-07-31 11:00"}}},
+		},
+		// The same shape on the fact path, where the answer carries both halves
+		// of what was missing — the key and the value — in one breath.
+		{
+			name: "fact completed over two turns",
+			turns: []turn{
+				{say: "запиши", question: dialogue.SlotKey, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotKey, attempt: 1}},
+				// His words back, not the key the parser filed them under
+				// (V-592). "water" is machine vocabulary and he never said it.
+				{say: "пил воду", contains: []string{"пил воду"}},
+			},
+			end: endState{factKeys: []string{"water"}},
+		},
+		// An answer past the TTL is a new request, not an answer (V-385). She
+		// says the old one is gone and routes the words fresh. A bare time on
+		// its own carries no request, so the fresh routing lands on the canned
+		// reply — the point of the row is that NOTHING is created: a reminder
+		// here would fire with the subject of a request she had already let go.
+		{
+			name: "answer arrives after the TTL",
+			turns: []turn{
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+				{say: "в 11:00", wait: clarifyTTL + time.Second, expired: true},
+			},
+			end: endState{},
+		},
+		// Three questions is the budget, and running out is SPOKEN: a mute
+		// give-up reads as "done" and he would wait for a reminder that was
+		// never set. The wording changes with the attempt (V-457).
+		{
+			name: "three unclear answers then the give-up line",
+			turns: []turn{
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+				{say: "ну не знаю", question: dialogue.SlotTime, attempt: 2,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 2}},
+				{say: "ну не знаю", question: dialogue.SlotTime, attempt: 3,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 3}},
+				{say: "ну не знаю", contains: []string{clarifyGaveUp}, noQuestion: true},
+			},
+			end: endState{},
+		},
+		// A correction points at the previous ACTED turn (repair.go): she redoes
+		// it under the intent he names and says so out loud, because a
+		// correction he cannot see is indistinguishable from one that was
+		// dropped. The task she filed first stays filed — repair redoes, it does
+		// not retract, and V-455 decided that deliberately.
+		//
+		// The corrected-to intent has to differ from the one she used, or repair
+		// declines: teaching the classifier the label it already produced is
+		// worse than doing nothing.
+		{
+			name: "correction of the previous turn",
+			turns: []turn{
+				{say: "добавь в задачи купить молоко", contains: []string{"купить молоко"}},
+				{say: "нет, это был вопрос", contains: []string{"поняла, это вопрос"}},
+			},
+			end: endState{tasks: []string{"купить молоко"}},
+		},
+		// He walks away from his own request: a question is parked, the next
+		// utterance is an unrelated request of its own, and nothing follows.
+		// V-554's fix is what makes this row pass — the question steps aside
+		// rather than scoring "добавь в задачи" as the time. The reminder is
+		// dropped in silence and that is the decision: if he meant it he says it
+		// again, and a question left armed eats the turn after next.
+		{
+			name: "abandoned flow: parked, then an unrelated request",
+			turns: []turn{
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+				{say: "добавь в задачи купить молоко", contains: []string{"купить молоко"}},
+				{say: "спасибо"},
+			},
+			end: endState{tasks: []string{"купить молоко"}},
+		},
+
+		// V-577 shape 1, the worst of the nine claimants measured on 2026-08-06.
+		// Every token of "что у меня сегодня?" is frame — an interrogative, a
+		// preposition, a particle and a day word — so the role classifier never
+		// looked at the route, the parked reminder read "сегодня" as its time,
+		// and the hour came from the clock. He got a reminder he never asked for
+		// at a minute he never said, and his question was answered nowhere.
+		//
+		// Two claims: the calendar answers, and nothing is written. The flow
+		// survives underneath, because a question of his own is not a request to
+		// abandon the one he was making.
+		{
+			name: "an agenda question mid-flow is answered, not eaten",
+			turns: []turn{
+				{say: "напомни забрать посылку", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "посылку"}},
+				{say: "что у меня сегодня?", contains: []string{"31.07.2026"},
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "посылку"}},
+			},
+			end: endState{},
+		},
+		// V-577 shape 2. He states something in the middle of the flow. It is
+		// neither a slot value nor a cancel, and it was scored as a failed
+		// answer and dropped in silence: alone the same sentence is stored.
+		// Silence is the one option that is wrong, so it is stored, no retry is
+		// spent, and the question comes back on the end of the same reply.
+		//
+		// The words are a fact and not the owner's note, because the fact parser
+		// is deterministic and the offline floor marks every classifier route
+		// Clarify. The row below carries his own sentence and needs the model.
+		//
+		// What this floor can prove is the arbitration: no retry is spent, the
+		// flow survives on the same attempt, and the words are answered as
+		// themselves with the question coming back after them. Whether the fact
+		// is then WRITTEN is the routing engine's business — the hash embedder
+		// is unsure of every sentence it sees, and an unsure fact has never been
+		// stored.
+		{
+			name: "a fact stated mid-flow steps aside without spending a retry",
+			turns: []turn{
+				{say: "напомни позвонить врачу", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "врачу"}},
+				// Nothing she says about it may be a word he did not say
+				// (V-592). On the box this sentence came back as "Проверила, что
+				// ты выпел стакан воды": a non-word for the verb, a glass copied
+				// out of the example in ReplySystemPrompt, and a claim to have
+				// checked something. The store held key=water value="drank"
+				// throughout, so all of it was generated from two tokens.
+				//
+				// The positive half of the contract — the confirmation IS his
+				// sentence — is asserted by "fact completed over two turns"
+				// above. It cannot be asserted here: the hash embedder marks
+				// this route Clarify, and an unsure fact is answered with the
+				// canned line rather than a confirmation of anything.
+				{say: "я выпил воды", contains: []string{"напоминание?"},
+					notContain: []string{"стакан", "выпел", "Проверила", "water"},
+					parked:     &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "врачу"}},
+			},
+			end: endState{},
+		},
+		// V-593: two asks about the same half of the day, with a turn between
+		// them that answered the DAY. Asking again is right and asking in the
+		// same bytes is not — from his side it is indistinguishable from not
+		// having been heard, which is what the whole V-558 family is about.
+		//
+		// The clock still opens every ask (the owner's rule, V-579); the
+		// acknowledgement goes after it and before the question.
+		{
+			name: "a re-ask names what the answer before it gave her",
+			turns: []turn{
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+				{say: "на 9", question: dialogue.SlotTime, attempt: 2, gap: whenAmbiguousHour, took: "на 9",
+					contains: []string{"Сейчас "},
+					parked:   &parkedWant{slot: dialogue.SlotTime, attempt: 2}},
+				{say: "на завтра", question: dialogue.SlotTime, attempt: 3, gap: whenAmbiguousHour, took: "на завтра",
+					contains: []string{"Сейчас ", "завтра"}, differs: true,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 3}},
+			},
+			end: endState{},
+		},
+		// V-579 turn 3: the preposition decided whether the hour was read. "в 9"
+		// set the reminder and "на 9" was not read at all, on the same build and
+		// with the same cardinal.
+		{
+			// It is read, and being read is not the same as being enough: nine is
+			// either half of the day, so she asks which and then which day
+			// (V-579). Both answers are frame words and neither carries an hour
+			// of its own, so this row is also the proof that an answer is read
+			// against the whole request rather than alone.
+			name: "на 9 answers the time question like в 9",
+			turns: []turn{
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+				{say: "на 9", question: dialogue.SlotTime, attempt: 2, gap: whenAmbiguousHour, took: "на 9",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 2}},
+				{say: "утра", question: dialogue.SlotTime, attempt: 3, gap: whenNoDay, took: "утра",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 3}},
+				{say: "завтра", contains: []string{"09:00"}},
+			},
+			end: endState{reminders: []reminderWant{{payload: "позвонить маме", fireAt: "2026-08-01 09:00"}}},
+		},
+		// The owner's own four, ruled 2026-08-06 (V-579). A reminder commits
+		// when what, what time and what day are all answered, and every ask
+		// states the clock she is reasoning from.
+		{
+			name: "his first example: a bare 3 is asked about",
+			turns: []turn{
+				{say: "напомни завтра в 3 заказать цветы",
+					question: dialogue.SlotTime, attempt: 1, gap: whenAmbiguousHour,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "цветы"}},
+			},
+			end: endState{},
+		},
+		{
+			// The hour is unambiguous and the day is still missing, so she asks.
+			// Today being a valid reading is not the same as him saying it.
+			name: "his second example: nine in the evening of which day",
+			turns: []turn{
+				{say: "напомни в 9 вечера разгрузить стиралку",
+					question: dialogue.SlotTime, attempt: 1, gap: whenNoDay,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "стиралку"}},
+				{say: "завтра", contains: []string{"21:00"}},
+			},
+			end: endState{reminders: []reminderWant{{payload: "стиралку", fireAt: "2026-08-01 21:00"}}},
+		},
+		{
+			// All three answered in one breath, so she does not ask at all.
+			name: "his third example: a full time commits",
+			turns: []turn{
+				{say: "напомни завтра в 15:00 заказать цветы", notContain: []string{"?"}},
+			},
+			end: endState{reminders: []reminderWant{{payload: "цветы", fireAt: "2026-08-01 15:00"}}},
+		},
+		{
+			// An interval is one instant, so it answers the hour and the day
+			// together. Confirmed by the owner: "через час is fine as is".
+			name: "an interval commits without a question",
+			turns: []turn{
+				{say: "напомни через час позвонить маме", notContain: []string{"?"}},
+			},
+			end: endState{reminders: []reminderWant{{payload: "маме", fireAt: "2026-07-31 10:17"}}},
+		},
+		// V-579 turn 4: he named a day and no hour, and got the day at the
+		// current minute. She has to ask instead, and the global check in
+		// checkEnd refuses the invented minute for every row at once.
+		{
+			name: "a day with no hour is asked about, not taken from the clock",
+			turns: []turn{
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+				{say: "на завтра", question: dialogue.SlotTime, attempt: 2,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 2}},
+			},
+			end: endState{},
+		},
+
+		// ---- rows below carry the CORRECT expectation and fail today ----
+
+		// The owner's own sentence from V-577 shape 2, in his words. It needs
+		// an engine that can route it: the hash embedder marks it note with
+		// Clarify set, and a route she is not sure of is not evidence that he
+		// stated anything. The row above is the same contract in words the
+		// floor's deterministic fact parser reads.
+		{
+			name: "a note stated mid-flow is stored, not dropped",
+			skip: "the offline floor cannot route «у меня новый ноутбук» confidently; needs the resident model",
+			turns: []turn{
+				{say: "напомни позвонить врачу", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "врачу"}},
+				{say: "у меня новый ноутбук",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "врачу"}},
+			},
+			end: endState{notes: 1},
+		},
+
+		// The owner's target transcript, V-561. He asks for a reminder, she asks
+		// when, he asks something else entirely, and then comes back to her
+		// question. On the box this created a reminder at 00:12 and never
+		// answered Rome; on the offline floor the side question is recognised as
+		// its own request and the flow is dropped instead, so the wrong reminder
+		// is not made and the right one is not either.
+		//
+		// Both are the same defect: there is no suspend and resume. The correct
+		// shape is the middle turn answered on its own and the parked question
+		// still standing, on the same attempt — a side query is not a failed
+		// answer and must not spend a retry.
+		//
+		// The skip came off with V-579. What held it was the parser, not the
+		// arbitration: neither the stub nor the production one read "на 9",
+		// because only "в" framed a spoken hour, and "на завтра" was completed
+		// from the clock.
+		//
+		// Turn 3 now closes the flow, where the transcript has one more exchange
+		// in it. That is the 12-hour question — the owner's turn 4 answers "на
+		// 9" with "сейчас 15:23, на 9 сегодня вечером?" — and it is a decision of
+		// its own, not one to invent here. Nine o'clock is read as nine and, at
+		// 09:17, as tomorrow's, which is where the transcript ends up anyway.
+		// Turn 4 then has nothing to answer and must not write anything.
+		{
+			name: "the owner's transcript from V-561",
+			turns: []turn{
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+				{say: "какая сейчас погода в Риме?",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "маме"}},
+				// His words, unchanged. What changed under V-579 is that "на 9"
+				// is a question and not a commit: nine could be either half of
+				// the day, so she says the clock she is reading from and asks.
+				// "на завтра." then answers the day and leaves the half open, so
+				// she asks that one again.
+				// Each ask names what the turn before it gave her (V-593). The
+				// two asks about the half of the day are the same question and
+				// must not be the same sentence: he answered between them, and a
+				// reply with no trace of that reads as not having been heard.
+				{say: "а, да, прости - на 9.", question: dialogue.SlotTime, attempt: 2, gap: whenAmbiguousHour, took: "а, да, прости - на 9.",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 2}},
+				{say: "на завтра.", question: dialogue.SlotTime, attempt: 3, gap: whenAmbiguousHour, took: "на завтра.",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 3}},
+			},
+			end: endState{},
+		},
+		// The same shape said in words StubDateTimeParser reads. GREEN since
+		// V-561. Same three claims: Rome is answered, the question survives the
+		// side query on the same attempt, and the answer after it completes the
+		// reminder he actually asked for.
+		//
+		// It sits under the "fail today" header because the row above it still
+		// does. Do not re-skip it to tidy that up: this is the owner's
+		// acceptance test in the only words the offline floor can read.
+		{
+			name: "nested question: a parked question, then one of his own",
+			turns: []turn{
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+				{say: "какая сейчас погода в Риме?",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "маме"}},
+				{say: "в 11:00", question: dialogue.SlotTime, attempt: 2, gap: whenNoDay, took: "в 11:00",
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 2, carries: "маме"}},
+				{say: "сегодня", contains: []string{"11:00"}},
+			},
+			end: endState{reminders: []reminderWant{{payload: "позвонить маме", fireAt: "2026-07-31 11:00"}}},
+		},
+		// A cancel is one of the five turn roles V-560 names, and today it is
+		// none of them: "неважно" fills no slot and carries no request of its
+		// own, so it reads as a failed answer and spends a retry. Two turns
+		// later she is still asking about a reminder he called off.
+		//
+		// The row asserts what is knowable — nothing armed, nothing written, and
+		// not another question — rather than her wording for it, which is not
+		// written yet and is not this task's to invent.
+		{
+			name: "cancel: a parked question, then never mind",
+			skip: "V-560: a cancel is scored as a failed answer, not as a cancel",
+			turns: []turn{
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+				{say: "неважно", noQuestion: true},
+			},
+			end: endState{},
+		},
+		// Order in runTurn is the whole arbitration (V-558), and this is what it
+		// costs: the clarify answer is checked at step 3 and the repair marker at
+		// step 4d, so while a question is parked no correction can be made. She
+		// scores "нет, это была заметка" as a bad time answer and asks again.
+		{
+			name: "correction while a question is parked",
+			skip: "V-560: clarify pre-empts the repair marker, so a correction cannot be spoken mid-flow",
+			turns: []turn{
+				{say: "добавь в задачи купить молоко", contains: []string{"купить молоко"}},
+				{say: "напомни позвонить маме", question: dialogue.SlotTime, attempt: 1,
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+				{say: "нет, это был вопрос", contains: []string{"поняла, это вопрос"},
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1, carries: "маме"}},
+			},
+			end: endState{tasks: []string{"купить молоко"}},
+		},
+		// A reminder said whole, in one breath, with the hour in it — and she
+		// asks when. ReminderGrammar (stage0.go) builds its slots by hand and
+		// never runs the extractor, so a stage-0 reminder carries no time
+		// whatever the sentence says, and the clarify gate reads the gap as
+		// real. It costs a turn on the commonest reminder shape there is.
+		//
+		// Hermetic despite the date parser: stage 0 calls no parser at all, so
+		// this fails the same way with or without python dateparser installed.
+		{
+			name: "a reminder said whole is not asked about",
+			skip: "V-562: a stage-0 decision never meets the extractor, so its slots are never validated",
+			turns: []turn{
+				{say: "напомни в 11:00 позвонить маме", contains: []string{"11:00"}, noQuestion: true},
+			},
+			end: endState{reminders: []reminderWant{{payload: "позвонить маме", fireAt: "2026-07-31 11:00"}}},
+		},
+		// The same gap on the repair path. A correction redoes the request
+		// through finishClarified, which goes straight to applyAction — it never
+		// passes the clarify gate — so a redo that lands short answers with the
+		// parse error V-557 removed from the routing path: "не поняла, на когда
+		// напомнить." She should ask, exactly as she does for a fresh reminder
+		// with no time.
+		{
+			name: "a correction that lands short asks rather than failing",
+			skip: "V-562: finishClarified skips the clarify gate, so a repaired decision is never checked for gaps",
+			turns: []turn{
+				{say: "добавь в задачи купить молоко", contains: []string{"купить молоко"}},
+				{say: "нет, это было напоминание", contains: []string{"поняла, это напоминание"},
+					parked: &parkedWant{slot: dialogue.SlotTime, attempt: 1}},
+			},
+			end: endState{tasks: []string{"купить молоко"}},
+		},
+	}
+}

cmd/mavend/ecosystem.go

@@ -12,6 +12,7 @@ import (
 	"log"
 	"net/http"
 	"net/url"
+	"strings"
 	"time"
 
 	hexisclient "github.com/kami/hexis/pkg/client"
@@ -42,28 +43,100 @@ const ecosystemAPIVersion = "v1"
 // anonymous HTTP client.
 const mavenRequester = "maven"
 
-// setEcosystemHeaders stamps the version, requester, auth and correlation
-// headers common to every outgoing ecosystem request. token may be empty,
-// which means the transport itself is trusted (loopback or unix socket).
+// ecosystemHTTP is the JSON transport every ecosystem client shares: one base
+// URL, one bearer token, and the header set the contract requires on each
+// request. Nexus and Praxis differ only in the service name and the version
+// header, so both embed this rather than repeating build, send and classify.
+type ecosystemHTTP struct {
+	service       string // "nexus", "praxis" — the name errors and traces carry
+	versionHeader string
+	baseURL       string
+	token         string
+	httpClient    *http.Client
+}
+
+func newEcosystemHTTP(service, versionHeader, baseURL string) ecosystemHTTP {
+	return ecosystemHTTP{
+		service:       service,
+		versionHeader: versionHeader,
+		baseURL:       baseURL,
+		httpClient:    &http.Client{Timeout: 10 * time.Second},
+	}
+}
+
+// setHeaders stamps the version, requester, auth and correlation headers common
+// to every outgoing ecosystem request. The token may be empty, which means the
+// transport itself is trusted (loopback or unix socket).
 //
-// The correlation ID is read from the context and never minted here. Minting
-// one per request sent the far side an ID that existed nowhere on this side,
-// and gave a single multi-hop action as many unrelated IDs as it made calls.
-// Callers that start an action assign the ID once (handleHexisAct,
+// The correlation ID is read from the request's own context and never minted
+// here. Minting one per request sent the far side an ID that existed nowhere on
+// this side, and gave a single multi-hop action as many unrelated IDs as it
+// made calls. Callers that start an action assign the ID once (handleHexisAct,
 // handlePraxisAct, resolveEntityReference) and every hop inherits it.
-func setEcosystemHeaders(req *http.Request, ctx context.Context, versionHeader, token string) {
+func (t *ecosystemHTTP) setHeaders(req *http.Request) {
 	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set(versionHeader, ecosystemAPIVersion)
+	req.Header.Set(t.versionHeader, ecosystemAPIVersion)
 	req.Header.Set("Accept", "application/json")
 	req.Header.Set("X-Requested-By", mavenRequester)
-	if token != "" {
-		req.Header.Set("Authorization", "Bearer "+token)
+	if t.token != "" {
+		req.Header.Set("Authorization", "Bearer "+t.token)
 	}
-	if id := correlationIDFromCtx(ctx); id != "" {
+	if id := correlationIDFromCtx(req.Context()); id != "" {
 		req.Header.Set("X-Correlation-ID", id)
 	}
 }
 
+// call sends one request and decodes the JSON answer into out, which may be nil
+// when the body carries nothing worth reading. op is the logical operation name
+// for errors and traces: the path carries the query string, and after entity
+// scoping that means an entity id in every log line built from the error, next
+// to a trace that redacts far less than that.
+//
+// Every failure is an *ecosystemError, including the transport and decode ones.
+// Some of these paths mutate remote state, and the question worth answering
+// afterwards is whether the call never left or was refused.
+func (t *ecosystemHTTP) call(ctx context.Context, method, op, path string, payload, out any) error {
+	var body io.Reader
+	if payload != nil {
+		data, err := json.Marshal(payload)
+		if err != nil {
+			return &ecosystemError{Service: t.service, Op: op, Err: err}
+		}
+		body = bytes.NewReader(data)
+	}
+	req, err := http.NewRequestWithContext(ctx, method, t.baseURL+path, body)
+	if err != nil {
+		return &ecosystemError{Service: t.service, Op: op, Err: err}
+	}
+	t.setHeaders(req)
+
+	resp, err := t.httpClient.Do(req)
+	if err != nil {
+		return &ecosystemError{Service: t.service, Op: op, Err: err}
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != 200 {
+		return httpError(t.service, op, resp.StatusCode)
+	}
+	if out == nil {
+		return nil
+	}
+	if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
+		return &ecosystemError{Service: t.service, Op: op, Status: resp.StatusCode, Err: err}
+	}
+	return nil
+}
+
+// getJSON performs a GET and decodes the JSON body into out.
+func (t *ecosystemHTTP) getJSON(ctx context.Context, op, path string, out any) error {
+	return t.call(ctx, http.MethodGet, op, path, nil, out)
+}
+
+// postJSON posts a JSON payload and decodes the JSON answer into out.
+func (t *ecosystemHTTP) postJSON(ctx context.Context, op, path string, payload, out any) error {
+	return t.call(ctx, http.MethodPost, op, path, payload, out)
+}
+
 // ecosystemError is the typed failure every ecosystem client returns, so
 // callers can tell a transport failure from a refusal from a contract
 // mismatch without matching on message text. The distinction matters:
@@ -107,17 +180,60 @@ func httpError(service, op string, status int) *ecosystemError {
 	}
 }
 
+// hexisStatusTexts maps the http.StatusText spelling back to its code, for the
+// failure statuses a Hexis call can plausibly answer with. It is the inverse of
+// what the vendored client threw away.
+var hexisStatusTexts = func() map[string]int {
+	codes := []int{
+		http.StatusBadRequest, http.StatusUnauthorized, http.StatusForbidden,
+		http.StatusNotFound, http.StatusMethodNotAllowed, http.StatusNotAcceptable,
+		http.StatusRequestTimeout, http.StatusConflict, http.StatusGone,
+		http.StatusUnprocessableEntity, http.StatusUpgradeRequired,
+		http.StatusTooManyRequests, http.StatusInternalServerError,
+		http.StatusNotImplemented, http.StatusBadGateway,
+		http.StatusServiceUnavailable, http.StatusGatewayTimeout,
+	}
+	m := make(map[string]int, len(codes))
+	for _, c := range codes {
+		m[http.StatusText(c)] = c
+	}
+	return m
+}()
+
+// hexisError re-wraps an error from the vendored Hexis client as an
+// *ecosystemError, so a Hexis failure classifies the same way a Nexus or Praxis
+// one does and ecosystemGap can tell a refused credential from an outage.
+//
+// This is a boundary adapter and it is not the fix anyone would choose. The
+// Hexis client lives in another repository and returns
+// fmt.Errorf("%s: %s", http.StatusText(status), body) for every status at or
+// above 400, so the status text is the only signal that survives — the correct
+// fix is a typed error carrying the code, and Maven cannot land it unilaterally
+// (Vikunja #587, docs/plans/20-two-artifacts-and-neither-is-spring.md). Parsing
+// here is bounded: the message's first colon-delimited segment is the status
+// text verbatim, no status text contains a colon, and anything unrecognised —
+// "do request: ...", "create request: ..." — is a transport failure and is left
+// at status 0, which is exactly what Unreachable() means.
+func hexisError(op string, err error) error {
+	if err == nil {
+		return nil
+	}
+	var ee *ecosystemError
+	if errors.As(err, &ee) {
+		return err
+	}
+	head, _, _ := strings.Cut(err.Error(), ": ")
+	return &ecosystemError{
+		Service: "hexis", Op: op, Status: hexisStatusTexts[head], Err: err,
+	}
+}
+
 type nexusClient struct {
-	baseURL    string
-	token      string
-	httpClient *http.Client
+	ecosystemHTTP
 }
 
 func newNexusClient(url string) *nexusClient {
-	return &nexusClient{
-		baseURL:    url,
-		httpClient: &http.Client{Timeout: 10 * time.Second},
-	}
+	return &nexusClient{newEcosystemHTTP("nexus", "X-Nexus-Version", url)}
 }
 
 // withToken sets the bearer token sent on every request. Returns the client so
@@ -176,62 +292,26 @@ func (c *nexusClient) Resolve(ctx context.Context, query string, types []string)
 		body["types"] = types
 	}
 
-	data, _ := json.Marshal(body)
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/api/v1/resolve", bytes.NewReader(data))
-	if err != nil {
-		return nil, fmt.Errorf("create request: %w", err)
-	}
-	setEcosystemHeaders(req, ctx, "X-Nexus-Version", c.token)
-
-	resp, err := c.httpClient.Do(req)
-	if err != nil {
-		return nil, &ecosystemError{Service: "nexus", Op: "resolve", Err: err}
-	}
-	defer resp.Body.Close()
-
-	bodyBytes, _ := io.ReadAll(resp.Body)
-	if resp.StatusCode != 200 {
-		return nil, httpError("nexus", "resolve", resp.StatusCode)
-	}
-
 	var result nexusResolveResult
-	if err := json.Unmarshal(bodyBytes, &result); err != nil {
-		return nil, &ecosystemError{Service: "nexus", Op: "resolve", Status: resp.StatusCode, Err: err}
+	if err := c.postJSON(ctx, "resolve", "/api/v1/resolve", body, &result); err != nil {
+		return nil, err
 	}
 	return &result, nil
 }
 
 func (c *nexusClient) Health(ctx context.Context) error {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+"/health", nil)
-	if err != nil {
-		return &ecosystemError{Service: "nexus", Op: "health", Err: err}
-	}
-	setEcosystemHeaders(req, ctx, "X-Nexus-Version", c.token)
-	resp, err := c.httpClient.Do(req)
-	if err != nil {
-		return &ecosystemError{Service: "nexus", Op: "health", Err: err}
-	}
-	resp.Body.Close()
-	if resp.StatusCode != 200 {
-		return httpError("nexus", "health", resp.StatusCode)
-	}
-	return nil
+	return c.getJSON(ctx, "health", "/health", nil)
 }
 
 // praxisClient talks to the Praxis HTTP tools API. Maven must not open Praxis's
 // SQLite store directly (ecosystem invariant: no component reads another's DB),
 // so attention/changes/lifecycle all go over this HTTP contract against praxisd.
 type praxisClient struct {
-	baseURL    string
-	token      string
-	httpClient *http.Client
+	ecosystemHTTP
 }
 
 func newPraxisClient(url string) *praxisClient {
-	return &praxisClient{
-		baseURL:    url,
-		httpClient: &http.Client{Timeout: 10 * time.Second},
-	}
+	return &praxisClient{newEcosystemHTTP("praxis", "X-Praxis-Version", url)}
 }
 
 func (c *praxisClient) withToken(token string) *praxisClient {
@@ -239,30 +319,6 @@ func (c *praxisClient) withToken(token string) *praxisClient {
 	return c
 }
 
-// getJSON performs a GET and decodes the JSON body into out. op is the logical
-// operation name for errors and traces: the path carries the query string, and
-// after entity scoping that means an entity id in every log line built from the
-// error, next to a trace that redacts far less than that.
-func (c *praxisClient) getJSON(ctx context.Context, op, path string, out any) error {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+path, nil)
-	if err != nil {
-		return err
-	}
-	setEcosystemHeaders(req, ctx, "X-Praxis-Version", c.token)
-	resp, err := c.httpClient.Do(req)
-	if err != nil {
-		return &ecosystemError{Service: "praxis", Op: op, Err: err}
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != 200 {
-		return httpError("praxis", op, resp.StatusCode)
-	}
-	if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
-		return &ecosystemError{Service: "praxis", Op: op, Status: resp.StatusCode, Err: err}
-	}
-	return nil
-}
-
 // praxisAttention — an attention response in either of the two shapes Praxis
 // may send (Vikunja #540).
 //
@@ -376,31 +432,14 @@ type praxisItem struct {
 // postItemAction posts {"item_id": id} to a Praxis tools lifecycle endpoint
 // and decodes the resulting item. Shared by Surface/Acknowledge/Resolve/Ignore.
 func (c *praxisClient) postItemAction(ctx context.Context, op, path, itemID string) (*praxisItem, error) {
-	return c.postJSON(ctx, op, path, map[string]any{"item_id": itemID})
+	return c.postItem(ctx, op, path, map[string]any{"item_id": itemID})
 }
 
-// postJSON posts a body to a Praxis lifecycle endpoint and decodes the item.
-// Every failure is a *ecosystemError, including the transport and decode ones:
-// these are the paths that mutate remote state, and the question worth
-// answering afterwards is whether the call never left or was refused.
-func (c *praxisClient) postJSON(ctx context.Context, op, path string, payload map[string]any) (*praxisItem, error) {
-	body, _ := json.Marshal(payload)
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+path, bytes.NewReader(body))
-	if err != nil {
-		return nil, &ecosystemError{Service: "praxis", Op: op, Err: err}
-	}
-	setEcosystemHeaders(req, ctx, "X-Praxis-Version", c.token)
-	resp, err := c.httpClient.Do(req)
-	if err != nil {
-		return nil, &ecosystemError{Service: "praxis", Op: op, Err: err}
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != 200 {
-		return nil, httpError("praxis", op, resp.StatusCode)
-	}
+// postItem posts a body to a Praxis lifecycle endpoint and decodes the item.
+func (c *praxisClient) postItem(ctx context.Context, op, path string, payload map[string]any) (*praxisItem, error) {
 	var out praxisItem
-	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
-		return nil, &ecosystemError{Service: "praxis", Op: op, Status: resp.StatusCode, Err: err}
+	if err := c.postJSON(ctx, op, path, payload, &out); err != nil {
+		return nil, err
 	}
 	return &out, nil
 }
@@ -425,7 +464,7 @@ func (c *praxisClient) Ignore(ctx context.Context, itemID string) (*praxisItem,
 }
 
 func (c *praxisClient) Pin(ctx context.Context, itemID string, pinned bool) (*praxisItem, error) {
-	return c.postJSON(ctx, "pin", "/api/v1/tools/pin", map[string]any{"item_id": itemID, "pinned": pinned})
+	return c.postItem(ctx, "pin", "/api/v1/tools/pin", map[string]any{"item_id": itemID, "pinned": pinned})
 }
 
 func (c *praxisClient) GetItem(ctx context.Context, itemID string) (*praxisItem, error) {
@@ -540,6 +579,7 @@ func (w *ecosystemWiring) discoverCapabilities(ctx context.Context, entityID str
 	}
 	caps, err := w.hexis.Capabilities(ctx, entityID)
 	if err != nil {
+		err = hexisError("capabilities", err)
 		log.Printf("ecosystem: hexis capabilities error: %v", err)
 		return nil, err
 	}
@@ -567,7 +607,10 @@ func (w *ecosystemWiring) executeCapability(ctx context.Context, capabilityID, t
 
 	exec, err := w.hexis.Execute(ctx, req)
 	if err != nil {
-		return correlationID, fmt.Errorf("execute: %w", err)
+		// A classified dependency failure. The two returns below are NOT: an
+		// execution that ran and failed is the command failing, not Hexis
+		// degrading, and it keeps its plain error so the caller says so.
+		return correlationID, hexisError("execute", err)
 	}
 	if exec.Status == "succeeded" {
 		return correlationID, nil

cmd/mavend/ecosystem_acts.go

@@ -22,13 +22,25 @@ import (
 // already knows which one it was talking to — it records the same name in the
 // trace (Vikunja #521).
 const (
-	serviceNexus = "Nexus"
-	serviceHexis = "Hexis"
+	serviceNexus  = "Nexus"
+	servicePraxis = "Praxis"
+	serviceHexis  = "Hexis"
 )
 
 // serviceVars — the one-key map the eco_down and eco_denied lines take.
 func serviceVars(name string) map[string]string { return map[string]string{"name": name} }
 
+// ecosystemGap names the service that failed. A rejected credential gets its
+// own line, because a wrong token looks exactly like an outage to him and
+// "try again" is advice that will never work. Every degrade path reads through
+// here, so all of them name the service and none of them guesses instead.
+func ecosystemGap(service string, err error) string {
+	if unauthorizedEcosystemError(err) {
+		return phraser.A(phraser.EcoDenied, serviceVars(service))
+	}
+	return phraser.A(phraser.EcoDown, serviceVars(service))
+}
+
 // praxisCapability is one arm of the Praxis act dispatch. This is an interface
 // rather than a map[string]func because each arm carries its own state: the
 // verb aliases it answers to, the trace name it records, and its own reply
@@ -130,7 +142,13 @@ type praxisItemAction struct {
 	verbs   []string
 	ask     string // reply when no item id was given
 	op      string // trace + log name of the operation
-	failure string // reply when the Praxis call errors
+	// failure is the first half of the reply when the Praxis call errors: which
+	// operation did not happen. ecosystemGap supplies the second half, which
+	// names Praxis and splits a refused token from an outage — those two used to
+	// produce the identical sentence and neither said "Praxis" (Vikunja #588).
+	// The verb is kept alongside the service name because the trace is the only
+	// other place it exists, and he is not reading the trace.
+	failure string
 	success string
 	call    func(ctx context.Context, px *praxisClient, id string) error
 }
@@ -147,7 +165,7 @@ func (a praxisItemAction) handle(ctx context.Context, h *reactiveHandler, px *pr
 		log.Printf("ecosystem: praxis %s %s: %v", a.op, id, err)
 		h.recordEcosystemTrace(ctx, "praxis", a.op, traceStatusForError(err), started,
 			mergeFields(traceErrorFields(err), map[string]any{"item_id": id}))
-		return a.failure
+		return a.failure + " " + ecosystemGap(servicePraxis, err)
 	}
 	h.recordPraxisTrace(ctx, a.op, started, map[string]any{"item_id": id})
 	return a.success
@@ -199,16 +217,10 @@ func (listAttentionCapability) handle(ctx context.Context, h *reactiveHandler, p
 		}
 		parts = append(parts, s)
 
-		// Speaking an item surfaces it, it does not acknowledge it
-		// (ECOSYSTEM-SPEC.md §2.3: surfaced != acknowledged). Best-effort:
-		// a failed surface call must not block delivering the digest.
-		if id, ok := item["id"].(string); ok && id != "" {
-			// Recorded in the order she says them, and only for items she could
-			// say: an item skipped above has no position in what he heard (#516).
+		// Recorded in the order she says them, and only for items she could
+		// say: an item skipped above has no position in what he heard (#516).
+		if id := surfaceSpoken(ctx, px, item); id != "" {
 			spoken = append(spoken, id)
-			if _, err := px.Surface(ctx, id); err != nil {
-				log.Printf("ecosystem: praxis surface %s: %v", id, err)
-			}
 		}
 	}
 	h.rememberSurfaced(spoken)
@@ -298,12 +310,7 @@ func (entityAttentionCapability) handle(ctx context.Context, h *reactiveHandler,
 		// trace gets. A trace that stores a rune count next to a log line
 		// storing the runes is not redacted at all.
 		log.Printf("ecosystem: entity attention resolve %s: %v", redactSubject(subject), err)
-		h.recordEcosystemTrace(ctx, "nexus", "resolve", traceStatusForError(err), started,
-			mergeFields(traceErrorFields(err), map[string]any{"subject": redactSubject(subject)}))
-		if unauthorizedEcosystemError(err) {
-			return phraser.A(phraser.EcoDenied, serviceVars(serviceNexus))
-		}
-		return phraser.A(phraser.EcoDown, serviceVars(serviceNexus))
+		return h.nexusResolveFailed(ctx, subject, started, err)
 	}
 	if len(ambiguous) > 0 {
 		return phraser.A(phraser.EcoAmbiguous, map[string]string{"items": strings.Join(ambiguous, ", ")})
@@ -339,19 +346,24 @@ func (entityAttentionCapability) handle(ctx context.Context, h *reactiveHandler,
 	})
 
 	var parts []string
+	var spoken []string
 	for _, item := range items {
 		title, _ := item["title"].(string)
 		if title == "" {
 			continue
 		}
 		parts = append(parts, title)
-		// Same surfaced != acknowledged rule as the unscoped digest.
-		if id, ok := item["id"].(string); ok && id != "" {
-			if _, err := px.Surface(ctx, id); err != nil {
-				log.Printf("ecosystem: praxis surface %s: %v", id, err)
-			}
+		if id := surfaceSpoken(ctx, px, item); id != "" {
+			spoken = append(spoken, id)
 		}
 	}
+	// The scoped digest is a list she read out, so it replaces the positional
+	// memory exactly as the unscoped one does. It used to surface these items
+	// and remember none of them, which left the previous digest live: "отметь
+	// второй как сделанное" then indexed into a list he had not just heard and
+	// transitioned somebody else's item (docs/ecosystem.md — a wrong guess here
+	// transitions the wrong item).
+	h.rememberSurfaced(spoken)
 	if known := h.localFactsForEntity(ctx, entityID); known != "" {
 		parts = append(parts, known)
 	}
@@ -366,6 +378,22 @@ func (entityAttentionCapability) handle(ctx context.Context, h *reactiveHandler,
 	return phraser.A(phraser.AttentionListEntity, map[string]string{"name": displayName, "items": strings.Join(parts, "; ")})
 }
 
+// surfaceSpoken marks an item she just read out as surfaced. Speaking an item
+// surfaces it, it does not acknowledge it (ECOSYSTEM-SPEC.md §2.3: surfaced !=
+// acknowledged), so this calls Surface and nothing else. Best effort: a failed
+// surface call must not block delivering the digest. Returns the item id, or ""
+// when the item carried none.
+func surfaceSpoken(ctx context.Context, px *praxisClient, item map[string]any) string {
+	id, _ := item["id"].(string)
+	if id == "" {
+		return ""
+	}
+	if _, err := px.Surface(ctx, id); err != nil {
+		log.Printf("ecosystem: praxis surface %s: %v", id, err)
+	}
+	return id
+}
+
 // scopedToEntity drops items that carry an entity_id other than the one asked
 // about, and reports whether the response can be trusted as scoped at all. An
 // item without an entity_id is kept only when at least one sibling carries the
@@ -474,6 +502,14 @@ func traceStatusForError(err error) string {
 	return traceFailed
 }
 
+// nexusResolveFailed records a resolve that failed and returns the named gap.
+// The subject is his words, so the trace keeps a rune count and not the runes.
+func (h *reactiveHandler) nexusResolveFailed(ctx context.Context, subject string, started time.Time, err error) string {
+	h.recordEcosystemTrace(ctx, "nexus", "resolve", traceStatusForError(err), started,
+		mergeFields(traceErrorFields(err), map[string]any{"subject": redactSubject(subject)}))
+	return ecosystemGap(serviceNexus, err)
+}
+
 // redactSubject reduces a user utterance to something safe to persist in a
 // trace: its length only. Traces are diagnostics, and his words are not
 // diagnostics — the correlation ID is what ties a trace to the turn.
@@ -532,26 +568,31 @@ func unauthorizedEcosystemError(err error) bool {
 	return errors.As(err, &ee) && ee.Unauthorized()
 }
 
+// isEcosystemError reports a failure that belongs to the service rather than to
+// what was asked of it: a call that never landed, or one the far side refused.
+// It separates "Hexis is down" from "the restart failed".
+func isEcosystemError(err error) bool {
+	var ee *ecosystemError
+	return errors.As(err, &ee)
+}
+
 // traceErrorFields describes an ecosystemError for a trace without leaking the
 // payload: the HTTP status and the failure class, nothing else.
 func traceErrorFields(err error) map[string]any {
-	fields := map[string]any{}
+	fields := map[string]any{"class": "error"}
 	var ee *ecosystemError
-	if errors.As(err, &ee) {
-		fields["http_status"] = ee.Status
-		switch {
-		case ee.Unauthorized():
-			fields["class"] = "unauthorized"
-		case ee.ContractMismatch():
-			fields["class"] = "contract_mismatch"
-		case ee.Unreachable():
-			fields["class"] = "unreachable"
-		default:
-			fields["class"] = "error"
-		}
+	if !errors.As(err, &ee) {
 		return fields
 	}
-	fields["class"] = "error"
+	fields["http_status"] = ee.Status
+	switch {
+	case ee.Unauthorized():
+		fields["class"] = "unauthorized"
+	case ee.ContractMismatch():
+		fields["class"] = "contract_mismatch"
+	case ee.Unreachable():
+		fields["class"] = "unreachable"
+	}
 	return fields
 }
 
@@ -636,16 +677,11 @@ func (h *reactiveHandler) handleHexisAct(ctx context.Context, dec router.Decisio
 	res := h.resolveEntityCandidates(ctx, entityReferences(dec))
 	subject, entityID, displayName, ambiguous, err := res.subject, res.entityID, res.displayName, res.ambiguous, res.err
 	if err != nil {
-		h.recordEcosystemTrace(ctx, "nexus", "resolve", traceStatusForError(err), started,
-			mergeFields(traceErrorFields(err), map[string]any{"subject": redactSubject(subject)}))
-		if unauthorizedEcosystemError(err) {
-			return phraser.A(phraser.EcoDenied, serviceVars(serviceNexus))
-		}
 		// 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 phraser.A(phraser.EcoDown, serviceVars(serviceNexus))
+		return h.nexusResolveFailed(ctx, subject, started, err)
 	}
 	if len(ambiguous) > 0 {
 		h.recordEcosystemTrace(ctx, "nexus", "resolve", traceAmbig, started,
@@ -668,10 +704,7 @@ func (h *reactiveHandler) handleHexisAct(ctx context.Context, dec router.Decisio
 	if err != nil {
 		h.recordEcosystemTrace(ctx, "hexis", "capabilities", traceStatusForError(err), discovered,
 			mergeFields(traceErrorFields(err), map[string]any{"entity_id": entityID}))
-		if unauthorizedEcosystemError(err) {
-			return phraser.A(phraser.EcoDenied, serviceVars(serviceHexis))
-		}
-		return phraser.A(phraser.EcoDown, serviceVars(serviceHexis))
+		return ecosystemGap(serviceHexis, err)
 	}
 	h.recordEcosystemTrace(ctx, "hexis", "capabilities", traceOK, discovered,
 		map[string]any{"entity_id": entityID, "count": len(caps)})
@@ -745,6 +778,9 @@ func (h *reactiveHandler) handleHexisAct(ctx context.Context, dec router.Decisio
 			entityID:     entityID,
 			displayName:  displayName,
 			expiry:       h.now().Add(confirmTTL),
+			// This action's id, so the execution the confirm authorises is
+			// joined to the resolve and the discovery that proposed it.
+			correlationID: correlationIDFromCtx(ctx),
 		}
 		h.mu.Unlock()
 		h.recordEcosystemTrace(ctx, "hexis", "confirmation", tracePending, started,
@@ -769,6 +805,14 @@ func (h *reactiveHandler) execHexis(ctx context.Context, capID, capName, entityI
 			mergeFields(traceErrorFields(err), map[string]any{
 				"entity_id": entityID, "capability": capName, "causation_id": causationID,
 			}))
+		// Hexis never answering, or answering "no", is a gap in Hexis and is
+		// named as one — a refused token said "не получилось выполнить команду"
+		// here and sent him to debug a capability that was never reached
+		// (Vikunja #587). An execution that genuinely ran and failed is not an
+		// ecosystemError and keeps the command-level line.
+		if isEcosystemError(err) {
+			return ecosystemGap(serviceHexis, err)
+		}
 		return phraser.A(phraser.ActFailEntity, map[string]string{"name": displayName})
 	}
 	// One record per hop: the second write this used to make said the same

cmd/mavend/ecosystem_gap_test.go

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

cmd/mavend/ecosystem_harness_test.go

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

cmd/mavend/historyq.go

@@ -54,30 +54,56 @@ var historyMarkersEn = [][2]string{
 // answers a topic far better than a list of the last five facts does.
 var historyRecall = []string{" про ", " об ", " о ", " about "}
 
+// historySide — whose turn the question asks about. The rows read are the same
+// either way, because a tapped fact is one act seen from two sides, but the
+// sentence is not: answering "что ты записала сегодня?" with "ты говорил…"
+// hands the question back instead of answering it (Vikunja #456).
+type historySide int
+
+const (
+	historyAskedHim historySide = iota // "что я тебе говорил"
+	historyAskedHer                    // "что ты записала сегодня"
+)
+
 // isHistoryQuery reports whether he is asking what he told her.
 func isHistoryQuery(u string) bool {
+	_, ok := historyAsks(u)
+	return ok
+}
+
+// historyAsks reports whether this is a history question, and whose turn it is
+// about.
+func historyAsks(u string) (historySide, bool) {
 	s := " " + strings.ToLower(strings.TrimSpace(u)) + " "
 	if s == "  " {
-		return false
+		return historyAskedHim, false
 	}
 	for _, r := range historyRecall {
 		if strings.Contains(s, r) {
-			return false
+			return historyAskedHim, false
 		}
 	}
 	for _, pair := range historyMarkersEn {
 		if strings.Contains(s, pair[0]) && strings.Contains(s, pair[1]) {
-			return true
+			if strings.Contains(pair[0], "you") {
+				return historyAskedHer, true
+			}
+			return historyAskedHim, true
 		}
 	}
 	toks := historyTokens(s)
 	if !hasAny(toks, "что", "чего") {
-		return false
+		return historyAskedHim, false
 	}
+	// His side is tested first: "отмечать" is on both verb lists, so "что я
+	// отметил" must not read as a question about her.
 	if hasAny(toks, firstPersonSubjects...) && hasVerbForm(toks, historySpokenVerbs) {
-		return true
+		return historyAskedHim, true
 	}
-	return hasAny(toks, secondPersonSubjects...) && hasVerbForm(toks, historyRecordedVerbs)
+	if hasAny(toks, secondPersonSubjects...) && hasVerbForm(toks, historyRecordedVerbs) {
+		return historyAskedHer, true
+	}
+	return historyAskedHim, false
 }
 
 // historyTokens splits an utterance into bare words. The punctuation goes
@@ -142,7 +168,8 @@ const historyWindow = 24 * time.Hour
 // pass: the notes pass would otherwise answer this from whatever note happens
 // to be nearest, which reads as an answer and is not one.
 func (h *reactiveHandler) queryHistory(ctx context.Context, t *queryTurn) (string, bool) {
-	if !isHistoryQuery(t.dec.Utterance) {
+	side, ok := historyAsks(t.dec.Utterance)
+	if !ok {
 		return "", false
 	}
 	facts, err := h.api.RecentFacts(ctx, historyScan)
@@ -164,8 +191,14 @@ func (h *reactiveHandler) queryHistory(ctx context.Context, t *queryTurn) (strin
 	if len(said) == 0 {
 		// Claim the turn rather than fall through. "ничего не говорил" is the
 		// true answer, and recall would answer it with an old note instead.
+		if side == historyAskedHer {
+			return "за последние сутки я ничего с твоих слов не записывала.", true
+		}
 		return "за последние сутки ты мне ничего такого не говорил.", true
 	}
+	if side == historyAskedHer {
+		return "я записала: " + strings.Join(said, "; "), true
+	}
 	return "ты говорил: " + strings.Join(said, "; "), true
 }
 

cmd/mavend/historyq_test.go

@@ -89,6 +89,33 @@ func TestHistoryReadsOnlyWhatHeSaid(t *testing.T) {
 	}
 }
 
+// The rows are the same either way, because a tapped fact is one act seen from
+// two sides. The sentence is not: "что ты записала" answered with "ты говорил"
+// hands the question back (Vikunja #456).
+func TestHistoryAnswersTheSideItWasAsked(t *testing.T) {
+	now := time.Date(2026, 8, 4, 20, 0, 0, 0, time.UTC)
+	h, _ := historyHandler(now, ipc.Fact{Key: "water", Value: "выпил", Source: "tap:voice", Ts: now.Add(-time.Hour)})
+
+	his, ok := askHistory(h, "что я тебе говорил?")
+	if !ok || !strings.HasPrefix(his, "ты говорил") {
+		t.Errorf("reply = %q, ok = %v, want his side", his, ok)
+	}
+	hers, ok := askHistory(h, "что ты записала сегодня?")
+	if !ok || !strings.HasPrefix(hers, "я записала") {
+		t.Errorf("reply = %q, ok = %v, want her side", hers, ok)
+	}
+	// "отмечать" is on both verb lists, so his subject has to win.
+	if side, ok := historyAsks("что я отметил?"); !ok || side != historyAskedHim {
+		t.Errorf("historyAsks(что я отметил) = %v, %v", side, ok)
+	}
+
+	empty, _ := historyHandler(now)
+	none, ok := askHistory(empty, "что ты записала сегодня?")
+	if !ok || !strings.Contains(none, "не записывала") {
+		t.Errorf("empty reply = %q, ok = %v, want her side", none, ok)
+	}
+}
+
 // Nothing said is an answer of its own. Falling through would hand the question
 // to recall, which answers it with an old note.
 func TestHistorySaysWhenThereIsNothing(t *testing.T) {

cmd/mavend/main.go

@@ -68,6 +68,11 @@ import (
 	"github.com/kami/maven/internal/webauthn"
 )
 
+// stepUpTTL is how long one passkey assertion keeps the session stepped up.
+// Long enough for the unlock call that follows it, short enough that a walked
+// away laptop does not stay authorized.
+const stepUpTTL = 5 * time.Minute
+
 var errLocked = errors.New("mavend: daemon locked — complete passkey assertion first")
 
 // daemonLock tracks whether the daemon is in locked (pre-unlock) mode, and
@@ -128,6 +133,8 @@ func run(args []string) error {
 	wrappedKeyPath := flag.String("wrapped-key-file", "", "path to wrapped encryption key blob (enables cold-start unlock)")
 	reembed := flag.Bool("reembed", false, "re-embed every stored note and fact with the configured embedder, then serve normally (run once after an embedder swap; the daemon does not answer until it finishes)")
 	allowSeed := flag.Bool("allow-seed", false, "enable the backdated seed_event write path (QA only: it lets a caller place a fact in the past and mint a routine the tick loop will then act on; off means the method has nothing to write with)")
+	wipe := flag.Bool("wipe", false, "print every table and its row count, then exit without serving; add -confirm-wipe to delete all of it")
+	confirmWipe := flag.Bool("confirm-wipe", false, "with -wipe, actually remove every piece of personal data (facts, notes, vectors, events, tasks, sessions, traces, voiceprints). config, models, passkeys and the encryption key are files and survive")
 	flag.CommandLine.Parse(args)
 	reembedOnStart = *reembed
 	allowSeedOnStart = *allowSeed
@@ -210,6 +217,14 @@ func run(args []string) error {
 		}()
 	}
 
+	// ----- wipe: never serves, exits when it is done (Vikunja #494) -----
+	if *wipe {
+		if locked {
+			return fmt.Errorf("wipe: the store is locked and there is no key to open it with")
+		}
+		return runWipe(ctx, st, os.Stdout, *confirmWipe)
+	}
+
 	// ----- daemon components (only wired when unlocked) -----
 	// Pre-declare so the unlock path can wire them later.
 	var (
@@ -239,42 +254,12 @@ func run(args []string) error {
 
 	if !locked {
 		rules = wireRules(cfg)
-		gatherer = loop.NewGatherer(st, rules)
-		if cfg.QuietHours != nil {
-			gatherer.SetQuietHours(cfg.QuietHours.Start, cfg.QuietHours.End)
-		}
+		gatherer = wireGatherer(st, cfg, rules)
 
 		// phraser
-		phr = phraser.NewStub()
-		if cfg.Phraser != nil {
-			pc := phraser.Config{
-				ModelPath:    cfg.Phraser.ModelPath,
-				BinPath:      cfg.Phraser.BinPath,
-				Listen:       cfg.Phraser.Listen,
-				NGpuLayers:   cfg.Phraser.NGpuLayers,
-				NCtx:         cfg.Phraser.NCtx,
-				CacheRAMMiB:  cacheRAMMiB(cfg.Phraser.CacheRAMMiB),
-				Timeout:      time.Duration(cfg.Phraser.Timeout),
-				LLMNudges:    cfg.Phraser.LLMNudges,
-				ContextBlock: contextBlockFn(cfg, time.Now),
-			}
-			if pc.BinPath == "" {
-				pc.BinPath = "llama-server"
-			}
-			if pc.Listen == "" {
-				pc.Listen = "127.0.0.1:0"
-			}
-			if pc.NCtx <= 0 {
-				pc.NCtx = 2048
-			}
-			if pc.Timeout <= 0 {
-				pc.Timeout = 30 * time.Second
-			}
-			var err error
-			phr, err = phraser.NewLLMPhraser(ctx, pc)
-			if err != nil {
-				return fmt.Errorf("phraser: %w", err)
-			}
+		phr, err = wirePhraser(ctx, cfg)
+		if err != nil {
+			return fmt.Errorf("phraser: %w", err)
 		}
 
 		// ecosystem — nexus + hexis + praxis (all over HTTP; no direct DB access)
@@ -287,48 +272,13 @@ func run(args []string) error {
 		}
 
 		// delivery
-		var ntfy delivery.Sink
-		if cfg.Ntfy != nil {
-			s, err := ntfysink.New(*cfg.Ntfy)
-			if err != nil {
-				return fmt.Errorf("wire ntfy sink: %w", err)
-			}
-			ntfy = s
+		dispatcher, err = wireDispatcher(st, cfg, voiceW)
+		if err != nil {
+			return err
 		}
-		var telegram delivery.Sink
-		if cfg.Telegram != nil {
-			s, err := telegramsink.New(*cfg.Telegram)
-			if err != nil {
-				return fmt.Errorf("wire telegram sink: %w", err)
-			}
-			telegram = s
-		}
-		var voiceSink delivery.Sink
-		if voiceW != nil {
-			voiceSink = voiceW.voiceSink
-		}
-		// A crashed prior run may have left "pending" delivery attempts (send
-		// may have landed externally, then the process died before recording
-		// it) — reconcile them to "unknown" before the tick loop resumes
-		// sending, so nothing auto-resends into that ambiguity.
-		if _, err := st.ReconcileStaleDeliveryAttempts(context.Background(), time.Now()); err != nil {
-			log.Printf("delivery outbox reconcile: %v", err)
-		}
-		dispatcher = delivery.NewDispatcher(delivery.Config{
-			Ntfy:      ntfy,
-			Telegram:  telegram,
-			Voice:     voiceSink,
-			Ack:       st,
-			Nudges:    st,
-			Reminders: st,
-			Outbox:    st,
-		})
 
 		// tick loop
-		tickInterval := time.Duration(cfg.TickInterval)
-		repeatInterval := time.Duration(cfg.RepeatInterval)
-		autotuneInterval := time.Duration(cfg.AutotuneInterval)
-		tl = newTickLoop(st, gatherer, dispatcher, phr, rules, tickInterval, repeatInterval, autotuneInterval, cfg.Digest, routinesFromConfig(cfg.Routines), config.MorningRoutinesFromConfig(cfg.MorningRoutines), cfg.PatternProposals)
+		tl = wireTickLoop(st, gatherer, dispatcher, phr, rules, cfg)
 		factWorker = newFactEnrichmentWorker(st, eco, time.Duration(cfg.FactEnrichmentInterval))
 		evalWorker = newMemoryEvalWorker(st, phr, cfg)
 		feedWkr = newFeedWorker(coreFor(), embedderOf(voiceW), cfg)
@@ -340,7 +290,9 @@ func run(args []string) error {
 			getMorningStatus: func(ctx context.Context) []ipc.MorningRoutineStatus { return tl.morningStatus(ctx, time.Now()) },
 			getDayPlan:       func(ctx context.Context) ipc.DayPlan { return tl.dayPlan(ctx, time.Now()) },
 			getEvents:        intakeEventsFn(evBus),
+			getDecisions:     turnDecisionsFn(voiceW),
 			seedStore:        seedStoreIfAllowed(st),
+			nexus:            nexusOf(voiceW),
 		}
 		if voiceW != nil && voiceW.handler != nil {
 			api := coreAPI.(*daemonAPI)
@@ -368,7 +320,7 @@ func run(args []string) error {
 		return fmt.Errorf("ipc listen: %w", err)
 	}
 
-	passkeySess := webauthn.NewPasskeySession(5 * time.Minute)
+	passkeySess := webauthn.NewPasskeySession(stepUpTTL)
 
 	// Set Server.Check — the single authorization guard, run once by
 	// Server.dispatch before any CoreAPI method is called (see
@@ -516,40 +468,11 @@ func run(args []string) error {
 
 			// Wire everything.
 			rules = wireRules(cfg)
-			gatherer = loop.NewGatherer(st, rules)
-			if cfg.QuietHours != nil {
-				gatherer.SetQuietHours(cfg.QuietHours.Start, cfg.QuietHours.End)
-			}
+			gatherer = wireGatherer(st, cfg, rules)
 
-			phr = phraser.NewStub()
-			if cfg.Phraser != nil {
-				pc := phraser.Config{
-					ModelPath:    cfg.Phraser.ModelPath,
-					BinPath:      cfg.Phraser.BinPath,
-					Listen:       cfg.Phraser.Listen,
-					NGpuLayers:   cfg.Phraser.NGpuLayers,
-					NCtx:         cfg.Phraser.NCtx,
-					CacheRAMMiB:  cacheRAMMiB(cfg.Phraser.CacheRAMMiB),
-					Timeout:      time.Duration(cfg.Phraser.Timeout),
-					LLMNudges:    cfg.Phraser.LLMNudges,
-					ContextBlock: contextBlockFn(cfg, time.Now),
-				}
-				if pc.BinPath == "" {
-					pc.BinPath = "llama-server"
-				}
-				if pc.Listen == "" {
-					pc.Listen = "127.0.0.1:0"
-				}
-				if pc.NCtx <= 0 {
-					pc.NCtx = 2048
-				}
-				if pc.Timeout <= 0 {
-					pc.Timeout = 30 * time.Second
-				}
-				phr, err = phraser.NewLLMPhraser(ctx, pc)
-				if err != nil {
-					return fmt.Errorf("phraser: %w", err)
-				}
+			phr, err = wirePhraser(ctx, cfg)
+			if err != nil {
+				return fmt.Errorf("phraser: %w", err)
 			}
 
 			eco = wireEcosystem(cfg)
@@ -559,43 +482,12 @@ func run(args []string) error {
 				return fmt.Errorf("wire voice: %w", err)
 			}
 
-			var ntfy delivery.Sink
-			if cfg.Ntfy != nil {
-				s, err := ntfysink.New(*cfg.Ntfy)
-				if err != nil {
-					return fmt.Errorf("wire ntfy sink: %w", err)
-				}
-				ntfy = s
+			dispatcher, err = wireDispatcher(st, cfg, voiceW)
+			if err != nil {
+				return err
 			}
-			var telegram delivery.Sink
-			if cfg.Telegram != nil {
-				s, err := telegramsink.New(*cfg.Telegram)
-				if err != nil {
-					return fmt.Errorf("wire telegram sink: %w", err)
-				}
-				telegram = s
-			}
-			var voiceSink delivery.Sink
-			if voiceW != nil {
-				voiceSink = voiceW.voiceSink
-			}
-			if _, err := st.ReconcileStaleDeliveryAttempts(context.Background(), time.Now()); err != nil {
-				log.Printf("delivery outbox reconcile: %v", err)
-			}
-			dispatcher = delivery.NewDispatcher(delivery.Config{
-				Ntfy:      ntfy,
-				Telegram:  telegram,
-				Voice:     voiceSink,
-				Ack:       st,
-				Nudges:    st,
-				Reminders: st,
-				Outbox:    st,
-			})
 
-			tickInterval := time.Duration(cfg.TickInterval)
-			repeatInterval := time.Duration(cfg.RepeatInterval)
-			autotuneInterval := time.Duration(cfg.AutotuneInterval)
-			tl = newTickLoop(st, gatherer, dispatcher, phr, rules, tickInterval, repeatInterval, autotuneInterval, cfg.Digest, routinesFromConfig(cfg.Routines), config.MorningRoutinesFromConfig(cfg.MorningRoutines), cfg.PatternProposals)
+			tl = wireTickLoop(st, gatherer, dispatcher, phr, rules, cfg)
 			factWorker = newFactEnrichmentWorker(st, eco, time.Duration(cfg.FactEnrichmentInterval))
 			evalWorker = newMemoryEvalWorker(st, phr, cfg)
 			feedWkr = newFeedWorker(coreFor(), embedderOf(voiceW), cfg)
@@ -608,6 +500,7 @@ func run(args []string) error {
 				getMorningStatus: func(ctx context.Context) []ipc.MorningRoutineStatus { return tl.morningStatus(ctx, time.Now()) },
 				getDayPlan:       func(ctx context.Context) ipc.DayPlan { return tl.dayPlan(ctx, time.Now()) },
 				getEvents:        intakeEventsFn(evBus),
+				getDecisions:     turnDecisionsFn(voiceW),
 				seedStore:        seedStoreIfAllowed(st),
 			}
 			if voiceW != nil && voiceW.handler != nil {
@@ -685,71 +578,39 @@ func run(args []string) error {
 		}
 	}
 
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
+	goWorker(&wg, func() {
 		if err := srv.Serve(); err != nil && !errors.Is(err, net.ErrClosed) {
 			log.Printf("ipc serve: %v", err)
 		}
-	}()
+	})
 	log.Printf("mavend: ipc listening on %s", srv.Path())
 
 	if !locked && voiceW != nil {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
+		goWorker(&wg, func() {
 			if err := voiceW.server.Serve(); err != nil && !errors.Is(err, net.ErrClosed) {
 				log.Printf("voice serve: %v", err)
 			}
-		}()
+		})
 		log.Printf("mavend: voice listening on %s", voiceW.server.Addr())
 	}
 
 	if !locked {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			tl.run(ctx)
-		}()
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			factWorker.run(ctx)
-		}()
+		goWorker(&wg, func() { tl.run(ctx) })
+		goWorker(&wg, func() { factWorker.run(ctx) })
 		if evalWorker != nil {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				evalWorker.run(ctx)
-			}()
+			goWorker(&wg, func() { evalWorker.run(ctx) })
 		}
 		if feedWkr != nil {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				feedWkr.run(ctx)
-			}()
+			goWorker(&wg, func() { feedWkr.run(ctx) })
 		}
 		if crawlWkr != nil {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				crawlWkr.run(ctx)
-			}()
+			goWorker(&wg, func() { crawlWkr.run(ctx) })
 		}
 		if voiceW != nil && voiceW.mcp != nil {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				voiceW.mcp.run(ctx)
-			}()
+			goWorker(&wg, func() { voiceW.mcp.run(ctx) })
 		}
 		if voiceW != nil && voiceW.home != nil {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				voiceW.home.run(ctx)
-			}()
+			goWorker(&wg, func() { voiceW.home.run(ctx) })
 		}
 	}
 
@@ -837,6 +698,125 @@ func waitWorkers(wg *sync.WaitGroup, d time.Duration) bool {
 	}
 }
 
+// Phraser defaults, applied when the config block leaves a field unset. They
+// are the daemon's, not the library's: phraser.Config carries no defaults of
+// its own, so an empty field here would reach llama-server as an empty flag.
+const (
+	defaultLlamaBin       = "llama-server"
+	defaultPhraserListen  = "127.0.0.1:0"
+	defaultPhraserNCtx    = 2048
+	defaultPhraserTimeout = 30 * time.Second
+)
+
+// wirePhraser builds the phrasing seam. No phraser block means the
+// deterministic stub, which is the floor and not an error: the daemon answers
+// without a model, in fixed words.
+func wirePhraser(ctx context.Context, cfg *config.Config) (phraser.Phraser, error) {
+	if cfg.Phraser == nil {
+		return phraser.NewStub(), nil
+	}
+	pc := phraser.Config{
+		ModelPath:    cfg.Phraser.ModelPath,
+		BinPath:      cfg.Phraser.BinPath,
+		Listen:       cfg.Phraser.Listen,
+		NGpuLayers:   cfg.Phraser.NGpuLayers,
+		NCtx:         cfg.Phraser.NCtx,
+		CacheRAMMiB:  cacheRAMMiB(cfg.Phraser.CacheRAMMiB),
+		Timeout:      time.Duration(cfg.Phraser.Timeout),
+		LLMNudges:    cfg.Phraser.LLMNudges,
+		ContextBlock: contextBlockFn(cfg, time.Now),
+	}
+	if pc.BinPath == "" {
+		pc.BinPath = defaultLlamaBin
+	}
+	if pc.Listen == "" {
+		pc.Listen = defaultPhraserListen
+	}
+	if pc.NCtx <= 0 {
+		pc.NCtx = defaultPhraserNCtx
+	}
+	if pc.Timeout <= 0 {
+		pc.Timeout = defaultPhraserTimeout
+	}
+	return phraser.NewLLMPhraser(ctx, pc)
+}
+
+// wireGatherer builds the nudge gatherer over the given rule set and applies
+// the configured quiet hours.
+func wireGatherer(st *store.Store, cfg *config.Config, rules []loop.Rule) *loop.Gatherer {
+	g := loop.NewGatherer(st, rules)
+	if cfg.QuietHours != nil {
+		g.SetQuietHours(cfg.QuietHours.Start, cfg.QuietHours.End)
+	}
+	return g
+}
+
+// wireDispatcher builds the delivery fan-out. Each sink stays nil unless its
+// config block is present, and a sink that fails to build fails the boot
+// rather than going quiet.
+//
+// A crashed prior run may have left "pending" delivery attempts (send may have
+// landed externally, then the process died before recording it). They are
+// reconciled to "unknown" here, before the tick loop resumes sending, so
+// nothing auto-resends into that ambiguity.
+func wireDispatcher(st *store.Store, cfg *config.Config, voiceW *voiceWiring) (*delivery.Dispatcher, error) {
+	var ntfy delivery.Sink
+	if cfg.Ntfy != nil {
+		s, err := ntfysink.New(*cfg.Ntfy)
+		if err != nil {
+			return nil, fmt.Errorf("wire ntfy sink: %w", err)
+		}
+		ntfy = s
+	}
+	var telegram delivery.Sink
+	if cfg.Telegram != nil {
+		s, err := telegramsink.New(*cfg.Telegram)
+		if err != nil {
+			return nil, fmt.Errorf("wire telegram sink: %w", err)
+		}
+		telegram = s
+	}
+	var voiceSink delivery.Sink
+	if voiceW != nil {
+		voiceSink = voiceW.voiceSink
+	}
+	if _, err := st.ReconcileStaleDeliveryAttempts(context.Background(), time.Now()); err != nil {
+		log.Printf("delivery outbox reconcile: %v", err)
+	}
+	return delivery.NewDispatcher(delivery.Config{
+		Ntfy:      ntfy,
+		Telegram:  telegram,
+		Voice:     voiceSink,
+		Ack:       st,
+		Nudges:    st,
+		Reminders: st,
+		Outbox:    st,
+	}), nil
+}
+
+// wireTickLoop reads the loop's three intervals and its schedules out of the
+// config, so the two boot paths cannot disagree about them.
+func wireTickLoop(st *store.Store, gatherer *loop.Gatherer, dispatcher *delivery.Dispatcher, phr phraser.Phraser, rules []loop.Rule, cfg *config.Config) *tickLoop {
+	return newTickLoop(st, gatherer, dispatcher, phr, rules,
+		time.Duration(cfg.TickInterval),
+		time.Duration(cfg.RepeatInterval),
+		time.Duration(cfg.AutotuneInterval),
+		cfg.Digest,
+		routinesFromConfig(cfg.Routines),
+		config.MorningRoutinesFromConfig(cfg.MorningRoutines),
+		cfg.PatternProposals)
+}
+
+// goWorker starts run on its own goroutine and registers it with wg, so
+// shutdown can wait for it inside workerGrace.
+func goWorker(wg *sync.WaitGroup, run func()) {
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		run()
+	}()
+}
+
 // wireRules builds the nudge rule set, minus anything config turned off. The
 // drop is logged because a rule vanishing silently is indistinguishable from a
 // rule that is broken, and the next person to wonder why she stopped nudging

cmd/mavend/notefragment.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"strings"
+
+	"github.com/kami/maven/internal/lexicon"
+	"github.com/kami/maven/internal/morph"
+)
+
+// correctionFragment reports that an utterance replaces a referent and states
+// nothing of its own: "нет, не маме, а папе" (V-576).
+//
+// Measured on the box 2026-08-06, that fragment routed to note and was filed.
+// It is not a repair either, because it names no intent, so parseRepair
+// declines it and repair.go is the wrong place to catch it. This is the note
+// path saying it has nothing to store.
+//
+// Three offline tests, all of them narrow on purpose. The sentence opens with a
+// refusal word from the lexicon, it carries the contrastive "а" that names the
+// replacement, and no token in it is a verb form. The verb test is what keeps
+// the rule off real notes: "нет, я не поеду, а останусь" says something, and a
+// Russian verb carries its own subject and tense.
+func correctionFragment(utterance string) bool {
+	toks := repairTokens(strings.ToLower(strings.TrimSpace(utterance)))
+	if len(toks) < 3 {
+		return false
+	}
+	if !refusalWord(toks[0]) {
+		return false
+	}
+	var negated, contrasted bool
+	for _, tok := range toks[1:] {
+		switch tok {
+		case "не", "not":
+			negated = true
+		case "а", "but":
+			contrasted = true
+		}
+		if morph.IsVerbForm(tok) {
+			return false
+		}
+	}
+	return negated && contrasted
+}
+
+// refusalWord reports that a token is a one-word refusal. The lexicon set holds
+// phrases too ("не надо"), and those are not what opens a correction.
+func refusalWord(tok string) bool {
+	for _, w := range lexicon.ConfirmNo() {
+		if strings.ContainsRune(w, ' ') {
+			continue
+		}
+		if w == tok {
+			return true
+		}
+	}
+	return false
+}

cmd/mavend/notefragment_test.go

@@ -0,0 +1,117 @@
+package main
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/memory"
+	"github.com/kami/maven/internal/router"
+	"github.com/kami/maven/internal/store"
+	"github.com/kami/maven/internal/tool"
+	"github.com/kami/maven/internal/voice"
+)
+
+func TestCorrectionFragment(t *testing.T) {
+	cases := []struct {
+		utterance string
+		want      bool
+	}{
+		{"нет, не маме, а папе", true},
+		{"Нет, не маме — а папе", true},
+		{"no, not mom, but dad", true},
+		// States something of its own, so it is his to keep.
+		{"нет, я не поеду, а останусь дома", false},
+		{"нет", false},
+		{"не маме, а папе", false},  // no refusal word opening it
+		{"нет, маме и папе", false}, // nothing negated
+		{"нет, не маме", false},     // nothing put in its place
+		{"запомни что кофе закончился", false},
+	}
+	for _, c := range cases {
+		if got := correctionFragment(c.utterance); got != c.want {
+			t.Errorf("correctionFragment(%q) = %v, want %v", c.utterance, got, c.want)
+		}
+	}
+}
+
+func newNoteHandler(t *testing.T) (*reactiveHandler, *store.Store) {
+	t.Helper()
+	st := newTestStore(t)
+	api := ipc.NewStoreAPI(st)
+	now := time.Now()
+	emb := router.NewHashEmbedder(1024)
+	h := &reactiveHandler{
+		api:       api,
+		recall:    recallWiring{embedder: emb, memStore: memory.NewInMemoryStore()},
+		router:    buildRouter(emb, tool.NewMatcher(api), 0.55, nil),
+		replier:   voice.NewStubReplier(),
+		now:       func() time.Time { return now },
+		dataStore: st,
+	}
+	return h, st
+}
+
+// TestNoteBodyIsTheUtterance — the stored body comes from the utterance, never
+// from Slots.Text, which the LLM router is free to write anything into (V-576).
+func TestNoteBodyIsTheUtterance(t *testing.T) {
+	ctx := context.Background()
+	h, st := newNoteHandler(t)
+
+	dec := router.Decision{
+		Intent:    router.IntentNote,
+		Utterance: "купил хлеб и молоко",
+		Slots:     router.Slots{Text: "ты поедешь на дачу"},
+	}
+	if reply := h.applyAction(ctx, dec); reply != "" {
+		t.Fatalf("applyAction = %q, want empty", reply)
+	}
+	notes, err := st.RecentNotes(ctx, 10)
+	if err != nil {
+		t.Fatalf("RecentNotes: %v", err)
+	}
+	if len(notes) != 1 || notes[0].Text != dec.Utterance {
+		t.Fatalf("stored note = %+v, want body %q", notes, dec.Utterance)
+	}
+}
+
+// TestNoteBodyIsStable — the same utterance twice stores the same text.
+func TestNoteBodyIsStable(t *testing.T) {
+	ctx := context.Background()
+	h, st := newNoteHandler(t)
+
+	dec := router.Decision{Intent: router.IntentNote, Utterance: "кофе закончился"}
+	h.applyAction(ctx, dec)
+	h.applyAction(ctx, dec)
+
+	notes, err := st.RecentNotes(ctx, 10)
+	if err != nil {
+		t.Fatalf("RecentNotes: %v", err)
+	}
+	if len(notes) != 2 {
+		t.Fatalf("notes = %d, want 2", len(notes))
+	}
+	if notes[0].Text != notes[1].Text || notes[0].Text != dec.Utterance {
+		t.Fatalf("bodies differ: %q vs %q", notes[0].Text, notes[1].Text)
+	}
+}
+
+// TestCorrectionFragmentWritesNoNote — a correction with nothing behind it is
+// not a note, and she says so instead of filing it (V-576).
+func TestCorrectionFragmentWritesNoNote(t *testing.T) {
+	ctx := context.Background()
+	h, st := newNoteHandler(t)
+
+	dec := router.Decision{Intent: router.IntentNote, Utterance: "нет, не маме, а папе"}
+	if reply := h.applyAction(ctx, dec); reply != nothingToCorrectReply {
+		t.Fatalf("reply = %q, want %q", reply, nothingToCorrectReply)
+	}
+	notes, err := st.RecentNotes(ctx, 10)
+	if err != nil {
+		t.Fatalf("RecentNotes: %v", err)
+	}
+	if len(notes) != 0 {
+		t.Fatalf("notes = %+v, want none", notes)
+	}
+}

cmd/mavend/ordinal.go

@@ -8,6 +8,7 @@ import (
 	"unicode"
 
 	"github.com/kami/maven/internal/dialogue"
+	"github.com/kami/maven/internal/lexicon"
 	"github.com/kami/maven/internal/store"
 )
 
@@ -26,44 +27,41 @@ import (
 // does not say what to do with it. Acting on the bare word would guess, and a
 // wrong guess here closes work he never finished.
 
-// candidateOrdinals — the words that pick a position, by index. Prefix match,
-// because Russian declines them: "первый", "первую", "первое".
-var candidateOrdinals = []struct {
-	word string
-	nth  int
-}{
-	{"перв", 1}, {"втор", 2}, {"трет", 3}, {"четв", 4}, {"пят", 5},
-	{"first", 1}, {"second", 2}, {"third", 3},
-}
+// The position words come from the lexicon, which lists every form with its
+// position and "последний" as -1 (V-522). They used to be stem prefixes here —
+// {"перв", 1}, {"втор", 2} — which is the shape that sweep removed: a stem
+// decides meaning by guessing where a word ends, and "трет" also opens
+// "third-party". The lexicon runs to twelve rather than five, so he can pick
+// past the fifth of a longer list; resolveCandidate already answers a position
+// she did not read.
 
 // candidateDigits — "второй" said as a number. Matched whole, never by prefix:
-// "15" starts with "1" and is a time, not a position.
+// "15" starts with "1" and is a time, not a position. Digits are not a Russian
+// word list, so they stay here rather than in the lexicon.
 var candidateDigits = map[string]int{"1": 1, "2": 2, "3": 3, "4": 4, "5": 5}
 
-// candidateLast — "последний" picks the end of the list whatever its length.
-var candidateLast = []string{"последн", "last"}
-
 // parseOrdinal reads which position he named. 0 and false when he named none.
 // A negative result means the last one.
 func parseOrdinal(text string) (int, bool) {
 	// Token by token, not substring: " 1" would otherwise match inside
 	// "напомни в 15:00" and turn a reminder into a selection.
-	for _, tok := range strings.FieldsFunc(strings.ToLower(text), func(r rune) bool {
+	toks := strings.FieldsFunc(strings.ToLower(text), func(r rune) bool {
 		return !unicode.IsLetter(r) && !unicode.IsDigit(r)
-	}) {
-		for _, w := range candidateLast {
-			if strings.HasPrefix(tok, w) {
-				return -1, true
-			}
-		}
+	})
+	for i, tok := range toks {
 		if n, ok := candidateDigits[tok]; ok {
 			return n, true
 		}
-		for _, o := range candidateOrdinals {
-			// Prefix, because Russian declines them: "первый", "первую".
-			if strings.HasPrefix(tok, o.word) {
-				return o.nth, true
-			}
+		// A spoken half hour names the hour it is entering with the same
+		// genitive ordinal: "в половине восьмого" is 07:30, not the eighth
+		// thing she read out. She reads a list and he answers with a time
+		// often enough that this has to be declined here, or the reminder
+		// becomes a selection.
+		if i > 0 && lexicon.IsHalfHour(toks[i-1]) {
+			continue
+		}
+		if n, ok := lexicon.Ordinal(tok); ok {
+			return n, true
 		}
 	}
 	return 0, false

cmd/mavend/ordinal_test.go

@@ -27,6 +27,16 @@ func TestParseOrdinalReadsThePosition(t *testing.T) {
 		{"", 0, false},
 		// A digit inside a time is not a position.
 		{"напомни в 15:00", 0, false},
+		// Forms the stem list used to miss, and positions past its fifth.
+		{"вторым", 2, true},
+		{"седьмую", 7, true},
+		{"одиннадцатый", 11, true},
+		// A spoken half hour names its hour with the same genitive ordinal, so
+		// this is 07:30 and not the eighth thing she read out (V-522).
+		{"напомни в половине восьмого", 0, false},
+		{"полвосьмого", 0, false},
+		// The ordinal still wins when the half word is not in front of it.
+		{"восьмую сделал", 8, true},
 	}
 	for _, c := range cases {
 		got, ok := parseOrdinal(c.text)

cmd/mavend/personalboundary.go

@@ -77,6 +77,32 @@ var worldSeeds = []string{
 	"что мне почитать про историю",
 	"что я должен знать про питон",
 	"what can i watch tonight",
+	// A third shape that looks personal and is not: asking when something
+	// happens (Vikunja #553). "во сколько закат сегодня" scored personal,
+	// because "что у меня сегодня" and "когда моя встреча" put that frame on
+	// the personal side and nothing here answered it. The sunset is the one
+	// thing on his list that is the same for everybody standing outside.
+	// "сегодня" is carried on purpose. Without it these caught nothing: the
+	// day word is most of what pulls the frame personal, because "что у меня
+	// сегодня" is a personal seed and the day word is the half it shares.
+	"во сколько сегодня открывается магазин",
+	"когда сегодня начинается матч",
+	"во сколько сегодня восход солнца",
+	// The other frame a day word carries, and the same story: "что у меня
+	// сегодня" is a personal seed, so "какой сегодня праздник" and "что
+	// интересного произошло сегодня в мире" were refused as his after the
+	// topic seeds had already let them past the weather source.
+	"какой сегодня курс валют",
+	"что сегодня происходит в мире",
+	// The narrative shape (Vikunja #554). "расскажи про Байкал" was refused as
+	// his by 0.0052, and nothing here was phrased as an order rather than a
+	// question: every world seed above opens with an interrogative. So a world
+	// question that names its subject and asks for prose landed nearer "я тебе
+	// рассказывал об этом?", which is the same verb about his own words.
+	"расскажи про байкал",
+	"расскажи про древний рим",
+	"объясни как работает двигатель",
+	"tell me about the roman empire",
 }
 
 // personalBoundary holds the embedded seeds. Zero value is usable and means

cmd/mavend/personalboundary_test.go

@@ -68,6 +68,27 @@ func TestONNXPersonalBoundary(t *testing.T) {
 		{"я хочу узнать про рим", false},
 		{"кто такой гагарин", false},
 		{"how do i boil an egg", false},
+		// Asking when a public thing happens (Vikunja #553). "во сколько закат
+		// сегодня" was answered "не знаю — не нашла у тебя такой записи",
+		// because the frame lived only on the personal side. The pair above it
+		// is the control: "во сколько у меня встреча" is the same frame about
+		// something that IS his, and it has to stay personal.
+		{"во сколько закат сегодня", false},
+		{"когда сегодня заканчивается концерт", false},
+		{"во сколько завтра открывается аптека", false},
+		// The "какой сегодня X" frame. These clear the weather topic after the
+		// V-553 seeds and were then refused here, which is the same defect one
+		// source further down the chain.
+		{"какой сегодня праздник", false},
+		{"что интересного произошло сегодня в мире", false},
+		{"кто выиграл вчера матч", false},
+		// The narrative shape, held out from the seeds above (Vikunja #554).
+		// The control is the row after them: the same verb about his own words
+		// is still his.
+		{"расскажи про эверест", false},
+		{"расскажи про войну 1812 года", false},
+		{"объясни что такое инфляция", false},
+		{"я рассказывал тебе про байкал?", true},
 	}
 
 	h := &reactiveHandler{recall: recallWiring{embedder: emb}}

cmd/mavend/praxis_gap_test.go

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

cmd/mavend/query_recall_test.go

@@ -2,8 +2,11 @@ package main
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"math"
+	"net/http"
+	"strings"
 	"testing"
 	"time"
 
@@ -31,6 +34,57 @@ func (f *fixedEmbedder) Embed(_ context.Context, text string) ([]float32, error)
 	return v, nil
 }
 
+// brokenEmbedder fails every call, which is what an ONNX session error looks
+// like from the query chain's side.
+type brokenEmbedder struct{}
+
+func (brokenEmbedder) Dim() int     { return 4 }
+func (brokenEmbedder) Close() error { return nil }
+func (brokenEmbedder) Embed(context.Context, string) ([]float32, error) {
+	return nil, errors.New("onnx: session failed")
+}
+
+// TestQueryEmbedFailureDoesNotStopTheChain — V-568. The embed source used to
+// claim the turn on an embedder error, so one failing EmbedQuery answered every
+// question below it with "не смогла ответить", including the ones the search
+// answers without an embedder at all. A source that could not look must pass.
+func TestQueryEmbedFailureDoesNotStopTheChain(t *testing.T) {
+	const q = "почему небо голубое"
+
+	h, _ := searchHandler(t, searchBody, http.StatusOK)
+	h.api = ipc.NewStoreAPI(newTestStore(t))
+	h.recall = recallWiring{embedder: brokenEmbedder{}, minScore: 0.55, minMargin: 0.008}
+	h.now = time.Now
+
+	// The embed source itself passes rather than claiming.
+	turn := &queryTurn{dec: router.Decision{Intent: router.IntentQuery, Utterance: q}}
+	if reply, ok := h.queryEmbed(context.Background(), turn); ok {
+		t.Fatalf("queryEmbed claimed the turn on an embedder error: %q", reply)
+	}
+
+	// And the whole chain still reaches the search below it.
+	reply := askQuery(t, h, q)
+	if !strings.Contains(reply, "рэлеевского рассеяния") {
+		t.Fatalf("reply = %q, want the search answer", reply)
+	}
+}
+
+// The recall sources read the empty vector the failed embed left behind, and
+// neither of them may turn that into an answer: no vector means they could not
+// look, which is not the same as looking and finding nothing.
+func TestQueryRecallPassesWithoutAVector(t *testing.T) {
+	h, _ := buildRecallHandler(t, "где молоко", []recallCase{
+		{text: "молоко стоит в холодильнике", score: 0.90, kind: "note"},
+	})
+	turn := &queryTurn{dec: router.Decision{Intent: router.IntentQuery, Utterance: "где молоко"}}
+	if reply, ok := h.queryMemory(context.Background(), turn); ok {
+		t.Errorf("queryMemory claimed with no vector: %q", reply)
+	}
+	if reply, ok := h.queryNotes(context.Background(), turn); ok {
+		t.Errorf("queryNotes claimed with no vector: %q", reply)
+	}
+}
+
 // scoreVec builds a unit vector whose cosine against the query vector
 // (1,0,0,0) is exactly score.
 func scoreVec(score float64) []float32 {

cmd/mavend/reminderwhen.go

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

cmd/mavend/replier_llm.go

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

cmd/mavend/ruwords.go

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

cmd/mavend/ruwords_test.go

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

cmd/mavend/self.go

@@ -0,0 +1,116 @@
+package main
+
+import (
+	"context"
+	"log"
+	"regexp"
+
+	"github.com/kami/maven/internal/phraser"
+)
+
+// A question about her — "что ты умеешь", "кто ты" — used to have no answer at
+// all (Vikunja #555). It reached the personal boundary, which claimed it as his
+// and said "не знаю — не нашла у тебя такой записи", because the boundary knows
+// two sides and this is neither: her own description is not his data and it is
+// not the world's either. Letting it past the boundary is no better, because
+// then SearXNG answers about somebody else's assistant.
+//
+// The description does NOT live in the note store. Notes are his. A note about
+// her sitting in his index would come back for "что я записал", would be fed to
+// the digestion worker as something he said, and would be recalled by vector
+// proximity for questions that are not about her at all. It is her own text, so
+// it lives here, in one place, and it is the only copy.
+//
+// This source sits ABOVE the boundary, because a question about her never had
+// an answer below it.
+
+// selfDescription — what she is and what this box actually does. Frozen text,
+// and the one rule for editing it: name only what is really wired. Anything
+// that depends on config — the house, the LAN, the feeds, telegram, search — is
+// named as depending on what he allowed, never claimed outright. Inventing a
+// capability here is the same defect as inventing a fact, and it is worse than
+// silence because he would plan around it.
+//
+// Written in her own voice, feminine, addressing him informally, because it is
+// handed to the phraser as the evidence for the answer and the phraser will
+// keep the words it is given.
+const selfDescription = `Я Мэйвен, твоя помощница. Я живу на твоём сервере, ` +
+	`и наружу уходит только поисковый запрос — больше ничего.
+
+Что я делаю сама: запоминаю, что ты мне говоришь, и потом отвечаю на вопросы ` +
+	`об этом; веду заметки; ставлю напоминания; читаю твой календарь и задачи; ` +
+	`отвечаю на вопросы о мире — сначала поиском, а если сети нет, то по ` +
+	`офлайновой энциклопедии.
+
+Что зависит от того, что ты мне разрешил: дом, локальная сеть, ленты, ` +
+	`список покупок, погода, телеграм. Если что-то из этого не настроено, я ` +
+	`скажу об этом прямо, а не буду выдумывать ответ.
+
+Говорю по-русски и по-английски.`
+
+// selfSeeds — the questions this source claims. Scoring data like every other
+// topic set: editing one moves the recogniser and has to be re-measured against
+// TestONNXTopics.
+//
+// All of them are about HER — what she is, what she can do, who made her. The
+// neighbouring set is topicAttend, "что требует внимания", which asks about the
+// state of his things; the two share almost nothing but the second person.
+var selfSeeds = []string{
+	"что ты умеешь",
+	"что ты можешь делать",
+	"кто ты такая",
+	"расскажи о себе",
+	"какие у тебя возможности",
+	// Added after measuring: it won self by 0.0002, under the margin, and the
+	// floor does not carry it — "способна" names no verb the floor matches.
+	"на что ты способна",
+	"чем ты можешь помочь",
+	"what can you do",
+	"who are you",
+}
+
+// selfFloor — the offline floor, for a handler with no embedder or a turn whose
+// vector never got computed. Narrow on purpose, like every other floor here: it
+// answers only when the seeds cannot, and a broad guess made blind is worse
+// than a narrow one.
+//
+// Go's \b is ASCII-only and never fires next to a Cyrillic letter, so the
+// Russian patterns spell the boundary out.
+var selfPatterns = []*regexp.Regexp{
+	regexp.MustCompile(`(?i)(^|[^\p{L}\p{N}])ты\s+(умеешь|можешь)([^\p{L}\p{N}]|$)`),
+	regexp.MustCompile(`(?i)(^|[^\p{L}\p{N}])кто\s+ты([^\p{L}\p{N}]|$)`),
+	regexp.MustCompile(`(?i)(^|[^\p{L}\p{N}])(расскажи|поведай)\s+о\s+себе([^\p{L}\p{N}]|$)`),
+	regexp.MustCompile(`(?i)\bwhat\s+can\s+you\s+do\b`),
+	regexp.MustCompile(`(?i)\bwho\s+are\s+you\b`),
+}
+
+func selfFloor(utterance string) bool {
+	for _, re := range selfPatterns {
+		if re.MatchString(utterance) {
+			return true
+		}
+	}
+	return false
+}
+
+// querySelf answers a question about her from selfDescription. The description
+// goes through the phraser as evidence so the answer is shaped to what he
+// asked — "что ты умеешь" and "кто ты" want different halves of it — and falls
+// back to the text itself, which is already readable, if the model is down.
+func (h *reactiveHandler) querySelf(ctx context.Context, t *queryTurn) (string, bool) {
+	if !h.turnIsAbout(ctx, t, topicSelf, selfFloor) {
+		return "", false
+	}
+	var reply string
+	if h.phraser != nil {
+		var err error
+		reply, err = h.phraser.PhraseSelf(ctx, t.dec.Utterance, selfDescription)
+		if err != nil {
+			log.Printf("voice: phrase self: %v", err)
+		}
+	}
+	if reply == "" {
+		reply = phraser.Q(phraser.QueryFound, map[string]string{"text": selfDescription})
+	}
+	return reply, true
+}

cmd/mavend/self_test.go

@@ -0,0 +1,96 @@
+package main
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/kami/maven/internal/router"
+)
+
+// TestSelfFloorClaimsAQuestionAboutHerAndNothingElse — the offline floor, which
+// is what answers with no embedder. Narrow on purpose, so the rows that must
+// NOT match are the point.
+func TestSelfFloorClaimsAQuestionAboutHerAndNothingElse(t *testing.T) {
+	claimed := []string{
+		"что ты умеешь",
+		"что ты можешь",
+		"а что ты умеешь?",
+		"кто ты",
+		"кто ты такая?",
+		"расскажи о себе",
+		"what can you do",
+		"who are you",
+	}
+	for _, u := range claimed {
+		if !selfFloor(u) {
+			t.Errorf("%q is a question about her and the floor missed it", u)
+		}
+	}
+	declined := []string{
+		"что у меня сегодня",
+		"расскажи про байкал",
+		"кто изобрёл телефон",
+		"что требует внимания",
+		"запиши что я пил воду",
+		// The floor spells its own word boundaries out, because Go's \b never
+		// fires next to a Cyrillic letter. Without that these would match.
+		"кто тыкал в розетку",
+		"расскажи о себестоимости",
+	}
+	for _, u := range declined {
+		if selfFloor(u) {
+			t.Errorf("%q is not about her and the floor claimed it", u)
+		}
+	}
+}
+
+// TestSelfSourceAnswersFromTheDescription — with no embedder the source falls
+// to the floor, and the answer has to be the description rather than silence.
+func TestSelfSourceAnswersFromTheDescription(t *testing.T) {
+	h := personalHandler()
+	reply, claimed := h.querySelf(context.Background(), &queryTurn{
+		dec: router.Decision{Utterance: "что ты умеешь"},
+	})
+	if !claimed {
+		t.Fatal("a question about her must be claimed above the boundary")
+	}
+	if !strings.Contains(reply, "напоминания") {
+		t.Errorf("the answer must come from the description: %q", reply)
+	}
+	if _, claimed := h.querySelf(context.Background(), &queryTurn{
+		dec: router.Decision{Utterance: "почему небо синее"},
+	}); claimed {
+		t.Error("a world question must pass this source")
+	}
+}
+
+// TestSelfDescriptionHoldsThePersona — it is her own text and she reads it out,
+// so the same rules the phrasing eval enforces apply to it. Feminine
+// self-reference, informal address, no pet names.
+func TestSelfDescriptionHoldsThePersona(t *testing.T) {
+	lower := strings.ToLower(selfDescription)
+	for _, bad := range []string{"я рад ", "я готов ", "вы ", "ваш", "милый", "дорогой"} {
+		if strings.Contains(lower, bad) {
+			t.Errorf("the description breaks the persona on %q", bad)
+		}
+	}
+	for _, want := range []string{"тво", "ты"} {
+		if !strings.Contains(lower, want) {
+			t.Errorf("the description must address him directly, missing %q", want)
+		}
+	}
+}
+
+// TestSelfDescriptionClaimsNothingUnconditionally — the constraint that makes
+// this text safe to read out. Every capability that depends on config has to be
+// named as depending on it, and inventing one here is the same defect as
+// inventing a fact.
+func TestSelfDescriptionClaimsNothingUnconditionally(t *testing.T) {
+	conditional := selfDescription[strings.Index(selfDescription, "Что зависит"):]
+	for _, cap := range []string{"дом", "локальная сеть", "ленты", "список покупок", "погода", "телеграм"} {
+		if !strings.Contains(conditional, cap) {
+			t.Errorf("%q is configured, not wired — it must sit under the conditional half", cap)
+		}
+	}
+}

cmd/mavend/simulator_test.go

@@ -347,6 +347,55 @@ func (s *scriptedLLM) Complete(_ context.Context, r llm.Req) (string, error) {
 		map[bool]string{true: "route", false: "reply"}[routing], truncateRunes(r.User, 60))
 }
 
+// scriptedPhraser answers the chat path from the same script the router reads.
+//
+// It exists because actionChat calls h.phraser.PhraseChat, and the production
+// implementation posts raw HTTP to /v1/chat/completions rather than going
+// through the llm client scriptedLLM stands in for. So until this, no scenario
+// could script what she SAYS on a chat turn: the simulator wired phraser.NewStub()
+// and every chat reply came back as a pick from fallbacks_ru_v1.json, four
+// variants deep, which varied between two runs of one scenario (V-542 item 4).
+//
+// Everything except PhraseChat is the Stub's, by embedding. A nudge and a
+// reminder are phrased by the tick loop, which has its own phraser and its own
+// assertions; this seam is only about the conversation.
+type scriptedPhraser struct {
+	*phraser.Stub
+	entries []scriptEntry
+}
+
+// PhraseChat returns the scripted reply for the utterance, or an error when the
+// scenario scripted none. The error rather than a fallback is deliberate and
+// matches scriptedLLM: actionChat logs it and falls back to ChatFallback(), so a
+// scenario that never meant to assert on a chat reply behaves exactly as it did
+// before, and one that DID means to is told its script has a hole.
+func (p *scriptedPhraser) PhraseChat(_ context.Context, utterance string, _ []dialogue.Turn) (string, error) {
+	for _, e := range p.entries {
+		if e.Reply == "" {
+			continue
+		}
+		if e.Match != "" && !strings.Contains(strings.ToLower(utterance), strings.ToLower(e.Match)) {
+			continue
+		}
+		return chatReplyText(e.Reply), nil
+	}
+	return "", fmt.Errorf("simulator: no scripted chat reply for %q", truncateRunes(utterance, 60))
+}
+
+// chatReplyText reads a scripted reply in either shape the phrasing contract
+// allows: the {"response","mood"} object the model emits, or plain text.
+// LLMPhraser does this parse itself, so a scenario writes one thing and both
+// paths understand it.
+func chatReplyText(reply string) string {
+	var out struct {
+		Response string `json:"response"`
+	}
+	if err := json.Unmarshal([]byte(reply), &out); err == nil && out.Response != "" {
+		return out.Response
+	}
+	return reply
+}
+
 // ---------------------------------------------------------------------------
 // Building the world
 // ---------------------------------------------------------------------------
@@ -440,7 +489,7 @@ func newSimWorld(t *testing.T, sc scenario) *simWorld {
 		api:                api,
 		matcher:            matcher,
 		tools:              tool.NewExecutor(api, 5*time.Second),
-		phraser:            phraser.NewStub(),
+		phraser:            &scriptedPhraser{Stub: phraser.NewStub(), entries: sc.Script},
 		replier:            newLLMReplier(scripted, nil),
 		now:                clock.Now,
 		dataStore:          st,

cmd/mavend/testdata/scenarios/conversation_anaphora.json

@@ -0,0 +1,79 @@
+{
+  "schema_version": 1,
+  "name": "conversation_anaphora",
+  "description": "Five consecutive Russian turns about one object, replayed from the run that found V-542 on the box on 05-08-2026. He names a monitor, then asks four questions that all say \"он\" and never name it again.\n\nThis scenario exists because the shape had nowhere to fail. The routing fixture scores one utterance at a time, so a conversation that breaks on its second turn cannot lose a point there, and V-44 step 2 could only be verified by hand. That is item 3 of V-542.\n\nFour of the five replies below are WRONG, and the assertions pin them anyway. Read them as the recorded defect rather than the contract: she has the last four turns in front of her and never once names the thing he is asking about. Every wrong assertion is marked in its step note with what it must become. When V-542 lands, those flip and the ones marked correct do not move.\n\nWhat the four assert is that the reply LACKS \"монитор\". Absence is the defect itself: she is answering a question about a thing she wrote down two minutes ago and cannot name it. It also survives the fallback picker, which matters on the three query turns — they refuse from internal/phraser/fallbacks_ru_v1.json, four variants deep, and the same scenario returned \"тут я пас.\" one run and \"не знаю, честно.\" the next, so a string assertion there would pin the picker rather than the daemon.\n\nTurn 4 asserts its text as well, because that turn goes through the chat path and the chat path is now scriptable. scriptedPhraser in simulator_test.go answers PhraseChat from the same script entries the router reads (V-542 item 4); before it, the simulator wired phraser.NewStub() and no scenario could say what she SAYS on a chat turn at all.\n\nThe routes are scripted exactly as the box produced them, because the failure is not the model's. Turn 1 went to fact despite \"давай поболтаем\", every question after it went to query, and turn 4 went to chat. A scripted route is what lets this scenario pin the daemon's half without a llama-server in the loop.",
+  "start": "2026-08-05T14:00:00+03:00",
+  "script": [
+    {
+      "match": "купил новый монитор",
+      "route": "[{\"intent\":\"fact\",\"key\":\"purchase\",\"value\":\"новый монитор\"}]",
+      "reply": "{\"response\":\"записала: новый монитор.\",\"mood\":\"neutral\"}"
+    },
+    {
+      "match": "он большой",
+      "route": "[{\"intent\":\"query\",\"text\":\"а он большой?\"}]"
+    },
+    {
+      "match": "сколько он примерно стоит",
+      "route": "[{\"intent\":\"query\",\"text\":\"сколько он примерно стоит по-твоему?\"}]"
+    },
+    {
+      "match": "переплатил",
+      "route": "[{\"intent\":\"chat\",\"text\":\"мне кажется я переплатил\"}]",
+      "reply": "{\"response\":\"я не знаю, о каком именно устройстве ты говоришь.\",\"mood\":\"neutral\"}"
+    },
+    {
+      "match": "стоит его вернуть",
+      "route": "[{\"intent\":\"query\",\"text\":\"стоит его вернуть?\"}]"
+    },
+    {
+      "match": "",
+      "route": "[{\"intent\":\"chat\",\"text\":\"\"}]",
+      "reply": "{\"response\":\"я рада тебя слышать.\",\"mood\":\"happy\"}"
+    }
+  ],
+  "steps": [
+    {
+      "at": "14:00",
+      "note": "CORRECT, and it is the first half of the defect. \"давай поболтаем\" is an explicit request to converse and the turn is filed as a fact anyway. Storing what he said is not wrong on its own — he did buy a monitor — but the object then lives in the fact store and never enters the transcript PhraseChat reads. That is V-542 decision 2: either the marker claims the turn at stage 0, or it means nothing and comes out of the fixture.",
+      "say": "давай поболтаем: я вчера купил новый монитор",
+      "expect_events": ["purchase"],
+      "expect_no_send": true
+    },
+    {
+      "at": "14:01",
+      "note": "WRONG. \"он\" is the monitor from one turn ago, and she says she has no record of it. followUpMerge inherits prev.Slots.Key, and a query turn asking about a pronoun has no key to merge, so the question reaches the query sources naked and the notes source answers the only way it can. Must become: an answer about the monitor, or a route to chat where the transcript is.",
+      "say": "а он большой?",
+      "expect_reply_lacks": ["монитор"],
+      "expect_no_send": true
+    },
+    {
+      "at": "14:02",
+      "note": "WRONG, and it rules out one explanation. This is not the previous turn failing to stick — it is the same wall a second time, two turns from where the monitor was named. Nothing accumulates across query turns.",
+      "say": "сколько он примерно стоит по-твоему?",
+      "expect_reply_lacks": ["монитор"],
+      "expect_no_send": true
+    },
+    {
+      "at": "14:03",
+      "note": "WRONG, and it is the same wall from the other side. This turn routed chat, so it HAD the history that Session.History holds, and it asks which device he means anyway — because turn 1's object went to the fact store rather than the transcript. So a source reading the conversation is not sufficient on its own; decision 1 has to say which store the referent comes from. This is the one step whose text is pinned: the reply is scripted and reaches PhraseChat, so it is the box's own words rather than a fallback pick. Must become: a reply that names the monitor.",
+      "say": "мне кажется я переплатил",
+      "expect_reply_contains": ["о каком именно устройстве"],
+      "expect_reply_lacks": ["монитор"],
+      "expect_no_send": true
+    },
+    {
+      "at": "14:04",
+      "note": "WRONG. The fifth turn is the one that shows the cost. A returns question about a purchase two minutes old is answered with \"не нашла у тебя такой записи\", which is wrong in kind rather than merely unhelpful: the record exists, she wrote it herself at 14:00 under the key purchase.",
+      "say": "стоит его вернуть?",
+      "expect_reply_lacks": ["монитор"],
+      "expect_no_send": true
+    },
+    {
+      "at": "14:05",
+      "note": "CORRECT, and it is the control. Nothing in five conversational turns was sent at him unprompted, and a tick with him mid-conversation stays silent. Whatever V-542 changes must not change this.",
+      "tick": true,
+      "expect_no_send": true
+    }
+  ]
+}

cmd/mavend/testdata/scenarios/evening_degraded.json

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

cmd/mavend/testdata/scenarios/morning_missed.json

@@ -74,17 +74,17 @@
     },
     {
       "at": "08:50",
-      "note": "he asks. The query path answers from local recall only: nothing stored clears the score gate, so she refuses rather than inventing a morning summary, and the replier is never reached. That refusal is the no-hallucination floor and this step pins it. Note what the persona check here is and is not: the reply is a constant in the Go source, so expect_reply_lacks pins that constant, not anything the model wrote. The step below is the one that reads model output.",
+      "note": "he asks what he missed, and Praxis holds one unresolved item — the morning medicine — so she reads that back. This step pinned \"не знаю\" until 05-08-2026, and that was the keyword floor's blind spot rather than a rule: isAttentionQuery does not match \"что я пропустил\", while the topicAttend seeds carry \"что важное я пропустил\" almost verbatim. The seeds only started deciding when turnVector fixed the empty query vector every topic source was reading (V-547). Reading a surfaced item aloud is not inventing a morning summary, so the no-hallucination floor still holds; what moved is which source answers. Note what the persona check here is and is not: the reply is a constant in the Go source, so expect_reply_lacks pins that constant, not anything the model wrote. The step below is the one that reads model output.",
       "say": "что я пропустил?",
-      "expect_reply_contains": ["не знаю"],
+      "expect_reply_contains": ["требует внимания", "morning_medicine"],
       "expect_reply_lacks": ["рад ", "милый", "ваш"]
     },
     {
       "at": "08:55",
-      "note": "stating a fact writes it and says so, in the feminine. This reply comes back through the replier from the scripted model, so the persona check is against generated text rather than a constant. The masculine forms are listed with their following character — \"записал \" and \"записал,\" — because \"записала\" contains \"записал\", and the earlier check on the comma alone passed on \"записал что ты выпил воды\".",
+      "note": "stating a fact writes it and says so, in the feminine, and in his own words. The reply no longer comes from the model at all (V-592): a 1.7B asked to restate «я выпил воды» answered «Проверила, что ты выпел стакан воды», so the confirmation is now a deck frame with his sentence in it. The masculine forms are listed with their following character — \"записал \" and \"записал,\" — because \"записала\" contains \"записал\".",
       "say": "я выпил воды",
-      "expect_reply_contains": ["записала"],
-      "expect_reply_lacks": ["записал ", "записал,", "записал.", "милый"],
+      "expect_reply_contains": ["записала", "я выпил воды"],
+      "expect_reply_lacks": ["записал ", "записал,", "записал.", "милый", "стакан"],
       "expect_events": ["water"]
     },
     {

cmd/mavend/tick.go

@@ -319,10 +319,7 @@ func (t *tickLoop) stopFinishedAlarms(ctx context.Context, keys []string, state
 	if len(keys) == 0 {
 		return nil
 	}
-	byName := make(map[string]loop.Rule, len(t.rules))
-	for _, r := range t.rules {
-		byName[r.Name] = r
-	}
+	byName := t.rulesByName()
 	live := keys[:0:0]
 	for _, key := range keys {
 		outcome := ""
@@ -381,19 +378,27 @@ func (t *tickLoop) repeatableRules(keys []string) []string {
 	if len(keys) == 0 {
 		return nil
 	}
-	wired := make(map[string]bool, len(t.rules))
-	for _, r := range t.rules {
-		wired[r.Name] = true
-	}
+	wired := t.rulesByName()
 	out := keys[:0:0]
 	for _, k := range keys {
-		if wired[k] {
+		if _, ok := wired[k]; ok {
 			out = append(out, k)
 		}
 	}
 	return out
 }
 
+// rulesByName indexes the wired rule set by name, for the two lookups above
+// that only care whether a key is still wired (repeatableRules) or need the
+// rule itself (stopFinishedAlarms).
+func (t *tickLoop) rulesByName() map[string]loop.Rule {
+	byName := make(map[string]loop.Rule, len(t.rules))
+	for _, r := range t.rules {
+		byName[r.Name] = r
+	}
+	return byName
+}
+
 // cachePhrase keeps the latest phrased nudge per rule for the sev4-repeat
 // path. writing under a mutex; the repeat path reads under the same. the
 // cache is bounded by the rule count (≤ ~30 per spec) so eviction is not a

cmd/mavend/tick_api.go

@@ -23,6 +23,12 @@ type daemonAPI struct {
 	chatFn           func(ctx context.Context, conversation, text string) string
 	getMCPServers    func() []ipc.MCPServerStatus
 	getEvents        func(n int) []ipc.IntakeEvent
+	getDecisions     func(n int) []ipc.TurnDecision
+	// nexus — the identity client, nil when no nexus block is configured. It
+	// is what makes ResolveEntity answerable at all; without it the store
+	// adapter's refusal stands, and a surface that wanted an entity id says so
+	// instead of storing a name.
+	nexus *nexusClient
 	// seedStore — non-nil ONLY when mavend was started with -allow-seed. It is
 	// the whole off-switch for the backdated write path (Vikunja #518), and it
 	// is a store rather than a bool so that leaving the flag off means the
@@ -41,6 +47,48 @@ func (d *daemonAPI) RecentEvents(ctx context.Context, n int) ([]ipc.IntakeEvent,
 	return d.getEvents(n), nil
 }
 
+// nexusOf — the identity client the voice wiring built, or nil. Same shape as
+// embedderOf: a wiring that is absent and a wiring with no nexus block are one
+// answer here.
+func nexusOf(w *voiceWiring) *nexusClient {
+	if w == nil || w.handler == nil || w.handler.ecosystem == nil {
+		return nil
+	}
+	return w.handler.ecosystem.nexus
+}
+
+// ResolveEntity asks Nexus for the canonical id behind a name (Vikunja #511).
+//
+// Three outcomes, kept apart on purpose. No nexus block is ErrNotImplemented,
+// so a surface can say "identity is not configured here" rather than invent an
+// id. A miss is ipc.ErrNoEntity. A match against several entities comes back
+// Ambiguous with the names, because picking one is how a task ends up blocked
+// on the wrong person and nobody can see it happened.
+func (d *daemonAPI) ResolveEntity(ctx context.Context, query string, types []string) (ipc.EntityRef, error) {
+	if d.nexus == nil {
+		return ipc.EntityRef{}, ipc.ErrNotImplemented
+	}
+	res, err := d.nexus.Resolve(ctx, query, types)
+	if err != nil {
+		return ipc.EntityRef{}, err
+	}
+	if len(res.Candidates) > 1 {
+		names := make([]string, 0, len(res.Candidates))
+		for _, c := range res.Candidates {
+			names = append(names, c.DisplayName)
+		}
+		return ipc.EntityRef{Ambiguous: true, Candidates: names}, nil
+	}
+	if res.Entity == nil || res.Entity.ID == "" {
+		return ipc.EntityRef{}, ipc.ErrNoEntity
+	}
+	return ipc.EntityRef{
+		ID:          res.Entity.ID,
+		Type:        res.Entity.Type,
+		DisplayName: res.Entity.DisplayName,
+	}, nil
+}
+
 // Chat runs one text turn and reports which query source claimed it. The sink
 // rides the context so handleText keeps the one string signature the mic,
 // telegram and the web all call it through (V-539).
@@ -71,6 +119,17 @@ func (d *daemonAPI) TickTrace(ctx context.Context) (ipc.TickTrace, error) {
 	return toIPCTickTrace(*trace), nil
 }
 
+// TurnDecisions — the arbitration records of the last few turns (V-564). Nil
+// getter means voice was never wired, and that is an empty list rather than an
+// error: a box with no voice path has had no turns to arbitrate, which is not a
+// fault and renders as an empty table.
+func (d *daemonAPI) TurnDecisions(ctx context.Context, n int) ([]ipc.TurnDecision, error) {
+	if d.getDecisions == nil {
+		return nil, nil
+	}
+	return d.getDecisions(n), nil
+}
+
 func (d *daemonAPI) MorningStatus(ctx context.Context) ([]ipc.MorningRoutineStatus, error) {
 	if d.getMorningStatus == nil {
 		return nil, errors.New("mavend: morning status not available")

cmd/mavend/topics.go

@@ -9,7 +9,7 @@ import (
 )
 
 // Which subject is this question about — the weather, the house, the LAN, what
-// needs looking at, or none of them. Third of the three mechanisms replacing hand-written Russian
+// needs looking at, his feeds, or none of them. Third of the three mechanisms replacing hand-written Russian
 // patterns (Vikunja #522, owner's call 2026-08-04). internal/lexicon holds the
 // sets that can be finished and internal/morph answers the grammar questions;
 // this is for the sets that can never be finished, because "is this about the
@@ -37,6 +37,11 @@ import (
 // внимания", which is Praxis's operational state and reached the web search
 // before the source existed (Vikunja #475).
 //
+// A fifth joined on 05-08-2026: the feeds, "что нового в лентах". Its word lists
+// were the last pair of hand-written Russian stem lists in the router (V-522),
+// and they carried the same admission in their own comments — vagueNouns exists
+// because "что нового?" is a greeting that matched a feed noun.
+//
 // The regexes stay as the offline floor, unchanged, for a handler with no
 // embedder or a turn whose vector never got computed. They are allowed to remain
 // narrow now precisely because they are no longer the only answer.
@@ -52,6 +57,9 @@ const (
 	topicHome    topicLabel = "home"
 	topicNetwork topicLabel = "network"
 	topicAttend  topicLabel = "attention"
+	topicFeed    topicLabel = "feeds"
+	topicList    topicLabel = "list"
+	topicSelf    topicLabel = "self"
 	topicOther   topicLabel = "other"
 )
 
@@ -117,7 +125,56 @@ var topicSeedSets = map[topicLabel][]string{
 		"what needs attention",
 		"what needs looking at right now",
 	},
+	topicFeed: {
+		"что нового в лентах",
+		"какие новости",
+		"что нового по технологиям",
+		"почитай заголовки",
+		// Two seeds carrying a day word beside the headlines. Without them
+		// "какие сегодня заголовки" read as weather, because "какая сегодня
+		// погода" is the nearest thing in the whole set with "сегодня" in it.
+		"заголовки за сегодня",
+		"какие главные новости за день",
+		"покажи новости за сегодня",
+		"что пишут в новостях",
+		"что нового про политику",
+		"расскажи что нового в ленте",
+		"what is new in the feeds",
+		"any news headlines today",
+	},
+	// Reading a standing list back, and only that. Adding to one and clearing
+	// one stay on the phrase tables in internal/router/list.go — see its header
+	// for why a span and a delete are not seed-shaped work.
+	topicList: {
+		"что в списке покупок",
+		"что мне нужно купить",
+		"прочитай список покупок",
+		"покажи что в списке",
+		"что осталось купить в магазине",
+		"что мне нужно в аптеке",
+		"какой у меня список покупок",
+		"what is on my shopping list",
+		"read me the grocery list",
+	},
+	// Questions about her (Vikunja #555). The set lives in self.go beside the
+	// description it unlocks, so the two are edited together — a seed claiming
+	// a question the description does not answer is the failure mode.
+	//
+	// "что ты умеешь" was a topicOther seed until this existed, put there so an
+	// attention question had something to lose to. It is a self seed now, and
+	// it cannot be both: a phrasing on two sides never clears the margin.
+	topicSelf: selfSeeds,
 	topicOther: {
+		// A task question is not a list read-back. They collide on "что у меня",
+		// and the list has its own table to lose to as well.
+		"какие у меня задачи",
+		"что у меня в делах",
+		// The bare newness opener, which is a greeting and not a request for
+		// headlines. It sits here on purpose: it is close enough to the feed
+		// seeds that it will not clear topicMargin, and a thin call goes to
+		// ParseFeedQuery, which declines a vague noun with no topic beside it.
+		"что нового",
+		"как дела",
 		// Complaints, which are not requests to scan or to read the house.
 		// isNetworkQuery's comment names this one: a scan she runs unasked is
 		// the noisy behaviour the bounds exist to prevent.
@@ -137,9 +194,40 @@ var topicSeedSets = map[topicLabel][]string{
 		"что я говорил про бэкапы",
 		"что у меня сегодня по календарю",
 		"напомни мне позвонить маме",
-		// An attention question is about the state of his things; this is not.
-		"что ты умеешь",
 		"what did i say about backups",
+		// World questions that name a day (Vikunja #553). Weather was the only
+		// topic whose seeds carry a day word — four of its eight do — so every
+		// "какой сегодня X" landed nearest it and cleared the margin: the
+		// dollar rate by 0.0220 and a public holiday by 0.0398, against 0.0883
+		// for a real weather question. The gate then asked "для какого города?"
+		// about the dollar.
+		//
+		// The margin was not the knob. 0.0398 is not a coin flip, and raising
+		// the bar far enough to catch it would take real weather questions with
+		// it. What was missing is the negative class: a day word means the
+		// question is about a day, and says nothing about whether it is about
+		// the sky.
+		"сколько стоит биткоин сегодня",
+		"какой завтра праздник в стране",
+		"во сколько сегодня восход солнца",
+		"кто вчера победил в чемпионате",
+		// The frame itself, twice. "какая сегодня погода" is a weather seed,
+		// and the four above did not move "какой сегодня курс доллара" or
+		// "что интересного произошло сегодня в мире" off weather, because what
+		// pulls them is the frame and not the noun. A frame that both topics
+		// use has to sit on both sides, or the side that owns it wins every
+		// noun it has never seen.
+		"какой сегодня курс валют",
+		"что сегодня происходит в мире",
+		// The same story one topic over, found while verifying V-554 on the
+		// box: "кто изобрёл телефон" ran a LAN scan and answered "нашла 3
+		// устройства". The network set opens with "кто в сети сейчас" and
+		// names devices throughout, so a "кто ..." question about any device
+		// noun landed there. A device has a history, and asking about it is
+		// not asking what is plugged in.
+		"кто изобрёл телефон",
+		"когда появился первый компьютер",
+		"как работает роутер",
 	},
 }
 
@@ -201,6 +289,35 @@ func (x *topicIndex) best(vec []float32) (label topicLabel, margin float64, ok b
 	return label, first - second, true
 }
 
+// turnVector returns the turn's query vector, computing it on first ask and
+// caching it on the turn.
+//
+// It exists because every topic source sits ABOVE the "embed" source in
+// querySources, and that source was the only thing that ever set t.vec. So
+// turnIsAbout was reading an empty vector on every deployed turn, best returned
+// ok=false, and all six recognisers ran on their keyword floors — the seeds
+// decided nothing outside the tests, which embed the utterance themselves and
+// call best directly. Found on the box on 05-08-2026: "что мне нужно купить" was
+// answered from an old note, and the seeds place it as the list by 0.0841.
+//
+// Computing here rather than moving the embed source up: the cost is paid by the
+// turns that ask, the cache means queryEmbed below reuses this one, and the
+// order of querySources stays what its comments argue for.
+func (h *reactiveHandler) turnVector(ctx context.Context, t *queryTurn) []float32 {
+	if len(t.vec) > 0 || h.recall.embedder == nil {
+		return t.vec
+	}
+	vec, err := router.EmbedQuery(ctx, h.recall.embedder, t.dec.Utterance)
+	if err != nil {
+		// The floor answers. A topic source is not the place to fail a turn:
+		// the recall sources below hit the same embedder and report it there.
+		log.Printf("voice: topic vector for %q: %v", t.dec.Utterance, err)
+		return nil
+	}
+	t.vec = vec
+	return vec
+}
+
 // turnIsAbout — the recogniser every topic source calls. The seeds decide when
 // the embedder is there, which is every deployed box; floor is the source's own
 // keyword test, which answers when they are not.
@@ -213,7 +330,7 @@ func (x *topicIndex) best(vec []float32) (label topicLabel, margin float64, ok b
 // network by 0.0055; isNetworkQuery says no, so it stays the complaint it is.
 func (h *reactiveHandler) turnIsAbout(ctx context.Context, t *queryTurn, want topicLabel, floor func(string) bool) bool {
 	h.recall.topics.load(ctx, h.recall.embedder)
-	label, margin, ok := h.recall.topics.best(t.vec)
+	label, margin, ok := h.recall.topics.best(h.turnVector(ctx, t))
 	if !ok {
 		return floor(t.dec.Utterance)
 	}

cmd/mavend/topics_test.go

@@ -25,6 +25,8 @@ func TestTopicFloorAnswersWithoutSeeds(t *testing.T) {
 		{"что включено в доме?", topicHome, isHomeQuery, true},
 		{"какие устройства в сети?", topicNetwork, isNetworkQuery, true},
 		{"что требует внимания?", topicAttend, isAttentionQuery, true},
+		{"что нового в лентах?", topicFeed, feedFloor, true},
+		{"что в списке покупок?", topicList, listFloor, true},
 		{"почему небо синее", topicWeather, isWeatherQuery, false},
 		{"я дома", topicHome, isHomeQuery, false},
 		{"интернет не работает", topicNetwork, isNetworkQuery, false},
@@ -86,6 +88,50 @@ func TestONNXTopics(t *testing.T) {
 		{"что требует моего внимания сейчас", topicAttend, isAttentionQuery},
 		{"что не так с базой данных", topicAttend, isAttentionQuery},
 		{"есть что-то срочное на сегодня", topicAttend, isAttentionQuery},
+		{"что нового в ленте за сегодня", topicFeed, feedFloor},
+		{"какие сегодня заголовки", topicFeed, feedFloor},
+		{"что нового про искусственный интеллект", topicFeed, feedFloor},
+		// The greeting. It has to lose to topicOther, or fall thin enough that
+		// ParseFeedQuery — which declines a vague noun with no topic — answers.
+		{"что нового?", topicOther, feedFloor},
+		{"что мне надо купить в магазине", topicList, listFloor},
+		{"прочитай мне список", topicList, listFloor},
+		{"что там в аптеке нужно взять", topicList, listFloor},
+		// A task read-back is not a list read-back, and the two collide on
+		// "что у меня".
+		{"какие у меня сейчас задачи", topicOther, listFloor},
+		// World questions that name a day (Vikunja #553). Weather was the only
+		// topic carrying day words, so all of these read as weather and two of
+		// them cleared the margin: the gate asked "для какого города?" about
+		// the dollar. The last two are far from any seed on purpose — the
+		// first three are close enough to the new topicOther seeds that they
+		// would pass on similarity alone.
+		{"какой сегодня курс доллара", topicOther, isWeatherQuery},
+		{"какой сегодня праздник", topicOther, isWeatherQuery},
+		{"что интересного произошло сегодня в мире", topicOther, isWeatherQuery},
+		{"во сколько завтра открывается музей", topicOther, isWeatherQuery},
+		{"кто сегодня играет в лиге чемпионов", topicOther, isWeatherQuery},
+		// The control the seeds above must not cost: real weather still reads
+		// as weather, including the two that lean on the keyword floor.
+		{"будет ли завтра дождь в москве", topicWeather, isWeatherQuery},
+		{"какая температура завтра утром", topicWeather, isWeatherQuery},
+		// The same shape one topic over, seen on the box (Vikunja #554): a
+		// device has a history, and asking about it is not asking what is
+		// plugged in. "кто изобрёл телефон" answered "нашла 3 устройства".
+		// Held out from the seeds, which name the telephone and the computer.
+		{"кто придумал радио", topicOther, isNetworkQuery},
+		{"когда изобрели телевизор", topicOther, isNetworkQuery},
+		{"как устроен телефон внутри", topicOther, isNetworkQuery},
+		// The control: a real scan is still a scan.
+		{"какие устройства подключены к вайфаю", topicNetwork, isNetworkQuery},
+		// Questions about her (Vikunja #555), held out from selfSeeds.
+		{"а что ты вообще умеешь делать", topicSelf, selfFloor},
+		{"какие у тебя навыки", topicSelf, selfFloor},
+		{"расскажи мне о себе", topicSelf, selfFloor},
+		{"what are you able to do", topicSelf, selfFloor},
+		// The control: an attention question is about the state of his things,
+		// and it is the neighbour these seeds could have taken.
+		{"что требует внимания у меня в сервисах", topicAttend, isAttentionQuery},
 	}
 
 	h := &reactiveHandler{recall: recallWiring{embedder: emb}}

cmd/mavend/turnrole.go

@@ -0,0 +1,322 @@
+package main
+
+import (
+	"strings"
+	"unicode"
+
+	"github.com/kami/maven/internal/dialogue"
+	"github.com/kami/maven/internal/lexicon"
+	"github.com/kami/maven/internal/router"
+)
+
+// turnRole — what this utterance IS, relative to the action Maven is in the
+// middle of assembling. The five roles are the owner's vocabulary (Vikunja
+// #558), plus the sixth answer a resolver is allowed to give: not_applicable,
+// which hands the turn back to generic dispatch.
+//
+// It exists because the arbitration used to be ordering. The clarify resolver,
+// the confirm gate, the follow-up merge and the repair marker all ran BEFORE
+// the router, so the claimant holding conversational state decided what an
+// utterance was without asking the one component whose job that is — and on
+// 2026-08-05 "какая сейчас погода в Риме?" became the time of a reminder,
+// because the extractor found "сейчас" in it and nothing looked at the rest.
+//
+// The rule that fixes that: a routed decision which stands on its own — its own
+// intent, its own slots filled from its own words — is not an answer, whatever
+// the extractor found inside it.
+type turnRole string
+
+const (
+	roleAnswer        turnRole = "answer"         // it fills the slot she asked about
+	roleCorrection    turnRole = "correction"     // it replaces a value she already had
+	roleSideQuery     turnRole = "side_query"     // a question of its own, asked mid-flow
+	roleNewRequest    turnRole = "new_request"    // a different request entirely
+	roleAside         turnRole = "aside"          // something he stated, not an answer
+	roleCancel        turnRole = "cancel"         // call the pending action off
+	roleNotApplicable turnRole = "not_applicable" // nothing is pending; not our turn
+)
+
+// frameWords — the words that can stand around a bare slot value without adding
+// a request. Every member is a closed class from internal/lexicon: the frame
+// itself, the interrogatives, the parts of a spoken clock, the days and the
+// months. Assembled once; the sets are copies, so this cannot edit them.
+var frameWords = buildFrameWords()
+
+func buildFrameWords() map[string]bool {
+	out := make(map[string]bool)
+	add := func(list []string) {
+		for _, w := range list {
+			out[strings.ToLower(w)] = true
+		}
+	}
+	add(lexicon.SlotValueFrame())
+	add(lexicon.Interrogatives())
+	add(lexicon.PartsOfDay())
+	add(lexicon.HalfHourWords())
+	add(lexicon.DayOffsetWords())
+	for i := 0; i < 7; i++ {
+		out[lexicon.Weekday(i)] = true
+	}
+	for m := 1; m <= 12; m++ {
+		out[lexicon.MonthGenitive(m)] = true
+	}
+	for hh := 0; hh <= 23; hh++ {
+		add(strings.Fields(lexicon.HourSpoken(hh)))
+	}
+	return out
+}
+
+// cancelWords — the same, for the words that call the pending action off.
+var cancelWords = buildCancelWords()
+
+func buildCancelWords() map[string]bool {
+	out := make(map[string]bool)
+	for _, w := range lexicon.DialogueCancel() {
+		out[strings.ToLower(w)] = true
+	}
+	return out
+}
+
+// turnTokens splits an utterance the way the router's own predicates do: over
+// letters and digits, lowercased, so punctuation and a clock's colon fall out.
+func turnTokens(text string) []string {
+	return strings.FieldsFunc(strings.ToLower(text), func(r rune) bool {
+		return !unicode.IsLetter(r) && !unicode.IsDigit(r)
+	})
+}
+
+// ownContent lists the tokens of an utterance that are neither frame nor value:
+// what it is about, over and above the thing she asked for. Numbers go out
+// because a number is the commonest slot value there is, and the closed number
+// and day lexicons go out with them.
+//
+// Empty ⇒ the utterance is a slot value and nothing else, however it is dressed
+// up. That is the whole test, and it is what separates "а что если в 11:00" —
+// which is a time, hedged — from "какая сейчас погода в Риме?", which leaves
+// "погода" and "риме" behind and is therefore about something.
+func ownContent(text string) []string {
+	var out []string
+	for _, tok := range turnTokens(text) {
+		if frameWords[tok] || lexicon.IsFillerParticle(tok) {
+			continue
+		}
+		if _, ok := lexicon.Cardinal(tok); ok {
+			continue
+		}
+		if _, ok := lexicon.Ordinal(tok); ok {
+			continue
+		}
+		if isNumeric(tok) {
+			continue
+		}
+		out = append(out, tok)
+	}
+	return out
+}
+
+func isNumeric(tok string) bool {
+	for _, r := range tok {
+		if !unicode.IsDigit(r) {
+			return false
+		}
+	}
+	return tok != ""
+}
+
+// isCancel reports whether the utterance is nothing but a call-off. Every
+// content token has to be a cancel word, so "забудь" ends the exchange and
+// "забудь купить молоко" does not.
+func isCancel(text string) bool {
+	content := ownContent(text)
+	if len(content) == 0 {
+		return false
+	}
+	for _, tok := range content {
+		if !cancelWords[tok] {
+			return false
+		}
+	}
+	return true
+}
+
+// carriesOwnRequest reads the ROUTED decision for the thing that decides this:
+// does the utterance ask for something in its own right? Each intent is asked
+// the question in its own terms, because "its own slots filled from its own
+// words" means a different field for each of them.
+//
+// A query or a system question needs no further evidence — the router already
+// read a question in these words. The write intents need the verb or the slot
+// that names the request, so a bare value the router guessed a home for does
+// not count as one.
+func carriesOwnRequest(dec router.Decision, text string) bool {
+	if dec.Clarify {
+		// The router itself was unsure. An utterance she could not route is
+		// not an utterance that outranks the question in front of it.
+		return false
+	}
+	switch dec.Intent {
+	case router.IntentQuery, router.IntentSystem:
+		return true
+	case router.IntentReminder:
+		return carriesReminderVerb(text)
+	case router.IntentFact, router.IntentNote:
+		return router.CarriesCaptureVerb(text)
+	case router.IntentAct:
+		// An act that resolved to a capability is a command. One that did not
+		// is words she cannot execute anyway, so it stays an answer and gets
+		// re-asked — the same thing that happens to it today.
+		return dec.Slots.HasFn
+	default: // chat
+		return false
+	}
+}
+
+// carriesReminderVerb — "напомни" and its forms, matched over tokens. The
+// reminder verbs are a closed lexicon and are not capture verbs, so
+// CarriesCaptureVerb never sees them.
+func carriesReminderVerb(text string) bool {
+	toks := turnTokens(text)
+	for _, v := range lexicon.ReminderVerbs() {
+		for _, t := range toks {
+			if t == strings.ToLower(v) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// offlineOwnRequest is the shape half of the evidence: the offline token tests,
+// which cost nothing and never depend on the model that produced the routing.
+// It is also the whole answer when there is no route to read — the classifier
+// is the failure floor and a turn must never break on the model.
+func offlineOwnRequest(text string) bool {
+	return router.IsQuestionShaped(text) || router.CarriesCaptureVerb(text) || carriesReminderVerb(text)
+}
+
+// classifyTurnRole decides what this utterance is against the pending action.
+//
+// The fast path is the first line and it is a fast path to the SAME answer, not
+// a second decision procedure: an utterance with no content of its own can
+// never be a request of its own, so it can never be anything but an answer, and
+// the route below would spend a second on the resident model to say so. Every
+// other utterance is routed first, and the role is read off the decision.
+//
+// `routed` is the turn's routing, already computed; ok is false when there was
+// none to compute (no router wired, or the route failed). A failed route falls
+// to the offline shape tests rather than breaking the turn.
+func classifyTurnRole(q *dialogue.PendingQuestion, text string, answer dialogue.Slots, routed router.Decision, ok bool) turnRole {
+	if isCancel(text) {
+		return roleCancel
+	}
+	// Two pieces of evidence, and the content gate in front of both. The shape
+	// tests are the floor and answer for free; the route is what sees a request
+	// with no shape to it — "погода в риме" asks a question and carries neither
+	// a question mark nor an interrogative, and only the router knows that.
+	//
+	// An utterance of pure frame gets one more chance, and V-577 is why. Every
+	// token of "что у меня сегодня?" is frame, so the content gate called it an
+	// answer, the parked reminder took "сегодня" for its time, and the question
+	// he asked was answered nowhere. A routed intent beats a frame match,
+	// because the frame is a hint and the route is a decision.
+	//
+	// The condition is that it fills nothing she asked about. That keeps the
+	// hedged "а что если в 11:00" an answer, which is what it is: it carries the
+	// hour, and no route saying "question" changes that. It works because the
+	// extractor no longer reads a day word as the current clock, so a sentence
+	// that names no hour now fills nothing to weigh.
+	own := false
+	if len(ownContent(text)) > 0 {
+		own = offlineOwnRequest(text) || (ok && carriesOwnRequest(routed, text))
+	} else if ok && fillsNothingAsked(q, answer) {
+		own = carriesOwnRequest(routed, text)
+	}
+	if !own {
+		if isAside(q, text, answer, routed, ok) {
+			return roleAside
+		}
+		if replacesFilledSlot(q, answer) {
+			return roleCorrection
+		}
+		return roleAnswer
+	}
+	if router.IsQuestionShaped(text) || (ok && (routed.Intent == router.IntentQuery || routed.Intent == router.IntentSystem)) {
+		return roleSideQuery
+	}
+	return roleNewRequest
+}
+
+// isAside reports whether the utterance is something he STATED while she was
+// waiting on a question (V-577 shape 2).
+//
+// "у меня новый ноутбук" said into a parked reminder was dropped in silence: it
+// carries no capture verb, so it is not a request of its own, and it fills no
+// slot, so it is not an answer either. Neither storing it nor saying it was
+// ignored is the one behaviour that is wrong, and it was the behaviour.
+//
+// Three conditions, and all three are needed. The route has to call it a
+// statement AND stand behind that, so a bare time is never an aside. It has to
+// fill none of what she asked about, so an answer she can use stays an answer.
+// And it has to say something, so a shrug is still a failed answer and still
+// spends a retry.
+func isAside(q *dialogue.PendingQuestion, text string, answer dialogue.Slots, routed router.Decision, ok bool) bool {
+	if !ok || q == nil {
+		return false
+	}
+	if !statesSomething(routed) {
+		return false
+	}
+	if len(ownContent(text)) == 0 {
+		return false
+	}
+	return fillsNothingAsked(q, answer)
+}
+
+// statesSomething reports whether the route is evidence that these words state
+// a thing, rather than a guess she has to interrupt a flow over.
+//
+// Two kinds of evidence, and the second one exists because the classifier floor
+// marks nearly everything Clarify. A parsed fact key comes from the
+// deterministic fact parser and not from a similarity score, so "я выпил воды"
+// is a statement on any engine. A confident note or fact is the other kind, and
+// that is the one the resident model gives for "у меня новый ноутбук".
+func statesSomething(routed router.Decision) bool {
+	switch routed.Intent {
+	case router.IntentFact:
+		return routed.Slots.HasKey || !routed.Clarify
+	case router.IntentNote:
+		return !routed.Clarify
+	}
+	return false
+}
+
+// fillsNothingAsked reports whether the utterance gave her none of what she
+// asked for. Nothing is pending counts as nothing filled.
+func fillsNothingAsked(q *dialogue.PendingQuestion, answer dialogue.Slots) bool {
+	if q == nil {
+		return true
+	}
+	return len(dialogue.StillMissing(q.Missing, answer)) == len(q.Missing)
+}
+
+// replacesFilledSlot reports whether the utterance overwrites something the
+// pending action already had, rather than filling the gap she asked about —
+// "нет, на девять" while she is waiting for the subject. Both are handled the
+// same way (dialogue.Answer already prefers the newer value), so this only
+// names the turn honestly for the log and for the decision trace V-564 adds.
+func replacesFilledSlot(q *dialogue.PendingQuestion, answer dialogue.Slots) bool {
+	if q == nil {
+		return false
+	}
+	asked := make(map[dialogue.Slot]bool, len(q.Missing))
+	for _, s := range q.Missing {
+		asked[s] = true
+	}
+	if answer.HasTime && q.Slots.HasTime && !asked[dialogue.SlotTime] && !answer.Time.Equal(q.Slots.Time) {
+		return true
+	}
+	if answer.HasKey && q.Slots.HasKey && !asked[dialogue.SlotKey] && answer.Key != q.Slots.Key {
+		return true
+	}
+	return false
+}

cmd/mavend/turnrole_test.go

@@ -0,0 +1,281 @@
+package main
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/kami/maven/internal/dialogue"
+	"github.com/kami/maven/internal/router"
+)
+
+// TestOwnContentSeparatesAValueFromAQuestion pins the test the whole role
+// classifier rests on: after the frame, the numbers and the closed time sets
+// come out, does anything of his own remain? A hedged time leaves nothing. A
+// question about the weather leaves the weather.
+func TestOwnContentSeparatesAValueFromAQuestion(t *testing.T) {
+	cases := []struct {
+		text string
+		own  bool
+	}{
+		{"в 11:00", false},
+		{"в семь вечера", false},
+		{"нет, в 15:00", false},
+		{"а что если в 11:00", false},
+		{"на 9", false},
+		{"а, да, прости — на 9", false},
+		{"завтра", false},
+		{"в половине восьмого", false},
+		{"какая сейчас погода в Риме?", true},
+		{"кто изобрёл телефон", true},
+		{"напомни в 11:00", true},
+		{"позвонить маме", true},
+		{"запиши что я пил воду", true},
+	}
+	for _, tc := range cases {
+		if got := len(ownContent(tc.text)) > 0; got != tc.own {
+			t.Errorf("ownContent(%q) = %v, want own content = %v", tc.text, ownContent(tc.text), tc.own)
+		}
+	}
+}
+
+// TestCancelIsTheWholeUtterance — a call-off calls the request off, and a
+// sentence that merely contains the word does not.
+func TestCancelIsTheWholeUtterance(t *testing.T) {
+	for _, yes := range []string{"отмена", "забудь", "неважно", "проехали", "cancel", "ой, отмена"} {
+		if !isCancel(yes) {
+			t.Errorf("isCancel(%q) = false, want true", yes)
+		}
+	}
+	for _, no := range []string{"забудь купить молоко", "в 11:00", "позвонить маме", ""} {
+		if isCancel(no) {
+			t.Errorf("isCancel(%q) = true, want false", no)
+		}
+	}
+}
+
+// TestTurnRoleReadsTheRoutedDecision — the inversion itself. The same utterance
+// gets a different role depending on what the router made of it, which is the
+// evidence the old guard never had.
+func TestTurnRoleReadsTheRoutedDecision(t *testing.T) {
+	q := &dialogue.PendingQuestion{
+		Intent:  dialogue.Intent(router.IntentReminder),
+		Missing: []dialogue.Slot{dialogue.SlotTime},
+	}
+	dec := func(in router.Intent, s router.Slots) router.Decision {
+		return router.Decision{Intent: in, Slots: s}
+	}
+	cases := []struct {
+		name   string
+		text   string
+		routed router.Decision
+		ok     bool
+		answer dialogue.Slots
+		want   turnRole
+	}{
+		{
+			// The measured defect. The extractor finds "сейчас" and would have
+			// closed the gap with it; the route says this is a question of its
+			// own, and the question wins.
+			name:   "a world question mid-flow is a side query",
+			text:   "какая сейчас погода в Риме?",
+			routed: dec(router.IntentQuery, router.Slots{Text: "какая сейчас погода в Риме?"}),
+			ok:     true,
+			answer: dialogue.Slots{HasTime: true, Time: time.Now()},
+			want:   roleSideQuery,
+		},
+		{
+			name:   "a hedged time is an answer even routed as a query",
+			text:   "а что если в 11:00",
+			routed: dec(router.IntentQuery, router.Slots{Text: "а что если в 11:00"}),
+			ok:     true,
+			answer: dialogue.Slots{HasTime: true, Time: time.Now()},
+			want:   roleAnswer,
+		},
+		{
+			name:   "a fresh reminder is a new request",
+			text:   "напомни завтра позвонить маме",
+			routed: dec(router.IntentReminder, router.Slots{Text: "позвонить маме", HasTime: true}),
+			ok:     true,
+			want:   roleNewRequest,
+		},
+		{
+			name:   "a capture is a new request",
+			text:   "запиши что я пил воду",
+			routed: dec(router.IntentFact, router.Slots{Key: "water", HasKey: true}),
+			ok:     true,
+			want:   roleNewRequest,
+		},
+		{
+			name:   "an act that resolved to a capability is a new request",
+			text:   "выключи свет в спальне",
+			routed: dec(router.IntentAct, router.Slots{Fn: "light_off", HasFn: true}),
+			ok:     true,
+			want:   roleNewRequest,
+		},
+		{
+			// She could not route it. An utterance she did not understand does
+			// not outrank the question in front of it.
+			name:   "a clarify decision is not a request of its own",
+			text:   "выключи свет",
+			routed: router.Decision{Intent: router.IntentAct, Slots: router.Slots{Fn: "light_off", HasFn: true}, Clarify: true},
+			ok:     true,
+			want:   roleAnswer,
+		},
+		{
+			// V-577 shape 1. Every token is frame, so the content gate called
+			// this an answer and the reminder took "сегодня" for its time. It
+			// fills nothing she asked about, so the route decides, and the route
+			// says the calendar answers it.
+			name:   "an agenda question of pure frame words is a side query",
+			text:   "что у меня сегодня?",
+			routed: dec(router.IntentQuery, router.Slots{}),
+			ok:     true,
+			want:   roleSideQuery,
+		},
+		{
+			// V-577 shape 2. Neither a slot value nor a request nor a cancel.
+			// It was dropped in silence; it is an aside, and an aside is stored
+			// and re-asked.
+			name:   "a fact stated mid-flow is an aside",
+			text:   "у меня новый ноутбук",
+			routed: dec(router.IntentNote, router.Slots{Text: "у меня новый ноутбук"}),
+			ok:     true,
+			want:   roleAside,
+		},
+		{
+			// A route she is not sure of is not evidence that he stated
+			// anything, and "позвонить маме" is the answer to the other half of
+			// a reminder.
+			name:   "an unsure note is not an aside",
+			text:   "позвонить маме",
+			routed: router.Decision{Intent: router.IntentNote, Clarify: true},
+			ok:     true,
+			want:   roleAnswer,
+		},
+		{
+			name: "a bare noun that answers nothing is still an answer",
+			text: "ага",
+			ok:   false,
+			want: roleAnswer,
+		},
+		{
+			name: "no route to read falls back to the shape",
+			text: "кто изобрёл телефон",
+			ok:   false,
+			want: roleSideQuery,
+		},
+		{
+			name: "a call-off needs no route at all",
+			text: "отмена",
+			ok:   false,
+			want: roleCancel,
+		},
+	}
+	for _, tc := range cases {
+		if got := classifyTurnRole(q, tc.text, tc.answer, tc.routed, tc.ok); got != tc.want {
+			t.Errorf("%s: classifyTurnRole(%q) = %s, want %s", tc.name, tc.text, got, tc.want)
+		}
+	}
+}
+
+// TestTurnRoleNamesACorrection — the answer overwrites a slot she was not
+// asking about. Handled like an answer, named as what it is.
+func TestTurnRoleNamesACorrection(t *testing.T) {
+	nine := time.Date(2026, 8, 6, 9, 0, 0, 0, time.UTC)
+	q := &dialogue.PendingQuestion{
+		Intent:  dialogue.Intent(router.IntentReminder),
+		Missing: []dialogue.Slot{dialogue.SlotText},
+		Slots:   dialogue.Slots{HasTime: true, Time: nine.Add(2 * time.Hour)},
+	}
+	got := classifyTurnRole(q, "нет, на 9", dialogue.Slots{HasTime: true, Time: nine}, router.Decision{}, false)
+	if got != roleCorrection {
+		t.Fatalf("role = %s, want %s", got, roleCorrection)
+	}
+}
+
+// TestRomeIsAnsweredAndTheReminderIsNotInvented — the measured failure of
+// 2026-08-05, end to end through the real cascade. "напомни позвонить маме"
+// parks the time question; the weather question that follows must not become
+// its answer and must not create a reminder for a time nobody asked for.
+//
+// V-560 got that far by DROPPING the parked request and saying so, and the
+// owner rejected the notice on sight: he did not ask to lose the reminder. So
+// the contract here is V-561's — the flow is suspended, this turn's reply ends
+// with the question coming back, and nothing says anything was let go.
+func TestRomeIsAnsweredAndTheReminderIsNotInvented(t *testing.T) {
+	ctx := context.Background()
+	h, st := newRoutingClarifyHandler(t)
+
+	if reply := h.handleText(ctx, "web", "напомни позвонить маме"); !strings.Contains(reply, "?") {
+		t.Fatalf("expected the time question, got %q", reply)
+	}
+	reply := h.handleText(ctx, "web", "какая сейчас погода в Риме?")
+	if strings.Contains(reply, "напомню") {
+		t.Fatalf("the question was eaten as the reminder's time again: %q", reply)
+	}
+	if strings.Contains(reply, clarifyDropped) {
+		t.Fatalf("a side query suspends the flow; nothing was dropped, so nothing may say so: %q", reply)
+	}
+	resumed, _ := clarifyResumedFor(dialogue.SlotTime)
+	if !strings.HasSuffix(reply, resumed) {
+		t.Fatalf("the reply must end with the resumed question %q, got %q", resumed, reply)
+	}
+	if reminders, err := st.DueReminders(ctx, h.now().Add(48*time.Hour)); err != nil || len(reminders) != 0 {
+		t.Fatalf("a reminder was invented for a time nobody asked for: %v err=%v", reminders, err)
+	}
+	// Still parked, and still on its first attempt: he answered the side query,
+	// not this question, so no retry may have been spent on it.
+	q := h.clarifyStore.Get(dialogueIDFor(sourceText, "web"), h.now())
+	if q == nil {
+		t.Fatal("the parked question was dropped instead of suspended")
+	}
+	if q.Attempts != 1 {
+		t.Fatalf("the side query spent a clarify attempt: attempts = %d, want 1", q.Attempts)
+	}
+	if !strings.Contains(q.Utterance, "маме") {
+		t.Fatalf("the suspended request lost what it was about: %q", q.Utterance)
+	}
+}
+
+// TestClarifyCancelEndsTheExchange — "отмена" while she is waiting calls the
+// half-built request off, out loud, and creates nothing.
+func TestClarifyCancelEndsTheExchange(t *testing.T) {
+	ctx := context.Background()
+	h, st := newRoutingClarifyHandler(t)
+
+	if reply := h.handleText(ctx, "web", "напомни позвонить маме"); !strings.Contains(reply, "?") {
+		t.Fatalf("expected the time question, got %q", reply)
+	}
+	if reply := h.handleText(ctx, "web", "отмена"); reply != clarifyCancelled {
+		t.Fatalf("reply = %q, want %q", reply, clarifyCancelled)
+	}
+	if reminders, err := st.DueReminders(ctx, h.now().Add(48*time.Hour)); err != nil || len(reminders) != 0 {
+		t.Fatalf("a cancelled request still landed: %v err=%v", reminders, err)
+	}
+	if h.clarifyStore.Get(dialogueIDFor(sourceText, "web"), h.now()) != nil {
+		t.Fatal("a cancelled exchange must leave nothing parked")
+	}
+}
+
+// TestTheTurnIsRoutedOnce — the cost bound. A turn with a question parked pays
+// for one extra route and not two: the clarify resolver and the pipeline read
+// the same memo.
+func TestTheTurnIsRoutedOnce(t *testing.T) {
+	h, _ := newRoutingClarifyHandler(t)
+	rt := h.newTurnRoute("какая сейчас погода в Риме?", h.now())
+	ctx := withTurnRoute(withDialogueID(context.Background(), voiceDialogueID), rt)
+
+	first, ok := h.routeForRole(ctx, rt.text)
+	if !ok {
+		t.Fatal("the cascade must produce a decision to classify against")
+	}
+	second, _, _, err := rt.resolve(ctx)
+	if err != nil {
+		t.Fatalf("resolve: %v", err)
+	}
+	if second.Intent != first.Intent || second.Utterance != first.Utterance {
+		t.Fatalf("the pipeline routed again and got something else: %+v vs %+v", second, first)
+	}
+}

cmd/mavend/turnroute.go

@@ -0,0 +1,125 @@
+package main
+
+import (
+	"context"
+	"log"
+	"sync"
+	"time"
+
+	"github.com/kami/maven/internal/dialogue"
+	"github.com/kami/maven/internal/router"
+)
+
+// turnRoute is this turn's routing, computed at most once.
+//
+// It exists because the arbitration was inverted (Vikunja #560): the clarify
+// resolver now reads the routed decision before deciding what the utterance is,
+// and the pipeline then acts on that same decision. Routing twice would cost a
+// second on the resident model and — worse — could disagree with itself, which
+// is exactly the class of bug this task is about.
+type turnRoute struct {
+	h    *reactiveHandler
+	text string
+	now  time.Time
+
+	once sync.Once
+	dec  router.Decision
+	cont bool
+	prev *dialogue.Session
+	err  error
+
+	// dropped — what she let go of this turn and must say out loud. A parked
+	// request that dies without a word leaves him thinking it landed.
+	dropped string
+
+	// resume — the parked question, re-worded, to put AFTER this turn's answer
+	// (Vikunja #561). A side query does not end the flow it interrupted, so the
+	// reply carries two acts: the answer he asked for, then the question he
+	// still owes her. Empty ⇒ nothing was suspended.
+	resume string
+	// suspended — a flow is parked underneath this turn. askClarify reads it to
+	// decide between Put (replace the top) and Push (keep the flow and stack the
+	// new question on it), because a side query that needs clarifying of its own
+	// must not overwrite the thing it interrupted.
+	suspended bool
+}
+
+type turnRouteKey struct{}
+
+func (h *reactiveHandler) newTurnRoute(text string, now time.Time) *turnRoute {
+	return &turnRoute{h: h, text: text, now: now}
+}
+
+func withTurnRoute(ctx context.Context, rt *turnRoute) context.Context {
+	return context.WithValue(ctx, turnRouteKey{}, rt)
+}
+
+// turnRouteFrom returns the turn's memo, or nil when the caller is not inside
+// runTurn — a unit test calling one resolver directly, most often.
+func turnRouteFrom(ctx context.Context) *turnRoute {
+	rt, _ := ctx.Value(turnRouteKey{}).(*turnRoute)
+	return rt
+}
+
+// resolve does the routing exactly as step 5 of runTurn does it: an elliptical
+// follow-up is answered from the previous turn, everything else goes to the
+// router. One copy of that, so the pre-route the clarify resolver reads and the
+// decision the pipeline acts on cannot drift apart.
+func (r *turnRoute) resolve(ctx context.Context) (router.Decision, bool, *dialogue.Session, error) {
+	r.once.Do(func() {
+		if r.h.dialogueSessions != nil {
+			r.prev = r.h.dialogueSessions.Get(dialogueIDOf(ctx), r.now)
+		}
+		if dec, cont := continuationDecision(r.prev, r.text, r.now); cont {
+			log.Printf("voice: continuation of %s from the previous turn", dec.Intent)
+			r.dec, r.cont = dec, true
+			return
+		}
+		if r.h.router == nil {
+			r.err = router.ErrNoIntents
+			return
+		}
+		r.dec, r.err = r.h.router.Route(ctx, r.text, r.now)
+	})
+	return r.dec, r.cont, r.prev, r.err
+}
+
+// routeForRole gives the role classifier the turn's routed decision. The second
+// return is false when there is no usable decision — no router wired, or the
+// route failed — and the classifier falls back to its offline tests then. A
+// turn must never break on the model, so the error is logged and swallowed
+// here; step 5 reads the same memo and reports it the way it always has.
+func (h *reactiveHandler) routeForRole(ctx context.Context, text string) (router.Decision, bool) {
+	rt := turnRouteFrom(ctx)
+	if rt == nil {
+		rt = h.newTurnRoute(text, h.now())
+	}
+	dec, _, _, err := rt.resolve(ctx)
+	if err != nil {
+		log.Printf("voice: role — no route to classify against (%v), falling back to the offline tests", err)
+		return router.Decision{}, false
+	}
+	return dec, true
+}
+
+// needsRoute reports whether classifying this utterance's role is worth a
+// route. It is not: an utterance with no content of its own carries no request
+// of its own, so the classifier reaches the same answer without the model. A
+// call-off is the same — it is read off a closed lexicon and nothing else.
+//
+// This is a fast path to the SAME answer and must stay one. If it ever needs a
+// rule the classifier does not have, it has become a second decision procedure
+// and it is the thing V-560 deleted.
+//
+// A question shape is the exception and V-577 is why (measured 2026-08-06).
+// "что у меня сегодня?" is an interrogative, a preposition, a particle and a day
+// word, so every token of it is frame and it left no content of its own. The
+// fast path called it an answer, the parked reminder read "сегодня" as its time,
+// and the question he asked was never answered. Asked alone the same sentence
+// routes to query at stage 0, so the route knew and was never consulted.
+func needsRoute(text string) bool {
+	if isCancel(text) {
+		return false
+	}
+	return len(ownContent(text)) > 0 || router.IsQuestionShaped(text)
+}

cmd/mavend/voice.go

@@ -53,6 +53,7 @@ import (
 
 	"github.com/kami/maven/internal/audio"
 	"github.com/kami/maven/internal/crawl"
+	"github.com/kami/maven/internal/decision"
 	"github.com/kami/maven/internal/dialogue"
 	"github.com/kami/maven/internal/ipc"
 	"github.com/kami/maven/internal/lexicon"
@@ -137,6 +138,13 @@ type reactiveHandler struct {
 	// slot per reach, not one for the box. nil ⇒ no carry-over.
 	dialogueSessions *dialogue.SessionStore
 
+	// decisions holds the last few turns' arbitration records (V-564): who
+	// claimed the turn, who lost it and who was never asked. In memory and
+	// bounded, because a turn record is read minutes later or never, and none
+	// of his words belong in a table that outlives the diagnosis. nil ⇒ nothing
+	// is recorded, which is what a test that did not ask for one gets.
+	decisions *decision.Ring
+
 	// clarifyStore parks the request behind an open question she asked (see
 	// clarify.go). nil ⇒ she falls back to the canned "не поняла" reply.
 	clarifyStore *dialogue.ClarifyStore
@@ -247,7 +255,27 @@ const (
 // path wraps it in stt/tts, the text path returns it as-is.
 //
 // The ordering is load-bearing — see the step comments.
-func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSource) string {
+func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSource) (reply string) {
+	// 0. the decision record (V-564). Installed here rather than in the IPC
+	// entry point, so the mic, telegram and the web all leave the same trail —
+	// a record only the web produced would be missing exactly the turns that
+	// are hardest to reproduce. It rides the context, costs a few dozen structs
+	// on a human-rate path, and no claim site can change a route with it.
+	if h.decisions != nil {
+		var rec *decision.Record
+		ctx, rec = decision.With(ctx, text)
+		decision.Expect(ctx, decision.StagePreRoute, preRouteLadder)
+		defer func() { h.decisions.Push(rec.Finish(h.now())) }()
+	}
+
+	// 0b. the turn's routing, computed at most once and shared (Vikunja #560).
+	// The clarify resolver reads it to decide what this utterance IS before
+	// claiming it, and step 5 acts on the same decision — routing twice would
+	// cost a second on the resident model and could disagree with itself.
+	now := h.now()
+	rt := h.newTurnRoute(text, now)
+	ctx = withTurnRoute(ctx, rt)
+
 	// 1. expired clarify — a question was parked but its TTL ran out, so the
 	// request behind it is gone. Say that out loud (see clarify.go) and carry
 	// on: these words are still routed as a fresh utterance below, with the
@@ -263,7 +291,7 @@ func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSour
 	// 2. confirm turn — if a destructive act is parked, this utterance is its
 	// y/n answer, not a fresh command. Handled before routing so "да" doesn't
 	// get classified as some other intent.
-	if reply, handled := h.resolveConfirm(ctx, text); handled {
+	if reply, handled := h.resolveConfirm(ctx, text); notePreRoute(ctx, "confirm", handled) {
 		return withNotice(expiredNotice, reply)
 	}
 
@@ -275,15 +303,27 @@ func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSour
 	// so the notice is empty here in practice. withNotice anyway: every exit
 	// from runTurn carries it, and that is what stops the next one from
 	// forgetting.
-	if reply, handled := h.resolveClarifyAnswer(ctx, text); handled {
+	if reply, handled := h.resolveClarifyAnswer(ctx, text); notePreRoute(ctx, "clarify-answer", handled) {
 		return withNotice(expiredNotice, reply)
 	}
+	// It did not claim the turn. If it let a parked request go to get out of the
+	// way, that has to be said in front of whatever these words are answered
+	// with — carried on the same notice, so every exit below keeps it.
+	expiredNotice = withNotice(expiredNotice, rt.dropped)
+
+	// 3b. and if it SUSPENDED a request instead of letting it go, the question
+	// comes back on the end of whatever these words are answered with (Vikunja
+	// #561). A deferred append rather than a call at each exit: there are eight
+	// returns between here and the replier, and the flow has to survive all of
+	// them — one that forgot would be a request parked for ever, waiting for an
+	// answer to a question he never heard asked.
+	defer func() { reply = withResumed(reply, rt.resume) }()
 
 	// 4. quiet-hours toggle — keyword match, not classifier-dependent.
 	// "тихий режим" / "quiet on" would route through the classifier
 	// unreliably (it's a command, not a free-form query), so we match it
 	// before routing. Same pattern as the confirm turn above.
-	if reply, handled := h.resolveQuietToggle(ctx, text, src); handled {
+	if reply, handled := h.resolveQuietToggle(ctx, text, src); notePreRoute(ctx, "quiet-toggle", handled) {
 		return withNotice(expiredNotice, reply)
 	}
 
@@ -291,14 +331,14 @@ func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSour
 	// sent. Only handled when a pending nudge is actually inside the window
 	// (snooze.go); otherwise the words route normally, because "потом" is an
 	// ordinary word and eating every one of them would break real sentences.
-	if reply, handled := h.resolveSnooze(ctx, text, src); handled {
+	if reply, handled := h.resolveSnooze(ctx, text, src); notePreRoute(ctx, "snooze", handled) {
 		return withNotice(expiredNotice, reply)
 	}
 
 	// 4c. spoken ack — "готово" closes that same nudge as `acted`. Only the
 	// contentless form is intercepted here; "выпил воды" keeps routing and
 	// closes the nudge after its fact lands (ackFromFact, step 8b).
-	if reply, handled := h.resolveAck(ctx, text, src); handled {
+	if reply, handled := h.resolveAck(ctx, text, src); notePreRoute(ctx, "ack", handled) {
 		return withNotice(expiredNotice, reply)
 	}
 
@@ -306,7 +346,7 @@ func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSour
 	// turn and names what it should have been (repair.go). Before routing,
 	// like the confirm and clarify turns: routing the correction as a fresh
 	// utterance files the correction itself instead of fixing anything.
-	if reply, handled := h.resolveRepair(ctx, text); handled {
+	if reply, handled := h.resolveRepair(ctx, text); notePreRoute(ctx, "repair", handled) {
 		return withNotice(expiredNotice, reply)
 	}
 
@@ -314,7 +354,7 @@ func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSour
 	// just read (ordinal.go). Before routing, and only when a list is actually
 	// bound to the session: with nothing offered, "второй" is an ordinary word
 	// and keeps routing.
-	if reply, handled := h.resolveCandidate(ctx, text, src); handled {
+	if reply, handled := h.resolveCandidate(ctx, text, src); notePreRoute(ctx, "ordinal", handled) {
 		return withNotice(expiredNotice, reply)
 	}
 
@@ -323,22 +363,7 @@ func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSour
 	// missing, so no amount of routing recovers it, and the model's guess
 	// costs seconds to obtain and is close to a coin flip. Everything else
 	// goes to the router.
-	var (
-		dec  router.Decision
-		err  error
-		prev *dialogue.Session
-	)
-	now := h.now()
-	if h.dialogueSessions != nil {
-		prev = h.dialogueSessions.Get(dialogueIDOf(ctx), now)
-	}
-	cont := false
-	if dec, cont = continuationDecision(prev, text, now); cont {
-		log.Printf("voice: continuation of %s from the previous turn", dec.Intent)
-	}
-	if !cont {
-		dec, err = h.router.Route(ctx, text, now)
-	}
+	dec, cont, prev, err := rt.resolve(ctx)
 	if err != nil {
 		// ErrNoIntents ⇒ classifier unseeded (cold boot). reply with a
 		// "still warming up" rather than a wire error.
@@ -359,21 +384,31 @@ func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSour
 	// ("а завтра?" … "а послезавтра?") keeps working.
 	if h.dialogueSessions != nil {
 		if !cont {
-			dec = followUpMerge(prev, dec, now)
+			merged := followUpMerge(prev, dec, now)
+			noteMerge(ctx, dec, merged)
+			dec = merged
 		}
 		if !dec.Clarify {
 			h.rememberTurn(ctx, prev, dec, now)
 		}
 	}
 
-	// 7. clarify — she is not sure. If one named thing is missing, ask about it
-	// and park the request (clarify.go); otherwise the replier's canned reply
-	// stands.
-	if dec.Clarify {
+	// 7. clarify — something she needs is missing. If one named thing is missing,
+	// ask about it and park the request (clarify.go); otherwise the replier's
+	// canned reply stands.
+	//
+	// Not gated on dec.Clarify alone (Vikunja #557). A turn the cascade routed
+	// confidently but incompletely skipped this entirely: "напомни позвонить"
+	// reached applyAction, failed on the missing time, parked nothing, and the
+	// "в семь вечера" that followed was web-searched as a world question. A
+	// required slot that missingFor names is a gap whatever the confidence.
+	if dec.Clarify || len(missingFor(dec)) > 0 {
 		if reply := h.hexisBeforeClarify(ctx, dec); reply != "" {
 			return withNotice(expiredNotice, reply)
 		}
 		if question, asked := h.askClarify(ctx, dec); asked {
+			noteTerminal(ctx, "clarify-ask", dec.Intent,
+				"the route was below the threshold, so she asked instead of acting")
 			return withNotice(expiredNotice, question)
 		}
 	}
@@ -390,6 +425,9 @@ func (h *reactiveHandler) runTurn(ctx context.Context, text string, src turnSour
 	// the round-trip stays alive.
 	replyText := h.applyAction(ctx, dec)
 	log.Printf("voice: applyAction returned: %q", replyText)
+	// A query turn was already claimed by a source inside the chain; every other
+	// intent has no chain and no scoreboard, so the handler is the winner.
+	noteTerminal(ctx, "action-handler", dec.Intent, "")
 
 	// 8b. a fact that answers a live nudge closes it as `acted` (ack.go).
 	// Silent: the fact reply stands, she does not congratulate him for it.
@@ -490,6 +528,17 @@ func (h *reactiveHandler) replySystem(ctx context.Context, dec router.Decision)
 	}
 }
 
+// sessionAsTurn projects a stored session onto the dialogue.Turn shape used in
+// history lists. Shared by chatHistory and rememberTurn (clarify.go) so the
+// same session is described the same way in both places.
+func sessionAsTurn(s *dialogue.Session) dialogue.Turn {
+	return dialogue.Turn{
+		Intent: s.Intent,
+		Slots:  s.Slots,
+		Text:   s.Slots.Text,
+	}
+}
+
 // chatHistory collects dialogue turns from the session store for the current
 // conversation. Returns prior user utterances (newest last) up to a depth of
 // 4 turns. Returns nil when there's no session or no history.
@@ -503,13 +552,9 @@ func (h *reactiveHandler) chatHistory(ctx context.Context) []dialogue.Turn {
 		return nil
 	}
 	// History already includes the immediate prior turn (set by the dialogue
-	// merge at lines 373-395), plus up to 3 more from deeper history.
+	// merge in runTurn's step 6, above), plus up to 3 more from deeper history.
 	out := make([]dialogue.Turn, 0, 1+len(prev.History))
-	out = append(out, dialogue.Turn{
-		Intent: prev.Intent,
-		Slots:  prev.Slots,
-		Text:   prev.Slots.Text,
-	})
+	out = append(out, sessionAsTurn(prev))
 	out = append(out, prev.History...)
 	return out
 }

cmd/mavend/voicewire.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/kami/maven/internal/config"
+	"github.com/kami/maven/internal/decision"
 	"github.com/kami/maven/internal/delivery"
 	"github.com/kami/maven/internal/delivery/voicesink"
 	"github.com/kami/maven/internal/dialogue"
@@ -235,21 +236,22 @@ func wireVoice(cfg *config.Config, coreAPI ipc.CoreAPI, phr phraser.Phraser, mem
 		memStore = memory.NewInMemoryStore()
 	}
 
-	// ----- dialogue (multi-turn slot carry-over; 2-min follow-up window) -----
+	// ----- dialogue (multi-turn slot carry-over; dialogueSessionTTL follow-up window) -----
 	// Store-backed when the daemon passes a store, so a restart mid-conversation
 	// keeps the thread (Vikunja #363). Sessions past their TTL are dropped on
 	// load, never revived. Clarify's parked question stays in memory only, and
 	// that is a decision rather than an omission (Vikunja #385, docs/design.md):
 	// a restart expires it, so the thread comes back and the open question does
 	// not.
+	const dialogueSessionTTL = 2 * time.Minute
 	var dialogueSessions *dialogue.SessionStore
 	if dataStore != nil {
-		dialogueSessions = dialogue.NewPersistentSessionStore(2*time.Minute, dataStore)
+		dialogueSessions = dialogue.NewPersistentSessionStore(dialogueSessionTTL, dataStore)
 		if err := dialogueSessions.Load(context.Background(), time.Now()); err != nil {
 			log.Printf("dialogue: load saved sessions: %v", err)
 		}
 	} else {
-		dialogueSessions = dialogue.NewSessionStore(2 * time.Minute)
+		dialogueSessions = dialogue.NewSessionStore(dialogueSessionTTL)
 	}
 	clarifyStore := dialogue.NewClarifyStore(clarifyTTL)
 	timeParser := router.NewPythonDateParser()
@@ -293,7 +295,11 @@ func wireVoice(cfg *config.Config, coreAPI ipc.CoreAPI, phr phraser.Phraser, mem
 		},
 		dataStore:        dataStore,
 		dialogueSessions: dialogueSessions,
-		clarifyStore:     clarifyStore,
+		// Always on (V-564). The record is the instrument the rest of V-558 is
+		// measured with, and one that only runs when a flag is set is not there
+		// on the night the misroute happens.
+		decisions:    decision.NewRing(),
+		clarifyStore: clarifyStore,
 		// 0 here (unset config) ⇒ the dialogue default.
 		clarifyMaxAttempts: cfg.Voice.ClarifyMaxAttempts,
 		extractor:          router.Extractor{Time: timeParser, Acts: matcher, Facts: router.DefaultFactParser{}},
@@ -371,9 +377,9 @@ func pickLLMRouter(enabled bool, c router.Completer) *router.LLMRouter {
 //   - The embedder is provided by wireVoice: HashEmbedder (floor) when no
 //     embedder config is present, or the ONNX multilingual model when
 //     configured — same interface, one constructor change.
-//   - 6 bootstrap examples covering the 5 intents + one compound-capture
-//     placeholder. Spec calls for ~10 per intent at production; this is the
-//     bootstrapping floor swapped by tuning the seed set later.
+//   - The classifier is floored by seedClassifier, which loads one file per
+//     intent from seedDir (models/seeds/<intent>.txt) — see seedClassifier
+//     below for the current intent list and file names.
 //   - Threshold is from voice.router_threshold config (default 0.55).
 func buildRouter(emb router.Embedder, acts router.ActMatcher, threshold float64, llmR *router.LLMRouter) *router.Router {
 	cls := router.NewClassifier(emb)
@@ -400,6 +406,14 @@ func buildRouter(emb router.Embedder, acts router.ActMatcher, threshold float64,
 	// explicit capture marker beats the model, which called it an act and
 	// rewrote the task text (Vikunja #467). After the rules above because a
 	// marker never collides with a clock or agenda question.
+	// After Praxis, whose bare "закрой" claim this rule cannot reach (it needs the
+	// board noun), and before the capture marker, which would otherwise read
+	// "убери из задач купить молоко" as a new task (Vikunja #512).
+	grammars = append(grammars, router.TaskStatusGrammar())
+	// Before the capture markers, which all need an object. A capture verb
+	// alone is a fact with no key, and the clarify path asks for it rather than
+	// letting the model invent an answer (Vikunja #557).
+	grammars = append(grammars, router.BareCaptureGrammar()...)
 	grammars = append(grammars, router.TaskCaptureGrammar())
 	// After the capture marker, so "запиши" still wins over "расскажи", and
 	// last overall because it matches on the first word alone: "расскажи про
@@ -448,9 +462,10 @@ func seedPath() string {
 
 // seedClassifier floors the embedded examples so the cold-boot path
 // doesn't return ErrNoIntents. Loads examples from seedDir — one file per
-// intent (act.txt, reminder.txt, fact.txt, note.txt, query.txt). When the
-// classifier can't decide it falls through to Clarify — the last-resort
-// path asks the user to rephrase rather than guessing wrong.
+// intent (act.txt, reminder.txt, fact.txt, note.txt, query.txt, chat.txt,
+// system.txt). When the classifier can't decide it falls through to
+// Clarify — the last-resort path asks the user to rephrase rather than
+// guessing wrong.
 func seedClassifier(c *router.Classifier) {
 	intents := []router.Intent{
 		router.IntentAct,

cmd/mavend/weatherq.go

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

cmd/mavend/weatherq_test.go

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

cmd/mavend/wipe.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	"github.com/kami/maven/internal/store"
+)
+
+// runWipe implements the -wipe flag: it prints what the database holds, and
+// removes it only when the operator also passed -confirm-wipe (Vikunja #494).
+//
+// Two flags rather than one, because the destructive reading of a single flag
+// is the reading a mistyped command gets. Without the confirmation this is a
+// dry run that costs nothing and answers the question a QA session actually
+// has — what is on this box right now.
+//
+// It runs before any daemon component is wired, so nothing is writing while
+// the tables go. The daemon exits afterwards rather than serving a store it
+// just emptied, because every component that read the old rows at boot would
+// still be holding them.
+func runWipe(ctx context.Context, st *store.Store, out io.Writer, confirmed bool) error {
+	counts, err := st.WipeCounts(ctx)
+	if err != nil {
+		return fmt.Errorf("wipe: read counts: %w", err)
+	}
+	total := 0
+	for _, c := range counts {
+		total += c.Rows
+		fmt.Fprintf(out, "  %-24s %d\n", c.Table, c.Rows)
+	}
+	fmt.Fprintf(out, "  %-24s %d rows in %d tables\n", "TOTAL", total, len(counts))
+
+	if !confirmed {
+		fmt.Fprintln(out, "\nnothing was deleted. pass -confirm-wipe to delete all of it.")
+		fmt.Fprintln(out, "config, models, passkeys and the encryption key are files and are never touched.")
+		return nil
+	}
+	if err := st.Wipe(ctx); err != nil {
+		return err
+	}
+	fmt.Fprintf(out, "\nwiped. %d rows gone, the schema is intact, mavend knows nobody.\n", total)
+	return nil
+}

cmd/mavpoll/main.go

@@ -6,10 +6,11 @@
 // restart-free, fail-independent — a crashing poller can't touch the store key
 // (it never had it), worst case a stale env fact until the next tick.
 //
-// Two sources, each its own provenance (the loop's rules trust source):
+// Four sources, each its own provenance (the loop's rules trust source):
 //   - netdata  → poll:netdata      resource alarms (disk/mem/cert/temp)
 //   - kuma     → poll:uptimekuma   service up/down (the source of truth for it)
 //   - zenmoney → poll:zenmoney     spending/income totals (Vikunja #125)
+//   - wireguard → infer:wg         latest handshake, the presence signal
 //
 // The zenmoney source is why the token lives HERE and not in core: the poller
 // already owns every other third-party credential, it holds no store key, and
@@ -76,27 +77,31 @@ func run(args []string) error {
 	if *netdataURL == "" && *kumaURL == "" && *wgIface == "" && *zenTokenFile == "" {
 		return fmt.Errorf("nothing to poll: set -netdata, -kuma, -wg and/or -zenmoney-token-file")
 	}
+	// A bad duration or an empty -wg-cmd used to get past start and kill the
+	// poller on the first tick — time.NewTicker panics on a non-positive
+	// interval, and pollWg indexed field 0 of an empty command. A zero -timeout
+	// is worse than a crash: http.Client reads it as "no deadline", so one
+	// wedged source stalls every other source behind it forever. Refuse all
+	// three here, where the operator sees the message.
+	if *interval <= 0 {
+		return fmt.Errorf("-interval must be positive, got %s", *interval)
+	}
+	if *timeout <= 0 {
+		return fmt.Errorf("-timeout must be positive, got %s", *timeout)
+	}
+	if *wgIface != "" && strings.TrimSpace(*wgCmd) == "" {
+		return fmt.Errorf("-wg-cmd is empty but -wg is set")
+	}
 
-	// The token is read from a file, never taken as a flag value: an argv token
-	// is visible in `ps` to every user on the box and lands in the compose file
-	// and the shell history. Read once at start — a rotated token means a
-	// restart, which is cheaper than re-reading his credential every hour.
-	var zen *zenmoney.Client
-	if *zenTokenFile != "" {
-		raw, err := os.ReadFile(*zenTokenFile)
-		if err != nil {
-			return fmt.Errorf("read zenmoney token: %w", err)
-		}
-		zen, err = zenmoney.New(strings.TrimSpace(string(raw)), *zenURL, *timeout*3)
-		if err != nil {
-			return err
-		}
+	zen, err := newZenClient(*zenTokenFile, *zenURL, *timeout)
+	if err != nil {
+		return err
 	}
 
 	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
 	defer stop()
 
-	core, err := ipc.DialWait(*socket, 60*time.Second)
+	core, err := ipc.DialWait(*socket, coreDialWait)
 	if err != nil {
 		return err
 	}
@@ -117,14 +122,46 @@ func run(args []string) error {
 	// The token is never logged, not even its length.
 	log.Printf("mavpoll: polling every %s (netdata=%q kuma=%q wg=%q zenmoney=%v every %s)",
 		*interval, *netdataURL, *kumaURL, *wgIface, zen != nil, *zenInterval)
+	p.loop(ctx, *interval)
+	return nil
+}
+
+// coreDialWait — how long to wait for core's socket at start. The poller and
+// core come up together under compose, so a cold start is a wait, not a failure.
+const coreDialWait = 60 * time.Second
+
+// zenTimeoutFactor — the zenmoney client gets a longer deadline than the other
+// sources. A diff call walks his whole transaction history, where netdata and
+// kuma answer from memory.
+const zenTimeoutFactor = 3
+
+// newZenClient builds the money client, or nil when no token file was given.
+//
+// The token is read from a file, never taken as a flag value: an argv token is
+// visible in `ps` to every user on the box and lands in the compose file and
+// the shell history. Read once at start — a rotated token means a restart,
+// which is cheaper than re-reading his credential every hour.
+func newZenClient(tokenFile, baseURL string, timeout time.Duration) (*zenmoney.Client, error) {
+	if tokenFile == "" {
+		return nil, nil
+	}
+	raw, err := os.ReadFile(tokenFile)
+	if err != nil {
+		return nil, fmt.Errorf("read zenmoney token: %w", err)
+	}
+	return zenmoney.New(strings.TrimSpace(string(raw)), baseURL, timeout*zenTimeoutFactor)
+}
+
+// loop polls until the context is cancelled.
+func (p *poller) loop(ctx context.Context, interval time.Duration) {
 	p.pollOnce(ctx) // fire immediately; don't idle a full interval on start
-	t := time.NewTicker(*interval)
+	t := time.NewTicker(interval)
 	defer t.Stop()
 	for {
 		select {
 		case <-ctx.Done():
 			log.Printf("mavpoll: bye")
-			return nil
+			return
 		case <-t.C:
 			p.pollOnce(ctx)
 		}
@@ -151,8 +188,8 @@ type poller struct {
 	zenLast  time.Time
 }
 
-// pollOnce — one sweep of both sources. A failure in one source logs and does
-// NOT abort the other: netdata being down shouldn't blind kuma and vice versa.
+// pollOnce — one sweep of every configured source. A failure in one logs and
+// does NOT abort the rest: netdata being down shouldn't blind kuma.
 func (p *poller) pollOnce(ctx context.Context) {
 	now := time.Now()
 	if p.netdataURL != "" {
@@ -244,6 +281,14 @@ func (p *poller) pollZenmoney(ctx context.Context, now time.Time) error {
 
 // ---- wireguard: latest handshake → presence signal -------------------------
 
+const (
+	// wgFactKey / wgSource — the presence signal, read by the decay in core.
+	// The source says infer because a handshake is evidence he is home, not a
+	// reading of where he is.
+	wgFactKey = "wg_handshake"
+	wgSource  = "infer:wg"
+)
+
 // pollWg reads `wg show <iface> latest-handshakes` and writes a wg_handshake
 // fact (source=infer:wg) stamped with the MOST RECENT peer handshake time — not
 // now(). Presence decays from the real handshake instant, so the fact's ts must
@@ -253,9 +298,19 @@ func (p *poller) pollZenmoney(ctx context.Context, now time.Time) error {
 // `wg show` needs CAP_NET_ADMIN; run mavpoll with the cap or set -wg-cmd "sudo wg".
 func (p *poller) pollWg(ctx context.Context) error {
 	fields := strings.Fields(p.wgCmd)
+	if len(fields) == 0 {
+		return fmt.Errorf("wg command is empty")
+	}
 	args := append(fields[1:], "show", p.wgIface, "latest-handshakes")
 	out, err := exec.CommandContext(ctx, fields[0], args...).Output()
 	if err != nil {
+		// wg says why it refused on stderr — usually a missing CAP_NET_ADMIN or
+		// an interface that does not exist. Output() drops that, leaving a log
+		// line that reads "exit status 1" and diagnoses nothing.
+		var ee *exec.ExitError
+		if errors.As(err, &ee) && len(ee.Stderr) > 0 {
+			return fmt.Errorf("run %s: %w: %s", p.wgCmd, err, strings.TrimSpace(string(ee.Stderr)))
+		}
 		return fmt.Errorf("run %s: %w", p.wgCmd, err)
 	}
 	maxTs := parseMaxHandshake(string(out))
@@ -263,20 +318,19 @@ func (p *poller) pollWg(ctx context.Context) error {
 		return nil // no peer has ever handshaked → drop out of presence
 	}
 	hs := time.Unix(maxTs, 0)
-	prev, err := p.core.LatestFactBySource(ctx, "wg_handshake", "infer:wg")
+	prev, err := p.core.LatestFactBySource(ctx, wgFactKey, wgSource)
 	if err == nil && !hs.After(prev.Ts) {
 		return nil // not newer → no churn
 	}
-	if err != nil && err != ipc.ErrNoFact && !isNoFact(err) {
-		return fmt.Errorf("read wg_handshake: %w", err)
+	if err != nil && !isNoFact(err) {
+		return fmt.Errorf("read %s: %w", wgFactKey, err)
 	}
-	if _, err := p.core.WriteFact(ctx, ipc.WriteFactReq{
-		Ts: hs, Kind: "env", Key: "wg_handshake", Value: `"up"`,
-		Source: "infer:wg", Confidence: 1.0,
-	}); err != nil {
-		return fmt.Errorf("write wg_handshake: %w", err)
+	// The ts is the handshake instant, not now(): presence decays from when he
+	// was last seen.
+	if err := p.writeFact(ctx, wgFactKey, wgSource, `"up"`, hs); err != nil {
+		return err
 	}
-	log.Printf("mavpoll: wg_handshake @ %s (infer:wg)", hs.Format(time.RFC3339))
+	log.Printf("mavpoll: %s @ %s (%s)", wgFactKey, hs.Format(time.RFC3339), wgSource)
 	return nil
 }
 
@@ -431,29 +485,53 @@ func kumaState(v float64) string {
 
 // ---- helpers ---------------------------------------------------------------
 
-// writeIfChanged writes a `facts(kind=env)` row only when val differs from the
-// latest fact for (key, source). Values are stored JSON-encoded (the store's
-// convention: `"down"`, `"critical"`), matching how rules compare f.Value.
-func (p *poller) writeIfChanged(ctx context.Context, key, source, val string, now time.Time) error {
-	jv, _ := json.Marshal(val) // string never fails to marshal
+// factConfidence — every poll is a direct reading of another service, never an
+// inference, so the fact goes in at full confidence.
+const factConfidence = 1.0
+
+// unchanged reports whether the latest fact for (key, source) already holds
+// jsonVal. A missing fact is not an error here, it is the first write.
+func (p *poller) unchanged(ctx context.Context, key, source, jsonVal string) (bool, error) {
 	prev, err := p.core.LatestFactBySource(ctx, key, source)
 	switch {
-	case err == nil && prev.Value == string(jv):
-		return nil // unchanged → no churn
-	case err != nil && err != ipc.ErrNoFact && !isNoFact(err):
-		return fmt.Errorf("read %s: %w", key, err)
+	case err == nil:
+		return prev.Value == jsonVal, nil
+	case isNoFact(err):
+		return false, nil
+	default:
+		return false, fmt.Errorf("read %s: %w", key, err)
 	}
-	_, err = p.core.WriteFact(ctx, ipc.WriteFactReq{
+}
+
+// writeFact writes one `facts(kind=env)` row. Every poll in this file lands
+// here, so the row shape is written once.
+func (p *poller) writeFact(ctx context.Context, key, source, jsonVal string, now time.Time) error {
+	_, err := p.core.WriteFact(ctx, ipc.WriteFactReq{
 		Ts:         now,
 		Kind:       "env",
 		Key:        key,
-		Value:      string(jv),
+		Value:      jsonVal,
 		Source:     source,
-		Confidence: 1.0, // a direct reading, not an inference
+		Confidence: factConfidence,
 	})
 	if err != nil {
 		return fmt.Errorf("write %s: %w", key, err)
 	}
+	return nil
+}
+
+// writeIfChanged writes only when val differs from the latest fact for
+// (key, source). Values are stored JSON-encoded (the store's convention:
+// `"down"`, `"critical"`), matching how rules compare f.Value.
+func (p *poller) writeIfChanged(ctx context.Context, key, source, val string, now time.Time) error {
+	jv, _ := json.Marshal(val) // a string never fails to marshal
+	same, err := p.unchanged(ctx, key, source, string(jv))
+	if err != nil || same {
+		return err // unchanged → no churn
+	}
+	if err := p.writeFact(ctx, key, source, string(jv), now); err != nil {
+		return err
+	}
 	log.Printf("mavpoll: %s=%s (%s)", key, val, source)
 	return nil
 }
@@ -466,18 +544,12 @@ func (p *poller) writeIfChanged(ctx context.Context, key, source, val string, no
 // The log line names the key and the source, never the figures: mavpoll's log
 // is not the place his spending ends up.
 func (p *poller) writeIfChangedRaw(ctx context.Context, key, source, jsonVal string, now time.Time) error {
-	prev, err := p.core.LatestFactBySource(ctx, key, source)
-	switch {
-	case err == nil && prev.Value == jsonVal:
-		return nil
-	case err != nil && err != ipc.ErrNoFact && !isNoFact(err):
-		return fmt.Errorf("read %s: %w", key, err)
+	same, err := p.unchanged(ctx, key, source, jsonVal)
+	if err != nil || same {
+		return err
 	}
-	if _, err := p.core.WriteFact(ctx, ipc.WriteFactReq{
-		Ts: now, Kind: "env", Key: key, Value: jsonVal,
-		Source: source, Confidence: 1.0,
-	}); err != nil {
-		return fmt.Errorf("write %s: %w", key, err)
+	if err := p.writeFact(ctx, key, source, jsonVal, now); err != nil {
+		return err
 	}
 	log.Printf("mavpoll: %s updated (%s)", key, source)
 	return nil
@@ -490,11 +562,8 @@ func (p *poller) writeIfChangedRaw(ctx context.Context, key, source, jsonVal str
 // The log line names the key only, never the figures: mavpoll's log is not the
 // place his spending ends up.
 func (p *poller) writeMoneyFact(ctx context.Context, key, jsonVal string, now time.Time) error {
-	if _, err := p.core.WriteFact(ctx, ipc.WriteFactReq{
-		Ts: now, Kind: "env", Key: key, Value: jsonVal,
-		Source: zenmoney.Source, Confidence: 1.0,
-	}); err != nil {
-		return fmt.Errorf("write %s: %w", key, err)
+	if err := p.writeFact(ctx, key, zenmoney.Source, jsonVal, now); err != nil {
+		return err
 	}
 	log.Printf("mavpoll: %s read (%s)", key, zenmoney.Source)
 	return nil
@@ -506,6 +575,15 @@ func isNoFact(err error) bool {
 	return errors.Is(err, ipc.ErrNoFact)
 }
 
+// maxBodyBytes caps what a source can make the poller hold. Kuma's whole
+// metrics page is a few hundred kilobytes, so 4 MiB is slack, not a budget.
+//
+// Hitting the cap is an error, not a shorter body. A truncated kuma page parses
+// cleanly right up to the cut, and every monitor past it reads as deleted — the
+// poller would write "unknown" over live services and the down-rule would go
+// quiet. Reading one byte past the cap is how we tell full from truncated.
+const maxBodyBytes = 4 << 20
+
 func (p *poller) get(ctx context.Context, url, basicUser string) ([]byte, error) {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
@@ -519,12 +597,15 @@ func (p *poller) get(ctx context.Context, url, basicUser string) ([]byte, error)
 		return nil, err
 	}
 	defer resp.Body.Close()
-	body, err := io.ReadAll(io.LimitReader(resp.Body, 4<<20))
+	body, err := io.ReadAll(io.LimitReader(resp.Body, maxBodyBytes+1))
 	if err != nil {
 		return nil, err
 	}
 	if resp.StatusCode != http.StatusOK {
 		return nil, fmt.Errorf("GET %s: %s", url, resp.Status)
 	}
+	if len(body) > maxBodyBytes {
+		return nil, fmt.Errorf("GET %s: body over %d bytes", url, maxBodyBytes)
+	}
 	return body, nil
 }

cmd/mavpoll/main_test.go

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

cmd/mavsttd/whisper_handler.go

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

cmd/mavttsd/piper_handler.go

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

cmd/mavweb/chat.go

@@ -0,0 +1,92 @@
+package main
+
+import (
+	_ "embed"
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/webauthn"
+)
+
+//go:embed chat.html
+var chatPageHTML string
+
+// chatTmpl — plain text conversation interface. No JS: form POSTs to /api/chat
+// and the handler redirects back to /chat with the response.
+var chatTmpl = parsePage("chat", chatPageHTML, nil)
+
+// chatMsg — one message in the conversation history.
+type chatMsg struct {
+	Role string // "user" | "assistant"
+	Text string
+	// Source — the query source that claimed the turn, shown as a badge beside
+	// the reply. Empty for a turn no source claimed (V-539).
+	Source string
+}
+
+// handleChatPage renders the chat conversation page.
+func handleChatPage(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
+	if !requireCore(w, core, "chat") {
+		return
+	}
+	msgs := []chatMsg{}
+	// Read user message + reply from query params (set by /api/chat redirect).
+	if q := r.URL.Query().Get("q"); q != "" {
+		msgs = append(msgs, chatMsg{Role: "user", Text: q})
+	}
+	if reply := r.URL.Query().Get("r"); reply != "" {
+		msgs = append(msgs, chatMsg{Role: "assistant", Text: reply, Source: r.URL.Query().Get("s")})
+	}
+	renderPage(w, chatTmpl, struct {
+		Error    string
+		Messages []chatMsg
+	}{Messages: msgs})
+}
+
+// handleChatAPI processes a chat message POST and redirects back to /chat.
+//
+// State-changing, and the widest surface on this server: the text reaches the
+// router, the LLM, and through mavend's applyAction the whole action path
+// including `act` — so it is gated on the same step-up as POST /tools and
+// POST /api/revert (Vikunja #317). With WebAuthn unconfigured the gate is
+// fail-open exactly like the others (see stepUpOK); with -require-stepup it
+// denies, which is the point of that flag.
+func handleChatAPI(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI, session *webauthn.PasskeySession, requireStepUp bool) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	if !requireCore(w, core, "chat") {
+		return
+	}
+	if !stepUpGate(w, session, requireStepUp) {
+		return
+	}
+	text := strings.TrimSpace(r.FormValue("text"))
+	if text == "" {
+		http.Redirect(w, r, "/chat", http.StatusSeeOther)
+		return
+	}
+	// One conversation id for the whole web chat, and a different one from
+	// telegram or the mic. A parked question belongs to the reach that was
+	// asked; before this, a clarify nobody answered on the web ate the next
+	// utterance spoken at the mic (Vikunja #466). This server has no
+	// per-browser session, so every browser tab is the same conversation —
+	// which is right for a single-owner box.
+	reply, err := core.Chat(r.Context(), "web", text)
+	if err != nil {
+		log.Printf("chat api: %v", err)
+		http.Redirect(w, r, "/chat", http.StatusSeeOther)
+		return
+	}
+	// The claiming query source rides back on the redirect so the page can show
+	// it. Empty for a turn no source claimed, which is most of them.
+	dest := "/chat?q=" + url.QueryEscape(text) + "&r=" + url.QueryEscape(reply.Reply)
+	if reply.Source != "" {
+		dest += "&s=" + url.QueryEscape(reply.Source)
+	}
+	http.Redirect(w, r, dest, http.StatusSeeOther)
+}

cmd/mavweb/ecosystem.go

@@ -117,8 +117,5 @@ func handleEcosystem(w http.ResponseWriter, r *http.Request, urls ecoURLs, core
 		d.Calls.Rows = rows
 	}
 
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	if err := ecosystemTmpl.Execute(w, d); err != nil {
-		log.Printf("ecosystem render: %v", err)
-	}
+	renderPage(w, ecosystemTmpl, d)
 }

cmd/mavweb/events.html

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

cmd/mavweb/events_test.go

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

cmd/mavweb/facts.go

@@ -0,0 +1,96 @@
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/webauthn"
+)
+
+// The two fact-writing API routes: POST /api/signal appends a presence
+// observation, POST /api/revert voids the latest fact for a key. Neither
+// renders a page.
+
+// presenceSignals — the only fact keys /api/signal may write. mavweb is a
+// network-facing surface inside wg; an allowlist keeps a compromised caller
+// boxed to forging weak presence signals (reachability, multi-source, never
+// truth) — it can't write arbitrary facts. ponytail: floor auth (wg-only); a
+// per-signal token belongs here if the tunnel ever hosts untrusted devices.
+var presenceSignals = map[string]string{
+	"desk_active":    "infer:hyprland",
+	"page_heartbeat": "infer:heartbeat",
+	"wg_handshake":   "infer:wg",
+}
+
+// handleSignal ingests one presence signal and writes a fresh fact through
+// CoreAPI. The fact's timestamp (now) is all the presence scorer reads; value
+// is a marker. Only allowlisted keys are accepted (see presenceSignals).
+func handleSignal(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	if !requireCore(w, core, "presence ingest") {
+		return
+	}
+	key := r.URL.Query().Get("key")
+	source, ok := presenceSignals[key]
+	if !ok {
+		http.Error(w, "unknown signal key", http.StatusBadRequest)
+		return
+	}
+	// kind=env: an observation about the device/surface, NOT a self-fact — a
+	// passive signal never writes truth about you (spec), it only feeds
+	// presence. confidence 1.0: the reading ("input happened") is certain;
+	// presence applies its own per-signal weight/decay on top.
+	if _, err := core.WriteFact(r.Context(), ipc.WriteFactReq{
+		Ts:         time.Now(),
+		Kind:       "env",
+		Key:        key,
+		Value:      `"active"`,
+		Source:     source,
+		Confidence: 1.0,
+	}); err != nil {
+		log.Printf("signal %s: %v", key, err)
+		http.Error(w, "write failed", http.StatusBadGateway)
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func handleRevert(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI, session *webauthn.PasskeySession, requireStepUp bool) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	if !requireCore(w, core, "revert") {
+		return
+	}
+	if !stepUpGate(w, session, requireStepUp) {
+		return
+	}
+
+	key := strings.TrimSpace(r.FormValue("key"))
+	if key == "" {
+		http.Error(w, "key required", http.StatusBadRequest)
+		return
+	}
+	newID, err := core.RevertFact(r.Context(), key)
+	if err != nil {
+		log.Printf("revert %q: %v", key, err)
+		if errors.Is(err, ipc.ErrNoFact) {
+			http.Error(w, "no fact to revert", http.StatusNotFound)
+			return
+		}
+		http.Error(w, "revert failed", http.StatusBadGateway)
+		return
+	}
+	log.Printf("reverted fact for key=%s, new_id=%d", key, newID)
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]any{"reverted": true, "new_id": newID})
+}

cmd/mavweb/handlers_test.go

@@ -65,6 +65,7 @@ type fakeCore struct {
 	// for handleTrace tests
 	tickTrace ipc.TickTrace
 	traceErr  error
+	turns     []ipc.TurnDecision
 
 	// for handleChatAPI tests
 	chatText   string
@@ -173,6 +174,10 @@ func (f *fakeCore) RevertFact(_ context.Context, key string) (int64, error) {
 	return f.revertNewID, nil
 }
 
+func (f *fakeCore) TurnDecisions(_ context.Context, _ int) ([]ipc.TurnDecision, error) {
+	return f.turns, nil
+}
+
 func (f *fakeCore) TickTrace(_ context.Context) (ipc.TickTrace, error) {
 	if f.traceErr != nil {
 		return ipc.TickTrace{}, f.traceErr
@@ -825,6 +830,41 @@ func TestHandleTrace(t *testing.T) {
 			t.Error("rendered 'nothing fired' but a winner was set")
 		}
 	})
+
+	// The turn arbitration shares this page (V-564). A reader must see the
+	// winner, a loser and the claimants that were never asked, because the last
+	// of those is what the hardcoded ordering hides.
+	t.Run("renders the turn decision record", func(t *testing.T) {
+		core := &fakeCore{turns: []ipc.TurnDecision{{
+			Ts:        time.Date(2025, 6, 1, 12, 0, 0, 0, time.UTC),
+			Utterance: "какая погода в риме",
+			Winner:    "query:weather",
+			Claims: []ipc.TurnClaim{
+				{Stage: "query", Claimant: "weather", Intent: "query", Outcome: "won"},
+				{Stage: "query", Claimant: "calendar", Outcome: "declined", Reason: "no answer"},
+				{Stage: "query", Claimant: "kiwix", Outcome: "never_asked"},
+			},
+		}}}
+		rr := httptest.NewRecorder()
+		handleTrace(rr, httptest.NewRequest(http.MethodGet, "/trace", nil), core)
+		body := rr.Body.String()
+		for _, want := range []string{"какая погода в риме", "query:weather", "calendar", "kiwix", "never_asked"} {
+			if !strings.Contains(body, want) {
+				t.Errorf("rendered page is missing %q", want)
+			}
+		}
+	})
+
+	t.Run("no turns renders the empty note, not an error", func(t *testing.T) {
+		rr := httptest.NewRecorder()
+		handleTrace(rr, httptest.NewRequest(http.MethodGet, "/trace", nil), &fakeCore{})
+		if rr.Code != http.StatusOK {
+			t.Fatalf("status = %d, want 200", rr.Code)
+		}
+		if !strings.Contains(rr.Body.String(), "no turn has run") {
+			t.Error("empty ring did not render its note")
+		}
+	})
 }
 
 // --- handleRevert ---

cmd/mavweb/models.go

@@ -2,8 +2,8 @@ package main
 
 import (
 	"context"
+	_ "embed"
 	"errors"
-	"html/template"
 	"log"
 	"net/http"
 	"strconv"
@@ -31,43 +31,10 @@ type modelController interface {
 	SwapModel(ctx context.Context, req ipc.SwapModelReq) (ipc.SwapModelResp, error)
 }
 
-var modelsTmpl = template.Must(template.New("models").Funcs(shellFuncs()).Parse(shellHTML + modelsHTML))
+//go:embed models.html
+var modelsHTML string
 
-const modelsHTML = `{{template "shellTop" "models"}}
-<h1>Resident model</h1>
-<p class=hint>swapping requires step-up — <a href=/auth/passkey>assert a passkey</a> first. The old model is unloaded before the new one is loaded (one model fits the iGPU at a time), so turns during the load are refused and fall back to the classifier.</p>
-<p class=hint>a swap is not remembered. Nothing writes it down, so the next restart of the daemon — including the one <code>mavupdate</code> does — comes back on <code>phraser.model_path</code> from the config. Make it stick by editing that.</p>
-{{if .Msg}}<div class="msg msg-ok">{{.Msg}}</div>{{end}}
-{{if .Err}}<div class="msg msg-err">{{.Err}}</div>{{end}}
-{{if .Off}}
-<section class=card>
-<h2 class=card-title>swap not configured</h2>
-<p class=hint>this core has no <code>phraser.swap_models</code> allowlist, so there is nothing to swap to. Add the gguf paths you allow to <code>deploy/mavend.json</code> and restart once.</p>
-</section>
-{{else}}
-<section class=card>
-<h2 class=card-title>loaded now</h2>
-<div class=scroll><table>
-<tr><th>model</th><td><code>{{.Status.Model}}</code></td></tr>
-<tr><th>file</th><td><code>{{.Status.ModelPath}}</code></td></tr>
-<tr><th>server</th><td><code>{{.Status.BaseURL}}</code></td></tr>
-<tr><th>n_ctx</th><td>{{.Status.NCtx}}</td></tr>
-<tr><th>n_gpu_layers</th><td>{{.Status.NGpuLayers}}</td></tr>
-</table></div>
-<p class=hint>the model name is what llama-server reports for itself, not what the config says it should be.</p>
-</section>
-<section class=card>
-<h2 class=card-title>allowed models <span class=badge>{{len .Status.Swappable}}</span></h2>
-{{if .Status.Swappable}}<div class=scroll><table><tr><th>file</th><th></th></tr>
-{{range .Status.Swappable}}<tr><td><code>{{.}}</code></td>
-<td><form method=post action=/models class=inline-form>
-<input type=hidden name=model_path value="{{.}}">
-<button class=btn>load this one</button></form></td></tr>{{end}}
-</table></div>
-{{else}}<div class=empty><div>no models allowlisted</div></div>{{end}}
-</section>
-{{end}}
-{{template "shellBottom"}}`
+var modelsTmpl = parsePage("models", modelsHTML, nil)
 
 type modelsPage struct {
 	Msg    string
@@ -154,8 +121,5 @@ func handleModels(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI, swap
 		}
 	}
 	page.Status = st
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	if err := modelsTmpl.Execute(w, page); err != nil {
-		log.Printf("models render: %v", err)
-	}
+	renderPage(w, modelsTmpl, page)
 }

cmd/mavweb/models.html

@@ -0,0 +1,35 @@
+{{template "shellTop" "models"}}
+<h1>Resident model</h1>
+<p class=hint>swapping requires step-up — <a href=/auth/passkey>assert a passkey</a> first. The old model is unloaded before the new one is loaded (one model fits the iGPU at a time), so turns during the load are refused and fall back to the classifier.</p>
+<p class=hint>a swap is not remembered. Nothing writes it down, so the next restart of the daemon — including the one <code>mavupdate</code> does — comes back on <code>phraser.model_path</code> from the config. Make it stick by editing that.</p>
+{{if .Msg}}<div class="msg msg-ok">{{.Msg}}</div>{{end}}
+{{if .Err}}<div class="msg msg-err">{{.Err}}</div>{{end}}
+{{if .Off}}
+<section class=card>
+<h2 class=card-title>swap not configured</h2>
+<p class=hint>this core has no <code>phraser.swap_models</code> allowlist, so there is nothing to swap to. Add the gguf paths you allow to <code>deploy/mavend.json</code> and restart once.</p>
+</section>
+{{else}}
+<section class=card>
+<h2 class=card-title>loaded now</h2>
+<div class=scroll><table>
+<tr><th>model</th><td><code>{{.Status.Model}}</code></td></tr>
+<tr><th>file</th><td><code>{{.Status.ModelPath}}</code></td></tr>
+<tr><th>server</th><td><code>{{.Status.BaseURL}}</code></td></tr>
+<tr><th>n_ctx</th><td>{{.Status.NCtx}}</td></tr>
+<tr><th>n_gpu_layers</th><td>{{.Status.NGpuLayers}}</td></tr>
+</table></div>
+<p class=hint>the model name is what llama-server reports for itself, not what the config says it should be.</p>
+</section>
+<section class=card>
+<h2 class=card-title>allowed models <span class=badge>{{len .Status.Swappable}}</span></h2>
+{{if .Status.Swappable}}<div class=scroll><table><tr><th>file</th><th></th></tr>
+{{range .Status.Swappable}}<tr><td><code>{{.}}</code></td>
+<td><form method=post action=/models class=inline-form>
+<input type=hidden name=model_path value="{{.}}">
+<button class=btn>load this one</button></form></td></tr>{{end}}
+</table></div>
+{{else}}<div class=empty><div>no models allowlisted</div></div>{{end}}
+</section>
+{{end}}
+{{template "shellBottom"}}

cmd/mavweb/morning.html

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

cmd/mavweb/morning_test.go

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

cmd/mavweb/notifications.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	_ "embed"
+	"log"
+	"net/http"
+	"strconv"
+
+	"github.com/kami/maven/internal/ipc"
+)
+
+//go:embed notifications.html
+var notificationsHTML string
+
+var notificationsTmpl = parsePage("notifications", notificationsHTML, nil)
+
+// deliveryRow is one outbox line, with every timestamp already formatted so
+// the template holds no date logic — same shape as taskRow.
+type deliveryRow struct {
+	Kind      string
+	Target    string
+	Channel   string
+	Status    string
+	Created   string
+	Completed string
+}
+
+func deliveryRows(as []ipc.DeliveryAttempt) []deliveryRow {
+	out := make([]deliveryRow, 0, len(as))
+	for _, a := range as {
+		target := a.Rule
+		if target == "" && a.ReminderID != 0 {
+			target = "reminder #" + strconv.FormatInt(a.ReminderID, 10)
+		}
+		row := deliveryRow{
+			Kind:    a.Kind,
+			Target:  target,
+			Channel: a.Channel,
+			Status:  a.Status,
+			Created: a.Created.Format("02.01 15:04"),
+		}
+		if a.Completed != nil {
+			row.Completed = a.Completed.Format("15:04")
+		}
+		out = append(out, row)
+	}
+	return out
+}
+
+func handleNotifications(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
+	if !requireCore(w, core, "notifications") {
+		return
+	}
+	ctx := r.Context()
+	nudges, err := core.RecentNudges(ctx, 50)
+	if err != nil {
+		log.Printf("notifications: %v", err)
+		http.Error(w, "notifications error: "+err.Error(), http.StatusBadGateway)
+		return
+	}
+	// The outbox, on the page that already answers "what did she send".
+	// A failed or dropped attempt is why she went quiet, and until now it was
+	// recorded and unreadable (Vikunja #390). Filter with ?status=dropped.
+	status := r.URL.Query().Get("status")
+	attempts, err := core.DeliveryAttempts(ctx, status, 50)
+	if err != nil {
+		// The nudge list is still worth showing, so this is a note on the page
+		// rather than a dead page.
+		log.Printf("notifications: delivery attempts: %v", err)
+	}
+	renderPage(w, notificationsTmpl, map[string]any{
+		"Nudges":   nudges,
+		"Attempts": deliveryRows(attempts),
+		"Status":   status,
+	})
+}

cmd/mavweb/pages.go

@@ -0,0 +1,205 @@
+package main
+
+import (
+	"cmp"
+	_ "embed"
+	"html/template"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/kami/maven/internal/ipc"
+)
+
+// The read-only pages: dash, history, trace, morning, events, and the voice
+// page mounted at "/". Each is GET-only, reads through CoreAPI and renders.
+// The write surfaces live next to their own handlers (tasks.go, tools.go,
+// routines.go, chat.go).
+
+//go:embed dash.html
+var dashHTML string
+
+//go:embed history.html
+var historyHTML string
+
+//go:embed trace.html
+var traceHTML string
+
+//go:embed morning.html
+var morningHTML string
+
+//go:embed events.html
+var eventsHTML string
+
+//go:embed voice.html
+var voiceHTML string
+
+//go:embed ecosystem.html
+var ecosystemHTML string
+
+// dashTmpl — the monitoring read surface, server-rendered from dash.html;
+// a small fetch loop refreshes the tables in place. html/template escapes the
+// user text in facts/nudges. Read-only: browses the append-only store via
+// CoreAPI, never writes — the store IS the audit trail, this just shows it.
+var dashTmpl = parsePage("dash", dashHTML, nil)
+
+var historyTmpl = parsePage("history", historyHTML, nil)
+
+var traceTmpl = parsePage("trace", traceHTML, template.FuncMap{
+	"fmtTime": func(t *time.Time) string {
+		if t == nil || t.IsZero() {
+			return "—"
+		}
+		return t.Format("15:04:05")
+	},
+	"join": strings.Join,
+})
+
+// morningTmpl — read-only view of today's checklist state per configured
+// morning routine (internal/morning). Same shape as trace.html: a plain
+// server-rendered page, refreshed on reload — no live-update loop, since
+// checklist state changes on the scale of minutes, not seconds.
+var morningTmpl = parsePage("morning", morningHTML, nil)
+
+// eventsTmpl — the unified intake journal (Vikunja #283), read-only. Same
+// shape as trace.html and morning.html: server-rendered, refreshed on reload.
+var eventsTmpl = parsePage("events", eventsHTML, nil)
+
+var voiceTmpl = parsePage("voice", voiceHTML, nil)
+
+// ecosystemTmpl — read-only view of the Nexus/Praxis/Hexis siblings, whose only
+// human surface is here (they ship no web UI of their own).
+var ecosystemTmpl = parsePage("ecosystem", ecosystemHTML, nil)
+
+func handleDash(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
+	if !requireCore(w, core, "dash") {
+		return
+	}
+	ctx := r.Context()
+	pres, err1 := core.Presence(ctx)
+	facts, err2 := core.RecentFacts(ctx, 50)
+	nudges, err3 := core.RecentNudges(ctx, 50)
+	notes, err4 := core.RecentNotes(ctx, 50)
+	if err := cmp.Or(err1, err2, err3, err4); err != nil {
+		log.Printf("dash: %v", err)
+		http.Error(w, "core read failed", http.StatusBadGateway)
+		return
+	}
+	renderPage(w, dashTmpl, struct {
+		Presence ipc.Presence
+		Facts    []ipc.Fact
+		Nudges   []ipc.Nudge
+		Notes    []ipc.Note
+	}{pres, facts, nudges, notes})
+}
+
+func handleHistory(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
+	if !requireCore(w, core, "history") {
+		return
+	}
+	facts, err := core.RecentFacts(r.Context(), 200)
+	if err != nil {
+		log.Printf("history: %v", err)
+		http.Error(w, "core read failed", http.StatusBadGateway)
+		return
+	}
+	renderPage(w, historyTmpl, struct {
+		Facts []ipc.Fact
+	}{facts})
+}
+
+func handleTrace(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
+	if !requireCore(w, core, "trace") {
+		return
+	}
+	trace, err := core.TickTrace(r.Context())
+	if err != nil {
+		log.Printf("trace: %v", err)
+		http.Error(w, "core read failed", http.StatusBadGateway)
+		return
+	}
+	// The turn records share this page rather than getting one of their own
+	// (V-564). Both answer the same question, who won and who lost and why, and
+	// one is about nudges while the other is about utterances. A read failure
+	// here is not fatal to the page. The rule trace above it still renders, and
+	// a daemon too old to know the method is the ordinary case during a rolling
+	// deploy.
+	turns, err := core.TurnDecisions(r.Context(), 25)
+	if err != nil {
+		log.Printf("trace: turn decisions: %v", err)
+	}
+	renderPage(w, traceTmpl, traceData{Tick: trace, Turns: turns})
+}
+
+// traceData — what trace.html renders: the last tick's rule arbitration and the
+// last turns' claim arbitration.
+type traceData struct {
+	Tick  ipc.TickTrace
+	Turns []ipc.TurnDecision
+}
+
+// morningView — what /morning renders: today's plan on top, the checklist
+// state under it. PlanErr is set instead of Plan when the core could not build
+// a plan, so the page says so rather than showing an empty day.
+type morningView struct {
+	Plan     *ipc.DayPlan
+	PlanErr  string
+	Routines []ipc.MorningRoutineStatus
+}
+
+func handleMorning(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
+	if !requireCore(w, core, "morning") {
+		return
+	}
+	ctx := r.Context()
+	status, err := core.MorningStatus(ctx)
+	if err != nil {
+		log.Printf("morning: %v", err)
+		http.Error(w, "core read failed", http.StatusBadGateway)
+		return
+	}
+	view := morningView{Routines: status}
+	// The day plan (#128) shows on this page because it is the same question at
+	// a different scale. A plan read that fails must not take the checklist
+	// down with it — the page degrades to what it had before.
+	plan, err := core.DayPlan(ctx)
+	if err != nil {
+		log.Printf("morning: day plan: %v", err)
+		view.PlanErr = err.Error()
+	} else {
+		view.Plan = &plan
+	}
+	renderPage(w, morningTmpl, view)
+}
+
+// eventsView — what /events renders. Err is set instead of Events when the
+// core could not serve the journal, so the page says why rather than showing an
+// empty intake and implying nothing arrived.
+type eventsView struct {
+	Events []ipc.IntakeEvent
+	Err    string
+}
+
+// eventsPageLimit — how many envelopes the page shows. The ring holds more; a
+// page is for scanning what just happened, not for archaeology.
+const eventsPageLimit = 200
+
+func handleEvents(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
+	if !requireCore(w, core, "intake journal") {
+		return
+	}
+	var view eventsView
+	evs, err := core.RecentEvents(r.Context(), eventsPageLimit)
+	if err != nil {
+		log.Printf("events: %v", err)
+		view.Err = err.Error()
+	} else {
+		view.Events = evs
+	}
+	renderPage(w, eventsTmpl, view)
+}
+
+func handleVoice(w http.ResponseWriter, r *http.Request) {
+	renderPage(w, voiceTmpl, nil)
+}

cmd/mavweb/passkey.html

@@ -0,0 +1,58 @@
+{{template "shellTop" "passkey"}}
+<h1>Passkey</h1>
+<p class=hint>Enroll a passkey once, then assert it to unlock destructive actions (tool enable) for a few minutes.</p>
+<div class=flex gap-2>
+<button class=btn onclick=enroll()>enroll passkey</button>
+<button class=btn onclick=assert()>assert (step-up)</button>
+<button class=btn onclick=rewrapKey()>rewrite cold-start key</button>
+<a href=/tools><button class=btn-primary>→ tools</button></a>
+</div>
+<p class=hint>Rewriting the cold-start key points it at the passkey you assert next. Every other enrolled passkey stops being able to unlock a cold-booted daemon.</p>
+<div id=msg></div>
+{{template "shellBottom"}}
+<script>
+const b64u=b=>btoa(String.fromCharCode(...new Uint8Array(b))).replace(/\+/g,'-').replace(/\//g,'_').replace(/=+$/,'');
+const ub64=s=>{s=s.replace(/-/g,'+').replace(/_/g,'/');const b=atob(s),a=new Uint8Array(b.length);for(let i=0;i<b.length;i++)a[i]=b.charCodeAt(i);return a;};
+const say=(t,ok)=>{const m=document.getElementById('msg');m.textContent=t;m.className=ok?'msg msg-ok':'msg msg-err';};
+async function enroll(){try{
+ const {challenge,options}=await (await fetch('/auth/webauthn/register/begin')).json();
+ options.challenge=ub64(options.challenge);
+ options.user.id=ub64(options.user.id);
+ const c=await navigator.credentials.create({publicKey:options});
+ const r=await fetch('/auth/webauthn/register/finish',{method:'POST',headers:{'content-type':'application/json'},
+  body:JSON.stringify({challenge,credential:{id:c.id,type:c.type,response:{
+   clientDataJSON:b64u(c.response.clientDataJSON),attestationObject:b64u(c.response.attestationObject)}}})});
+ if(!r.ok){say('enroll failed: '+await r.text(),false);return;}
+ // The wrapped key can only be written from an assertion: PRF results are
+ // not produced at create() time on most authenticators. Enrolment reports
+ // whether PRF is available at all so he is not told cold-start works when
+ // it cannot.
+ const ext=c.getClientExtensionResults?c.getClientExtensionResults():{};
+ const prfOK=!!(ext.prf&&ext.prf.enabled);
+ say(prfOK?'enrolled ✓ — now assert once to write the cold-start key':
+  'enrolled ✓ — but this authenticator has no PRF: cold-start unlock unavailable',true);
+}catch(e){say('enroll error: '+e,false);}}
+async function assert(explicit){try{
+ const {challenge,options}=await (await fetch('/auth/webauthn/assert/begin')).json();
+ options.challenge=ub64(options.challenge);
+ const c=await navigator.credentials.get({publicKey:options});
+ // The PRF result is the cold-start secret. It never touches localStorage
+ // and is posted once, over the same request as the assertion.
+ const ext=c.getClientExtensionResults?c.getClientExtensionResults():{};
+ const prf=ext.prf&&ext.prf.results&&ext.prf.results.first?b64u(ext.prf.results.first):'';
+ const r=await fetch('/auth/webauthn/assert/finish',{method:'POST',headers:{'content-type':'application/json'},
+  body:JSON.stringify({challenge,prf,explicit:!!explicit,credential:{id:c.id,type:c.type,response:{
+   clientDataJSON:b64u(c.response.clientDataJSON),authenticatorData:b64u(c.response.authenticatorData),
+   signature:b64u(c.response.signature)}}})});
+ if(!r.ok){say('assert failed: '+await r.text(),false);return;}
+ if(!prf){say('stepped up ✓ — no PRF from this authenticator, so cold-start unlock stayed unavailable',true);return;}
+ say(explicit?'stepped up ✓ — cold-start key now points at this passkey':
+  'stepped up ✓ — enable tools now',true);
+}catch(e){say('assert error: '+e,false);}}
+// Rewriting the wrapped key is a separate gesture, never a side effect of a
+// step-up. Only this button sets explicit, and only explicit lets the daemon
+// replace a blob that already exists.
+async function rewrapKey(){
+ if(!confirm('Rewrite the cold-start key under the passkey you are about to assert? Every other enrolled passkey stops being able to unlock a cold-booted daemon.'))return;
+ await assert(true);}
+</script>

cmd/mavweb/reminders.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	_ "embed"
+	"encoding/json"
+	"log"
+	"net/http"
+	"strings"
+
+	"github.com/kami/maven/internal/ipc"
+)
+
+//go:embed reminders.html
+var remindersHTML string
+
+var remindersTmpl = parsePage("reminders", remindersHTML, nil)
+
+// reminderRow is one line on /reminders, with the payload unwrapped and both
+// timestamps already in his clock.
+//
+// The page rendered `{{.Payload}}` and the UTC instant, so a reminder read
+// `{"text":"выпить таблетки"}` and fired an hour off what he was told
+// (Vikunja #469). Neither is a formatting nicety: the envelope is an internal
+// shape he never chose, and a time on a page he reads is the time on his wall.
+type reminderRow struct {
+	Created string
+	Fires   string
+	Status  string
+	Text    string
+}
+
+// reminderText unwraps the {"text":...} payload the router writes.
+//
+// A copy of store.ReminderText rather than a call to it, because mavweb is one
+// of the pure-Go daemons and internal/store carries the CGO sqlite driver. The
+// ipc DTO is decoupled from the store on purpose, so the unwrap belongs to
+// whoever renders it. Payload that is not that shape is shown as he said it.
+func reminderText(payload string) string {
+	var m map[string]any
+	if err := json.Unmarshal([]byte(payload), &m); err == nil {
+		if t, ok := m["text"]; ok {
+			if s, isStr := t.(string); isStr && s != "" {
+				return s
+			}
+		}
+	}
+	return strings.TrimSpace(payload)
+}
+
+func reminderRows(rs []ipc.Reminder) []reminderRow {
+	out := make([]reminderRow, 0, len(rs))
+	for _, r := range rs {
+		out = append(out, reminderRow{
+			Created: r.CreatedTs.Local().Format("02 Jan 15:04"),
+			Fires:   r.FireTs.Local().Format("02 Jan 15:04"),
+			Status:  r.Status,
+			Text:    reminderText(r.Payload),
+		})
+	}
+	return out
+}
+
+func handleReminders(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
+	if !requireCore(w, core, "reminders") {
+		return
+	}
+	reminders, err := core.ListReminders(r.Context(), 50)
+	if err != nil {
+		log.Printf("reminders: %v", err)
+		http.Error(w, "reminders error: "+err.Error(), http.StatusBadGateway)
+		return
+	}
+	renderPage(w, remindersTmpl, map[string]any{"Reminders": reminderRows(reminders)})
+}

cmd/mavweb/routines.go

@@ -0,0 +1,200 @@
+package main
+
+import (
+	"context"
+	_ "embed"
+	"errors"
+	"fmt"
+	"log"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/pattern"
+	"github.com/kami/maven/internal/webauthn"
+)
+
+//go:embed routines.html
+var routinesHTML string
+
+// routinesTmpl — the proposed-routine review surface. One row per thing maven
+// noticed, in her words, with at most two actions: accept or dismiss.
+var routinesTmpl = parsePage("routines", routinesHTML, nil)
+
+// routineView is one line on the page: what maven noticed, in her words, and
+// how long ago she noticed it. A view model, not a database row — the template
+// never formats an interval or a timestamp itself.
+type routineView struct {
+	ID      int64
+	Phrase  string
+	Noticed string
+}
+
+// handleRoutines serves the routine review surface (GET) and answers a
+// proposal (POST id + action=accept|dismiss).
+//
+// Accept is gated at step-up, the same tier as enabling a tool: saying yes
+// hands the trigger loop a new standing reason to speak to the human, so it
+// moves the boundary and only an authed surface may do it. Dismiss is not
+// gated — it only ever removes a reason to speak, so the worst a weaker caller
+// can do is make maven quieter.
+func handleRoutines(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI, session *webauthn.PasskeySession, requireStepUp bool) {
+	if !requireCore(w, core, "routines") {
+		return
+	}
+	ctx := r.Context()
+	var msg string
+	if r.Method == http.MethodPost {
+		var ok bool
+		if msg, ok = applyRoutinePost(w, r, core, session, requireStepUp); !ok {
+			return
+		}
+	}
+	proposed, err := core.ListProposedRoutines(ctx)
+	if err != nil {
+		log.Printf("routines: list: %v", err)
+		http.Error(w, "routines error: "+err.Error(), http.StatusBadGateway)
+		return
+	}
+	renderPage(w, routinesTmpl, struct {
+		Msg      string
+		Proposed []routineView
+	}{msg, toRoutineViews(proposed)})
+}
+
+// applyRoutinePost performs one write and returns the message to show. Unlike
+// the task form, a bad request here is an HTTP status rather than an inline
+// note, so the second return says whether the response was already written.
+func applyRoutinePost(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI, session *webauthn.PasskeySession, requireStepUp bool) (string, bool) {
+	ctx := r.Context()
+	action := r.FormValue("action")
+	// "seed" is the one action with no routine to act on — it is what
+	// MAKES a routine (Vikunja #518), so it runs before the id parse. It
+	// lives on this route rather than a page of its own because it is
+	// already the step-up-gated surface for this table, and a second gated
+	// surface is a second thing to get wrong.
+	if action == "seed" {
+		if !stepUpGate(w, session, requireStepUp) {
+			return "", false
+		}
+		out, err := seedRoutineEvent(ctx, core, r)
+		if err != nil {
+			log.Printf("routines: seed: %v", err)
+			http.Error(w, "seed failed: "+err.Error(), http.StatusBadGateway)
+			return "", false
+		}
+		return out, true
+	}
+
+	idStr := r.FormValue("id")
+	var rid int64
+	if n, _ := fmt.Sscanf(idStr, "%d", &rid); n != 1 {
+		http.Error(w, "invalid id", http.StatusBadRequest)
+		return "", false
+	}
+	switch action {
+	case "accept":
+		if !stepUpGate(w, session, requireStepUp) {
+			return "", false
+		}
+		if err := acceptRoutine(ctx, core, rid); err != nil {
+			log.Printf("routines: accept %d: %v", rid, err)
+			http.Error(w, "accept failed: "+err.Error(), http.StatusBadGateway)
+			return "", false
+		}
+		return "accepted routine — maven will remind you", true
+	case "dismiss":
+		if err := core.DismissProposedRoutine(ctx, rid); err != nil {
+			log.Printf("routines: dismiss %d: %v", rid, err)
+			http.Error(w, "dismiss failed: "+err.Error(), http.StatusBadGateway)
+			return "", false
+		}
+		return "dismissed routine", true
+	default:
+		http.Error(w, "unknown action", http.StatusBadRequest)
+		return "", false
+	}
+}
+
+// toRoutineViews turns the wire rows into view models. The phrase comes from
+// pattern.PhraseRoutine so the page says the same thing maven's voice says.
+func toRoutineViews(rs []ipc.ProposedRoutine) []routineView {
+	out := make([]routineView, 0, len(rs))
+	for _, r := range rs {
+		p := pattern.ProposedRoutine{Action: r.Action, Object: r.Object, IntervalDays: r.IntervalDays}
+		noticed := "just now"
+		if r.CreatedTs > 0 {
+			noticed = time.Since(time.UnixMilli(r.CreatedTs)).Round(time.Minute).String() + " ago"
+		}
+		out = append(out, routineView{ID: r.ID, Phrase: pattern.PhraseRoutine(&p), Noticed: noticed})
+	}
+	return out
+}
+
+// acceptRoutine marks a proposal accepted. This page is the ONLY surface that
+// may do it (Vikunja #367): accepting gives the tick loop a standing new
+// reason to speak, which DESIGN.md puts at layer 3, and the button here is
+// behind step-up. Voice can park the question and dismiss, never accept.
+func acceptRoutine(ctx context.Context, core ipc.CoreAPI, id int64) error {
+	proposed, err := core.ListProposedRoutines(ctx)
+	if err != nil {
+		return err
+	}
+	var found *ipc.ProposedRoutine
+	for i := range proposed {
+		if proposed[i].ID == id {
+			found = &proposed[i]
+			break
+		}
+	}
+	if found == nil {
+		return errors.New("no such proposed routine")
+	}
+
+	// No reminder is created here. Accepting only flips the status; the tick
+	// loop reads accepted routines and nudges on the interval (Vikunja #366).
+	// The old code made a one-shot reminder, so a non-weekly routine fired
+	// once and then went quiet forever.
+	return core.AcceptProposedRoutine(ctx, id)
+}
+
+// seedRoutineEvent drives one backdated fact write through core (Vikunja #518),
+// so the pattern detector can be exercised against a running daemon instead of
+// over real days. Refused unless mavend was started with -allow-seed; on an
+// ordinary box the error says so and nothing is written.
+//
+// Takes "ago" rather than an absolute timestamp — hours before now, as a float
+// so a QA sitting can space four seeds three hours apart without doing clock
+// arithmetic. The detector's floor is two hours, and "0" is a legal answer
+// meaning now.
+func seedRoutineEvent(ctx context.Context, core ipc.CoreAPI, r *http.Request) (string, error) {
+	key := strings.TrimSpace(r.FormValue("key"))
+	value := strings.TrimSpace(r.FormValue("value"))
+	if key == "" || value == "" {
+		return "", errors.New("seed needs a key and a value")
+	}
+	agoHours, err := strconv.ParseFloat(strings.TrimSpace(r.FormValue("ago")), 64)
+	if err != nil {
+		return "", fmt.Errorf("seed: bad ago (hours before now): %w", err)
+	}
+	if agoHours < 0 {
+		return "", errors.New("seed: ago is hours BEFORE now, so it cannot be negative")
+	}
+	resp, err := core.SeedEvent(ctx, ipc.SeedEventReq{
+		Key:   key,
+		Value: value,
+		Ts:    time.Now().Add(-time.Duration(agoHours * float64(time.Hour))),
+	})
+	if err != nil {
+		return "", err
+	}
+	if !resp.Extracted {
+		return fmt.Sprintf("wrote fact %d, but %q is not in the action lexicon — no event, no pattern", resp.FactID, value), nil
+	}
+	if !resp.Proposed {
+		return fmt.Sprintf("seeded %s/%s (fact %d, event %d) — not enough yet to propose", resp.Action, resp.Object, resp.FactID, resp.EventID), nil
+	}
+	return fmt.Sprintf("seeded %s/%s and PROPOSED routine %d, every %.1f days", resp.Action, resp.Object, resp.RoutineID, resp.IntervalDays), nil
+}

cmd/mavweb/shell.go

@@ -0,0 +1,195 @@
+package main
+
+import (
+	_ "embed"
+	"html/template"
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/webauthn"
+)
+
+// shellHTML — the shell partial every page is wrapped in: "shellTop", the
+// "sidebar" it calls, and "shellBottom". It used to be two Go string constants
+// with the sidebar assembled by a strings.Builder, which is the one piece of
+// markup that was still concatenated in Go.
+//
+// Two template pieces wrap every page:
+//
+//	{{template "shellTop" "<page-key>"}}  ← opens <html>, topbar, sidebar, content
+//	{{template "shellBottom"}}            ← closes content, inspector, </html>
+//
+// The page-key argument highlights the active sidebar link and sets breadcrumbs.
+//
+//go:embed shell.html
+var shellHTML string
+
+// sidebarSections maps sidebar section → page entries {label, url, icon}
+var sidebarSections = []struct {
+	Label string
+	Pages []struct{ Label, URL, Key string }
+}{
+	{
+		Label: "Workspace",
+		Pages: []struct{ Label, URL, Key string }{
+			{Label: "Dashboard", URL: "/dash", Key: "dash"},
+		},
+	},
+	{
+		Label: "Infrastructure",
+		Pages: []struct{ Label, URL, Key string }{
+			{Label: "History", URL: "/history", Key: "history"},
+		},
+	},
+	{
+		Label: "Automation",
+		Pages: []struct{ Label, URL, Key string }{
+			{Label: "Rule Trace", URL: "/trace", Key: "trace"},
+			{Label: "Notifications", URL: "/notifications", Key: "notifications"},
+			{Label: "Tasks", URL: "/tasks", Key: "tasks"},
+			{Label: "Reminders", URL: "/reminders", Key: "reminders"},
+			{Label: "Routines", URL: "/routines", Key: "routines"},
+			{Label: "Morning", URL: "/morning", Key: "morning"},
+			{Label: "Intake", URL: "/events", Key: "events"},
+		},
+	},
+	{
+		Label: "Ecosystem",
+		Pages: []struct{ Label, URL, Key string }{
+			{Label: "Siblings", URL: "/ecosystem", Key: "ecosystem"},
+		},
+	},
+	{
+		Label: "AI",
+		Pages: []struct{ Label, URL, Key string }{
+			{Label: "Chat", URL: "/chat", Key: "chat"},
+			{Label: "Voice", URL: "/", Key: "voice"},
+		},
+	},
+	{
+		Label: "Settings",
+		Pages: []struct{ Label, URL, Key string }{
+			{Label: "Tools", URL: "/tools", Key: "tools"},
+			{Label: "Model", URL: "/models", Key: "models"},
+			{Label: "Passkey", URL: "/auth/passkey", Key: "passkey"},
+		},
+	},
+}
+
+// pageChrome is the per-page title and ethos-icons.svg symbol id, keyed by the
+// page key a page hands to shellTop. One table rather than two parallel
+// switches, so a new page cannot end up with a title and no icon.
+var pageChrome = map[string]struct{ Title, Icon string }{
+	"dash":          {"Dashboard", "i-grid"},
+	"history":       {"History", "i-clock"},
+	"trace":         {"Rule Trace", "i-wave"},
+	"notifications": {"Notifications", "i-bell"},
+	"tasks":         {"Tasks", "i-grid"},
+	"reminders":     {"Reminders", "i-calendar"},
+	"routines":      {"Routines", "i-repeat"},
+	"morning":       {"Morning Routines", "i-calendar"},
+	"events":        {"Intake", "i-download"},
+	"chat":          {"Chat", "i-message"},
+	"voice":         {"Voice", "i-mic"},
+	"ecosystem":     {"Ecosystem", "i-grid"},
+	"tools":         {"Tools", "i-settings"},
+	"models":        {"Resident Model", "i-wave"},
+	"passkey":       {"Passkey", "i-lock"},
+}
+
+// pageIcon returns the ethos-icons.svg symbol id for the given page. The
+// sidebar template wraps it in the <use> reference.
+func pageIcon(key string) string {
+	if c, ok := pageChrome[key]; ok {
+		return c.Icon
+	}
+	return "i-search"
+}
+
+// pageTitle returns the human-readable page title for the given key. An
+// unknown key renders as itself rather than as a blank crumb.
+func pageTitle(key string) string {
+	if c, ok := pageChrome[key]; ok {
+		return c.Title
+	}
+	return key
+}
+
+// shellFuncs returns the FuncMap shared by every server-rendered page template.
+func shellFuncs() template.FuncMap {
+	return template.FuncMap{
+		"pageTitle":       pageTitle,
+		"pageIcon":        pageIcon,
+		"sidebarSections": func() any { return sidebarSections },
+		"ago": func(t time.Time) string {
+			if t.IsZero() {
+				return "never"
+			}
+			return time.Since(t).Round(time.Second).String() + " ago"
+		},
+	}
+}
+
+// parsePage parses one server-rendered page: the shell partial plus the page's
+// own embedded markup, under the shared FuncMap. extra adds page-local
+// functions (/tools needs capability lookups, /trace a time format) and may be
+// nil.
+//
+// The name is also the page's log label, so a render failure says which page.
+func parsePage(name, body string, extra template.FuncMap) *template.Template {
+	funcs := shellFuncs()
+	for k, v := range extra {
+		funcs[k] = v
+	}
+	return template.Must(template.New(name).Funcs(funcs).Parse(shellHTML + body))
+}
+
+// renderPage writes one page. Every handler sent the same content type and
+// logged the same way on failure; the header is already written by then, so a
+// render error can only be logged, never reported.
+func renderPage(w http.ResponseWriter, t *template.Template, data any) {
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	if err := t.Execute(w, data); err != nil {
+		log.Printf("%s render: %v", t.Name(), err)
+	}
+}
+
+// requireCore answers whether the surface has a core to read. mavweb runs
+// without -core (voice-only), and every page that needs mavend says so with a
+// 503 naming itself rather than a blank error.
+func requireCore(w http.ResponseWriter, core ipc.CoreAPI, surface string) bool {
+	if core == nil {
+		http.Error(w, surface+" disabled (no -core)", http.StatusServiceUnavailable)
+		return false
+	}
+	return true
+}
+
+// stepUpGate reports whether the caller may proceed through the AuthStepUp
+// gate, writing the 403 itself when it may not. See stepUpOK for the policy.
+func stepUpGate(w http.ResponseWriter, session *webauthn.PasskeySession, requireStepUp bool) bool {
+	if stepUpOK(session, requireStepUp) {
+		return true
+	}
+	http.Error(w, "step-up required: assert a passkey first", http.StatusForbidden)
+	return false
+}
+
+// stepUpOK is the single decision point for the AuthStepUp gate shared by
+// POST /tools and POST /api/revert.
+//
+// A nil session means WebAuthn is not configured (-webauthn-origin /
+// -webauthn-rpid unset), so step-up can never be asserted — not merely unmet.
+// The default is therefore fail-OPEN: gating on an unassertable session would
+// 403 those surfaces permanently. In that mode the actions rest on the
+// transport-level auth in front of mavweb (wg+nginx+auth), and main logs a
+// startup warning naming them. With -require-stepup the same situation fails
+// CLOSED instead: no assertable step-up ⇒ deny.
+func stepUpOK(session *webauthn.PasskeySession, requireStepUp bool) bool {
+	if session == nil {
+		return !requireStepUp
+	}
+	return session.IsStepUp()
+}

cmd/mavweb/tasks.go

@@ -0,0 +1,412 @@
+package main
+
+import (
+	"context"
+	_ "embed"
+	"errors"
+	"fmt"
+	"log"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/tasks"
+)
+
+//go:embed tasks.html
+var tasksHTML string
+
+var tasksTmpl = parsePage("tasks", tasksHTML, nil)
+
+// now — the wall clock, indirected so the task page can be rendered at a fixed
+// instant in a test. internal/tasks is pure and the daemon path already ranks
+// through a clock it is handed; the page had no reason to be the one surface
+// that could only be tested at whatever time it happened to run.
+var now = time.Now
+
+// resolvedShown — how many finished tasks the page renders. The list is
+// history, it only grows, and the rows below the first screen are read by
+// nobody.
+const resolvedShown = 50
+
+// taskRow is one line on /tasks, with every timestamp already formatted so the
+// template holds no date logic.
+type taskRow struct {
+	ID         int64
+	Text       string
+	Source     string
+	Evidence   string
+	Status     string
+	Due        string
+	Created    string
+	Resolved   string
+	ResolvedBy string
+	// DueValue and Weight are the raw values the edit form posts back
+	// (Vikunja #509). Due above is for reading and says "—" for no date; a
+	// date input needs "2026-08-07" or the empty string.
+	DueValue string
+	Weight   int
+	// Why — the ranker's reason for this row's position (Vikunja #129), in
+	// Russian, empty when nothing distinguished the task. Blank is the honest
+	// rendering: he never said this one mattered more.
+	Why string
+}
+
+// rowOf renders one wire task into the shared read-only columns. The two call
+// sites below add what only they need: the live rows carry the edit form's raw
+// values and the ranker's reason, the resolved rows carry neither.
+func rowOf(t ipc.Task) taskRow {
+	return taskRow{
+		ID: t.ID, Text: t.Text, Source: t.Source, Evidence: t.Evidence,
+		Status: t.Status, Created: fmtTaskTime(&t.CreatedTs),
+		Due: fmtTaskDate(t.Due), Resolved: fmtTaskTime(t.Resolved),
+		ResolvedBy: t.ResolvedBy,
+	}
+}
+
+// handleTasks serves the task review surface (GET) and the five writes it
+// offers (POST): add, edit, confirm, done, drop.
+//
+// Not step-up gated, unlike /tools and /routines, and the difference is the
+// point: enabling a tool defines argv Maven will execute, and accepting a
+// routine hands the tick loop a new standing reason to interrupt him. A task is
+// neither — nothing in the tick loop reads the tasks table, so the worst a
+// weaker caller can do here is write a line onto a list he reads himself. It
+// still sits behind whatever transport auth fronts mavweb, like every other
+// page.
+//
+// "edit" was re-argued on the same terms rather than inheriting the exemption
+// (Vikunja #509), and it stays ungated. It rewrites a line on a list he reads
+// himself, the same blast radius "drop" already has on this page, and the store
+// refuses the two edits that would cost something: a resolved task keeps the
+// text it was finished under, and a text collision with another live row is
+// named instead of merged.
+//
+// "confirm" is the only interesting move: it promotes a candidate Maven derived
+// from something she read into work he owns. That review step is why derived
+// tasks are captured as candidates in the first place.
+func handleTasks(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI) {
+	if !requireCore(w, core, "tasks") {
+		return
+	}
+	ctx := r.Context()
+	var msg, errMsg string
+	if r.Method == http.MethodPost {
+		var err error
+		msg, err = applyTaskPost(ctx, core, r)
+		if err != nil {
+			log.Printf("tasks: %v", err)
+			errMsg = err.Error()
+		}
+	}
+
+	all, err := core.ListTasks(ctx, "")
+	if err != nil {
+		log.Printf("tasks: list: %v", err)
+		http.Error(w, "tasks error: "+err.Error(), http.StatusBadGateway)
+		return
+	}
+	// Live rows are ordered by the same ranker the spoken list uses, so the page
+	// and the voice reply can never disagree about what comes first. Resolved
+	// rows keep store order (newest first) — ranking finished work is pointless.
+	var live []tasks.Item
+	var resolved []taskRow
+	resolvedTotal := 0
+	for _, t := range all {
+		switch t.Status {
+		case "candidate", "open":
+			live = append(live, tasks.Item{
+				ID: t.ID, Text: t.Text, Status: t.Status,
+				Created: t.CreatedTs, Due: t.Due, Weight: t.Weight,
+			})
+		default:
+			resolvedTotal++
+			// Finished work is history, and the history only grows. The page
+			// showed every row that ever existed, which is a page that gets
+			// slower every month for a section nobody reads past the top of.
+			if len(resolved) >= resolvedShown {
+				continue
+			}
+			resolved = append(resolved, rowOf(t))
+		}
+	}
+	byID := make(map[int64]ipc.Task, len(all))
+	for _, t := range all {
+		byID[t.ID] = t
+	}
+	var cands, open []taskRow
+	for _, r := range tasks.Rank(live, now()) {
+		t := byID[r.ID]
+		row := rowOf(t)
+		row.DueValue = fmtTaskDateValue(t.Due)
+		row.Weight = t.Weight
+		row.Why = r.Reason
+		if t.Status == "candidate" {
+			// A candidate's due date is Maven's reading of a mail, so its
+			// ranking reason is not shown as if he had set a priority.
+			row.Why = ""
+			cands = append(cands, row)
+		} else {
+			open = append(open, row)
+		}
+	}
+	renderPage(w, tasksTmpl, struct {
+		Msg, Err     string
+		Stalls       []tasks.Stall
+		Candidates   []taskRow
+		Open         []taskRow
+		Resolved     []taskRow
+		ResolvedMore bool
+	}{msg, errMsg, tasks.Stalls(live, now()), cands, open, resolved, resolvedTotal > len(resolved)})
+}
+
+// applyTaskPost performs one write and returns the message to show. A bad
+// request returns an error, which the page renders inline rather than as a
+// bare 400 — this is a form surface, not an API.
+func applyTaskPost(ctx context.Context, core ipc.CoreAPI, r *http.Request) (string, error) {
+	action := r.FormValue("action")
+	if action == "add" {
+		text := strings.TrimSpace(r.FormValue("text"))
+		if text == "" {
+			return "", errors.New("empty task text")
+		}
+		req := ipc.CaptureTaskReq{Text: text, Source: "tap:web", Status: "open", Ts: now()}
+		wgt, err := formWeight(r)
+		if err != nil {
+			return "", err
+		}
+		req.Weight = wgt
+		due, err := formDue(r, now())
+		if err != nil {
+			return "", err
+		}
+		req.Due = due
+		resp, err := core.CaptureTask(ctx, req)
+		if err != nil {
+			return "", err
+		}
+		if resp.Promoted {
+			return "confirmed a candidate maven had found", nil
+		}
+		if !resp.Created {
+			return "already on the list", nil
+		}
+		return "added task", nil
+	}
+
+	id, err := strconv.ParseInt(r.FormValue("id"), 10, 64)
+	if err != nil {
+		return "", errors.New("invalid id")
+	}
+
+	if action == "promote" {
+		msg, err := promoteCandidate(ctx, core, r, id)
+		if err != nil {
+			return "", err
+		}
+		return msg, nil
+	}
+
+	if action == "edit" {
+		// The three fields capture set, and only those (Vikunja #509). Status
+		// is not editable here: that ladder is one-way and has its own buttons.
+		text := strings.TrimSpace(r.FormValue("text"))
+		if text == "" {
+			return "", errors.New("empty task text")
+		}
+		wgt, err := formWeight(r)
+		if err != nil {
+			return "", err
+		}
+		due, err := formDue(r, now())
+		if err != nil {
+			return "", err
+		}
+		switch err := core.EditTask(ctx, id, text, due, wgt); {
+		case err == nil:
+			return "saved task", nil
+		case errors.Is(err, ipc.ErrTaskDuplicate):
+			// Naming the collision instead of merging: two live rows carry two
+			// provenances, and picking one is not the page's call.
+			return "", errors.New("another open task already says this — drop one of the two")
+		case errors.Is(err, ipc.ErrTaskResolved):
+			return "", errors.New("a resolved task keeps the text it was finished under")
+		default:
+			return "", err
+		}
+	}
+
+	var status, msg string
+	switch action {
+	case "confirm":
+		status, msg = "open", "confirmed task"
+	case "done":
+		status, msg = "done", "task done"
+	case "drop":
+		status, msg = "dropped", "dropped task"
+	default:
+		return "", fmt.Errorf("unknown action %q", action)
+	}
+	if err := core.SetTaskStatus(ctx, id, status, now(), "tap:web"); err != nil {
+		return "", statusWriteErr(err)
+	}
+	return msg, nil
+}
+
+// errNoDoneWhen — the refusal has to name what is missing, or the button looks
+// broken. The field it asks for arrives with the intake form (Vikunja #511).
+var errNoDoneWhen = errors.New("write a definition of done before confirming this candidate")
+
+// statusWriteErr translates a SetTaskStatus failure into what the page says.
+func statusWriteErr(err error) error {
+	if errors.Is(err, ipc.ErrTaskNoDoneWhen) {
+		return errNoDoneWhen
+	}
+	return err
+}
+
+// promoteCandidate turns a candidate into open work with the three things the
+// board needs (Vikunja #511): a definition of done, an optional blocker, and an
+// optional date.
+//
+// The definition of done is required, and the refusal is the store's — this
+// only reaches it in a readable order. The blocker is a NAME here and an entity
+// id in the row: identity lives in Nexus, so the name is resolved first and a
+// name Nexus cannot resolve stops the promotion instead of being stored.
+//
+// A date set here writes a reminder, which is the one unprompted delivery the
+// persona allows: he asked to be told, on a day he named.
+func promoteCandidate(ctx context.Context, core ipc.CoreAPI, r *http.Request, id int64) (string, error) {
+	doneWhen := strings.TrimSpace(r.FormValue("done_when"))
+	if doneWhen == "" {
+		return "", errors.New("write a definition of done — what has to be true for this to be finished")
+	}
+	text := strings.TrimSpace(r.FormValue("text"))
+	if text == "" {
+		return "", errors.New("empty task text")
+	}
+	due, err := formDue(r, now())
+	if err != nil {
+		return "", err
+	}
+
+	blockedOn, err := resolveBlocker(ctx, core, r.FormValue("blocked_on"))
+	if err != nil {
+		return "", err
+	}
+
+	if err := core.SetTaskFields(ctx, id, doneWhen, blockedOn); err != nil {
+		return "", err
+	}
+	wgt, err := formWeight(r)
+	if err != nil {
+		return "", err
+	}
+	// The importance select is posted whether or not a date is. This ran under
+	// `if due != nil`, so confirming a candidate as "срочно" with no deadline
+	// dropped the word on the floor — the row came back normal and nothing said
+	// why. A promote with neither field set still writes nothing.
+	if due != nil || wgt != 0 {
+		if err := core.EditTask(ctx, id, text, due, wgt); err != nil {
+			return "", err
+		}
+	}
+	if err := core.SetTaskStatus(ctx, id, "open", now(), "tap:web"); err != nil {
+		return "", statusWriteErr(err)
+	}
+	if due == nil {
+		return "confirmed", nil
+	}
+	// A date-only field has no hour. Nine in the morning, because the reminder
+	// is about a day's work and being told at midnight is being told the night
+	// before.
+	fire := time.Date(due.Year(), due.Month(), due.Day(), 9, 0, 0, 0, due.Location())
+	if _, err := core.CreateReminder(ctx, fire, text, ""); err != nil {
+		// The task IS promoted; only the reminder failed. Saying "confirmed"
+		// and nothing else would leave him expecting a nudge that will not come.
+		return "", fmt.Errorf("confirmed, but the reminder did not save: %w", err)
+	}
+	return "confirmed, and maven will remind you that morning", nil
+}
+
+// resolveBlocker turns the blocked-on NAME the form posts into the entity id
+// the row stores. Identity lives in Nexus, so an unresolvable name stops the
+// promotion instead of being written as free text. An empty field is no
+// blocker and reaches Nexus not at all.
+func resolveBlocker(ctx context.Context, core ipc.CoreAPI, field string) (string, error) {
+	name := strings.TrimSpace(field)
+	if name == "" {
+		return "", nil
+	}
+	ref, err := core.ResolveEntity(ctx, name, []string{"person"})
+	switch {
+	case errors.Is(err, ipc.ErrNotImplemented):
+		return "", errors.New("no identity service here, so blocked-on cannot be stored — leave it empty")
+	case errors.Is(err, ipc.ErrNoEntity):
+		return "", fmt.Errorf("nexus does not know %q", name)
+	case err != nil:
+		return "", fmt.Errorf("resolving %q: %w", name, err)
+	case ref.Ambiguous:
+		// Asking, not picking: a task blocked on the wrong person is a
+		// mistake nobody can see afterwards.
+		return "", fmt.Errorf("%q matches %s — say which", name, strings.Join(ref.Candidates, ", "))
+	}
+	return ref.ID, nil
+}
+
+// formWeight reads the importance select. Out-of-range clamps rather than
+// rejects — a bad select is not worth a 400 — but trailing garbage is refused,
+// because strconv is not Sscanf and "3junk" is not a 3.
+func formWeight(r *http.Request) (int, error) {
+	v := r.FormValue("weight")
+	if v == "" {
+		return 0, nil
+	}
+	wgt, err := strconv.Atoi(v)
+	if err != nil || wgt < 0 {
+		return 0, fmt.Errorf("bad weight %q", v)
+	}
+	if wgt > tasks.MaxWeight {
+		wgt = tasks.MaxWeight
+	}
+	return wgt, nil
+}
+
+// formDue reads the date input. An empty field is nil, which on an edit means
+// "clear the date" — the form has no other way to say it.
+func formDue(r *http.Request, now time.Time) (*time.Time, error) {
+	d := r.FormValue("due")
+	if d == "" {
+		return nil, nil
+	}
+	due, err := time.ParseInLocation("2006-01-02", d, now.Location())
+	if err != nil {
+		return nil, fmt.Errorf("bad due date %q", d)
+	}
+	return &due, nil
+}
+
+// fmtTaskDateValue renders a due date the way <input type=date> requires, or
+// "" for no date. Separate from fmtTaskDate, which renders it for reading.
+func fmtTaskDateValue(t *time.Time) string {
+	if t == nil || t.IsZero() {
+		return ""
+	}
+	return t.Local().Format("2006-01-02")
+}
+
+func fmtTaskTime(t *time.Time) string {
+	if t == nil || t.IsZero() {
+		return "—"
+	}
+	return t.Local().Format("02 Jan 15:04")
+}
+
+func fmtTaskDate(t *time.Time) string {
+	if t == nil || t.IsZero() {
+		return "—"
+	}
+	return t.Local().Format("02 Jan")
+}

cmd/mavweb/tasks.html

@@ -21,20 +21,43 @@
 </form>
 </section>
 
+{{if .Stalls}}
+<section class=card>
+<h2 class=card-title>shapes</h2>
+<!-- Counts, and nothing about what they mean (V-512). Whether a task should be
+     dropped is his call and Maven does not have an opinion to show here. -->
+<div class=scroll><table>
+<tr><th>count</th><th>shape</th></tr>
+{{range .Stalls}}<tr><td>{{.N}}</td><td>{{.Line}}</td></tr>{{end}}
+</table></div>
+</section>
+{{end}}
+
 {{if .Candidates}}
 <section class=card>
 <h2 class=card-title>found, not confirmed <span class=badge>{{len .Candidates}}</span></h2>
 <div class=hint>maven derived these from something she read. nothing counts as your work until you confirm it.</div>
+<div class=hint>confirming asks for a definition of done: what has to be true for this to be finished. a task without one can never leave the board. a date here also books a reminder that morning.</div>
 <div class=scroll><table>
-<tr><th>task</th><th>where from</th><th>due</th><th>captured</th><th></th><th></th></tr>
+<tr><th>task</th><th>where from</th><th>captured</th><th>confirm</th><th></th></tr>
 {{range .Candidates}}<tr>
 <td class=text-max>{{.Text}}</td>
 <td class=hint>{{.Source}}{{if .Evidence}} — {{.Evidence}}{{end}}</td>
-<td>{{.Due}}</td>
 <td class=muted>{{.Created}}</td>
 <td><form method=post action=/tasks class=inline-form>
 <input type=hidden name=id value="{{.ID}}">
-<input type=hidden name=action value=confirm>
+<input type=hidden name=action value=promote>
+<input type=hidden name=text value="{{.Text}}">
+<input type=text name=done_when placeholder="готово, когда…" size=26 required>
+<!-- A name, not an id. It is resolved against nexus before anything is
+     stored, and a name nexus cannot place stops the confirmation. -->
+<input type=text name=blocked_on placeholder="ждёт кого-то" size=14>
+<input type=date name=due value="{{.DueValue}}" title="due date">
+<select name=weight title=importance>
+<option value=0 {{if eq .Weight 0}}selected{{end}}>normal</option>
+<option value=2 {{if eq .Weight 2}}selected{{end}}>важно</option>
+<option value=3 {{if eq .Weight 3}}selected{{end}}>срочно</option>
+</select>
 <button class=btn>confirm</button></form></td>
 <td><form method=post action=/tasks class=inline-form>
 <input type=hidden name=id value="{{.ID}}">
@@ -48,12 +71,27 @@
 <h2 class=card-title>open <span class=badge>{{len .Open}}</span></h2>
 <div class=hint>most pressing first — by the deadlines and the urgency you gave. nothing about a task is guessed; the only signal that is not yours is age, which lifts anything sitting here for weeks.</div>
 {{if .Open}}<div class=scroll><table>
-<tr><th>task</th><th>why</th><th>from</th><th>due</th><th>captured</th><th></th><th></th></tr>
+<tr><th>task</th><th>why</th><th>from</th><th>captured</th><th></th><th></th></tr>
 {{range .Open}}<tr>
-<td class=text-max>{{.Text}}</td>
+<!-- The text, the date and the importance are editable in place (V-509): a
+     dictated task can carry a typo, and a deadline moves. The status is not
+     here — that ladder is one-way and has its own two buttons. -->
+<td class=text-max><form method=post action=/tasks class=inline-form>
+<input type=hidden name=id value="{{.ID}}">
+<input type=hidden name=action value=edit>
+<input type=text name=text value="{{.Text}}" size=30 required>
+<input type=date name=due value="{{.DueValue}}" title="due date">
+<select name=weight title=importance>
+<!-- Any weight that is not one of the three rungs keeps its own option, or
+     saving an unrelated edit would silently reset it to normal. -->
+{{if and (ne .Weight 0) (ne .Weight 2) (ne .Weight 3)}}<option value={{.Weight}} selected>{{.Weight}}</option>{{end}}
+<option value=0 {{if eq .Weight 0}}selected{{end}}>normal</option>
+<option value=2 {{if eq .Weight 2}}selected{{end}}>важно</option>
+<option value=3 {{if eq .Weight 3}}selected{{end}}>срочно</option>
+</select>
+<button class="btn btn-muted">save</button></form></td>
 <td class=hint>{{.Why}}</td>
 <td class=hint>{{.Source}}</td>
-<td>{{.Due}}</td>
 <td class=muted>{{.Created}}</td>
 <td><form method=post action=/tasks class=inline-form>
 <input type=hidden name=id value="{{.ID}}">

cmd/mavweb/tasks_test.go

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

cmd/mavweb/tools.go

@@ -0,0 +1,112 @@
+package main
+
+import (
+	"cmp"
+	_ "embed"
+	"html/template"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/kami/maven/internal/ipc"
+	"github.com/kami/maven/internal/tool"
+	"github.com/kami/maven/internal/webauthn"
+)
+
+//go:embed tools.html
+var toolsHTML string
+
+// toolsTmpl — the enable surface. Server-rendered, no JS: a plain HTML form
+// POSTs back to /tools to enable a proposal. html/template escapes tool names +
+// utterances (they came from voice STT — untrusted text).
+var toolsTmpl = parsePage("tools", toolsHTML, template.FuncMap{
+	"join":       strings.Join,
+	"capability": func(t ipc.Tool) string { return tool.CapabilityOf(t).String() },
+	"risk":       func(t ipc.Tool) string { return string(tool.RiskOf(t)) },
+})
+
+// handleTools serves the enable surface (GET) and applies an enable (POST).
+// POST fields: name, cmd (space-separated argv), destructive (checkbox). cmd is
+// whitespace-split — argv with embedded spaces isn't supported (ponytail: no
+// shell-word parsing; the box owner controls this input, quote a wrapper script
+// if an arg needs spaces).
+func handleTools(w http.ResponseWriter, r *http.Request, core ipc.CoreAPI, session *webauthn.PasskeySession, requireStepUp bool) {
+	if !requireCore(w, core, "tools") {
+		return
+	}
+	ctx := r.Context()
+	var msg string
+	if r.Method == http.MethodPost {
+		if !stepUpGate(w, session, requireStepUp) {
+			return
+		}
+		action := r.FormValue("action")
+		name := strings.TrimSpace(r.FormValue("name"))
+		switch action {
+		case "enable":
+			scope := r.FormValue("scope")
+			cmd := strings.Fields(r.FormValue("cmd"))
+			destructive := r.FormValue("destructive") != ""
+			if name == "" || len(cmd) == 0 {
+				http.Error(w, "name and cmd required", http.StatusBadRequest)
+				return
+			}
+			if err := core.EnableTool(ctx, name, cmd, destructive, scope, time.Now()); err != nil {
+				log.Printf("tools: enable %q: %v", name, err)
+				http.Error(w, "enable failed: "+err.Error(), http.StatusBadGateway)
+				return
+			}
+			msg = "enabled " + name
+		case "disable":
+			if name == "" {
+				http.Error(w, "name required", http.StatusBadRequest)
+				return
+			}
+			if err := core.DisableTool(ctx, name); err != nil {
+				log.Printf("tools: disable %q: %v", name, err)
+				http.Error(w, "disable failed: "+err.Error(), http.StatusBadGateway)
+				return
+			}
+			msg = "disabled " + name
+		case "dismiss":
+			if name == "" {
+				http.Error(w, "name required", http.StatusBadRequest)
+				return
+			}
+			if err := core.DeleteTool(ctx, name); err != nil {
+				log.Printf("tools: dismiss %q: %v", name, err)
+				http.Error(w, "dismiss failed: "+err.Error(), http.StatusBadGateway)
+				return
+			}
+			msg = "dismissed " + name
+		default:
+			http.Error(w, "unknown action", http.StatusBadRequest)
+			return
+		}
+	}
+	proposed, err1 := core.ListTools(ctx, "proposed")
+	enabled, err2 := core.ListTools(ctx, "enabled")
+	if err := cmp.Or(err1, err2); err != nil {
+		log.Printf("tools: %v", err)
+		http.Error(w, "core read failed", http.StatusBadGateway)
+		return
+	}
+	// MCP is off by default and an older core may not know the method at all,
+	// so a failure here renders an empty section rather than breaking the page.
+	servers, err := core.MCPServers(ctx)
+	if err != nil {
+		log.Printf("tools: mcp servers: %v", err)
+		servers = nil
+	}
+	// Enabled rows are shown grouped by capability domain (Vikunja #452). A
+	// flat list stops answering "what can she do to the house" somewhere
+	// around fifteen rows, and that is the question this page exists for.
+	renderPage(w, toolsTmpl, struct {
+		Msg      string
+		Proposed []ipc.Tool
+		Enabled  []ipc.Tool
+		Groups   []tool.CapabilityGroup
+		MCP      []ipc.MCPServerStatus
+	}{msg, proposed, enabled, tool.GroupByDomain(enabled), servers})
+}

cmd/mavweb/trace.html

@@ -1,9 +1,9 @@
 {{template "shellTop" "trace"}}
 <h1>Rule Trace</h1>
-<div class="hint mb-4">{{.Now | ago}} — winner: <strong>{{if .Winner}}{{.Winner}}{{else}}nothing fired{{end}}</strong></div>
+<div class="hint mb-4">{{.Tick.Now | ago}} — winner: <strong>{{if .Tick.Winner}}{{.Tick.Winner}}{{else}}nothing fired{{end}}</strong></div>
 <div class=scroll><table class=mono>
 <tr><th>rule<th>sev<th>predicate<th>gate<th>blocked by<th>detail<th>selected<th>lost to</tr>
-{{range .Rules}}<tr>
+{{range .Tick.Rules}}<tr>
 <td>{{.RuleName}}</td>
 <td>{{.Severity}}</td>
 <td class={{if .PredicateResult}}green{{else}}gray{{end}}>{{.PredicateResult}}</td>
@@ -21,5 +21,25 @@
 <td>{{.LostTo}}</td>
 </tr>{{end}}
 </table></div>
+
+<h1 class=mt-4>Turn Decisions</h1>
+<div class="hint mb-4">Who claimed each utterance, who lost it, and who was never asked. In memory, newest first, cleared on restart.</div>
+{{if not .Turns}}<div class=hint>no turn has run since the daemon started</div>{{end}}
+{{range .Turns}}
+<details class=mb-4>
+<summary><span class=mono>{{.Utterance}}</span> — <strong>{{if .Winner}}{{.Winner}}{{else}}nobody{{end}}</strong> <span class=hint>{{.Ts | ago}}</span></summary>
+<div class=scroll><table class=mono>
+<tr><th>stage<th>claimant<th>would have been<th>score<th>outcome<th>why</tr>
+{{range .Claims}}<tr>
+<td>{{.Stage}}</td>
+<td>{{.Claimant}}</td>
+<td>{{if .Intent}}{{.Intent}}{{else}}—{{end}}</td>
+<td>{{if .HasScore}}{{printf "%.3f" .Score}}{{else}}—{{end}}</td>
+<td class={{if eq .Outcome "won"}}green{{else if eq .Outcome "never_asked"}}red{{else}}gray{{end}}>{{.Outcome}}</td>
+<td>{{.Reason}}</td>
+</tr>{{end}}
+</table></div>
+</details>
+{{end}}
 {{template "shellBottom"}}
 </html>

cmd/mavweb/voiceproxy.go

@@ -0,0 +1,245 @@
+package main
+
+import (
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"net/url"
+	"time"
+
+	"github.com/coder/websocket"
+	"github.com/kami/maven/internal/audio"
+	"github.com/kami/maven/internal/voice"
+	"github.com/kami/maven/internal/webauthn"
+)
+
+// The two proxies onto mavend's voice port: GET /ws streams turns over a
+// websocket, POST /api/ptt does one turn over plain HTTP. Both carry the same
+// step-up gate, because speaking an act is not a smaller act than typing one
+// (Vikunja #317). The length-prefixed framing they share is at the bottom.
+
+// maxFrame caps a single voice frame in either direction.
+const maxFrame = 64 << 20
+
+// pushToTalk builds the one request either proxy sends. Surface is
+// SurfacePCClient for both: the browser is standing in for the PC client.
+func pushToTalk(pcm []byte) voice.Request {
+	return voice.Request{
+		ID:     uint64(time.Now().UnixNano()),
+		Method: voice.MethodPushToTalk,
+		Params: mustMarshal(voice.PushToTalkReq{
+			Audio:   audio.Audio{Format: audio.PCM16kMono, Bytes: pcm},
+			Lang:    "mixed",
+			Surface: voice.SurfacePCClient,
+		}),
+	}
+}
+
+func handleWS(w http.ResponseWriter, r *http.Request, voiceAddr string, session *webauthn.PasskeySession, requireStepUp bool) {
+	if !stepUpGate(w, session, requireStepUp) {
+		return
+	}
+	conn, err := websocket.Accept(w, r, &websocket.AcceptOptions{
+		OriginPatterns: []string{"*"},
+	})
+	if err != nil {
+		log.Printf("ws accept: %v", err)
+		return
+	}
+	defer conn.Close(websocket.StatusNormalClosure, "bye")
+
+	ctx := r.Context()
+
+	var d net.Dialer
+	tc, err := d.DialContext(ctx, "tcp", voiceAddr)
+	if err != nil {
+		log.Printf("dial voice: %v", err)
+		writeWSErr(conn, ctx, "voice unavailable")
+		return
+	}
+	defer tc.Close()
+
+	for {
+		_, msg, err := conn.Read(ctx)
+		if err != nil {
+			log.Printf("ws read: %v", err)
+			return
+		}
+		if len(msg) < 4 {
+			log.Printf("ws msg too short (%d bytes)", len(msg))
+			continue
+		}
+
+		log.Printf("ws got %d bytes from client", len(msg))
+		req := pushToTalk(msg)
+		if err := writeFrame(tc, &req); err != nil {
+			log.Printf("write voice req: %v", err)
+			return
+		}
+
+		// Read frames until we get the matching Response (handling any interleaved Pushes)
+		for {
+			resp, push, err := readOneFrame(tc)
+			if err != nil {
+				log.Printf("read voice: %v", err)
+				return
+			}
+			if push != nil {
+				data, _ := json.Marshal(push)
+				conn.Write(ctx, websocket.MessageText, data)
+				continue
+			}
+			if resp.Error != nil {
+				writeWSErr(conn, ctx, resp.Error.Message)
+				break
+			}
+			var pttResp voice.PushToTalkResp
+			if err := json.Unmarshal(resp.Result, &pttResp); err != nil {
+				log.Printf("unmarshal resp: %v", err)
+				break
+			}
+			if pttResp.ReplyText != "" {
+				conn.Write(ctx, websocket.MessageText, []byte(pttResp.ReplyText))
+			}
+			if len(pttResp.ReplyAudio.Bytes) > 0 {
+				conn.Write(ctx, websocket.MessageBinary, pttResp.ReplyAudio.Bytes)
+			}
+			break
+		}
+	}
+}
+
+func handlePTT(w http.ResponseWriter, r *http.Request, voiceAddr string, session *webauthn.PasskeySession, requireStepUp bool) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "POST only", 405)
+		return
+	}
+	if !stepUpGate(w, session, requireStepUp) {
+		return
+	}
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		http.Error(w, err.Error(), 400)
+		return
+	}
+	if len(body) < 4 {
+		http.Error(w, "too short", 400)
+		return
+	}
+
+	log.Printf("ptt got %d bytes from client", len(body))
+
+	var d net.Dialer
+	tc, err := d.DialContext(r.Context(), "tcp", voiceAddr)
+	if err != nil {
+		log.Printf("ptt dial voice: %v", err)
+		http.Error(w, "voice unavailable", 503)
+		return
+	}
+	defer tc.Close()
+
+	req := pushToTalk(body)
+	if err := writeFrame(tc, &req); err != nil {
+		log.Printf("ptt write: %v", err)
+		http.Error(w, err.Error(), 500)
+		return
+	}
+
+	for {
+		resp, push, err := readOneFrame(tc)
+		if err != nil {
+			log.Printf("ptt read: %v", err)
+			http.Error(w, err.Error(), 500)
+			return
+		}
+		if push != nil {
+			continue
+		}
+		if resp.Error != nil {
+			http.Error(w, resp.Error.Message, 500)
+			return
+		}
+		var pttResp voice.PushToTalkResp
+		if err := json.Unmarshal(resp.Result, &pttResp); err != nil {
+			http.Error(w, err.Error(), 500)
+			return
+		}
+		w.Header().Set("Content-Type", "audio/l16;rate=16000;channels=1")
+		// PathEscape, not QueryEscape (Vikunja #533). QueryEscape writes a space
+		// as "+", which is form encoding, and the client decodes this header
+		// with decodeURIComponent, which only knows "%20" — so every space in a
+		// spoken reply reached the on-page log as a plus sign. PathEscape is the
+		// flavour decodeURIComponent actually reverses, which keeps the encoding
+		// a property of the header rather than something the client has to know.
+		w.Header().Set("X-Reply-Text", url.PathEscape(pttResp.ReplyText))
+		w.Write(pttResp.ReplyAudio.Bytes)
+		return
+	}
+}
+
+func writeWSErr(conn *websocket.Conn, ctx context.Context, msg string) {
+	conn.Write(ctx, websocket.MessageText, []byte(`{"error":"`+msg+`"}`))
+}
+
+func writeFrame(w io.Writer, v any) error {
+	body, err := json.Marshal(v)
+	if err != nil {
+		return fmt.Errorf("marshal: %w", err)
+	}
+	if len(body) > maxFrame {
+		return fmt.Errorf("frame too large: %d", len(body))
+	}
+	var hdr [4]byte
+	binary.BigEndian.PutUint32(hdr[:], uint32(len(body)))
+	if _, err := w.Write(hdr[:]); err != nil {
+		return err
+	}
+	_, err = w.Write(body)
+	return err
+}
+
+func readFrame(r io.Reader, v any) error {
+	var hdr [4]byte
+	if _, err := io.ReadFull(r, hdr[:]); err != nil {
+		return err
+	}
+	n := binary.BigEndian.Uint32(hdr[:])
+	if n > maxFrame {
+		return fmt.Errorf("frame too large: %d", n)
+	}
+	buf := make([]byte, n)
+	if _, err := io.ReadFull(r, buf); err != nil {
+		return err
+	}
+	return json.Unmarshal(buf, v)
+}
+
+func readOneFrame(r io.Reader) (*voice.Response, *voice.Push, error) {
+	var raw struct {
+		ID     uint64          `json:"id"`
+		Result json.RawMessage `json:"r,omitempty"`
+		Error  *voice.RpcError `json:"e,omitempty"`
+		Kind   voice.PushKind  `json:"kind,omitempty"`
+		Params json.RawMessage `json:"p,omitempty"`
+	}
+	if err := readFrame(r, &raw); err != nil {
+		return nil, nil, err
+	}
+	if raw.Kind != "" && raw.ID == 0 {
+		return nil, &voice.Push{Kind: raw.Kind, Params: raw.Params}, nil
+	}
+	return &voice.Response{ID: raw.ID, Result: raw.Result, Error: raw.Error}, nil, nil
+}
+
+func mustMarshal(v any) json.RawMessage {
+	b, err := json.Marshal(v)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}

cmd/mavweb/webauthn.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	_ "embed"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -76,69 +77,17 @@ func newPasskeyHandle(cfg webauthn.Config, core ipc.CoreAPI, storePath string, s
 // on: assert here (bumps the daemon session to L3 for the assertion TTL), then
 // enable a tool on /tools within that window.
 func (h *PasskeyHandle) Page(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	passkeyTmpl.Execute(w, nil)
+	renderPage(w, passkeyTmpl, nil)
 }
 
-// passkeyPageHTML — rendered via passkeyTmpl (main.go) which wraps with shellTop/shellBottom.
-const passkeyPageHTML = `{{template "shellTop" "passkey"}}
-<h1>Passkey</h1>
-<p class=hint>Enroll a passkey once, then assert it to unlock destructive actions (tool enable) for a few minutes.</p>
-<div class=flex gap-2>
-<button class=btn onclick=enroll()>enroll passkey</button>
-<button class=btn onclick=assert()>assert (step-up)</button>
-<button class=btn onclick=rewrapKey()>rewrite cold-start key</button>
-<a href=/tools><button class=btn-primary>→ tools</button></a>
-</div>
-<p class=hint>Rewriting the cold-start key points it at the passkey you assert next. Every other enrolled passkey stops being able to unlock a cold-booted daemon.</p>
-<div id=msg></div>
-{{template "shellBottom"}}
-<script>
-const b64u=b=>btoa(String.fromCharCode(...new Uint8Array(b))).replace(/\+/g,'-').replace(/\//g,'_').replace(/=+$/,'');
-const ub64=s=>{s=s.replace(/-/g,'+').replace(/_/g,'/');const b=atob(s),a=new Uint8Array(b.length);for(let i=0;i<b.length;i++)a[i]=b.charCodeAt(i);return a;};
-const say=(t,ok)=>{const m=document.getElementById('msg');m.textContent=t;m.className=ok?'msg msg-ok':'msg msg-err';};
-async function enroll(){try{
- const {challenge,options}=await (await fetch('/auth/webauthn/register/begin')).json();
- options.challenge=ub64(options.challenge);
- options.user.id=ub64(options.user.id);
- const c=await navigator.credentials.create({publicKey:options});
- const r=await fetch('/auth/webauthn/register/finish',{method:'POST',headers:{'content-type':'application/json'},
-  body:JSON.stringify({challenge,credential:{id:c.id,type:c.type,response:{
-   clientDataJSON:b64u(c.response.clientDataJSON),attestationObject:b64u(c.response.attestationObject)}}})});
- if(!r.ok){say('enroll failed: '+await r.text(),false);return;}
- // The wrapped key can only be written from an assertion: PRF results are
- // not produced at create() time on most authenticators. Enrolment reports
- // whether PRF is available at all so he is not told cold-start works when
- // it cannot.
- const ext=c.getClientExtensionResults?c.getClientExtensionResults():{};
- const prfOK=!!(ext.prf&&ext.prf.enabled);
- say(prfOK?'enrolled ✓ — now assert once to write the cold-start key':
-  'enrolled ✓ — but this authenticator has no PRF: cold-start unlock unavailable',true);
-}catch(e){say('enroll error: '+e,false);}}
-async function assert(explicit){try{
- const {challenge,options}=await (await fetch('/auth/webauthn/assert/begin')).json();
- options.challenge=ub64(options.challenge);
- const c=await navigator.credentials.get({publicKey:options});
- // The PRF result is the cold-start secret. It never touches localStorage
- // and is posted once, over the same request as the assertion.
- const ext=c.getClientExtensionResults?c.getClientExtensionResults():{};
- const prf=ext.prf&&ext.prf.results&&ext.prf.results.first?b64u(ext.prf.results.first):'';
- const r=await fetch('/auth/webauthn/assert/finish',{method:'POST',headers:{'content-type':'application/json'},
-  body:JSON.stringify({challenge,prf,explicit:!!explicit,credential:{id:c.id,type:c.type,response:{
-   clientDataJSON:b64u(c.response.clientDataJSON),authenticatorData:b64u(c.response.authenticatorData),
-   signature:b64u(c.response.signature)}}})});
- if(!r.ok){say('assert failed: '+await r.text(),false);return;}
- if(!prf){say('stepped up ✓ — no PRF from this authenticator, so cold-start unlock stayed unavailable',true);return;}
- say(explicit?'stepped up ✓ — cold-start key now points at this passkey':
-  'stepped up ✓ — enable tools now',true);
-}catch(e){say('assert error: '+e,false);}}
-// Rewriting the wrapped key is a separate gesture, never a side effect of a
-// step-up. Only this button sets explicit, and only explicit lets the daemon
-// replace a blob that already exists.
-async function rewrapKey(){
- if(!confirm('Rewrite the cold-start key under the passkey you are about to assert? Every other enrolled passkey stops being able to unlock a cold-booted daemon.'))return;
- await assert(true);}
-</script>`
+// passkeyPageHTML — the enrolment page's own markup, wrapped by passkeyTmpl
+// with shellTop/shellBottom. It was a Go string constant, which is the one
+// place page markup still lived in Go.
+//
+//go:embed passkey.html
+var passkeyPageHTML string
+
+var passkeyTmpl = parsePage("passkey", passkeyPageHTML, nil)
 
 func (h *PasskeyHandle) RegisterBegin(w http.ResponseWriter, r *http.Request) {
 	opts, challenge, err := h.rp.CreationOptions([]byte("maven-user"), "maven user")

docs/evals/2026-08-05-audio-in-routing.md

@@ -0,0 +1,93 @@
+# Routing from audio: four paths, one fixture
+
+**05-08-2026. Vikunja #486.** Workstation `gemma-4-12B-it-qat-UD-Q4_K_XL` with
+`mmproj-F16.gguf`, homesrv whisper `ggml-small`, piper `ru_RU-irina-medium`.
+
+**Verdict: transcribe, then route.** One call from audio straight to a route loses 36
+points, so it is not a candidate. Moving speech-to-text to the workstation buys 375ms and
+better transcripts at no measurable accuracy cost. So #486 proceeds on the two-call shape.
+
+## The numbers
+
+72 Russian cases from `internal/router/eval/ru_routing_v1.json`, rendered by piper at
+16kHz mono, 153.9s of audio, mean 2.14s per clip. Every path used the daemon's own
+`routeSystem` prompt and `routeGrammar`, read out of `internal/router/llmrouter.go` at run
+time, at `temperature 0` and `enable_thinking:false`.
+
+| Path | Intent-only | Verbatim transcripts | p50 | p95 |
+|---|---|---|---|---|
+| text in, the ceiling | **90.3%** (65/72) | — | 361ms | 495ms |
+| whisper on homesrv, then route | **84.7%** (61/72) | 29/72 | 1372ms | 1546ms |
+| workstation transcribes, then routes | **83.3%** (60/72) | 48/72 | 997ms | 1177ms |
+| workstation, one call from audio | **54.2%** (39/72) | — | 425ms | 756ms |
+
+The 90.3% ceiling is the same model on the same 72 cases with the utterance as text. It is
+not the 93.5% in `docs/evals/2026-08-02-workstation-gemma4-12b.md`, which scored all 87
+cases including the English ones.
+
+The two speech-to-text paths differ by one case, which is noise on 72. So the choice
+between them is latency and transcript quality, and the workstation wins both.
+
+## One call from audio is not a transcription failure
+
+The obvious reading of 54.2% is that the audio encoder cannot hear Russian. It can. Eight
+of the failing clips were sent back with a transcribe instruction instead of the router
+prompt:
+
+| Clip | Said | Heard, transcribing | Routing from audio |
+|---|---|---|---|
+| ru-sys-002 | какое число завтра | Какое число завтра? | `unknown` |
+| ru-sys-003 | переходи в тихий режим | Переходи в тихий режим. | `unknown` |
+| ru-query-001 | сколько воды я выпил с утра | Сколько воды я выпил с утра? | `fact`, value "выпил с утра" |
+| ru-act-002 | выключи свет в спальне | Выключи свет в спальне. | `fact`, value "включен" |
+
+Four clips it transcribes word for word, and routes wrong or refuses. The `ru-query-001`
+row shows the mechanism: the emitted slot holds the tail of the sentence and the
+interrogative head is gone. The model is not deaf, it stops attending to the audio once it
+is also holding a 3.5k-character classification prompt.
+
+That pattern decides the whole task. A long system prompt and an audio part compete, so the
+transcription has to be its own call with a short instruction. It also means the number
+would not be rescued by a better prompt, a longer clip, or a bigger `mmproj`.
+
+The failures cluster where the head of the sentence carries the intent: `ru-act` 1/6,
+`ru-sys` 2/5, `ru-query` 12/25. Reminders scored 10/10, because "напомни" is the first word
+and nothing after it changes the answer.
+
+## Transcript quality and routing accuracy come apart
+
+The workstation transcribes 48 of 72 verbatim against whisper's 29, and routes one case
+worse. Both directions of that appear in the same run:
+
+- `ru-chat-002`: whisper heard "Кто думаешь про переезд", the workstation heard "Что ты
+  думаешь про переезд". The correct transcript routed to `chat`, the broken one to `query`.
+- `ru-query-020`: whisper heard "Кто дальше?", the workstation heard the correct "Что
+  дальше?". The **broken** transcript routed correctly and the correct one missed.
+
+A word error rate is not a proxy for routing accuracy here. Judge a speech-to-text change
+on the routing fixture, not on transcripts.
+
+Three cases only the text path gets right. No speech-to-text path recovers them, so they
+are lost in the rendering rather than in the model.
+
+## Latency
+
+Whisper `ggml-small` on homesrv CPU costs p50 998ms for a 2.14s clip, which is nearly
+all of that path's 1372ms. The workstation does the same job inside its 997ms end-to-end
+total for two calls. So the transfer is worth about 375ms per turn at p50, and more at p95.
+
+Both are above the one-call 425ms, and that is the trade the table settles: 29 points of
+accuracy for 572ms.
+
+## Notes for the next run
+
+- `--mmproj /mnt/D/AI/gemma4/mmproj-F16.gguf` has to be in `llama_args` in
+  `~/.config/mavgpud.json`, or `/props` reports `modalities.audio: false` and every audio
+  part is dropped silently. It was added for this measurement and removed afterwards, so
+  the box is back to the text-only config.
+- `enable_thinking:false` is mandatory. It was set for all 224 calls here.
+- The degenerate `<|channel>thought` output recorded against #486 did not reproduce, in 80
+  transcribe calls or in 144 routing calls.
+- Piper renders at 22050Hz mono. Every clip was resampled with
+  `ffmpeg -ar 16000 -ac 1 -c:a pcm_s16le`, because 16kHz is what `audio.PCM16kMono`
+  declares and what the earlier measurement used.

docs/evals/2026-08-05-reach-llm-router.md

@@ -0,0 +1,70 @@
+# Ecosystem reach with the resident model as router
+
+Date: 2026-08-05. Vikunja #517, split out of #405.
+Fixture: `internal/router/eval/ru_ecosystem_v1.json`, 30 held-out Russian cases.
+Model: Qwen3-1.7B-UD-Q4_K_XL, llama-server on the host at 127.0.0.1:8899.
+Harness: `TestReachWithLLMRouter` in `internal/router/eval/llmrouter_test.go`.
+
+## The numbers
+
+| configuration | reached the right place | praxis | hexis | none |
+|---|---|---|---|---|
+| classifier + hash (V-405 floor) | 16/30 | 0/12 | — | — |
+| classifier + ONNX, after the V-516 grammars | 27/30 | 11/12 | — | — |
+| **llm-only** (resident model alone) | **17/30 (56.7%)** | **0/12** | 10/10 | 7/8 |
+| **cascade + llm** + hash fallback | **28/30 (93.3%)** | **11/12** | 10/10 | 7/8 |
+
+Latency: llm-only p50 1.29s, p95 1.65s. Cascade p50 1.11s, p95 1.64s.
+No case errored in either configuration.
+
+## The open question is answered: the model never reaches Praxis
+
+The route grammar lets the model write any string into the `fn` slot. So it
+could in principle emit a literal Praxis capability name, and reach a service
+the classifier structurally cannot. It does not. **Praxis is 0/12 with the
+model alone.** That is exactly what the classifier alone scores. Every one of
+the twelve fails the same way: the utterance stays local with an empty `fn`.
+
+So the stage-0 Praxis grammars from V-516 are not a determinism argument. They
+are the only path to Praxis that exists. Deleting them takes reach from 11/12
+back to 0/12 whichever engine is answering.
+
+The failure is not that the model routes these badly in its own terms. It
+spreads them across `query`, `fact`, `system` and `chat`. Those are reasonable
+readings of "что требует внимания" and "готово, закрывай" for a model that has
+never been told Praxis exists. Nothing in the prompt names a Praxis capability,
+so there is no string for it to write.
+
+## What the model does buy
+
+Hexis is 10/10 with the model alone, and the mutating tag is 10/15 llm-only
+against 15/15 through the cascade. The model reaches everything Hexis owns
+without help, which is the half the act allowlist already names in the prompt.
+
+Cascade + llm scores one point above the classifier baseline: 28/30 against
+27/30, the difference being one attention case. That is the same shape as the
+routing fixture, where the router buys about 4 points rather than a doubling.
+
+## The two that still miss
+
+- `eco-ru-021 "что там с нексусом"`. Routes `query`, stays local, wants Praxis.
+  Asking after a named service reads as a question about a thing, and no
+  grammar claims a service name.
+- `eco-ru-029 "сделай это"`. Routes `act` and reaches Hexis. The fixture wants
+  nothing reached, because "это" names no target. This is the overreach case
+  and it is the one direction worth failing on. The confirmation binding
+  downstream still resolves a canonical entity id before anything executes.
+  The fixture is right that the turn should have asked.
+
+Overreach is 1 in both configurations, under the 4 the harness asserts.
+
+## How to re-run
+
+```sh
+MAVEN_LLM_URL=http://127.0.0.1:8899 \
+  deps/go/go/bin/go test -v -count=1 -timeout 40m \
+  -run TestReachWithLLMRouter ./internal/router/eval/
+```
+
+The host `http_proxy` answers 503 for 127.0.0.1. `noProxyLoopback` in the test
+excludes it. A run that scores every case as a route error measured the proxy.

docs/evals/2026-08-05-routing-resident-model.md

@@ -0,0 +1,69 @@
+# Routing with the resident model, re-measured
+
+Date: 2026-08-05. Vikunja #320 items 2 and 3.
+Fixture: `internal/router/eval/ru_routing_v1.json`, now **91 cases** (76 ru, 15 en).
+Model: Qwen3-1.7B-UD-Q4_K_XL, llama-server on the host at 127.0.0.1:8899.
+Harness: `TestLLMRouterBaseline`, `make eval-models`.
+
+## How the block was cleared
+
+Item 2 was blocked because the resident llama-server binds `--host 127.0.0.1
+--port 0` inside `maven-mavend-1`. The port is kernel-assigned, scraped from
+stderr and never published, so no `go test` on the host can reach it. The task
+listed three ways out. This run took the first: a **second** llama-server on
+the same gguf, on a fixed host port. The Vega takes the second copy of a 1.7B
+without complaint.
+
+## The numbers
+
+| configuration | full | intent-only | p50 | p95 |
+|---|---|---|---|---|
+| llm-only | 34/91 (37.4%) | 61.5% | 1.24s | 1.65s |
+| cascade + llm + hash fallback | 69/91 (75.8%) | 80.2% | 1.19s | 1.65s |
+
+By language, through the cascade: ru 57/76, en 12/15.
+Clarify: 3 false, 1 missed. No errors. Six slots deferred to the daemon.
+
+For comparison, the figures that stood in CLAUDE.md were 72.7% full and 77.9%
+intent-only, measured on 77 cases. The fixture has grown by 14 cases since, so
+this is a new baseline rather than a movement.
+
+## llm-only is low for a reason that is not routing
+
+37.4% full against 61.5% intent-only is the gap, and it is almost entirely
+slots. Every reminder case fails with "no time slot, want one". The model
+routes `reminder` correctly and leaves the time to the daemon, which is what
+the contract asks of it. The cascade fills those slots. That is why the same
+model scores 38 points higher inside it.
+
+Three cases errored in the llm-only arm and none in the cascade, which is the
+fallback working as designed.
+
+## Item 3: latency
+
+Router p50 1.19s, p95 1.65s, max 1.79s through the cascade. The one earlier
+data point in the task, roughly 6s wall clock for `привет` through
+`POST /api/chat`, was the whole path and not the router. It is not comparable
+and should not be quoted as a routing number.
+
+These numbers are the homesrv floor. With the workstation up, routing completes
+against gemma-4-12b at p50 329ms, measured separately in
+`docs/evals/2026-08-02-workstation-gemma4-12b.md`.
+
+## What still misses
+
+The confusion is concentrated in one direction: `query→fact ×4`,
+`query→note ×3`, `query→system ×3`. A question about his own rows that carries
+no interrogative reads as a statement to the model. Ten of the twenty-two
+failures are that shape, including "я сегодня вообще пил воду" and "чем я
+занимался в среду". This is the case V-546's three-head classifier is aimed at.
+
+The two `разбуди меня` cases clarify at 0.300 instead of routing `reminder`.
+
+## Item 4 is still not run
+
+Killing the resident llama-server to confirm the classifier floor needs a
+permission this session does not have. The test is otherwise ready. It now has
+a second half. With the workstation up, killing the resident server should
+still complete a turn through `modelSeam`. Only killing both proves the
+classifier answers.

docs/evals/2026-08-06-claimant-interleave.md

@@ -0,0 +1,93 @@
+# Nine claimants interrupting a parked reminder
+
+Measured 2026-08-06 on homesrv against master at `70b32af`, so after V-560, V-565, V-567
+and V-572. Probed through `POST /api/chat` on mavweb, three turns per scenario, an explicit
+`отмена` between scenarios so each starts from an empty pending slot.
+
+The question this answers: the Rome failure was one claimant eating one question. How many
+other claimants do the same, and does routing first fix all of them or only weather?
+
+## Time forms, no pending state
+
+V-572 holds for every spoken shape, not just the one it was measured on.
+
+| said | answered |
+|---|---|
+| `напомни в 11:00 позвонить маме` | `хорошо, напомню сегодня в 11:00.` |
+| `напомни в 9 позвонить маме` | `хорошо, напомню сегодня в 09:00.` |
+| `напомни в 9 утра позвонить маме` | `хорошо, напомню сегодня в 09:00.` |
+| `напомни завтра в 9 купить молоко` | `хорошо, напомню завтра в 09:00.` |
+| `напомни в девять позвонить маме` | `хорошо, напомню сегодня в 09:00.` |
+| `напомни через час выпить воды` | `хорошо, напомню сегодня в 02:26.` |
+
+The spelled-out `девять` works, which is the lexicon's oblique cardinals doing their job.
+
+## The nine scenarios
+
+Each opens with a reminder that names no time, so a clarify is parked. Then a different
+claimant speaks.
+
+| | interrupted by | claiming source | flow | verdict |
+|---|---|---|---|---|
+| A | `какая сейчас погода в Риме?` | weather | dropped, announced | question answered |
+| B | `что я говорил про отпуск?` | personal | dropped, announced | question answered |
+| C | `какая столица Франции?` | search | dropped, announced | question answered |
+| D | `у меня новый ноутбук` | none | kept | **note silently discarded** |
+| E | `что у меня сегодня?` | none | completed wrongly | **reminder invented at the clock** |
+| F | `что требует внимания?` | none | dropped, announced | question answered |
+| G | `напомни завтра в 9 купить молоко` | none | dropped, announced | new reminder set |
+| H | reminder said whole, then weather, then a repair | weather | none parked | **repair invents a note** |
+| I | `сколько времени?` | none | dropped, announced | question answered |
+
+Six of nine answer the interrupting utterance. That is what V-560 bought, and it is the
+half of Rome that was broken.
+
+## The three that fail
+
+**E is the worst of the nine.**
+
+```text
+me:     напомни забрать посылку
+maven:  Когда?
+me:     что у меня сегодня?
+maven:  хорошо, напомню сегодня в 01:28.
+```
+
+The agenda question is never answered and a reminder exists that nobody asked for, at the
+current minute. Asked with nothing parked, the same sentence is answered by the calendar.
+So stage 0 routes it correctly and the pending claimant runs in front of that route. This
+is worse than the pre-V-560 Rome behaviour, which at least failed audibly. Filed as V-577.
+
+**D drops a note without saying so.**
+
+```text
+me:     напомни позвонить врачу
+maven:  Когда?
+me:     у меня новый ноутбук
+maven:  Во сколько напомнить?
+```
+
+Nothing wrong is written, and nothing right is either. Alone the sentence is stored. Also
+V-577.
+
+**H writes a note nobody dictated.**
+
+```text
+нет, не маме, а папе  ->  Сохранила заметку о том, что ты поедешь на дачу.
+```
+
+Reproduced with no pending state at all, twice, with two different inventions. The stored
+body is generated rather than captured. Filed as V-576. It is the only defect here that outlives
+the turn. A wrong note is indexed and comes back later as recall.
+
+## What the drop notice looks like now
+
+Six scenarios answer the question and say `Прошлую просьбу отпускаю.` first. That sentence
+is rejected by the owner. V-561 replaces it with suspend and resume for a side query, and
+keeps it for a new request (G) and a cancel.
+
+## Reading of the set
+
+The pattern behind Rome, V-567 and V-577 is one pattern. The claimant that knows least
+about the utterance holds the earliest and strongest trigger. V-560 moved the routing
+in front of one resolver. The other roles still decide before the route is read.

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

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

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

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

docs/offload.md

@@ -1,6 +1,6 @@
 # Offloading model work to the workstation
 
-*Last verified: 2026-08-03 @ 12530c8. Living doc: correct it in place, do not append.*
+*Last verified: 2026-08-05 @ b789676. Living doc: correct it in place, do not append.*
 
 Owner's call, 2026-08-02. Vikunja #483 is the umbrella. Tasks #484 to #487 are the
 work, and this file holds the shape and the rules all four must obey.
@@ -149,6 +149,13 @@ flips. It is wired anyway: `PhraseReminder` is on the same transport and is on.
 Then the embedder above, **whisper.cpp** in `mavsttd`, and **piper** in `mavttsd`.
 `mavwaked` uses no model at all: an energy-threshold VAD over 30ms frames.
 
+Speech-to-text stays two stages when it moves. One call carrying both a clip and the router
+prompt was measured on 05-08-2026. It scores 54.2% intent-only against 84.7% for whisper on
+homesrv, on the same 72 cases. The model transcribes clips it then routes wrong, so a long
+classification prompt and an audio part compete for attention. Transcribing on the
+workstation and routing the text scores 83.3% at p50 997ms. So the transfer buys 375ms and
+cleaner transcripts, not accuracy. See `docs/evals/2026-08-05-audio-in-routing.md`.
+
 ## Order
 
 1. **Transport** (#484). Nothing else is possible until a seam can cross a host.

docs/plans/17-where-the-voice-loop-runs.md

@@ -47,7 +47,13 @@ for.
 
 QA session 1 step 2 should say what it actually covers, which is push-to-talk through
 `/dash`. It should not read as though it covers the voice loop. The wake path is checked
-on the client machine or it is not checked, and today there is no client machine.
+on the client machine or it is not checked.
+
+**Correction, 2026-08-05.** This plan said there was no client machine. There is: workpc,
+where he sits most of the day and where the microphone is. The sentence was written when
+the workstation was only a model host. The verdict above is unchanged, and so is
+everything about the seam. What changes is the size of the remaining work: deploying two
+daemons and asking mavend to listen on TCP, not acquiring hardware.
 
 That is the honest state, and it is worse than the task suggests: this is not a
 configuration gap that a compose entry closes. Until a machine with a microphone runs

docs/plans/19-dialogue-arbitration.md

@@ -0,0 +1,135 @@
+# Plan: dialogue arbitration, one channel and many claimants
+
+Umbrella V-558. This file collects the design for its children.
+
+Last verified: 06-08-2026 @ b6305f1
+
+## A common unit for claims on an utterance (V-565)
+
+**Verdict: four ordinal bands, and the band is the tie-break rather than the decision.
+Coverage decides first.** The measurement below says no claimant Maven has today can produce
+a graded confidence. A float would be an invention either way. What is available is the KIND
+of evidence a claimant holds, and there are exactly four kinds.
+
+### What the claimants report today
+
+Measured 06-08-2026 on the 91-case RU fixture (`internal/router/eval`), through the deployed
+cascade with the quantized multilingual-e5-small embedder. The harness is
+`TestONNXClaimConfidenceDistribution` and `TestStage0Contention` in
+`internal/router/eval/claims_test.go`. Correct means the right intent, or a refusal where the
+fixture wants one. Slots are excluded, because a slot miss is a parser question and would
+blur what the number is being asked to predict.
+
+| Claimant | Values it can emit | Distribution on the fixture | Correct |
+|---|---|---|---|
+| Stage 0 grammars, 21 of them | `1.0`, always | claimed 20 of 91 cases | 20/20 (100%) |
+| Classifier, cosine | continuous in principle | observed range 0.859 to 0.942 over 71 cases | 44/71 (62%) |
+| LLM router | `1.0` or `0.3`, nothing between | not run here, no llama-server | see below |
+| Query sources, 22 of them | a bool | not routed by the fixture | n/a |
+| Stateful four | nothing at all | n/a | n/a |
+
+Four findings, and each one constrains the band set.
+
+**The classifier's cosine carries no signal about correctness.** It scores 62% below the
+median and 62% above it. That is 13/21 in 0.8 to 0.9, and 31/50 in 0.9 to 1.0. The spread is
+0.083 wide. Every case sits above the 0.55 threshold, so the gate never fires here. A number
+flat against correctness, which never crosses its own gate, is not a confidence.
+
+**Nor does the margin between its top two intents.** Top1 minus top2 is min 0.000, p50
+0.009, max 0.025. Sixty-eight of the 71 classified cases sit under 0.02 and score 60%. Three
+clear 0.02 and score 3/3, which is a sample of three. So the ledger's question is answered:
+a calibrated float is NOT cheaply available from the classifier alone. Nearest-centroid over
+frozen seeds ranks intents, and the ranking is decided in the third decimal place. It can say
+which intent is nearest. It cannot say how near.
+
+**Stage 0 asserts 1.0 by fiat, and on this fixture the fiat is right.** Twenty of twenty.
+That is not evidence that a hand-written anchored pattern is always right. It is evidence
+that anchored and nearest are different kinds of claim, and must not share a scale. The gap
+is 100% against 62% on the same 91 utterances.
+
+**Stage 0 contention is rarer than the list order suggests.** Exactly one case of 91 draws
+two grammars. That is `ru-query-019`, where `calendar-query` and `agenda-query` both match,
+and `calendar-query` wins because it is earlier in `buildRouter`. Both would route
+`IntentQuery`, so the ordering costs nothing there. The finding is not that ordering is
+harmless. It is that the fixture barely exercises what V-558 is about. Part of what a claim
+object buys is making the contention countable.
+
+**The LLM router emits two values, and one of them is not a confidence.** `llmFullConfidence`
+is 1.0 and `llmThinConfidence` is 0.3. `gateLLMDecision` moves a decision to 0.3 through
+three named arms. A fact with no key, an act with no allowlisted fn, a reminder with no
+subject. Each is a self-veto with a reason, flattened into a number that then loses the
+reason. Both values are meaningful only against `config.DefaultRouterThreshold`. 0.3 is below
+0.55 and 1.0 is above it, and nothing anywhere reads any other property of either.
+
+### The band set
+
+Four bands, ordinal, highest first. They name the kind of evidence, because that is the one
+thing every claimant can report without inventing it.
+
+**`BandAnchored`.** A literal pattern anchored in the utterance matched, and the matched span
+is what decides the intent. Stage 0 grammars and query-source matchers. The claimant is
+certain about the shape of the sentence. That is not the same as being certain about the
+answer. Measured 20/20.
+
+**`BandStructural`.** A claimant read the whole sentence and produced a complete route. Every
+slot the intent requires is filled. The LLM router at `llmFullConfidence` sits here, and so
+does a stateful claimant holding a pending question. Not anchored, because nothing in the
+utterance is pointed at.
+
+**`BandNearest`.** The claim rests only on resemblance to something else. No anchor in the
+utterance, no structural check behind it. The classifier. One band rather than a graded
+scale, and the measurement is the argument. 62% at both ends of the cosine range, and a
+top-two margin that never reaches 0.03.
+
+**`BandVetoed`.** The claimant will take the turn only if nobody else will, and says why it
+should not. The three arms of `gateLLMDecision` land here with their reason preserved. A
+vetoed claim is still a claim. Maven asking "о чём напомнить?" beats silence.
+
+There is no fifth band, and that is a measurement result rather than a preference. No
+claimant in the cascade today can report what a fifth band would carry. V-546 lands a softmax
+head whose max probability is a calibrated number. That one gets read as a number, not
+squeezed into these four.
+
+### Coverage decides before the band does
+
+The band is the tie-break. The first question is how much of the utterance a claim explains,
+and that is `Consumed` against `Unexplained` on the claim object. Two reasons.
+
+It is the fix for the failure that opened V-558. "какая сейчас погода в Риме?" arrived while
+a reminder was pending. The pending claimant ate the whole utterance as a time answer while
+explaining none of it. Not "погода", not "Риме", not the question mark. A weather claim
+explains all of it. Coverage-first arbitration prefers the weather claim without knowing that
+a pending reminder is less trustworthy than a grammar. The pending question then survives to
+be asked again.
+
+It also keeps the stateful four out of the top slot without special-casing them. They sit at
+`BandStructural`, below any anchored claim. That is the whole V-558 complaint about the
+highest-priority claimants being the least informed, expressed as one rule.
+
+### The claim object
+
+```go
+type Claim struct {
+    Claimant    string   // who wants the turn
+    Intent      string   // plain string: internal/dialogue must not import internal/router
+    Filled      []string // the slots this claim would fill
+    Consumed    []string // utterance tokens this claim explains
+    Unexplained []string // the rest, in order
+    Band        Band
+    Veto        string   // why this claim should NOT win, empty when there is none
+}
+```
+
+`Intent` is a plain `string` rather than `router.Intent` on purpose. `internal/dialogue` must
+not import `internal/router`, so the claim package must not either, and a shared string costs
+one conversion at each edge.
+
+`Unexplained` is carried rather than derived at read time. A claimant can then decline to
+explain a span it did match.
+
+### What this task does not do
+
+`router.Decision.Confidence` stays and keeps its float. `r.threshold` and `gateLLMDecision`
+read it, and the classifier is the failure floor. A rewire that broke either would trade a
+measured floor for an unmeasured design. V-565 lands the type and the builder beside the
+existing path. The arbiter that reads claims is V-560.

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

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

docs/qa.md

@@ -1,6 +1,6 @@
 # QA plan: checking Maven properly
 
-*Last verified: 2026-08-04 @ 8d816f4. Living doc: correct it in place, do not append.*
+*Last verified: 2026-08-05 @ 12667fd. Living doc: correct it in place, do not append.*
 
 Written 2026-08-01, after the 35-PR stack landed and the box came back up.
 Refreshed 2026-08-02 against the live list, after PRs #85-#90.
@@ -255,8 +255,13 @@ room — **463**, written up in `docs/plans/17-where-the-voice-loop-runs.md`.
 So the wake word and the VAD gate are covered by their unit tests and by
 nothing else, and no session at this box changes that. Checking them needs a
 machine with a microphone running both binaries against a TCP-listening mavend.
-`ipc.Dial` already speaks `tcp://host:port?token=...`, so the work is a machine
-and a config line, not protocol work. Until then, **287** can only be
+`ipc.Dial` already speaks `tcp://host:port?token=...`, so the work is not
+protocol work.
+
+That machine is workpc (owner's correction, 05-08-2026). This section used to
+call it a machine Maven does not have. That was written when the workstation
+was only a model host. So the remaining work is deploying two daemons and
+asking mavend to listen on TCP. Until that is done, **287** can only be
 half-answered, and step 2 above is push-to-talk, not the voice loop.
 
 **319's single-token bug is fixed** (01-08-2026). Single-word Russian utterances no longer come
@@ -418,11 +423,15 @@ something only a ZIM answers, with the search block on. Live search leads and th
 ZIMs are the fallback since 02-08-2026. **286**'s remaining half is doc and
 git ingestion, which is build work, not a check.
 
-**Do not read `/trace` for this.** `/trace` is the nudge-rule trace: rule,
-severity, predicate, gate, selected. No query-source field exists anywhere in the
-codebase. The only evidence of which query source claimed a turn is the
-`voice: search:` and `voice: kiwix:` lines in `docker compose logs mavend`
-(`actions_query.go:589` and `:660`).
+**Read `/trace` for this.** It carries two tables since 06-08-2026 (V-564). The
+nudge-rule trace it always had, and below it the **turn decisions**: one
+collapsible record per utterance. Each names every claimant, what it would have
+made the turn, the score it reported, and whether it won, declined, lost or was
+**never asked**. That last one answers "did Kiwix pass, or was it never
+reached". The log lines cannot tell you that. The ring holds the last 25 turns
+in daemon memory and is empty after a restart, so read it in the same sitting.
+`/chat` still shows the claiming source as a badge, and the `voice: query
+claimed by source` line is still in `docker compose logs mavend`.
 
 Run 02-08-2026, 20 turns. **Search leads and the personal boundary holds.** Every
 world question that reached the boundary was claimed by search. All three

internal/audio/audio_test.go

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

internal/audio/pcmwav.go

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