Say a read-only mesh-cli call in no line of its own, and count them hourly (hq issue 762)

A page polling plans every few seconds wrote about 14,000 journal lines a day. A line is judged a
read by the generic command verb's reading forms (ADR 0266), on its every word, so plans go,
conditions silence and settings set are still said; a refused or failed read is said too.

cmd/mesh-controller/meshcli.go

@@ -7,7 +7,10 @@ import (
 	"fmt"
 	"os/exec"
 	"slices"
+	"sort"
 	"strings"
+	"sync"
+	"time"
 
 	"github.com/novox/mesh-controller/internal/inventory"
 	"github.com/novox/mesh-controller/internal/link"
@@ -123,8 +126,82 @@ func answerMeshCLI(inv *inventory.Inventory) link.CLIHandler {
 // cliJournal says one line in the controller's journal (its standard output); a variable so a test can read it.
 var cliJournal = func(line string) { fmt.Println(line) }
 
-// runForMeshCLI runs a judged line and answers what it said. Every line is said in the journal first: its call,
-// who asked on which node, its command word only, and how it runs (review of ADR 0272).
+// onlyReads says a line only reads, judged by the generic `command` verb's reading forms (novox/hq ADR 0266) — the
+// same allow list that decides what an ordinary call may run, never a second list kept here — judged on the line's
+// every word, so `plans go`, `conditions silence` and `settings set` are not reads while `plans`, `conditions` and
+// `settings show` are. A line those forms do not name is not judged a read, and is said (novox/hq issue 762).
+func onlyReads(asked link.CLIAsked, v cliVerdict) bool {
+	if v.refused != "" || len(asked.Line) == 0 || len(asked.Stdin) > 0 || cliServers[asked.Line[0]] {
+		return false
+	}
+	return commandReads(asked.Line) == nil && terminalOnly(asked.Line) == nil
+}
+
+// readCalls counts the read calls said in no line, per caller, until the next hourly line says them.
+type readCalls struct {
+	mu     sync.Mutex
+	counts map[string]int
+}
+
+// cliReads are this controller's read calls not yet said.
+var cliReads = &readCalls{}
+
+func (r *readCalls) add(caller string) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if r.counts == nil {
+		r.counts = map[string]int{}
+	}
+	r.counts[caller]++
+}
+
+// said is the line that says the read calls counted since the last, and starts counting again; empty when there
+// were none, so an idle hour says nothing.
+func (r *readCalls) said(over time.Duration) string {
+	r.mu.Lock()
+	counts := r.counts
+	r.counts = nil
+	r.mu.Unlock()
+	if len(counts) == 0 {
+		return ""
+	}
+	callers := make([]string, 0, len(counts))
+	for c := range counts {
+		callers = append(callers, c)
+	}
+	sort.Strings(callers)
+	parts := make([]string, len(callers))
+	for i, c := range callers {
+		parts[i] = fmt.Sprintf("%s %d", c, counts[c])
+	}
+	return fmt.Sprintf("mesh-cli read calls in the last %s, said in no line of their own: %s", over,
+		strings.Join(parts, ", "))
+}
+
+// readCallsEvery is how often the count of read calls is said.
+const readCallsEvery = time.Hour
+
+// sayReadCalls says, every readCallsEvery until ctx ends, how many read calls each caller made — when any did — so
+// a runaway poller stays visible while its calls write no line each (novox/hq issue 762).
+func sayReadCalls(ctx context.Context) {
+	tick := time.NewTicker(readCallsEvery)
+	defer tick.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-tick.C:
+			if line := cliReads.said(readCallsEvery); line != "" {
+				cliJournal(line)
+			}
+		}
+	}
+}
+
+// runForMeshCLI runs a judged line and answers what it said. Every line that changes something, is refused or fails
+// is said in the journal: its call, who asked on which node, its command word only, and how it runs (review of ADR
+// 0272). A line that only reads and succeeds is counted instead, and the count said hourly (novox/hq issue 762): a
+// page polling `plans` every few seconds would otherwise write thousands of lines a day.
 func runForMeshCLI(ctx context.Context, node string, asked link.CLIAsked, v cliVerdict) link.CLIAnswer {
 	how := "as an ordinary call"
 	switch {
@@ -137,7 +214,23 @@ func runForMeshCLI(ctx context.Context, node string, asked link.CLIAsked, v cliV
 	if call == "" {
 		call = "(no call)"
 	}
-	cliJournal(fmt.Sprintf("mesh-cli %s: %s on %s asked %q, %s", call, asked.Account, node, asked.Line[0], how))
+	line := fmt.Sprintf("mesh-cli %s: %s on %s asked %q, %s", call, asked.Account, node, asked.Line[0], how)
+	if !onlyReads(asked, v) {
+		cliJournal(line)
+		return runJudgedLine(ctx, node, asked, v)
+	}
+	answer := runJudgedLine(ctx, node, asked, v)
+	if answer.Exit != 0 || answer.Refused != "" {
+		// A read that was refused or failed is said, as a change is.
+		cliJournal(fmt.Sprintf("%s, and it failed (exit %d)", line, answer.Exit))
+	} else {
+		cliReads.add(fmt.Sprintf("%s on %s", asked.Account, node))
+	}
+	return answer
+}
+
+// runJudgedLine runs a line runForMeshCLI has said or counted.
+func runJudgedLine(ctx context.Context, node string, asked link.CLIAsked, v cliVerdict) link.CLIAnswer {
 	if v.refused != "" {
 		return link.CLIRefusal(v.refused)
 	}