Pin the keyword models to one thread each and ship them (V-487)

The gate loaded and worked on workpc and took mavwaked from 68% of one core
to 335%. onnxruntime sizes its intra-op pool to every core and spins between
runs, which an always-on gate scoring three graphs twelve times a second
provokes for the whole day. One thread per session brings it to 81%, so the
keyword costs about 13% of a core, and each graph still finishes well inside
its 80ms.

The unit now passes the three -wake- flags and the models sit beside
silero_vad.onnx in ~/.local/share/maven/models. The threshold is left at the
binary's default so there is one place to change it.

CLAUDE.md

@@ -2,17 +2,21 @@
 
 Guidance for Claude Code (claude.ai/code) working in this repository.
 
-This file is loaded into every session, so it carries rules and not history. A
-measurement lives in `docs/evals/<date>-<name>.md` and is never edited after the
-day. A subsystem's reasoning lives in a living doc under `docs/`. When a line
-here says "see X", read X before changing that subsystem.
+**This is a rules file.** It loads into every session, so it carries only what
+changes what an agent does. A measurement belongs in `docs/evals/`, dated and
+never edited after the day. A subsystem's reasoning belongs in its living doc
+under `docs/`. Read that doc before changing the subsystem.
 
 | Read this | Before |
 |---|---|
 | `docs/routing.md` | touching `internal/router/` or `queryWalk` |
+| `docs/deployment.md` | touching a daemon, compose, a systemd unit or the web UI |
 | `docs/offload.md` | touching a daemon seam or adding a model caller |
+| `docs/world.md` | touching search, Kiwix or the world chain |
+| `docs/language.md` | changing a prompt contract or a Russian word list |
 | `docs/ecosystem.md` | touching Nexus, Praxis or Hexis |
 | `docs/rearchitecture.md`, `docs/design.md` | changing the shape of anything |
+| `docs/workflow.md` | the five stores, the doc tiers, the guards |
 | `AGENTS.md` | local preview, screenshots, model downloads |
 
 ## What Maven is
@@ -21,470 +25,176 @@ A self-hosted, privacy-first voice assistant in Russian and English. Go daemons
 talk over unix sockets. One resident small model routes and phrases. whisper.cpp
 does speech-to-text and piper does text-to-speech.
 
-The deploy target is a Ryzen laptop (homesrv) with Vulkan offload to the Vega
-iGPU (`n_gpu_layers: 99`, compose passes `/dev/dri` and the render gid). The
-resident model stays at 1.7B or under either way.
+The resident model is **Qwen3-1.7B** (`UD-Q4_K_XL`) on homesrv, a Thinking
+variant at `n_ctx` 4096. Keep it at 1.7B or under. Sub-500M models are unusable
+in Russian (`docs/evals/2026-07-31-model-bakeoff.md`). Model files live in
+`/mnt/hdd1/llms`, bind-mounted over the repo's `models/llm/`, so a gguf sitting
+in the repo is loaded by nothing.
 
-### The resident model
+The workstation is workpc and it holds the remote model and speech-to-text.
+**It is never assumed up.** **Fall back silently** when it would only do the job
+better. **Name the gap** when the resident model cannot do the job at all.
 
-**Qwen3-1.7B** (`UD-Q4_K_XL`), stock, not yet the CPT'd one. It is a Thinking
-variant, so `n_ctx` is 4096. Reasoning tokens need the room, and 4096 is what
-every score was measured at.
-
-The target is the locally CPT'd Qwen3-1.7B (V-122, training in flight). Stock
-already speaks good Russian. What it gets wrong is the persona. It writes `я рад`
-where Maven needs `рада`.
-
-**Do not bother with sub-500M models.** LFM2.5-230M and 350M were measured on
-2026-07-31 and both are unusable in Russian
-(`docs/evals/2026-07-31-model-bakeoff.md`). Their published IFEval and BFCL
-numbers are English-only.
-
-Model files live in `/mnt/hdd1/llms`, bind-mounted to `/opt/maven/models/llm`.
-That **shadows** the repo's `models/llm/`, so a gguf sitting there is not loaded
-by anything. Swapping the resident model is a one-line change to
-`phraser.model_path` in `deploy/mavend.json`.
-
-### The workstation
-
-Model work moved to workpc on 2026-08-02 (owner's call). homesrv cannot grow a
-GPU and workpc has 16GB of VRAM. So the resident model, speech-to-text and
-text-to-speech are preferred remotes with a floor on homesrv.
-
-Three rules:
-
-- **The workstation is never assumed up.**
-- **Fall back silently** when it would only do the job better.
-- **Name the gap** when the resident model cannot do the job at all. A world
-  question goes through `LLMPhraser.PhraseWorld` and returns `worldGap`
-  (`cmd/mavend/worldmodel.go`) rather than an invented answer. A box with no
-  `workstation` block behaves exactly as it did before the seam.
-
-Routing and replies prefer the workstation through `modelSeam`. Nudge and
-reminder phrasing prefer it inside the phraser. `docs/offload.md` says which
-caller is which.
-
-**The embedder stays on homesrv permanently**, because it backs that floor. It is
-multilingual-e5-small, quantized and asymmetric. `EmbedQuery` and `EmbedPassage`
-apply the `query:` and `passage:` prefixes it was trained with. Calling plain
-`Embed` on a note is a bug. See `docs/evals/2026-08-04-recall-e5-small.md`.
-
-### Speech-to-text
-
-`sttSeam` in `cmd/mavend/voicewire.go` builds an `stt.Pair` beside `modelSeam`.
-It prefers CrisperWhisper 2.0 turbo on workpc with mavsttd as the floor. It takes
-only the silent half of the rule, because a worse transcript is still a turn. So
-`stt.Pair` has no `TranscribeRemote` and the fallback is never spoken.
-
-CW2 turbo scores 10.4% WER in Russian against 27.5% for the `ggml-small.bin`
-mavsttd loads, over 200 Golos clips
-(`docs/evals/2026-08-09-crisperwhisper2-russian-wer.md`).
-
-**whisper.cpp cannot load CW2 at all.** It reads its language count off the
-vocabulary size. CW2's 51897 tokens shift seven special token ids. So CW2 is its
-own transformers service on port 8081 (`deploy/cw2/serve.py`).
-`stt.HTTPTranscriber` posts raw PCM to it with a bearer token, because audio is
-the most sensitive thing that crosses this seam. The switch is `workstation.stt`
-in `deploy/mavend.json`, and deleting the block sends every utterance to mavsttd.
-
-**mavgpud runs that service as a second child.** This is not an optimisation.
-CW2 is a ROCm process on the same card, so it registers on the KFD like any
-contender. Under its own systemd unit it made mavgpud evict llama-server every
-few seconds. That took the model arm down for eight minutes on 2026-08-09. The
-card needs one owner. **Any GPU service added beside mavgpud goes in
-`cmd/mavgpud`, never in systemd.** CW2 is on the yield clock and not the idle
-one. At 1.6GB it denies the card to nobody.
-
-Text-to-speech has not moved. piper on homesrv is the only synthesizer.
+**The embedder stays on homesrv permanently**, because it backs that floor.
+`EmbedQuery` and `EmbedPassage` apply the `query:` and `passage:` prefixes
+multilingual-e5-small was trained with. Calling plain `Embed` on a note is a bug.
 
 ## Build and test
 
 CGO daemons (`mavend`, `mavsttd`, `mavttsd`, `mavenclient`) need the vendored
-toolchain and libs wired through the Makefile. **Do not call `go build` on them
-bare, use `make`.**
+toolchain wired through the Makefile. **Do not call `go build` on them bare**,
+and **do not hand-write the CGO preamble**. This box runs zsh, so an unquoted
+`-run Test*` dies on "no matches found" before `go` is reached. `make t` also
+carries `-count=1` and sets `MAVEN_ONNX_LIB`. Without that variable the four
+`TestONNX*` measurements self-skip and the run still prints `ok`.
 
 ```sh
-make build          # all 11 binaries
-make build-web      # one daemon (web/waked/poll/caldav build without CGO)
-make test           # go test -race across ./internal/... ./cmd/... with CGO env set
-make t PKG=./internal/router/
-make t PKG=./cmd/mavend/ RUN=TestSimulator
+make build   # all 11 binaries. make build-web for one (web/waked/poll/caldav skip CGO)
+make test    # go test -race across ./internal/... ./cmd/... with CGO env set
 make t PKG=./internal/router/eval/ RUN='TestONNX' V=1   # V=1 for -v, RACE=0 to drop -race
 ```
 
-**Do not hand-write the CGO preamble.** Past sessions pasted it about 390 times,
-and that is where the shell-quoting failures came from. This box runs zsh, so an
-unquoted `-run Test*` dies on "no matches found" before `go` is ever reached.
-
-`make t` carries `-race`, so a green `make t` cannot turn red under `make test`.
-It carries `-count=1`, so a cached PASS from before your edit is never mistaken
-for a result. It sets `MAVEN_ONNX_LIB`, which the hand-written recipe did not.
-The four `TestONNX*` measurements self-skip when that variable is unset and the
-run still prints `ok`. So every targeted eval done the old way reported the hash
-ratchet while reading as a real embedder score.
-
-## The daemons (`cmd/`)
-
-| Binary | Role |
-|---|---|
-| `mavend` | **Core.** Router, phraser, memory, reminders, digestion tick. Owns the DB and IPC socket. |
-| `mavweb` | HTTP UI and PWA (`/dash`, `/history`, `/trace`, `/notifications`, `/tools`), WebAuthn auth. |
-| `mavsttd` | Speech-to-text (whisper.cpp, CGO). |
-| `mavttsd` | Text-to-speech (piper subprocess). |
-| `mavwaked` | Wake-word and VAD gate. **Not deployed anywhere yet.** |
-| `mavenclient` | Voice loop client (mic, stt, core, tts). **Not deployed anywhere yet.** |
-| `mavpoll` | Environment poller: netdata alarms, uptime-kuma, zenmoney, wireguard presence. Writes facts, sends nothing. Telegram is `internal/delivery/telegramsink`. |
-| `mavcaldav` | CalDAV calendar sync. |
-| `mavmaild` | Mail reader (IMAP, read-only). Holds the IMAP password, core never sees it. |
-| `mavgpud` | GPU supervisor. **Runs on workpc**, own unit `deploy/mavgpud.service`. Keeps llama-server loaded while the card is free (V-488). Maven never asks it for anything and reads `/health` through `llm.Pair`. |
-| `mavupdate` | Not a daemon. Operator CLI a human runs on the box to deploy a new build. |
-
-Two binaries have no Makefile target and neither is deployed. `mavseal` encrypts
-a live tmpfs working copy back to the ciphertext file when mavend was killed
-before `defer st.Close()` sealed it. `labelgen` runs the stage 0 grammars over
-utterances and prints JSONL, the training data for the routing heads.
-
-Daemons are wired socket-to-socket, not linked. `internal/ipc` is the wire
-protocol. `deploy/mavend.json` sets socket paths, model paths and the phraser and
-embedder blocks, with `${VAR}` expansion from gitignored `deploy/telegram.env`.
-
-### Who is in compose, and who is not
+## The daemons
 
+Eleven binaries under `cmd/`, wired socket-to-socket over `internal/ipc`, not
+linked. `mavend` is the core and owns the DB and the IPC socket.
+`deploy/mavend.json` sets sockets, model paths and the phraser and embedder
+blocks, with `${VAR}` expansion from gitignored `deploy/telegram.env`.
 **`docker-compose.yml` runs five**: `mavend`, `mavsttd`, `mavttsd`, `mavweb`,
-`mavpoll`. Count against compose, not against the table above. Four daemons are
-absent and each absence has a different reason.
+`mavpoll`. Count against compose, not against `make build`. `mavwaked` runs on
+workpc under systemd. `docs/deployment.md` says who else is absent and why.
 
-`mavmaild` and `mavcaldav` are commented out, each with the reason beside it. The
-first needs a mail account and the second a CalDAV account, and this box has
-neither. Two things ride on the CalDAV absence (V-644). Agenda questions route to
-`IntentQuery` at stage 0, and the `calendar` query source then reads a table
-nobody writes. And `loop.State.CalendarBusy` is fed by the same facts, so the
-gate's "do not nag mid-meeting" is permanently false.
-
-`mavwaked` and `mavenclient` are absent **by decision** (V-463,
-`docs/plans/17-where-the-voice-loop-runs.md`). homesrv has a microphone, because
-it is a laptop, but it is in the wrong room. They belong on a client machine
-where the owner is standing, and that machine is workpc. `ipc.Dial` already takes
-`tcp://host:port?token=...`, so V-515 is a deployment and not a build.
-
-Until then the wake word and the VAD gate are covered by unit tests and nothing
-else. Push-to-talk through `/dash` is what QA covers. Deploying them does not by
-itself prove a wake word. `mavwaked` has no keyword model (V-487 stage two), so
-the loop runs open until that lands.
-
-**Passwords are read from files, never taken as flag values.** `mavcaldav` uses
-`-pass-file` and `-render-pass-file`. `mavpoll` and `mavmaild` follow the same
-rule.
+- **Passwords are read from files, never taken as flag values.**
+- **The voice wire is plaintext with no auth.** mavend's voice port stays on
+  homesrv loopback and reaches workpc over ssh. Do not LAN-bind it.
+  `SurfaceVoice` caps acts at L0, and L0 does not cap reading.
+- **A GPU service added beside mavgpud goes in `cmd/mavgpud`, never in systemd.**
+  The card needs one owner. A second unit made mavgpud evict llama-server every
+  few seconds and took the model arm down for eight minutes.
 
 ## The ecosystem: Nexus, Praxis, Hexis
 
-Maven is one of four services. It owns conversation and personal memory. It does
-not own identity, operational state, or execution. Full contract in
-`docs/ecosystem.md`.
-
-```text
-Nexus identifies.  Praxis observes.  Hexis acts.  Maven understands and coordinates.
-```
-
-| Service | Owns | Maven's client | Configured at |
-|---|---|---|---|
-| **Nexus** | Canonical entity ids, names, aliases, relationships. Projects, services, devices, people, pets, places. | `nexusClient` in `cmd/mavend/ecosystem.go`, `POST /api/v1/resolve` | `nexus.url` (`http://nexus:9740`) |
-| **Praxis** | Operational attention and item lifecycle. What needs looking at, what changed, what is unresolved. | `praxisClient`, the HTTP tools API under `/api/v1/tools/` | `praxis.url` (`http://praxis:8989`) |
-| **Hexis** | The capability registry and the only path to executing anything. | vendored `github.com/kami/hexis/pkg/client` | `hexis.url` (`http://hexis:9741`) |
-
-All three are `nil` unless configured and every one degrades on its own. An
-outage means a named gap in the answer, never a broken turn and never a guess.
-
-Rules that are not negotiable:
+Nexus identifies, Praxis observes, Hexis acts, Maven understands. Maven does not
+own identity, operational state, or execution. Full contract in
+`docs/ecosystem.md`. All three are `nil` unless configured and each degrades
+alone. An outage means a named gap, never a broken turn or a guess.
 
 - **No component reads another component's database.** Praxis attention comes
   over HTTP, never from its SQLite file.
-- **Identity lives in Nexus.** Do not invent a local fact key for something Nexus
-  resolves. `actionFact` sets `Subject`, and `cmd/mavend/factenrichment.go`
-  resolves it in the background.
+- **Identity lives in Nexus.** Do not invent a local fact key for something
+  Nexus resolves. `cmd/mavend/factenrichment.go` resolves `actionFact.Subject`.
 - **Free text never reaches a mutating Hexis call.** Resolve to a canonical
   entity id first. Ambiguous resolution asks the owner, it does not pick.
 - **LLM output is not authorization.** Confirmation binds capability id, target
-  entity, arguments, requester and expiry. See `cmd/mavend/confirm.go`.
-- **Praxis lifecycle words mean different things.** Surfaced is not acknowledged,
-  acknowledged is not resolved, execution success is not recovery. Reading an
-  item aloud calls `Surface`, never `Acknowledge`.
-- **No automatic attention-to-action path.** Digestion may summarise Praxis. It
+  entity, arguments, requester and expiry (`cmd/mavend/confirm.go`).
+- **Praxis lifecycle words differ.** Surfaced is not acknowledged, acknowledged
+  is not resolved, execution success is not recovery. Reading an item aloud
+  calls `Surface`, never `Acknowledge`.
+- **No automatic attention-to-action path.** Digestion may summarise Praxis and
   may not call Hexis.
-
-Every cross-service call carries a correlation id minted once per action
-(`withCorrelationID`), a contract version header, and `X-Requested-By: maven`.
+- Every cross-service call carries a correlation id minted once per action
+  (`withCorrelationID`), a contract version header, and `X-Requested-By: maven`.
 
 ## Routing
 
 **Read `docs/routing.md` before touching `internal/router/` or `queryWalk`.** It
-carries the stage-by-stage reasoning, every measurement, and why each rule
-exists. What follows is only what must not be broken.
+carries the reasoning, the measurements and every rule's why. A route produces
+two decisions. **Intent** is one of seven values. **Source** is where the answer
+lives and is read on `IntentQuery` alone. Score them separately. The cascade is
+stage 0 grammars, then the routing heads, then the resident model, then the
+classifier. Every stage may decline and the next one answers.
 
-A route produces two decisions. **Intent** is one of seven values. **Source** is
-where the answer lives and is read on `IntentQuery` alone. They are scored
-separately, because one number hides which one moved.
-
-The cascade is stage 0 grammars, then the routing heads, then the resident model,
-then the classifier. Every stage may decline and the next one answers.
-
-- **The classifier is the floor, not dead code.** It runs when the resident model
-  is off. It runs when there is no llama-server, and on any error. Deleting it
-  makes a model outage a broken turn.
-- **Any model error falls through**, so a turn never breaks on a model.
-- **`baselineGrammars` in `eval_test.go` mirrors `buildRouter`.** Add a grammar
-  to one and it belongs in both, or the fixture scores a set nobody runs.
+- **The classifier is the floor, not dead code.** It answers when the resident
+  model is off, absent, or erroring. **Any model error falls through.**
+- **`baselineGrammars` in `eval_test.go` mirrors `buildRouter`.** A grammar
+  added to one belongs in both, or the fixture scores a set nobody runs.
 - **Go's `\b` is ASCII-only** and never fires after a Cyrillic letter. A Russian
   pattern needs an explicit `(\s|[?!.]|$)`.
-- **`PraxisGrammars()` is the only path to Praxis**, not a faster one. The model
-  reaches Praxis 0/12 alone, because nothing in the router prompt names a Praxis
-  capability.
-- **`voice.embedder.heads_path` must never point at `model_path`.** The resident
-  e5-small must not be replaced by the fine-tuned copy. Recall depends on that
-  file scoring what it scored. Fine-tune a copy of the weights.
-- **Bump `tokenizerRev` on any change to what `encodeWord` emits.** The embedder
-  id carries the revision. So a tokenizer fix triggers `ReembedAll` the way
-  swapping the model file does.
-- **A new rung in the `runTurn` ladder needs its name in `preRouteLadder`**
-  (`cmd/mavend/decisiontrace.go`). Otherwise that rung is silently missing from
-  the decision record.
+- **`PraxisGrammars()` is the only path to Praxis**, not a faster one.
+- **`voice.embedder.heads_path` must never point at `model_path`.** Recall
+  depends on the resident e5-small scoring what it scored. Fine-tune a copy.
 - **Routing traces are retained 14 days**, enforced on write and again on start.
-  The utterance is stored in clear and nothing reads it outward. `Store.Wipe`
-  deletes it with everything else.
+- **Bump `tokenizerRev` on any change to what `encodeWord` emits**, so a
+  tokenizer fix triggers `ReembedAll` the way swapping the model file does.
+- **A new rung in the `runTurn` ladder needs its name in `preRouteLadder`**
+  (`cmd/mavend/decisiontrace.go`), or it is missing from the decision record.
 
-### `queryWalk` and the destination
+**`queryWalk` takes query sources out and moves none** (`actions_query.go`). That
+is the safety argument and it is not negotiable. The table's order is
+load-bearing and carries "the owner's data first, then the world".
+`SourceUnknown` is the floor and walks the whole chain. A named destination
+removes only the sources marked `guesses: true`, so a source that looks rather
+than guesses is always asked. **The personal boundary is the one exception and
+it is deliberate.** It guesses, so naming `SourceWorld` drops it. **Only a stage
+0 grammar may drop it** (owner's call, V-666). `queryWalk` reads
+`Decision.SourceAnchored` for the source marked `boundary: true` and no other.
 
-`queryWalk` in `cmd/mavend/actions_query.go` takes sources **out** and moves
-none. That is the safety argument and it is not negotiable. The table's order is
-load-bearing, and above all it carries "the owner's data first, then the world".
+Judge a routing change against the classifier (76.0% intent, 36.4% destination)
+and the resident model (80.2% intent), since those always answer. The fixture
+has grown from 77 cases to 96, so a number compares only to another number on
+the same fixture.
 
-`SourceUnknown` is a real value and it is the floor. Nothing named a destination,
-so the daemon walks the whole chain. Naming `SourceWorld` does not send the turn
-outside on its own.
+## Language: model output and Russian
 
-What comes out is only the sources marked `guesses: true`. Those decide a turn is
-theirs by cosine against frozen seeds, then answer whatever they claimed. A
-source that looks rather than guesses is always asked.
+Both contracts are in `docs/language.md`. What must not be broken:
 
-**The personal boundary is the one exception and it is deliberate.** It guesses,
-so naming `SourceWorld` drops it. **Only a stage 0 grammar may drop it**
-(owner's call, V-666). `Decision.SourceAnchored` carries the provenance, and
-`queryWalk` reads it for the source marked `boundary: true` and no other. So
-every other guesser still comes off the turn, whoever named the destination.
-`TestOnlyAGrammarMayDropTheBoundary` and `TestNamingRecallKeepsTheBoundary` pin
-both directions.
-
-### Current numbers
-
-| Arm | Intent | Destination | p50 |
-|---|---|---|---|
-| classifier + ONNX | 76.0% | 36.4% | 16.6µs |
-| resident Qwen3-1.7B, cascade | 80.2% | not measured | 1.19s |
-| routing heads, cascade | 96.9% | 75.8% | 27.9ms |
-| workstation gemma-4-E4B, cascade | 89.6% | 57.6% | 294ms |
-
-Judge a routing change against the classifier and the resident model, since those
-are what always answer. The fixture has grown from 77 cases to 96, so a number is
-comparable only to another number on the same fixture.
-
-## LLM output contract
-
-All phrasing paths emit `{"response":"...","mood":"..."}`, falling back 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`. `cmd/mavend/replier_llm.go`
-wraps the last of those, holds the stub fallback, and does no parsing of its own.
-Mood is a fixed enum.
-
-The router prompt is a separate contract:
-`[{"intent":<enum>, key?, value?, text?, verb?}, ...]` over 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 stay identical.
-
-## Russian patterns: three mechanisms, no fourth
-
-Hand-written Russian stem patterns were swept out on 2026-08-04 (owner's call).
-A regex whose output is a fact or a route is the defect. A regex over structured
-input, such as HTML, MIME, JSON, a URL or an argv list, is not. Before writing a
-Russian word list, pick one of these:
-
-- **`internal/lexicon`** for closed classes, in `lexicon_ru_v1.json`.
-  Interrogatives, capture verbs, reminder verbs, cardinals, day offsets, parts of
-  day, weekdays, months, spoken hours. Editing a word is a data change and there
-  is exactly one copy. Months used to live in three files. Cardinals carry the
-  oblique forms, because a spoken time declines and `в семь` and `к семи` are one
-  hour.
-- **`internal/morph`** for grammar, from the vendored golem Russian dictionary.
-  `IsVerbForm` and `SameWord`. Lemma matching is BROADER than stem-plus-one-ending,
-  so a verb slot meaning the imperative must be matched exactly. `говори` and
-  `говорил` are one lemma and only one of them is a command
-  (`cmd/mavend/quiet_toggle.go`).
-- **`cmd/mavend/topics.go` and the embedder** for open sets, where the question is
-  what a turn is ABOUT. Frozen seeds per subject plus a real `other` class, scored
-  against the turn's own query vector. Same shape as the personal boundary in
-  `personalboundary.go`, with one difference. A topic must clear the runner-up by
-  `topicMargin`, because a false claim here spends a network scan rather than one
-  honest "не знаю". The old keyword tests stay as the offline floor.
-- **The ecosystem trio** when the answer is not in the utterance at all. Identity
-  is Nexus's, never a local pattern.
-
-Seeds are scoring data. Editing one moves a recogniser and must be re-measured
-against the `TestONNX*` tests, not eyeballed.
+- **One parser for model text, `parseResponseMood`** in
+  `internal/phraser/parse.go`. Every phrasing path reaches it. Mood is an enum.
+- **The router prompt is a separate contract** over 7 intents, and
+  `llm/check_prompt_parity.py` keeps the Go and relabelling copies identical.
+- **Russian words are matched by three mechanisms and no fourth**:
+  `internal/lexicon` for closed classes, `internal/morph` for grammar, and
+  `cmd/mavend/topics.go` with the embedder for open sets. A regex whose output
+  is a fact or a route is the defect. A regex over structured input is not.
+- **Seeds are scoring data.** Editing one moves a recogniser and must be
+  re-measured against the `TestONNX*` tests, not eyeballed.
 
 ## Non-goals and hard constraints
 
 Not a nag, not autonomous.
-
-**The persona is feminine.** Russian self-reference uses feminine forms: `рада`
+**The persona is feminine.** Russian self-reference takes feminine forms: `рада`
 not `рад`, `поняла` not `понял`. The owner is male and she speaks to him
-informally. Use "ты", singular, never "вы" or "ваш", and never "он" or "его". She talks TO
-the owner, not about him. Pet names such as "милый" are forbidden. The name
-"Ками" is not. `CheckAddress`, `CheckFeminine` and `CheckCringe` in
+informally. Use "ты", singular, never "вы" or "ваш", and never "он" or "его".
+She talks TO the owner, not about him. Pet names such as "милый" are forbidden.
+The name "Ками" is not. `CheckAddress`, `CheckFeminine` and `CheckCringe` in
 `internal/phraser/eval/checks.go` enforce this, scored by `make eval-phrasing`.
 
-**"Never phones home" is deprecated** (owner's call, 2026-07-31). A 1.7B does not
-know enough to answer world questions, so she reads external sources. What
-replaces it:
+**"Never phones home" is deprecated** (owner's call, 2026-07-31). She reads
+external sources, and `docs/world.md` carries that chain. What holds regardless:
 
-- **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.
+- **No telemetry, no cloud model, no third-party account.** Inference stays on
+  the box and nothing about Maven is reported to anyone.
 - **The owner's data first, then the world.** Every source reading his facts,
-  notes, calendar, tasks or house runs before anything outside. The personal
-  boundary sits between them. Reading beats recalling for a small model.
-- **The owner's notes and facts are never search input.** Only the utterance goes
-  out. Never the persona block, the history, or matched notes.
-- **External search is allowed and off unless configured**, like weather and
-  telegram. The code default is off. `deploy/mavend.json` ships a `search` block,
-  so it is on for this box and deleting the block turns it off again.
-- **In the world, live search leads and the ZIMs are the fallback** (owner's
-  call, 2026-08-02). A self-hosted SearXNG answers first. The Kiwix ZIMs on
-  homesrv answer when the search is empty, unreachable, or the line is down.
-
-### The world chain
-
-`Response.Empty()` is the whole gate and there is no quality threshold in front
-of it. Four signals were tried and none separates a real question from an
-invented one. Token overlap would cost "столица Франции" its answer, because the
-answer is Париж and that word is not in the question
-(`docs/evals/2026-08-05-search-quality-signals.md`). **The embedder is not a
-fifth signal**: query-to-passage cosine measures topic and not whether the
-passage answers, and the two sets overlap
-(`docs/evals/2026-08-09-kiwix-topic-retrieval.md`).
-
-The connect phase alone is capped at `dialTimeout` (1.5s), because a blackholed
-host once cost the owner 8 seconds. A slow instance that did connect keeps the
-full 8 (`docs/evals/2026-08-05-kiwix-offline-fallback.md`).
-
-**A Russian question reads `wikipedia_ru_all_maxi_2026-02` verbatim** through
-`kiwix.book_ru`. The RU→EN rewriter is the workaround for an English book and is
-skipped there. Kiwix catalog names come from the filename, not the `<name>`
-field.
-
-**Kiwix ranks by keyword overlap.** Never send it a whole sentence.
-`kiwix.Topic` drops the narrative request, the interrogative and a verb behind
-one. `kiwix.TitlePath` tries the exact article first, since a ZIM is addressable
-by title and a wrong title is a 404. `TitleCandidates` tries the spoken form and
-then the capitalized one. Both apply on the verbatim path alone. The rewriter
-already reduces a question, and reducing twice takes the topic off its input
-(V-668).
-
-**Which query source claimed a turn is readable on `/chat`** as a badge beside
-the reply. It is carried on `ipc.ChatReply.Source` and noted by `noteQuerySource`
-in `cmd/mavend/querysource.go`. It rides the context, so `handleText` keeps the
-one string signature the mic, telegram and the web share.
-
-## Web UI conventions
-
-Server-rendered pages share `cmd/mavweb/static/ui.css` (served at `/ui.css`) and
-the shell partial in `cmd/mavweb/shell.html`. A page opens with
-`{{template "shellTop" "<page-key>"}}` and closes with `{{template "shellBottom"}}`,
-and the key marks the active sidebar link.
-
-Every page is its own embedded `.html` file next to `main.go`. No page markup
-lives in Go, and the sidebar is data (`sidebarSections`, `pageIcon`) the template
-renders. No per-page `<style>` beyond true one-offs. Wrap every table in
-`<div class=scroll>` so wide data pans on a phone. Local preview and headless
-screenshot recipes are in `AGENTS.md`.
-
-## Vikunja
-
-This repo is project **Maven** (ID 2). MCP at `http://localhost:9100/mcp`, or
-`http://192.168.1.104:9100/mcp` from workpc. Feature, bug and deploy tasks go
-there.
-
-Vikunja is the durable task store. A task holds the goal, the constraints and the
-assumption ledger. Work without a task id is work nobody can resume, so a session
-with no id asks for one before it starts.
-
-The MCP tool schemas are deferred. Load the four you use in ONE call at the start
-of a session:
-
-```text
-ToolSearch("select:mcp__vikunja__list_tasks,mcp__vikunja__get_task_details,mcp__vikunja__create_task,mcp__vikunja__update_task")
-```
-
-**Close a finished task with `done: true` and nothing else** (owner's call,
-2026-08-07). Do not write a completion summary into the description on the way
-out. It is lost anyway, and the durable record is the commit messages and the
-merged PR. `update_task` carrying a `description` resets `done` to false, which
-is why a write-up ever took two calls.
+  notes, calendar, tasks or house runs first, and the personal boundary sits
+  between them and anything outside.
+- **His notes and facts are never search input.** Only the utterance goes out,
+  never the persona block, the history, or matched notes.
+- **External search is allowed and off unless configured.** Deleting the
+  `search` block in `deploy/mavend.json` turns it off.
+- **`Response.Empty()` is the whole gate** on a world answer. There is no
+  quality threshold in front of it and four candidate signals all failed.
 
 ## Session workflow
 
-`~/.local/bin/task` owns the branch, the commit identity and the PR. One task,
-one session, one PR.
+`docs/workflow.md` carries the five stores, the doc tiers and the guards. One
+task, one session, one PR. `/pickup` opens a session and `/wrap` closes it. Wrap
+at roughly half context rather than letting the session compact.
 
 ```sh
 task start <vikunja-id>   # branch off origin/master, write TASK.md, fetch review comments
 task pr                   # push, open or refresh the PR, label Vikunja, notify
-task comments             # re-pull this branch's review comments into .task/
+ToolSearch("select:mcp__vikunja__list_tasks,mcp__vikunja__get_task_details,mcp__vikunja__create_task,mcp__vikunja__update_task")
 ```
 
-Around that, `/pickup` opens a session and `/wrap` closes it. Wrap at roughly
-half context rather than letting the session compact.
-
-Five stores, and each one owns something the others must not hold:
-
-| Store | Holds | Lifetime |
-|---|---|---|
-| Vikunja task | goal, constraints, assumption ledger, status | durable |
-| `CLAUDE.md`, `AGENTS.md` | what an agent must know before touching code | durable |
-| `docs/` | design, measurements, decisions | durable |
-| `TASK.md` | the brief for this branch, written by `task start`, immutable | one branch |
-| `HANDOFF.md` | only what the next agent needs to resume | one session |
-
-`TASK.md` and `.task/` are excluded through `.git/info/exclude`. `HANDOFF.md` is
-gitignored and injected at session start. If a line in the handoff would still
-matter next week, it is in the wrong file.
-
-Docs are tiered by path, so staleness is visible from the filename. Files
-directly under `docs/` are living and carry a `Last verified: <date> @ <sha>`
-line. Files under `docs/evals/` are dated measurements and are never edited after
-the day, so a newer number is a new file. Files under `docs/archive/` are dead
-and read by nobody by default.
-
-**This file is a rules file.** A new measurement belongs in `docs/evals/`. The
-reasoning behind a subsystem belongs in its living doc. A line here earns its
-place only by changing what an agent does.
-
-## Git guards
-
-Two hooks in `.githooks/`, tracked, wired with `core.hooksPath`. Fresh clone:
-
-```sh
-git config core.hooksPath .githooks
-```
-
-- `pre-commit` refuses master, and refuses more than 300 changed lines in
+- This repo is Vikunja project **Maven** (ID 2), MCP at
+  `http://localhost:9100/mcp`, or `http://192.168.1.104:9100/mcp` from workpc.
+- **A session with no task id asks for one before it starts**, because work
+  without one is work nobody can resume.
+- **Close a finished task with `done: true` and nothing else** (owner's call,
+  2026-08-07). `update_task` carrying a `description` resets `done` to false.
+- **`pre-commit` refuses master** and more than 300 changed lines in
   non-markdown files. Markdown is exempt and may land as one batch.
-- `commit-msg` requires the subject to end with `(V-<id>)`. `V-` and not `#`,
-  because Gitea autolinks `#123` to a Gitea issue, which is the wrong tracker.
-
-Two more guards live outside the repo, in `~/.claude/hooks/`. `diff-budget.sh`
-blocks further edits past 600 changed lines on a `task/` branch.
-`prose_lint_hook.py` checks prose on every write. Both measure against
-`origin/master`, so a local master that is ahead of the remote makes the diff
-budget read high.
-
-`--no-verify` exists. Using it means saying why in the commit body.
+- **`commit-msg` requires the subject to end with `(V-<id>)`.** `V-` and not
+  `#`, because Gitea autolinks `#123` to the wrong tracker.
+- **`diff-budget.sh` blocks edits past 600 changed lines** on a `task/` branch.
+- **`--no-verify` exists.** Using it means saying why in the commit body.

cmd/mavwaked/main.go

@@ -12,10 +12,17 @@
 // samples and the capture frame is 480, so silero.go re-chunks. This comment
 // used to say the two matched, which was true of silero v4.
 //
-// There is still no wake-word model, so anything spoken near the microphone
-// becomes a turn (V-487 stage two). The SurfaceVoice auth layer caps all
-// commands at L0 (no destructive acts), which is what makes an accidental
-// trigger safe rather than expensive.
+// The keyword is "Мэйвен" and it is required, when -wake-model points at the
+// head (V-487 stage two). Without it anything spoken near the microphone
+// becomes a turn, which the SurfaceVoice auth layer makes safe rather than
+// expensive: it caps all commands at L0, no destructive acts. It does not cap
+// reading, so an open gate still lets the room hear his facts read back.
+// wakeword.go holds the cadence and wakefeatures.go the three models.
+//
+// The conn carries both directions. mavwaked sends utterances and receives
+// proactive nudges on it, and it is opened at startup rather than at the first
+// utterance, because mavend registers a voice session on accept. See nudge.go
+// for why a nudge that is not heard is worse than one that is not delivered.
 //
 // While a reply is playing the capture side is muted (half-duplex): without
 // it, Maven's own voice comes back in through the mic and she answers
@@ -57,6 +64,12 @@ const (
 	defaultAddr     = "127.0.0.1:9100"
 	defaultLang     = "ru"
 	defaultReadSize = 4096 // max PCM bytes per read from arecord (fits multiple frames)
+
+	// defaultWakeWindowMs — how long the keyword stays good for. He says
+	// "Мэйвен" and then a sentence, and the VAD does not close the utterance
+	// until he stops, so this has to outlive the word by the length of what
+	// follows it. It is spent on dispatch: one keyword, one turn.
+	defaultWakeWindowMs = 8000
 )
 
 func main() {
@@ -81,12 +94,18 @@ func run(args []string) error {
 	vadModel := flag.String("vad-model", "", "silero-vad onnx file; empty runs the energy threshold instead")
 	vadThreshold := flag.Float64("vad-threshold", defaultSileroThreshold, "speech probability a frame must clear")
 	onnxLib := flag.String("onnx-lib", os.Getenv("MAVEN_ONNX_LIB"), "libonnxruntime.so, needed with -vad-model")
+	wakeModel := flag.String("wake-model", "", "keyword head onnx; empty ships every utterance, as before V-487")
+	wakeMel := flag.String("wake-mel", "", "melspectrogram.onnx, required with -wake-model")
+	wakeEmbed := flag.String("wake-embed", "", "embedding_model.onnx, required with -wake-model")
+	wakeThreshold := flag.Float64("wake-threshold", defaultWakeThreshold, "score the keyword must clear")
+	wakeWindowMs := flag.Int("wake-window-ms", defaultWakeWindowMs, "ms an utterance may still start after the keyword")
 	flag.CommandLine.Parse(args)
 
 	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)
 	defer stop()
 
-	// Voice client — reused across utterances; SendRequest reconnects on error.
+	// Voice client — one conn carrying both directions. SendRequest reconnects
+	// on error, and the push receiver redials on its own clock.
 	vc := voice.Dial(*addr)
 	defer vc.Close()
 
@@ -165,6 +184,29 @@ func run(args []string) error {
 	}
 	sess := newSession(vad, newAplayPlayer(), &voiceSender{vc: vc}, *lang, barge)
 
+	// Keyword gate. A model that will not load is logged and not fatal, for
+	// the same reason silero's is not: an open gate is the daemon he had
+	// yesterday, and a daemon that refuses to start is not.
+	if *wakeModel != "" {
+		w, err := newWakeWord(*wakeMel, *wakeEmbed, *wakeModel, *onnxLib, *wakeThreshold)
+		if err != nil {
+			log.Printf("mavwaked: wake word unavailable, every utterance is a turn: %v", err)
+		} else {
+			defer w.Close()
+			sess.UseWakeWord(w, time.Duration(*wakeWindowMs)*time.Millisecond)
+			log.Printf("mavwaked: wake word from %s, threshold %.3f, window %dms",
+				*wakeModel, *wakeThreshold, *wakeWindowMs)
+		}
+	}
+
+	// Listen for nudges alongside capture. Connect eagerly so mavend has a
+	// voice session before he has said anything: without one, a nudge routed
+	// to voice finds nobody home and goes to the away channels instead.
+	if err := vc.Connect(ctx); err != nil {
+		log.Printf("mavwaked: voice server not reachable yet, retrying in background: %v", err)
+	}
+	go runNudgeReceiver(ctx, vc, sess)
+
 	return captureLoop(ctx, src, sess)
 }
 

cmd/mavwaked/nudge.go

@@ -0,0 +1,79 @@
+package main
+
+// The receiving half of the voice reach (V-671).
+//
+// mavwaked used to send and never listen. It wired no PushHandler, and
+// SendRequest discards a push frame when there is none. The consequence was
+// not a missing feature but a silent one: mavend routes a nudge to the voice
+// session that spoke most recently, and once mavwaked had spoken once it WAS
+// that session. PushToMostRecent succeeded, the dispatcher counted the nudge
+// delivered and stopped rerouting to telegram and ntfy, and mavwaked threw the
+// audio away. He heard nothing, anywhere.
+//
+// So the connection is opened at startup rather than at the first utterance,
+// and it is held open. A client that has never connected has no session, and
+// the dispatcher must be able to tell "he is not at the machine" from "he is,
+// and she has nothing to say".
+
+import (
+	"context"
+	"encoding/json"
+	"log"
+	"time"
+
+	"github.com/kami/maven/internal/voice"
+)
+
+// nudgeRetry is how long to wait before dialling again after the conn ends.
+// mavend restarts on every deploy, and a listener that gives up then is a
+// listener that is deaf until the next reboot.
+const nudgeRetry = 5 * time.Second
+
+// nudgeHandler decodes a push and hands the audio to the session, which
+// speaks it through the same player the reply path uses. It does not play
+// anything itself: the half-duplex gate and barge-in live on the capture
+// loop, and a nudge has to sit under both.
+type nudgeHandler struct{ sess *session }
+
+func (h *nudgeHandler) OnPush(p voice.Push) {
+	if p.Kind != voice.PushKindAudioNudge {
+		log.Printf("mavwaked: ignoring push of unknown kind %q", p.Kind)
+		return
+	}
+	var ap voice.AudioNudgePush
+	if err := json.Unmarshal(p.Params, &ap); err != nil {
+		log.Printf("mavwaked: nudge: decode: %v", err)
+		return
+	}
+	log.Printf("mavwaked: nudge from rule %q (severity %d): %q (%.2fs audio)",
+		ap.RuleName, ap.Severity, ap.Text, ap.Audio.Duration())
+	if len(ap.Audio.Bytes) == 0 {
+		// mavttsd was down or the text was empty. Say so rather than going
+		// quiet: the dispatcher already counted this one as delivered.
+		log.Printf("mavwaked: nudge %q carried no audio, nothing to speak", ap.RuleName)
+		return
+	}
+	h.sess.Nudge(ap.Audio)
+}
+
+// runNudgeReceiver keeps a push handler wired for as long as ctx lives,
+// redialling whenever the conn ends. Returns when ctx is cancelled.
+func runNudgeReceiver(ctx context.Context, vc *voice.Client, sess *session) {
+	h := &nudgeHandler{sess: sess}
+	for {
+		err := vc.RunPushReceiver(ctx, h)
+		if ctx.Err() != nil {
+			return
+		}
+		if err != nil {
+			log.Printf("mavwaked: nudge receiver: %v", err)
+		} else {
+			log.Printf("mavwaked: voice connection ended, reconnecting in %s", nudgeRetry)
+		}
+		select {
+		case <-ctx.Done():
+			return
+		case <-time.After(nudgeRetry):
+		}
+	}
+}

cmd/mavwaked/nudge_test.go

@@ -0,0 +1,170 @@
+package main
+
+// The receiving half: a nudge pushed by mavend has to reach the speaker, and
+// it has to obey the same two gates a reply obeys (V-671).
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/kami/maven/internal/audio"
+	"github.com/kami/maven/internal/voice"
+)
+
+func nudgeAudio() audio.Audio {
+	return audio.Audio{Format: audio.PCM16kMono, Bytes: make([]byte, 8000)}
+}
+
+// pushFrame builds the frame mavend's voicesink sends.
+func pushFrame(t *testing.T, a audio.Audio) voice.Push {
+	t.Helper()
+	body, err := json.Marshal(voice.AudioNudgePush{
+		RuleName: "test-rule",
+		Severity: 3,
+		Audio:    a,
+		Text:     "пора пить воду",
+		Ts:       time.Unix(0, 0),
+	})
+	if err != nil {
+		t.Fatalf("marshal push: %v", err)
+	}
+	return voice.Push{Kind: voice.PushKindAudioNudge, Params: body}
+}
+
+// The defect itself: the push arrived and nothing came out of the speaker.
+func TestNudgeReachesThePlayer(t *testing.T) {
+	sess, p, snd := newTestSession(bargeInConfig{})
+	(&nudgeHandler{sess: sess}).OnPush(pushFrame(t, nudgeAudio()))
+
+	if p.plays != 0 {
+		t.Fatal("nudge played from the push goroutine; it must wait for the capture loop")
+	}
+	if err := sess.feed(context.Background(), silentBytes()); err != nil {
+		t.Fatalf("feed: %v", err)
+	}
+	if p.plays != 1 {
+		t.Fatalf("plays = %d, want 1", p.plays)
+	}
+	if len(p.last.Bytes) != 8000 {
+		t.Errorf("played %d bytes, want the nudge audio", len(p.last.Bytes))
+	}
+	if sess.nudges != 1 {
+		t.Errorf("nudges = %d, want 1", sess.nudges)
+	}
+	if len(snd.sent) != 0 {
+		t.Errorf("a nudge must not be shipped back to the daemon as an utterance")
+	}
+}
+
+// A push of some other kind, or one carrying no audio, must not reach the
+// player and must not wedge the one that follows.
+func TestNudgeIgnoresUnusablePushes(t *testing.T) {
+	sess, p, _ := newTestSession(bargeInConfig{})
+	h := &nudgeHandler{sess: sess}
+
+	h.OnPush(voice.Push{Kind: "something-else", Params: json.RawMessage(`{}`)})
+	h.OnPush(voice.Push{Kind: voice.PushKindAudioNudge, Params: json.RawMessage(`not json`)})
+	h.OnPush(pushFrame(t, audio.Audio{Format: audio.PCM16kMono}))
+
+	if err := sess.feed(context.Background(), silentBytes()); err != nil {
+		t.Fatalf("feed: %v", err)
+	}
+	if p.plays != 0 {
+		t.Fatalf("plays = %d, want 0", p.plays)
+	}
+
+	h.OnPush(pushFrame(t, nudgeAudio()))
+	if err := sess.feed(context.Background(), silentBytes()); err != nil {
+		t.Fatalf("feed: %v", err)
+	}
+	if p.plays != 1 {
+		t.Fatalf("plays after a usable nudge = %d, want 1", p.plays)
+	}
+}
+
+// The half-duplex gate covers a nudge exactly as it covers a reply: she does
+// not start one over herself, and the mic stays muted while it runs.
+func TestNudgeWaitsForTheReplyToFinish(t *testing.T) {
+	sess, p, _ := newTestSession(bargeInConfig{})
+	speakThenPause(t, sess)
+	if !p.Playing() {
+		t.Fatal("expected the reply to be playing")
+	}
+	plays := p.plays
+
+	(&nudgeHandler{sess: sess}).OnPush(pushFrame(t, nudgeAudio()))
+	for i := 0; i < 20; i++ {
+		if err := sess.feed(context.Background(), silentBytes()); err != nil {
+			t.Fatalf("feed: %v", err)
+		}
+	}
+	if p.plays != plays {
+		t.Fatalf("nudge cut across the reply: plays = %d, want %d", p.plays, plays)
+	}
+
+	p.playing = false
+	if err := sess.feed(context.Background(), silentBytes()); err != nil {
+		t.Fatalf("feed: %v", err)
+	}
+	if p.plays != plays+1 {
+		t.Fatalf("nudge never played after the reply ended: plays = %d", p.plays)
+	}
+}
+
+// Speaking a nudge must not leave half a sentence in the VAD. The frames
+// captured before it are pre-nudge speech, and splicing them onto whatever he
+// says afterwards ships one utterance that is two.
+func TestNudgeResetsTheVAD(t *testing.T) {
+	sess, p, snd := newTestSession(bargeInConfig{})
+	loud := frameAt(0.35)
+	speechFrames := (defaultSpeechMs + defaultFrameMs - 1) / defaultFrameMs
+	for i := 0; i < speechFrames+5; i++ {
+		if err := sess.feed(context.Background(), loud); err != nil {
+			t.Fatalf("feed: %v", err)
+		}
+	}
+
+	(&nudgeHandler{sess: sess}).OnPush(pushFrame(t, nudgeAudio()))
+	if err := sess.feed(context.Background(), silentBytes()); err != nil {
+		t.Fatalf("feed: %v", err)
+	}
+	if p.plays != 1 {
+		t.Fatalf("nudge did not play: plays = %d", p.plays)
+	}
+
+	// Playback ends, silence follows. The half-formed utterance must be gone
+	// rather than closing on the first quiet frame.
+	p.playing = false
+	silenceFrames := (defaultSilenceMs+defaultFrameMs-1)/defaultFrameMs + 2
+	for i := 0; i < silenceFrames; i++ {
+		if err := sess.feed(context.Background(), silentBytes()); err != nil {
+			t.Fatalf("feed: %v", err)
+		}
+	}
+	if len(snd.sent) != 0 {
+		t.Fatalf("sent %d utterances after a nudge, want 0", len(snd.sent))
+	}
+}
+
+// Two nudges queued back to back: the newer one is what he hears. The
+// PushHandler contract in internal/voice says the next nudge replaces the
+// stale one rather than dogpiling on it.
+func TestNudgeReplacesAnUnspokenOne(t *testing.T) {
+	sess, p, _ := newTestSession(bargeInConfig{})
+	h := &nudgeHandler{sess: sess}
+
+	h.OnPush(pushFrame(t, audio.Audio{Format: audio.PCM16kMono, Bytes: make([]byte, 4000)}))
+	h.OnPush(pushFrame(t, audio.Audio{Format: audio.PCM16kMono, Bytes: make([]byte, 12000)}))
+
+	if err := sess.feed(context.Background(), silentBytes()); err != nil {
+		t.Fatalf("feed: %v", err)
+	}
+	if p.plays != 1 {
+		t.Fatalf("plays = %d, want 1", p.plays)
+	}
+	if len(p.last.Bytes) != 12000 {
+		t.Errorf("played %d bytes, want the newer nudge", len(p.last.Bytes))
+	}
+}

cmd/mavwaked/session.go

@@ -7,6 +7,7 @@ package main
 import (
 	"context"
 	"log"
+	"sync"
 	"time"
 
 	"github.com/kami/maven/internal/audio"
@@ -19,6 +20,15 @@ type utteranceSender interface {
 	Send(ctx context.Context, utt audio.Audio, lang string) (audio.Audio, error)
 }
 
+// keywordGate answers whether the keyword has just been spoken. The
+// production one is wakeWord; tests substitute a recorder, because a gate that
+// can only be exercised with three ONNX files is a gate nobody tests.
+type keywordGate interface {
+	Feed(frame []int16) bool
+	Reset()
+	Score() float64
+}
+
 // bargeInConfig holds the two numbers barge-in needs. Zero Frames disables
 // barge-in entirely — the half-duplex gate still runs.
 type bargeInConfig struct {
@@ -62,11 +72,29 @@ type session struct {
 	// whenever playback ends.
 	loudFrames int
 
+	// wake is the keyword gate, or nil when no model was loaded. wakeUntil is
+	// how long a keyword stays good for: he says "Мэйвен" and then a sentence,
+	// and the VAD does not close the utterance until he stops, so the window
+	// has to outlive the word by the length of what follows it.
+	wake       keywordGate
+	wakeWindow time.Duration
+	wakeUntil  time.Time
+
+	// pending holds a nudge the push receiver handed over, waiting for the
+	// capture loop to speak it. It is the one field written from another
+	// goroutine, hence the mutex; everything else in this struct belongs to
+	// the capture loop alone.
+	nudgeMu sync.Mutex
+	pending *audio.Audio
+
 	// counters, read by tests and logged on the way out.
 	suppressed int // frames dropped because she was speaking
 	dropped    int // frames dropped as round-trip backlog
 	bargeIns   int // times playback was cut because he spoke over her
 	sent       int // utterances shipped to the daemon
+	nudges     int // proactive pushes spoken through the speaker
+	wakes      int // times the keyword opened the gate
+	ignored    int // complete utterances dropped because the keyword was absent
 
 	// loudSum and loudSeen accumulate the energy of suppressed frames, so
 	// the operator can read what the room actually measures and set
@@ -79,6 +107,12 @@ func newSession(vad *VAD, p player, s utteranceSender, lang string, barge bargeI
 	return &session{vad: vad, player: p, sender: s, lang: lang, barge: barge, now: time.Now}
 }
 
+// UseWakeWord puts the keyword gate in front of dispatch. Without it every
+// utterance is shipped, which is what mavwaked did before V-487 stage two.
+func (s *session) UseWakeWord(w keywordGate, window time.Duration) {
+	s.wake, s.wakeWindow = w, window
+}
+
 // frameDuration is the wall time one captured frame represents.
 const frameDuration = defaultFrameMs * time.Millisecond
 
@@ -138,6 +172,7 @@ func (s *session) feed(ctx context.Context, frame []byte) error {
 		s.bargeIns++
 		s.loudFrames = 0
 		s.vad.Reset()
+		s.resetWake()
 		log.Printf("mavwaked: barge-in — stopped playback")
 		s.replayRecent()
 		return nil
@@ -148,15 +183,101 @@ func (s *session) feed(ctx context.Context, frame []byte) error {
 	if s.loudFrames != 0 {
 		s.loudFrames = 0
 		s.vad.Reset()
+		// The wake word saw nothing during playback, so what it holds is from
+		// before she spoke. Judging what he says next on it would score a
+		// sentence that ended a reply ago.
+		s.resetWake()
 	}
 
-	utt, state := s.vad.Feed(PCMToI16(frame))
+	if s.startPendingNudge() {
+		return nil
+	}
+
+	// The keyword is scored on the same frames the VAD sees, and only on the
+	// ones that reach here: every path above returns while she is speaking, so
+	// her own voice saying "Мэйвен" cannot wake her.
+	pcm := PCMToI16(frame)
+	if s.wake != nil && s.wake.Feed(pcm) {
+		s.wakes++
+		s.wakeUntil = s.now().Add(s.wakeWindow)
+		log.Printf("mavwaked: keyword heard (score %.3f), listening for %s",
+			s.wake.Score(), s.wakeWindow)
+	}
+
+	utt, state := s.vad.Feed(pcm)
 	if state == StateSpeech || utt.Bytes == nil {
 		return nil
 	}
 	return s.dispatch(ctx, utt)
 }
 
+// Nudge hands proactive audio to the session, to be spoken as soon as the
+// capture loop finds a quiet moment. Safe to call from the push receiver
+// goroutine; nothing else here is.
+//
+// A nudge arriving while one is already waiting REPLACES it. That is the
+// contract internal/voice states for PushHandler: the next nudge replaces the
+// stale one in his attention rather than dogpiling on it.
+func (s *session) Nudge(a audio.Audio) {
+	if len(a.Bytes) == 0 {
+		return
+	}
+	s.nudgeMu.Lock()
+	if s.pending != nil {
+		log.Printf("mavwaked: nudge replaced one still waiting to be spoken")
+	}
+	s.pending = &a
+	s.nudgeMu.Unlock()
+}
+
+// takeNudge removes and returns the waiting nudge, or nil.
+func (s *session) takeNudge() *audio.Audio {
+	s.nudgeMu.Lock()
+	defer s.nudgeMu.Unlock()
+	a := s.pending
+	s.pending = nil
+	return a
+}
+
+// startPendingNudge speaks a waiting nudge and reports whether it started
+// one. It runs on the capture loop, past the half-duplex gate, so a nudge
+// never cuts across a reply and never plays into a backlog drain.
+//
+// The VAD is reset first. Playback is about to suppress every frame until it
+// ends, and a half-heard sentence left in the VAD would splice onto whatever
+// he says afterwards. Barge-in needs no special case: it reads the player,
+// and the player does not care which audio it is playing.
+func (s *session) startPendingNudge() bool {
+	a := s.takeNudge()
+	if a == nil {
+		return false
+	}
+	s.vad.Reset()
+	s.nudges++
+	log.Printf("mavwaked: speaking nudge (%.2fs audio)", a.Duration())
+	s.player.Play(*a)
+	return true
+}
+
+// awake reports whether an utterance ending now was addressed to her.
+//
+// With no wake word loaded every utterance is, which is exactly what mavwaked
+// did before this gate existed. An operator with no model file gets the old
+// daemon rather than a daemon that refuses to hear anything.
+func (s *session) awake() bool {
+	if s.wake == nil {
+		return true
+	}
+	return s.now().Before(s.wakeUntil)
+}
+
+// resetWake drops the gate's streaming state when there is a gate.
+func (s *session) resetWake() {
+	if s.wake != nil {
+		s.wake.Reset()
+	}
+}
+
 // keepRecent stores a copy of one barge-in trigger frame, keeping at most
 // barge.Frames of them.
 func (s *session) keepRecent(frame []byte) {
@@ -197,6 +318,19 @@ func (s *session) replayRecent() {
 // whole backlog straight into the VAD, and a Send error did the same on every
 // failed turn, so a dead socket drove a retry loop off nothing but backlog.
 func (s *session) dispatch(ctx context.Context, utt audio.Audio) error {
+	if !s.awake() {
+		s.ignored++
+		log.Printf("mavwaked: utterance ignored, keyword not heard (%.2fs, %d ignored so far)",
+			utt.Duration(), s.ignored)
+		s.vad.Reset()
+		s.resetWake()
+		return nil
+	}
+	// One keyword, one turn. A window that renewed itself on every reply would
+	// leave the microphone open for as long as he kept talking, which is the
+	// state this gate exists to end.
+	s.wakeUntil = time.Time{}
+
 	log.Printf("mavwaked: utterance complete (%.2fs, %d bytes), sending...", utt.Duration(), len(utt.Bytes))
 	start := s.now()
 	reply, err := s.sender.Send(ctx, utt, s.lang)
@@ -225,6 +359,7 @@ func (s *session) dispatch(ctx context.Context, utt audio.Audio) error {
 // recorded before she started speaking.
 func (s *session) dropBacklog(start time.Time) {
 	s.vad.Reset()
+	s.resetWake()
 	s.loudFrames = 0
 	s.recent = s.recent[:0]
 	if elapsed := s.now().Sub(start); elapsed > 0 {

cmd/mavwaked/wakefeatures.go

@@ -0,0 +1,202 @@
+package main
+
+// The three models behind the wake word (V-487 stage two).
+//
+// openWakeWord's pipeline, run in a row:
+//
+//	audio      -> melspectrogram.onnx -> 32-bin mel frames, one per 10ms
+//	76 frames  -> embedding_model.onnx -> one 96-dim embedding per 80ms
+//	16 embeds  -> maven_wakeword.onnx  -> one score
+//
+// The first two are frozen and pretrained. Only the last was trained here,
+// which is why it is 100KB and the other two are megabytes. The shapes are
+// not guesses: 2.0s of 16kHz audio measures 197 mel frames, and 76-frame
+// windows at stride 8 give exactly the 16 embeddings the head was fitted on.
+//
+// This file knows ONNX and nothing about the 80ms cadence. wakeword.go knows
+// the cadence and nothing about tensors.
+
+import (
+	"fmt"
+
+	ort "github.com/yalue/onnxruntime_go"
+)
+
+const (
+	// melHop — samples per mel frame. 10ms at 16kHz.
+	melHop = 160
+	// melBins — mel bins per frame, fixed by melspectrogram.onnx.
+	melBins = 32
+	// embedFrames — mel frames one embedding is computed over, 760ms.
+	embedFrames = 76
+	// embedStride — mel frames between embeddings, 80ms.
+	embedStride = 8
+	// embedDim — the embedding width.
+	embedDim = 96
+	// headWindow — embeddings the head scores at once, 1.28s of audio.
+	headWindow = 16
+
+	// melContext — samples of history prepended to each incremental mel
+	// call, chosen so the eight frames this call yields continue exactly
+	// where the previous call's eight stopped.
+	//
+	// melspectrogram.onnx returns N/160-3 frames for N samples, and frame i
+	// covers [i*160, i*160+400). With 480 samples of history the buffer is
+	// 1760 samples, which is 8 frames, and the oldest of them starts one hop
+	// after the newest of the previous call. Less history leaves a gap: the
+	// first frames of a bare chunk would be computed against silence.
+	melContext = 480
+
+	// chunkSamples — audio per embedding step, 80ms.
+	chunkSamples = embedStride * melHop
+)
+
+// wakeModels holds the three ONNX sessions. It runs on CPU threads beside
+// silero and never touches the GPU. That is a rule, not a result: a wake word
+// that waits on card admission is not a wake word.
+type wakeModels struct {
+	mel  *ort.DynamicAdvancedSession
+	emb  *ort.DynamicAdvancedSession
+	head *ort.DynamicAdvancedSession
+}
+
+// newWakeModels loads all three. melPath and embedPath are openWakeWord's
+// frozen feature models; headPath is the keyword head trained for "Мэйвен".
+func newWakeModels(melPath, embedPath, headPath, libPath string) (*wakeModels, error) {
+	if !ort.IsInitialized() {
+		if libPath != "" {
+			ort.SetSharedLibraryPath(libPath)
+		}
+		if err := ort.InitializeEnvironment(); err != nil {
+			return nil, fmt.Errorf("wake word: onnx runtime: %w", err)
+		}
+	}
+	// One thread per session, not the default of every core. Measured on
+	// workpc: the default took mavwaked from 68% of one core to 335% of
+	// three, for three graphs that each run in well under 80ms single
+	// threaded. An always-on gate that eats a quarter of the workstation is
+	// not a gate he will leave running.
+	opts, err := ort.NewSessionOptions()
+	if err != nil {
+		return nil, fmt.Errorf("wake word: session options: %w", err)
+	}
+	defer opts.Destroy()
+	if err := opts.SetIntraOpNumThreads(1); err != nil {
+		return nil, fmt.Errorf("wake word: intra-op threads: %w", err)
+	}
+	if err := opts.SetInterOpNumThreads(1); err != nil {
+		return nil, fmt.Errorf("wake word: inter-op threads: %w", err)
+	}
+	open := func(p string, in, out []string) (*ort.DynamicAdvancedSession, error) {
+		s, err := ort.NewDynamicAdvancedSession(p, in, out, opts)
+		if err != nil {
+			return nil, fmt.Errorf("wake word: load %s: %w", p, err)
+		}
+		return s, nil
+	}
+	m := &wakeModels{}
+	if m.mel, err = open(melPath, []string{"input"}, []string{"output"}); err != nil {
+		return nil, err
+	}
+	if m.emb, err = open(embedPath, []string{"input_1"}, []string{"conv2d_19"}); err != nil {
+		m.Close()
+		return nil, err
+	}
+	if m.head, err = open(headPath, []string{"embeddings"}, []string{"score"}); err != nil {
+		m.Close()
+		return nil, err
+	}
+	return m, nil
+}
+
+// Close releases the three sessions.
+func (m *wakeModels) Close() {
+	if m == nil {
+		return
+	}
+	for _, s := range []*ort.DynamicAdvancedSession{m.mel, m.emb, m.head} {
+		if s != nil {
+			s.Destroy()
+		}
+	}
+	m.mel, m.emb, m.head = nil, nil, nil
+}
+
+// melFrames runs one buffer of samples and returns the mel frames it yielded.
+func (m *wakeModels) melFrames(buf []float32) ([][melBins]float32, error) {
+	in, err := ort.NewTensor(ort.NewShape(1, int64(len(buf))), buf)
+	if err != nil {
+		return nil, err
+	}
+	defer in.Destroy()
+
+	n := int64(len(buf)/melHop - 3)
+	if n < 1 {
+		return nil, fmt.Errorf("wake word: %d samples yield no mel frames", len(buf))
+	}
+	out, err := ort.NewEmptyTensor[float32](ort.NewShape(1, 1, n, melBins))
+	if err != nil {
+		return nil, err
+	}
+	defer out.Destroy()
+
+	if err := m.mel.Run([]ort.Value{in}, []ort.Value{out}); err != nil {
+		return nil, err
+	}
+	data := out.GetData()
+	frames := make([][melBins]float32, n)
+	for i := range frames {
+		for j := 0; j < melBins; j++ {
+			// The scaling openWakeWord applies between the two feature
+			// models, and the head was fitted on its output.
+			frames[i][j] = data[i*melBins+j]/10.0 + 2.0
+		}
+	}
+	return frames, nil
+}
+
+// embedding runs embedFrames mel frames through the frozen embedder.
+func (m *wakeModels) embedding(mels [][melBins]float32) ([embedDim]float32, error) {
+	var e [embedDim]float32
+	flat := make([]float32, 0, embedFrames*melBins)
+	for _, f := range mels {
+		flat = append(flat, f[:]...)
+	}
+	in, err := ort.NewTensor(ort.NewShape(1, embedFrames, melBins, 1), flat)
+	if err != nil {
+		return e, err
+	}
+	defer in.Destroy()
+	out, err := ort.NewEmptyTensor[float32](ort.NewShape(1, 1, 1, embedDim))
+	if err != nil {
+		return e, err
+	}
+	defer out.Destroy()
+	if err := m.emb.Run([]ort.Value{in}, []ort.Value{out}); err != nil {
+		return e, err
+	}
+	copy(e[:], out.GetData())
+	return e, nil
+}
+
+// score runs the trained head over headWindow embeddings.
+func (m *wakeModels) score(embeds [][embedDim]float32) (float64, error) {
+	flat := make([]float32, 0, headWindow*embedDim)
+	for _, e := range embeds {
+		flat = append(flat, e[:]...)
+	}
+	in, err := ort.NewTensor(ort.NewShape(1, headWindow, embedDim), flat)
+	if err != nil {
+		return 0, err
+	}
+	defer in.Destroy()
+	out, err := ort.NewEmptyTensor[float32](ort.NewShape(1, 1))
+	if err != nil {
+		return 0, err
+	}
+	defer out.Destroy()
+	if err := m.head.Run([]ort.Value{in}, []ort.Value{out}); err != nil {
+		return 0, err
+	}
+	return float64(out.GetData()[0]), nil
+}

cmd/mavwaked/wakeword.go

@@ -0,0 +1,195 @@
+package main
+
+// The wake word, "Мэйвен" (V-487 stage two).
+//
+// Silero answers "is this frame speech". It does not answer "was this said to
+// her", and until this file existed nothing did: every utterance near the
+// microphone became a turn. What made that safe rather than expensive was
+// SurfaceVoice capping acts at L0, and L0 does not cap reading, so the room
+// could still hear his facts read back.
+//
+// This file owns the 80ms cadence and the three rings of state between the
+// models. wakefeatures.go owns the tensors.
+//
+// Nil is a working value, and it is the CLOSED gate rather than the open one.
+// Feed on a nil receiver reports no keyword; session.go asks separately
+// whether a gate exists at all. That split is deliberate: a nil that answers
+// "yes, keyword" reads as a working wake word in every log line it produces.
+
+import (
+	"log"
+	"sync"
+)
+
+// defaultWakeThreshold — score above which the keyword was said.
+//
+// Picked from the false-accept rate on held-out Russian speech, not from
+// accuracy: a miss costs him a repeat, a false accept costs a turn nobody
+// asked for. Over 65 minutes of Common Voice, 0.99 woke her three times and
+// 0.999 once, and the difference in recall was one render out of 126. So the
+// default is the strict one. `docs/evals/2026-08-09-wake-word.md` has both
+// tables.
+const defaultWakeThreshold = 0.999
+
+// wakeWord is the streaming state around wakeModels. It is fed the same
+// capture frames the VAD sees and answers whether the keyword has just been
+// spoken.
+type wakeWord struct {
+	mu sync.Mutex
+	m  *wakeModels
+
+	threshold float64
+
+	// pending holds captured samples not yet part of a full 80ms chunk, and
+	// history holds the melContext samples before them.
+	pending []float32
+	history []float32
+
+	// mels is the newest embedFrames mel frames, oldest first.
+	mels [][melBins]float32
+	// embeds is the newest headWindow embeddings, oldest first.
+	embeds [][embedDim]float32
+
+	last float64 // most recent score, held between chunks
+}
+
+// newWakeWord loads the models and wraps them in the streaming gate.
+func newWakeWord(melPath, embedPath, headPath, libPath string, threshold float64) (*wakeWord, error) {
+	m, err := newWakeModels(melPath, embedPath, headPath, libPath)
+	if err != nil {
+		return nil, err
+	}
+	if threshold <= 0 {
+		threshold = defaultWakeThreshold
+	}
+	return &wakeWord{m: m, threshold: threshold}, nil
+}
+
+// Close releases the models.
+func (w *wakeWord) Close() {
+	if w == nil {
+		return
+	}
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	w.m.Close()
+	w.m = nil
+}
+
+// Feed takes one capture frame and reports whether the keyword was heard on
+// it. A nil wakeWord hears nothing.
+func (w *wakeWord) Feed(frame []int16) bool {
+	if w == nil {
+		return false
+	}
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	for _, v := range frame {
+		w.pending = append(w.pending, float32(v)/32768.0)
+	}
+	fired := false
+	for len(w.pending) >= chunkSamples {
+		chunk := w.pending[:chunkSamples]
+		if w.step(chunk) {
+			fired = true
+		}
+		w.history = append(w.history[:0], tailFloat32(append(w.history, chunk...), melContext)...)
+		// Slide the remainder to the front rather than reslicing. This runs
+		// every 80ms for as long as the daemon lives.
+		w.pending = append(w.pending[:0], w.pending[chunkSamples:]...)
+	}
+	return fired
+}
+
+// Reset drops the streaming state, so a fresh utterance is not judged on audio
+// from before it. Called after every dispatch and after barge-in, for the same
+// reason silero is: echo-era history must not score the next sentence, and her
+// own voice saying the keyword must not wake her.
+func (w *wakeWord) Reset() {
+	if w == nil {
+		return
+	}
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	w.pending, w.history = w.pending[:0], w.history[:0]
+	w.mels, w.embeds = nil, nil
+	w.last = 0
+}
+
+// Score returns the most recent score, for the operator to read out of the
+// journal when picking a threshold for his room.
+func (w *wakeWord) Score() float64 {
+	if w == nil {
+		return 0
+	}
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	return w.last
+}
+
+// step runs one 80ms chunk through all three models. It returns true when the
+// score crosses the threshold on this chunk.
+func (w *wakeWord) step(chunk []float32) bool {
+	buf := make([]float32, 0, melContext+len(chunk))
+	if pad := melContext - len(w.history); pad > 0 {
+		buf = append(buf, make([]float32, pad)...)
+	}
+	buf = append(buf, tailFloat32(w.history, melContext)...)
+	buf = append(buf, chunk...)
+
+	frames, err := w.m.melFrames(buf)
+	if err != nil {
+		// A failed inference must not silence the microphone. Hold the last
+		// score and let the next chunk try again.
+		log.Printf("mavwaked: wake word: mel: %v", err)
+		return false
+	}
+	w.mels = tailMel(append(w.mels, frames...), embedFrames)
+	if len(w.mels) < embedFrames {
+		return false
+	}
+	e, err := w.m.embedding(w.mels)
+	if err != nil {
+		log.Printf("mavwaked: wake word: embedding: %v", err)
+		return false
+	}
+	w.embeds = tailEmbed(append(w.embeds, e), headWindow)
+	if len(w.embeds) < headWindow {
+		return false
+	}
+	score, err := w.m.score(w.embeds)
+	if err != nil {
+		log.Printf("mavwaked: wake word: head: %v", err)
+		return false
+	}
+	// Report the crossing, not the state. A keyword held above the threshold
+	// for a second is one wake, and firing on every chunk of it would make the
+	// gate look open when it is merely slow to fall.
+	crossed := score >= w.threshold && w.last < w.threshold
+	w.last = score
+	return crossed
+}
+
+// The three rings. Each keeps the newest n entries and nothing older.
+
+func tailFloat32(s []float32, n int) []float32 {
+	if len(s) <= n {
+		return s
+	}
+	return s[len(s)-n:]
+}
+
+func tailMel(s [][melBins]float32, n int) [][melBins]float32 {
+	if len(s) <= n {
+		return s
+	}
+	return append(s[:0], s[len(s)-n:]...)
+}
+
+func tailEmbed(s [][embedDim]float32, n int) [][embedDim]float32 {
+	if len(s) <= n {
+		return s
+	}
+	return append(s[:0], s[len(s)-n:]...)
+}

cmd/mavwaked/wakeword_test.go

@@ -0,0 +1,174 @@
+package main
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// fakeGate fires on demand instead of running three ONNX models. The gate's
+// own arithmetic is measured on real audio in docs/evals; what these tests
+// cover is the thing that decides whether an utterance is shipped.
+type fakeGate struct {
+	fireOn int // fire when this many frames have been fed, 0 never fires
+	fed    int
+	resets int
+}
+
+func (g *fakeGate) Feed(_ []int16) bool {
+	g.fed++
+	return g.fireOn > 0 && g.fed == g.fireOn
+}
+func (g *fakeGate) Reset()         { g.resets++ }
+func (g *fakeGate) Score() float64 { return 1 }
+
+// wakingSession wires a session whose gate fires on the first frame it sees.
+func wakingSession(fireOn int, window time.Duration) (*session, *fakePlayer, *fakeSender, *fakeGate) {
+	sess, p, snd := newTestSession(bargeInConfig{})
+	g := &fakeGate{fireOn: fireOn}
+	sess.UseWakeWord(g, window)
+	return sess, p, snd, g
+}
+
+func TestKeywordlessSpeechNeverReachesSTT(t *testing.T) {
+	sess, p, snd, g := wakingSession(0, 8*time.Second)
+	speakThenPause(t, sess)
+
+	if len(snd.sent) != 0 {
+		t.Fatalf("sent %d utterances, want 0 — this is the whole point of V-487", len(snd.sent))
+	}
+	if sess.ignored != 1 {
+		t.Errorf("ignored = %d, want 1", sess.ignored)
+	}
+	if p.plays != 0 {
+		t.Errorf("plays = %d, want 0", p.plays)
+	}
+	if g.fed == 0 {
+		t.Error("the gate was never fed a frame")
+	}
+}
+
+func TestKeywordOpensTheGate(t *testing.T) {
+	sess, p, snd, _ := wakingSession(1, 8*time.Second)
+	speakThenPause(t, sess)
+
+	if len(snd.sent) != 1 {
+		t.Fatalf("sent %d utterances, want 1", len(snd.sent))
+	}
+	if sess.wakes != 1 {
+		t.Errorf("wakes = %d, want 1", sess.wakes)
+	}
+	if sess.ignored != 0 {
+		t.Errorf("ignored = %d, want 0", sess.ignored)
+	}
+	if p.plays != 1 {
+		t.Errorf("plays = %d, want 1", p.plays)
+	}
+}
+
+// One keyword buys one turn. Without this the microphone stays open for as
+// long as he keeps talking, which is the state the gate exists to end.
+func TestOneKeywordBuysOneTurn(t *testing.T) {
+	sess, p, snd, _ := wakingSession(1, 8*time.Second)
+	speakThenPause(t, sess)
+	p.Stop()         // she finished her reply
+	sess.discard = 0 // the backlog drain is not what this measures
+	speakThenPause(t, sess)
+
+	if len(snd.sent) != 1 {
+		t.Fatalf("sent %d utterances, want 1: the second had no keyword", len(snd.sent))
+	}
+	if sess.ignored != 1 {
+		t.Errorf("ignored = %d, want 1", sess.ignored)
+	}
+}
+
+// The keyword is heard, then he says nothing for longer than the window. What
+// he says after that is not addressed to her.
+func TestTheKeywordExpires(t *testing.T) {
+	sess, _, snd, _ := wakingSession(1, 500*time.Millisecond)
+	now := time.Unix(1750000000, 0)
+	sess.now = func() time.Time { return now }
+
+	if err := sess.feed(context.Background(), silentBytes()); err != nil {
+		t.Fatalf("feed: %v", err)
+	}
+	if sess.wakes != 1 {
+		t.Fatalf("wakes = %d, want 1", sess.wakes)
+	}
+	now = now.Add(2 * time.Second)
+	speakThenPause(t, sess)
+
+	if len(snd.sent) != 0 {
+		t.Fatalf("sent %d utterances, want 0 — the keyword had expired", len(snd.sent))
+	}
+}
+
+// Barge-in cuts her off whether or not the keyword was heard. What he says
+// after cutting her off still has to carry it.
+func TestBargeInStillInterruptsHer(t *testing.T) {
+	sess, p, _, g := wakingSession(0, 8*time.Second)
+	sess.barge = bargeInConfig{RMS: 0.2, Frames: 3}
+	p.playing = true
+	loud := frameAt(0.35)
+	for i := 0; i < 4; i++ {
+		if err := sess.feed(context.Background(), loud); err != nil {
+			t.Fatalf("feed %d: %v", i, err)
+		}
+	}
+	if sess.bargeIns != 1 {
+		t.Fatalf("bargeIns = %d, want 1", sess.bargeIns)
+	}
+	if p.stops != 1 {
+		t.Errorf("stops = %d, want 1", p.stops)
+	}
+	if g.resets == 0 {
+		t.Error("barge-in left pre-playback audio in the gate")
+	}
+}
+
+// Her own reply must not wake her. Frames captured while the player runs never
+// reach the gate, and the gate is cleared when playback ends.
+func TestHerOwnVoiceNeverReachesTheGate(t *testing.T) {
+	sess, p, _, g := wakingSession(1, 8*time.Second)
+	p.playing = true
+	for i := 0; i < 10; i++ {
+		if err := sess.feed(context.Background(), frameAt(0.35)); err != nil {
+			t.Fatalf("feed: %v", err)
+		}
+	}
+	if g.fed != 0 {
+		t.Fatalf("gate was fed %d frames while she was speaking, want 0", g.fed)
+	}
+	if sess.wakes != 0 {
+		t.Errorf("wakes = %d, want 0", sess.wakes)
+	}
+}
+
+// No model, no gate: the daemon behaves exactly as it did before V-487 stage
+// two. An operator with a missing file gets yesterday's mavwaked, not one that
+// refuses to hear anything.
+func TestNoGateShipsEveryUtterance(t *testing.T) {
+	sess, _, snd := newTestSession(bargeInConfig{})
+	speakThenPause(t, sess)
+
+	if len(snd.sent) != 1 {
+		t.Fatalf("sent %d utterances, want 1", len(snd.sent))
+	}
+	if sess.ignored != 0 {
+		t.Errorf("ignored = %d, want 0", sess.ignored)
+	}
+}
+
+// A nil *wakeWord is the closed gate, not a crash and not an open one.
+func TestNilWakeWordHearsNothing(t *testing.T) {
+	var w *wakeWord
+	if w.Feed([]int16{0, 0, 0}) {
+		t.Error("a nil wake word reported the keyword")
+	}
+	if w.Score() != 0 {
+		t.Error("a nil wake word reported a score")
+	}
+	w.Reset()
+	w.Close()
+}

deploy/mavwaked.service

@@ -4,11 +4,22 @@
 # user unit because it needs his ALSA session and his ssh agent, and because
 # it should stop when he logs out.
 #
-# THERE IS NO WAKE WORD YET (V-487 stage two). Anything spoken near the fifine
-# becomes a turn. What makes that safe rather than expensive is voiceSender:
-# it sends Surface=SurfaceVoice, which caps every command at L0, so no
-# accidental trigger runs a destructive act. It does not stop her answering
-# out loud, so this unit is his to stop when the room is not his alone.
+# The keyword is "Мэйвен" and the three -wake- flags are what require it
+# (V-487 stage two). Without them anything spoken near the fifine becomes a
+# turn, which voiceSender makes safe rather than expensive: it sends
+# Surface=SurfaceVoice, capping every command at L0. That does not stop her
+# answering out loud, which is the whole reason the keyword exists.
+#
+# The threshold is 0.999 and it is the binary's default, so it is not passed.
+# It came from 65 minutes of held-out Russian speech through this same binary:
+# 0.9 false wakes an hour against 2.8 at 0.99, for one lost render out of 126
+# (docs/evals/2026-08-09-wake-word.md). If the room proves noisier than the
+# corpus, read the scores out of this unit's journal and pass -wake-threshold.
+# Do not lower it by guessing.
+#
+# A keyword shorter than 1.32s can be heard too late to be used, because the
+# head scores 1.28s of audio and the VAD has closed the utterance by then.
+# "Мэйвен, <request>" is unaffected. A bare "Мэйвен" is the case that fails.
 #
 # -vad-model is passed on purpose. Silero answers "is this frame speech" where
 # the energy floor answers "is this frame loud". It declines white noise at
@@ -24,7 +35,7 @@
 #            systemctl --user enable --now mavwaked.service
 
 [Unit]
-Description=Maven always-on listening (VAD, no wake word yet)
+Description=Maven always-on listening (silero VAD, "Мэйвен" keyword)
 # The tunnel is the only path to mavend and the only thing authenticating it.
 Requires=maven-voice-tunnel.service
 After=maven-voice-tunnel.service
@@ -45,6 +56,9 @@ ExecStart=%h/.local/bin/mavwaked \
   -addr 127.0.0.1:9100 \
   -lang ru \
   -vad-model %h/.local/share/maven/models/silero_vad.onnx \
+  -wake-model %h/.local/share/maven/models/maven_wakeword.onnx \
+  -wake-mel %h/.local/share/maven/models/melspectrogram.onnx \
+  -wake-embed %h/.local/share/maven/models/embedding_model.onnx \
   -onnx-lib %h/.local/lib/libonnxruntime.so
 Restart=on-failure
 RestartSec=5

docs/deployment.md

@@ -0,0 +1,208 @@
+# Deployment: the boxes, the models, the daemons
+
+*Last verified: 2026-08-09 @ a9b480a*
+
+What runs where, and why each choice was made. `CLAUDE.md` carries only the
+rules. This file carries the reasoning.
+
+## The two boxes
+
+**homesrv** is a Ryzen 5 5600U laptop and the deploy target. It offloads to the
+Vega iGPU over Vulkan (`n_gpu_layers: 99`). Compose passes `/dev/dri` and the
+render gid (993), and without both Vulkan enumerates zero devices and
+llama-server falls back to CPU silently.
+
+**workpc** is the workstation, 16GB of VRAM, reached as `kami@workpc` at
+192.168.1.105. Model work moved there on 2026-08-02 by the owner's call, because
+homesrv cannot grow a GPU.
+
+Three rules govern the seam:
+
+- **The workstation is never assumed up.**
+- **Fall back silently** when it would only do the job better.
+- **Name the gap** when the resident model cannot do the job at all.
+
+A world question goes through `LLMPhraser.PhraseWorld` and returns `worldGap`
+(`cmd/mavend/worldmodel.go`) rather than an invented answer. A box with no
+`workstation` block behaves exactly as it did before the seam. `docs/offload.md`
+says which caller is which.
+
+## The resident model
+
+**Qwen3-1.7B** (`UD-Q4_K_XL`), stock, not yet the CPT'd one. It is a Thinking
+variant, so `n_ctx` is 4096. Reasoning tokens need the room, and 4096 is what
+every score was measured at.
+
+The target is the locally CPT'd Qwen3-1.7B (V-122, training in flight). Stock
+already speaks good Russian. What it gets wrong is the persona. It writes `я рад`
+where Maven needs `рада`.
+
+**Do not bother with sub-500M models.** LFM2.5-230M and 350M were measured on
+2026-07-31 and both are unusable in Russian
+(`docs/evals/2026-07-31-model-bakeoff.md`). Their published IFEval and BFCL
+numbers are English-only.
+
+Model files live in `/mnt/hdd1/llms`, bind-mounted to `/opt/maven/models/llm`.
+That **shadows** the repo's `models/llm/`, so a gguf sitting there is not loaded
+by anything. Swapping the resident model is a one-line change to
+`phraser.model_path` in `deploy/mavend.json`.
+
+The workstation model is gemma-4-E4B as of 2026-08-09, replacing the 12B by the
+owner's call. Keep the 12B gguf. It is the better teacher for label runs, at
+72.7% destination against E4B's 57.6%.
+
+## The embedder
+
+**It stays on homesrv permanently**, because it backs the floor. It is
+multilingual-e5-small, quantized and asymmetric. `EmbedQuery` and `EmbedPassage`
+apply the `query:` and `passage:` prefixes it was trained with. Calling plain
+`Embed` on a note is a bug. See `docs/evals/2026-08-04-recall-e5-small.md`.
+
+The vendored onnxruntime under `deps/` has two copies, and the stale one is
+1.17.1. The live runtime is 1.26.0, and the Go binding asks for API 26. Anything
+shipped to another box needs `deps/onnxruntime-linux-x64-1.26.0`.
+
+## Speech-to-text
+
+`sttSeam` in `cmd/mavend/voicewire.go` builds an `stt.Pair` beside `modelSeam`.
+It prefers CrisperWhisper 2.0 turbo on workpc with mavsttd as the floor. It takes
+only the silent half of the rule, because a worse transcript is still a turn. So
+`stt.Pair` has no `TranscribeRemote` and the fallback is never spoken.
+
+CW2 turbo scores 10.4% WER in Russian against 27.5% for the `ggml-small.bin`
+mavsttd loads, over 200 Golos clips
+(`docs/evals/2026-08-09-crisperwhisper2-russian-wer.md`).
+
+**whisper.cpp cannot load CW2 at all.** It reads its language count off the
+vocabulary size. CW2's 51897 tokens shift seven special token ids. So CW2 is its
+own transformers service on port 8081 (`deploy/cw2/serve.py`).
+`stt.HTTPTranscriber` posts raw PCM to it with a bearer token, because audio is
+the most sensitive thing that crosses this seam. The switch is `workstation.stt`
+in `deploy/mavend.json`, and deleting the block sends every utterance to mavsttd.
+
+**mavgpud runs that service as a second child.** This is not an optimisation.
+CW2 is a ROCm process on the same card, so it registers on the KFD like any
+contender. Under its own systemd unit it made mavgpud evict llama-server every
+few seconds. That took the model arm down for eight minutes on 2026-08-09. The
+card needs one owner. CW2 is on the yield clock and not the idle one. At 1.6GB
+it denies the card to nobody.
+
+Text-to-speech has not moved. piper on homesrv is the only synthesizer.
+
+## The daemons
+
+| Binary | Role |
+|---|---|
+| `mavend` | **Core.** Router, phraser, memory, reminders, digestion tick. Owns the DB and IPC socket. |
+| `mavweb` | HTTP UI and PWA (`/dash`, `/history`, `/trace`, `/notifications`, `/tools`), WebAuthn auth. |
+| `mavsttd` | Speech-to-text (whisper.cpp, CGO). |
+| `mavttsd` | Text-to-speech (piper subprocess). |
+| `mavwaked` | Wake-word and VAD gate. Runs on workpc. |
+| `mavenclient` | Voice loop client (mic, stt, core, tts). Not deployed. |
+| `mavpoll` | Environment poller: netdata alarms, uptime-kuma, zenmoney, wireguard presence. Writes facts, sends nothing. Telegram is `internal/delivery/telegramsink`. |
+| `mavcaldav` | CalDAV calendar sync. |
+| `mavmaild` | Mail reader (IMAP, read-only). Holds the IMAP password, core never sees it. |
+| `mavgpud` | GPU supervisor. **Runs on workpc**, own unit `deploy/mavgpud.service`. Keeps llama-server loaded while the card is free (V-488). Maven never asks it for anything and reads `/health` through `llm.Pair`. |
+| `mavupdate` | Not a daemon. Operator CLI a human runs on the box to deploy a new build. |
+
+Two binaries have no Makefile target and neither is deployed. `mavseal` encrypts
+a live tmpfs working copy back to the ciphertext file when mavend was killed
+before `defer st.Close()` sealed it. `labelgen` runs the stage 0 grammars over
+utterances and prints JSONL, the training data for the routing heads.
+
+Daemons are wired socket-to-socket, not linked. `internal/ipc` is the wire
+protocol. `deploy/mavend.json` sets socket paths, model paths and the phraser and
+embedder blocks, with `${VAR}` expansion from gitignored `deploy/telegram.env`.
+
+### Who is in compose, and who is not
+
+**`docker-compose.yml` runs five**: `mavend`, `mavsttd`, `mavttsd`, `mavweb`,
+`mavpoll`. Count against compose, not against the table above.
+
+`mavmaild` and `mavcaldav` are commented out, each with the reason beside it. The
+first needs a mail account and the second a CalDAV account, and this box has
+neither. Two things ride on the CalDAV absence (V-644). Agenda questions route to
+`IntentQuery` at stage 0, and the `calendar` query source then reads a table
+nobody writes. And `loop.State.CalendarBusy` is fed by the same facts, so the
+gate's "do not nag mid-meeting" is permanently false.
+
+`mavenclient` is still absent. `mavwaked` moved to workpc on 2026-08-09 (V-515).
+
+### The voice wire
+
+`internal/voice` is plaintext with no auth. Its own server doc says production
+binds inside the wg tunnel, because the wg layer is the L0 floor. workpc is not
+a wg peer, it sits on wlan0. So the tunnel is ssh instead.
+
+mavend publishes the voice port to homesrv loopback only, `127.0.0.1:9110`.
+Host 9100 is Vikunja's MCP, hence 9110. The container side stays 9100 so mavweb
+keeps reaching `mavend:9100` by name. `deploy/maven-voice-tunnel.service` on
+workpc forwards it over his key.
+
+**Do not replace this with a LAN bind.** `SurfaceVoice` caps acts at L0, so an
+unauthorized speaker could not run a destructive tool. L0 does not cap reading,
+so they would still hear his facts, notes and calendar read back.
+
+Both `mavwaked` and `mavenclient` speak `voice.Dial`, not `ipc.Dial`. The
+`netaddr` token guards the daemon-to-daemon IPC seam and never touches this one.
+`ipc.Dial` does take `tcp://host:port?token=...`, which is why V-515 was filed
+as a config change. That premise was wrong, and the ssh leg is the correction.
+
+The voice loop belongs on a client machine where the owner is standing, and that
+machine is workpc (V-463, `docs/plans/17-where-the-voice-loop-runs.md`). homesrv
+has a microphone, because it is a laptop, but it is in the wrong room.
+
+### mavwaked on workpc
+
+`deploy/mavwaked.service`, a user unit beside `mavgpud.service`. Two flags are
+deliberate.
+
+`-vad-model` is passed. Silero answers "is this frame speech" where the energy
+floor answers "is this frame loud". It declines white noise at the same RMS, 0
+frames against 68 to 99, and still hears all four spoken fixtures
+(`docs/evals/2026-08-09-silero-vad.md`). It costs 509µs a frame and never touches
+the GPU. A model that will not load is logged and not fatal.
+
+`-barge-in` is not passed. The threshold is room-specific and this room has no
+number yet. Read the "suppressed while speaking" means out of the journal first.
+
+The device is `plughw:0,0` and not `hw:0,0`. The fifine offers 2 channels at
+44100 or 48000 and nothing else, and mavwaked asks arecord for 16kHz mono. Bare
+`hw` dies on "Channels count non available" before a frame is read.
+
+The three `-wake-` flags require the keyword "Мэйвен" (V-487 stage two). Drop
+them and the loop runs open, which is what it did before. The threshold is the
+binary's default of 0.999 and is not passed. Over 65 minutes of held-out
+Russian speech it woke her 0.9 times an hour against 2.8 at 0.99. That cost one
+lost render out of 126 (`docs/evals/2026-08-09-wake-word.md`).
+
+The three sessions are pinned to one thread each. onnxruntime otherwise sizes
+its pool to every core and spins between runs, which took mavwaked from 68% of
+one core to 335%. With the cap it sits at 81%, so the gate costs about 13%.
+
+A keyword shorter than 1.32s can be heard too late to be used. The head scores
+1.28s of audio, and the VAD has closed the utterance by then.
+"Мэйвен, <request>" is unaffected. A bare "Мэйвен" is the case that fails.
+
+mavwaked connects at startup and holds the conn, so a nudge routed to voice
+reaches the speaker before he has said anything (V-671). It used to connect
+lazily, which made the failure silent rather than absent: after one utterance
+the session existed, `PushToMostRecent` succeeded, the dispatcher stopped
+rerouting to telegram and ntfy, and mavwaked discarded the audio.
+
+**Passwords are read from files, never taken as flag values.** `mavcaldav` uses
+`-pass-file` and `-render-pass-file`. `mavpoll` and `mavmaild` follow the same
+rule.
+
+## Web UI conventions
+
+Server-rendered pages share `cmd/mavweb/static/ui.css` (served at `/ui.css`) and
+the shell partial in `cmd/mavweb/shell.html`. A page opens with
+`{{template "shellTop" "<page-key>"}}` and closes with `{{template "shellBottom"}}`,
+and the key marks the active sidebar link.
+
+Every page is its own embedded `.html` file next to `main.go`. No page markup
+lives in Go, and the sidebar is data (`sidebarSections`, `pageIcon`) the template
+renders. No per-page `<style>` beyond true one-offs. Wrap every table in
+`<div class=scroll>` so wide data pans on a phone. Local preview and headless
+screenshot recipes are in `AGENTS.md`.

docs/ecosystem.md

@@ -30,6 +30,12 @@ Maven is the user-facing control center, but not the source of truth for identit
 
 Maven provides the human interface over the other systems.
 
+| Service | Owns | Maven's client | Configured at |
+|---|---|---|---|
+| **Nexus** | Canonical entity ids, names, aliases, relationships. Projects, services, devices, people, pets, places. | `nexusClient` in `cmd/mavend/ecosystem.go`, `POST /api/v1/resolve` | `nexus.url` (`http://nexus:9740`) |
+| **Praxis** | Operational attention and item lifecycle. What needs looking at, what changed, what is unresolved. | `praxisClient`, the HTTP tools API under `/api/v1/tools/` | `praxis.url` (`http://praxis:8989`) |
+| **Hexis** | The capability registry and the only path to executing anything. | vendored `github.com/kami/hexis/pkg/client` | `hexis.url` (`http://hexis:9741`) |
+
 It is responsible for:
 
 - interpreting Russian and English utterances

docs/evals/2026-08-09-wake-word.md

@@ -0,0 +1,112 @@
+# The "Мэйвен" wake word: what it hears and what it invents
+
+*Measured 2026-08-09 on workpc and homesrv. V-487, stage two of two.*
+
+Stage one gave mavwaked silero-vad, which answers "is this frame speech".
+Nothing answered "was this said to her", so every utterance near the
+microphone became a turn. SurfaceVoice caps acts at L0, which made that safe
+rather than expensive. L0 does not cap reading, so the room could still hear
+his facts read back.
+
+The keyword is "Мэйвен". openWakeWord's two frozen feature models do the
+hearing and a 100KB head trained here draws the boundary. It runs on CPU
+beside silero and never touches the GPU.
+
+## Why a per-window accuracy is not a number anyone can act on
+
+The gate scores every 80ms. A 1.7% false-accept rate per window sounds small
+and means a wake every few seconds. The useful question is how many times an hour
+it wakes on speech that was not the keyword. So every table below counts
+threshold crossings over whole clips and divides by the audio duration.
+
+A crossing, not a window above the threshold. A keyword held high for half a
+second is one wake, not six.
+
+## The data
+
+Positives are 600 silero TTS renders of three stressings of the keyword, six
+speakers, ten trailing phrases, augmented eight ways each. Hard negatives are
+560 renders of confusable Russian words. Real speech is Common Voice ru and Golos.
+The 74257 Common Voice clips were already on workpc from the CrisperWhisper
+work. The 200 Golos clips came from the CW2 WER eval.
+
+Splits are by source file. Augmented copies of one render on both sides of a
+split would measure memorisation.
+
+Golos was never trained on at any stage, so it answers the harder question:
+does this survive a change of speakers and rooms.
+
+## Three heads
+
+Each row is a full retrain. The false-accept column is 8.89 hours of Common
+Voice that no stage of training had seen.
+
+| trained on | recall (window) | false wakes/hour @0.99 |
+|---|---|---|
+| TTS + 13.7 min of Golos | 0.869 | not measurable |
+| + 4000 Common Voice clips | 0.836 | 21.9 |
+| + 3837 mined hard negatives | 0.784 | 4.2 |
+| + 753 more mined | 0.810 | 3.4 |
+
+The first row is why the second exists. Thirteen minutes of held-out speech
+cannot measure a rate for a gate that scores twelve times a second. A head
+trained only against TTS learns to tell TTS from not-TTS.
+
+Mining is the whole story after that. Random negatives teach the head what
+most speech sounds like. They do not teach it the few syllable sequences that
+score high, because 4000 clips barely contain them. So the current head was
+run over 20000 fresh clips, keeping every window it scored above 0.05. That
+found 3837 windows in 855512. Repeating those ten times in the next training
+run cut the rate five-fold.
+
+The second round found 753 in 852240, a fifth of the yield, and bought a
+further 20%. It also recovered recall, which the first round had cost. Whether
+a third round is worth 25 minutes of workpc is untested.
+
+## Where the threshold came from
+
+Both columns are held out. Positives are the 126 renders in the test split.
+Speech is 65.1 minutes of Common Voice, disjoint from every training and
+mining pool. Both were run through the built `mavwaked` binary reading PCM from a
+file, not through the python that trained the head.
+
+| threshold | renders shipped | false wakes/hour |
+|---|---|---|
+| 0.99 | 116 / 126 | 2.8 |
+| 0.999 | 115 / 126 | 0.9 |
+
+One render against a third of the false wakes. `defaultWakeThreshold` is
+0.999.
+
+Golos disagrees. It gave 2 wakes in 14 minutes at every threshold, which is
+8.7 per hour. Two events is not a rate. What it does say is that a handful of real utterances score above 0.999
+and no threshold will move them.
+
+## What it costs him
+
+Ten of the 126 held-out renders were heard and still dropped, and every one
+was an utterance shorter than 1.32s. The head scores 16 embeddings, or 1.28s of
+audio. The score therefore peaks up to a second after a short keyword ends.
+By then the VAD has closed the utterance and dispatch has already asked.
+
+Real commands are "Мэйвен, <request>" and run past two seconds, which gives
+the head the whole request to peak during. A bare "Мэйвен" with nothing after
+it is the case that fails. One fix would hold an ignored utterance for a grace
+period and ship it if the keyword lands late. It is not built.
+
+## What it costs the workstation
+
+Under systemd on workpc, mavwaked sat at 335% of a core with the gate on and
+68% with only silero. onnxruntime sizes its thread pool to every core and spins
+between runs, and this gate runs three graphs twelve times a second. Pinning
+all three sessions to one thread brought it to 81%, so the keyword costs about
+13% of one core. The three graphs each finish in well under 80ms that way.
+
+## What was not measured
+
+No room recordings. Every negative above is a clean corpus clip. This gate
+will live among a television, a fan and the far side of a kitchen. None of
+those are in these numbers.
+
+No measurement of him. Training on his voice means copying his transcripts off
+homesrv, which is his call and has not been asked.

docs/language.md

@@ -0,0 +1,74 @@
+# Language: what the model emits, and how Russian is matched
+
+*Last verified: 2026-08-09 @ a9b480a*
+
+Two contracts live here. What a model call is allowed to return, and which
+mechanism is allowed to recognise a Russian word.
+
+## The LLM output contract
+
+All phrasing paths emit `{"response":"...","mood":"..."}`. They fall back to
+plain text when the model skips the JSON.
+
+**One parser, `parseResponseMood` in `internal/phraser/parse.go`.** Every path
+reaches it: the six `LLMPhraser` methods, `PhraseWorld`, and
+`Replier.PhraseReply`. `cmd/mavend/replier_llm.go` wraps the last of those,
+holds the stub fallback, and parses nothing itself. Mood is a fixed enum.
+
+The router prompt is a separate contract:
+
+```text
+[{"intent":<enum>, key?, value?, text?, verb?}, ...]
+```
+
+over 7 intents: `fact, reminder, note, query, act, chat, system`.
+`llm/check_prompt_parity.py` in the training workspace enforces that the Go
+prompt and the relabelling prompt stay identical. They diverged once, and the
+relabelled set then taught a head the Go router never asks for.
+
+## Russian patterns: three mechanisms, no fourth
+
+Hand-written Russian stem patterns were swept out on 2026-08-04 by the owner's
+call. A regex whose output is a fact or a route is the defect. A regex over
+structured input, such as HTML, MIME, JSON, a URL or an argv list, is not.
+
+Before writing a Russian word list, pick one of these.
+
+### `internal/lexicon`, for closed classes
+
+`lexicon_ru_v1.json` holds interrogatives, capture verbs, reminder verbs,
+cardinals, day offsets, parts of day, weekdays, months and spoken hours.
+Editing a word is a data change and there is exactly one copy. Months used to
+live in three files and drifted between them.
+
+Cardinals carry the oblique forms, because a spoken time declines. `в семь` and
+`к семи` are one hour.
+
+### `internal/morph`, for grammar
+
+From the vendored golem Russian dictionary. `IsVerbForm` and `SameWord`.
+
+Lemma matching is BROADER than stem-plus-one-ending. A verb slot that means the
+imperative must be matched exactly. `говори` and `говорил` share a
+lemma and only one of them is a command
+(`cmd/mavend/quiet_toggle.go`).
+
+### `cmd/mavend/topics.go` and the embedder, for open sets
+
+Use these when the question is what a turn is ABOUT. Frozen seeds per subject
+plus a real `other` class, scored against the turn's own query vector.
+
+Same shape as the personal boundary in `personalboundary.go`, with one
+difference. A topic must clear the runner-up by `topicMargin`, because a false
+claim here spends a network scan rather than one honest "не знаю". The old
+keyword tests stay as the offline floor.
+
+### The ecosystem trio
+
+Use it when the answer is not in the utterance at all. Identity is Nexus's,
+never a local pattern.
+
+## Seeds are scoring data
+
+Editing one moves a recogniser. Re-measure against the `TestONNX*` tests rather
+than eyeballing the change.

docs/routing.md

@@ -353,6 +353,11 @@ stage 0 grammar may drop it (owner's call, V-666, 2026-08-09).
 one of those could stop implying the others. `definitionQueryPattern` claims "кто
 такой X", so the 2026-08-07 case is still anchored and still answered.
 
+`queryWalk` reads `SourceAnchored` for the query source marked `boundary: true`
+and no other. Every other guesser still comes off the turn, whoever named the
+destination. `TestOnlyAGrammarMayDropTheBoundary` and
+`TestNamingRecallKeepsTheBoundary` pin both directions.
+
 ### The destination fixture
 
 `want_source` on `eval.Case` is a pointer, because the destination has three

docs/workflow.md

@@ -0,0 +1,80 @@
+# Session workflow: the five stores and the guards
+
+*Last verified: 2026-08-09 @ a9b480a*
+
+How a session starts, where each kind of writing belongs, and what the hooks
+refuse. `CLAUDE.md` carries the commands. This file carries the reasoning.
+
+## Five stores
+
+Each owns something the others must not hold.
+
+| Store | Holds | Lifetime |
+|---|---|---|
+| Vikunja task | goal, constraints, assumption ledger, status | durable |
+| `CLAUDE.md`, `AGENTS.md` | what an agent must know before touching code | durable |
+| `docs/` | design, measurements, decisions | durable |
+| `TASK.md` | the brief for this branch, written by `task start`, immutable | one branch |
+| `HANDOFF.md` | only what the next agent needs to resume | one session |
+
+`TASK.md` and `.task/` are excluded through `.git/info/exclude`. `HANDOFF.md` is
+gitignored and injected at session start. If a line in the handoff would still
+matter next week, it is in the wrong file.
+
+## Doc tiers
+
+Tiered by path, so staleness is visible from the filename.
+
+- Files directly under `docs/` are living. They carry a
+  `Last verified: <date> @ <sha>` line and are corrected in place.
+- Files under `docs/evals/` are dated measurements and are never edited after
+  the day. A newer number is a new file, not an edit.
+- Files under `docs/archive/` are dead and read by nobody by default.
+
+## Vikunja
+
+This repo is project **Maven** (ID 2). MCP at `http://localhost:9100/mcp`, or
+`http://192.168.1.104:9100/mcp` from workpc. Feature, bug and deploy tasks go
+there.
+
+A task holds the goal, the constraints and the assumption ledger. A session
+without a task id cannot be resumed by anyone, so a session with none asks for
+one first.
+
+**Close a finished task with `done: true` and nothing else** (owner's call,
+2026-08-07). Do not write a completion summary into the description on the way
+out. It is lost anyway, and the durable record is the commit messages and the
+merged PR. `update_task` carrying a `description` resets `done` to false, which
+is why a write-up ever took two calls.
+
+## The branch tool
+
+`~/.local/bin/task` owns the branch, the commit identity and the PR. One task,
+one session, one PR.
+
+```sh
+task start <vikunja-id>   # branch off origin/master, write TASK.md, fetch review comments
+task pr                   # push, open or refresh the PR, label Vikunja, notify
+task comments             # re-pull this branch's review comments into .task/
+```
+
+`/pickup` opens a session and `/wrap` closes it. Wrap at roughly half context
+rather than letting the session compact.
+
+## Guards
+
+Two hooks in `.githooks/`, tracked, wired with `core.hooksPath`. A fresh clone
+needs `git config core.hooksPath .githooks`.
+
+- `pre-commit` refuses master, and refuses more than 300 changed lines in
+  non-markdown files. Markdown is exempt and may land as one batch.
+- `commit-msg` requires the subject to end with `(V-<id>)`. `V-` and not `#`,
+  because Gitea autolinks `#123` to a Gitea issue, which is the wrong tracker.
+
+Two more guards live outside the repo, in `~/.claude/hooks/`. `diff-budget.sh`
+blocks further edits past 600 changed lines on a `task/` branch.
+`prose_lint_hook.py` checks prose on every write. Both measure against
+`origin/master`, so a local master that is ahead of the remote makes the diff
+budget read high.
+
+`--no-verify` exists. Using it means saying why in the commit body.

docs/world.md

@@ -0,0 +1,71 @@
+# The world chain
+
+*Last verified: 2026-08-09 @ a9b480a*
+
+What happens when the answer is not his. `CLAUDE.md` carries the boundary rule.
+This file carries the mechanism and the measurements behind it.
+
+## What replaced "never phones home"
+
+That promise was deprecated on 2026-07-31 by the owner's call. A 1.7B does not
+know enough to answer world questions, so she reads external sources. Four rules
+replaced 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.
+- **The owner's data first, then the world.** Every source reading his facts,
+  notes, calendar, tasks or house runs before anything outside. The personal
+  boundary sits between them. Reading beats recalling for a small model.
+- **The owner's notes and facts are never search input.** Only the utterance
+  goes out. Never the persona block, the history, or matched notes.
+- **External search is allowed and off unless configured**, like weather and
+  telegram. The code default is off. `deploy/mavend.json` ships a `search`
+  block, so it is on for this box and deleting the block turns it off again.
+
+**Live search leads and the ZIMs are the fallback** (owner's call, 2026-08-02).
+A self-hosted SearXNG answers first. The Kiwix ZIMs on homesrv answer when the
+search is empty, unreachable, or the line is down.
+
+## The gate is emptiness and nothing else
+
+`Response.Empty()` is the whole gate. There is no quality threshold in front of
+it. Four signals were tried and none separates a real question from an invented
+one.
+
+Token overlap was the closest and it still fails. "столица Франции" would lose
+its answer, because the answer is Париж and that word is not in the question
+(`docs/evals/2026-08-05-search-quality-signals.md`).
+
+**The embedder is not a fifth signal.** Query-to-passage cosine measures topic
+and not whether the passage answers. The two sets overlap
+(`docs/evals/2026-08-09-kiwix-topic-retrieval.md`).
+
+## Timeouts
+
+The connect phase alone is capped at `dialTimeout`, 1.5s, because a blackholed
+host once cost the owner 8 seconds. A slow instance that did connect keeps the
+full 8 (`docs/evals/2026-08-05-kiwix-offline-fallback.md`).
+
+## Kiwix
+
+**A Russian question reads `wikipedia_ru_all_maxi_2026-02` verbatim** through
+`kiwix.book_ru`. The RU→EN rewriter is the workaround for an English book and is
+skipped there. Kiwix catalog names come from the filename, not the `<name>`
+field.
+
+**Kiwix ranks by keyword overlap.** Never send it a whole sentence. `kiwix.Topic`
+drops the narrative request, the interrogative and a verb behind one.
+
+`kiwix.TitlePath` tries the exact article first, since a ZIM is addressable by
+title and a wrong title is a 404. `TitleCandidates` tries the spoken form and
+then the capitalized one. Both apply on the verbatim path alone. The rewriter
+already reduces a question, and reducing twice takes the topic off its input
+(V-668).
+
+## Which source answered
+
+**The claiming query source is readable on `/chat`** as a badge beside the
+reply. It is carried on `ipc.ChatReply.Source` and noted by `noteQuerySource` in
+`cmd/mavend/querysource.go`. It rides the context, so `handleText` keeps the one
+string signature the mic, telegram and the web share.

internal/voice/client.go

@@ -9,15 +9,18 @@
 //
 // The wire is symmetric: a Request from the client is answered by a
 // Response with a matching ID, OR a server-initiated Push frame (no ID)
-// may arrive interleaved. SendRequest loops reading frames, drops Push
-// frames to the harness if a receiver is running (or silently if not),
-// and returns the first Response with the matching ID.
+// may arrive interleaved. One reader goroutine per connection owns the
+// socket. It hands each Response to whichever SendRequest is waiting on
+// that ID and each Push to the handler, so a client may send and listen
+// at the same time on one conn. mavwaked needs exactly that: it speaks
+// utterances and it must hear nudges, and the server routes a nudge to
+// the session that spoke most recently, so a second listening conn would
+// never be picked (V-671).
 package voice
 
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net"
@@ -41,13 +44,22 @@ type PushHandler interface {
 // Client — one connection to the voice.Server.
 type Client struct {
 	addr   string
-	mu     sync.Mutex
-	c      net.Conn
 	nextID atomic.Uint64
 
-	// pushCh fan-out: a reader goroutine (started by RunPushReceiver)
-	// writes Push frames here; SendRequest also drains it when no reader
-	// is running (drops the frame in that case).
+	mu sync.Mutex
+	c  net.Conn
+	// pending holds one channel per in-flight request, keyed by frame id.
+	// The reader goroutine delivers the Response here and deletes the entry.
+	pending map[uint64]chan *Response
+	// dead is closed by the reader goroutine when this conn ends, so a
+	// waiting SendRequest fails at once instead of at its own deadline.
+	dead chan struct{}
+
+	// wmu serialises writes. Frames must not interleave on the wire.
+	wmu sync.Mutex
+
+	// pushH is set by RunPushReceiver and survives a reconnect, because the
+	// client that wants pushes wants them on whatever conn it ends up with.
 	pushMu sync.Mutex
 	pushH  PushHandler
 }
@@ -55,6 +67,15 @@ type Client struct {
 // Dial returns a Client that will connect to addr on first use.
 func Dial(addr string) *Client { return &Client{addr: addr} }
 
+// Connect opens the conn now rather than on the first request. mavwaked calls
+// it at startup: the server registers a session on accept, and a client that
+// has never connected cannot be sent a nudge.
+func (c *Client) Connect(ctx context.Context) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.ensureConnLocked(ctx)
+}
+
 // Close releases the conn. Idempotent.
 func (c *Client) Close() error {
 	c.mu.Lock()
@@ -75,12 +96,14 @@ func (c *Client) PushToTalk(ctx context.Context, a audio.Audio, lang string) (Pu
 	return out, err
 }
 
+// requestTimeout bounds a round-trip with no deadline on its context. It is
+// generous because the far end runs speech-to-text, a router and a voice.
+const requestTimeout = 120 * time.Second
+
 // SendRequest sends one Request frame and waits for the matching Response.
-// Push frames received while waiting are dropped on the floor UNLESS a
-// PushHandler has been wired via RunPushReceiver, in which case the handler
-// is invoked inline (still synchronous with the SendRequest caller's
-// read). For sanity, the reference client runs either one-shot (no
-// receiver) or interactive (RunPushReceiver, no concurrent SendRequest).
+// Push frames arriving meanwhile go to the handler on the reader goroutine,
+// so listening and sending on one Client is supported rather than merely
+// tolerated.
 func (c *Client) SendRequest(ctx context.Context, m Method, params any, out any) error {
 	body, err := marshalParams(params)
 	if err != nil {
@@ -94,58 +117,69 @@ func (c *Client) SendRequest(ctx context.Context, m Method, params any, out any)
 		c.mu.Unlock()
 		return err
 	}
-	conn := c.c
+	conn, dead := c.c, c.dead
+	ch := make(chan *Response, 1)
+	c.pending[id] = ch
 	c.mu.Unlock()
 
-	if dl, ok := ctx.Deadline(); ok {
-		_ = conn.SetDeadline(dl)
-	} else {
-		_ = conn.SetDeadline(time.Now().Add(120 * time.Second))
-	}
-	defer conn.SetDeadline(time.Time{})
-
-	if err := writeFrame(conn, &req); err != nil {
-		c.teardown()
+	c.wmu.Lock()
+	err = writeFrame(conn, &req)
+	c.wmu.Unlock()
+	if err != nil {
+		c.forget(id)
+		c.teardownConn(conn)
 		return err
 	}
-	for {
-		resp, push, err := readOneFrame(conn)
-		if err != nil {
-			c.teardown()
-			return err
-		}
-		if push != nil {
-			c.deliverPush(*push)
-			continue
-		}
-		if resp.ID != id {
-			continue // not ours; ignore (singleplex ⇒ shouldn't happen)
-		}
-		if resp.Error != nil {
-			return hydrate(resp.Error)
-		}
-		if out != nil {
-			if err := json.Unmarshal(resp.Result, out); err != nil {
-				return fmt.Errorf("voice: unmarshal result: %w", err)
-			}
-		}
-		return nil
+
+	timer := time.NewTimer(requestTimeout)
+	defer timer.Stop()
+
+	var resp *Response
+	select {
+	case resp = <-ch:
+	case <-dead:
+		c.forget(id)
+		return fmt.Errorf("voice: connection closed before reply")
+	case <-ctx.Done():
+		c.forget(id)
+		return ctx.Err()
+	case <-timer.C:
+		c.forget(id)
+		c.teardownConn(conn)
+		return fmt.Errorf("voice: no reply within %s", requestTimeout)
 	}
+
+	if resp.Error != nil {
+		return hydrate(resp.Error)
+	}
+	if out != nil {
+		if err := json.Unmarshal(resp.Result, out); err != nil {
+			return fmt.Errorf("voice: unmarshal result: %w", err)
+		}
+	}
+	return nil
 }
 
-// RunPushReceiver spawns a reader goroutine that delivers Push frames to h
-// until the conn closes or Close is called. Today's reference client uses
-// this in -listen mode (proactive voice playback). SendRequest and
-// RunPushReceiver SHOULD NOT be used concurrently on the same Client — the
-// wire is singleplex at the reference client's scale; production picks one
-// mode per conn. Returns when the goroutine ends (ctx cancel or conn close).
+// forget drops an abandoned request so a late Response is discarded rather
+// than delivered to nobody.
+func (c *Client) forget(id uint64) {
+	c.mu.Lock()
+	delete(c.pending, id)
+	c.mu.Unlock()
+}
+
+// RunPushReceiver wires h and blocks until the conn ends or ctx is
+// cancelled. Frames are read by the per-conn reader goroutine, so a client
+// may call SendRequest on the same Client while this is running. Returns nil
+// when the conn ended, so a caller that wants to stay reachable reconnects
+// and calls it again.
 func (c *Client) RunPushReceiver(ctx context.Context, h PushHandler) error {
 	c.mu.Lock()
 	if err := c.ensureConnLocked(ctx); err != nil {
 		c.mu.Unlock()
 		return err
 	}
-	conn := c.c
+	dead := c.dead
 	c.mu.Unlock()
 
 	c.pushMu.Lock()
@@ -158,21 +192,34 @@ func (c *Client) RunPushReceiver(ctx context.Context, h PushHandler) error {
 		c.pushMu.Unlock()
 	}()
 
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-dead:
+		return nil
+	}
+}
+
+// readLoop owns conn for its whole life. It ends on any read error, which is
+// how a closed conn, a killed server and a cancelled dial all arrive here.
+func (c *Client) readLoop(conn net.Conn, dead chan struct{}) {
+	defer close(dead)
 	for {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		default:
-		}
-		_, push, err := readOneFrame(conn)
+		resp, push, err := readOneFrame(conn)
 		if err != nil {
-			if errors.Is(err, io.EOF) || errors.Is(err, net.ErrClosed) {
-				return nil
-			}
-			return err
+			c.teardownConn(conn)
+			return
 		}
 		if push != nil {
 			c.deliverPush(*push)
+			continue
+		}
+		c.mu.Lock()
+		ch := c.pending[resp.ID]
+		delete(c.pending, resp.ID)
+		c.mu.Unlock()
+		if ch != nil {
+			ch <- resp
 		}
 	}
 }
@@ -196,13 +243,19 @@ func (c *Client) ensureConnLocked(ctx context.Context) error {
 		return fmt.Errorf("voice: dial %s: %w", c.addr, err)
 	}
 	c.c = conn
+	c.pending = make(map[uint64]chan *Response)
+	c.dead = make(chan struct{})
+	go c.readLoop(conn, c.dead)
 	return nil
 }
 
-func (c *Client) teardown() {
+// teardownConn closes conn and forgets it, but only if it is still the live
+// one. A reconnect may already have replaced it, and closing the new conn
+// because the old one died takes the client down on every hiccup.
+func (c *Client) teardownConn(conn net.Conn) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
-	if c.c != nil {
+	if c.c != nil && c.c == conn {
 		_ = c.c.Close()
 		c.c = nil
 	}

internal/voice/voice_test.go

@@ -221,3 +221,113 @@ func TestClientListenModeReceivesPush(t *testing.T) {
 type pushHandlerFunc func(Push)
 
 func (f pushHandlerFunc) OnPush(p Push) { f(p) }
+
+// The whole point of the per-conn reader (V-671): mavwaked speaks utterances
+// and must hear nudges, and the server routes a nudge to the session that
+// spoke most recently. A second listening conn would never be picked, so both
+// directions have to share one conn.
+func TestClientSendsAndListensOnOneConn(t *testing.T) {
+	l := newTestListener(t)
+	sess := NewSessions()
+	h := &stubHandler{}
+	srv := NewServer(l.Addr().String(), h, sess)
+	if err := srv.Listen(); err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+	defer func() {
+		_ = srv.Close()
+		waitPort()
+	}()
+	go func() { _ = srv.Serve() }()
+
+	c := Dial(l.Addr().String())
+	defer c.Close()
+
+	got := make(chan audio.Audio, 4)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	go func() {
+		_ = c.RunPushReceiver(ctx, pushHandlerFunc(func(p Push) {
+			var ap AudioNudgePush
+			if err := json.Unmarshal(p.Params, &ap); err == nil {
+				got <- ap.Audio
+			}
+		}))
+	}()
+
+	for i := 0; i < 100 && sess.Active() < 1; i++ {
+		time.Sleep(10 * time.Millisecond)
+	}
+	if sess.Active() != 1 {
+		t.Fatalf("active sessions = %d, want exactly 1", sess.Active())
+	}
+
+	// A round-trip while the receiver is running. Before the reader owned the
+	// conn, this and the receiver raced for every frame.
+	resp, err := c.PushToTalk(context.Background(), audio.Audio{Format: audio.PCM16kMono, Bytes: []byte("hello")}, "ru")
+	if err != nil {
+		t.Fatalf("PushToTalk with a receiver running: %v", err)
+	}
+	if resp.ReplyText != "got it" {
+		t.Fatalf("ReplyText = %q, want %q", resp.ReplyText, "got it")
+	}
+
+	// And the nudge still arrives, on the session that just spoke.
+	err = sess.PushToMostRecent(context.Background(), AudioNudgePush{
+		RuleName: "after-speaking",
+		Audio:    audio.Audio{Format: audio.PCM16kMono, Bytes: []byte("proactive")},
+	})
+	if err != nil {
+		t.Fatalf("PushToMostRecent: %v", err)
+	}
+	select {
+	case a := <-got:
+		if string(a.Bytes) != "proactive" {
+			t.Fatalf("received %q, want the nudge audio", string(a.Bytes))
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatal("nudge never reached the handler after the client had spoken")
+	}
+}
+
+// A request abandoned by its context must not leave its slot behind, or a
+// long-running client leaks one channel per timeout.
+func TestClientForgetsAbandonedRequests(t *testing.T) {
+	l := newTestListener(t)
+	sess := NewSessions()
+	srv := NewServer(l.Addr().String(), &blockingHandler{}, sess)
+	if err := srv.Listen(); err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+	defer func() {
+		_ = srv.Close()
+		waitPort()
+	}()
+	go func() { _ = srv.Serve() }()
+
+	c := Dial(l.Addr().String())
+	defer c.Close()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+	_, err := c.PushToTalk(ctx, audio.Audio{Format: audio.PCM16kMono, Bytes: []byte("x")}, "ru")
+	if err == nil {
+		t.Fatal("expected the round-trip to fail on its context")
+	}
+
+	c.mu.Lock()
+	n := len(c.pending)
+	c.mu.Unlock()
+	if n != 0 {
+		t.Fatalf("pending = %d after an abandoned request, want 0", n)
+	}
+}
+
+// blockingHandler never answers, so the client's context is what ends the
+// round-trip.
+type blockingHandler struct{}
+
+func (blockingHandler) HandlePushToTalk(ctx context.Context, _ PushToTalkReq, _ uint64) (PushToTalkResp, error) {
+	<-ctx.Done()
+	return PushToTalkResp{}, ctx.Err()
+}