Review a long record within a bound sized to it, and let a proposal waiting on its author leave the knowledge base healthy (hq issue 508)

A judgement over one bus call's 30 seconds is collected by its ticket from
claude-code, so an eleven-clause record can be reviewed; a proposal out of
review tries is told to the operator, not raised as the module's fault, so
it no longer holds the module's own rollouts.

modules/mesh-knowledge/cmd/mesh-knowledge/review.go

@@ -12,8 +12,9 @@ package main
 //     and says so on it. It is never taken as an approval. It is owed: the try count and when the next try is due
 //     are kept with the version in the store, so the background work takes it up at that time, also after a restart
 //     of the tool runner (novox/hq issue 497), up to MostReviewTries. After the last try the record says so, its
-//     author proposes it again to have it reviewed again, the module's health names it, and the operator is told
-//     once on the operator's channel.
+//     author proposes it again to have it reviewed again, and the operator is told once on the operator's channel.
+//     The module's health names it and stays healthy: the record waits on its author, and the module works
+//     (novox/hq issue 508).
 //   - A record with a version whose writer the runtime did not prove is not reviewed: who wrote it cannot be told,
 //     and no one but its proven author revises it, so its author proposes it again under a new number.
 //   - On approve, a record that does not need the operator is accepted at once; one its author marked
@@ -278,7 +279,7 @@ func (k *KB) ReviewStep() (string, error) {
 }
 
 // Unreviewed are the proposed records that ran out of review tries: no judgement could be had, or the operator
-// could not be asked. They make the module unhealthy, so the mesh raises a condition naming them.
+// could not be asked. The module's health names them and stays healthy (novox/hq issue 508); the operator is told.
 func Unreviewed(all []*Entry) []string {
 	var out []string
 	for _, e := range all {
@@ -326,19 +327,23 @@ func (k *KB) tellUnreviewed(e *Entry) {
 		version = e.PendingVersion
 	}
 	key := fmt.Sprintf("%sv%d", unreviewedOf(w.Key()), version)
-	// Kept as told before the notice is sent, as for drafted clauses: a notice that fails is logged and not sent
-	// again, and the module's health still names the record, so the mesh's condition stands for it.
+	// Kept as told before the notice is sent, so two steps never send it twice; a notice that fails is no longer
+	// kept as told, and is sent again at the next step: the module's health stays healthy for it (novox/hq issue
+	// 508), so this notice is the only loud word of it.
 	if first, err := k.Store.Told(ctx, key+" "+at); err != nil || !first {
 		return
 	}
 	summary := fmt.Sprintf("%s was never reviewed: its review could not be had %d times (last: %s). It stays proposed, and nothing of it is in force.",
 		w.Key(), w.Judging.Tries, w.Judging.Reason)
 	explanation := "No review that could not be had counts as an approval. Its author proposes it again to have it reviewed again; " +
-		"until then the knowledge base's health names it. The knowledge base's get and history show it."
+		"the knowledge base's get and history show it."
 	// The channel edits a cleared message with the resolved line given here, not the one sent with the clear.
 	resolved := w.Key().String() + " no longer waits for its review"
 	if err := k.Notify(key, summary, "A proposal was never reviewed: "+w.Key().String(), explanation, resolved); err != nil {
-		k.logf("[mesh-knowledge] the operator could not be told that %s was never reviewed: %v; the module's health still names it", w.Key(), err)
+		k.logf("[mesh-knowledge] the operator could not be told that %s was never reviewed: %v; told again at the next step", w.Key(), err)
+		if uerr := k.Store.Untold(ctx, key+" "+at); uerr != nil {
+			k.logf("[mesh-knowledge] and that it was not told could not be kept: %v", uerr)
+		}
 	}
 }