Merge pull request 'Compose each read-write access's grant for the node-engine (hq ADR 0312, issue 537)' (#256) from feat/537-a-read-write-access-grants-the-paths-group into main

A path beginning with the same letters is another path, and a read-only mount
of a read-write access is still granted: the grant follows what mounts it.

.gitignore

@@ -6,3 +6,5 @@
 /mesh-controller
 /postgres-provisioner
 /redis-provisioner
+# And where `go build` in cmd/mesh-controller leaves it (novox/hq issue 233).
+/cmd/mesh-controller/mesh-controller

cmd/mesh-controller/apply_failing.go

@@ -0,0 +1,118 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/novox/mesh-controller/internal/conditions"
+	"github.com/novox/mesh-controller/internal/inventory"
+)
+
+// kindApplyFailing is S21's kind: a machine whose declarations have been refused, or applied only in part,
+// for longer than one apply interval (novox/hq issue 233).
+const kindApplyFailing = "apply-failing"
+
+// applyEvery is how often a node-engine applies what it was last told when nothing new arrives: its
+// ReconcileEvery. A failure still there after one more of them is not one the next apply clears.
+const applyEvery = 5 * time.Minute
+
+// packageManagerKey is how a node-engine names a package manager that does not answer among what failed
+// (mesh-host's probe.go): "the package manager (pacman)".
+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 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 {
+	heard := map[string]bool{}
+	for _, m := range f.machines {
+		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 || f.now.Sub(*d.Since) <= applyEvery || !heard[d.Node] {
+			continue
+		}
+		out = append(out, applyFailing(d, f.now))
+	}
+	return out
+}
+
+// applyFailing is one machine's S21 condition.
+func applyFailing(d inventory.Doing, now time.Time) conditions.Observation {
+	m := d.Node
+	since := d.Since.UTC().Format("2006-01-02 15:04 MST")
+	o := conditions.Observation{Scope: conditions.ScopeMachine, ID: m, Kind: kindApplyFailing, Machine: m,
+		Severity: conditions.Warning, Said: doingWords(d),
+		Resolved: m + " applies what it is sent again"}
+	how := "refused its declaration whole"
+	if d.Outcome != inventory.OutcomeRefused {
+		how = "applied its declaration only in part"
+	}
+	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, 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 "+
+			"look on the machine.", m, tool, humanDuration(now.Sub(*d.Since)))
+	}
+	return o
+}
+
+// plainHow is how a machine failed, as the operator reads it.
+func plainHow(d inventory.Doing) string {
+	if d.Outcome == inventory.OutcomeRefused {
+		return "refused every update"
+	}
+	return "applied its updates only in part"
+}
+
+// unansweringTool is the package manager a machine said does not answer, or "".
+func unansweringTool(d inventory.Doing) string {
+	for _, r := range d.Failed {
+		if rest, ok := strings.CutPrefix(r.ID, packageManagerKey); ok {
+			return strings.TrimSuffix(rest, ")")
+		}
+	}
+	return ""
+}
+
+// failedNames is what failed, by name: the refusal, or the failed resources' ids.
+func failedNames(d inventory.Doing) string {
+	if d.Outcome == inventory.OutcomeRefused {
+		return "refused"
+	}
+	ids := make([]string, 0, len(d.Failed))
+	for _, r := range d.Failed {
+		ids = append(ids, r.ID)
+	}
+	sort.Strings(ids)
+	return "failed " + strings.Join(ids, ", ")
+}
+
+// doingWords is the machine's own words on what failed: the evidence, kept inside the mesh.
+func doingWords(d inventory.Doing) string {
+	if d.Outcome == inventory.OutcomeRefused {
+		return "refused: " + oneLine(d.Refused)
+	}
+	var parts []string
+	for _, r := range d.Failed {
+		parts = append(parts, r.ID+": "+oneLine(r.Error))
+	}
+	sort.Strings(parts)
+	return strings.Join(parts, "; ")
+}

cmd/mesh-controller/apply_failing_test.go

@@ -0,0 +1,123 @@
+package main
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/novox/mesh-controller/internal/conditions"
+	"github.com/novox/mesh-controller/internal/inventory"
+)
+
+// unansweringPackageManager is anchor's last report as the workstation's read on 2026-10-04, once its
+// node-engine applies the rest (novox/hq issue 233): the package failed and the package manager did not answer,
+// the same failure on times reports since for before now.
+func unansweringPackageManager(now time.Time, forHowLong time.Duration, times int) inventory.Doing {
+	since := now.Add(-forHowLong)
+	return inventory.Doing{Node: "anchor", Outcome: inventory.OutcomeFailed, At: now.Add(-time.Second),
+		Since: &since, Times: times, Applied: 41, Failed: []inventory.FailedResource{
+			{ID: "apply", Error: `applying "pacman.base": nothing can be said about "base": this is the arch host and ` +
+				"pacman does not answer here. Either this machine is not Arch, or its package database is broken: " +
+				"pacman exited 1: error: config file /etc/pacman.conf could not be read: No such file or directory"},
+			{ID: "the package manager (pacman)", Error: "pacman does not answer here, so every package in this " +
+				"declaration fails and the rest of it is applied (novox/hq issue 233): pacman exited 1: error: config " +
+				"file /etc/pacman.conf could not be read: No such file or directory"}}}
+}
+
+// **A machine whose package manager does not answer is raised by the mesh itself, naming the tool and the
+// probe's words** (novox/hq issue 233): the words in the evidence, the path kept out of the summary.
+func TestAPackageManagerThatDoesNotAnswerIsRaisedNamingItsWords(t *testing.T) {
+	now := time.Date(2026, 10, 4, 14, 0, 0, 0, time.UTC)
+	f := calm(now)
+	f.doing = []inventory.Doing{unansweringPackageManager(now, 90*time.Minute, 18)}
+	got := watchApplyFailing(f)
+	if len(got) != 1 {
+		t.Fatalf("raised %d conditions, want one: %+v", len(got), got)
+	}
+	o := got[0]
+	if o.Key() != "machine.anchor.apply-failing" || o.Machine != "anchor" {
+		t.Errorf("the condition is not the machine's: %s", o.Key())
+	}
+	if !strings.Contains(o.Summary, "pacman does not answer") || !strings.Contains(o.Summary, "since 2026-10-04 12:30") {
+		t.Errorf("the summary does not name the tool and since when: %s", o.Summary)
+	}
+	if strings.Contains(o.Summary, "/etc/") {
+		t.Errorf("the summary carries a path, which belongs in the evidence: %s", o.Summary)
+	}
+	if !strings.Contains(o.Said, "could not be read") {
+		t.Errorf("the evidence does not carry the probe's words: %s", o.Said)
+	}
+	if !strings.Contains(o.Headline, "cannot install packages") || o.Explanation == "" || o.Resolved == "" {
+		t.Errorf("the plain words do not say it: %+v", o)
+	}
+}
+
+// **A whole refusal is raised too**, with the node-engine's words: what the workstation's report said before the
+// node-engine applied the rest.
+func TestARefusalThatGoesOnIsRaised(t *testing.T) {
+	now := time.Date(2026, 10, 4, 14, 0, 0, 0, time.UTC)
+	since := now.Add(-time.Hour)
+	f := calm(now)
+	f.doing = []inventory.Doing{{Node: "anchor", Outcome: inventory.OutcomeRefused, Since: &since, Times: 12,
+		Refused: "this is the arch host and pacman does not answer here", At: now.Add(-time.Minute)}}
+	got := watchApplyFailing(f)
+	if len(got) != 1 || !strings.Contains(got[0].Summary, "refused its declaration whole") ||
+		!strings.Contains(got[0].Said, "pacman does not answer") {
+		t.Fatalf("a refusal that went on for an hour was not raised with its words: %+v", got)
+	}
+}
+
+// **Judged by time while the machine is heard, not by how many reports said it** (review of novox/hq issue 233):
+// a node-engine says the same failure once, so one report an apply interval old is a fault that goes on; one
+// younger is not yet; and a silent or sleeping machine is S1's.
+func TestOneReportOlderThanAnApplyIsRaisedAndAQuietMachineIsNot(t *testing.T) {
+	now := time.Date(2026, 10, 4, 14, 0, 0, 0, time.UTC)
+	f := calm(now)
+	f.doing = []inventory.Doing{unansweringPackageManager(now, 6*time.Minute, 1)}
+	if got := watchApplyFailing(f); len(got) != 1 {
+		t.Errorf("one report of a failure six minutes old was not raised: %+v", got)
+	}
+	f.doing = []inventory.Doing{unansweringPackageManager(now, 4*time.Minute, 1)}
+	if got := watchApplyFailing(f); len(got) != 0 {
+		t.Errorf("a failure four minutes old was raised before one apply could clear it: %+v", got)
+	}
+	f.doing = []inventory.Doing{unansweringPackageManager(now, time.Hour, 1)}
+	f.machines[0].lastHeard = now.Add(-time.Hour)
+	if got := watchApplyFailing(f); len(got) != 0 {
+		t.Errorf("a silent machine was raised for its last report: %+v", got)
+	}
+	f = calm(now)
+	f.doing = []inventory.Doing{unansweringPackageManager(now, time.Hour, 1)}
+	f.doing[0].Node = "a-machine-the-mesh-does-not-know"
+	if got := watchApplyFailing(f); len(got) != 0 {
+		t.Errorf("a machine not heard of was raised: %+v", got)
+	}
+}
+
+// **A failed re-apply followed by a clean one clears S21** (review of novox/hq issue 233): the node-engine says
+// the clean re-apply, the store keeps it as applied with no failure since, and the condition the failure raised
+// is cleared through the keeper on the next tick.
+func TestACleanReapplyAfterAFailedOneClearsTheCondition(t *testing.T) {
+	now := time.Date(2026, 10, 4, 14, 0, 0, 0, time.UTC)
+	store := conditions.NewInMemory()
+	k := conditions.NewKeeper(t.Context(), conditions.Options{Store: store, History: store,
+		Teller: &conditions.Told{}, Now: func() time.Time { return now }})
+	defer k.Close(context.Background())
+	w := &watchdogs{keeper: k, started: now.Add(-time.Hour)}
+
+	failing := calm(now)
+	failing.doing = []inventory.Doing{unansweringPackageManager(now, 20*time.Minute, 1)}
+	w.see(t.Context(), failing)
+	open, err := k.Open(t.Context())
+	if err != nil || len(open) != 1 || open[0].Kind != kindApplyFailing {
+		t.Fatalf("the failed re-apply raised %+v (%v), want apply-failing", open, err)
+	}
+
+	clean := calm(now.Add(5 * time.Minute))
+	clean.doing = nil // the clean re-apply recorded: NotDoingWhatTheyWereTold no longer lists the machine
+	w.see(t.Context(), clean)
+	if open, _ := k.Open(t.Context()); len(open) != 0 {
+		t.Fatalf("the condition stayed open after the clean re-apply: %+v", open)
+	}
+}

cmd/mesh-controller/plain_words.go

@@ -81,6 +81,13 @@ var plainWordings = map[string]func(conditions.Observation) words{
 				"It usually catches up by itself.", m, m),
 			Resolved: m + " applied the change"}
 	}),
+	kindApplyFailing: worded(func(o conditions.Observation) words {
+		m := machineOr(o, "a machine")
+		return words{Headline: m + " is not applying its update",
+			Explanation: fmt.Sprintf("%s has refused or only partly applied what the mesh sent it, again and again. "+
+				"The details say what fails.", conditions.Capital(m)),
+			Resolved: m + " applies what it is sent again"}
+	}),
 	"tools-silent": worded(func(o conditions.Observation) words {
 		m := machineOr(o, "a machine")
 		return words{Headline: "Tools on " + m + " are not answering",

cmd/mesh-controller/plan.go

@@ -947,9 +947,14 @@ func renderingFor(ctx context.Context, open *stores, node string,
 	if err != nil {
 		return catalogue.Rendering{}, inventory.Node{}, err
 	}
+	grantsGroups, err := engineGrantsGroups(ctx, inv, node)
+	if err != nil {
+		return catalogue.Rendering{}, inventory.Node{}, err
+	}
 	return catalogue.Rendering{
 		ReadsHealth:   readsHealth,
 		JudgesRoot:    judgesRoot,
+		GrantsGroups:  grantsGroups,
 		BusMembership: memberships[node],
 		Settings:      settings, Generators: gens, Grants: grants, Needed: needed, Foreseen: foreseen, Ports: ports,
 		Certificate: certificate, Authority: authority, Mesh: private, Names: names,
@@ -982,6 +987,16 @@ func engineJudgesRoot(ctx context.Context, inv *inventory.Inventory, node string
 	return had && stated.Contract >= link.RootContract, nil
 }
 
+// engineGrantsGroups says whether a machine's node-engine reads an access's `grant` (novox/hq ADR 0312), by its own
+// newest statement, for the same reason as engineReadsHealth: an older engine parses strictly.
+func engineGrantsGroups(ctx context.Context, inv *inventory.Inventory, node string) (bool, error) {
+	stated, had, err := inv.HealthOf(ctx, node)
+	if err != nil {
+		return false, err
+	}
+	return had && stated.Contract >= link.GrantContract, nil
+}
+
 // zonesInTheMesh is every zone a module in the mesh declares, where the mesh placed it (novox/hq ADR
 // 0199): the zone settled from that node's settings, the node's private address, the port the
 // answering listen is published on there.

cmd/mesh-controller/plans_follow.go

@@ -1,158 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/novox/mesh-controller/internal/inventory"
-	"github.com/novox/mesh-controller/internal/link"
-)
-
-// Following a plan (novox/hq issue 229): `plans wait <id>` holds its answer until the plan moves, reaches its
-// next tier or ends, or until its bound passes, and says which. Before it, an agent following a rollout had
-// `plans` answer once, in prose, and wrote a loop of its own round the mesh's tools to be told the plan moved.
-//
-// **No wait is longer than a call is answered within** (link.LongestAnswer, inside the console's thirty
-// seconds): a longer one would answer "still running" and leave its caller to ask `calls` — the loop again.
-// So a caller following a plan to its end asks again; each call answers the moment the plan moves.
-
-// maxPlanWait is the longest bound a wait takes, and the bound when none is given: what a call is answered
-// within, less the time a verb's command takes to start and read the store.
-var maxPlanWait = link.LongestAnswer - planWaitStart
-
-// planWaitStart is what the verb's window allows beyond the bound: starting the command and opening the stores.
-// A store slow enough to push the read and the answer past it degrades as any long call does: the caller is
-// answered that the call is still running, and `calls` with its id says what came of it.
-const planWaitStart = 5 * time.Second
-
-// planWaitEvery is how often a wait reads the plan again.
-const planWaitEvery = time.Second
-
-// The things a wait waits until.
-var planWaitUntil = []string{"moved", "tier", "done"}
-
-// planWaitAsked checks what a wait is asked for: until (moved when empty) and a bound (a duration, or a number
-// of seconds; maxPlanWait when empty).
-func planWaitAsked(until, bound string) (string, time.Duration, error) {
-	if until == "" {
-		until = "moved"
-	}
-	known := false
-	for _, u := range planWaitUntil {
-		known = known || u == until
-	}
-	if !known {
-		return "", 0, fmt.Errorf("a wait is until %s, not %q", strings.Join(planWaitUntil, ", "), until)
-	}
-	d := maxPlanWait
-	if bound = strings.TrimSpace(bound); bound != "" {
-		var err error
-		if secs, isNumber := strconv.Atoi(bound); isNumber == nil {
-			d = time.Duration(secs) * time.Second
-		} else if d, err = time.ParseDuration(bound); err != nil {
-			return "", 0, fmt.Errorf("the bound %q is not a duration (such as 20s) or a number of seconds", bound)
-		}
-		if d <= 0 || d > maxPlanWait {
-			return "", 0, fmt.Errorf("the bound is at most %s, the longest a call is answered within; %s was asked "+
-				"— to follow a plan longer, ask again: each call answers the moment the plan moves", maxPlanWait, d)
-		}
-	}
-	return until, d, nil
-}
-
-// planEnded is a plan that will not move again: done, failed or superseded. A batch being assembled is not one.
-func planEnded(p inventory.Plan) bool { return !p.Open() && !p.Batch() }
-
-// waitOnPlan reads the plan until what it waits for happens or the bound passes, and answers the plan as last
-// read and what ended the wait: moved (any save of it), tier (its tier changed), done (it ended — which ends
-// every wait, since nothing comes after it), or bound. Moved and tier are judged against the plan as first read.
-func waitOnPlan(ctx context.Context, read func(context.Context) (inventory.Plan, error), until string,
-	bound, every time.Duration) (inventory.Plan, string, error) {
-	first, err := read(ctx)
-	if err != nil {
-		return inventory.Plan{}, "", err
-	}
-	if planEnded(first) {
-		return first, "done", nil
-	}
-	deadline := time.Now().Add(bound)
-	tick := time.NewTicker(every)
-	defer tick.Stop()
-	last := first
-	for {
-		select {
-		case <-ctx.Done():
-			return last, "", ctx.Err()
-		case <-tick.C:
-		}
-		if !time.Now().Before(deadline) {
-			return last, "bound", nil
-		}
-		p, err := read(ctx)
-		if err != nil {
-			return last, "", err
-		}
-		last = p
-		switch {
-		case planEnded(p):
-			return p, "done", nil
-		case until == "moved" && p.Revision != first.Revision:
-			return p, "moved", nil
-		case until == "tier" && p.Tier != first.Tier:
-			return p, "tier", nil
-		}
-	}
-}
-
-// planWaited is what `plans wait` answers: the plan, what ended the wait, and the line a person reads (`text`,
-// which the verb answers as its output and not again in the data).
-type planWaited struct {
-	// Came is what ended the wait: moved, tier, done, or bound when nothing did.
-	Came   string     `json:"came"`
-	Until  string     `json:"until"`
-	Waited string     `json:"waited"`
-	Plan   planStatus `json:"plan"`
-	// Revision is the plan's as read: a caller asking again with the same plan sees whether it moved since.
-	Revision int64  `json:"revision"`
-	Text     string `json:"text"`
-}
-
-func planWaitedDoc(p inventory.Plan, st planStatus, until, came string, waited time.Duration, line string) planWaited {
-	said := map[string]string{
-		"moved": "moved", "tier": "reached another tier", "done": "ended",
-		"bound": "did not " + map[string]string{"moved": "move", "tier": "reach another tier", "done": "end"}[until],
-	}[came]
-	text := fmt.Sprintf("%s %s in %s (waited until %s)\n%s — %s\n", p.ID, said, waited.Round(time.Second), until,
-		p.ID, line)
-	return planWaited{Came: came, Until: until, Waited: waited.Round(time.Millisecond).String(), Plan: st,
-		Revision: p.Revision, Text: text}
-}
-
-// planWaitCommand is `plans wait <id>`: the plan followed until it moves, or the bound passes.
-func planWaitCommand(ctx context.Context, inv *inventory.Inventory, id, untilAsked, boundAsked string) error {
-	until, bound, err := planWaitAsked(untilAsked, boundAsked)
-	if err != nil {
-		return err
-	}
-	began := time.Now()
-	p, came, err := waitOnPlan(ctx, func(ctx context.Context) (inventory.Plan, error) {
-		return inv.PlanByID(ctx, id)
-	}, until, bound, planWaitEvery)
-	if err != nil {
-		return err
-	}
-	// Said as `plans <id>` says its first line, and as `status` says the plan.
-	now, one := time.Now(), []inventory.Plan{p}
-	bounds, pause := readTierBounds(ctx, inv, now), buildSeatPause(ctx, inv, one)
-	line := planLineSaid(p, now, pause, bounds.of(p.Repository), func(module string) []string {
-		on, _ := inv.Running(ctx, module)
-		return on
-	}, waitsOf(ctx, inv, one))
-	doc := planWaitedDoc(p, planStatuses(one, now, pause, bounds)[0], until, came, now.Sub(began), line)
-	return json.NewEncoder(os.Stdout).Encode(doc)
-}

cmd/mesh-controller/plans_follow_test.go

@@ -1,196 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/novox/mesh-controller/internal/inventory"
-)
-
-// A plan as the store would answer it at each read: the reads are counted, and each answers the next.
-type planReads struct {
-	plans []inventory.Plan
-	n     int
-}
-
-func (r *planReads) read(context.Context) (inventory.Plan, error) {
-	p := r.plans[min(r.n, len(r.plans)-1)]
-	r.n++
-	return p, nil
-}
-
-func followedPlan(rev int64, state string, tier int) inventory.Plan {
-	return inventory.Plan{ID: "plan-1", Repository: "novox/x", Commit: "abc", State: state, Tier: tier,
-		Tiers: [][]string{{"a"}, {"b"}}, Revision: rev}
-}
-
-// **`plans` waits for a plan, and says what ended the wait** (novox/hq issue 229): an agent following a
-// rollout is told when the plan moved, reached its next tier or ended, or that the bound passed — in one
-// call, without a loop of its own.
-func TestAWaitForAPlanEndsWhenWhatItWaitsForHappens(t *testing.T) {
-	cases := []struct {
-		name  string
-		until string
-		reads []inventory.Plan
-		came  string
-		times int
-	}{
-		{"moved: any save", "moved", []inventory.Plan{
-			followedPlan(1, inventory.PlanBuilding, 0), followedPlan(1, inventory.PlanBuilding, 0),
-			followedPlan(2, inventory.PlanBuilding, 0)}, "moved", 3},
-		{"tier: a save inside the tier is not enough", "tier", []inventory.Plan{
-			followedPlan(1, inventory.PlanBuilding, 0), followedPlan(2, inventory.PlanBuilding, 0),
-			followedPlan(3, inventory.PlanRolling, 1)}, "tier", 3},
-		{"tier: a plan that ended has no next tier to wait for", "tier", []inventory.Plan{
-			followedPlan(1, inventory.PlanBuilding, 0), followedPlan(2, inventory.PlanFailed, 0)}, "done", 2},
-		{"done: a new tier is not the end", "done", []inventory.Plan{
-			followedPlan(1, inventory.PlanBuilding, 0), followedPlan(2, inventory.PlanRolling, 1),
-			followedPlan(3, inventory.PlanDone, 1)}, "done", 3},
-		{"done: a plan already ended answers at once", "done", []inventory.Plan{
-			followedPlan(4, inventory.PlanSuperseded, 1)}, "done", 1},
-		{"the bound passes", "moved", []inventory.Plan{followedPlan(1, inventory.PlanBuilding, 0)}, "bound", -1},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			r := &planReads{plans: c.reads}
-			p, came, err := waitOnPlan(context.Background(), r.read, c.until, 50*time.Millisecond, time.Millisecond)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if came != c.came {
-				t.Fatalf("the wait ended as %q, want %q", came, c.came)
-			}
-			if c.times > 0 && r.n != c.times {
-				t.Errorf("read the plan %d times, want %d: it answered before or after what it waited for", r.n, c.times)
-			}
-			if want := c.reads[min(r.n, len(c.reads))-1]; p.Revision != want.Revision {
-				t.Errorf("answered revision %d, not the plan as it was last read (%d)", p.Revision, want.Revision)
-			}
-		})
-	}
-}
-
-// What a wait is asked for is checked before anything is read: what it waits until, and a bound no longer than
-// a call is answered within.
-func TestAWaitIsRefusedWhatItCannotDo(t *testing.T) {
-	for _, bad := range []struct{ until, bound string }{{"landed", ""}, {"", "1h"}, {"", "-3s"}, {"", "soon"}} {
-		if _, _, err := planWaitAsked(bad.until, bad.bound); err == nil {
-			t.Errorf("until %q, bound %q was taken", bad.until, bad.bound)
-		}
-	}
-	until, bound, err := planWaitAsked("", "")
-	if err != nil || until != "moved" || bound != maxPlanWait {
-		t.Fatalf("the defaults are %q %s %v, want moved and %s", until, bound, err, maxPlanWait)
-	}
-	if _, bound, _ := planWaitAsked("tier", "12"); bound != 12*time.Second {
-		t.Errorf("a bare number is seconds; read %s", bound)
-	}
-}
-
-// **The answer is data, with its prose as a field beside it** (novox/hq issue 229): the verb's `answer` carries
-// the plan and what ended the wait, and its output is the line a person reads — never JSON inside a string.
-func TestAWaitForAPlanAnswersAsData(t *testing.T) {
-	p := followedPlan(7, inventory.PlanRolling, 1)
-	st := planStatuses([]inventory.Plan{p}, time.Now(), pauseView{}, tierBounds{})[0]
-	doc := planWaitedDoc(p, st, "tier", "tier", 3*time.Second, "rolling, tier 2 of 2")
-	stdout, _ := json.Marshal(doc)
-	a := answerOf([]string{"plans", "wait", "plan-1"}, stdout, "", true)
-	data, ok := a.Answer.(map[string]any)
-	if !ok {
-		t.Fatalf("the answer is not data: %v", a.Answer)
-	}
-	if data["came"] != "tier" || data["revision"] != float64(7) {
-		t.Errorf("the data does not say what ended the wait: %v", data)
-	}
-	if plan, _ := data["plan"].(map[string]any); plan["state"] != "rolling" || plan["tier"] != float64(1) {
-		t.Errorf("the data does not carry the plan: %v", data["plan"])
-	}
-	if _, text := data["text"]; text {
-		t.Errorf("the prose is in the data too: %v", data)
-	}
-	if strings.Contains(a.Output, "{") || !strings.Contains(a.Output, "plan-1") || !strings.Contains(a.Output, "tier") {
-		t.Errorf("the output is not the line a person reads: %q", a.Output)
-	}
-}
-
-// The verb composes the wait, and asks for a window as long as its bound.
-func TestThePlansVerbComposesAWait(t *testing.T) {
-	argv, err := argvFor("plans", map[string]any{"wait": "plan-1", "until": "done", "bound": "15s"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got := strings.Join(argv, " "); got != "plans wait plan-1 --until done --bound 15s" {
-		t.Fatalf("composed %q", got)
-	}
-	if _, err := argvFor("plans", map[string]any{"until": "done"}); err == nil {
-		t.Error("until without wait was taken")
-	}
-	if _, err := argvFor("plans", map[string]any{"wait": "plan-1", "bound": "1h"}); err == nil {
-		t.Error("a bound past what a call can wait was taken")
-	}
-}
-
-// Live, with the store: `plans wait` run as the verb runs it answers when the plan reaches its next tier, as
-// data, and says the bound passed when nothing moved (novox/hq issue 229).
-func TestAPlanFollowedFromTheStoreAnswersWhenItMoves(t *testing.T) {
-	open := aMesh(t)
-	ctx := t.Context()
-	now := time.Now().UTC()
-	walk := inventory.Plan{ID: "plan-229", Repository: "novox/mesh-catalog", Branch: "main", Commit: "c229c229",
-		Created: now, State: inventory.PlanBuilding, Tiers: [][]string{{"a"}, {"b"}},
-		Modules: map[string]*inventory.PlanModule{"a": {}, "b": {}}}
-	if err := open.inventory.SavePlan(ctx, &walk); err != nil {
-		t.Fatal(err)
-	}
-	moved := make(chan error, 1)
-	go func() {
-		time.Sleep(1500 * time.Millisecond)
-		p, err := open.inventory.PlanByID(ctx, walk.ID)
-		if err == nil {
-			p.Tier, p.State = 1, inventory.PlanRolling
-			err = open.inventory.SavePlan(ctx, &p)
-		}
-		moved <- err
-	}()
-	began := time.Now()
-	var got planWaited
-	out := printed(t, func() error {
-		return plansCommand(ctx, []string{"wait", walk.ID, "--until", "tier", "--bound", "15s"})
-	})
-	if err := <-moved; err != nil {
-		t.Fatal(err)
-	}
-	if err := json.Unmarshal([]byte(out), &got); err != nil {
-		t.Fatalf("plans wait did not answer data: %v: %q", err, out)
-	}
-	if got.Came != "tier" || got.Plan.Tier != 1 || got.Plan.State != inventory.PlanRolling {
-		t.Fatalf("the wait answered %+v", got)
-	}
-	if waited := time.Since(began); waited > 10*time.Second {
-		t.Errorf("it answered after %s, not when the plan moved", waited)
-	}
-	out = printed(t, func() error {
-		return plansCommand(ctx, []string{"wait", walk.ID, "--bound", "2"})
-	})
-	if err := json.Unmarshal([]byte(out), &got); err != nil || got.Came != "bound" || got.Until != "moved" {
-		t.Fatalf("a plan that did not move answered %+v (%v)", got, err)
-	}
-}
-
-// The verb's schema says the longest bound in words, and the words are the value (review 75 on #266): the
-// catalogue cannot read maxPlanWait, so this holds them together.
-func TestThePlansSchemaSaysTheLongestBoundThereIs(t *testing.T) {
-	v, ok := controllerVerb("plans")
-	if !ok {
-		t.Fatal("no plans verb")
-	}
-	props, _ := v.Input["properties"].(map[string]any)
-	bound, _ := props["bound"].(map[string]any)
-	said, _ := bound["description"].(string)
-	if !strings.Contains(said, maxPlanWait.String()+", the default, is the longest") {
-		t.Fatalf("the schema says %q; the longest bound is %s", said, maxPlanWait)
-	}
-}

cmd/mesh-controller/release_plan.go

@@ -1463,10 +1463,6 @@ func plansCommand(ctx context.Context, args []string) error {
 	modules := set.String("modules", "", "or the modules it would change, comma-separated")
 	moduleDirs := set.String("module-dirs", "", "with --paths: the directories holding a module.json at the commit, "+
 		"comma-separated, as the forge's announcer says them (novox/hq issue 278)")
-	// Following a plan (novox/hq issue 229): `plans wait <id>`.
-	until := set.String("until", "", "with wait: what to wait for — moved (any change), tier (its next tier) or done (its end)")
-	bound := set.String("bound", "", "with wait: how long to wait at most, as 15s or seconds (default and at most the "+
-		"longest a call is answered within)")
 	// Ending a plan by hand is a repair, and says why (novox/hq to-be 45 §7).
 	why := addHandActFlags(set)
 	positionals, err := parseAround(set, args)
@@ -1486,9 +1482,6 @@ func plansCommand(ctx context.Context, args []string) error {
 	defer open.Close()
 	inv := open.inventory
 	now := time.Now()
-	if len(positionals) == 2 && positionals[0] == "wait" {
-		return planWaitCommand(ctx, inv, positionals[1], *until, *bound)
-	}
 	if len(positionals) == 1 {
 		p, err := inv.PlanByID(ctx, positionals[0])
 		if err != nil {

cmd/mesh-controller/seatverbs.go

@@ -365,21 +365,6 @@ func (a *verbArguments) commandLine() ([]string, error) {
 				return argv, nil
 			}
 		}
-		if id := str("wait"); id != "" {
-			// Following a plan (novox/hq issue 229): checked here too, so a call asking what no wait can do is
-			// refused before a command is started.
-			if _, _, err := planWaitAsked(a.given["until"], a.given["bound"]); err != nil {
-				return nil, err
-			}
-			argv := []string{"plans", "wait", id}
-			if u := str("until"); u != "" {
-				argv = append(argv, "--until", u)
-			}
-			if b := str("bound"); b != "" {
-				argv = append(argv, "--bound", b)
-			}
-			return argv, nil
-		}
 		if id := str("id"); id != "" {
 			return []string{"plans", id}, nil
 		}
@@ -1000,14 +985,12 @@ var jsonVerbs = map[string]bool{"status": true, "seats": true, "plan": true, "co
 	// The delivery's owner's verbs answer JSON where they read (plan, order, check, walks) — novox/hq ADR 0239.
 	"delivery": true,
 	// The build queue, each ask with its position among the waiting (novox/hq issue 455).
-	"queue": true,
-	// A plan followed (novox/hq issue 229): `plans wait` answers JSON; its other forms say text, and so answer no data.
-	"plans": true}
+	"queue": true}
 
 // tableBesideVerbs are the JSON verbs whose document carries the table a person reads as its `text`: the
 // verb answers that table as its output, as it did before it answered data, and the rest as `answer` —
 // both from the one read, so they never disagree (novox/hq issue 455).
-var tableBesideVerbs = map[string]bool{"queue": true, "plans": true}
+var tableBesideVerbs = map[string]bool{"queue": true}
 
 // overviewVerbs are the JSON verbs whose answer is said once, as data, and not again as the text the
 // command printed: the overviews, which grow with the mesh (novox/hq issue 314). Every reader of theirs
@@ -1281,16 +1264,6 @@ func seatToolHandlers() (map[string]link.ToolHandler, []string, error) {
 				// Whatever it did, `status` is composed again once it has.
 				defer statusFrom.nudge()
 			}
-			if verb == "plans" && len(argv) > 1 && argv[1] == "wait" {
-				// A wait holds its answer up to its bound (novox/hq issue 229), and is answered in full inside it.
-				asked := ""
-				if i := slices.Index(argv, "--bound"); i > 0 && i+1 < len(argv) {
-					asked = argv[i+1]
-				}
-				if _, bound, err := planWaitAsked("", asked); err == nil {
-					link.AnswersWithin(ctx, bound+planWaitStart)
-				}
-			}
 			if answer, read := readHere(ctx, argv); read {
 				return answer, nil
 			}

cmd/mesh-controller/signals.go

@@ -254,6 +254,16 @@ var signalsTable = []signalRow{
 		newest: func(f *signalFacts) time.Time {
 			return newestOf(f.bus.waits, func(w busWaitFacts) time.Time { return w.since })
 		}},
+	{Row: "S21", Signal: "a clean apply", Emitter: "node-engine", Trigger: "each report of a declaration refused or applied only in part (novox/hq issue 233)",
+		Bound: "one apply interval (5 min) past the first report of the same failure, judged by time while the machine " +
+			"is heard — the node-engine says a re-apply only when how it went changed; not while it is silent or " +
+			"asleep; naming the refusal, or the package manager that does not answer with its words; cleared by the " +
+			"clean apply it then says",
+		Kind: kindApplyFailing, Severity: conditions.Warning, Phase: 2,
+		needs: func(f *signalFacts) error { return f.doingErr }, watch: watchApplyFailing,
+		newest: func(f *signalFacts) time.Time {
+			return newestOf(f.doing, func(d inventory.Doing) time.Time { return d.At })
+		}},
 }
 
 // watchFacts is S14: the snapshot a merge check is fed is older than its bound, or none was kept since

cmd/mesh-controller/signals_test.go

@@ -186,6 +186,14 @@ var suppressions = map[string]suppression{
 		},
 		past: func(f *signalFacts) { f.refusedSends = []inventory.Send{refusedSend(f.now.Add(-time.Second))} },
 	},
+	// A machine whose package manager does not answer (novox/hq issue 233): said once its first report of the
+	// failure is older than one apply interval while it is heard. Inside: exactly five minutes old.
+	"S21": {
+		inside: func(f *signalFacts) { f.doing = []inventory.Doing{unansweringPackageManager(f.now, 5*time.Minute, 1)} },
+		past: func(f *signalFacts) {
+			f.doing = []inventory.Doing{unansweringPackageManager(f.now, 5*time.Minute+time.Second, 1)}
+		},
+	},
 	// Twice by hand within a fortnight is a healer wanted; once, or the first of two a day too old, is not.
 	"S15": {
 		inside: func(f *signalFacts) {

cmd/mesh-controller/watchdogs.go

@@ -59,6 +59,10 @@ type signalFacts struct {
 	// from, each naming its sender (S20, novox/hq issue 234).
 	refusedSends    []inventory.Send
 	refusedSendsErr error
+	// doing is every machine whose last report was not a clean apply, with since when it has said the same
+	// failure (S21, novox/hq issue 233).
+	doing    []inventory.Doing
+	doingErr error
 
 	loop    loopFacts
 	loopErr error
@@ -369,6 +373,7 @@ func (w *watchdogs) gather(ctx context.Context) *signalFacts {
 	}
 	f.handActs, f.handActsErr = w.gatherHandActs(ctx, now)
 	f.refusedSends, f.refusedSendsErr = inv.RefusedSendsSince(ctx, now.Add(-generationRefusalsSaid))
+	f.doing, f.doingErr = inv.NotDoingWhatTheyWereTold(ctx)
 	f.facts.taken, _, f.facts.began, f.facts.err = exportedFacts.last()
 	return f
 }

go.mod

@@ -35,4 +35,4 @@ require (
 // committed. Every build (the build agent's `go build`, the Dockerfile) compiles from vendor/ and
 // fetches nothing; go refuses to build when vendor/ and this file disagree, so a pin moved without
 // `go mod vendor` fails loudly, at once, everywhere.
-replace github.com/novox/mesh-host => git.novox.be/novox/mesh-host v0.0.0-20261011092230-20d5af9b2d5f
+replace github.com/novox/mesh-host => git.novox.be/novox/mesh-host v0.0.0-20261012112256-3f7f797168d3

go.sum

@@ -1,5 +1,5 @@
-git.novox.be/novox/mesh-host v0.0.0-20261011092230-20d5af9b2d5f h1:8N5OW2mdTNIck2pe4EciTYX5NsrPsHrTLENGNIWYNTU=
-git.novox.be/novox/mesh-host v0.0.0-20261011092230-20d5af9b2d5f/go.mod h1:tcTK4LMs1d6JpZUwy3hSHMFG/MIuDr/XFs7/nbeaW/c=
+git.novox.be/novox/mesh-host v0.0.0-20261012112256-3f7f797168d3 h1:VpH8CesuBOo7k8GcXZq1eRUfbvUoktfmcUynI5N3IFQ=
+git.novox.be/novox/mesh-host v0.0.0-20261012112256-3f7f797168d3/go.mod h1:tcTK4LMs1d6JpZUwy3hSHMFG/MIuDr/XFs7/nbeaW/c=
 git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261010191001-33917f91ac3c h1:l5onJwoIeH8yE/PjVlEeoPyXBsHp2NQiWLllz2fwX7s=
 git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261010191001-33917f91ac3c/go.mod h1:GFuZUElBZ9A++mxgIKo97aXXo+kV0uJ/UkbhQPPIbrY=
 github.com/antithesishq/antithesis-sdk-go v0.7.0-default-no-op h1:Z/MZK75wC/NSrkgqeNIa7jexam9uWzhLmFTSCPI/kn0=

internal/catalogue/declaration.go

@@ -246,6 +246,11 @@ type Rendering struct {
 	// statement's contract is link.RootContract or later). To an older, strict engine the field is not
 	// sent, and the account it names is not judged — which the self-check says, as not judged.
 	JudgesRoot bool
+
+	// GrantsGroups says this machine's node-engine reads an access's `grant` (novox/hq ADR 0312: its statement's
+	// contract is link.GrantContract or later). To an older, strict engine the field is not sent, nor the
+	// runtime's restarts on it, and a read-write access is reached as before: by whoever owns the path.
+	GrantsGroups bool
 }
 
 // RootField is a user resource's field saying the account must never become root without a person
@@ -543,6 +548,9 @@ func (r Resolution) compose(with Rendering, owner map[string]string,
 	}
 
 	var out []map[string]any
+	// The read-write accesses each module grants its tools' account, by module (novox/hq ADR 0312): the runtime
+	// that runs as that account is restarted on them.
+	grantedToTools := map[string][]string{}
 	for _, m := range r.Modules {
 		if with.Adopted && m.Filtering != nil {
 			// Nothing of a module that loads a filter, on an adopted node: its table would drop
@@ -1115,6 +1123,13 @@ func (r Resolution) compose(with Rendering, owner map[string]string,
 			out = append(out, copied)
 		}
 
+		// **A read-write access grants its path's group to what runs this module's code** (novox/hq ADR 0312):
+		// the containers composed above that mount it, and the account its tools run as. Only to an engine that
+		// reads the field.
+		if with.GrantsGroups {
+			grantedToTools[m.Module] = grantAccesses(out, owner, m.Module, r.toolsAccount(m, with))
+		}
+
 		// **What only the mesh knows, where this module asked for it.** The graph is the control
 		// plane's; making a name resolve is the module's software. Emitted as ordinary files under
 		// this module's name, so they are applied, reported and removed exactly as anything else
@@ -1141,6 +1156,12 @@ func (r Resolution) compose(with Rendering, owner map[string]string,
 		}
 		owner[fmt.Sprint(process["id"])] = RuntimeModule
 		out = append(out, process)
+		// Restarted when an access moved its account's groups, so its process holds them (novox/hq ADR 0312 §6).
+		for _, m := range r.Modules {
+			if m.RunsAs == "" {
+				restartOnGrants(process, grantedToTools[m.Module])
+			}
+		}
 		// And a runtime of its own for each module of its own account, after it (novox/hq ADR 0259 §8).
 		owns, err := r.ownRuntimes(with)
 		if err != nil {
@@ -1149,6 +1170,7 @@ func (r Resolution) compose(with Rendering, owner map[string]string,
 		for _, p := range owns {
 			id := fmt.Sprint(p["id"])
 			owner[id] = strings.TrimSuffix(id, "."+OwnRuntimeID())
+			restartOnGrants(p, grantedToTools[owner[id]])
 			out = append(out, p)
 		}
 		// What each module's bundles are given is read as the account the runtime runs as — not what a

internal/catalogue/grants.go

@@ -0,0 +1,134 @@
+package catalogue
+
+import (
+	"fmt"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// A read-write access grants the path's own group to what runs the module's code (novox/hq ADR 0312, issue 537).
+//
+// **The controller says who; the node-engine reads which group.** Which group owns the operator's path is a fact
+// of the machine the controller cannot know, and the path is never changed (§2): so each read-write access
+// reaches a machine naming the identities its module's code runs as, and the node-engine reads the path's group
+// at apply and grants it to them. Two kinds of identity run a module's code here:
+//
+//   - each of its containers that mounts the path — the source of one of its volumes is the path, or below it —
+//     which gains the group as a supplementary group of its process and is recreated with it;
+//   - the account its tools run as, where it has a tools bundle the machine's runtime loads: the operator's
+//     account the runtime runs as, or the module's own account for a module served by a runtime of its own
+//     (ADR 0259 §8). That runtime names the access under its `restart-on`, so it is restarted when the access
+//     moved the account's groups, and its new process holds the group with no new login (§6).
+//
+// A read access grants nothing (§3): it is sent as before. A read-write access whose module runs nothing here is
+// sent an empty grant, so the node-engine still states it unhealthy while its group cannot write (§2).
+//
+// **Only to an engine that reads it.** An older node-engine parses strictly and refuses a whole declaration for a
+// field it does not know; the field and the restarts it brings are composed only where the engine's statement
+// says link.GrantContract or later (Rendering.GrantsGroups).
+
+// GrantField is an access's field naming who its path's group is granted to (novox/hq ADR 0312).
+const GrantField = "grant"
+
+// toolsAccount is the account module m's tools run as on this machine, or empty where they run nowhere as one:
+// no runtime here, no bundle it loads, a module left out of an adopted machine's declaration, or a runtime
+// running as root on a machine with no account.
+func (r Resolution) toolsAccount(m Manifest, with Rendering) string {
+	if !r.runtimeHere() || (with.Adopted && m.Filtering != nil) {
+		return ""
+	}
+	loads := false
+	for _, b := range m.Bundles {
+		if len(b.Loads) > 0 {
+			loads = true
+		}
+	}
+	if !loads {
+		return ""
+	}
+	if m.RunsAs != "" {
+		return m.RunsAs
+	}
+	return r.Account
+}
+
+// grantAccesses writes the grant of every read-write access of module, among the resources composed so far: the
+// module's containers that mount the access's path, and account when it is not empty. The ids of the accesses
+// that grant to account, for the runtime that runs as it to be restarted on.
+func grantAccesses(out []map[string]any, owner map[string]string, module, account string) []string {
+	var containers []map[string]any
+	for _, res := range out {
+		if res["type"] == "container" && owner[fmt.Sprint(res["id"])] == module {
+			containers = append(containers, res)
+		}
+	}
+	var toAccount []string
+	for _, res := range out {
+		if res["type"] != "access" || owner[fmt.Sprint(res["id"])] != module || res["mode"] != AccessReadWrite {
+			continue
+		}
+		path, _ := res["path"].(string)
+		grant := map[string]any{}
+		var mounting []any
+		for _, c := range containers {
+			if mounts(c, path) {
+				mounting = append(mounting, fmt.Sprint(c["id"]))
+			}
+		}
+		if len(mounting) > 0 {
+			grant["containers"] = mounting
+		}
+		if account != "" {
+			grant["account"] = account
+			toAccount = append(toAccount, fmt.Sprint(res["id"]))
+		}
+		res[GrantField] = grant
+	}
+	sort.Strings(toAccount)
+	return toAccount
+}
+
+// mounts says whether a container mounts path, or something below it, from the machine. A path that merely
+// begins with the same letters — /storage/media2 beside /storage/media — is another path. A read-only mount of a
+// read-write access still counts: the module declared the access read-write, the engine grants the group to what
+// mounts it, and a read-only mount only means that container chose not to write through it.
+func mounts(container map[string]any, path string) bool {
+	volumes, _ := container["volumes"].([]any)
+	path = filepath.Clean(path)
+	for _, v := range volumes {
+		s, ok := v.(string)
+		if !ok {
+			continue
+		}
+		source, _, _ := strings.Cut(s, ":")
+		if !strings.HasPrefix(source, "/") {
+			continue // a named volume: the runtime's, not the operator's path
+		}
+		source = filepath.Clean(source)
+		if source == path || strings.HasPrefix(source, path+"/") {
+			return true
+		}
+	}
+	return false
+}
+
+// restartOnGrants adds to a runtime process's restart-on the accesses that grant to the account it runs as, so it
+// is restarted to hold a group the account was put in or taken out of (novox/hq ADR 0312 §6).
+func restartOnGrants(process map[string]any, ids []string) {
+	if process == nil || len(ids) == 0 {
+		return
+	}
+	restarts, _ := process["restart-on"].([]any)
+	seen := map[string]bool{}
+	for _, id := range restarts {
+		seen[fmt.Sprint(id)] = true
+	}
+	for _, id := range ids {
+		if !seen[id] {
+			restarts = append(restarts, id)
+			seen[id] = true
+		}
+	}
+	process["restart-on"] = restarts
+}

internal/catalogue/grants_test.go

@@ -0,0 +1,174 @@
+package catalogue
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"github.com/novox/mesh-host/validate"
+)
+
+// Defends novox/hq ADR 0312 and issue 537 on the controller's side: each read-write access reaches the machine
+// naming who its path's group is granted to — the module's containers that mount it, and the account its tools
+// run as — and the tool runner is restarted on it; a read access grants nothing; and none of it is sent to a
+// node-engine older than the field, which would refuse the whole declaration.
+
+const anImage = "x@sha256:1111111111111111111111111111111111111111111111111111111111111111"
+
+// anImporter files into one library it writes and reads another: a container mounting both, a step mounting
+// neither, and tools served by the machine's runtime.
+func anImporter(t *testing.T) Manifest {
+	t.Helper()
+	m := aToolsModule(t, "importer", "tools/index.js")
+	m.Accesses = []Access{
+		{ID: "music", Path: "/storage/media/music", Mode: AccessReadWrite},
+		{ID: "movies", Path: "/storage/media/movies", Mode: AccessRead},
+	}
+	m.Resources = []map[string]any{
+		{"id": "app", "type": "container", "name": "importer", "image": anImage,
+			"volumes": []any{"${access:music}/incoming:/music", "${access:movies}:/movies:ro"}},
+		{"id": "sidecar", "type": "container", "name": "importer-sidecar", "image": anImage},
+	}
+	return m
+}
+
+func composeImporter(t *testing.T, r Resolution, with Rendering) map[string]map[string]any {
+	t.Helper()
+	with.Needed = map[string]map[string]string{RuntimeModule: {"broker": "sealed-credential"}}
+	with.ArtifactStore = "anchor.internal:5101"
+	out, err := r.Declaration(with)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// What the node-engine this controller pins would make of it: nothing refused.
+	body, err := json.Marshal(map[string]any{"declaration": validate.Version, "resources": out})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if problems := validate.Declaration(body); len(problems) > 0 {
+		t.Fatalf("composed into something the node-engine refuses: %v", problems)
+	}
+	return byID(out)
+}
+
+func TestAReadWriteAccessNamesTheContainersThatMountItAndTheToolsAccount(t *testing.T) {
+	r := Resolution{Node: "ace", Account: "jochen", Modules: []Manifest{anImporter(t), theRuntime(t)}}
+	got := composeImporter(t, r, Rendering{GrantsGroups: true})
+
+	music := got["importer."+AccessID("/storage/media/music")]
+	if music == nil {
+		t.Fatalf("no access resource for the library: %v", keysOf(got))
+	}
+	grant, _ := music[GrantField].(map[string]any)
+	if fmt.Sprint(grant["containers"]) != "[importer.app]" || grant["account"] != "jochen" {
+		t.Errorf("the read-write access grants %v; want the container that mounts it and the tools' account", grant)
+	}
+	// A read access grants nothing (§3).
+	if movies := got["importer."+AccessID("/storage/media/movies")]; movies[GrantField] != nil {
+		t.Errorf("a read access names a grant: %v", movies[GrantField])
+	}
+	// The tool runner is restarted when the access moved its account's groups (§6).
+	runtime := got[RuntimeModule+"."+RuntimeProcessID()]
+	found := false
+	for _, id := range runtime["restart-on"].([]any) {
+		if id == "importer."+AccessID("/storage/media/music") {
+			found = true
+		}
+	}
+	if !found {
+		t.Errorf("the tool runner is not restarted on the access that grants its account: %v", runtime["restart-on"])
+	}
+}
+
+func TestAModuleOfItsOwnAccountIsGrantedAsThatAccount(t *testing.T) {
+	m := anImporter(t)
+	m.RunsAs = "importer"
+	m.OwnSecrets = OwnSecrets{"broker": {Path: "/var/lib/mesh/importer/broker"}}
+	runtime := theRuntime(t)
+	runtime.Bundles[0].Binary = "node-tools"
+	r := Resolution{Node: "ace", Account: "jochen", Modules: []Manifest{m, runtime}}
+	with := Rendering{GrantsGroups: true}
+	with.Needed = map[string]map[string]string{RuntimeModule: {"broker": "sealed"}, "importer": {"broker": "sealed"}}
+	with.ArtifactStore = "anchor.internal:5101"
+	out, err := r.Declaration(with)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := byID(out)
+	grant, _ := got["importer."+AccessID("/storage/media/music")][GrantField].(map[string]any)
+	if grant["account"] != "importer" {
+		t.Errorf("the access grants %v; want the module's own account", grant)
+	}
+	own := got["importer."+OwnRuntimeID()]
+	if fmt.Sprint(own["restart-on"]) == "" || !restartsOnIt(own["restart-on"], "importer."+AccessID("/storage/media/music")) {
+		t.Errorf("the module's own runtime is not restarted on its access: %v", own["restart-on"])
+	}
+	if restartsOnIt(got[RuntimeModule+"."+RuntimeProcessID()]["restart-on"], "importer."+AccessID("/storage/media/music")) {
+		t.Error("the machine's runtime is restarted on an access of a module it does not serve")
+	}
+}
+
+func TestAModuleThatRunsNothingHereSendsAnEmptyGrant(t *testing.T) {
+	m := mod("spool", nil, nil, nil)
+	m.Accesses = []Access{{Path: "/storage/downloads", Mode: AccessReadWrite}}
+	out, err := Resolution{Node: "ace", Account: "jochen", Modules: []Manifest{m}}.Declaration(Rendering{GrantsGroups: true})
+	if err != nil {
+		t.Fatal(err)
+	}
+	grant, has := byID(out)["spool."+AccessID("/storage/downloads")][GrantField].(map[string]any)
+	if !has || len(grant) != 0 {
+		t.Errorf("a read-write access of a module running nothing here is sent %v (sent %v); want an empty grant, "+
+			"so its group is still judged", grant, has)
+	}
+}
+
+func TestNoGrantIsSentToAnEngineOlderThanTheField(t *testing.T) {
+	r := Resolution{Node: "ace", Account: "jochen", Modules: []Manifest{anImporter(t), theRuntime(t)}}
+	got := composeImporter(t, r, Rendering{})
+	for id, res := range got {
+		if _, has := res[GrantField]; has {
+			t.Errorf("%s names a grant to an engine that does not read it", id)
+		}
+	}
+	if restartsOnIt(got[RuntimeModule+"."+RuntimeProcessID()]["restart-on"], "importer."+AccessID("/storage/media/music")) {
+		t.Error("the tool runner is restarted on an access an older engine grants nothing for")
+	}
+}
+
+func restartsOnIt(list any, want string) bool {
+	items, _ := list.([]any)
+	for _, i := range items {
+		if fmt.Sprint(i) == want {
+			return true
+		}
+	}
+	return false
+}
+
+func keysOf(m map[string]map[string]any) []string {
+	var out []string
+	for k := range m {
+		out = append(out, k)
+	}
+	return out
+}
+
+// Only a container that mounts the access's path, or below it, is named: a path that begins with the same letters is
+// another path. A read-only mount of a read-write access is still named — the access is read-write, and the grant
+// follows what mounts it, not how.
+func TestOnlyAContainerMountingThePathIsNamedReadOnlyIncluded(t *testing.T) {
+	m := mod("library", nil, nil, nil)
+	m.Accesses = []Access{{ID: "media", Path: "/storage/media", Mode: AccessReadWrite}}
+	m.Resources = []map[string]any{
+		{"id": "beside", "type": "container", "name": "beside", "image": anImage, "volumes": []any{"/storage/media2:/x"}},
+		{"id": "reader", "type": "container", "name": "reader", "image": anImage, "volumes": []any{"${access:media}:/media:ro"}},
+	}
+	out, err := Resolution{Node: "ace", Modules: []Manifest{m}}.Declaration(Rendering{GrantsGroups: true})
+	if err != nil {
+		t.Fatal(err)
+	}
+	grant, _ := byID(out)["library."+AccessID("/storage/media")][GrantField].(map[string]any)
+	if fmt.Sprint(grant["containers"]) != "[library.reader]" {
+		t.Errorf("the access grants %v; want the read-only mount and not /storage/media2", grant)
+	}
+}

internal/catalogue/verbs.go

@@ -116,15 +116,9 @@ var ControllerVerbs = []Verb{
 			"limit":  "how many builds to list (default 20); not with log",
 		}, nil)},
 	{Name: "plans", Description: "What the last merges produced and where each stands (novox/hq ADR 0162): " +
-		"the tiers, the tier a plan is at, what it waits for and since when; one plan whole, given its id; " +
-		"or, given wait, one plan followed until it moves.",
+		"the tiers, the tier a plan is at, what it waits for and since when; one plan whole, given its id.",
 		Input: schema(map[string]string{
-			"id": "a plan's id (as `plans` lists them): that plan, tier by tier",
-			"wait": "a plan's id: wait until it moves, then answer it as data — the plan, and what ended the wait " +
-				"(moved, tier, done, or bound); ask again to follow it further (novox/hq issue 229)",
-			"until": "with wait: moved (any change, the default), tier (it reaches another tier) or done (it ends)",
-			"bound": "with wait: how long to wait at most, as 15s or seconds — 20s, the default, is the longest, " +
-				"inside what a call is answered within",
+			"id":    "a plan's id (as `plans` lists them): that plan, tier by tier",
 			"stop":  "a plan's id: stop it — what was asked still builds, nothing further is asked",
 			"close": "a plan's id: close a plan that will not move again, as failed by hand (novox/hq issue 254)",
 			"retry": "a failed plan's id: ask its failed builds again under new ids, and carry the plan on from that tier (novox/hq ADR 0219)",

internal/link/calls.go

@@ -601,24 +601,6 @@ func Acknowledge(ctx context.Context) {
 	}
 }
 
-// LongestAnswer is the longest a handler that waits on purpose may hold its caller's one answer
-// (AnswersWithin, novox/hq issue 229): inside the console's thirty seconds with room for the trip back,
-// and inside the bus's window for an answer (broker.ResponseTTL). A variable so a test need not wait.
-var LongestAnswer = 25 * time.Second
-
-type answerWithinKey struct{}
-
-// AnswersWithin asks that the call's caller be answered in full if the handler ends within d of the
-// call's start, rather than within AnswerWithin: for a handler that waits on purpose, with a bound —
-// `plans` waiting for a plan to move (novox/hq issue 229). Past d, or past LongestAnswer whichever is
-// shorter, its caller is told it is running, as for any call. Never shortens the window; without effect
-// outside a served call, and once the caller was answered.
-func AnswersWithin(ctx context.Context, d time.Duration) {
-	if f, ok := ctx.Value(answerWithinKey{}).(func(time.Duration)); ok {
-		f(d)
-	}
-}
-
 // running is the interim answer: what a caller reads when the call has not finished.
 func running(c *Call, within time.Duration, acknowledged bool, follow string) []byte {
 	why := fmt.Sprintf("it has not finished in %s", within)
@@ -663,13 +645,6 @@ func (l *CallLog) serveCallWithin(seat, verb string, args json.RawMessage, reply
 	acknowledged := make(chan struct{})
 	var once sync.Once
 	ctx = context.WithValue(ctx, answerNowKey{}, func() { once.Do(func() { close(acknowledged) }) })
-	longer := make(chan time.Duration, 1)
-	ctx = context.WithValue(ctx, answerWithinKey{}, func(d time.Duration) {
-		select {
-		case longer <- d:
-		default:
-		}
-	})
 
 	type outcome struct {
 		body   []byte
@@ -728,29 +703,17 @@ func (l *CallLog) serveCallWithin(seat, verb string, args json.RawMessage, reply
 			}
 		}
 	}
-	within, start := AnswerWithin, time.Now()
-	timer := time.NewTimer(within)
+	timer := time.NewTimer(AnswerWithin)
 	defer timer.Stop()
-waiting:
-	for {
-		select {
-		case o := <-done:
-			l.finish(c, o.body, o.failed, false)
-			say(o.body)
-			return
-		case <-acknowledged:
-			say(running(c, within, true, l.Follow))
-			break waiting
-		case d := <-longer:
-			// A handler waiting on purpose (AnswersWithin): its window is stretched, never past LongestAnswer.
-			if d = min(d, LongestAnswer); d > within {
-				within = d
-				timer.Reset(time.Until(start.Add(d)))
-			}
-		case <-timer.C:
-			say(running(c, within, false, l.Follow))
-			break waiting
-		}
+	select {
+	case o := <-done:
+		l.finish(c, o.body, o.failed, false)
+		say(o.body)
+		return
+	case <-acknowledged:
+		say(running(c, AnswerWithin, true, l.Follow))
+	case <-timer.C:
+		say(running(c, AnswerWithin, false, l.Follow))
 	}
 	o := <-done
 	l.finish(c, o.body, o.failed, true)

internal/link/calls_wait_test.go

@@ -1,55 +0,0 @@
-package link
-
-import (
-	"context"
-	"encoding/json"
-	"testing"
-	"time"
-)
-
-// **A handler that waits on purpose is answered in full when it ends inside the window it asked for**
-// (novox/hq issue 229): `plans` asked to wait for a plan holds its caller's one answer until the plan
-// moves or its bound passes, rather than being answered "still running" at AnswerWithin.
-func TestAHandlerThatWaitsOnPurposeIsAnsweredInFullInsideItsWindow(t *testing.T) {
-	shortWindow(t, 20*time.Millisecond)
-	l, a := NewCallLog(), newAnswers(t)
-	l.serveCall("mesh-controller", "plans", json.RawMessage(`{"wait":"plan-1"}`), "_INBOX.x.3",
-		func(ctx context.Context, _ json.RawMessage) (any, error) {
-			AnswersWithin(ctx, 200*time.Millisecond)
-			time.Sleep(80 * time.Millisecond) // past AnswerWithin, inside what it asked for
-			return "plan-1 moved", nil
-		}, a.respond, nil)
-	if got := a.only()["result"]; got != "plan-1 moved" {
-		t.Fatalf("a waiting handler inside its window was answered %v, not in full", got)
-	}
-}
-
-// What a handler may ask for is bounded: past LongestAnswer its caller is told it is running, as any
-// call is, so no answer is ever later than the console waits.
-func TestAWaitIsNeverLongerThanTheLongestAnswer(t *testing.T) {
-	shortWindow(t, 10*time.Millisecond)
-	was := LongestAnswer
-	LongestAnswer = 30 * time.Millisecond
-	t.Cleanup(func() { LongestAnswer = was })
-	l, a := NewCallLog(), newAnswers(t)
-	release := make(chan struct{})
-	finished := make(chan struct{})
-	go func() {
-		l.serveCall("mesh-controller", "plans", nil, "_INBOX.x.4", func(ctx context.Context, _ json.RawMessage) (any, error) {
-			AnswersWithin(ctx, time.Hour)
-			<-release
-			return "late", nil
-		}, a.respond, nil)
-		close(finished)
-	}()
-	select {
-	case <-a.sent:
-	case <-time.After(2 * time.Second):
-		t.Fatal("a handler asking for an hour held its caller past LongestAnswer")
-	}
-	if got, _ := a.only()["result"].(map[string]any); got["running"] != true {
-		t.Fatalf("past LongestAnswer the caller was answered %v, not that it is running", a.only())
-	}
-	close(release)
-	<-finished
-}

internal/link/protocol.go

@@ -436,6 +436,12 @@ const ReadinessContract = 2
 // parses strictly and would refuse the whole declaration for it.
 const RootContract = 3
 
+// GrantContract is the statement of an engine that also reads an access's `grant` (novox/hq ADR 0312): it grants a
+// read-write access's path group to the containers and the account the grant names, takes it back, and states the
+// access unhealthy while the group cannot write. Only to such an engine is the field sent: an older one parses
+// strictly and would refuse the whole declaration for it.
+const GrantContract = 4
+
 // ReasonRoot starts the reason of an account verdict that found a way to root (ADR 0266); the node-engine's
 // own words (mesh-host internal/accounts ReasonRoot).
 const ReasonRoot = "can become root without a person"
@@ -487,6 +493,11 @@ const KindAccount = "account"
 // ReasonUsedAsFound.
 const KindDirectory = "directory"
 
+// KindAccess is a read-write access that grants its path's group (novox/hq ADR 0312): healthy while the group may
+// write the path, unhealthy while it cannot — the operator's to decide, since the mesh changes nothing on the path
+// — or while the path is owned by a group that is never granted. The node-engine's own (mesh-host internal/link).
+const KindAccess = "access"
+
 // ReasonUsedAsFound starts the reason of a directory used as found.
 const ReasonUsedAsFound = "used as found:"
 

testdata/beside/CAPTURED

@@ -8,7 +8,7 @@ private addresses. That is acceptable while mesh-controller is private; if it ev
 a second place to clean besides the catalogue itself.
 
 mesh-catalog  b9de001833b1b61b297182b8e3bcdae1cbdeace9  modules/*/module.json, modules/nats/Dockerfile
-mesh-host     a76baa4b47f07a8b2bab065603414530bd02b53a  examples/foundation-first-node-nats.lock
+mesh-host     3f7f797168d33ec22241bdd6ef2c64de86eea914  examples/foundation-first-node-nats.lock
 mesh-sdk      33917f91ac3cc213b879b32f3c70e2aa70395f98  conformance/events/module-event.json
 
 To move them, from this repository's root, with the two repositories checked out beside it:

testdata/store-tests

@@ -7,7 +7,6 @@
 ./cmd/mesh-controller TestAStopNamesWhatStaysOnTheMachinesAndWhatStillCarriesIt
 ./cmd/mesh-controller TestAStopWithoutAMergeLeavesItOutOfABatch
 ./cmd/mesh-controller TestSavingPlansAndMovingMergesIsOneAct
-./cmd/mesh-controller TestAPlanFollowedFromTheStoreAnswersWhenItMoves
 ./internal/inventory TestTheLastSendSaysWhatTheMachineAnswered
 ./internal/inventory TestAReportIsTheLastSendsAnswerOnlyWhenItIsAboutThatSend
 ./cmd/mesh-controller TestNodeShowAndStatusReadTheLastSendFromTheStore

vendor/github.com/novox/mesh-host/internal/declaration/declaration.go

@@ -464,6 +464,35 @@ type Access struct {
 	Path string `json:"path"`
 	// Mode is how this module reaches the path: read or read-write. Absent narrows to read.
 	Mode string `json:"mode,omitempty"`
+
+	// Grant is who the path's own group is granted to, for a read-write access (novox/hq ADR 0312 §1): the
+	// identities the module's code runs as. The controller says who; the node-engine reads which group owns
+	// the path when it applies, because only the machine knows, and never changes the path (§2). Absent is a
+	// controller older than the grant, or an access that grants nothing — and a read access always is one (§3).
+	Grant *AccessGrant `json:"grant,omitempty"`
+}
+
+// AccessGrant is the identities a read-write access grants its path's group to (novox/hq ADR 0312 §1).
+type AccessGrant struct {
+	// Containers are the module's containers that mount the path, by id: each is created with the group as a
+	// supplementary group of its process, and recreated when the group moves (§6).
+	Containers []string `json:"containers,omitempty"`
+	// Account is the account that runs the module's tools: put in the group as an account group, as ADR 0252
+	// §1 puts one, and taken out again as §3 takes back (§5). Empty for a module whose code runs nowhere as
+	// an account.
+	Account string `json:"account,omitempty"`
+}
+
+// UnmarshalJSON reads a grant as strictly as a resource is read: a field the engine does not know is a
+// thing the controller believes it asked for, and is refused rather than ignored.
+func (g *AccessGrant) UnmarshalJSON(raw []byte) error {
+	type plain AccessGrant
+	var p plain
+	if err := strictDecode(raw, &p); err != nil {
+		return fmt.Errorf("a grant: %w", err)
+	}
+	*g = AccessGrant(p)
+	return nil
 }
 
 func (a *Access) Identity() string { return a.ID }
@@ -482,6 +511,24 @@ func (a *Access) validate(where string, _ bool) []string {
 		problems = append(problems, fmt.Sprintf(
 			"%s: an access is %q or %q, not %q", where, AccessRead, AccessReadWrite, a.Mode))
 	}
+	if a.Grant != nil && a.Mode != AccessReadWrite {
+		// A read access reads as any account may, and gains no group (novox/hq ADR 0312 §3).
+		problems = append(problems, where+": a read access grants nothing, and this one names a grant; "+
+			"only a read-write access grants its path's group (novox/hq ADR 0312 §3)")
+	}
+	if a.Grant != nil {
+		for _, id := range a.Grant.Containers {
+			if id == "" {
+				problems = append(problems, where+": a grant names a container with no id")
+			}
+		}
+		if a.Grant.Account != "" && !accountName.MatchString(a.Grant.Account) {
+			// Handed to id, usermod and gpasswd as an argument: a name starting with a dash would be read as an
+			// option by each of them.
+			problems = append(problems, fmt.Sprintf("%s: a grant's account is an account's name — letters, digits, "+
+				"dots, underscores and dashes, not starting with a dash — and %q is not one", where, a.Grant.Account))
+		}
+	}
 	return problems
 }
 
@@ -1668,6 +1715,7 @@ func parse(raw []byte, allowActions bool) (*Declaration, error) {
 		d.Resources = append(d.Resources, resource)
 	}
 	problems = append(problems, checkWhileStopped(d.Resources)...)
+	problems = append(problems, checkGrants(d.Resources)...)
 	problems = append(problems, checkAdoption(env.Adoption, d.Resources, allowActions)...)
 	problems = append(problems, checkReplaces(d.Resources)...)
 	if env.Adoption == nil {
@@ -1732,6 +1780,36 @@ func checkWhileStopped(resources []Resource) []string {
 	return problems
 }
 
+// accountName is what a grant's account may be: the portable account name the user tools take, optionally ending
+// in `$`, never starting with a dash.
+var accountName = regexp.MustCompile(`^[A-Za-z0-9_.][A-Za-z0-9_.-]*\$?$`)
+
+// checkGrants judges each access's grant against the whole declaration (novox/hq ADR 0312): a container it
+// names is a container of this declaration, as a maintenance window's are. A grant to a container the machine
+// is not told about would be a group given to nothing, said as granted.
+func checkGrants(resources []Resource) []string {
+	containers := map[string]bool{}
+	for _, r := range resources {
+		if r.Kind() == TypeContainer {
+			containers[r.Identity()] = true
+		}
+	}
+	var problems []string
+	for _, r := range resources {
+		a, ok := r.(*Access)
+		if !ok || a.Grant == nil {
+			continue
+		}
+		for _, id := range a.Grant.Containers {
+			if id != "" && !containers[id] {
+				problems = append(problems, fmt.Sprintf("resource %q: its grant names %q, and this declaration "+
+					"has no container by that id", a.ID, id))
+			}
+		}
+	}
+	return problems
+}
+
 func strictDecode(raw []byte, into any) error {
 	// DisallowUnknownFields is the whole point rather than strictness for its own sake: a
 	// field the host does not know is a thing the control plane believes it asked for.

vendor/modules.txt

@@ -78,7 +78,7 @@ github.com/nats-io/nkeys
 # github.com/nats-io/nuid v1.0.1
 ## explicit
 github.com/nats-io/nuid
-# github.com/novox/mesh-host v0.0.0 => git.novox.be/novox/mesh-host v0.0.0-20261011092230-20d5af9b2d5f
+# github.com/novox/mesh-host v0.0.0 => git.novox.be/novox/mesh-host v0.0.0-20261012112256-3f7f797168d3
 ## explicit; go 1.26.0
 github.com/novox/mesh-host/internal/declaration
 github.com/novox/mesh-host/rootsearch
@@ -135,4 +135,4 @@ golang.org/x/text/width
 # golang.org/x/time v0.15.0
 ## explicit; go 1.25.0
 golang.org/x/time/rate
-# github.com/novox/mesh-host => git.novox.be/novox/mesh-host v0.0.0-20261011092230-20d5af9b2d5f
+# github.com/novox/mesh-host => git.novox.be/novox/mesh-host v0.0.0-20261012112256-3f7f797168d3