Write down every conversational eval score from tonight

Records all four configurations on the 27-case talk fixture, three runs
each: no grammar, plus grammar, plus Russian prompts, plus the truncation
fix. Composite, per-path and per-check, with the reproduce command.

The short version is that the plumbing got fixed and the score barely
moved. Grammar was the real win. Russian prompts helped a little and cut
latency by 5x. The truncation fix was necessary and bought nothing.

Also writes down three things that are easy to lose:

- The truncation cause was the grammar's 400-character bound, not the
  token cap. Measured at three caps, same 400 characters every time.
- Then I set the bound to 1000 against a 768-token cap and made it worse.
  The two limits have to agree.
- One run is contaminated and marked void: I ran an agent against the same
  llama-server, and the report still claimed zero errors while a third of
  the fixture silently answered "не знаю.". That is #397 and it is worse
  than filed — a busy server is indistinguishable from bad phrasing.

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

TALK-EVAL-31-07-2026.md

@@ -0,0 +1,150 @@
+# Conversational phrasing eval — 31-07-2026
+
+Every score measured tonight, on the three paths the nudge eval never touched:
+chat, query-with-notes, and general knowledge.
+
+**Short version: the plumbing got fixed and the score barely moved.** Grammar and
+Russian prompts together took the composite from ~9 to ~14 of 27. Everything
+still failing is the model not knowing things or not holding a constraint, and
+prompting is out of levers. Settles the measurement half of Vikunja #395 / #398 /
+#400.
+
+## How to reproduce
+
+```sh
+# llama-server: -c 4096 -ngl 99 -t 6, model /mnt/hdd1/llms/qwen3.5/Qwen3.5-0.8B.Q4_K_M.gguf
+MAVEN_LLM_URL=http://127.0.0.1:18099 no_proxy=127.0.0.1,localhost \
+  deps/go/go/bin/go test -count=1 -timeout 40m \
+  -run TestLLMTalkBaseline ./internal/phraser/eval/ -v
+```
+
+Three runs per configuration, always. The fixture is 27 cases, so one reply
+changing moves the composite by 3.7 points — a single run cannot tell a real
+change from sampling noise. This was learned the expensive way: an earlier claim
+that "one nudge case fails every run" turned out to be three different cases
+across three runs.
+
+**Run the box otherwise idle.** See the contamination note at the bottom.
+
+## Composite, per configuration
+
+| config | overall /27 | chat /9 | query /9 | knowledge /9 | canned fallbacks |
+|---|---|---|---|---|---|
+| baseline, no grammar | 7, 12, 7 | 1, 1, 0 | 2, 4, 2 | 4, 7, 5 | 0, 0, 0 |
+| + GBNF grammar (#398) | 14, 15, 8 | 1, 3, 0 | 5, 6, 3 | 8, 6, 5 | 0, 0, 0 |
+| + Russian prompts (#400) | 11, 17, 15 | 1, 5, 3 | 5, 6, 8 | 5, 6, 4 | 0, 0, 0 |
+| + truncation fix, 1000ch/768tok | 12, 13, 10 | 2, 2, 1 | 7, 7, 5 | 3, 4, 4 | 3, 3, 6 |
+| + rebalanced, 600ch/1024tok | **void — contaminated** | | | | |
+
+"Canned fallbacks" counts replies that came back as the hardcoded `"не знаю."`
+or `"поговорили."`. It is not a check, it is a health signal: those strings mean
+the phraser gave up, and the eval scores them as ordinary bad replies.
+
+## Per-check
+
+| check | no grammar | + grammar | + RU prompts | + truncation fix |
+|---|---|---|---|---|
+| nonempty | 27, 27, 27 | 27, 27, 27 | 27, 27, 27 | 27, 27, 27 |
+| ellipsis | 20, 19, 23 | 27, 27, 27 | 27, 27, 27 | 27, 27, 27 |
+| lang | 13, 16, 15 | 23, 26, 26 | 25, 26, 25 | 26, 27, 27 |
+| feminine | — | — | 25, 24, 26 | 25, 25, 27 |
+| address | — | — | 21, 22, 22 | 22, 21, 22 |
+| ontopic | — | — | 17, 24, 18 | 17, 19, 14 |
+
+`nonempty` reading 27/27 everywhere is not good news — it was a broken check.
+It tested for a non-blank string, so replies of literally `{` and `"15-16"`
+passed it. Fixed on `overnight/fix-truncation`; it needs a letter now.
+
+## What each change actually bought
+
+**GBNF grammar (#398) — the biggest single win.** Qwen3.5-0.8B writes
+`Thinking Process:` as plain text with no tags, `stripThink` only handles
+`</think>`, so the JSON never closed and the plain-text fallback shipped the
+literal reasoning. `ellipsis` went 20→27 and `lang` 13→26. The router had been
+using a grammar for ages; the phraser asking nicely in the prompt was the
+oversight.
+
+**Russian prompts (#400) — modest, plus a large latency win.** Chat 1.3→3.0
+average, query 4.7→6.3, knowledge 6.3→5.0. All inside the run-to-run spread, so
+"probably better on the paths it targeted, not provable in three runs". p50
+latency dropped from ~11.5s to ~2.3s and that part is consistent across all
+three runs — shorter prompts, and she stopped emitting English reasoning first.
+
+**Truncation fix — necessary, and did not help the score.** Two real bugs
+(replies of `{`, and a `nonempty` check that passed them), both fixed, and the
+composite went nowhere. A complete rambling wrong answer fails the same checks a
+truncated one did. Worth doing anyway: the daemon was shipping `{` to a
+text-to-speech voice.
+
+## The truncation bug, since the cause was counter-intuitive
+
+The grammar's `string ::= ... {0,400}` rule was the cause, not the token cap.
+Measured against Qwen3.5-0.8B at three caps — 256, 768 and 2048 — the reply came
+back **exactly 400 characters every time, cut mid-word** (`"Нужно записать и,"`).
+
+Then I raised the bound to 1000 while the cap was 768 tokens and made it worse:
+Russian runs ~1.5 characters per token here, so generation died on the *token*
+cap instead, mid-object, and the new guard correctly refused it and shipped
+`"не знаю."` — 3, 3 and 6 fallbacks per run, from zero. **The two limits have to
+agree.** 600 characters needs ~400 tokens; the cap is 1024.
+
+## Where the remaining failures live
+
+`address` is stuck at 21-22 of 27 and `ontopic` at 14-19. Both resist prompting.
+
+**The prompt now explicitly forbids exactly what she does.** It says never "вы",
+use the singular — and she writes `вашей`, `подождите`, `делаете`, `хотите`,
+`напишите`. Telling a 0.8B "never do X" does not work. Same for
+`feminine`: `я готов`, `я понял`, `я нашел`, `я заметил`, `я сказал`.
+
+**Some of `ontopic` is the fixture, not the model.** `chat-how-are-you` got
+`"Привет! Я здесь, чтобы поговорить. Как дела сегодня?"` — a fine reply that
+fails because `want_any` is `[норм, хорош, порядк, тут, работ]`. It fails in
+every run, so it inflates the count. The `ontopic` column currently measures the
+fixture as much as the model. Not fixed yet, deliberately: changing it would
+break comparability with the runs above.
+
+**Two replies worth reading, because they are not fixable by prompting:**
+
+- Thunder and lightning: *"Скорость молнии — 8-10 тысяч километров в секунду, но
+  звук — 300 метров в секунду, что делает молнию громче."* Confidently wrong,
+  and it concludes lightning is *louder* rather than sound being *slower*.
+- "расскажи обо мне": *"Ты — прекрасное существо, с душой и вниманием… Спасибо за
+  твою улыбку… О тебе — заповедь любви."* Sycophantic filler, zero information,
+  and precisely the "not a relationship" non-goal.
+- Boiling an egg: `"15-16"` one run, `"1"` another. No unit, wrong number.
+
+The first argues for reading instead of recalling (#403 — Kiwix retrieval scores
+8/8 on the same questions given English keywords). The second and third argue
+for templates on the paths where correctness matters (#392).
+
+## Contamination note — how the last row got voided
+
+I started the query-rewrite agent against the same llama-server the sweep was
+using, and assumed contention would only affect latency. It did not. The
+knowledge path collapsed to 0 of 9 with eight canned `"не знаю."` replies, p95
+tripled to 23.7s, and **the report still said "0 errors"**.
+
+That is Vikunja #397, and it is worse than filed: a merely *busy* server
+produces a clean-looking report with a third of the fixture silently answering
+`"не знаю."`. `PhraseChat` and `PhraseQuery` swallow every failure and return a
+hardcoded string, so infrastructure trouble is indistinguishable from bad
+phrasing in the score. The talk test guards the *start* and *end* of a run with
+a model check, which catches a dead server but not a loaded one.
+
+**Until #397 is fixed, treat any run made on a busy box as void.**
+
+## Next
+
+- Re-run 600ch/1024tok clean, to fill the void row.
+- Score `Qwen3.5-2B-UD-Q4_K_XL` (already at `/mnt/hdd1/llms/qwen3.5/`, never
+  measured) on this fixture and the router fixture. Not the 4B — too big for
+  this box, owner's call.
+- Newer sub-500M candidates (LFM2.5 200M/300M) are worth a run for routing.
+  Note `MODEL-BAKEOFF-31-07-2026.md` found LFM2.5-**1.2B** worse than
+  Qwen3.5-0.8B at Russian routing and 2.4× slower — but those are a different,
+  older generation, so that result does not predict the small ones.
+- Fix `chat-how-are-you`'s `want_any`, and re-baseline once, so `ontopic`
+  measures the model.
+- #397 first if anything, since it decides whether any of the above is
+  trustworthy.

internal/kiwix/client.go

@@ -1,116 +0,0 @@
-// Package kiwix reads a local Kiwix server (offline Wikipedia and friends).
-//
-// Why: the resident model is a 0.8B and invents facts. Letting her read a local
-// article snippet beats letting her recall. Nothing here talks to the internet;
-// the Kiwix server is on the same box.
-//
-// This is search only. Full articles are ~100KB of HTML, far too big for a 4096
-// token context, so the unit of context is the search snippet (~500 chars).
-package kiwix
-
-import (
-	"context"
-	"encoding/xml"
-	"fmt"
-	"html"
-	"io"
-	"net/http"
-	"net/url"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// Result is one search hit.
-type Result struct {
-	Title     string // article title, e.g. "Rayleigh scattering"
-	Path      string // e.g. /content/wikipedia_en_all_maxi_2026-02/Rayleigh_scattering
-	Snippet   string // plain text, tags stripped, entities decoded
-	WordCount int    // 0 if the server did not say
-}
-
-// Client is a Kiwix HTTP client. Boring on purpose: no retries, no cache.
-type Client struct {
-	base string
-	http *http.Client
-}
-
-// New makes a client for a Kiwix base URL like http://127.0.0.1:8034.
-func New(baseURL string) *Client {
-	return &Client{
-		base: strings.TrimRight(baseURL, "/"),
-		http: &http.Client{Timeout: 10 * time.Second},
-	}
-}
-
-// Search runs a keyword search in one ZIM (book) and returns up to limit hits.
-//
-// Ranking is keyword based, not semantic: "Rayleigh scattering" finds the right
-// article, "why is the sky blue" finds a TV episode. Pass keywords, not questions.
-func (c *Client) Search(ctx context.Context, pattern, book string, limit int) ([]Result, error) {
-	if limit <= 0 {
-		limit = 5
-	}
-	q := url.Values{}
-	q.Set("pattern", pattern)
-	q.Set("books.name", book)
-	q.Set("format", "xml")
-	q.Set("pageLength", strconv.Itoa(limit))
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.base+"/search?"+q.Encode(), nil)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := c.http.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("kiwix search: http %d", resp.StatusCode)
-	}
-	return ParseSearchRSS(resp.Body)
-}
-
-// rss mirrors just the bits of the RSS 2.0 reply we use.
-type rss struct {
-	Items []struct {
-		Title string `xml:"title"`
-		Link  string `xml:"link"`
-		// innerxml keeps the <b> match markers so we can strip them ourselves.
-		Description struct {
-			Inner string `xml:",innerxml"`
-		} `xml:"description"`
-		WordCount   string `xml:"wordCount"`
-	} `xml:"channel>item"`
-}
-
-var tagRE = regexp.MustCompile(`<[^>]*>`)
-
-// ParseSearchRSS turns a Kiwix search reply into results. Exported so the parser
-// is testable from a captured response, with no server running.
-func ParseSearchRSS(r io.Reader) ([]Result, error) {
-	var doc rss
-	if err := xml.NewDecoder(r).Decode(&doc); err != nil {
-		return nil, fmt.Errorf("kiwix search: bad xml: %w", err)
-	}
-	out := make([]Result, 0, len(doc.Items))
-	for _, it := range doc.Items {
-		n, _ := strconv.Atoi(strings.ReplaceAll(it.WordCount, ",", ""))
-		out = append(out, Result{
-			Title:     strings.TrimSpace(it.Title),
-			Path:      strings.TrimSpace(it.Link),
-			Snippet:   plainText(it.Description.Inner),
-			WordCount: n,
-		})
-	}
-	return out, nil
-}
-
-// plainText drops markup and decodes entities, leaving text a model can read.
-func plainText(s string) string {
-	s = tagRE.ReplaceAllString(s, "")
-	s = html.UnescapeString(s)
-	return strings.TrimSpace(strings.Join(strings.Fields(s), " "))
-}

internal/kiwix/kiwix_test.go

@@ -1,90 +0,0 @@
-package kiwix
-
-import (
-	"context"
-	"os"
-	"strings"
-	"testing"
-	"time"
-)
-
-// A real reply from the live server, trimmed to two items.
-const sampleRSS = `<?xml version="1.0" encoding="UTF-8"?>
-<rss version="2.0" xmlns:opensearch="http://a9.com/-/spec/opensearch/1.1/">
-  <channel>
-    <title>Search: Rayleigh scattering</title>
-    <opensearch:totalResults>800</opensearch:totalResults>
-    <item>
-      <title>Rayleigh scattering</title>
-      <link>/content/wikipedia_en_all_maxi_2026-02/Rayleigh_scattering</link>
-      <description><b>Rayleigh</b> scattering causes the blue color of the sky &amp; yellow colors near the Sun.[1]</description>
-      <book><title>Wikipedia</title></book>
-      <wordCount>2,818</wordCount>
-    </item>
-    <item>
-      <title>Hyper–Rayleigh scattering</title>
-      <link>/content/wikipedia_en_all_maxi_2026-02/Hyper%E2%80%93Rayleigh_scattering</link>
-      <description>...<b>Rayleigh</b> scattering" is a nonlinear optical counterpart.</description>
-      <book><title>Wikipedia</title></book>
-      <wordCount>914</wordCount>
-    </item>
-  </channel>
-</rss>`
-
-func TestParseSearchRSS(t *testing.T) {
-	got, err := ParseSearchRSS(strings.NewReader(sampleRSS))
-	if err != nil {
-		t.Fatalf("parse: %v", err)
-	}
-	if len(got) != 2 {
-		t.Fatalf("want 2 results, got %d", len(got))
-	}
-	if got[0].Title != "Rayleigh scattering" {
-		t.Errorf("title = %q", got[0].Title)
-	}
-	if got[0].Path != "/content/wikipedia_en_all_maxi_2026-02/Rayleigh_scattering" {
-		t.Errorf("path = %q", got[0].Path)
-	}
-	if got[0].WordCount != 2818 {
-		t.Errorf("wordCount = %d", got[0].WordCount)
-	}
-	want := "Rayleigh scattering causes the blue color of the sky & yellow colors near the Sun.[1]"
-	if got[0].Snippet != want {
-		t.Errorf("snippet = %q, want %q", got[0].Snippet, want)
-	}
-	if strings.Contains(got[1].Snippet, "<b>") {
-		t.Errorf("second snippet still has tags: %q", got[1].Snippet)
-	}
-}
-
-func TestParseSearchRSSBadXML(t *testing.T) {
-	if _, err := ParseSearchRSS(strings.NewReader("not xml at all")); err == nil {
-		t.Fatal("want an error on junk input")
-	}
-}
-
-// Opt-in: needs a live Kiwix server. CI has none.
-// MAVEN_KIWIX_URL=http://127.0.0.1:8034 no_proxy=127.0.0.1,localhost go test -run Retrieval -v ./internal/kiwix/
-func TestRetrievalEval(t *testing.T) {
-	base := os.Getenv("MAVEN_KIWIX_URL")
-	if base == "" {
-		t.Skip("set MAVEN_KIWIX_URL to run the retrieval eval")
-	}
-	noProxyLoopback(t)
-
-	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
-	defer cancel()
-
-	rep, err := RunRetrievalEval(ctx, New(base), 5)
-	if err != nil {
-		t.Fatalf("eval: %v", err)
-	}
-	// No pass bar on purpose: the number is the finding.
-	t.Log("\n" + rep.String() + rep.Detail())
-}
-
-// noProxyLoopback stops the box's SOCKS bridge from eating loopback requests.
-func noProxyLoopback(t *testing.T) {
-	t.Setenv("no_proxy", "127.0.0.1,localhost")
-	t.Setenv("NO_PROXY", "127.0.0.1,localhost")
-}

internal/kiwix/knowledge_v1.json

@@ -1,63 +0,0 @@
-{
-  "name": "kiwix-knowledge-v1",
-  "book": "wikipedia_en_all_maxi_2026-02",
-  "note": "The 9 knowledge cases from internal/phraser/eval/talk_v1.json. Queries are hand-written English keywords on purpose: Kiwix ranks by keyword, not meaning, so a natural question fails. Writing them by hand separates 'retrieval is broken' from 'the model writes bad queries'.",
-  "cases": [
-    {
-      "id": "know-sky-blue",
-      "question": "почему небо синее?",
-      "query": "Rayleigh scattering sky blue",
-      "want_titles": ["Rayleigh scattering", "Diffuse sky radiation"]
-    },
-    {
-      "id": "know-boil-egg",
-      "question": "сколько варить яйцо вкрутую?",
-      "query": "boiled egg cooking",
-      "want_titles": ["Boiled egg", "Egg as food"]
-    },
-    {
-      "id": "know-ssd-vs-hdd",
-      "question": "чем ssd отличается от hdd?",
-      "query": "solid-state drive",
-      "want_titles": ["Solid-state drive", "Hard disk drive"]
-    },
-    {
-      "id": "know-cat-purr",
-      "question": "почему кошки мурчат?",
-      "query": "cat purr",
-      "want_titles": ["Purr", "Cat communication"]
-    },
-    {
-      "id": "know-hiccups",
-      "question": "как быстро избавиться от икоты?",
-      "query": "hiccup",
-      "want_titles": ["Hiccup"]
-    },
-    {
-      "id": "know-polite-form",
-      "question": "не могли бы вы объяснить, что такое vpn?",
-      "query": "virtual private network",
-      "want_titles": ["Virtual private network"]
-    },
-    {
-      "id": "know-dont-know",
-      "question": "как зовут моего соседа снизу?",
-      "query": "name of my downstairs neighbour",
-      "want_titles": [],
-      "expect_miss": true,
-      "note": "Unanswerable by design. Retrieval SHOULD find nothing useful. Counted as a hit only when nothing relevant comes back."
-    },
-    {
-      "id": "know-water-per-day",
-      "question": "сколько воды в день надо пить?",
-      "query": "human daily water requirement drinking",
-      "want_titles": ["Drinking water", "Water", "Dehydration", "Hydration"]
-    },
-    {
-      "id": "know-thunder-delay",
-      "question": "почему гром слышно позже молнии?",
-      "query": "thunder speed of sound lightning",
-      "want_titles": ["Thunder", "Lightning"]
-    }
-  ]
-}

internal/kiwix/retrieval_eval.go

@@ -1,135 +0,0 @@
-package kiwix
-
-// This scores retrieval alone: no LLM. For each general-knowledge question we
-// hand-write English keywords and ask whether the article that would answer it
-// comes back in the top N hits. If this score is low, reading Wikipedia cannot
-// help the model no matter how good the prompt is.
-//
-// The unanswerable case (know-dont-know) is not scored. Whether the junk it
-// returns is "nothing useful" is a human judgement, so the report just prints
-// the titles and leaves the score to the 8 answerable cases.
-
-import (
-	"context"
-	_ "embed"
-	"encoding/json"
-	"fmt"
-	"strings"
-)
-
-//go:embed knowledge_v1.json
-var knowledgeFixtureJSON []byte
-
-// EvalCase — one question with hand-written keywords.
-type EvalCase struct {
-	ID         string   `json:"id"`
-	Question   string   `json:"question"`
-	Query      string   `json:"query"`
-	WantTitles []string `json:"want_titles"`
-	ExpectMiss bool     `json:"expect_miss"`
-}
-
-type fixture struct {
-	Name  string     `json:"name"`
-	Book  string     `json:"book"`
-	Cases []EvalCase `json:"cases"`
-}
-
-// Outcome — what one case retrieved.
-type Outcome struct {
-	Case   EvalCase
-	Titles []string // titles of the top N hits, in rank order
-	Rank   int      // 1-based rank of the first wanted title, 0 if none
-	Err    error
-}
-
-// Hit is true when a wanted title came back.
-func (o Outcome) Hit() bool { return o.Rank > 0 }
-
-// Report — the score plus per-case detail.
-type Report struct {
-	Name     string
-	Book     string
-	TopN     int
-	Scored   int // answerable cases
-	Hits     int
-	Errors   int
-	Outcomes []Outcome
-}
-
-// Accuracy over the answerable cases.
-func (r Report) Accuracy() float64 {
-	if r.Scored == 0 {
-		return 0
-	}
-	return float64(r.Hits) / float64(r.Scored)
-}
-
-// RunRetrievalEval searches for every fixture case.
-func RunRetrievalEval(ctx context.Context, c *Client, topN int) (Report, error) {
-	var f fixture
-	if err := json.Unmarshal(knowledgeFixtureJSON, &f); err != nil {
-		return Report{}, err
-	}
-	rep := Report{Name: f.Name, Book: f.Book, TopN: topN}
-	for _, cs := range f.Cases {
-		res, err := c.Search(ctx, cs.Query, f.Book, topN)
-		o := Outcome{Case: cs, Err: err}
-		if err != nil {
-			rep.Errors++
-		}
-		for i, hit := range res {
-			o.Titles = append(o.Titles, hit.Title)
-			if o.Rank == 0 && matches(cs.WantTitles, hit.Title) {
-				o.Rank = i + 1
-			}
-		}
-		if !cs.ExpectMiss {
-			rep.Scored++
-			if o.Hit() {
-				rep.Hits++
-			}
-		}
-		rep.Outcomes = append(rep.Outcomes, o)
-	}
-	return rep, nil
-}
-
-func matches(want []string, title string) bool {
-	for _, w := range want {
-		if strings.EqualFold(strings.TrimSpace(title), w) {
-			return true
-		}
-	}
-	return false
-}
-
-// String — the headline number.
-func (r Report) String() string {
-	var b strings.Builder
-	fmt.Fprintf(&b, "%s: %d/%d answerable questions retrieve a wanted article in top %d (%.1f%%), %d errors\n",
-		r.Name, r.Hits, r.Scored, r.TopN, 100*r.Accuracy(), r.Errors)
-	fmt.Fprintf(&b, "  book: %s\n", r.Book)
-	return b.String()
-}
-
-// Detail — per case: what was asked, what was searched, what came back.
-func (r Report) Detail() string {
-	var b strings.Builder
-	for _, o := range r.Outcomes {
-		mark := "MISS"
-		switch {
-		case o.Case.ExpectMiss:
-			mark = "n/a "
-		case o.Hit():
-			mark = fmt.Sprintf("hit@%d", o.Rank)
-		}
-		fmt.Fprintf(&b, "  %-6s %-20s q=%q\n", mark, o.Case.ID, o.Case.Query)
-		if o.Err != nil {
-			fmt.Fprintf(&b, "         error: %v\n", o.Err)
-			continue
-		}
-		fmt.Fprintf(&b, "         got: %s\n", strings.Join(o.Titles, " | "))
-	}
-	return b.String()
-}

internal/phraser/broken_json_test.go

@@ -0,0 +1,54 @@
+package phraser
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+// A reply that starts a JSON object and never finishes it is a failed
+// generation, not a reply. Before this, the parser returned ("", "") for these
+// and every caller then shipped the raw fragment as the thing Maven said. A
+// real run produced replies of literally "{" and "{\n  \"".
+func TestParseResponseMoodRejectsUnfinishedJSON(t *testing.T) {
+	for _, raw := range []string{
+		`{`,
+		"{\n  \"",
+		`{"response": "неполн`,
+		`{"response": "текст", "mood":`,
+	} {
+		text, mood, err := parseResponseMood(raw)
+		if !errors.Is(err, errBrokenJSON) {
+			t.Errorf("parseResponseMood(%q) err = %v, want errBrokenJSON", raw, err)
+		}
+		if text != "" || mood != "" {
+			t.Errorf("parseResponseMood(%q) leaked %q/%q — a fragment must never come back as a reply", raw, text, mood)
+		}
+	}
+}
+
+// Bare prose is still fine. Small models sometimes answer without any JSON at
+// all, and that reply is usable — so the new error must not swallow it.
+func TestParseResponseMoodAllowsBareProse(t *testing.T) {
+	for _, raw := range []string{
+		"норм, а ты как?",
+		"вот что я нашла: ключ у соседа",
+	} {
+		text, mood, err := parseResponseMood(raw)
+		if err != nil {
+			t.Errorf("parseResponseMood(%q) err = %v, want nil", raw, err)
+		}
+		// No JSON means no fields; the caller ships raw as-is.
+		if text != "" || mood != "" {
+			t.Errorf("parseResponseMood(%q) = %q/%q, want empty", raw, text, mood)
+		}
+	}
+}
+
+// The measured failure: the model wants more than 400 characters and the old
+// grammar cut it off mid-word. Guards the bound against being tightened back.
+func TestGrammarStringBoundHasRoomForARealAnswer(t *testing.T) {
+	if !strings.Contains(responseGrammar, "{0,1000}") {
+		t.Error("grammar string bound is not 1000; 400 truncated real replies mid-word (see the comment on responseGrammar)")
+	}
+}

internal/phraser/eval/address_multi_test.go

@@ -31,3 +31,35 @@ func TestAddressDeduplicates(t *testing.T) {
 		t.Errorf("detail repeats the same break %d times: %q", n, res.Detail)
 	}
 }
+
+// The fragments a real run produced. All of them scored as non-empty replies
+// before checkNonEmpty looked for letters.
+func TestNonEmptyNeedsLetters(t *testing.T) {
+	for _, body := range []string{
+		"{",
+		"{\n  \"",
+		"15-16",
+		`{"`,
+		"   ",
+		"...",
+	} {
+		if got := checkNonEmpty(body); got.Pass {
+			t.Errorf("checkNonEmpty(%q) passed — that is not a reply", body)
+		}
+	}
+}
+
+// And it must not start failing real replies. Latin counts as well as Cyrillic:
+// answers about ssd or vpn are legitimately part English.
+func TestNonEmptyAcceptsRealReplies(t *testing.T) {
+	for _, body := range []string{
+		"норм, а ты как?",
+		"вот что я нашла: ключ у соседа",
+		"ssd быстрее hdd.",
+		"9 минут.",
+	} {
+		if got := checkNonEmpty(body); !got.Pass {
+			t.Errorf("checkNonEmpty(%q) failed: %s", body, got.Detail)
+		}
+	}
+}

internal/phraser/eval/checks.go

@@ -623,11 +623,24 @@ const (
 	CheckEllipsis = "ellipsis" // she finished the sentence
 )
 
+// A reply needs words in it, not just characters. This check used to test for a
+// non-empty string, which scored 27/27 on a run where two replies were "{" and
+// "{\n  \"" — punctuation passed as content. Braces, quotes, digits and spaces
+// are all empty in the only sense that matters.
+//
+// Digits alone fail too, and that is deliberate: the same run answered "сколько
+// варить яйцо вкрутую?" with "15-16". No unit, no words, and it is also the
+// wrong number. Whatever that is, it is not something she said.
 func checkNonEmpty(body string) Result {
 	if strings.TrimSpace(body) == "" {
 		return Result{CheckNonEmpty, false, "empty reply"}
 	}
-	return Result{CheckNonEmpty, true, ""}
+	for _, r := range body {
+		if unicode.IsLetter(r) {
+			return Result{CheckNonEmpty, true, ""}
+		}
+	}
+	return Result{CheckNonEmpty, false, fmt.Sprintf("no letters in the reply %q — punctuation or digits only", strings.TrimSpace(body))}
 }
 
 // checkEllipsis — a reply ending in "…" or "..." is a generation that ran out of

internal/phraser/grammar_test.go

@@ -97,7 +97,10 @@ func TestGrammarStringRuleIsNotASCIIOnly(t *testing.T) {
 // Russian body with an escaped quote inside, hand-built to test the contract.
 func TestGrammarShapedJSONParses(t *testing.T) {
 	raw := `{"response": "он сказал \"привет\" и ушёл.\nвот так.", "mood": "confused"}`
-	text, mood := parseResponseMood(raw)
+	text, mood, err := parseResponseMood(raw)
+	if err != nil {
+		t.Fatalf("grammar-shaped JSON did not parse: %v", err)
+	}
 	if want := "он сказал \"привет\" и ушёл.\nвот так."; text != want {
 		t.Errorf("response = %q, want %q", text, want)
 	}

internal/phraser/llmphraser.go

@@ -190,7 +190,12 @@ func (p *LLMPhraser) PhraseNudge(ctx context.Context, c loop.Candidate) (deliver
 	if err != nil {
 		return delivery.PhrasedNudge{}, err
 	}
-	body, mood := parseResponseMood(resp)
+	body, mood, perr := parseResponseMood(resp)
+	if perr != nil {
+		// Truncated JSON. Not a nudge — use the plain Russian fallback.
+		log.Printf("phraser: PhraseNudge: %v", perr)
+		body, mood = "", ""
+	}
 	if body == "" {
 		// fallback: try old body/summary format
 		body, _ = parsePhrase(resp)
@@ -216,11 +221,16 @@ func (p *LLMPhraser) PhraseQuery(ctx context.Context, utterance string, notes []
 		// prompt is the single tested source in router.KnowledgePrompt.
 		sys := persona.Prepend(p.cfg.ContextBlock, router.KnowledgePrompt())
 		prompt := fmt.Sprintf("Пользователь спрашивает: \"%s\".", utterance)
-		resp, err := p.chatWithSystem(ctx, sys, prompt, 256)
+		resp, err := p.chatWithSystem(ctx, sys, prompt, 768)
 		if err != nil || resp == "" {
 			return "не знаю.", nil
 		}
-		if text, _ := parseResponseMood(resp); text != "" {
+		text, _, perr := parseResponseMood(resp)
+		if perr != nil {
+			log.Printf("phraser: PhraseQuery: %v", perr)
+			return "не знаю.", nil
+		}
+		if text != "" {
 			return text, nil
 		}
 		return resp, nil
@@ -230,17 +240,22 @@ func (p *LLMPhraser) PhraseQuery(ctx context.Context, utterance string, notes []
 	}
 	sys := p.querySystemPrompt()
 	prompt := fmt.Sprintf(
-		`The user asks: "%s". Your notes matching the query contain: "%s". Answer them naturally and briefly. If the notes don't answer the question, say so.`,
+		`Он спрашивает: "%s". В твоих заметках по этому вопросу написано: "%s". Ответь ему коротко и своими словами. Если в заметках ответа нет — так и скажи.`,
 		utterance, strings.Join(notes, `"; "`),
 	)
-	resp, err := p.chatWithSystem(ctx, sys, prompt, 256)
-	if err != nil {
+	resp, err := p.chatWithSystem(ctx, sys, prompt, 768)
+	text, _, perr := parseResponseMood(resp)
+	if err != nil || perr != nil {
+		// Read the notes out rather than ship a broken fragment.
+		if perr != nil {
+			log.Printf("phraser: PhraseQuery: %v", perr)
+		}
 		if len(notes) == 1 {
 			return "вот что я нашла: " + notes[0], nil
 		}
 		return "вот что я нашла: " + strings.Join(notes, "; "), nil
 	}
-	if text, _ := parseResponseMood(resp); text != "" {
+	if text != "" {
 		return text, nil
 	}
 	return resp, nil
@@ -263,12 +278,17 @@ func (p *LLMPhraser) PhraseChat(ctx context.Context, utterance string, history [
 	combined += utterance
 	msgs = append(msgs, chatMsg{Role: "user", Content: strings.TrimSpace(combined)})
 
-	resp, err := p.chatWithMessages(ctx, msgs, 512)
+	resp, err := p.chatWithMessages(ctx, msgs, 768)
 	if err != nil {
 		log.Printf("phraser: PhraseChat: %v", err)
 		return "поговорили.", nil
 	}
-	if text, _ := parseResponseMood(resp); text != "" {
+	text, _, perr := parseResponseMood(resp)
+	if perr != nil {
+		log.Printf("phraser: PhraseChat: %v", perr)
+		return "поговорили.", nil
+	}
+	if text != "" {
 		return text, nil
 	}
 	// fallback: plain text without JSON
@@ -281,11 +301,13 @@ func (p *LLMPhraser) PhraseChat(ctx context.Context, utterance string, history [
 // chatSystemPrompt returns the system prompt for conversational chat.
 // Prepends the shared context block when the phraser has one.
 func chatSystemPrompt(block func() string) string {
-	base := `You are maven, a self-hosted personal assistant. You're talking with your owner. 
-Keep replies brief (1-3 sentences) and natural. You're helpful, curious, and a little warm.
-Respond in the user's language (Russian or English, matching their last message). 
-Never roleplay emotions you don't have, but stay friendly. 
-Respond ONLY with valid JSON: {"response": "...", "mood": "neutral"}. "response" is your reply text; "mood" reflects your tone (neutral/happy/thinking/tired/confused).`
+	// No self-introduction here: the persona block prepended one line above
+	// already says who she is, same as router.KnowledgePrompt.
+	base := `Ты разговариваешь с хозяином. О себе говоришь в женском роде ("я подумала", "я рада"). Он мужчина: обращайся к нему на "ты", в мужском роде ("ты сказал", "ты забыл"). Никогда не "вы"/"ваш" и никогда "он"/"его" — ты говоришь ему, а не о нём.
+
+Отвечай по-русски, коротко: одна-три фразы, живым языком. Ты доброжелательная, тебе интересно, но чувства не изображай.
+
+Отвечай ТОЛЬКО одним объектом JSON: {"response": "...", "mood": "neutral"}. В "response" — твой ответ. В "mood" — ровно одно из: neutral, happy, thinking, tired, confused.`
 	return persona.Prepend(block, base)
 }
 
@@ -349,7 +371,12 @@ func (p *LLMPhraser) PhraseReminder(ctx context.Context, d loop.ReminderDecision
 	if err != nil {
 		return delivery.PhrasedReminder{}, err
 	}
-	body, mood := parseResponseMood(resp)
+	body, mood, perr := parseResponseMood(resp)
+	if perr != nil {
+		// Truncated JSON. Fall through to the reminder's own text.
+		log.Printf("phraser: PhraseReminder: %v", perr)
+		body, mood = "", ""
+	}
 	if body == "" {
 		// fallback: try old body/summary format
 		body, _ = parsePhrase(resp)
@@ -394,10 +421,16 @@ type chatReq struct {
 // Russian, so an ASCII-only rule would make every reply empty. The escape rule
 // is what lets the model close a string it opened with a quote inside. Length
 // is bounded so a repetition loop truncates the field, not the JSON object.
+//
+// That bound was 400 and 400 was too tight. Measured against Qwen3.5-0.8B: on
+// "почему гром слышно позже молнии?" the reply came back exactly 400 characters
+// long, cut mid-word ("Нужно записать и,"), at every token cap from 256 to 2048.
+// So the token cap was never what stopped it — this rule was. 1000 characters is
+// roughly six Russian sentences, still short enough to stop a repetition loop.
 const responseGrammar = `
 root   ::= "{" ws "\"response\"" ws ":" ws string ws "," ws "\"mood\"" ws ":" ws mood ws "}"
 mood   ::= "\"neutral\"" | "\"happy\"" | "\"thinking\"" | "\"tired\"" | "\"confused\""
-string ::= "\"" ([^"\\] | "\\" ["\\/bfnrt]){0,400} "\""
+string ::= "\"" ([^"\\] | "\\" ["\\/bfnrt]){0,1000} "\""
 ws     ::= [ \t\n]*
 `
 
@@ -507,7 +540,9 @@ func (p *LLMPhraser) systemPrompt() string {
 // querySystemPrompt returns the system prompt for PhraseQuery (notes + general
 // knowledge). Prepends the configured persona when set.
 func (p *LLMPhraser) querySystemPrompt() string {
-	base := "You are maven, a self-hosted personal assistant answering from your notes. Answer briefly and naturally in Russian starting with \"вот что я нашла: \". Respond ONLY with valid JSON: {\"response\": \"...\", \"mood\": \"neutral\"}."
+	// No self-introduction here: the persona block prepended one line above
+	// already says who she is, same as router.KnowledgePrompt.
+	base := "Ты отвечаешь ему по своим заметкам. Отвечай по-русски, коротко и своими словами, начинай с \"вот что я нашла: \". О себе — в женском роде (\"нашла\", \"записала\"). Он мужчина, обращайся к нему на \"ты\". Respond ONLY with valid JSON: {\"response\": \"...\", \"mood\": \"neutral\"}."
 	return persona.Prepend(p.cfg.ContextBlock, base)
 }
 
@@ -629,21 +664,39 @@ type responseMood struct {
 	Mood     string `json:"mood"`
 }
 
+// errBrokenJSON — the model started a JSON object and never finished it.
+// That is a failed generation, not a reply. Callers must use their fallback.
+var errBrokenJSON = fmt.Errorf("phraser: model output starts as JSON but does not parse")
+
 // parseResponseMood extracts {"response","mood"} from LLM output, tolerant
-// of thinking tokens and extra text before/after the JSON block. Returns
-// ("", "") when no valid JSON is found.
-func parseResponseMood(raw string) (response, mood string) {
+// of thinking tokens and extra text before/after the JSON block.
+//
+// Three outcomes:
+//   - parsed fine → the fields, nil error.
+//   - output never looked like JSON → ("", "", nil). The caller may ship it
+//     as-is; small models sometimes answer in bare prose and that is fine.
+//   - output starts with "{" but does not parse → errBrokenJSON. The grammar
+//     guarantees a valid *prefix*, so a generation that hits the token cap
+//     mid-object comes back as a fragment like `{` or `{\n  "`. Shipping that
+//     as a reply is the bug this error exists to stop.
+func parseResponseMood(raw string) (response, mood string, err error) {
 	cleaned := strings.TrimSpace(raw)
 	start := strings.Index(cleaned, "{")
 	end := strings.LastIndex(cleaned, "}")
 	if start < 0 || end < 0 || end <= start {
-		return "", ""
+		if strings.HasPrefix(cleaned, "{") {
+			return "", "", errBrokenJSON
+		}
+		return "", "", nil
 	}
 	var parsed responseMood
-	if err := json.Unmarshal([]byte(cleaned[start:end+1]), &parsed); err != nil {
-		return "", ""
+	if e := json.Unmarshal([]byte(cleaned[start:end+1]), &parsed); e != nil {
+		if strings.HasPrefix(cleaned, "{") {
+			return "", "", errBrokenJSON
+		}
+		return "", "", nil
 	}
-	return parsed.Response, parsed.Mood
+	return parsed.Response, parsed.Mood, nil
 }
 
 func parsePhrase(raw string) (body, summary string) {