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.go

@@ -62,10 +62,37 @@ const (
 )
 
 // SilenceAction is the action that stops a condition's messages for a week, with the operator's why: the
-// answer to a condition the operator decided to live with.
+// answer to a condition the operator decided to live with. It is an acknowledgement (ADR 0234 §8): the
+// only kind of answer a desk click performs until answers are authorised (novox/hq ADR 0258). Its cause
+// marks it as an answer, which the hand-act log does not count as a repair.
 func SilenceAction(key string) Action {
 	return Action{Label: "Silence for a week", Verb: "mesh-controller.conditions",
-		Arguments: map[string]string{"silence": key, "for": "7d", "why": ""}}
+		Arguments: map[string]string{"silence": key, "for": "7d", "why": "", "cause": CauseOperatorAnswer}}
+}
+
+// CauseOperatorAnswer is the cause an answer chosen on a notification is recorded with.
+const CauseOperatorAnswer = "operator-answer"
+
+// FallbackNeeds is what a condition needs when its producer's words needed the operator and could not
+// be said: the verdict is kept, never turned into "Nothing for you to do." (ADR 0258).
+const FallbackNeeds = "read the details to see what to do."
+
+func sameActions(a, b []Action) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i].Label != b[i].Label || a[i].Verb != b[i].Verb || a[i].Machine != b[i].Machine ||
+			len(a[i].Arguments) != len(b[i].Arguments) {
+			return false
+		}
+		for k, v := range a[i].Arguments {
+			if b[i].Arguments[k] != v {
+				return false
+			}
+		}
+	}
+	return true
 }
 
 // Bounds of the plain words: a headline fits a notification's title line, an explanation two sentences.
@@ -108,7 +135,9 @@ var (
 	goDuration = regexp.MustCompile(`\b[0-9]+(h[0-9]+m|m[0-9]+s|h[0-9]+m[0-9]+s)\b|\b[0-9]+(\.[0-9]+)?(ns|ms|µs)\b`)
 	clockTime  = regexp.MustCompile(`\b[0-9]{1,2}:[0-9]{2}\b|\b[0-9]{4}-[0-9]{2}-[0-9]{2}\b|\bUTC\b`)
 	flag       = regexp.MustCompile(`(^|\s)--?[a-z]`)
-	agentWord  = regexp.MustCompile(`(?i)\bagents?\b|\bby hand\b|\bsession\b`)
+	agentWord  = regexp.MustCompile(`(?i)\bagents?\b`)
+	byHand     = regexp.MustCompile(`(?i)\bby hand\b`)
+	latinAbbr  = regexp.MustCompile(`\b(e\.g|i\.e|etc)\.`)
 	markup     = regexp.MustCompile("[`*<>{}\\[\\]|#]|(^|\\s)_|_(\\s|$)")
 )
 
@@ -126,14 +155,15 @@ func Plain(text string, machines ...string) (string, bool) {
 	if m := markup.FindString(text); m != "" {
 		return "markup (" + m + ")", false
 	}
+	text = latinAbbr.ReplaceAllString(text, "eg")
 	for _, shape := range []struct {
 		re   *regexp.Regexp
 		what string
 	}{{hexID, "a hash"}, {numberedID, "a numbered id"}, {dotted, "a dotted name"}, {goDuration, "a duration in code"},
 		{clockTime, "a clock time or date"}, {flag, "a command's flag"}} {
 		if m := shape.re.FindString(text); m != "" {
-			if shape.re == hexID && !strings.ContainsAny(m, "0123456789") {
-				continue // a word of letters a to f only
+			if shape.re == hexID && (!strings.ContainsAny(m, "0123456789") || !strings.ContainsAny(m, "abcdef")) {
+				continue // letters a to f only, or a number: words and counts, not a hash
 			}
 			return shape.what + " (" + strings.TrimSpace(m) + ")", false
 		}
@@ -158,16 +188,14 @@ func PlainWords(w Words, machines ...string) (string, bool) {
 	if len(w.Explanation) > ExplanationMax {
 		return fmt.Sprintf("explanation: longer than %d characters", ExplanationMax), false
 	}
-	for _, m := range agentWord.FindAllString(w.Explanation, -1) {
-		if !strings.EqualFold(m, "by hand") { // "repaired by hand" is a fact; telling to act by hand is not
-			return "explanation: sends the operator elsewhere (" + m + ")", false
-		}
+	if m := agentWord.FindString(w.Explanation); m != "" {
+		return "explanation: sends the operator elsewhere (" + m + ")", false
 	}
 	if w.Needs != "" {
 		if why, ok := Plain(w.Needs, machines...); !ok {
 			return "needs: " + why, false
 		}
-		if m := agentWord.FindString(w.Needs); m != "" {
+		if m := agentWord.FindString(w.Needs) + byHand.FindString(w.Needs); m != "" {
 			return "needs: not something the operator does themselves (" + m + ")", false
 		}
 		if len(w.Needs) > NeedsMax || !strings.HasSuffix(w.Needs, ".") {
@@ -221,6 +249,8 @@ func plainly(o Observation) Observation {
 	if w.Headline != "" && w.Resolved == "" {
 		w.Resolved = "Resolved: " + lowerFirst(w.Headline)
 	}
+	// An explanation too long is cut, never refused: what it says first is what matters.
+	w.Explanation = cut(w.Explanation, ExplanationMax-len(Verdict(w.Needs, ""))-1)
 	if from == "" {
 		if Unworded != nil {
 			Unworded(o, "the kind "+o.Kind+" has no plain words")
@@ -230,13 +260,42 @@ func plainly(o Observation) Observation {
 		if Unworded != nil {
 			Unworded(o, from+" is not plain: "+why)
 		}
+		// The scope's words, but never a weaker verdict: what needed the operator still does, and its
+		// answers are kept where they are themselves sound.
+		needed, actions := w.Needs != "", soundActions(w.Actions)
 		w = scopeWords(o)
+		if needed {
+			w.Needs, w.Actions = FallbackNeeds, actions
+		}
 	}
 	o.Headline, o.Resolved, o.Needs, o.Actions = w.Headline, w.Resolved, w.Needs, w.Actions
 	o.Explanation = Verdict(w.Needs, w.Explanation)
 	return o
 }
 
+// soundActions are the actions with a label and a verb.
+func soundActions(list []Action) []Action {
+	var out []Action
+	for _, a := range list {
+		if a.Label != "" && len(a.Label) <= 24 && a.Verb != "" {
+			out = append(out, a)
+		}
+	}
+	return out
+}
+
+// cut shortens text to at most n bytes at a word, ending it with an ellipsis.
+func cut(text string, n int) string {
+	if len(text) <= n || n < 10 {
+		return text
+	}
+	t := text[:n-3]
+	if i := strings.LastIndexByte(t, ' '); i > n/2 {
+		t = t[:i]
+	}
+	return strings.TrimRight(t, " ,;:") + "…"
+}
+
 // Verdict is an explanation opened by its verdict.
 func Verdict(needs, explanation string) string {
 	if needs == "" {