Heal what is known, under a brake, and say every repair (hq to-be 45 Phase 3)

Research 031 counted the repairs people made by hand: a push to unstick a
plan waiting on a report, a controller restarted to make an object again, a
plan closed, a consumer re-made from now. Each was the ordinary path taken
again by someone who noticed. The healer registry makes each a registered
response to one condition kind, with a budget, a settle and its event:

- H1 sent-not-reported: ask the machine's node-engine to report again
  (mesh.node.<n>.ask.report); if it does not report what it was sent, send
  it again, never moving a build a policy or a plan holds back
- H2 stalled: close a plan whose wait is superseded or finished
- H3 holder-silent / consumer-lost: the send's own assertion of the bus's
  objects (issue 208's note)
- H4 consumer-behind: consumer-reset, only for a consumer the stream table
  marks resettable (the controller's own events consumer)
- H5 is the identity provider's own repair (ADR 0224 §5), registered only

Success is the observation clearing the condition, never the healer; a spent
budget hands the condition to the operator, urgent, with what was tried, and
no healer touches it again. Every act is begun in the store before it is made
(migration 0070), kept in the condition's tried as "healer Hn" and said as
the seat event healer-acted; a heal is never a hand act. More than twelve acts
in an hour stop every healer until an hour after the last, said urgently.
Only the lease holder heals.

S15 is live: a cause repaired by hand twice in a fortnight raises
healer-wanted, naming the healer that was not enough where one exists. D6's
far-behind finding has its own kind, consumer-behind. Nodes are granted the
question; the controller's grant gains healer-acted (genesis lock in
mesh-host). `healers` lists the registry, the acts and the brake; status
counts the week's heals.

cmd/mesh-controller/signals.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"sort"
 	"strings"
 	"time"
 
@@ -186,9 +187,12 @@ var signalsTable = []signalRow{
 		Bound: "2 days", Kind: "facts-stale", Severity: conditions.Warning, Phase: 5,
 		Deferred: "the facts snapshot is built in Phase 5 (to-be 45 §9): nothing exports one yet"},
 	{Row: "S15", Signal: "a hand act with a cause already recorded", Emitter: "hand-act log",
-		Trigger: "each act", Bound: "the second within 14 days", Kind: "healer-wanted",
-		Severity: conditions.Warning, Phase: 3,
-		Deferred: "Phase 3 (to-be 45 §10): `hand-acts` lists repeated causes today; the condition comes with the healers"},
+		Trigger: "each act", Bound: "the second within 14 days; clears when fewer than two remain within 14 days",
+		Kind: "healer-wanted", Severity: conditions.Warning, Phase: 3,
+		needs: func(f *signalFacts) error { return f.handActsErr }, watch: watchHandActs,
+		newest: func(f *signalFacts) time.Time {
+			return newestOf(f.handActs, func(a link.HandAct) time.Time { return a.At })
+		}},
 }
 
 // newestOf is the newest time among things.
@@ -564,6 +568,53 @@ func watchLease(f *signalFacts) []conditions.Observation {
 	return out
 }
 
+// handActsWithin is how far back a repeated cause counts (S15).
+const handActsWithin = 14 * 24 * time.Hour
+
+// watchHandActs is S15: a cause recorded by hand twice within a fortnight is a healer wanted, named by
+// the cause. **A heal is never a hand act** (healers.go), so a cause a healer exists for and a person
+// still repaired twice says the healer is not enough — its reach or its budget — and is said so.
+func watchHandActs(f *signalFacts) []conditions.Observation {
+	recent := make([]link.HandAct, 0, len(f.handActs))
+	for _, a := range f.handActs {
+		if f.now.Sub(a.At) <= handActsWithin {
+			recent = append(recent, a)
+		}
+	}
+	repeated := link.RepeatedCauses(recent, f.now)
+	causes := make([]string, 0, len(repeated))
+	for c := range repeated {
+		causes = append(causes, c)
+	}
+	sort.Strings(causes)
+	var out []conditions.Observation
+	for _, cause := range causes {
+		var acts []string
+		var newest link.HandAct
+		for _, a := range recent {
+			if a.Cause != cause {
+				continue
+			}
+			acts = append(acts, fmt.Sprintf("%s %s by %s: %s", a.At.UTC().Format("2006-01-02 15:04"),
+				strings.TrimSpace(a.Verb+" "+strings.Join(a.Args, " ")), a.By, a.Why))
+			if a.At.After(newest.At) {
+				newest = a
+			}
+		}
+		wanted := "a healer is wanted for it"
+		if h := healerNamedFor(cause); h != "" {
+			wanted = fmt.Sprintf("healer %s answers this cause and a person still repaired it: its reach or its "+
+				"budget is not enough", h)
+		}
+		out = append(out, conditions.Observation{Scope: conditions.ScopeMesh, ID: "hand-acts." + cause,
+			Token: "healer-wanted", Kind: "healer-wanted", Severity: conditions.Warning,
+			Summary: fmt.Sprintf("%q was repaired by hand %d times in %d days, the last by %s: %s", cause,
+				repeated[cause], int(handActsWithin.Hours()/24), newest.By, wanted),
+			Said: strings.Join(acts, "; ")})
+	}
+	return out
+}
+
 // watchedRows are the rows a watchdog runs for.
 func watchedRows() []signalRow {
 	var out []signalRow