Offer only acknowledgements as answers, keep a refused verdict, and say a change of words

Review found that a desk click proves nothing about who chose, that refused words
could turn "Needs you" into "Nothing for you to do", that sound words were refused,
and that a quiet warning whose words came to need the operator was never said
(hq ADR 0258).

internal/conditions/plain_test.go

@@ -11,7 +11,7 @@ import (
 func TestThePlainRuleRefusesIdentifiersCodeAndTimes(t *testing.T) {
 	refused := map[string]string{
 		"the walk of novox/mesh-catalog a6385479 waits": "a hash",
-		"plan plan-1791454185265004861 is waiting":      "a hash",
+		"plan plan-1791454185265004861 is waiting":      "a numbered id",
 		"see `mesh-delivery.show` for why":              "markup",
 		"call mesh-delivery.show for why":               "a dotted name",
 		"key plan.x.waiting":                            "a dotted name",
@@ -124,7 +124,6 @@ func TestEveryExplanationOpensWithItsVerdict(t *testing.T) {
 	for _, w := range []Words{
 		{Headline: "x waits", Explanation: "Have an agent start it.", Resolved: "x started"},
 		{Headline: "x waits", Explanation: "It waits.", Needs: "start it by hand.", Resolved: "x started"},
-		{Headline: "x waits", Explanation: "It waits.", Needs: "open a session and start it.", Resolved: "x started"},
 		{Headline: "x waits", Explanation: "It waits.", Needs: "start it", Resolved: "x started"},
 		{Headline: "x waits", Explanation: "It waits.", Resolved: "x started", Actions: []Action{{Label: "Start"}}},
 	} {
@@ -161,3 +160,88 @@ func TestAnEscalatedConditionSaysItNeedsTheOperator(t *testing.T) {
 		t.Errorf("seen again after escalation: %q", c.Explanation)
 	}
 }
+
+// **What the plain rule refused wrongly** (novox/hq ADR 0258): a login session is the operator's own word,
+// "e.g." is not a dotted name, a long count is not a hash, and a long explanation is cut, not refused.
+func TestThePlainRuleRefusesNoPlainWords(t *testing.T) {
+	for _, text := range []string{
+		"log out of every session on g14 and log in again.",
+		"A module, e.g. the lighting daemon, waits.",
+		"It holds 12345678 files.",
+		"A person repaired push by hand 35 times in 14 days.",
+	} {
+		if why, ok := Plain(text, "g14"); !ok {
+			t.Errorf("%q refused: %s", text, why)
+		}
+	}
+	if _, ok := Plain("commit 0123abc landed"); ok {
+		t.Error("a hash passed")
+	}
+	k, _, _, _ := keeper(t)
+	long := strings.Repeat("The bus refused a message. ", 30)
+	Wording("test-long", func(o Observation) Words {
+		return Words{Headline: "A long one", Explanation: long, Resolved: "Done"}
+	})
+	before := Unworded
+	var unworded []string
+	Unworded = func(o Observation, why string) { unworded = append(unworded, why) }
+	t.Cleanup(func() { Unworded = before })
+	c, err := k.Observe(t.Context(), Observation{Scope: ScopeBus, ID: "x", Kind: "test-long", Severity: Warning,
+		Source: "test", Summary: "long"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Headline != "A long one" || len(c.Explanation) > ExplanationMax || !strings.HasSuffix(c.Explanation, "…") ||
+		len(unworded) != 0 {
+		t.Errorf("a long explanation was not cut: %d %q %v", len(c.Explanation), c.Headline, unworded)
+	}
+}
+
+// **Words refused keep their verdict and their answers** (ADR 0258): a producer that needed the operator
+// still does, said as "read the details", and its sound answers stay.
+func TestRefusedWordsKeepTheirVerdictAndAnswers(t *testing.T) {
+	k, _, _, _ := keeper(t)
+	before := Unworded
+	Unworded = func(Observation, string) {}
+	t.Cleanup(func() { Unworded = before })
+	silence := SilenceAction("module.openrazer.g14.x")
+	c, err := k.Observe(t.Context(), Observation{Scope: ScopeModule, ID: "openrazer.g14", Token: "x", Kind: "test-refused",
+		Machine: "g14", Severity: Warning, Source: "test", Summary: "s",
+		Headline: "openrazer at 0123abc failed", Needs: "restart it.", Explanation: "It failed.",
+		Actions: []Action{silence}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Needs != FallbackNeeds || !strings.HasPrefix(c.Explanation, NeedsYou+" "+FallbackNeeds) ||
+		len(c.Actions) != 1 || c.Actions[0].Label != silence.Label || strings.Contains(c.Headline, "0123abc") {
+		t.Errorf("the verdict or the answers were lost: %+v", c)
+	}
+	// Words that needed nothing stay "Nothing for you to do.".
+	c, _ = k.Observe(t.Context(), Observation{Scope: ScopeModule, ID: "openrazer.g14", Token: "y", Kind: "test-refused",
+		Machine: "g14", Severity: Warning, Source: "test", Summary: "s", Headline: "at 0123abc", Explanation: "x."})
+	if c.Needs != "" || !strings.HasPrefix(c.Explanation, NothingToDo) {
+		t.Errorf("%+v", c)
+	}
+}
+
+// **Words that now need the operator are said as a change** (ADR 0258): a condition whose needs or answers
+// change emits condition-changed, so a warning kept quiet is said.
+func TestAChangeOfWordsIsSaid(t *testing.T) {
+	k, _, told, _ := keeper(t)
+	o := Observation{Scope: ScopeMachine, ID: "ace", Kind: "silent", Machine: "ace", Severity: Warning, Source: "S1",
+		Summary: "ace is silent", Headline: "ace is not answering", Explanation: "It may be asleep."}
+	if _, err := k.Observe(t.Context(), o); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := k.Observe(t.Context(), o); err != nil { // the same words: no event
+		t.Fatal(err)
+	}
+	o.Needs = "check that ace is on."
+	if _, err := k.Observe(t.Context(), o); err != nil {
+		t.Fatal(err)
+	}
+	said := settled(t, told, 2)
+	if len(said) != 2 || said[1].Change != ChangeWords || said[1].Event != EventChanged || said[1].Needs != o.Needs {
+		t.Fatalf("%+v", said)
+	}
+}