Judge S21 by time since the first failing report while the machine is heard, not by how many reports said it (issue 233 review)

cmd/mesh-controller/apply_failing.go

@@ -25,20 +25,21 @@ const packageManagerKey = "the package manager ("
 // watchApplyFailing is S21: **a machine that does not apply what it was sent is said by the mesh, not only
 // to someone who asks for `status`** (novox/hq issue 233, issue 187's family). A workstation refused every
 // declaration for an hour and a half because its package manager did not answer, and the mesh's only word
-// on it was a line in `status`. Raised once its reports have said the same failure for longer than one
-// apply interval, over at least two reports — a laptop shut for a week has had one attempt, not a week of
-// them — naming the refusal's or the failure's words; cleared by a clean apply. Not while the machine is
-// silent or asleep: S1 says silent, and asleep is not lost.
+// on it was a line in `status`. Raised once the machine's first report of this failure is older than one apply
+// interval **while the machine is heard** — judged by time, not by how many reports said it: a node-engine
+// says a re-apply only when how it went changed, so the same failure is one report however long it lasts.
+// Names the refusal's or the failure's words; cleared by the clean apply the node-engine then says. Not while
+// the machine is silent, asleep or not known: S1 says silent, and asleep is not lost.
 func watchApplyFailing(f *signalFacts) []conditions.Observation {
-	quiet := map[string]bool{}
+	heard := map[string]bool{}
 	for _, m := range f.machines {
-		if m.asleep() || (!m.lastHeard.IsZero() && f.now.Sub(m.lastHeard) > heartbeatBound(m.every)) {
-			quiet[m.name] = true
+		if !m.asleep() && !m.lastHeard.IsZero() && f.now.Sub(m.lastHeard) <= heartbeatBound(m.every) {
+			heard[m.name] = true
 		}
 	}
 	var out []conditions.Observation
 	for _, d := range f.doing {
-		if !d.Wrong() || d.Since == nil || d.Times < 2 || f.now.Sub(*d.Since) <= applyEvery || quiet[d.Node] {
+		if !d.Wrong() || d.Since == nil || f.now.Sub(*d.Since) <= applyEvery || !heard[d.Node] {
 			continue
 		}
 		out = append(out, applyFailing(d, f.now))
@@ -57,14 +58,13 @@ func applyFailing(d inventory.Doing, now time.Time) conditions.Observation {
 	if d.Outcome != inventory.OutcomeRefused {
 		how = "applied its declaration only in part"
 	}
-	o.Summary = fmt.Sprintf("%s has %s on %d reports in a row since %s (bound %s): %s", m, how, d.Times, since,
-		ago(applyEvery), failedNames(d))
+	o.Summary = fmt.Sprintf("%s has %s since %s (bound %s): %s", m, how, since, ago(applyEvery), failedNames(d))
 	o.Headline = m + " is not applying its update"
 	o.Explanation = fmt.Sprintf("%s has %s for %s, and trying again has not helped. The details say what fails.",
 		m, plainHow(d), humanDuration(now.Sub(*d.Since)))
 	if tool := unansweringTool(d); tool != "" {
 		o.Summary = fmt.Sprintf("%s: %s does not answer, so no package reaches it; everything else it was sent "+
-			"is applied, on %d reports in a row since %s (bound %s)", m, tool, d.Times, since, ago(applyEvery))
+			"is applied, since %s (bound %s)", m, tool, since, ago(applyEvery))
 		o.Headline = fmt.Sprintf("%s cannot install packages", m)
 		o.Explanation = fmt.Sprintf("The package manager on %s (%s) has not answered for %s, so no package reaches "+
 			"it. Everything else is still applied, so an update that repairs it can land; if none does, it needs a "+