Say an account without its time as age unknown, not as two thousand years (issue 160)

The architecture and kernel a machine reported were kept and read by nothing, and the facts the
node-engine now says (memory, filesystems, processor, distribution, virtual or physical, uptime,
timezone) would have joined them. node shows every one in one block with the age of the account,
and a fact the machine could not determine as unknown with its why, never as a zero.

.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/machine_lines.go

@@ -0,0 +1,135 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/novox/mesh-controller/internal/inventory"
+)
+
+// machineLines is what a machine said it is made of (novox/hq issue 160), as `node` shows it: every fact in
+// one block with its age, the architecture and kernel the profile always carried among them, and each fact
+// the machine could not determine said as unknown with its why — never as a zero, and never left out.
+func machineLines(a inventory.MachineAccount, had bool, now time.Time) []string {
+	if !had {
+		return []string{"  what it is made of: never said — this machine has not reported a profile"}
+	}
+	m := a.Machine
+	if m == nil {
+		return []string{
+			"  what it is made of: not said — its node-engine is older than the one that says it",
+			"    " + factLine("architecture", orUnsaid(a.Architecture)),
+			"    " + factLine("kernel", orUnsaid(a.Kernel)),
+		}
+	}
+	age := roughly(now.Sub(m.ObservedAt)) + " ago"
+	if m.ObservedAt.IsZero() {
+		// Said with no time: its age is not known, and is never read as two thousand years.
+		age = "at a time it did not say (age unknown)"
+	}
+	out := []string{fmt.Sprintf("  what it is made of, as it said %s:", age)}
+	add := func(name, value string) { out = append(out, "    "+factLine(name, value)) }
+	unknown := map[string]string{}
+	for k, v := range m.Unknown {
+		unknown[k] = v
+	}
+	// said is the value, or the fact's own reason it is unknown; a fact neither said nor unknown is a
+	// node-engine that broke its own rule, and is said so rather than shown blank.
+	said := func(fact, value string) string {
+		if value != "" {
+			delete(unknown, fact)
+			return value
+		}
+		if why, ok := unknown[fact]; ok {
+			delete(unknown, fact)
+			return "unknown: " + why
+		}
+		return "unknown: the machine said neither it nor why"
+	}
+
+	add("architecture", orUnsaid(a.Architecture))
+	release := said("kernel release", m.KernelRelease)
+	if m.KernelRelease == "" {
+		release = "(release " + release + ")"
+	}
+	add("kernel", orUnsaid(a.Kernel)+" "+release)
+	dist := said("distribution", m.Distribution)
+	if m.Distribution != "" {
+		dist += " " + said("version", m.Version)
+	}
+	add("distribution", dist)
+	add("processor", said("processor", m.Processor))
+	add("cores", said("cores", countWords(m.Cores)))
+	add("threads", said("threads", countWords(m.Threads)))
+	add("memory", said("memory", bytesWords(m.MemoryBytes)))
+	add("virtual", said("virtual or physical", m.Virtual))
+	up := ""
+	if m.BootedAt != nil {
+		up = fmt.Sprintf("%s, since %s", roughly(now.Sub(*m.BootedAt)), m.BootedAt.Local().Format("2006-01-02 15:04"))
+	}
+	add("up", said("uptime", up))
+	add("timezone", said("timezone", m.Timezone))
+	if len(m.Filesystems) == 0 {
+		add("filesystems", said("filesystems", ""))
+	} else {
+		for i, f := range m.Filesystems {
+			name := ""
+			if i == 0 {
+				name = "filesystems"
+			}
+			add(name, fmt.Sprintf("%s  %s, %s free (%s %s)", f.Mount, bytesWords(f.SizeBytes),
+				bytesWords(f.FreeBytes), f.Type, f.Device))
+		}
+		if why, ok := unknown["filesystems"]; ok {
+			add("", "and some unknown: "+why)
+			delete(unknown, "filesystems")
+		}
+	}
+	add("public address", said("public address", ""))
+	// Any other fact a newer node-engine named unknown, so nothing it said is dropped.
+	rest := make([]string, 0, len(unknown))
+	for k := range unknown {
+		rest = append(rest, k)
+	}
+	sort.Strings(rest)
+	for _, k := range rest {
+		add(k, "unknown: "+unknown[k])
+	}
+	return out
+}
+
+func factLine(name, value string) string { return fmt.Sprintf("%-15s %s", name, value) }
+
+func orUnsaid(s string) string {
+	if strings.TrimSpace(s) == "" {
+		return "not said"
+	}
+	return s
+}
+
+// countWords is a number a machine said, or nothing when it said none (its unknown says why).
+func countWords(n int) string {
+	if n <= 0 {
+		return ""
+	}
+	return fmt.Sprint(n)
+}
+
+// bytesWords is an amount of bytes a person reads, in binary units; nothing when none was said.
+func bytesWords(n int64) string {
+	if n <= 0 {
+		return ""
+	}
+	units := []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB"}
+	v, u := float64(n), 0
+	for v >= 1024 && u < len(units)-1 {
+		v /= 1024
+		u++
+	}
+	if u == 0 {
+		return fmt.Sprintf("%d B", n)
+	}
+	return fmt.Sprintf("%.1f %s", v, units[u])
+}

cmd/mesh-controller/machine_lines_test.go

@@ -0,0 +1,88 @@
+package main
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/novox/mesh-controller/internal/inventory"
+)
+
+// Defends novox/hq issue 160: `node` shows every fact a machine said it is made of, in one block with its
+// age, the architecture and kernel among them; and a fact it could not determine as unknown with why.
+func TestNodeShowsWhatAMachineIsMadeOfWithItsAge(t *testing.T) {
+	now := time.Date(2026, 10, 12, 15, 0, 0, 0, time.UTC)
+	booted := now.Add(-75 * time.Hour)
+	a := inventory.MachineAccount{Architecture: "amd64", Kernel: "linux", Machine: &inventory.MadeOf{
+		ObservedAt: now.Add(-3 * time.Hour), KernelRelease: "7.2.8-arch1-2", Distribution: "Arch Linux",
+		Version: "rolling", Processor: "AMD Ryzen 9 8945HS", Cores: 8, Threads: 16, MemoryBytes: 32891494400,
+		Virtual: "physical", BootedAt: &booted, Timezone: "Europe/Brussels",
+		Filesystems: []inventory.MountedFilesystem{{Mount: "/", Device: "/dev/nvme0n1p3", Type: "ext4",
+			SizeBytes: 987978522624, FreeBytes: 31830110208}},
+		Unknown: map[string]string{"public address": "how it learns it is not decided yet"},
+	}}
+	got := strings.Join(machineLines(a, true, now), "\n")
+	t.Log("\n" + got)
+	for _, want := range []string{
+		"what it is made of, as it said 3h ago:",
+		"architecture    amd64",
+		"kernel          linux 7.2.8-arch1-2",
+		"distribution    Arch Linux rolling",
+		"processor       AMD Ryzen 9 8945HS",
+		"cores           8",
+		"threads         16",
+		"memory          30.6 GiB",
+		"virtual         physical",
+		"up              3d, since",
+		"timezone        Europe/Brussels",
+		"filesystems     /  920.1 GiB, 29.6 GiB free (ext4 /dev/nvme0n1p3)",
+		"public address  unknown: how it learns it is not decided yet",
+	} {
+		if !strings.Contains(got, want) {
+			t.Errorf("missing %q", want)
+		}
+	}
+}
+
+func TestAFactAMachineCouldNotReadIsShownUnknownNeverZero(t *testing.T) {
+	now := time.Date(2026, 10, 12, 15, 0, 0, 0, time.UTC)
+	a := inventory.MachineAccount{Architecture: "arm64", Kernel: "linux", Machine: &inventory.MadeOf{
+		ObservedAt: now, Unknown: map[string]string{"memory": "MemTotal not found in /proc/meminfo",
+			"cores": "/proc/cpuinfo says no core id", "kernel release": "permission denied"}}}
+	got := strings.Join(machineLines(a, true, now), "\n")
+	t.Log("\n" + got)
+	for _, want := range []string{
+		"memory          unknown: MemTotal not found in /proc/meminfo",
+		"cores           unknown: /proc/cpuinfo says no core id",
+		"kernel          linux (release unknown: permission denied)",
+		// Neither said nor named unknown: the node-engine broke its rule, and that is shown.
+		"timezone        unknown: the machine said neither it nor why",
+	} {
+		if !strings.Contains(got, want) {
+			t.Errorf("missing %q", want)
+		}
+	}
+	if strings.Contains(got, " 0 ") || strings.Contains(got, "0 B") {
+		t.Error("a fact the machine could not read was shown as a zero")
+	}
+}
+
+func TestAnOlderNodeEngineStillShowsArchitectureAndKernel(t *testing.T) {
+	got := strings.Join(machineLines(inventory.MachineAccount{Architecture: "amd64", Kernel: "linux"}, true,
+		time.Now()), "\n")
+	if !strings.Contains(got, "older than the one that says it") || !strings.Contains(got, "architecture    amd64") ||
+		!strings.Contains(got, "kernel          linux") {
+		t.Errorf("%s", got)
+	}
+	if got := strings.Join(machineLines(inventory.MachineAccount{}, false, time.Now()), "\n"); !strings.Contains(got, "never said") {
+		t.Errorf("%s", got)
+	}
+}
+
+func TestAnAccountWithoutItsTimeSaysAgeUnknown(t *testing.T) {
+	got := machineLines(inventory.MachineAccount{Architecture: "amd64", Kernel: "linux",
+		Machine: &inventory.MadeOf{KernelRelease: "7.2"}}, true, time.Now())[0]
+	if !strings.Contains(got, "age unknown") || strings.Contains(got, "d ago") {
+		t.Errorf("%s", got)
+	}
+}

cmd/mesh-controller/nodes.go

@@ -875,6 +875,17 @@ func showNode(ctx context.Context, stored *stores, name string) error {
 		}
 	}
 
+	// What it is made of, in one block with its age (novox/hq issue 160): collected and shown in the same
+	// breath, so no fact the machine says is kept and read by nothing.
+	if account, had, err := inv.MachineOf(ctx, name); err != nil {
+		fmt.Printf("\n  what it is made of could NOT be read: %v\n", err)
+	} else {
+		fmt.Println()
+		for _, line := range machineLines(account, had, time.Now()) {
+			fmt.Println(line)
+		}
+	}
+
 	held, err := inv.Profile(ctx, name)
 	if err != nil {
 		return err

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/seats.go

@@ -34,10 +34,8 @@ type seatRow struct {
 	Delivers string `json:"delivers,omitempty"`
 	Decision string `json:"decision"`
 	// Replicated says the seat may be held on several machines at once (novox/hq ADR 0223).
-	Replicated bool `json:"replicated,omitempty"`
-	// Paths are the paths on its machine the seat's holder owns (novox/hq ADR 0287).
-	Paths   []catalogue.SeatPath `json:"paths,omitempty"`
-	Holders []seatHolder         `json:"holders"`
+	Replicated bool         `json:"replicated,omitempty"`
+	Holders    []seatHolder `json:"holders"`
 }
 
 // seatsHeld is every seat the mesh defines with its holders, and every claim held that names no
@@ -51,7 +49,7 @@ func seatsHeld(seats []catalogue.Seat, held []catalogue.Held) ([]seatRow, []cata
 	rows := make([]seatRow, 0, len(seats))
 	for _, s := range seats {
 		row := seatRow{Seat: s.Name, Scope: s.Scope, Delivers: s.Delivers, Decision: s.Decision,
-			Replicated: s.Replicated, Paths: s.Paths, Holders: []seatHolder{}}
+			Replicated: s.Replicated, Holders: []seatHolder{}}
 		seen := map[seatHolder]bool{}
 		for _, h := range held {
 			// Resolve the held claim to a seat rather than comparing names, so a record naming a
@@ -257,16 +255,12 @@ func seatsCommand(ctx context.Context, args []string) error {
 		return err
 	}
 	rows, outside := seatsHeld(catalogue.Seats(), world.Held)
-	// Which module owns each seat's path on each machine (novox/hq ADR 0287): the seat naming it, and
-	// that seat's holder there, with the stepping back applied.
-	owners := catalogue.PathOwners(catalogue.Seats(), world.Held)
 
 	if *asJSON {
 		out := struct {
-			Seats   []seatRow             `json:"seats"`
-			Owners  []catalogue.PathOwner `json:"path-owners,omitempty"`
-			Outside []catalogue.Held      `json:"outside,omitempty"`
-		}{rows, owners, outside}
+			Seats   []seatRow        `json:"seats"`
+			Outside []catalogue.Held `json:"outside,omitempty"`
+		}{rows, outside}
 		body, err := json.MarshalIndent(out, "", "  ")
 		if err != nil {
 			return err
@@ -276,7 +270,7 @@ func seatsCommand(ctx context.Context, args []string) error {
 	}
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
-	fmt.Fprintln(w, "SEAT\tSCOPE\tDELIVERS\tPATHS\tHELD BY")
+	fmt.Fprintln(w, "SEAT\tSCOPE\tDELIVERS\tHELD BY")
 	for _, r := range rows {
 		delivers := r.Delivers
 		if delivers == "" {
@@ -290,22 +284,11 @@ func seatsCommand(ctx context.Context, args []string) error {
 			}
 			holders = strings.Join(parts, ", ")
 		}
-		fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", r.Seat, r.Scope, delivers, seatPathsText(r.Paths), holders)
+		fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", r.Seat, r.Scope, delivers, holders)
 	}
 	if err := w.Flush(); err != nil {
 		return err
 	}
-	if len(owners) > 0 {
-		fmt.Println("\nwho owns each seat's path, by machine (novox/hq ADR 0287):")
-		w = tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
-		fmt.Fprintln(w, "PATH\tMACHINE\tSEAT\tMODULE")
-		for _, o := range owners {
-			fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", o.Path, o.Node, o.Seat, o.Module)
-		}
-		if err := w.Flush(); err != nil {
-			return err
-		}
-	}
 	if len(outside) > 0 {
 		fmt.Println("\nheld, and not a seat this mesh defines (registered before the set closed — novox/hq ADR 0110):")
 		for _, h := range outside {
@@ -314,19 +297,3 @@ func seatsCommand(ctx context.Context, args []string) error {
 	}
 	return nil
 }
-
-// seatPathsText is a seat's paths in one column: each path, and the seat it steps back for, if any.
-func seatPathsText(paths []catalogue.SeatPath) string {
-	if len(paths) == 0 {
-		return "—"
-	}
-	parts := make([]string, 0, len(paths))
-	for _, p := range paths {
-		if p.StepsBackFor != "" {
-			parts = append(parts, p.Path+" (steps back for "+p.StepsBackFor+")")
-			continue
-		}
-		parts = append(parts, p.Path)
-	}
-	return strings.Join(parts, ", ")
-}

cmd/mesh-controller/seats_test.go

@@ -74,22 +74,3 @@ func TestAKindedBenchIsNotHandedOver(t *testing.T) {
 		}
 	}
 }
-
-// The listing shows each seat's paths, and the seat a path steps back for (novox/hq ADR 0287).
-func TestTheSeatsListingShowsEachSeatsPaths(t *testing.T) {
-	rows, _ := seatsHeld(catalogue.Seats(), nil)
-	got := map[string]string{}
-	for _, r := range rows {
-		got[r.Seat] = seatPathsText(r.Paths)
-	}
-	for seat, want := range map[string]string{
-		"node-hostname":      "/etc/hosts, /etc/hostname",
-		"node-uplink":        "/etc/resolv.conf (steps back for node-resolver)",
-		"node-resolver":      "/etc/resolv.conf",
-		"node-packet-filter": "—",
-	} {
-		if got[seat] != want {
-			t.Errorf("%s lists its paths as %q, not %q", seat, got[seat], want)
-		}
-	}
-}

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/node_resolver.go

@@ -1,7 +1,5 @@
 package catalogue
 
-import "path"
-
 // The machine's own resolver (novox/hq ADR 0247).
 //
 // **Most machines have none.** Every machine lists the mesh's resolvers in /etc/resolv.conf and nothing
@@ -68,39 +66,43 @@ func holdsSeat(m Manifest, seat string) bool {
 	return false
 }
 
-// stepsBack is the module as it composes among the modules of one machine (novox/hq ADR 0287,
-// ADR 0247):
-// **where it holds a seat that names a path stepping back for another seat, and that other seat's holder
-// is on the machine and declares the path, its own rendering of the path is left out**, and nothing else
-// of it changes. Only a file the mesh renders for it steps back, as before: a resource on the path is
-// composed as declared (the declaration copies a module's resources whole), so an uplink holder declaring
-// the resolver file as a resource beside the resolver's holder is two owners of one path, and refused. The stepping back is the seat's definition — node-uplink stepping back from the resolver
-// file for node-resolver — so any other module declaring the path beside the owner's is still two owners
-// of one path, and is refused as before.
-func stepsBack(m Manifest, modules []Manifest) Manifest {
-	drop := map[string]bool{}
-	for _, c := range m.Claims {
-		seat, known := SeatNamed(c.Name)
-		if !known {
-			continue
-		}
-		for _, p := range seat.Paths {
-			if p.StepsBackFor == "" {
-				continue
-			}
-			for _, o := range modules {
-				if o.Module != m.Module && holdsSeat(o, p.StepsBackFor) && declaresPath(o, p.Path) {
-					drop[p.Path] = true
-				}
-			}
+// rendersResolverFile says whether a module asks the mesh to render the machine's resolver file.
+func rendersResolverFile(m Manifest) bool {
+	for _, f := range m.Facts {
+		if !f.Home && f.Path == ResolverFile {
+			return true
 		}
 	}
-	if len(drop) == 0 {
+	return false
+}
+
+// ResolverFileOwner is the module that writes the machine's resolver file among the modules on one
+// machine (novox/hq ADR 0247): the holder of node-resolver when one renders it, else nobody is named here
+// and the file is whoever's it always was — the uplink holder's (ADR 0223).
+func ResolverFileOwner(modules []Manifest) string {
+	for _, m := range modules {
+		if holdsSeat(m, ResolverSeat) && rendersResolverFile(m) {
+			return m.Module
+		}
+	}
+	return ""
+}
+
+// stepsBack is the module as it composes on a machine whose resolver file is the node-resolver holder's:
+// **the uplink holder's rendering of that file is left out**, and nothing else of it changes. Only the
+// uplink's holder steps back — any other module rendering the file beside the resolver's is still two
+// owners of one path, and is refused as before.
+func stepsBack(m Manifest, modules []Manifest) Manifest {
+	if !holdsSeat(m, "node-uplink") || !rendersResolverFile(m) {
+		return m
+	}
+	owner := ResolverFileOwner(modules)
+	if owner == "" || owner == m.Module {
 		return m
 	}
 	facts := make(map[string]RosterFile, len(m.Facts))
 	for name, f := range m.Facts {
-		if !f.Home && drop[path.Clean(f.Path)] {
+		if !f.Home && f.Path == ResolverFile {
 			continue
 		}
 		facts[name] = f
@@ -111,6 +113,9 @@ func stepsBack(m Manifest, modules []Manifest) Manifest {
 
 // steppedBack is every module of one machine as it composes there (stepsBack, each).
 func steppedBack(modules []Manifest) []Manifest {
+	if ResolverFileOwner(modules) == "" {
+		return modules
+	}
 	out := make([]Manifest, len(modules))
 	for i, m := range modules {
 		out[i] = stepsBack(m, modules)

internal/catalogue/resolve.go

@@ -957,9 +957,7 @@ func checkResources(modules []Manifest) []string {
 	// Judged as the machine composes them: where the node-resolver holder writes the resolver file, the
 	// uplink holder's rendering of it is not composed, so it is not a second owner (novox/hq ADR 0247).
 	modules = steppedBack(modules)
-	// And only a claimant of a seat naming a path declares it — the controller's generated resources
-	// included, which are judged here at composition (novox/hq ADR 0287).
-	problems := seatPathsOnMachine(modules)
+	var problems []string
 	owner := map[string]string{}
 	ownedPath := map[string]string{} // path → owning module, for the access check below
 	packagePresent, packageAbsent := map[string][]string{}, map[string][]string{}

internal/catalogue/seat_paths.go

@@ -1,315 +0,0 @@
-package catalogue
-
-import (
-	"fmt"
-	"path"
-	"strings"
-)
-
-// The paths a seat's holder owns (novox/hq ADR 0287).
-//
-// **Who owns a machine-wide file is the role's question, answered once.** Until this, which module owned
-// /etc/hosts or /etc/resolv.conf was decided record by record (ADRs 0199, 0222, 0223, 0241) and enforced
-// only after the fact, by checkResources finding two modules on one machine declaring the same path: a
-// module that did not hold node-hostname could declare /etc/hosts on a machine where nobody held it, and
-// nothing refused it. Now a seat's definition names the paths the role owns on any machine, and three
-// refusals follow from it, each where the mesh can still say no:
-//
-//   - a claim whose module does not declare every path its seat names, by CanHold, at registration and at
-//     handover;
-//   - a module declaring a path a seat names while claiming none of the seats that name it, at
-//     registration (CatalogueProblems), and what the controller generates for a machine, at composition;
-//   - a module's own seat naming a path another seat already names, at registration — the second loses.
-//
-// Reading a seat's path is access, never a resource, so it stays allowed.
-
-// SeatPath is one path a seat's holder owns: absolute, literal, on the machine where the holder runs.
-type SeatPath struct {
-	Path string `json:"path"`
-	// StepsBackFor is a node seat whose holder owns the path instead, on a machine where that seat is held
-	// (novox/hq ADR 0287, ADR 0247): this seat's holder still declares the path, and its declaration is not
-	// composed there. Only the mesh's own seats step back, each by a record.
-	StepsBackFor string `json:"steps-back-for,omitempty"`
-}
-
-// seatPathProblem is what is wrong with one path a seat names, judged alone: absolute, written literally
-// with no placeholder, and clean, so it compares with what a module declares byte for byte.
-func seatPathProblem(seat, scope, p string) string {
-	switch {
-	case scope != ScopeNode:
-		return fmt.Sprintf("the seat %s names the path %q and is a %s seat; only a node seat names paths, "+
-			"because a path is a machine's (novox/hq ADR 0287)", seat, p, scope)
-	case strings.Contains(p, "${"):
-		return fmt.Sprintf("the seat %s names the path %q, which has a placeholder; a seat's path is written "+
-			"literally (novox/hq ADR 0287)", seat, p)
-	case !strings.HasPrefix(p, "/") || path.Clean(p) != p:
-		return fmt.Sprintf("the seat %s names the path %q, which is not a clean absolute path (novox/hq ADR 0287)",
-			seat, p)
-	case path.Dir(p) == "/":
-		// The root or a top-level directory is every role's, never one role's own (ADR 0287).
-		return fmt.Sprintf("the seat %s names the path %q, the root or a top-level directory, which no one "+
-			"role owns (novox/hq ADR 0287)", seat, p)
-	}
-	return ""
-}
-
-// SeatPathProblems is what is wrong with the paths a set of the mesh's own seats names (novox/hq ADR
-// 0287): only a node seat names one, each absolute and literal; every path has exactly one seat naming it
-// without stepping back; and a seat steps back only for another node seat naming the same path without
-// stepping back, so the stepping back cannot cycle.
-func SeatPathProblems(set []Seat) []string {
-	var problems []string
-	owners := map[string][]string{}     // path → the seats naming it without stepping back
-	stepping := map[string][]SeatPath{} // seat → the paths it names stepping back
-	byName := map[string]Seat{}
-	for _, s := range set {
-		byName[s.Name] = s
-		for _, p := range s.Paths {
-			if why := seatPathProblem(s.Name, s.Scope, p.Path); why != "" {
-				problems = append(problems, why)
-			}
-			if p.StepsBackFor == "" {
-				owners[p.Path] = append(owners[p.Path], s.Name)
-			} else {
-				stepping[s.Name] = append(stepping[s.Name], p)
-			}
-		}
-	}
-	for _, s := range set {
-		for _, p := range stepping[s.Name] {
-			other, known := byName[p.StepsBackFor]
-			switch {
-			case !known || other.Scope != ScopeNode:
-				problems = append(problems, fmt.Sprintf("the seat %s steps back from %q for %q, which is not a "+
-					"node seat of the mesh's (novox/hq ADR 0287)", s.Name, p.Path, p.StepsBackFor))
-			case !namesWithoutSteppingBack(other, p.Path):
-				problems = append(problems, fmt.Sprintf("the seat %s steps back from %q for %s, which does not "+
-					"own that path itself; a seat steps back only for the one that owns it (novox/hq ADR 0287)",
-					s.Name, p.Path, other.Name))
-			}
-		}
-	}
-	for _, p := range sortedKeys(owners) {
-		if len(owners[p]) > 1 {
-			problems = append(problems, fmt.Sprintf("the path %q is named by %s, each without stepping back; "+
-				"no two seats name one path (novox/hq ADR 0287)", p, strings.Join(owners[p], " and ")))
-		}
-	}
-	for _, s := range set {
-		for _, p := range stepping[s.Name] {
-			if len(owners[p.Path]) == 0 {
-				problems = append(problems, fmt.Sprintf("the path %q has no seat naming it without stepping back "+
-					"(novox/hq ADR 0287)", p.Path))
-			}
-		}
-	}
-	return problems
-}
-
-func namesWithoutSteppingBack(s Seat, p string) bool {
-	for _, sp := range s.Paths {
-		if sp.Path == p && sp.StepsBackFor == "" {
-			return true
-		}
-	}
-	return false
-}
-
-// declaredPaths is every machine path a module declares it owns: a resource's literal path, and a file
-// the mesh renders for it outside the operator's home. An access is not here — reading is not owning.
-//
-// **Cleaned, because the machine writes the cleaned path**: /etc//hosts, /etc/./hosts, /etc/../etc/hosts and
-// /etc/hosts/ are all /etc/hosts to it, and a seat's path is clean by its own rule, so a declaration compared
-// as written would pass for a path nobody named.
-func declaredPaths(m Manifest) map[string]bool {
-	out := map[string]bool{}
-	for _, r := range m.Resources {
-		if p, ok := r["path"].(string); ok && strings.HasPrefix(p, "/") {
-			out[path.Clean(p)] = true
-		}
-	}
-	for _, f := range m.Facts {
-		if !f.Home && strings.HasPrefix(f.Path, "/") {
-			out[path.Clean(f.Path)] = true
-		}
-	}
-	return out
-}
-
-// declaresPath says whether a module declares one path, as a resource or as a file the mesh renders.
-func declaresPath(m Manifest, p string) bool { return declaredPaths(m)[p] }
-
-// missingPaths is each path a seat names that a module does not declare, in the seat's order.
-func missingPaths(m Manifest, paths []SeatPath) []string {
-	if len(paths) == 0 {
-		return nil
-	}
-	has := declaredPaths(m)
-	var missing []string
-	for _, p := range paths {
-		if !has[p.Path] {
-			missing = append(missing, p.Path)
-		}
-	}
-	return missing
-}
-
-// pathSeats is which seats name each path: the mesh's own, and then those modules declare, in the order
-// given. A module's seat naming a path a seat already names loses it, and the refusal says so (novox/hq
-// ADR 0287 — as for a seat's name, the second declaration loses).
-func pathSeats(order []string, shelf Shelf, declaredBy map[string]string) (map[string][]string, []string) {
-	named := map[string][]string{}
-	for _, s := range Seats() {
-		for _, p := range s.Paths {
-			named[p.Path] = append(named[p.Path], s.Name)
-		}
-	}
-	var problems []string
-	for _, module := range order {
-		for _, s := range shelf[module].DefinesSeats {
-			if declaredBy != nil && declaredBy[s.Name] != module {
-				continue // a second declaration of the seat's name, refused for that already
-			}
-			for _, p := range s.Paths {
-				if others := named[p]; len(others) > 0 {
-					problems = append(problems, fmt.Sprintf(
-						"%s declares the seat %s naming the path %q, which %s already names; no two seats "+
-							"name one path (novox/hq ADR 0287)", module, s.Name, p, strings.Join(others, " and ")))
-					continue
-				}
-				named[p] = append(named[p], s.Name)
-			}
-		}
-	}
-	return named, problems
-}
-
-// unclaimedSeatPaths is each path a module declares that a seat names while it claims none of the seats
-// naming it (novox/hq ADR 0287): only a claimant declares a seat's path, and a module claiming any one of
-// them may.
-func unclaimedSeatPaths(m Manifest, named map[string][]string) []string {
-	claims := map[string]bool{}
-	for _, c := range m.Claims {
-		claims[canonicalSeat(c.Name)] = true
-	}
-	var problems []string
-	declared := declaredPaths(m)
-	for _, p := range sortedKeys(declared) {
-		seats := named[p]
-		if len(seats) == 0 {
-			continue
-		}
-		claimsOne := false
-		for _, s := range seats {
-			claimsOne = claimsOne || claims[s]
-		}
-		if !claimsOne {
-			problems = append(problems, fmt.Sprintf(
-				"%s declares the path %q, which the seat %s names, and claims none of them; only a holder of "+
-					"a seat naming a path declares it (novox/hq ADR 0287)", m.Module, p, strings.Join(seats, " and ")))
-		}
-	}
-	return problems
-}
-
-// declaredSeatPathProblems is what one module's own seat declaration can be judged on alone: a path
-// only on a node seat, absolute, literal and clean.
-func declaredSeatPathProblems(m Manifest, s SeatDeclaration) []string {
-	var problems []string
-	for _, p := range s.Paths {
-		if why := seatPathProblem(s.Name, s.At(), p); why != "" {
-			problems = append(problems, m.Module+": "+why)
-		}
-	}
-	return problems
-}
-
-// asSeatPaths is a module's own seat's paths in the shape the mesh's seats name theirs. A module's seat
-// never steps back: only the mesh's own seats do, each by a record.
-func asSeatPaths(paths []string) []SeatPath {
-	out := make([]SeatPath, 0, len(paths))
-	for _, p := range paths {
-		out = append(out, SeatPath{Path: p})
-	}
-	return out
-}
-
-// PathOwner is the module that owns one seat's path on one machine (novox/hq ADR 0287): the seat naming
-// the path, and that seat's holder there, with the stepping back applied.
-type PathOwner struct {
-	Path   string `json:"path"`
-	Node   string `json:"node"`
-	Seat   string `json:"seat"`
-	Module string `json:"module"`
-}
-
-// PathOwners is, for every path a seat in the set names and every machine where a seat naming it is held,
-// who owns the path there. A seat that steps back for another held on the same machine is passed over.
-func PathOwners(set []Seat, held []Held) []PathOwner {
-	// node → seat → holding module
-	holders := map[string]map[string]string{}
-	for _, h := range held {
-		s, ok := SeatNamed(h.Claim)
-		if !ok || h.Scope != ScopeNode || s.Scope != ScopeNode {
-			continue
-		}
-		if holders[h.Node] == nil {
-			holders[h.Node] = map[string]string{}
-		}
-		if _, taken := holders[h.Node][s.Name]; !taken {
-			holders[h.Node][s.Name] = h.Module
-		}
-	}
-	naming := map[string][]Seat{}           // path → the seats naming it
-	steps := map[string]map[string]string{} // path → seat → the seat it steps back for
-	for _, s := range set {
-		for _, p := range s.Paths {
-			naming[p.Path] = append(naming[p.Path], s)
-			if p.StepsBackFor != "" {
-				if steps[p.Path] == nil {
-					steps[p.Path] = map[string]string{}
-				}
-				steps[p.Path][s.Name] = p.StepsBackFor
-			}
-		}
-	}
-	var out []PathOwner
-	for _, p := range sortedKeys(naming) {
-		for _, node := range sortedKeys(holders) {
-			for _, s := range naming[p] {
-				module, holds := holders[node][s.Name]
-				if !holds {
-					continue
-				}
-				if forSeat := steps[p][s.Name]; forSeat != "" {
-					if _, there := holders[node][forSeat]; there {
-						continue
-					}
-				}
-				out = append(out, PathOwner{Path: p, Node: node, Seat: s.Name, Module: module})
-				break
-			}
-		}
-	}
-	return out
-}
-
-// seatPathsOnMachine is each path the modules of one machine declare that a seat names, for a module
-// claiming none of the seats naming it (novox/hq ADR 0287). Registration refuses the same of a manifest;
-// this holds what the controller generates for a machine to it too, because a computed module's resources
-// exist only once composed (checkResources is asked them there). The seats are the mesh's own and those the
-// machine's modules declare.
-func seatPathsOnMachine(modules []Manifest) []string {
-	shelf := Shelf{}
-	var order []string
-	for _, m := range modules {
-		shelf[m.Module] = m
-		order = append(order, m.Module)
-	}
-	named, _ := pathSeats(order, shelf, nil)
-	var problems []string
-	for _, m := range modules {
-		problems = append(problems, unclaimedSeatPaths(m, named)...)
-	}
-	return problems
-}

internal/catalogue/seat_paths_test.go

@@ -1,311 +0,0 @@
-package catalogue
-
-import (
-	"strings"
-	"testing"
-)
-
-// Defends novox/hq ADR 0287 (issue 412): a seat names the paths its holder owns, a claim without them is
-// refused, and only a claimant declares a seat's path.
-
-// The starting set, exactly: node-hostname names /etc/hosts and /etc/hostname, node-uplink the resolver
-// file stepping back for node-resolver, node-resolver the resolver file, and every other seat names none.
-func TestTheSeatsThatNamePathsAreTheStartingSet(t *testing.T) {
-	want := map[string]string{
-		"node-hostname": "/etc/hosts /etc/hostname",
-		"node-uplink":   "/etc/resolv.conf>node-resolver",
-		ResolverSeat:    "/etc/resolv.conf",
-	}
-	for _, s := range DefaultSeats() {
-		var got []string
-		for _, p := range s.Paths {
-			if p.StepsBackFor != "" {
-				got = append(got, p.Path+">"+p.StepsBackFor)
-			} else {
-				got = append(got, p.Path)
-			}
-		}
-		if strings.Join(got, " ") != want[s.Name] {
-			t.Errorf("%s names %v; ADR 0287 gives it %q", s.Name, got, want[s.Name])
-		}
-	}
-}
-
-// The compiled set keeps the rules: node seats only, absolute and literal, one seat per path without
-// stepping back, and a stepping back that cannot cycle.
-func TestTheCompiledSeatPathsKeepTheRules(t *testing.T) {
-	if p := SeatPathProblems(DefaultSeats()); len(p) != 0 {
-		t.Fatalf("the compiled set breaks ADR 0287: %v", p)
-	}
-	for _, c := range []struct {
-		why  string
-		set  []Seat
-		want string
-	}{
-		{"a mesh seat naming a path", []Seat{{Name: "mesh-x", Scope: ScopeMesh, Paths: []SeatPath{{Path: "/etc/x"}}}},
-			"only a node seat names paths"},
-		{"a placeholder", []Seat{{Name: "node-x", Scope: ScopeNode, Paths: []SeatPath{{Path: "/etc/${setting:x}"}}}},
-			"placeholder"},
-		{"a relative path", []Seat{{Name: "node-x", Scope: ScopeNode, Paths: []SeatPath{{Path: "etc/x"}}}},
-			"not a clean absolute path"},
-		{"two owners", []Seat{
-			{Name: "node-a", Scope: ScopeNode, Paths: []SeatPath{{Path: "/etc/x"}}},
-			{Name: "node-b", Scope: ScopeNode, Paths: []SeatPath{{Path: "/etc/x"}}}}, "no two seats name one path"},
-		{"a cycle", []Seat{
-			{Name: "node-a", Scope: ScopeNode, Paths: []SeatPath{{Path: "/etc/x", StepsBackFor: "node-b"}}},
-			{Name: "node-b", Scope: ScopeNode, Paths: []SeatPath{{Path: "/etc/x", StepsBackFor: "node-a"}}}},
-			"does not own that path itself"},
-		{"stepping back for nobody", []Seat{
-			{Name: "node-a", Scope: ScopeNode, Paths: []SeatPath{{Path: "/etc/x", StepsBackFor: "node-z"}}}},
-			"not a node seat"},
-	} {
-		if got := strings.Join(SeatPathProblems(c.set), "; "); !strings.Contains(got, c.want) {
-			t.Errorf("%s: %q does not say %q", c.why, got, c.want)
-		}
-	}
-}
-
-// What the store's rows carry is never the paths: a row read back keeps the compiled ones.
-func TestTheSeatPathsSurviveTheStoresRows(t *testing.T) {
-	before := seats
-	t.Cleanup(func() { seats = before })
-	UseSeats([]Seat{{Name: "node-hostname", Scope: ScopeNode}})
-	s, _ := SeatNamed("node-hostname")
-	if len(s.Paths) != 2 {
-		t.Fatalf("node-hostname read back from its row names %v", s.Paths)
-	}
-}
-
-func hostnameSeat(t *testing.T) Seat {
-	t.Helper()
-	s, ok := SeatNamed("node-hostname")
-	if !ok {
-		t.Fatal("no node-hostname seat")
-	}
-	return s
-}
-
-func hostnameHolder(resources ...map[string]any) Manifest {
-	return Manifest{Module: "names", Version: "1", Claims: []Claim{{Name: "node-hostname", Scope: ScopeNode,
-		Serves: []string{"entries", "add", "remove"}}}, Resources: resources}
-}
-
-// A holder declares every path its seat names, as a resource or as a file the mesh renders for it, or
-// CanHold refuses it naming the seat and each missing path — the judgement registration and handover share.
-func TestAClaimWithoutTheSeatsPathsIsRefused(t *testing.T) {
-	seat := hostnameSeat(t)
-	hosts := map[string]any{"id": "hosts", "type": "file", "path": "/etc/hosts", "content": "x"}
-	name := map[string]any{"id": "name", "type": "file", "path": "/etc/hostname", "content": "x"}
-
-	if err := CanHold(hostnameHolder(hosts, name), seat); err != nil {
-		t.Errorf("a holder declaring both paths as resources was refused: %v", err)
-	}
-	rendered := hostnameHolder(hosts)
-	rendered.Facts = map[string]RosterFile{"name": {Path: "/etc/hostname", Template: "{{.Node}}\n"}}
-	if err := CanHold(rendered, seat); err != nil {
-		t.Errorf("a holder declaring a path as a file the mesh renders was refused: %v", err)
-	}
-	err := CanHold(hostnameHolder(), seat)
-	if err == nil {
-		t.Fatal("a holder declaring neither path was accepted")
-	}
-	for _, want := range []string{"node-hostname", "/etc/hosts", "/etc/hostname", "ADR 0287"} {
-		if !strings.Contains(err.Error(), want) {
-			t.Errorf("the refusal does not name %s: %v", want, err)
-		}
-	}
-	// A file under the operator's home is placed per account: it is not the machine's path.
-	home := hostnameHolder(hosts)
-	home.Facts = map[string]RosterFile{"name": {Path: "/etc/hostname", Home: true, Template: "x"}}
-	if err := CanHold(home, seat); err == nil {
-		t.Error("a file in the operator's home counted as the machine's /etc/hostname")
-	}
-	// At registration, the same refusal.
-	if got := strings.Join(CatalogueProblems(Shelf{"names": hostnameHolder(hosts)}), "; "); !strings.Contains(got,
-		"does not declare /etc/hostname") {
-		t.Errorf("registration let a holder without /etc/hostname through: %q", got)
-	}
-}
-
-// Only a claimant declares a seat's path: a module claiming no seat that names /etc/hosts and declaring
-// it is refused at registration naming the seat; the uplink's holder and the resolver's both declaring
-// the resolver file are each a claimant of a seat naming it. Reading a seat's path is access, and allowed.
-func TestOnlyAClaimantDeclaresASeatsPath(t *testing.T) {
-	stranger := Manifest{Module: "stranger", Version: "1", Resources: []map[string]any{
-		{"id": "hosts", "type": "file", "path": "/etc/hosts", "into": "block", "content": "10.0.0.1 x\n"}}}
-	got := strings.Join(CatalogueProblems(Shelf{"stranger": stranger}), "; ")
-	if !strings.Contains(got, `stranger declares the path "/etc/hosts", which the seat node-hostname names`) {
-		t.Errorf("a module declaring /etc/hosts without claiming node-hostname was not refused: %q", got)
-	}
-	// However the path is spelled (novox/hq issue 412 review).
-	unclean := Manifest{Module: "unclean", Version: "1", Resources: []map[string]any{
-		{"id": "hosts", "type": "file", "path": "/etc/../etc/hosts", "content": "10.0.0.1 x\n"}}}
-	if got := strings.Join(CatalogueProblems(Shelf{"unclean": unclean}), "; "); !strings.Contains(got, "node-hostname") {
-		t.Errorf("/etc/../etc/hosts from a module not claiming node-hostname was not refused: %q", got)
-	}
-	reader := Manifest{Module: "reader", Version: "1", Accesses: []Access{{ID: "hosts", Path: "/etc/hosts"}}}
-	if got := CatalogueProblems(Shelf{"reader": reader}); len(got) != 0 {
-		t.Errorf("reading /etc/hosts was refused: %v", got)
-	}
-	uplink := Manifest{Module: "uplink", Version: "1", Claims: []Claim{{Name: "node-uplink", Scope: ScopeNode}},
-		Facts: map[string]RosterFile{"resolvers": {Path: ResolverFile, Template: "nameserver 10.42.0.1\n"}}}
-	resolver := localResolver()
-	resolver.Claims[0].Serves = []string{"routes", "route", "unroute"}
-	if got := CatalogueProblems(Shelf{"uplink": uplink, resolver.Module: resolver}); len(got) != 0 {
-		t.Errorf("the uplink's holder and the resolver's declaring the resolver file were refused: %v", got)
-	}
-}
-
-// A module's own seat names paths under the same rules: a node seat only, literal, and none another seat
-// names — the second declaration loses. Its holder declares them, as a mesh seat's does.
-func TestAModulesOwnSeatNamesPathsUnderTheSameRules(t *testing.T) {
-	meshScoped := Manifest{Module: "a", Version: "1", DefinesSeats: []SeatDeclaration{
-		{Name: "a-seat", Paths: []string{"/etc/a"}}}}
-	if got := strings.Join(declaredSeatProblems(meshScoped), "; "); !strings.Contains(got, "only a node seat names paths") {
-		t.Errorf("a module's mesh seat naming a path was accepted: %q", got)
-	}
-	placeholder := Manifest{Module: "a", Version: "1", DefinesSeats: []SeatDeclaration{
-		{Name: "a-seat", Scope: ScopeNode, Paths: []string{"${dir:state}/a"}}}}
-	if got := strings.Join(declaredSeatProblems(placeholder), "; "); !strings.Contains(got, "placeholder") {
-		t.Errorf("a module's seat naming a path with a placeholder was accepted: %q", got)
-	}
-
-	taken := Manifest{Module: "b", Version: "1", DefinesSeats: []SeatDeclaration{
-		{Name: "b-seat", Scope: ScopeNode, Paths: []string{"/etc/hosts"}}}}
-	if got := strings.Join(CatalogueProblems(Shelf{"b": taken}), "; "); !strings.Contains(got,
-		`b declares the seat b-seat naming the path "/etc/hosts", which node-hostname already names`) {
-		t.Errorf("a module's seat naming /etc/hosts was accepted: %q", got)
-	}
-
-	own := Manifest{Module: "c", Version: "1",
-		DefinesSeats: []SeatDeclaration{{Name: "c-seat", Scope: ScopeNode, Paths: []string{"/etc/c.conf"}}},
-		Claims:       []Claim{{Name: "c-seat", Scope: ScopeNode}}}
-	if got := strings.Join(CatalogueProblems(Shelf{"c": own}), "; "); !strings.Contains(got,
-		"c claims c-seat but does not declare /etc/c.conf") {
-		t.Errorf("a holder of a module's seat without its path was accepted: %q", got)
-	}
-	own.Resources = []map[string]any{{"id": "conf", "type": "file", "path": "/etc/c.conf", "content": "x"}}
-	if got := CatalogueProblems(Shelf{"c": own}); len(got) != 0 {
-		t.Errorf("a holder declaring its own seat's path was refused: %v", got)
-	}
-	other := Manifest{Module: "d", Version: "1", Resources: []map[string]any{
-		{"id": "conf", "type": "file", "path": "/etc/c.conf", "content": "x"}}}
-	if got := strings.Join(CatalogueProblems(Shelf{"c": own, "d": other}), "; "); !strings.Contains(got,
-		`d declares the path "/etc/c.conf", which the seat c-seat names`) {
-		t.Errorf("a module not claiming c-seat declared its path: %q", got)
-	}
-}
-
-type writesHosts struct{}
-
-func (writesHosts) Resources(string) ([]map[string]any, bool, error) {
-	return []map[string]any{{"id": "hosts", "type": "file", "path": "/etc/hosts", "into": "block",
-		"content": "10.42.0.1 anchor\n"}}, true, nil
-}
-
-// The controller is bound too: what it generates for a machine on a seat's path is refused at composition.
-func TestAGeneratedResourceOnASeatsPathIsRefused(t *testing.T) {
-	r := Resolution{Node: "workstation", Modules: []Manifest{
-		{Module: "mesh-names", Computed: "mesh-names"},
-	}}
-	_, err := r.Declaration(Rendering{Generators: map[string]Generator{"mesh-names": writesHosts{}}})
-	if err == nil {
-		t.Fatal("a generated resource on /etc/hosts was composed")
-	}
-	for _, want := range []string{"mesh-names", "/etc/hosts", "node-hostname"} {
-		if !strings.Contains(err.Error(), want) {
-			t.Errorf("the refusal does not name %s: %v", want, err)
-		}
-	}
-}
-
-// Who owns a seat's path on a machine: the seat naming it and its holder there, with the stepping back
-// applied — the resolver's holder where node-resolver is held, else the uplink's.
-func TestPathOwnersApplyTheSteppingBack(t *testing.T) {
-	held := []Held{
-		{Claim: "node-uplink", Scope: ScopeNode, Node: "laptop", Module: "networkmanager"},
-		{Claim: ResolverSeat, Scope: ScopeNode, Node: "laptop", Module: "systemd-resolved"},
-		{Claim: "node-uplink", Scope: ScopeNode, Node: "server", Module: "systemd-networkd"},
-		{Claim: "node-hostname", Scope: ScopeNode, Node: "server", Module: "hostname"},
-	}
-	var got []string
-	for _, o := range PathOwners(Seats(), held) {
-		got = append(got, o.Path+" "+o.Node+" "+o.Seat+" "+o.Module)
-	}
-	want := []string{
-		"/etc/hostname server node-hostname hostname",
-		"/etc/hosts server node-hostname hostname",
-		"/etc/resolv.conf laptop node-resolver systemd-resolved",
-		"/etc/resolv.conf server node-uplink systemd-networkd",
-	}
-	if strings.Join(got, "\n") != strings.Join(want, "\n") {
-		t.Errorf("the owners are\n%s\nnot\n%s", strings.Join(got, "\n"), strings.Join(want, "\n"))
-	}
-}
-
-// The stepping back comes from the seat, and is of a rendered file only: an uplink holder declaring the
-// resolver file as a resource beside a node-resolver holder is two writers of one path, refused when the
-// machine is resolved — never composed twice — as before the seat named its paths.
-func TestAnUplinkDeclaringTheResolverFileAsAResourceIsRefusedBesideTheResolver(t *testing.T) {
-	shelf := resolverShelf(t)
-	uplink := shelf["systemd-networkd"]
-	uplink.Facts = nil
-	uplink.Resources = append(append([]map[string]any(nil), uplink.Resources...),
-		map[string]any{"id": "resolvers", "type": "file", "path": ResolverFile, "content": "nameserver 10.42.0.1\n"})
-	shelf["systemd-networkd"] = uplink
-	shelf["local-resolver"] = localResolver()
-	_, err := Resolve(shelf, []string{"dnsmasq", "systemd-networkd", "local-resolver"}, splitDNSLaptop(), World{})
-	if err == nil || !strings.Contains(err.Error(), `both declare the path "/etc/resolv.conf"`) {
-		t.Fatalf("an uplink declaring the resolver file as a resource beside the resolver was not refused: %v", err)
-	}
-	// Its rendered file steps back, by the seat's definition, and nothing else of it does.
-	rendered := Manifest{Module: "uplink", Version: "1", Claims: []Claim{{Name: "node-uplink"}},
-		Facts: map[string]RosterFile{"resolvers": {Path: "/etc//resolv.conf", Template: "x"},
-			"other": {Path: "/etc/uplink.conf", Template: "x"}}}
-	got := stepsBack(rendered, []Manifest{rendered, localResolver()})
-	if len(got.Facts) != 1 || got.Facts["other"].Path == "" {
-		t.Errorf("the uplink's holder renders %v beside the resolver", got.Facts)
-	}
-}
-
-// A path is compared as the machine writes it: cleaned. Each spelling of /etc/hosts is /etc/hosts.
-func TestAnUncleanSpellingOfASeatsPathIsTheSeatsPath(t *testing.T) {
-	for _, spelled := range []string{"/etc//hosts", "/etc/./hosts", "/etc/../etc/hosts", "/etc/hosts/"} {
-		stranger := Manifest{Module: "stranger", Version: "1", Resources: []map[string]any{
-			{"id": "hosts", "type": "file", "path": spelled, "content": "10.0.0.1 x\n"}}}
-		if got := strings.Join(CatalogueProblems(Shelf{"stranger": stranger}), "; "); !strings.Contains(got,
-			`stranger declares the path "/etc/hosts", which the seat node-hostname names`) {
-			t.Errorf("%s from a module not claiming node-hostname was not refused: %q", spelled, got)
-		}
-		holder := hostnameHolder(map[string]any{"id": "hosts", "type": "file", "path": spelled, "content": "x"},
-			map[string]any{"id": "name", "type": "file", "path": "/etc/hostname", "content": "x"})
-		if err := CanHold(holder, hostnameSeat(t)); err != nil {
-			t.Errorf("a holder declaring %s was refused: %v", spelled, err)
-		}
-	}
-}
-
-// A seat names a role's own path, never the root or a top-level directory.
-func TestASeatNamesNoRootOrTopLevelDirectory(t *testing.T) {
-	for _, p := range []string{"/", "/etc"} {
-		m := Manifest{Module: "a", Version: "1", DefinesSeats: []SeatDeclaration{
-			{Name: "a-seat", Scope: ScopeNode, Paths: []string{p}}}}
-		if got := strings.Join(declaredSeatProblems(m), "; "); !strings.Contains(got, "top-level directory") {
-			t.Errorf("a module's seat naming %s was accepted: %q", p, got)
-		}
-	}
-}
-
-// The catalogue as it is passes: no holder of a seat naming a path is missing one, and nobody else
-// declares one.
-func TestTheCataloguePassesTheSeatPathRules(t *testing.T) {
-	shelf := Shelf{}
-	for _, m := range theCatalogue(t) {
-		shelf[m.Module] = m
-	}
-	for _, p := range CatalogueProblems(shelf) {
-		if strings.Contains(p, "ADR 0287") {
-			t.Errorf("the catalogue breaks ADR 0287: %s", p)
-		}
-	}
-}

internal/catalogue/seats.go

@@ -53,11 +53,6 @@ type Seat struct {
 	// ${contribution:<seat>:<kind>}. Compiled, never stored: like the protocol, it is the mesh's
 	// definition of the role, and the store's rows carry no column for it.
 	Receives []Receivable
-	// Paths are the paths on its machine the seat's holder owns (novox/hq ADR 0287): a holder declares
-	// every one, and a module claiming no seat that names a path may not declare it. Only a node seat
-	// names paths. Compiled, never stored, like Receives: adding or taking away a path is a decision,
-	// recorded, and the store's rows carry no column for it.
-	Paths []SeatPath
 	// Decision is the record that made it a seat.
 	Decision string
 }
@@ -183,8 +178,6 @@ var defaultSeats = append([]Seat{
 	// holds none of it. Named node-hosts-file until ADR 0223; the former name resolves to it as an
 	// alias on a mesh that knew it.
 	{Name: "node-hostname", Scope: ScopeNode, Decision: "novox/hq ADR 0199, ADR 0223",
-		// The machine's names are the role's files, whatever program fills it (novox/hq ADR 0287).
-		Paths: []SeatPath{{Path: "/etc/hosts"}, {Path: "/etc/hostname"}},
 		Serves: []Verb{
 			{Name: "entries", Description: "Every line of this machine's /etc/hosts, each marked whose it is: " +
 				"the operator's, or the block of the module or tool that writes it.",
@@ -306,17 +299,12 @@ var defaultSeats = append([]Seat{
 	// resolver file as it is and who wrote it, and every link with its addresses, routes and the resolvers
 	// the manager knows for it — the same for every holder, so a question about a machine's names is asked
 	// the same way whatever manages its network. Optional until both holders serve them.
-	//
-	// It owns the resolver file, stepping back for node-resolver where that is held (novox/hq ADR 0287,
-	// ADR 0247).
-	{Name: "node-uplink", Scope: ScopeNode, Decision: "novox/hq ADR 0117", Serves: uplinkVerbs(),
-		Paths: []SeatPath{{Path: ResolverFile, StepsBackFor: ResolverSeat}}},
+	{Name: "node-uplink", Scope: ScopeNode, Decision: "novox/hq ADR 0117", Serves: uplinkVerbs()},
 	// The machine's own resolver (novox/hq ADR 0247): held only where something requires `split-dns` — a
 	// VPN client whose domains must go to its own servers while every other name goes to the mesh's.
 	// Where it is held, its holder writes the resolver file and the uplink's holder steps back from it
 	// (node_resolver.go). It knows nothing of any VPN: its verbs route domains to servers over a link.
-	{Name: ResolverSeat, Scope: ScopeNode, Decision: "novox/hq ADR 0247", Serves: resolverVerbs(),
-		Paths: []SeatPath{{Path: ResolverFile}}},
+	{Name: ResolverSeat, Scope: ScopeNode, Decision: "novox/hq ADR 0247", Serves: resolverVerbs()},
 	// A machine's shares and the shares it mounts (novox/hq ADR 0263): the holder of node-nfs-server
 	// exports a machine's folders to the private network and provides each as `nfs-share`; the holder of
 	// node-mounts writes a mount and an automount unit per share on a machine that asks (shares.go).
@@ -376,11 +364,10 @@ func UseSeats(s []Seat) {
 				row.Accepts, row.Emits, row.Serves = d.Accepts, d.Emits, d.Serves
 			}
 		}
-		// What a seat receives, whether it is replicated and the paths it names are never stored
-		// (novox/hq ADR 0212, ADR 0223, ADR 0287), so they are always the compiled ones.
+		// What a seat receives and whether it is replicated are never stored (novox/hq ADR 0212, ADR
+		// 0223), so they are always the compiled ones.
 		if d, known := byName[row.Name]; known {
 			row.Receives = d.Receives
-			row.Paths = d.Paths
 			row.Replicated = d.Replicated
 			row.Serves = optionalAsCompiled(row.Serves, d.Serves)
 		}
@@ -554,14 +541,6 @@ func CanHold(m Manifest, seat Seat) error {
 		return fmt.Errorf("%s claims %s, whose holder answers for %q, and %s does not provide %q at %s scope",
 			m.Module, seat.Name, seat.Delivers, m.Module, seat.Delivers, seat.Scope)
 	}
-	// **A holder owns what the role owns** (novox/hq ADR 0287): every path the seat names, declared as
-	// a resource or as a file the mesh renders for it, so which module owns /etc/hosts on a machine is
-	// answered by the seat's definition and not by reading every manifest.
-	if missing := missingPaths(m, seat.Paths); len(missing) > 0 {
-		return fmt.Errorf("%s claims %s but does not declare %s, which that seat's holder owns (novox/hq "+
-			"ADR 0287) — a holder declares every path its seat names, as a resource or as a file the mesh "+
-			"renders for it", m.Module, seat.Name, strings.Join(missing, ", "))
-	}
 	// **Serving the seat's tools is a condition of holding it** (novox/hq ADR 0132). A holder that
 	// does not answer what the role promises is every caller's timeout, found at registration and
 	// at handover instead, naming the verbs rather than the fact that something is missing.

internal/catalogue/seats_declared.go

@@ -67,10 +67,6 @@ type SeatDeclaration struct {
 	// Records are state buckets of the declaring module that each user reads under its own name — the
 	// keys `<user>.…` and no other (ADR 0259 §3).
 	Records []string `json:"records,omitempty"`
-	// Paths are the paths on its machine the seat's holder owns (novox/hq ADR 0287), under the rules the
-	// mesh's own seats name theirs by: a node seat only, each absolute and literal, and none another seat
-	// names. A module's seat never steps back.
-	Paths []string `json:"paths,omitempty"`
 }
 
 // KindedBenches are the seats that may be kinded (novox/hq ADR 0234 §2): `channel` sends to the operator,
@@ -167,7 +163,6 @@ func declaredSeatProblems(m Manifest) []string {
 			}
 		}
 		problems = append(problems, trafficProblems(m, s)...)
-		problems = append(problems, declaredSeatPathProblems(m, s)...)
 	}
 
 	for _, u := range m.Uses {
@@ -276,10 +271,6 @@ func CatalogueProblems(shelf Shelf) []string {
 		return ok
 	}
 
-	// Which seats name each path (novox/hq ADR 0287): a module's seat naming one another seat names loses.
-	named, pathProblems := pathSeats(shelfOrder(shelf), shelf, declaredBy)
-	problems = append(problems, pathProblems...)
-
 	// Who claims each kind of a kinded bench, so a second claim of one kind is refused (ADR 0234 §2).
 	kindsTaken := map[string]string{}
 
@@ -336,15 +327,7 @@ func CatalogueProblems(shelf Shelf) []string {
 					"%s claims %s but does not serve %s, which that seat's protocol promises",
 					module, c.Name, strings.Join(missing, ", ")))
 			}
-			// And owns what the seat's holder owns, as a holder of the mesh's own seats does (ADR 0287).
-			if missing := missingPaths(m, asSeatPaths(s.Paths)); len(missing) > 0 {
-				problems = append(problems, fmt.Sprintf(
-					"%s claims %s but does not declare %s, which that seat's holder owns (novox/hq ADR 0287)",
-					module, c.Name, strings.Join(missing, ", ")))
-			}
 		}
-		// Only a claimant declares a seat's path (novox/hq ADR 0287).
-		problems = append(problems, unclaimedSeatPaths(m, named)...)
 	}
 	// **A trusted holder runs as its own account** (novox/hq ADR 0259 §8): a module saying warrants, or
 	// speaking for a kind that proves its sender, is never carried by a machine's runtime.

internal/catalogue/uplink_verbs_test.go

@@ -33,9 +33,7 @@ func TestTheUplinkSeatPromisesItsVerbsAndRequiresNoneYet(t *testing.T) {
 	if !slices.Equal(names, []string{"resolvers", "links"}) {
 		t.Fatalf("node-uplink promises %v", names)
 	}
-	// The resolver file is the seat's path (novox/hq ADR 0287), which every holder of today renders.
-	today := Manifest{Module: "networkmanager", Version: "1", Claims: []Claim{{Name: "node-uplink", Scope: ScopeNode}},
-		Facts: map[string]RosterFile{"resolvers": {Path: ResolverFile, Template: "x"}}}
+	today := Manifest{Module: "networkmanager", Version: "1", Claims: []Claim{{Name: "node-uplink", Scope: ScopeNode}}}
 	if err := CanHold(today, seat); err != nil {
 		t.Fatalf("a holder that serves no verb yet is refused: %v", err)
 	}
@@ -57,8 +55,7 @@ func TestTheUplinkVerbsReadBackFromTheRowStayOptional(t *testing.T) {
 	// The row as seeding stores it: both verbs, the mark not a column.
 	UseSeats([]Seat{{Name: "node-uplink", Scope: ScopeNode, Serves: []Verb{{Name: "resolvers"}, {Name: "links"}}}})
 	seat := uplinkSeat(t)
-	holder := Manifest{Module: "systemd-networkd", Version: "1", Claims: []Claim{{Name: "node-uplink", Scope: ScopeNode}},
-		Facts: map[string]RosterFile{"resolvers": {Path: ResolverFile, Template: "x"}}}
+	holder := Manifest{Module: "systemd-networkd", Version: "1", Claims: []Claim{{Name: "node-uplink", Scope: ScopeNode}}}
 	if err := CanHold(holder, seat); err != nil {
 		t.Fatalf("read back from the row, the verbs are required: %v", err)
 	}

internal/inventory/machine.go

@@ -0,0 +1,74 @@
+package inventory
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+)
+
+// MachineAccount is what a machine said it is made of (novox/hq issue 160), from the profile it last
+// reported: the architecture and kernel family the profile always carried, and the facts a node-engine that
+// knows how says beside them. Read by `node`, so what a machine says of itself is visible in one place —
+// collected and shown in the same breath, not collected and read by nothing (issue 160's pattern).
+type MachineAccount struct {
+	Architecture string `json:"architecture"`
+	Kernel       string `json:"kernel"`
+	// Machine is nil when the node-engine that reported is older than the one that says it.
+	Machine *MadeOf `json:"machine"`
+}
+
+// MadeOf is the node-engine's account of what it is made of, as it put it on the wire. A fact it could
+// not determine is absent here and named in Unknown with why — never a zero.
+type MadeOf struct {
+	ObservedAt    time.Time           `json:"observed_at"`
+	KernelRelease string              `json:"kernel_release"`
+	Distribution  string              `json:"distribution"`
+	Version       string              `json:"version"`
+	Processor     string              `json:"processor"`
+	Cores         int                 `json:"cores"`
+	Threads       int                 `json:"threads"`
+	MemoryBytes   int64               `json:"memory_bytes"`
+	Virtual       string              `json:"virtual"`
+	BootedAt      *time.Time          `json:"booted_at"`
+	Timezone      string              `json:"timezone"`
+	Filesystems   []MountedFilesystem `json:"filesystems"`
+	Unknown       map[string]string   `json:"unknown"`
+}
+
+// MountedFilesystem is one local filesystem a machine has mounted.
+type MountedFilesystem struct {
+	Mount     string `json:"mount"`
+	Device    string `json:"device"`
+	Type      string `json:"type"`
+	SizeBytes int64  `json:"size_bytes"`
+	FreeBytes int64  `json:"free_bytes"`
+}
+
+// MachineOf is what a node last said it is made of. had is false for a node that has never reported a
+// profile at all, which is a different answer from one whose node-engine does not say the facts yet.
+func (i *Inventory) MachineOf(ctx context.Context, nodeName string) (account MachineAccount, had bool, err error) {
+	var raw []byte
+	err = i.store.Pool().QueryRow(ctx, `select profile from node where name = $1`, nodeName).Scan(&raw)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return MachineAccount{}, false, fmt.Errorf("%w: %s", ErrNoSuchNode, nodeName)
+	}
+	if err != nil {
+		return MachineAccount{}, false, err
+	}
+	return machineFrom(raw)
+}
+
+func machineFrom(raw []byte) (MachineAccount, bool, error) {
+	if len(raw) == 0 {
+		return MachineAccount{}, false, nil
+	}
+	var account MachineAccount
+	if err := json.Unmarshal(raw, &account); err != nil {
+		return MachineAccount{}, false, err
+	}
+	return account, true, nil
+}

internal/inventory/machine_test.go

@@ -0,0 +1,42 @@
+package inventory
+
+import (
+	"testing"
+)
+
+// The node-engine's words for a machine's facts (novox/hq issue 160), as mesh-host's profile.Machine puts
+// them on the wire. A rename on either side fails here rather than as a blank on a real machine.
+func TestAMachinesAccountIsReadInTheNodeEnginesWords(t *testing.T) {
+	raw := []byte(`{"architecture":"amd64","kernel":"linux","capabilities":[],
+		"machine":{"observed_at":"2026-10-12T15:00:00Z","kernel_release":"7.2.8-arch1-2",
+		"distribution":"Arch Linux","version":"rolling","processor":"AMD Ryzen 9","cores":8,"threads":16,
+		"memory_bytes":32891494400,"virtual":"physical","booted_at":"2026-10-09T08:50:34Z",
+		"timezone":"Europe/Brussels",
+		"filesystems":[{"mount":"/","device":"/dev/nvme0n1p3","type":"ext4","size_bytes":100,"free_bytes":40}],
+		"unknown":{"public address":"not decided"}}}`)
+	a, had, err := machineFrom(raw)
+	if err != nil || !had {
+		t.Fatalf("had %v, err %v", had, err)
+	}
+	m := a.Machine
+	if a.Architecture != "amd64" || a.Kernel != "linux" || m == nil {
+		t.Fatalf("%+v", a)
+	}
+	if m.KernelRelease != "7.2.8-arch1-2" || m.Distribution != "Arch Linux" || m.Version != "rolling" ||
+		m.Processor != "AMD Ryzen 9" || m.Cores != 8 || m.Threads != 16 || m.MemoryBytes != 32891494400 ||
+		m.Virtual != "physical" || m.BootedAt == nil || m.Timezone != "Europe/Brussels" ||
+		len(m.Filesystems) != 1 || m.Filesystems[0].FreeBytes != 40 || m.Unknown["public address"] == "" ||
+		m.ObservedAt.IsZero() {
+		t.Errorf("%+v", m)
+	}
+}
+
+func TestAProfileWithoutTheFactsIsAnOlderNodeEngineNotNothing(t *testing.T) {
+	a, had, err := machineFrom([]byte(`{"architecture":"amd64","kernel":"linux","capabilities":[]}`))
+	if err != nil || !had || a.Machine != nil || a.Architecture != "amd64" {
+		t.Errorf("%+v had %v err %v", a, had, err)
+	}
+	if _, had, _ := machineFrom(nil); had {
+		t.Error("a node that never reported read as having reported")
+	}
+}

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:

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