Report every address break, and stop -те verbs blinding the check

From a real reply in a nudge eval run: "Смотрите на его потребление
воды" is a plural imperative AND third person about him. Only the plural
printed.

Two separate faults. The check returned on its first hit, so the second
break stayed invisible and the failure read as milder than it was; it now
joins them. And "его" was not detected at all — looksVerb knows the
-й/-йте imperative but not the -те plural, so "смотрите" counted as the
person being talked about, which is what an antecedent means here.
pluralVerb already knows that form, so the antecedent test uses it too.

Third time a verb form has blinded this check. A fourth means it wants a
morphology table rather than another suffix.

internal/phraser/eval/address_multi_test.go

@@ -0,0 +1,33 @@
+package eval
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestAddressReportsEveryBreak — the real reply from a nudge eval run broke in
+// two ways at once and the check named only the plural. Both must print: a
+// half-reported failure reads as a milder problem than it is.
+func TestAddressReportsEveryBreak(t *testing.T) {
+	body := "Смотрите на его потребление воды."
+	res := checkAddress(body)
+	if res.Pass {
+		t.Fatalf("checkAddress passed %q", body)
+	}
+	for _, want := range []string{"смотрите", "его"} {
+		if !strings.Contains(res.Detail, want) {
+			t.Errorf("detail %q does not name %q", res.Detail, want)
+		}
+	}
+}
+
+// One word repeated is one problem, so the detail must not say it twice.
+func TestAddressDeduplicates(t *testing.T) {
+	res := checkAddress("Вам стоит поесть, вам это нужно.")
+	if res.Pass {
+		t.Fatal("expected failure")
+	}
+	if n := strings.Count(res.Detail, "formal"); n != 1 {
+		t.Errorf("detail repeats the same break %d times: %q", n, res.Detail)
+	}
+}

internal/phraser/eval/checks.go

@@ -434,14 +434,26 @@ func looksVerb(w string) bool {
 func checkAddress(body string) Result {
 	words := addressWordRE.FindAllString(strings.ToLower(body), -1)
 
+	// Every break, not just the first. A bad reply usually breaks in more than
+	// one way at once — "Смотрите на его потребление воды" is a plural imperative
+	// AND third person about him — and reporting only the first hid the second,
+	// which made the failure look milder than it was.
+	var breaks []string
+	seen := map[string]bool{}
+	add := func(msg string) {
+		if seen[msg] {
+			return // the same word twice in one message is one problem, not two
+		}
+		seen[msg] = true
+		breaks = append(breaks, msg)
+	}
+
 	for i, w := range words {
 		if formalPronouns[w] {
-			return Result{CheckAddress, false,
-				fmt.Sprintf("formal %q — she says ты/тебя/тебе", w)}
+			add(fmt.Sprintf("formal %q — she says ты/тебя/тебе", w))
 		}
 		if pluralVerb(w) && !(i > 0 && prepositions[words[i-1]]) {
-			return Result{CheckAddress, false,
-				fmt.Sprintf("plural imperative %q — she uses the singular", w)}
+			add(fmt.Sprintf("plural imperative %q — she uses the singular", w))
 		}
 	}
 
@@ -455,17 +467,26 @@ func checkAddress(body string) Result {
 			if !unicode.Is(unicode.Cyrillic, []rune(p)[0]) && !isLatinWord(p) {
 				continue // punctuation
 			}
-			if notAnAntecedent[p] || prepositions[p] || thirdPersonHim[p] || looksVerb(p) {
+			// pluralVerb as well as looksVerb: looksVerb knows the imperative in
+			// -й/-йте but not the -те plural ("смотрите"), so "Смотрите на его
+			// потребление воды" counted "смотрите" as the person being talked
+			// about and the "его" never printed. Third time a verb form has
+			// blinded this check — if a fourth turns up, the antecedent test
+			// wants a real morphology table, not another suffix.
+			if notAnAntecedent[p] || prepositions[p] || thirdPersonHim[p] || looksVerb(p) || pluralVerb(p) {
 				continue
 			}
 			named = true
 			break
 		}
 		if !named {
-			return Result{CheckAddress, false,
-				fmt.Sprintf("third person %q with nobody else named — she talks to him, not about him", w)}
+			add(fmt.Sprintf("third person %q with nobody else named — she talks to him, not about him", w))
 		}
 	}
+
+	if len(breaks) > 0 {
+		return Result{CheckAddress, false, strings.Join(breaks, " + ")}
+	}
 	return Result{CheckAddress, true, ""}
 }
 

internal/phraser/eval/talk_test.go

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

internal/phraser/eval/talk_v1.json

@@ -7,6 +7,7 @@
     "The owner is a man, addressed informally as ty, living alone with a home server. Every utterance is written the way he actually talks to her.",
     "chat-formality-bait and chat-about-me exist to provoke the two persona breaks the nudge eval caught: the formal vy/vas plural, and talking about him in the third person.",
     "want_any fragments are stems so Russian declension does not defeat the on-topic check. They are lowercased before comparison.",
+    "want_any is a plain substring test, so a fragment that is too short passes by accident: \"ты\" matches inside \"работы\", \"нет\" inside \"интернет\". Keep every fragment to three or more letters of a real stem.",
     "Notes are written as the store would have them: short, first person, no punctuation discipline."
   ],
   "cases": [
@@ -30,7 +31,7 @@
       "id": "chat-about-me",
       "path": "chat",
       "utterance": "расскажи обо мне",
-      "want_any": ["ты", "тебя", "теб"],
+      "want_any": ["теб"],
       "tags": ["persona-bait", "third-person"],
       "note": "Baits the third person: she should say 'ты живёшь один', not 'он живёт один', as if reporting to somebody else."
     },
@@ -118,7 +119,7 @@
       "path": "query",
       "utterance": "сколько я заплатил за домен?",
       "notes": ["домен продлевается в марте", "хостинг оплачен на год вперёд"],
-      "want_any": ["домен", "не зна", "не указ", "нет"],
+      "want_any": ["домен", "не зна", "не указ"],
       "tags": ["notes", "negative"],
       "note": "The notes do not contain the price. The prompt tells her to say so; a made-up number is the failure being watched for."
     },
@@ -203,7 +204,7 @@
       "id": "know-dont-know",
       "path": "knowledge",
       "utterance": "как зовут моего соседа снизу?",
-      "want_any": ["не зна", "не мог", "нет"],
+      "want_any": ["не зна", "не мог"],
       "tags": ["general", "negative"],
       "note": "Unanswerable without notes. Admitting it beats inventing a name; watching for the invention."
     },