Merge pull request 'Pin mesh-sdk dbcaa29, so a held module's hold no longer spreads to the modules that read from it (issue 1960)' (#175) from fix/1960-no-hold-spread into main

mesh-sdk's composer no longer holds a module behind a held one it reads from; the selfcompose test now expects
proxy handed, composed without de-spiegel's routes, and de-spiegel told alone. Needs mesh-sdk pinned at the fix.

cmd/mesh-host/apply_context_test.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// An apply runs in a context the bus's loss cannot end: the link's context ends when the bus goes, and the bus may go
+// because of the apply itself (it replaces the bus's own container), which then must finish (issue 1945, live on
+// 2026-10-25 at 11:23: novox's node-engine removed the bus container, its link's context ended, and the docker run that
+// would have made the new one was never made).
+func TestAnApplyOutlivesTheLinksContext(t *testing.T) {
+	type key struct{}
+	link, cancel := context.WithCancel(context.WithValue(context.Background(), key{}, "v"))
+	ctx, done := applyContext(link)
+	defer done()
+	cancel()
+	if ctx.Err() != nil {
+		t.Fatalf("the apply's context ended with the link's: %v", ctx.Err())
+	}
+	if ctx.Value(key{}) != "v" {
+		t.Fatal("the apply's context lost the link's values")
+	}
+}
+
+// An apply is bounded all the same: a step that hangs (a docker call that never returns) cannot hold the node agent for
+// ever (the review of issue 1945).
+func TestAnApplyIsBounded(t *testing.T) {
+	ctx, done := applyContext(context.Background())
+	defer done()
+	at, ok := ctx.Deadline()
+	if !ok {
+		t.Fatal("an apply has no bound")
+	}
+	if left := time.Until(at); left > applyBound || left < applyBound-time.Minute {
+		t.Fatalf("the bound is %s away, want about %s", left, applyBound)
+	}
+}

cmd/mesh-host/applywhole_test.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"context"
+
+	"git.novox.be/novox/mesh-sdk/go/declaration"
+	"github.com/novox/mesh-host/internal/apply"
+	"github.com/novox/mesh-host/internal/link"
+	"github.com/novox/mesh-host/internal/store"
+)
+
+// applyAndKeep applies a whole declaration the way the carried bundle is applied, and says what came of it as the facts
+// the node says: what the tests of the apply's steps read. The node-engine applies no whole declaration on its own now
+// (novox/hq ADR 0539 §9); this is the test's way to put a machine in a state.
+func applyAndKeep(ctx context.Context, opts options, raw []byte, signed *store.Declared, sched *apply.Scheduler,
+	say link.Announce) link.Report {
+	declared, err := declaration.Parse(raw)
+	if err != nil {
+		return link.Report{Refused: err.Error()}
+	}
+	got := applyModuleHeld(ctx, opts, declared, nil, sched, say)
+	if got.Refused != "" {
+		return link.Report{Refused: got.Refused}
+	}
+	held := map[string]bool{}
+	for _, h := range got.Updated.Held {
+		held[h.ID] = true
+	}
+	report := factsOf(ctx, opts, declared, got.Updated, got.Outcome, held)
+	if signed != nil {
+		if err := store.SaveDeclared(store.DeclaredPath(opts.state), *signed); err != nil {
+			report.Failed = map[string]string{"keeping the declaration": err.Error()}
+		}
+	}
+	if got.Err != nil {
+		report.Failed = map[string]string{"apply": got.Err.Error()}
+	}
+	report.Failed = withUnanswered(report.Failed, got.Probe)
+	report.Unapplied = unapplied(declared, got.Outcome, got.Err)
+	return report
+}

cmd/mesh-host/authority.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"git.novox.be/novox/mesh-sdk/go/catalogue"
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+)
+
+// authorityPath is where this engine keeps the mesh's own certificate as it last applied it (public): beside the
+// certificate issued for the machine's name, read into its record (novox/hq ADR 0555 §3).
+func authorityPath(state string) string { return filepath.Join(filepath.Dir(state), "authority.crt") }
+
+// keepAuthority keeps the mesh's own certificate a composition carries (the resource a module's certificate.authority
+// asks for, catalogue.AuthorityID), so the record says the authority this machine holds. A composition carrying none
+// changes nothing.
+func keepAuthority(state string, c delivery.Composed) error {
+	for _, raw := range c.Resources {
+		var r struct {
+			ID      string `json:"id"`
+			Content string `json:"content"`
+		}
+		if json.Unmarshal(raw, &r) != nil || r.Content == "" || !strings.HasSuffix(r.ID, "."+catalogue.AuthorityID()) {
+			continue
+		}
+		path := authorityPath(state)
+		if was, err := os.ReadFile(path); err == nil && string(was) == r.Content {
+			return nil
+		}
+		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+			return err
+		}
+		return os.WriteFile(path, []byte(r.Content), 0o644)
+	}
+	return nil
+}

cmd/mesh-host/authority_test.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+)
+
+// Issue 1126 (ADR 0555 §3): the mesh's own certificate a composition carries is kept for the machine's record, and the
+// record's keys read it; a composition carrying none changes nothing.
+func TestTheAppliedAuthorityIsKeptForTheRecord(t *testing.T) {
+	state := filepath.Join(t.TempDir(), "state", "state.json")
+	res := func(id, content string) json.RawMessage {
+		raw, _ := json.Marshal(map[string]any{"id": id, "type": "file", "path": "/etc/x", "content": content})
+		return raw
+	}
+	if err := keepAuthority(state, delivery.Composed{Resources: []json.RawMessage{res("web.conf", "x")}}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(authorityPath(state)); !os.IsNotExist(err) {
+		t.Fatalf("a composition with no authority kept one: %v", err)
+	}
+	if err := keepAuthority(state, delivery.Composed{Resources: []json.RawMessage{res("ca-trust.certificate-authority", "CA-1")}}); err != nil {
+		t.Fatal(err)
+	}
+	if got := recordKeys(state)(); got.Authority != "CA-1" {
+		t.Errorf("the record's keys read the authority %q", got.Authority)
+	}
+}

cmd/mesh-host/backup_event_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+	"time"
+)
+
+func backupEvent(node, module string, ok bool, at time.Time, why string) []byte {
+	raw, _ := json.Marshal(map[string]any{"node": node, "module": module, "ok": ok, "at": at, "error": why})
+	return raw
+}
+
+// A backup is done when the holder says so for this node and module, held on its words when it says it failed, and held
+// when it says nothing within the bound; another node's or module's event, or one from before the ask, is not the answer
+// (R6-A A5, novox/hq ADR 0429 §14).
+func TestABackupEndsWhenItsEventSaysSo(t *testing.T) {
+	since := time.Now()
+	run := func(within time.Duration, events ...[]byte) (done bool, words string) {
+		ch := make(chan []byte, len(events))
+		for _, e := range events {
+			ch <- e
+		}
+		got := awaitBackup(context.Background(), ch, "n1", "db", since, within)
+		return got.Done, got.Words
+	}
+	if done, _ := run(time.Second,
+		backupEvent("n2", "db", true, since, ""), backupEvent("n1", "web", true, since, ""),
+		backupEvent("n1", "db", false, since.Add(-time.Hour), "an old night"),
+		backupEvent("n1", "db", true, since.Add(time.Second), "")); !done {
+		t.Error("the event of this node and module was not the answer")
+	}
+	if done, words := run(time.Second, backupEvent("n1", "db", false, since, "the repository is locked")); done ||
+		!strings.Contains(words, "repository is locked") {
+		t.Errorf("a failed backup: done=%v words=%q", done, words)
+	}
+	if done, words := run(50 * time.Millisecond); done || !strings.Contains(words, "did not say it was done") {
+		t.Errorf("silence within the bound: done=%v words=%q", done, words)
+	}
+}

cmd/mesh-host/backup_nothing_test.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+// A module that declares nothing to back up on this machine is not backed up before it moves, and so never held for a
+// backup that cannot run (issue 1945, live on 2026-10-25: redis and searxng on ace were held: "redis declares nothing to
+// back up on this machine"). What node-backup.backed-up answers decides it.
+func TestAModuleWithNothingToBackUpIsNotBackedUp(t *testing.T) {
+	for _, c := range []struct {
+		said    string
+		nothing bool
+	}{
+		{`[{"module":"postgres","runs":1,"paths":["/var/lib/postgres"]}]`, true},
+		{`[{"module":"redis","runs":0,"paths":null,"data":[{"item":"cache"}]}]`, true},
+		{`[]`, true},
+		{`[{"module":"redis","runs":1,"paths":["/var/lib/redis"]}]`, false},
+	} {
+		nothing, ok := declaresNothingToBackUp(json.RawMessage(c.said), "redis")
+		if !ok || nothing != c.nothing {
+			t.Errorf("%s: nothing %v (read %v), want %v", c.said, nothing, ok, c.nothing)
+		}
+	}
+	if _, ok := declaresNothingToBackUp(json.RawMessage(`{"error":"x"}`), "redis"); ok {
+		t.Error("an answer that is not the list was read")
+	}
+}

cmd/mesh-host/busy_test.go

@@ -5,62 +5,30 @@ import (
 	"sync/atomic"
 	"testing"
 	"time"
-
-	"github.com/novox/mesh-host/internal/link"
 )
 
-// A container waiting because it said busy is news when it starts waiting and when it is replaced, never on
-// its output alone (novox/hq ADR 0335): the walk waiting on this machine starts its gate at the report that
-// says it replaced, and a reconcile is otherwise silent.
-func TestABusyWaitIsSaidWhenItStartsAndWhenItEnds(t *testing.T) {
-	quiet := link.Report{Outward: []string{"eth0"}}
-	waiting := link.Report{Outward: []string{"eth0"}, Busy: []link.Busy{{ID: "build-agent.server",
-		Container: "mesh-build-agent", State: "waiting", Said: "building a"}}}
-	still := link.Report{Outward: []string{"eth0"}, Busy: []link.Busy{{ID: "build-agent.server",
-		Container: "mesh-build-agent", State: "waiting", Said: "building b, a minute on"}}}
-	replaced := link.Report{Outward: []string{"eth0"}, Busy: []link.Busy{{ID: "build-agent.server",
-		Container: "mesh-build-agent", State: "replaced-when-idle"}}}
-	if adoptionFingerprint(waiting) == adoptionFingerprint(quiet) {
-		t.Error("a container starting to wait is not news")
-	}
-	if adoptionFingerprint(still) != adoptionFingerprint(waiting) {
-		t.Error("a wait whose output changed reads as news on every ask")
-	}
-	if adoptionFingerprint(replaced) == adoptionFingerprint(waiting) {
-		t.Error("a container replaced after it waited is not news")
-	}
-	if !worthSaying(link.Report{Busy: replaced.Busy}) {
-		t.Error("a replacement after a wait is not worth saying")
-	}
-}
-
-// While a container waits, a pass is asked for every so often, not at the reconcile's five minutes; with
-// nothing waiting, none (novox/hq ADR 0335 §2).
-func TestAWaitIsAskedAgainSoonerThanTheReconcile(t *testing.T) {
-	if BusyAskEvery >= ReconcileEvery || BusyAskEvery > time.Minute {
+// While a container waits, a pass is asked for every so often, not at some long interval; with nothing waiting, none
+// (novox/hq ADR 0335 §2, ADR 0360 §11).
+func TestAWaitIsAskedAgainSoon(t *testing.T) {
+	if BusyAskEvery > time.Minute {
 		t.Fatalf("a waiting container is asked every %s", BusyAskEvery)
 	}
-	var reconciles atomic.Int32
-	queue := &link.Queue{Reconcile: func(context.Context) (link.Report, bool) {
-		reconciles.Add(1)
-		return link.Report{}, false
-	}}
+	var asked atomic.Int32
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	go queue.Run(ctx)
 	busyWaiting.Store(false)
 	t.Cleanup(func() { busyWaiting.Store(false) })
-	go busyPasses(ctx, queue, 10*time.Millisecond)
+	go busyPasses(ctx, func() { asked.Add(1) }, 10*time.Millisecond)
 	time.Sleep(100 * time.Millisecond)
-	if n := reconciles.Load(); n != 0 {
+	if n := asked.Load(); n != 0 {
 		t.Fatalf("%d passes were asked with nothing waiting", n)
 	}
 	busyWaiting.Store(true)
 	deadline := time.Now().Add(2 * time.Second)
-	for reconciles.Load() == 0 && time.Now().Before(deadline) {
+	for asked.Load() == 0 && time.Now().Before(deadline) {
 		time.Sleep(10 * time.Millisecond)
 	}
-	if reconciles.Load() == 0 {
+	if asked.Load() == 0 {
 		t.Fatal("no pass was asked while a container waits")
 	}
 }

cmd/mesh-host/empty_write_test.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+)
+
+// A composition that names a file the provisioner fills without saying it is filled would have this node-engine write
+// that file empty: its apply is refused, loudly, before anything is written (issue 1945, live on 2026-10-25 at 01:22,
+// when ace, g14 and shanks wrote claude-code's, node-env's and power's files empty).
+func TestAFileItCannotProduceIsNeverWrittenEmpty(t *testing.T) {
+	unit := json.RawMessage(`{"id":"power.after-boot-unit","type":"file","path":"/etc/systemd/system/mesh-power-after-boot.service","mode":"0644","owner-at-runtime":"owned"}`)
+	c := delivery.Composed{Node: "ace", Resources: []json.RawMessage{unit}}
+	d, err := declarationOf(c)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := refuseEmptyWrites(d); err == nil || !strings.Contains(err.Error(), "power.after-boot-unit") {
+		t.Fatalf("a file the provisioner fills, not filled here: %v", err)
+	}
+	c.Filled = []string{"/etc/systemd/system/mesh-power-after-boot.service"}
+	if d, _ = declarationOf(c); refuseEmptyWrites(d) != nil {
+		t.Fatalf("a filled file was refused: %v", refuseEmptyWrites(d))
+	}
+	plain := delivery.Composed{Node: "ace", Resources: []json.RawMessage{json.RawMessage(
+		`{"id":"x.f","type":"file","path":"/etc/x","mode":"0644","content":"x"}`)}}
+	if d, _ = declarationOf(plain); refuseEmptyWrites(d) != nil {
+		t.Fatalf("a file with its content was refused: %v", refuseEmptyWrites(d))
+	}
+}

cmd/mesh-host/epoch_test.go

@@ -1,77 +0,0 @@
-package main
-
-import (
-	"context"
-	"crypto/ed25519"
-	"encoding/json"
-	"errors"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/novox/mesh-host/internal/link"
-	"github.com/novox/mesh-host/internal/store"
-)
-
-// **A declaration from an older lease epoch is refused before anything is applied** (novox/hq to-be
-// 45 §6, ADR 0227 rule 2). The controller that sent it lost its lease and goes on sending; this node
-// applied the holder's. Refused on the host's own apply path — the one the queue's worker runs — before
-// the machine is read or touched, with a report naming what was refused and what is held, and the
-// kept declaration left as it was.
-func TestADeclarationFromAnOlderEpochIsRefusedBeforeAnythingIsApplied(t *testing.T) {
-	dir := t.TempDir()
-	opts := options{state: filepath.Join(dir, "state.json")}
-	_, private, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	target := filepath.Join(dir, "a.conf")
-	declared := func(epoch, sequence int64) store.Declared {
-		body, err := json.Marshal(map[string]any{"declaration": 1, "epoch": epoch, "sequence": sequence,
-			"resources": []any{map[string]any{"id": "a", "type": "file", "path": target, "content": "x\n"}}})
-		if err != nil {
-			t.Fatal(err)
-		}
-		return store.Declared{Declaration: body, Signature: ed25519.Sign(private, body)}
-	}
-	held := declared(57, 3)
-	if err := store.SaveDeclared(store.DeclaredPath(opts.state), held); err != nil {
-		t.Fatal(err)
-	}
-
-	stale := declared(41, 12)
-	report := applyAndKeep(context.Background(), opts, stale.Declaration, &stale, nil, nil)
-	if report.OlderThan == nil || *report.OlderThan != (link.Order{Epoch: 57, Sequence: 3}) ||
-		report.Order != (link.Order{Epoch: 41, Sequence: 12}) || report.Declared != digestOf(stale.Declaration) ||
-		report.Refused == "" {
-		t.Fatalf("the refusal does not name what was refused and what is held: %+v", report)
-	}
-	if _, err := os.Stat(target); !errors.Is(err, os.ErrNotExist) {
-		t.Fatal("the refused declaration touched the machine")
-	}
-	kept, err := store.ReadDeclared(store.DeclaredPath(opts.state))
-	if err != nil || string(kept.Declaration) != string(held.Declaration) {
-		t.Fatal("the refused declaration replaced what this node kept")
-	}
-}
-
-// The queue's counts are kept beside the state and read back by the next host; unreadable is an
-// error, never zero.
-func TestTheNumbersSurviveTheHost(t *testing.T) {
-	state := filepath.Join(t.TempDir(), "state.json")
-	if sequence, refused, err := numbersBeside(state).Read(); err != nil || sequence != 0 || refused != 0 {
-		t.Fatalf("a node that never reported read %d, %d, %v", sequence, refused, err)
-	}
-	if err := numbersBeside(state).Save(41, 2); err != nil {
-		t.Fatal(err)
-	}
-	if sequence, refused, err := numbersBeside(state).Read(); err != nil || sequence != 41 || refused != 2 {
-		t.Fatalf("read back %d, %d, %v", sequence, refused, err)
-	}
-	if err := os.WriteFile(store.NumbersPath(state), []byte(`{"report_sequence":`), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := numbersBeside(state).Read(); err == nil {
-		t.Fatal("unreadable numbers were read as zero")
-	}
-}

cmd/mesh-host/file_references_test.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -9,13 +10,20 @@ import (
 	"testing"
 
 	"git.novox.be/novox/mesh-sdk/go/declaration"
+	"github.com/nats-io/nats.go"
 	"github.com/novox/mesh-host/internal/link"
 )
 
-// aFilesLink is a link that serves objects by name.
-type aFilesLink struct{ objects map[string][]byte }
+// aFilesLink is a link that serves objects by name, or fails every read with err.
+type aFilesLink struct {
+	objects map[string][]byte
+	err     error
+}
 
 func (a aFilesLink) FileObject(_ context.Context, name string, _ int64) ([]byte, error) {
+	if a.err != nil {
+		return nil, a.err
+	}
 	if b, ok := a.objects[name]; ok {
 		return b, nil
 	}
@@ -40,7 +48,7 @@ func TestADeclarationWithAFileByDigestAppliesFromTheObject(t *testing.T) {
 
 	bad := append([]byte(nil), body...)
 	bad[10] ^= 1
-	ctx := link.WithFiles(context.Background(), aFilesLink{map[string][]byte{name: bad}})
+	ctx := link.WithFiles(context.Background(), aFilesLink{objects: map[string][]byte{name: bad}})
 	report := applyAndKeep(ctx, opts, raw, nil, nil, nil)
 	if report.Refused == "" || !strings.Contains(report.Refused, "m.big") {
 		t.Errorf("1695/AC2: a differing object did not refuse the declaration: %+v", report)
@@ -48,8 +56,24 @@ func TestADeclarationWithAFileByDigestAppliesFromTheObject(t *testing.T) {
 	if _, err := os.Stat(target); err == nil {
 		t.Error("1695/AC2: a file was written from an object that differs")
 	}
+	if failedWith(report.Refused).Transient {
+		t.Errorf("an object that differs is a real failure, and was taken as the bus not answering: %s", report.Refused)
+	}
 
-	ctx = link.WithFiles(context.Background(), aFilesLink{map[string][]byte{name: body}})
+	// The bus answers no JetStream request while it reloads its accounts (2026-10-25 23:04:24, mesh-vault on the bus
+	// node): the failure is transient, so the agent tries it again, and the detail kept is its cause, the tail.
+	noResponders := fmt.Errorf("fetching the object 2bd98ebd of this node's own object bucket: reading the chunks of "+
+		"object %s: %w", strings.Repeat("x", 300), nats.ErrNoResponders)
+	ctx = link.WithFiles(context.Background(), aFilesLink{err: noResponders})
+	report = applyAndKeep(ctx, opts, raw, nil, nil, nil)
+	failed := failedWith("a file of this composition could not be had by its digest: file mesh-vault.kept: " + report.Refused)
+	if !failed.Transient || !strings.HasSuffix(failed.Detail, nats.ErrNoResponders.Error()) || len(failed.Detail) > 310 ||
+		!strings.HasPrefix(failed.Detail, "a file of this composition") {
+		t.Errorf("a fetch that met no responders: transient %v, detail %q (%d bytes); want transient, its head and its cause",
+			failed.Transient, failed.Detail, len(failed.Detail))
+	}
+
+	ctx = link.WithFiles(context.Background(), aFilesLink{objects: map[string][]byte{name: body}})
 	report = applyAndKeep(ctx, opts, raw, nil, nil, nil)
 	if report.Refused != "" {
 		t.Fatalf("1695/AC1: refused: %s", report.Refused)

cmd/mesh-host/filling.go

@@ -4,7 +4,9 @@ import (
 	"context"
 	"crypto/ed25519"
 	"errors"
+	"fmt"
 	"path/filepath"
+	"sync/atomic"
 
 	"git.novox.be/novox/mesh-sdk/go/declaration"
 	"github.com/novox/mesh-host/internal/apply"
@@ -16,22 +18,41 @@ import (
 // serveFilling writes filled files on the provisioner client's request for as long as this engine serves (novox/hq
 // ADR 0349 §4). A socket that cannot be served is said once, and this engine goes on applying.
 func serveFilling(ctx context.Context, opts options, signer ed25519.PublicKey, say func(string)) {
-	if err := filling.Serve(ctx, filling.Socket, fillingEngine(opts, signer, say), say); err != nil {
+	e := fillingEngine(opts, signer, say)
+	fillingNow.Store(e)
+	defer fillingNow.CompareAndSwap(e, nil)
+	if err := filling.Serve(ctx, filling.Socket, e, say); err != nil {
 		say("filled files are not written on request on this machine: " + err.Error())
 	}
 }
 
+// fillingNow is the filling this engine serves, for knockFilling; nil while none is served.
+var fillingNow atomic.Pointer[filling.Engine]
+
+// knockFilling tells the provisioner's client to fill again what the filling refused or failed and the declaration
+// applied now may let through (filling.Engine.Knock), once a module's apply or removal settled (agent.Env.Settled).
+// What it told, or why it could not, is said.
+func knockFilling(module string, say func(string)) {
+	e := fillingNow.Load()
+	if e == nil {
+		return
+	}
+	told, err := e.Knock(filling.Socket)
+	switch {
+	case err != nil:
+		say(fmt.Sprintf("after %s settled: %v", module, err))
+	case told != "":
+		say(fmt.Sprintf("after %s settled, the provisioner's client is told to fill again: %s", module, told))
+	}
+}
+
 // fillingEngine is the write of a filled file as this engine does it: the declaration it keeps, verified, read under
 // the apply's lock — the same two locks every apply takes, the process's and the one beside the state — and the file
 // written through the apply (apply.WriteFilled), its outcome recorded in the node's state as an apply's is.
 func fillingEngine(opts options, signer ed25519.PublicKey, say func(string)) *filling.Engine {
 	return &filling.Engine{
 		Declared: func() (*declaration.Declaration, error) {
-			raw, err := store.LoadDeclared(store.DeclaredPath(opts.state), signer)
-			if err != nil {
-				return nil, err
-			}
-			return declaration.Parse(raw)
+			return declaredNow(opts.state, signer)
 		},
 		UIDOf: filling.UIDOf,
 		Lock: func() (func(), error) {

cmd/mesh-host/generation_floor_test.go

@@ -1,40 +0,0 @@
-package main
-
-import (
-	"context"
-	"testing"
-
-	"github.com/novox/mesh-host/internal/apply"
-	"github.com/novox/mesh-host/internal/store"
-	"github.com/novox/mesh-host/internal/system"
-)
-
-// **The generation applied is kept, and a put-back never lowers it**: after a put-back of generation 5
-// over 7, a send from generation 6 is still older than what this machine applied.
-func TestThePutBackDoesNotLowerTheGenerationApplied(t *testing.T) {
-	built, err := system.For("arch")
-	if err != nil || built.Confirm(context.Background(), apply.ExecRunner) != nil {
-		t.Skip("this machine is not one these tests can apply on")
-	}
-	was := builtFor
-	builtFor = "arch"
-	t.Cleanup(func() { builtFor = was })
-	f := machineThatApplied(t, 7)
-
-	newer := f.declared(t, map[string]any{"sequence": 9, "generation": 8}, "docker.conf", f.stays)
-	if r := applyAndKeep(context.Background(), f.opts, newer.Declaration, &newer, nil, nil); r.Refused != "" {
-		t.Fatalf("a newer generation was refused: %s", r.Refused)
-	}
-	back := f.declared(t, map[string]any{"sequence": 10, "generation": 5, "put_back": true}, "docker.conf", f.stays)
-	if r := applyAndKeep(context.Background(), f.opts, back.Declaration, &back, nil, nil); r.Refused != "" {
-		t.Fatalf("a put-back was refused: %s", r.Refused)
-	}
-	state, err := store.Load(f.opts.state)
-	if err != nil || state.Generation != 8 {
-		t.Fatalf("the generation applied is %d after a put-back of 5 over 8 (%v)", state.Generation, err)
-	}
-	stale := f.declared(t, map[string]any{"sequence": 11, "generation": 7}, "docker.conf", f.stays)
-	if r := applyAndKeep(context.Background(), f.opts, stale.Declaration, &stale, nil, nil); r.OlderGeneration == nil {
-		t.Fatalf("a send from generation 7 after 8 was applied because a put-back came between: %+v", r)
-	}
-}

cmd/mesh-host/generation_test.go

@@ -1,170 +0,0 @@
-package main
-
-import (
-	"context"
-	"crypto/ed25519"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/novox/mesh-host/internal/link"
-	"github.com/novox/mesh-host/internal/store"
-)
-
-// The assignment generation a declaration was composed from (novox/hq issue 234).
-//
-// On 2026-10-04 a declaration newer in sequence than every other, and composed from a view of the
-// assignments older than the one this machine had applied, named four fewer modules — and the host,
-// ordering by sequence alone, undeclared all four. The sequence orders arrival; it cannot tell a later
-// send carrying earlier content. The generation can: the node-engine refuses a declaration composed from
-// an older generation than the one it applied, before anything is read from the machine.
-//
-// These read what the report says through its JSON, as the controller does, so they run against a
-// node-engine that has never heard of a generation and fail there for that reason.
-
-// generationFixture is a machine that applied generation 7: a file the mesh declared, kept in its state,
-// and the declaration it kept — signed — that named it.
-type generationFixture struct {
-	opts    options
-	private ed25519.PrivateKey
-	kept    store.Declared
-	// stays is the file the older generation's declaration does not name.
-	stays string
-}
-
-func machineThatApplied(t *testing.T, generation int64) generationFixture {
-	t.Helper()
-	dir := t.TempDir()
-	opts := options{state: filepath.Join(dir, "state.json")}
-	_, private, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	stays := filepath.Join(dir, "docker.conf")
-	if err := os.WriteFile(stays, []byte("kept\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	// The state as a node-engine that applied generation 7 keeps it: the file it owns, and the highest
-	// generation it applied. Written as JSON, so the fixture is the same bytes for any build under test.
-	state := map[string]any{"resources": []any{map[string]any{"id": "docker.conf", "type": "file",
-		"origin": store.OriginDeclared, "target": stays}}, "generation": generation}
-	raw, err := json.Marshal(state)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(opts.state, raw, 0o600); err != nil {
-		t.Fatal(err)
-	}
-	f := generationFixture{opts: opts, private: private, stays: stays}
-	f.kept = f.declared(t, map[string]any{"sequence": 3, "generation": generation}, "docker.conf", stays)
-	if err := store.SaveDeclared(store.DeclaredPath(opts.state), f.kept); err != nil {
-		t.Fatal(err)
-	}
-	return f
-}
-
-// declared is a signed declaration with the envelope's keys given and one file.
-func (f generationFixture) declared(t *testing.T, envelope map[string]any, id, path string) store.Declared {
-	t.Helper()
-	body := map[string]any{"declaration": 1,
-		"resources": []any{map[string]any{"id": id, "type": "file", "path": path, "content": "x\n"}}}
-	for k, v := range envelope {
-		body[k] = v
-	}
-	raw, err := json.Marshal(body)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return store.Declared{Declaration: raw, Signature: ed25519.Sign(f.private, raw)}
-}
-
-// reportJSON is a report as the controller reads it.
-func reportJSON(t *testing.T, r link.Report) map[string]any {
-	t.Helper()
-	raw, err := json.Marshal(r)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var out map[string]any
-	if err := json.Unmarshal(raw, &out); err != nil {
-		t.Fatal(err)
-	}
-	return out
-}
-
-// **A newer sequence from an older generation is refused, and nothing is undeclared** (issue 234).
-func TestANewerSequenceFromAnOlderGenerationIsRefusedAndNothingIsUndeclared(t *testing.T) {
-	f := machineThatApplied(t, 7)
-	other := filepath.Join(filepath.Dir(f.opts.state), "sudo.conf")
-	stale := f.declared(t, map[string]any{"sequence": 9, "generation": 6}, "sudo.conf", other)
-
-	report := applyAndKeep(context.Background(), f.opts, stale.Declaration, &stale, nil, nil)
-	said := reportJSON(t, report)
-	older, _ := said["older_generation"].(map[string]any)
-	if older == nil || older["generation"] != float64(6) || older["applied"] != float64(7) {
-		t.Fatalf("the refusal does not name the generation refused and the one applied: %v", said)
-	}
-	if report.Refused == "" || !strings.Contains(report.Refused, "generation 6") ||
-		!strings.Contains(report.Refused, "generation 7") {
-		t.Errorf("the refusal is not said in words naming both generations: %q", report.Refused)
-	}
-	if report.Declared != digestOf(stale.Declaration) || report.Sequence != 9 {
-		t.Errorf("the refusal does not name the declaration refused, so the mesh cannot name who sent it: %+v", report)
-	}
-	if _, err := os.Stat(f.stays); err != nil {
-		t.Fatalf("a refused declaration undeclared what the machine applied: %v", err)
-	}
-	if _, err := os.Stat(other); err == nil {
-		t.Error("the refused declaration touched the machine")
-	}
-	state, err := store.Load(f.opts.state)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, owned := state.Find("docker.conf"); !owned {
-		t.Error("the refused declaration took a resource out of what this machine owns")
-	}
-	kept, err := store.ReadDeclared(store.DeclaredPath(f.opts.state))
-	if err != nil || string(kept.Declaration) != string(f.kept.Declaration) {
-		t.Error("the refused declaration replaced what this node kept, so the next reconcile would apply it")
-	}
-}
-
-// refusedForItsGeneration says a report refused its declaration for the generation it came from.
-func refusedForItsGeneration(t *testing.T, r link.Report) bool {
-	t.Helper()
-	return reportJSON(t, r)["older_generation"] != nil || strings.Contains(r.Refused, "generation")
-}
-
-// refusedAsUnread says a report refused its declaration as one this node-engine cannot read.
-func refusedAsUnread(r link.Report) bool { return strings.Contains(r.Refused, "not a declaration") }
-
-// **A gate's put-back is applied, whatever generation it carries**: it carries the generation of what it
-// puts back, and says it is a put-back (issue 234).
-func TestAPutBackFromAnOlderGenerationIsNotRefused(t *testing.T) {
-	f := machineThatApplied(t, 7)
-	back := f.declared(t, map[string]any{"sequence": 9, "generation": 5, "put_back": true}, "docker.conf", f.stays)
-	report := applyAndKeep(context.Background(), f.opts, back.Declaration, &back, nil, nil)
-	if refusedForItsGeneration(t, report) || refusedAsUnread(report) {
-		t.Fatalf("a put-back was refused: %s", report.Refused)
-	}
-}
-
-// **A declaration that carries no generation is applied as it always was**: an older controller sends
-// none, and a node-engine that refused it would strand every machine the moment the controller is older.
-func TestADeclarationWithoutAGenerationIsNotRefusedForOne(t *testing.T) {
-	f := machineThatApplied(t, 7)
-	older := f.declared(t, map[string]any{"sequence": 9}, "docker.conf", f.stays)
-	report := applyAndKeep(context.Background(), f.opts, older.Declaration, &older, nil, nil)
-	if refusedForItsGeneration(t, report) || refusedAsUnread(report) {
-		t.Fatalf("a declaration without a generation was refused: %s", report.Refused)
-	}
-	// And the same generation again is no older.
-	same := f.declared(t, map[string]any{"sequence": 10, "generation": 7}, "docker.conf", f.stays)
-	report = applyAndKeep(context.Background(), f.opts, same.Declaration, &same, nil, nil)
-	if refusedForItsGeneration(t, report) || refusedAsUnread(report) {
-		t.Fatalf("a declaration of the generation applied was refused: %s", report.Refused)
-	}
-}

cmd/mesh-host/healthowed_test.go

@@ -0,0 +1,90 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"github.com/novox/mesh-host/internal/link"
+	"github.com/novox/mesh-host/internal/liveness"
+)
+
+// owedBus is a link that takes reports and statements and keeps a have bucket in memory.
+type owedBus struct {
+	mu sync.Mutex
+	kv map[string][]byte
+	rv map[string]uint64
+}
+
+func (b *owedBus) Report(context.Context, string, []byte) error      { return nil }
+func (b *owedBus) Health(context.Context, string, []byte) error      { return nil }
+func (b *owedBus) HaveBind(context.Context) (link.HaveBucket, error) { return b, nil }
+
+func (b *owedBus) Get(_ context.Context, key string) ([]byte, uint64, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	v, ok := b.kv[key]
+	if !ok {
+		return nil, 0, link.ErrHaveAbsent
+	}
+	return v, b.rv[key], nil
+}
+
+func (b *owedBus) Set(_ context.Context, key string, value []byte, revision uint64) error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	if b.rv[key] != revision {
+		return errors.New("wrong last sequence")
+	}
+	b.kv[key], b.rv[key] = value, revision+1
+	return nil
+}
+
+func (b *owedBus) have(key string) (delivery.Have, bool) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	h, err := delivery.DecodeHave(b.kv[key])
+	return h, err == nil
+}
+
+// A module with nothing long-running (xorg) is ok within one look of its apply, not at the five-minute statement: the
+// facts look inside the apply runs while it is applying and judges nothing, and the running write then owes a look,
+// which the health loop makes at once (review of fix 15, B1).
+func TestAModuleWithNothingLongRunningIsOkWithinALookOfItsApply(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	bus := &owedBus{kv: map[string][]byte{}, rv: map[string]uint64{}}
+	queue := &link.Session{Membership: link.Membership{Node: "n1"}, Timeout: time.Second}
+	queue.Attach(ctx, bus)
+	j, err := liveness.Open(filepath.Join(t.TempDir(), "liveness.json"), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fact := link.ModuleFact{Module: "xorg", FP: "src2:" + strings.Repeat("a", 64), Composed: "sha256:" + strings.Repeat("b", 64)}
+	applying := fact
+	applying.Phase = string(delivery.PhaseApplying)
+	queue.NoteModule(ctx, applying)
+	go judgeWhatRuns(ctx, j, queue, func(string) {}, nil, nil)
+	// The facts look inside the apply, while the module is still applying.
+	queue.SayFacts(ctx, link.Report{Health: &link.Health{Contract: link.LivenessContract, At: time.Now().UTC()}})
+	if h, _ := bus.have("n1.xorg"); h.Health != delivery.HealthUnknown {
+		t.Fatalf("judged while applying: %+v", h)
+	}
+	queue.NoteModule(ctx, fact)
+	deadline := time.Now().Add(2 * time.Second) // well within one look (liveness.LookEvery, 15 s)
+	for {
+		h, _ := bus.have("n1.xorg")
+		if h.Phase == delivery.PhaseRunning && h.Health == delivery.HealthOK {
+			return
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("not ok within a look of its apply: %+v", h)
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+}

cmd/mesh-host/inactive.go

@@ -0,0 +1,88 @@
+package main
+
+import (
+	"context"
+	"time"
+
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"github.com/novox/mesh-host/internal/apply"
+	"github.com/novox/mesh-host/internal/liveness"
+)
+
+// heldBy is the containers an open maintenance window holds still, by runtime name (ADR 0189), at now.
+func heldBy(windows *apply.Windows) func(time.Time) map[string]bool {
+	return func(now time.Time) map[string]bool {
+		held := map[string]bool{}
+		for _, w := range windows.Open(now) {
+			for _, name := range w.Holds {
+				held[name] = true
+			}
+		}
+		return held
+	}
+}
+
+// inactiveIn is what the agent asks at its start of a module it believes runs (ADR 0568 §1): whether the machine shows a
+// long-running resource the composition declares running not active, read from the service manager and the container
+// runtime and from no record. A resource held by an open maintenance window, or waiting for a library, is not counted;
+// one that cannot be read is not counted either (unknown is not inactive), and neither is one the manager is restarting.
+func inactiveIn(rt liveness.Runtime, held func(time.Time) map[string]bool) func(context.Context, delivery.Composed) bool {
+	return func(ctx context.Context, c delivery.Composed) bool {
+		d, err := declarationOf(c)
+		if err != nil {
+			return false
+		}
+		var holding map[string]bool
+		if held != nil {
+			holding = held(time.Now())
+		}
+		return anyInactive(ctx, rt, liveness.LongRunning(d, withWaiting(nil, apply.WaitingOnLibrary(d))), holding)
+	}
+}
+
+// anyInactive reads each group of resources once (the containers, each service manager's units) and says whether any is
+// not active.
+func anyInactive(ctx context.Context, rt liveness.Runtime, resources []liveness.Resource, held map[string]bool) bool {
+	type group struct {
+		kind, scope, user string
+		targets           []string
+	}
+	var groups []*group
+	at := map[string]*group{}
+	for _, r := range resources {
+		if r.Kind == liveness.KindContainer && held[r.Target] {
+			continue
+		}
+		g := &group{kind: r.Kind, scope: r.Scope, user: r.User}
+		if r.Kind == liveness.KindContainer {
+			g.scope, g.user = "", ""
+		}
+		key := g.kind + "/" + g.scope + "/" + g.user
+		if r.Kind != liveness.KindContainer {
+			key = "units/" + g.scope + "/" + g.user
+		}
+		if at[key] == nil {
+			at[key] = g
+			groups = append(groups, g)
+		}
+		at[key].targets = append(at[key].targets, r.Target)
+	}
+	for _, g := range groups {
+		var got map[string]liveness.Observed
+		var err error
+		if g.kind == liveness.KindContainer {
+			got, err = rt.Containers(ctx, g.targets)
+		} else {
+			got, err = rt.Units(ctx, g.scope, g.user, g.targets)
+		}
+		if err != nil {
+			continue
+		}
+		for _, t := range g.targets {
+			if o := got[t]; !o.Found || !(o.Running || o.Restarting) {
+				return true
+			}
+		}
+	}
+	return false
+}

cmd/mesh-host/inactive_test.go

@@ -0,0 +1,89 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"github.com/novox/mesh-host/internal/liveness"
+)
+
+// 1957/AC2 and AC4 (unit; ADR 0568 §2, §4): the judge's look acts on a resource that goes down, once per edge. A repeated
+// statement acts nothing, the edge clears when the resource is healthy again, and a resource held, restarting, starting or
+// missing (the other path's) is no edge.
+func testOnlyAResourceNewlyDownIsAnEdge(t *testing.T) {
+	state := func(id, s, reason string, missing bool) liveness.State {
+		return liveness.State{Resource: liveness.Resource{Module: "dnsmasq", ID: id}, State: s, Reason: reason, Missing: missing}
+	}
+	down := state("dnsmasq.unit", liveness.Unhealthy, liveness.ReasonDown, false)
+	steps := []struct {
+		name string
+		st   []liveness.State
+		want []string
+	}{
+		{"down: an edge", []liveness.State{down}, []string{"dnsmasq"}},
+		{"said again while down: none", []liveness.State{down}, nil},
+		{"healthy again: clears", []liveness.State{state("dnsmasq.unit", liveness.Healthy, "", false)}, nil},
+		{"down again: an edge", []liveness.State{down}, []string{"dnsmasq"}},
+		{"held by a window: none", []liveness.State{state("dnsmasq.unit", liveness.Held, "", false)}, nil},
+		{"restarting: none", []liveness.State{state("dnsmasq.unit", liveness.Unhealthy, liveness.ReasonRestarting, false)}, nil},
+		{"starting: none", []liveness.State{state("dnsmasq.unit", liveness.Starting, "", false)}, nil},
+		{"missing: the other path's", []liveness.State{state("dnsmasq.unit", liveness.Unhealthy, liveness.ReasonDown, true)}, nil},
+	}
+	var last map[string]bool
+	for _, s := range steps {
+		var got []string
+		got, last = newlyInactive(last, liveness.Statement{Resources: s.st})
+		if len(got) != len(s.want) || (len(got) == 1 && got[0] != s.want[0]) {
+			t.Fatalf("%s: acted on %v, want %v", s.name, got, s.want)
+		}
+	}
+}
+
+type fakeRuntime struct {
+	units      map[string]liveness.Observed
+	containers map[string]liveness.Observed
+	err        error
+}
+
+func (f fakeRuntime) Containers(_ context.Context, _ []string) (map[string]liveness.Observed, error) {
+	return f.containers, f.err
+}
+func (f fakeRuntime) Units(_ context.Context, _, _ string, _ []string) (map[string]liveness.Observed, error) {
+	return f.units, f.err
+}
+
+// 1957/AC1 (unit; ADR 0568 §1): the machine's facts say a declared-running resource is not active when its unit is stopped
+// or unknown to the manager; everything up, a restart in progress, a read that failed and a container held by a
+// maintenance window are not.
+func testTheMachineShowsAResourceNotActive(t *testing.T) {
+	svc := []byte(`{"id":"dnsmasq.unit","type":"service","unit":"dnsmasq.service","state":"running","module":"dnsmasq"}`)
+	ctr := []byte(`{"id":"dnsmasq.box","type":"container","name":"box","image":"x@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","module":"dnsmasq"}`)
+	up := liveness.Observed{Found: true, Running: true}
+	for _, c := range []struct {
+		name string
+		rt   fakeRuntime
+		held map[string]bool
+		want bool
+	}{
+		{"all up", fakeRuntime{units: map[string]liveness.Observed{"dnsmasq.service": up}, containers: map[string]liveness.Observed{"box": up}}, nil, false},
+		{"unit inactive", fakeRuntime{units: map[string]liveness.Observed{"dnsmasq.service": {Found: true}}, containers: map[string]liveness.Observed{"box": up}}, nil, true},
+		{"unit unknown to the manager", fakeRuntime{containers: map[string]liveness.Observed{"box": up}}, nil, true},
+		{"unit restarting", fakeRuntime{units: map[string]liveness.Observed{"dnsmasq.service": {Found: true, Restarting: true}}, containers: map[string]liveness.Observed{"box": up}}, nil, false},
+		{"container not running", fakeRuntime{units: map[string]liveness.Observed{"dnsmasq.service": up}, containers: map[string]liveness.Observed{"box": {Found: true}}}, nil, true},
+		{"container held by a window", fakeRuntime{units: map[string]liveness.Observed{"dnsmasq.service": up}, containers: map[string]liveness.Observed{"box": {Found: true}}}, map[string]bool{"box": true}, false},
+		{"unread", fakeRuntime{err: errors.New("the service manager could not be read")}, nil, false},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			d, err := declarationOf(delivery.Composed{Node: "n1", Module: "dnsmasq", Resources: []json.RawMessage{svc, ctr}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := anyInactive(context.Background(), c.rt, liveness.LongRunning(d, nil), c.held); got != c.want {
+				t.Fatalf("inactive = %v, want %v", got, c.want)
+			}
+		})
+	}
+}

cmd/mesh-host/judge_directories.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 	"fmt"
 
-	"git.novox.be/novox/mesh-sdk/go/declaration"
 	"github.com/novox/mesh-host/internal/apply"
 	"github.com/novox/mesh-host/internal/link"
 	"github.com/novox/mesh-host/internal/store"
@@ -13,16 +12,12 @@ import (
 // judgeDirectories judges every directory of the declaration this node keeps, read-only (novox/hq issue 358): which
 // the walk that follows no link another account could make would refuse. Nothing is made, chmodded or chowned.
 func judgeDirectories(statePath string) (string, error) {
-	kept, err := store.ReadDeclared(store.DeclaredPath(statePath))
+	d, err := declaredNow(statePath, nil)
 	if errors.Is(err, store.ErrNothingDeclared) {
 		return "", errors.New("this node keeps no declaration, so it is declared no directory")
 	}
 	if err != nil {
-		return "", err
-	}
-	d, err := declaration.Parse(kept.Declaration)
-	if err != nil {
-		return "", fmt.Errorf("the declaration this node keeps does not read: %w", err)
+		return "", fmt.Errorf("what runs on this node does not read: %w", err)
 	}
 	return apply.JudgeDirectories(d), nil
 }

cmd/mesh-host/libraries.go

@@ -251,16 +251,12 @@ func startKeeping(ctx context.Context, say func(string)) {
 // declaration this node keeps, and run beside the applies.
 func accessActFrom(statePath string, timeout time.Duration) link.AccessActFunc {
 	return func(act link.AccessAct) (string, error) {
-		kept, err := store.ReadDeclared(store.DeclaredPath(statePath))
+		d, err := declaredNow(statePath, nil)
 		if errors.Is(err, store.ErrNothingDeclared) {
 			return "", errors.New("this node keeps no declaration, so it is declared no library")
 		}
 		if err != nil {
-			return "", err
-		}
-		d, err := declaration.Parse(kept.Declaration)
-		if err != nil {
-			return "", fmt.Errorf("the declaration this node keeps does not read: %w", err)
+			return "", fmt.Errorf("what runs on this node does not read: %w", err)
 		}
 		ctx, cancel := context.WithTimeout(context.Background(), timeout)
 		defer cancel()

cmd/mesh-host/local_network_test.go

@@ -1,29 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	"github.com/novox/mesh-host/internal/link"
-	"github.com/novox/mesh-host/internal/outward"
-	"github.com/novox/mesh-host/internal/profile"
-)
-
-func reportOn(networks ...outward.Network) link.Report {
-	return link.Report{Outward: []string{"eth0"},
-		Profile: profileAsReported(profile.Profile{Machine: &profile.Machine{Networks: networks}})}
-}
-
-// **A change of the networks a machine is attached to is said unasked** (novox/hq ADR 0340 §7): a port
-// reached from the local network is admitted from them, so a laptop that joins another network is said at
-// the next reconcile, not at the next push — and the same networks again are not news.
-func TestAChangedNetworkIsSaidUnasked(t *testing.T) {
-	w := &adoptionWatch{}
-	home := reportOn(outward.Network{Link: "eth0", Network: "192.168.1.0/24"})
-	w.said(home)
-	if w.differs(reportOn(outward.Network{Link: "eth0", Network: "192.168.1.0/24"})) {
-		t.Fatal("the same networks read as a change, so the machine would speak on every reconcile")
-	}
-	if !w.differs(reportOn(outward.Network{Link: "eth0", Network: "10.20.0.0/16"})) {
-		t.Fatal("a machine that moved to another network does not say so until it is pushed to")
-	}
-}

cmd/mesh-host/machine_refresh_test.go

@@ -1,107 +0,0 @@
-package main
-
-import (
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/novox/mesh-host/internal/link"
-)
-
-// Defends novox/hq issue 160: a machine nobody pushed to still says what it is made of once a day, so the
-// newest of it the mesh holds is no older than a day. Before, the reconcile said it only with something
-// else (a hold, a firewall, an outward link changed), and a converged machine's picture was as old as the
-// last delivery to it.
-func TestAMachineNobodyPushedToSaysWhatItIsOnceADay(t *testing.T) {
-	at := time.Date(2026, 10, 12, 9, 0, 0, 0, time.UTC)
-	w := &adoptionWatch{now: func() time.Time { return at }}
-	quiet := link.Report{Outward: []string{"wlan0"},
-		Profile: map[string]any{"machine": map[string]any{"observed_at": at}}}
-
-	if !w.news(quiet) {
-		t.Fatal("the first reconcile after the engine started did not say what the machine is")
-	}
-	w.said(quiet)
-
-	for _, after := range []time.Duration{5 * time.Minute, 12 * time.Hour, 22*time.Hour + 55*time.Minute} {
-		at = time.Date(2026, 10, 12, 9, 0, 0, 0, time.UTC).Add(after)
-		if w.news(quiet) {
-			t.Errorf("%s after the mesh heard it, an unchanged reconcile was said again", after)
-		}
-	}
-	// The reconcile that falls past 23 hours says it, so it reaches the mesh inside the day.
-	at = time.Date(2026, 10, 12, 9, 0, 0, 0, time.UTC).Add(23*time.Hour + 5*time.Minute)
-	if !w.news(quiet) {
-		t.Fatal("a day on, the reconcile did not say what the machine is")
-	}
-	w.said(quiet)
-	at = at.Add(5 * time.Minute)
-	if w.news(quiet) {
-		t.Error("once said, it was said again at the next reconcile")
-	}
-}
-
-// A delivery's account carries the profile too: heard, it starts the day again.
-func TestADeliveryHeardStartsTheDayAgain(t *testing.T) {
-	at := time.Date(2026, 10, 12, 9, 0, 0, 0, time.UTC)
-	w := &adoptionWatch{now: func() time.Time { return at }}
-	report := link.Report{Outward: []string{"eth0"}, Profile: map[string]any{"capabilities": []any{}}}
-	w.said(report)
-	at = at.Add(20 * time.Hour)
-	w.said(report) // a delivery's apply
-	at = at.Add(20 * time.Hour)
-	if w.news(report) {
-		t.Error("said again unasked 20 hours after a delivery told the mesh")
-	}
-}
-
-// A refusal carries nothing about the machine, so it is never said for being a day old.
-func TestARefusalIsNotSaidForTheMachinesSake(t *testing.T) {
-	at := time.Date(2026, 10, 12, 9, 0, 0, 0, time.UTC)
-	w := &adoptionWatch{now: func() time.Time { return at }}
-	if w.machineDue(link.Report{Refused: "no"}) {
-		t.Error("a refusal was due for what the machine is made of")
-	}
-}
-
-// A laptop that slept still says what it is within a day of wall time (review of mesh-host#92). Go's monotonic
-// clock stops while a machine is suspended, and Sub between two times that both carry a monotonic reading uses
-// it, so a watch that kept one would count a day asleep as almost nothing. Simulated with a clock that first
-// reads now (a monotonic reading), and after the sleep reads the wall time a day on: the watch must keep no
-// monotonic reading, and judge the day as the wall clock says it.
-func TestALaptopThatSleptStillSaysWhatItIsWithinADay(t *testing.T) {
-	before := time.Now() // carries a monotonic reading
-	asleep := before.Add(3 * time.Second)
-	if asleep.Sub(before) != 3*time.Second {
-		t.Fatal("the monotonic reading is not what this test simulates with")
-	}
-	calls := 0
-	w := &adoptionWatch{now: func() time.Time {
-		calls++
-		if calls == 1 {
-			return before
-		}
-		// The wall clock a day on, as a machine's clock reads after waking.
-		return asleep.Round(0).Add(24 * time.Hour)
-	}}
-	report := link.Report{Outward: []string{"wlan0"}, Profile: map[string]any{"capabilities": []any{}}}
-	w.said(report)
-	if strings.Contains(w.machineSaid.String(), "m=") {
-		t.Fatalf("the watch kept a monotonic reading (%s): a sleep would not count toward the day", w.machineSaid)
-	}
-	if !w.news(report) {
-		t.Error("a day of wall time on, a laptop that slept did not say what it is")
-	}
-}
-
-// And the watch's own clock never carries a monotonic reading.
-func TestTheWatchClockIsWallTime(t *testing.T) {
-	w := &adoptionWatch{}
-	if s := w.clock().String(); strings.Contains(s, "m=") {
-		t.Errorf("the watch's clock carries a monotonic reading: %s", s)
-	}
-	w = &adoptionWatch{now: time.Now}
-	if s := w.clock().String(); strings.Contains(s, "m=") {
-		t.Errorf("a given clock's time kept its monotonic reading: %s", s)
-	}
-}

cmd/mesh-host/main_test.go

@@ -3,7 +3,6 @@ package main
 import (
 	"bytes"
 	"context"
-	"crypto/ed25519"
 	"encoding/json"
 	"errors"
 	"os"
@@ -14,8 +13,6 @@ import (
 
 	"git.novox.be/novox/mesh-sdk/go/declaration"
 	"github.com/novox/mesh-host/internal/apply"
-	"github.com/novox/mesh-host/internal/bundle"
-	"github.com/novox/mesh-host/internal/identity"
 	"github.com/novox/mesh-host/internal/link"
 	"github.com/novox/mesh-host/internal/store"
 	"github.com/novox/mesh-host/internal/system"
@@ -98,26 +95,6 @@ func TestNoCommandIsNotAnError(t *testing.T) {
 	}
 }
 
-func TestApplyNeedsExactlyOneDeclaration(t *testing.T) {
-	// `apply` takes a file where every other command takes nothing, so the leftover-argument
-	// rule has an exception — and an exception is where a parser stops refusing things it
-	// should. Both directions are checked.
-	if _, _, err := parseArgs([]string{"apply"}); err == nil {
-		t.Error("apply with no file was accepted")
-	}
-	if _, _, err := parseArgs([]string{"apply", "a.json", "b.json"}); err == nil {
-		t.Error("apply with two files was accepted")
-	}
-
-	command, opts, err := parseArgs([]string{"apply", "decl.json", "--dry-run"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if command != "apply" || opts.file != "decl.json" || !opts.dryRun {
-		t.Errorf("parsed as command=%q file=%q dry-run=%v", command, opts.file, opts.dryRun)
-	}
-}
-
 func TestTheStateHasADocumentedDefault(t *testing.T) {
 	// A host that wrote its state somewhere unexpected would forget what it owns on the next
 	// run, and then leave everything it had applied behind forever.
@@ -135,93 +112,22 @@ func TestAFlagAfterAPositionalIsRead(t *testing.T) {
 	// off the front fixed the flag after the COMMAND and not the flag after its ARGUMENT: the
 	// standard library stops at the first non-flag argument wherever that argument is.
 	for _, args := range [][]string{
-		{"apply", "decl.json", "--dry-run", "--json"},
-		{"apply", "--dry-run", "decl.json", "--json"},
-		{"apply", "--dry-run", "--json", "decl.json"},
+		{"hand-over", "decl.json", "--dry-run", "--json"},
+		{"hand-over", "--dry-run", "decl.json", "--json"},
+		{"hand-over", "--dry-run", "--json", "decl.json"},
 	} {
 		command, opts, err := parseArgs(args)
 		if err != nil {
 			t.Errorf("%v: unexpected error: %v", args, err)
 			continue
 		}
-		if command != "apply" || opts.file != "decl.json" || !opts.dryRun || !opts.json {
+		if command != "hand-over" || opts.file != "decl.json" || !opts.dryRun || !opts.json {
 			t.Errorf("%v parsed as file=%q dry-run=%v json=%v",
 				args, opts.file, opts.dryRun, opts.json)
 		}
 	}
 }
 
-// Defends novox/hq ADR 0100: a reconcile on an adopted node speaks unasked only when what it holds
-// or its firewall changed — which is how a predecessor still writing is caught, without a report
-// every five minutes saying nothing new.
-func TestAReconcileSpeaksOnlyWhenWhatIsHeldChanged(t *testing.T) {
-	w := &adoptionWatch{}
-	held := link.Report{Firewall: "ufw", Held: []link.Held{{ID: "hello-web.page"}, {ID: "hello-web.server"}}}
-	if !w.changed(held) {
-		t.Fatal("the first report of a hold was not said")
-	}
-	again := link.Report{Firewall: "ufw", Held: []link.Held{{ID: "hello-web.server"}, {ID: "hello-web.page"}}}
-	if w.changed(again) {
-		t.Error("the same holds in another order were said again")
-	}
-	rewritten := link.Report{Firewall: "ufw", Held: []link.Held{{ID: "hello-web.page", Changed: "rewritten"}, {ID: "hello-web.server"}}}
-	if !w.changed(rewritten) {
-		t.Error("a held file rewritten by something else was not said")
-	}
-	if !w.changed(link.Report{Firewall: "none", Held: rewritten.Held}) {
-		t.Error("a changed firewall was not said")
-	}
-	// What filters the machine is part of it (novox/hq ADR 0168): a predecessor's chain removed by
-	// hand, or the found firewall enabled again, is said without being asked.
-	filtered := link.Report{Firewall: "none", Held: rewritten.Held,
-		Filters: []link.Filter{{Where: "chain HAL-MESH-ONLY (iptables-legacy)", Owner: "other", Refuses: "-j DROP"}}}
-	if !w.changed(filtered) {
-		t.Error("a filter appearing was not said")
-	}
-	if !w.changed(link.Report{Firewall: "none", Held: rewritten.Held}) {
-		t.Error("a filter removed was not said")
-	}
-	if !w.changed(link.Report{Firewall: "none", Held: rewritten.Held, FoundFirewall: &link.FoundFirewall{Kind: "ufw", Active: true}}) {
-		t.Error("the found firewall coming back was not said")
-	}
-	if !worthSaying(link.Report{Filters: filtered.Filters}) {
-		t.Error("a report carrying only what filters the machine is not worth saying")
-	}
-}
-
-// What the mesh heard — a delivery's account as much as a reconcile's — counts as said: the queue
-// tells the watch every report the broker took (link.Queue.Heard).
-func TestWhatTheMeshHeardCountsAsSaid(t *testing.T) {
-	w := &adoptionWatch{}
-	report := link.Report{Firewall: "ufw", Held: []link.Held{{ID: "a"}}}
-	heard := w.said
-	heard(report)
-	if w.changed(report) {
-		t.Error("a reconcile repeated what the mesh had just heard")
-	}
-}
-
-func TestAReconcileSpeaksWhenWhatIsReachableChanged(t *testing.T) {
-	// The controller previews a flip from what the node last said is reachable; a port that opened
-	// since must reach it without waiting for the next delivery (novox/hq ADR 0100).
-	w := &adoptionWatch{}
-	before := link.Report{Firewall: "ufw", Reachable: []link.Reach{
-		{Protocol: "tcp", Address: "0.0.0.0", Port: 22, By: "sshd"}}}
-	if !w.changed(before) {
-		t.Fatal("the first report was not said")
-	}
-	reordered := link.Report{Firewall: "ufw", Reachable: []link.Reach{
-		{Protocol: "tcp", Address: "0.0.0.0", Port: 22, By: "sshd"}}}
-	if w.changed(reordered) {
-		t.Error("the same reachable set was said again")
-	}
-	opened := link.Report{Firewall: "ufw", Reachable: append(before.Reachable,
-		link.Reach{Protocol: "tcp", Address: "0.0.0.0", Port: 8080, By: "hello-web", Published: true, ContainerPort: 80})}
-	if !w.changed(opened) {
-		t.Error("a newly published port was not said")
-	}
-}
-
 // Defends the node's own record: the link and the reconcile loop both apply, and each reads the
 // state, acts, and writes it back — so they must not run at the same time, or the last save loses
 // what the other recorded.
@@ -270,24 +176,6 @@ func TestOnlyOneApplyRunsAtATime(t *testing.T) {
 	}
 }
 
-// Defends novox/hq ADR 0100: a change is counted as said only once the mesh has been told. Queued
-// and lost — the link down when the reconcile spoke — it must be said again.
-func TestAChangeThatNeverReachedTheMeshIsSaidAgain(t *testing.T) {
-	w := &adoptionWatch{}
-	held := link.Report{Firewall: "ufw", Held: []link.Held{{ID: "hello-web.page", Changed: "rewritten"}}}
-	if !w.differs(held) {
-		t.Fatal("the first report of a change was not new")
-	}
-	// The link was down: nothing published it, so nothing says it was said.
-	if !w.differs(held) {
-		t.Error("a change that never reached the mesh was counted as said")
-	}
-	w.said(held)
-	if w.differs(held) {
-		t.Error("a change the mesh was told was said again")
-	}
-}
-
 // Defends novox/hq issue 104: a declaration for the other mode than this node is in is refused at
 // the point of application, whichever command delivered it, naming both — an adopted control-node
 // once applied its converged genesis bundle and closed itself for forty-five minutes.
@@ -468,125 +356,6 @@ func TestADryRunChangesNothingAndListsTheActions(t *testing.T) {
 	}
 }
 
-// Defends novox/hq issue 104: once the mesh has told this node anything, `reconcile` holds it to
-// that — never to the bundle the host carries, which genesis consumed.
-func TestReconcileAfterAControllerDeclarationDoesNotReapplyTheBundle(t *testing.T) {
-	was := builtFor
-	builtFor = "arch"
-	t.Cleanup(func() { builtFor = was })
-	opts := stateWithMode(t, store.ModeAdopted)
-
-	controllerPublic, controllerPrivate, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	said := []byte(`{"declaration":1,"adoption":{"taken":[]},"resources":[{"id":"a","type":"file","path":"/tmp/a","content":"x\n"}]}`)
-	if err := store.SaveDeclared(store.DeclaredPath(opts.state), store.Declared{Declaration: said,
-		Signature: ed25519.Sign(controllerPrivate, said)}); err != nil {
-		t.Fatal(err)
-	}
-
-	// Told, and unable to prove by whom: refused, and the bundle is not applied in its place.
-	_, _, _, err = reconcileSource(opts)
-	if err == nil || !strings.Contains(err.Error(), "not applied in its place") {
-		t.Errorf("a node that cannot prove what it was told fell back to something: %v", err)
-	}
-
-	mine, err := identity.Generate("workstation")
-	if err != nil {
-		t.Fatal(err)
-	}
-	mine.Membership = identity.Membership{Broker: "198.51.100.10:5671", Fingerprint: "sha256:0",
-		Signer: controllerPublic, Password: "issued"}
-	if err := identity.Save(identity.Path(opts.state), mine); err != nil {
-		t.Fatal(err)
-	}
-	d, raw, from, err := reconcileSource(opts)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if from != fromDeclared || !bytes.Equal(raw, said) || d.Adoption == nil {
-		t.Errorf("reconcile chose %d with %d bytes, not what the mesh last said", from, len(raw))
-	}
-
-	// And before the mesh has said anything: the bundle, as it always was. A test binary carries
-	// only the placeholder, and asking for it is what proves the path.
-	if err := os.Remove(store.DeclaredPath(opts.state)); err != nil {
-		t.Fatal(err)
-	}
-	_, _, _, err = reconcileSource(opts)
-	if !errors.Is(err, bundle.ErrEmpty) {
-		t.Errorf("with nothing said, reconcile did not reach for the carried bundle: %v", err)
-	}
-}
-
-// **A machine says which links face outside without being asked.**
-//
-// The mesh composes no filter for a machine that has not said (novox/hq ADR 0140), and a machine only
-// speaks unasked when this fingerprint changes. Left out of it, a machine that has just learnt to say
-// could speak only when a declaration arrived — and a declaration cannot be composed until it has
-// spoken. A machine waiting for a push that is waiting for the machine.
-func TestANewOutwardLinkIsSaidUnasked(t *testing.T) {
-	w := &adoptionWatch{}
-	first := link.Report{Firewall: "none"}
-	if !w.differs(first) {
-		t.Fatal("the first report should differ from nothing")
-	}
-	w.said(first)
-
-	// Only the links changed, and nothing about adoption.
-	learnt := link.Report{Firewall: "none", Outward: []string{"eth0"}}
-	if !w.differs(learnt) {
-		t.Fatal("a machine that has just learnt which links face outside would never say so, " +
-			"and could then never be sent a filter")
-	}
-	w.said(learnt)
-	if w.differs(link.Report{Firewall: "none", Outward: []string{"eth0"}}) {
-		t.Fatal("the same links are reported as a change, so the machine would speak on every reconcile")
-	}
-
-	// And a link that changes — a laptop moving from a cable to a radio — is said too, because the
-	// filter is written around the old one until it is.
-	if !w.differs(link.Report{Firewall: "none", Outward: []string{"wlan0"}}) {
-		t.Fatal("a changed outward link is not said, so the filter stays written around the old one")
-	}
-}
-
-// **A converged machine can say which links face outside, unasked.**
-//
-// A reconcile is otherwise silent, and the condition deciding when it speaks asked only what an
-// adopted node reports — what it holds, and the firewall it found. A converged node has neither, so
-// it could speak only in reply to a declaration, and the mesh composes no declaration for a node
-// that has not said which links face outside (novox/hq ADR 0140). Measured: three converged machines
-// sat silent while the control plane refused to send them a filter.
-func TestAConvergedMachineSaysItsOutwardLinksUnasked(t *testing.T) {
-	// A converged node's reconcile: nothing held, no found firewall, and the links it can see.
-	converged := link.Report{Outward: []string{"eth0"}}
-	if !worthSaying(converged) {
-		t.Fatal("a converged machine cannot say which links face outside, so it can never be " +
-			"sent a filter — a machine waiting for a push that is waiting for the machine")
-	}
-
-	// An adopted node's reasons still hold, because that is how a predecessor still writing is caught.
-	if !worthSaying(link.Report{Firewall: "ufw"}) {
-		t.Fatal("an adopted machine no longer says which firewall it found")
-	}
-	if !worthSaying(link.Report{Held: []link.Held{{ID: "a-file"}}}) {
-		t.Fatal("an adopted machine no longer says what it holds")
-	}
-
-	// And a reconcile with nothing to say stays silent, or every machine speaks every five minutes
-	// about nothing.
-	if worthSaying(link.Report{}) {
-		t.Fatal("a reconcile with nothing to say speaks anyway")
-	}
-
-	// A refused report says nothing about the machine; the refusal is for the console.
-	if worthSaying(link.Report{Outward: []string{"eth0"}, Refused: "not for this node"}) {
-		t.Fatal("a refused report is offered as news about the machine")
-	}
-}
-
 // **A host running as a service says what its apply did.**
 //
 // The serving path passed nil where the apply writes its detail, and nil is silence. The one-shot path
@@ -611,63 +380,3 @@ func TestTheApplysLogIsNeverNil(t *testing.T) {
 		t.Fatalf("the apply's detail did not reach the caller's announce: %v", said)
 	}
 }
-
-// Defends novox/hq issues 257 and 261: a reconcile due while the link applies a newer declaration
-// applies that newer one once its turn comes — never the one kept when its timer fired. Read before
-// waiting, it gave back a module assigned a second earlier, and reported a declaration the mesh no
-// longer recorded as sent.
-func TestAReconcileAppliesWhatWasKeptWhenItsTurnComes(t *testing.T) {
-	built, err := system.For("arch")
-	if err != nil || built.Confirm(context.Background(), apply.ExecRunner) != nil {
-		t.Skip("this machine is not one these tests can apply on")
-	}
-	was := builtFor
-	builtFor = "arch"
-	t.Cleanup(func() { builtFor = was })
-	dir := t.TempDir()
-	opts := options{state: filepath.Join(dir, "state.json")}
-	public, private, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	target := filepath.Join(dir, "a.conf")
-	kept := func(content string) store.Declared {
-		body := []byte(`{"declaration":1,"resources":[{"id":"a","type":"file","path":"` + target +
-			`","content":"` + content + `\n"}]}`)
-		return store.Declared{Declaration: body, Signature: ed25519.Sign(private, body)}
-	}
-	if err := store.SaveDeclared(store.DeclaredPath(opts.state), kept("older")); err != nil {
-		t.Fatal(err)
-	}
-
-	// The link is applying: the reconcile's timer fires and it waits its turn.
-	applying.Lock()
-	done := make(chan error, 1)
-	go func() {
-		_, err := reapplyKept(context.Background(), opts, public, nil, nil)
-		done <- err
-	}()
-	time.Sleep(50 * time.Millisecond)
-	// The link's apply ends by keeping the newer declaration, and lets go.
-	if err := store.SaveDeclared(store.DeclaredPath(opts.state), kept("newer")); err != nil {
-		applying.Unlock()
-		t.Fatal(err)
-	}
-	applying.Unlock()
-
-	select {
-	case err := <-done:
-		if err != nil {
-			t.Fatal(err)
-		}
-	case <-time.After(10 * time.Second):
-		t.Fatal("the reconcile never ran once the node was free")
-	}
-	got, err := os.ReadFile(target)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(got) != "newer\n" {
-		t.Errorf("the reconcile applied %q, what was kept before the newer declaration", got)
-	}
-}

cmd/mesh-host/meshcli.go

@@ -11,14 +11,14 @@ import (
 // serveMeshCLI answers mesh-cli on this machine for as long as this engine serves (novox/hq ADR 0272): the account
 // from the kernel, the line asked of the controller over the link open at the time. A socket that cannot be served
 // is said once, and this engine goes on applying; mesh-cli then says the engine does not answer.
-func serveMeshCLI(ctx context.Context, queue *link.Queue, say func(string)) {
+func serveMeshCLI(ctx context.Context, queue *link.Session, say func(string)) {
 	if err := meshcli.Serve(ctx, cli.Socket, forwardOver(queue), say); err != nil {
 		say("mesh-cli is not answered on this machine: " + err.Error())
 	}
 }
 
 // forwardOver asks the controller over the queue's link, and follows the line to what came of it.
-func forwardOver(queue *link.Queue) meshcli.Forward {
+func forwardOver(queue *link.Session) meshcli.Forward {
 	return func(ctx context.Context, asked meshcli.Asked) cli.Answer {
 		return meshcli.AskTheController(ctx, queue.AskController, asked)
 	}

cmd/mesh-host/movesecret.go

@@ -27,7 +27,7 @@ type vaultAsk func(verb string, args any) (json.RawMessage, error)
 
 // moveSecretFrom is the engine's move: this machine's sealing key, read for each ask, and the vault asked over
 // the link open now.
-func moveSecretFrom(statePath string, queue *link.Queue) link.MoveSecretFunc {
+func moveSecretFrom(statePath string, queue *link.Session) link.MoveSecretFunc {
 	return func(m link.MoveSecret) (link.MovedSecret, error) {
 		key, err := identity.LoadSealingKey(identity.SealingKeyPath(statePath))
 		if err != nil {

cmd/mesh-host/no_check_script_test.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// The checker runs gofmt, go vet and both test levels by Go's convention, and the build module starts the bus the
+// integration level needs (novox/hq ADR 0529): no script of the repository's own runs beside them.
+func TestTheRepositoryHoldsNoCheckScript(t *testing.T) {
+	if _, err := os.Stat(filepath.Join("..", "..", "merge-check.sh")); err == nil {
+		t.Fatal("merge-check.sh is back: the checker's levels run the tests")
+	}
+}

cmd/mesh-host/nodeagent_integration_test.go

@@ -0,0 +1,777 @@
+//go:build integration
+
+package main
+
+import (
+	"context"
+	"crypto/ed25519"
+	"encoding/base64"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"git.novox.be/novox/mesh-sdk/go/buscompose"
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"github.com/nats-io/nats-server/v2/server"
+	"github.com/nats-io/nats.go"
+	"github.com/novox/mesh-host/internal/agent"
+	"github.com/novox/mesh-host/internal/link"
+	"github.com/novox/mesh-host/internal/selfcompose"
+	"github.com/novox/mesh-host/internal/store"
+)
+
+// The node agent whole, against a real bus with JetStream started in the test: the wants bucket, the node's composition
+// bucket and the have bucket, a session on the bus, and the real apply of a module's composition into a directory of the
+// test. R6-A AC1, AC5 and AC9 (novox/hq ADR 0539).
+
+const itNode = "it1"
+
+type itBed struct {
+	t    *testing.T
+	conn *nats.Conn
+	js   nats.JetStreamContext
+	// nodeConn and nodeJS are the node's own, under its real grant (buscompose.PermissionsFor, KindNode): the agent runs
+	// on them, so a watch or a read the grant does not allow fails here as it fails on the bus (issue 1126, 2026-10-27
+	// 09:21: a watch of every have key stopped every node agent). conn is the test's, unrestricted, for setting up.
+	nodeConn *nats.Conn
+	nodeJS   nats.JetStreamContext
+	wants    nats.KeyValue
+	composed nats.KeyValue
+	haves    nats.KeyValue
+	dir      string
+	opts     options
+	session  *link.Session
+	controll ed25519.PrivateKey
+	operator ed25519.PrivateKey
+	said     []string
+	// refusals are the bus's asynchronous errors on the node's connection: each permissions violation it met.
+	refusals []string
+	mu       sync.Mutex
+}
+
+// aServer is an embedded bus with JetStream and two users: the test's, unrestricted, and the node's, granted exactly what
+// buscompose.PermissionsFor gives a node (KindNode); it answers a connection of each.
+func aServer(t *testing.T, principal buscompose.Principal, refused func(error)) (admin, node *nats.Conn) {
+	t.Helper()
+	perms, err := buscompose.PermissionsFor(principal)
+	if err != nil {
+		t.Fatal(err)
+	}
+	granted := &server.Permissions{Publish: &server.SubjectPermission{Allow: perms.Publish, Deny: perms.PublishDeny},
+		Subscribe: &server.SubjectPermission{Allow: perms.Subscribe}}
+	if perms.AllowResponses {
+		granted.Response = &server.ResponsePermission{MaxMsgs: 1, Expires: buscompose.ResponseTTL}
+	}
+	nodeUser := buscompose.Principal{Kind: buscompose.KindNode, Node: itNode}.Username()
+	srv, err := server.NewServer(&server.Options{Port: -1, JetStream: true, StoreDir: t.TempDir(), NoLog: true, NoSigs: true,
+		Users: []*server.User{{Username: "test", Password: "test"}, {Username: nodeUser, Password: "node", Permissions: granted}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	go srv.Start()
+	if !srv.ReadyForConnections(10 * time.Second) {
+		t.Fatal("the embedded server did not start")
+	}
+	t.Cleanup(srv.Shutdown)
+	if admin, err = nats.Connect(srv.ClientURL(), nats.UserInfo("test", "test")); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(admin.Close)
+	if node, err = nats.Connect(srv.ClientURL(), nats.UserInfo(nodeUser, "node"), nats.CustomInboxPrefix("_INBOX."+nodeUser),
+		nats.ErrorHandler(func(_ *nats.Conn, _ *nats.Subscription, err error) { refused(err) })); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(node.Close)
+	return admin, node
+}
+
+func newItBed(t *testing.T) *itBed {
+	t.Helper()
+	return newItBedAs(t, buscompose.Principal{Kind: buscompose.KindNode, Node: itNode})
+}
+
+// newItBedAs is newItBed with the node's connection under the grant of principal, a node's (KindNode).
+func newItBedAs(t *testing.T, principal buscompose.Principal) *itBed {
+	t.Helper()
+	// Not skipped off Arch: a package manager that answers is put on PATH, so the apply of files runs on any build node.
+	bin := t.TempDir()
+	if err := os.WriteFile(filepath.Join(bin, "pacman"), []byte("#!/bin/sh\nexit 0\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("PATH", bin+string(os.PathListSeparator)+os.Getenv("PATH"))
+	was := builtFor
+	builtFor = "arch"
+	t.Cleanup(func() { builtFor = was })
+
+	b := &itBed{t: t, dir: t.TempDir()}
+	b.conn, b.nodeConn = aServer(t, principal, func(err error) {
+		b.mu.Lock()
+		b.refusals = append(b.refusals, err.Error())
+		b.mu.Unlock()
+	})
+	var err error
+	if b.js, err = b.conn.JetStream(); err != nil {
+		t.Fatal(err)
+	}
+	if b.nodeJS, err = b.nodeConn.JetStream(); err != nil {
+		t.Fatal(err)
+	}
+	composedBucket, _ := delivery.ComposedBucketFor(itNode)
+	for _, c := range []struct {
+		name    string
+		into    *nats.KeyValue
+		history uint8
+	}{{delivery.AssignerWantsBucket, &b.wants, 8}, {composedBucket, &b.composed, delivery.ComposedHistory},
+		{delivery.HaveBucket, &b.haves, delivery.HaveHistory}} {
+		kv, err := b.js.CreateKeyValue(&nats.KeyValueConfig{Bucket: c.name, History: c.history})
+		if err != nil {
+			t.Fatal(err)
+		}
+		*c.into = kv
+	}
+	b.opts = options{state: filepath.Join(b.dir, "state", "state.json"), timeout: 2 * time.Second}
+	if err := os.MkdirAll(filepath.Dir(b.opts.state), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	_, b.controll, _ = ed25519.GenerateKey(nil)
+	_, b.operator, _ = ed25519.GenerateKey(nil)
+	return b
+}
+
+// start runs the node agent under a session on the bus, trusting the controller's key, and the operator's when asked.
+func (b *itBed) start(trustOperator bool) (stop func()) {
+	b.t.Helper()
+	if trustOperator {
+		pub := b.operator.Public().(ed25519.PublicKey)
+		if err := os.WriteFile(filepath.Join(filepath.Dir(b.opts.state), operatorKeysFile),
+			[]byte("# the operator\n"+base64.StdEncoding.EncodeToString(pub)+"\n"), 0o600); err != nil {
+			b.t.Fatal(err)
+		}
+	}
+	b.session = &link.Session{Membership: link.Membership{Node: itNode}, Timeout: 2 * time.Second,
+		Say: b.say, Keys: func() link.RecordKeys { return link.RecordKeys{} }}
+	b.session.Attach(context.Background(), link.OverNATS{Conn: b.nodeConn, JS: b.nodeJS, Node: itNode})
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		nodeAgent(ctx, b.opts, b.controll.Public().(ed25519.PublicKey), b.session, nil, b.say, func() {},
+			&agentNow{}, func(context.Context, *agent.Agent) {})
+	}()
+	return func() { cancel(); <-done }
+}
+
+func (b *itBed) say(line string) {
+	b.mu.Lock()
+	b.said = append(b.said, line)
+	b.mu.Unlock()
+	b.t.Log(line)
+}
+
+func fpIt(c string) string { return delivery.SourcePrefix2 + strings.Repeat(c, 64) }
+
+func fpDigest(c string) string { return "sha256:" + strings.Repeat(c, 64) }
+
+// compose writes a module's signed composition of one file into the node's bucket and returns its digest.
+func (b *itBed) compose(module, fp, content string, data bool, signer ed25519.PrivateKey) string {
+	b.t.Helper()
+	path := filepath.Join(b.dir, module+".conf")
+	res, _ := json.Marshal(map[string]any{"id": module + ".conf", "type": "file", "path": path, "content": content, "module": module})
+	c := delivery.Composed{Node: itNode, Module: module, FP: fp, Data: data, Resources: []json.RawMessage{res}}
+	signed, err := delivery.SignComposed(c, signer)
+	if err != nil {
+		b.t.Fatal(err)
+	}
+	raw, err := delivery.EncodeComposed(signed)
+	if err != nil {
+		b.t.Fatal(err)
+	}
+	dig, _ := delivery.ComposedDigestOf(signed)
+	key, _ := delivery.ComposedKey(itNode, module, fp)
+	if _, err := b.composed.Put(key, raw); err != nil {
+		b.t.Fatal(err)
+	}
+	return dig
+}
+
+func (b *itBed) want(module, fp, digest, backup string) {
+	b.t.Helper()
+	raw, err := delivery.EncodeWant(delivery.Want{FP: fp, Composed: digest, Backup: backup})
+	if err != nil {
+		b.t.Fatal(err)
+	}
+	key, _ := delivery.WantKey(itNode, module)
+	if _, err := b.wants.Put(key, raw); err != nil {
+		b.t.Fatal(err)
+	}
+}
+
+func (b *itBed) file(module string) string {
+	got, _ := os.ReadFile(filepath.Join(b.dir, module+".conf"))
+	return string(got)
+}
+
+func (b *itBed) have(module string) delivery.Have {
+	key, _ := delivery.HaveKey(itNode, module)
+	e, err := b.haves.Get(key)
+	if err != nil {
+		return delivery.Have{}
+	}
+	h, _ := delivery.DecodeHave(e.Value())
+	return h
+}
+
+func within(t *testing.T, d time.Duration, what string, ok func() bool) {
+	t.Helper()
+	deadline := time.Now().Add(d)
+	for !ok() {
+		if time.Now().After(deadline) {
+			t.Fatal(what)
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+}
+
+// R6-A AC1: given a running agent on a bus, when a want naming a digest and that composition are written, the module is
+// applied within one second and its have names the fingerprint and the digest; a composition whose digest no want names
+// is not applied.
+func TestNatsAWantAndItsCompositionAreAppliedWithinASecond(t *testing.T) {
+	t.Run("1957: an engine start starts a declared-running unit", testNatsAnEngineStartStartsADeclaredRunningUnitTheHaveSaysRuns)
+	b := newItBed(t)
+	stop := b.start(false)
+	defer stop()
+	time.Sleep(300 * time.Millisecond) // the watches are up
+
+	fp := fpIt("a")
+	dig := b.compose("web", fp, "one\n", false, b.controll)
+	time.Sleep(300 * time.Millisecond)
+	if b.file("web") != "" {
+		t.Fatal("a composition no want names was applied")
+	}
+	began := time.Now()
+	b.want("web", fp, dig, "")
+	within(t, time.Second, "the module was not applied within one second of its want", func() bool { return b.file("web") == "one\n" })
+	t.Logf("applied %s after the want", time.Since(began))
+	within(t, 2*time.Second, "the have does not name the fingerprint and the digest", func() bool {
+		h := b.have("web")
+		return h.FP == fp && h.Composed == dig && h.Phase == delivery.PhaseRunning
+	})
+
+	// A want naming a digest the composition at its fingerprint does not have applies nothing.
+	fp2 := fpIt("b")
+	b.compose("web", fp2, "two\n", false, b.controll)
+	b.want("web", fp2, "sha256:"+strings.Repeat("0", 64), "")
+	time.Sleep(300 * time.Millisecond)
+	if b.file("web") != "one\n" {
+		t.Fatalf("a want naming another digest changed the module: %q", b.file("web"))
+	}
+}
+
+// R6-A AC5: a data module that ran before asks its backup before any resource changes; a backup that fails holds the
+// module (nothing applied, the have says held with the backup's words); when its want then says skip, it is applied.
+func TestNatsADataModuleAsksItsBackupFirstAndIsHeldWhenItFails(t *testing.T) {
+	b := newItBed(t)
+	var mu sync.Mutex
+	var asked []string
+	var onDiskWhenAsked string
+	if _, err := b.conn.Subscribe("mesh.seat.node-backup.tool.now."+itNode, func(m *nats.Msg) {
+		mu.Lock()
+		asked = append(asked, "now")
+		onDiskWhenAsked = b.file("db")
+		mu.Unlock()
+		_ = m.Respond([]byte(`{"result":{"started":"db"}}`))
+		// The holder says the backup ended on its event.
+		ev, _ := json.Marshal(map[string]any{"node": itNode, "module": "db", "ok": false, "at": time.Now().UTC(),
+			"error": "restic: the repository is locked"})
+		_ = b.conn.Publish(backedUpEvent, ev)
+	}); err != nil {
+		t.Fatal(err)
+	}
+	stop := b.start(false)
+	defer stop()
+	time.Sleep(300 * time.Millisecond)
+
+	fp1, fp2 := fpIt("a"), fpIt("b")
+	b.want("db", fp1, b.compose("db", fp1, "v1\n", true, b.controll), "")
+	within(t, 3*time.Second, "the first composition was not applied", func() bool { return b.file("db") == "v1\n" })
+	mu.Lock()
+	if len(asked) != 0 {
+		t.Fatalf("a module that never ran was backed up: %v", asked)
+	}
+	mu.Unlock()
+
+	dig2 := b.compose("db", fp2, "v2\n", true, b.controll)
+	b.want("db", fp2, dig2, "")
+	within(t, 3*time.Second, "the module was not held behind the failed backup", func() bool {
+		h := b.have("db")
+		return h.Phase == delivery.PhaseHeld && strings.Contains(h.Detail, "repository is locked")
+	})
+	mu.Lock()
+	if len(asked) != 1 || onDiskWhenAsked != "v1\n" {
+		t.Fatalf("the backup was asked %v, with %q on disk: it is asked before any resource changes", asked, onDiskWhenAsked)
+	}
+	mu.Unlock()
+	if b.file("db") != "v1\n" {
+		t.Fatalf("something was applied behind a failed backup: %q", b.file("db"))
+	}
+	if h := b.have("db"); h.FP != fp1 {
+		t.Fatalf("a held module should still name what it runs: %+v", h)
+	}
+
+	b.want("db", fp2, dig2, delivery.BackupSkip)
+	within(t, 3*time.Second, "the module was not applied once its want said skip", func() bool { return b.file("db") == "v2\n" })
+	within(t, 2*time.Second, "the have does not say running at the new fingerprint", func() bool {
+		h := b.have("db")
+		return h.Phase == delivery.PhaseRunning && h.FP == fp2 && h.Composed == dig2
+	})
+}
+
+// R6-A AC9, the hand path end to end: with no controller running, a composition signed by the operator's key and a want
+// naming it are applied and the have written; the same signed by a key nobody trusts is not.
+func TestNatsTheHandPathAppliesACompositionTheOperatorSigned(t *testing.T) {
+	b := newItBed(t)
+	stop := b.start(true)
+	defer stop()
+	time.Sleep(300 * time.Millisecond)
+
+	_, stranger, _ := ed25519.GenerateKey(nil)
+	fpS := fpIt("c")
+	b.want("evil", fpS, b.compose("evil", fpS, "no\n", false, stranger), "")
+	time.Sleep(300 * time.Millisecond)
+	if b.file("evil") != "" {
+		t.Fatal("a composition signed by a key nobody trusts was applied")
+	}
+
+	fp := fpIt("d")
+	dig := b.compose("rescue", fp, "back\n", false, b.operator)
+	b.want("rescue", fp, dig, "")
+	within(t, 2*time.Second, "the operator's composition was not applied", func() bool { return b.file("rescue") == "back\n" })
+	within(t, 2*time.Second, "the have was not written", func() bool {
+		h := b.have("rescue")
+		return h.FP == fp && h.Composed == dig && h.Phase == delivery.PhaseRunning
+	})
+}
+
+// Issue 1126 (ADR 0547 §2, the milestone's H8): the node agent started whole against a real bus, once the catalogue
+// places its node (the placement written after it started), composes a module from its want, the indexer's manifest, its record and its mesh-config value, and applies it,
+// with no key in the controller's compositions; a changed config value is composed again on its event and applied as a
+// revision of what runs. And a catalogue pull request's placement candidate equal to its placement is answered "same"
+// in the node's own key, and nothing is applied for it (ADR 0559 §4, subtask 10 of the milestone).
+//
+// And (issue 1126, ADR 0560) it reads, through its own session under the grant the grants part composes for it
+// (buscompose.Users, so it carries ServedReads), the build of a placed module that declares one and the one config value
+// a provider on another node serves from (a mail domain); under a grant without that served key the bus refuses the
+// read and the node composes nothing.
+func TestNatsANodeThePlacementNamesComposesAndAppliesItsOwn(t *testing.T) {
+	users, err := buscompose.Users(buscompose.Records{Nodes: []string{itNode, "it2"},
+		Assigned: map[string][]buscompose.Declared{"it2": {{Module: "mailer", Served: []string{"domain"}}}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var principal buscompose.Principal
+	for _, u := range users {
+		if u.Kind == buscompose.KindNode && u.Node == itNode {
+			principal = u
+		}
+	}
+	if len(principal.ServedReads) != 1 {
+		t.Fatalf("the grants part's principal of %s reads %v of the served keys", itNode, principal.ServedReads)
+	}
+	t.Run("without the served key the bus refuses the read", func(t *testing.T) {
+		b := newItBed(t)
+		stop, _ := h8(t, b, false)
+		defer stop()
+		// 15 s, above link.historyWithin (10 s): the bus's refusal of a publish reaches only the connection's error
+		// handler (nats.go fails no request on it), so the refused read ends at its own bound, then the node says it.
+		within(t, 15*time.Second, "the bus did not refuse the served key's read, or the node did not say it", func() bool {
+			b.mu.Lock()
+			defer b.mu.Unlock()
+			return strings.Contains(strings.Join(b.refusals, "\n"), "Permissions Violation for Publish to \"$JS.API.CONSUMER.CREATE.KV_"+
+				selfcompose.ResolvedBucket) && strings.Contains(strings.Join(b.refusals, "\n"), ".it2.mailer.domain") &&
+				strings.Contains(strings.Join(b.said, "\n"), "what mailer serves on it2 (domain)")
+		})
+		if b.file("web") != "" {
+			t.Errorf("composed and applied under a grant without the served key: %q", b.file("web"))
+		}
+	})
+	b := newItBedAs(t, principal)
+	stop, st := h8(t, b, true)
+	defer stop()
+	placement, resolved, candidates := st.placement, st.resolved, st.candidates
+	hkey, place, fp := st.hkey, st.place, st.fp
+	within(t, 5*time.Second, "the node did not compose and apply its own module once placed", func() bool { return b.file("web") == "greeting=bonjour\n" })
+	h8rest(t, b, resolved, candidates, hkey, place, fp)
+	t.Run("one answer per candidate revision", func(t *testing.T) { h8once(t, b, resolved, candidates, place) })
+	h8back(t, b, placement, resolved, candidates, hkey)
+}
+
+// h8once is issue 1126, 2026-10-28 (shanks answered probe/1126-seed-7 at revision 84 every 13-17 s, its bus flooded):
+// a candidate revision is answered once. The node's own answer written, a module's have whose health words alone move
+// (each look rewrites them) and a config value written again with the value it held answer nothing again; the
+// candidate's next revision is answered once.
+func h8once(t *testing.T, b *itBed, resolved, candidates nats.KeyValue, place []byte) {
+	answering := func() int {
+		b.mu.Lock()
+		defer b.mu.Unlock()
+		n := 0
+		for _, l := range b.said {
+			if strings.HasPrefix(l, "answering placement candidate feat-x ") {
+				n++
+			}
+		}
+		return n
+	}
+	time.Sleep(time.Second)
+	settled := answering()
+	if settled == 0 {
+		t.Fatal("feat-x was never answered")
+	}
+	hkey, _ := delivery.HaveKey(itNode, "web")
+	for _, detail := range []string{"its tool web_health: no link to the bus is open", "its tool web_health: no answer within 10s"} {
+		h := b.have("web")
+		h.Health, h.Detail = delivery.HealthFailed, detail
+		raw, err := delivery.EncodeHave(h)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := b.haves.Put(hkey, raw); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := resolved.Put(itNode+".web.greeting", []byte(`{"value":"salut","source":"module"}`)); err != nil {
+			t.Fatal(err)
+		}
+	}
+	time.Sleep(1500 * time.Millisecond)
+	if got := answering(); got != settled {
+		t.Errorf("feat-x answered %d more time(s) at the same revision, with nothing it is composed from changed", got-settled)
+	}
+	same, _ := delivery.DecodePlacement(place)
+	craw, err := delivery.EncodePlacementCandidate(delivery.PlacementCandidate{Proposal: "feat-x", Placement: &same})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ckey, _ := delivery.PlacementCandidateKey("feat-x", itNode)
+	if _, err := candidates.Put(ckey, craw); err != nil {
+		t.Fatal(err)
+	}
+	within(t, 10*time.Second, "the candidate's next revision was not answered", func() bool { return answering() > settled })
+	time.Sleep(1500 * time.Millisecond)
+	if got := answering(); got != settled+1 {
+		t.Errorf("the candidate's next revision was answered %d time(s), want 1", got-settled)
+	}
+}
+
+// h8back is the way back (issue 1126, the seed's revert): a candidate deleting the node's placement is compared with
+// the controller's compositions at its wants (here none: refused, naming web), and the placement key deleted returns the agent to them without a
+// restart, said in the journal and the node's have, keeping what runs.
+func h8back(t *testing.T, b *itBed, placement, resolved, candidates nats.KeyValue, hkey string) {
+	t.Helper()
+	node := func() delivery.HaveNode {
+		e, err := b.haves.Get(hkey)
+		if err != nil {
+			return delivery.HaveNode{}
+		}
+		n, _ := delivery.DecodeHaveNode(e.Value())
+		return n
+	}
+	if n := node(); n.Composes != delivery.ComposesOwn {
+		t.Errorf("a node composing its own says it composes %q", n.Composes)
+	}
+	craw, err := delivery.EncodePlacementCandidate(delivery.PlacementCandidate{Proposal: "revert-x"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ckey, _ := delivery.PlacementCandidateKey("revert-x", itNode)
+	if _, err := candidates.Put(ckey, craw); err != nil {
+		t.Fatal(err)
+	}
+	// The controller holds no composition at web's want (the node composed its own): returning would leave web with
+	// nothing to apply, and the answer says so rather than "same" (review of the shadow, round 1).
+	within(t, 10*time.Second, "the node did not refuse returning to compositions the controller does not hold", func() bool {
+		a := node().Candidates["revert-x"]
+		return a.Proposal == "revert-x" && a.Returns == "" && a.Verdict == delivery.CandidateRefused &&
+			strings.Contains(a.Refused, "web: the controller holds no composition")
+	})
+	ran := b.have("web").Composed
+	pkey, _ := delivery.PlacementKey(itNode)
+	// A pass in flight at the switch (issue 1126, 2026-10-28: the last pass of the own run, failing on its run's end,
+	// marked the next agent's modules failed): a config value changed starts one, and the key goes at once.
+	if _, err := resolved.Put(itNode+".web.greeting", []byte(`{"value":"salut","source":"module"}`)); err != nil {
+		t.Fatal(err)
+	}
+	if err := placement.Delete(pkey); err != nil {
+		t.Fatal(err)
+	}
+	stopWatch := make(chan struct{})
+	marked := make(chan Have1126, 1)
+	go func() {
+		for {
+			select {
+			case <-stopWatch:
+				return
+			case <-time.After(20 * time.Millisecond):
+			}
+			if h := b.have("web"); h.Phase == delivery.PhaseFailed {
+				select {
+				case marked <- Have1126{h.Phase, h.Detail}:
+				default:
+				}
+				return
+			}
+		}
+	}()
+	defer close(stopWatch)
+	within(t, 15*time.Second, "the node did not return to the controller's compositions when its placement went", func() bool {
+		b.mu.Lock()
+		said := strings.Join(b.said, "\n")
+		b.mu.Unlock()
+		return strings.Contains(said, "key in the seat's placement state is gone") && node().Composes == delivery.ComposesController
+	})
+	time.Sleep(3 * time.Second) // what a pass in flight would mark lands within it
+	select {
+	case h := <-marked:
+		t.Errorf("a pass in flight at the switch marked web failed: %+v", h)
+	default:
+	}
+	if h := b.have("web"); h.Composed != ran || h.Phase == delivery.PhaseFailed || b.file("web") != "greeting=salut\n" {
+		t.Errorf("returning to the controller's compositions moved what runs: %+v, %q", h, b.file("web"))
+	}
+}
+
+// Have1126 is what H8's way back watches of web's have.
+type Have1126 struct {
+	Phase  delivery.Phase
+	Detail string
+}
+
+// h8state is what h8 set up that the rest of H8 writes to.
+type h8state struct {
+	placement, resolved, candidates nats.KeyValue
+	hkey                            string
+	place                           []byte
+	fp                              string
+}
+
+// h8 sets H8's bus up and starts the agent, then places the node. With checkBuild, the placed module's build key is
+// first one that does not decode, which the node must read through its session (and say), then a done one.
+func h8(t *testing.T, b *itBed, checkBuild bool) (func(), h8state) {
+	t.Helper()
+	kvOf := func(bucket string) nats.KeyValue {
+		kv, err := b.js.CreateKeyValue(&nats.KeyValueConfig{Bucket: bucket, History: 5})
+		if err != nil {
+			t.Fatal(err)
+		}
+		return kv
+	}
+	placement, modules, manifests := kvOf(delivery.PlacementBucket), kvOf(delivery.ModulesBucket), kvOf(delivery.ManifestsBucket)
+	resolved := kvOf(selfcompose.ResolvedBucket)
+	builds := kvOf(delivery.BuilderBuildsBucket)
+	candidates := kvOf(delivery.PlacementCandidatesBucket)
+	// The controller's stream the node's facts go into, so the node's key carries the facts it says.
+	if _, err := b.js.AddStream(&nats.StreamConfig{Name: "CONTROL", Subjects: []string{link.ReportSubject(itNode)}}); err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(b.dir, "web.conf")
+	man := `{"module":"web","version":"1","config":{"greeting":{"type":"string","description":"what the file says","default":"hello"}},` +
+		`"resources":[{"id":"conf","type":"file","path":"` + path + `","mode":"0644","content":"greeting=${config:greeting}\n"}],` +
+		`"build":{"artifacts":[{"name":"files","kind":"archive","from":"files"}]}}`
+	digest := delivery.ManifestDigest([]byte(man))
+	mraw, _ := delivery.EncodeManifest(delivery.Manifest{Module: "web", JSON: man})
+	mkey, _ := delivery.ManifestsKey(digest)
+	fp := fpIt("a")
+	modv, _ := delivery.EncodeModule(delivery.Module{FP2: fp, Manifest: digest, Repository: "novox/web", Commit: strings.Repeat("1", 40)})
+	place, _ := delivery.EncodePlacement(delivery.Placement{Node: itNode, Modules: []delivery.PlacedModule{{Module: "web"}}})
+	rec, _ := delivery.EncodeHaveNode(delivery.HaveNode{Record: &delivery.NodeRecord{Node: itNode, Capabilities: []string{"service-manager"}}})
+	pkey, _ := delivery.PlacementKey(itNode)
+	hkey, _ := delivery.HaveNodeKey(itNode)
+	// A provider on it2 serving from its own config value: a mail domain, which it1's composition settles.
+	mailer := `{"module":"mailer","version":"1","config":{"domain":{"type":"string","description":"the mail domain","required":true}},` +
+		`"provides":[{"name":"smtp","scope":"mesh"}],"serves":{"smtp":{"port":587,"domain":"${config:domain}"}}}`
+	mdigest := delivery.ManifestDigest([]byte(mailer))
+	mlraw, _ := delivery.EncodeManifest(delivery.Manifest{Module: "mailer", JSON: mailer})
+	mlkey, _ := delivery.ManifestsKey(mdigest)
+	mlmod, _ := delivery.EncodeModule(delivery.Module{FP2: fpIt("b"), Manifest: mdigest, Repository: "novox/mailer", Commit: strings.Repeat("2", 40)})
+	place2, _ := delivery.EncodePlacement(delivery.Placement{Node: "it2", Modules: []delivery.PlacedModule{{Module: "mailer"}}})
+	rec2, _ := delivery.EncodeHaveNode(delivery.HaveNode{Record: &delivery.NodeRecord{Node: "it2", Capabilities: []string{"service-manager"}}})
+	pkey2, _ := delivery.PlacementKey("it2")
+	hkey2, _ := delivery.HaveNodeKey("it2")
+	buildKey, _ := delivery.BuilderBuildKey("web", fp)
+	done, _ := delivery.EncodeBuilderBuild(delivery.BuilderBuild{State: delivery.BuildDone, Manifest: digest,
+		Artifacts: []delivery.BuiltArtifact{{Name: "files", Kind: "archive", Reference: "artifact-store://web/files/blobs/" + fpDigest("f"), Digest: fpDigest("f")}}})
+	firstBuild := done
+	if checkBuild {
+		firstBuild = []byte(`{"v":1,"state":"no such state"}`)
+	}
+	for _, w := range []struct {
+		kv    nats.KeyValue
+		key   string
+		value []byte
+	}{{manifests, mkey, mraw}, {modules, "web", modv}, {b.haves, hkey, rec},
+		{resolved, itNode + ".web.greeting", []byte(`{"value":"bonjour","source":"module"}`)},
+		{manifests, mlkey, mlraw}, {modules, "mailer", mlmod}, {b.haves, hkey2, rec2}, {placement, pkey2, place2},
+		{resolved, "it2.mailer.domain", []byte(`{"value":"example.org","source":"module"}`)}, {builds, buildKey, firstBuild}} {
+		if _, err := w.kv.Put(w.key, w.value); err != nil {
+			t.Fatal(err)
+		}
+	}
+	want, _ := delivery.EncodeWant(delivery.Want{FP: fp, Self: true})
+	wkey, _ := delivery.WantKey(itNode, "web")
+	if _, err := b.wants.Put(wkey, want); err != nil {
+		t.Fatal(err)
+	}
+
+	stop := b.start(false)
+	// Not placed yet: the agent applies the controller's compositions, of which there are none. The catalogue's seed then
+	// places the node, and the agent begins again composing its own (ADR 0549 §4), with no restart of the engine.
+	time.Sleep(300 * time.Millisecond)
+	if b.file("web") != "" {
+		t.Fatal("a node the catalogue does not place composed its own")
+	}
+	if _, err := placement.Put(pkey, place); err != nil {
+		t.Fatal(err)
+	}
+	if checkBuild {
+		// The build of the placed module is read through the node's session: one that does not decode is said, and nothing
+		// is applied; a done one, then a config event, and the node composes.
+		within(t, 5*time.Second, "the node did not read web's build key through its session", func() bool {
+			b.mu.Lock()
+			defer b.mu.Unlock()
+			return strings.Contains(strings.Join(b.said, "\n"), "the builder's "+buildKey)
+		})
+		if b.file("web") != "" {
+			t.Fatal("composed with a build key that does not decode")
+		}
+		if _, err := builds.Put(buildKey, done); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := resolved.Put(itNode+".web.greeting", []byte(`{"value":"bonjour","source":"module"}`)); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return stop, h8state{placement: placement, resolved: resolved, candidates: candidates, hkey: hkey, place: place, fp: fp}
+}
+
+// h8rest is H8 once the node composes its own: the have, a config revision, and the candidate answered "same".
+func h8rest(t *testing.T, b *itBed, resolved, candidates nats.KeyValue, hkey string, place []byte, fp string) {
+	t.Helper()
+	within(t, 2*time.Second, "the have does not name the build", func() bool {
+		h := b.have("web")
+		return h.FP == fp && h.Composed != "" && h.Phase == delivery.PhaseRunning
+	})
+	if keys, _ := b.composed.Keys(); len(keys) != 0 {
+		t.Errorf("the controller's compositions hold %v; the node composed its own", keys)
+	}
+	first := b.have("web").Composed
+	if _, err := resolved.Put(itNode+".web.greeting", []byte(`{"value":"salut","source":"module"}`)); err != nil {
+		t.Fatal(err)
+	}
+	within(t, 3*time.Second, "a changed config value was not composed and applied again", func() bool { return b.file("web") == "greeting=salut\n" })
+	within(t, 2*time.Second, "the have does not name the revision", func() bool {
+		h := b.have("web")
+		return h.FP == fp && h.Composed != first && h.Phase == delivery.PhaseRunning
+	})
+
+	// The node says its facts (its record, as the test wrote it), then a candidate equal to its placement is written: the
+	// node answers "same" at the candidate's head and revision in its own key, and applies nothing.
+	b.session.SayFacts(context.Background(), link.Report{Profile: map[string]any{"capabilities": []any{
+		map[string]any{"name": "service-manager", "present": true}}}})
+	second := b.have("web").Composed
+	same, _ := delivery.DecodePlacement(place)
+	craw, err := delivery.EncodePlacementCandidate(delivery.PlacementCandidate{Proposal: "feat-x", Placement: &same})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ckey, _ := delivery.PlacementCandidateKey("feat-x", itNode)
+	crev, err := candidates.Put(ckey, craw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var answer delivery.CandidateAnswer
+	within(t, 10*time.Second, "the node did not answer its candidate", func() bool {
+		e, err := b.haves.Get(hkey)
+		if err != nil {
+			return false
+		}
+		n, err := delivery.DecodeHaveNode(e.Value())
+		answer = n.Candidates["feat-x"]
+		return err == nil && answer.Proposal == "feat-x" && n.Record != nil
+	})
+	if answer.Verdict != delivery.CandidateSame || answer.Revision != crev || len(answer.Same) != 1 || answer.Same[0] != "web" {
+		t.Errorf("the answer to a candidate equal to the placement: %+v", answer)
+	}
+	if h := b.have("web"); h.Composed != second || b.file("web") != "greeting=salut\n" {
+		t.Errorf("a candidate moved what runs: %+v, %q", h, b.file("web"))
+	}
+}
+
+// 1957/AC1 (integration; ADR 0568 §1): a node agent starting on a bus that holds a `running` have for a module at its want,
+// with a service manager (a systemctl on the PATH) that shows the module's unit inactive, starts the unit once and writes
+// the have running; the same start with the unit active applies nothing.
+func testNatsAnEngineStartStartsADeclaredRunningUnitTheHaveSaysRuns(t *testing.T) {
+	for _, active := range []bool{false, true} {
+		b := newItBed(t)
+		bin := t.TempDir()
+		stateFile, calls := filepath.Join(bin, "state"), filepath.Join(bin, "calls")
+		if active {
+			os.WriteFile(stateFile, []byte("active"), 0o644)
+		} else {
+			os.WriteFile(stateFile, []byte("inactive"), 0o644)
+		}
+		script := "#!/bin/sh\necho \"$@\" >> " + calls + "\ncase \"$1\" in\n" +
+			"show) printf 'LoadState=loaded\\nActiveState=%s\\nType=simple\\n' \"$(cat " + stateFile + ")\" ;;\n" +
+			"start) printf active > " + stateFile + " ;;\nis-enabled) echo enabled ;;\nesac\nexit 0\n"
+		if err := os.WriteFile(filepath.Join(bin, "systemctl"), []byte(script), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		t.Setenv("PATH", bin+string(os.PathListSeparator)+os.Getenv("PATH"))
+
+		// The engine's own record of the unit, as a previous run left it, and the have it wrote then.
+		res, _ := json.Marshal(map[string]any{"id": "web.unit", "type": "service", "unit": "web-it.service", "state": "running", "module": "web"})
+		var known store.State
+		known.Record(store.Applied{ID: "web.unit", Type: "service", Target: "web-it.service"})
+		if err := store.Save(b.opts.state, known); err != nil {
+			t.Fatal(err)
+		}
+		fp := fpIt("a")
+		c := delivery.Composed{Node: itNode, Module: "web", FP: fp, Resources: []json.RawMessage{res}}
+		signed, _ := delivery.SignComposed(c, b.controll)
+		raw, _ := delivery.EncodeComposed(signed)
+		dig, _ := delivery.ComposedDigestOf(signed)
+		key, _ := delivery.ComposedKey(itNode, "web", fp)
+		if _, err := b.composed.Put(key, raw); err != nil {
+			t.Fatal(err)
+		}
+		b.want("web", fp, dig, "")
+		hkey, _ := delivery.HaveKey(itNode, "web")
+		have, err := delivery.EncodeHave(delivery.Have{FP: fp, Composed: dig, Phase: delivery.PhaseRunning, Health: delivery.HealthUnknown})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := b.haves.Put(hkey, have); err != nil {
+			t.Fatal(err)
+		}
+
+		stop := b.start(false)
+		within(t, 5*time.Second, "the unit was not started and the have not running", func() bool {
+			got, _ := os.ReadFile(stateFile)
+			h := b.have("web")
+			return string(got) == "active" && h.Phase == delivery.PhaseRunning && h.Composed == dig
+		})
+		time.Sleep(300 * time.Millisecond)
+		stop()
+		starts := 0
+		log, _ := os.ReadFile(calls)
+		for _, l := range strings.Split(string(log), "\n") {
+			if strings.HasPrefix(l, "start") {
+				starts++
+			}
+		}
+		if want := map[bool]int{false: 1, true: 0}[active]; starts != want {
+			t.Fatalf("unit active=%v: started %d times, want %d", active, starts, want)
+		}
+	}
+}

cmd/mesh-host/nodeclare_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// R6-A AC8: nothing in the node-engine receives, orders or reconciles a whole declaration (novox/hq ADR 0539 §9, ADR
+// 0429 §8): no package subscribes to a node's declare subject or names the deleted symbols.
+func TestNoPackageHearsOrOrdersAWholeDeclaration(t *testing.T) {
+	deleted := []string{
+		"DeclareSubject", "mesh.node.\" + node + \".declare", "ReconcileDue", "ReconcileEvery", "olderThanKept",
+		"refuseOlder", "olderGeneration", "appliedGeneration", "reconcileKept", "reapplyKept", "adoptionWatch",
+		"unsaidFile", "numbersFile", "func gather(", "func handleBody(", "Supersedes(", "ReportSequence",
+		"RefusedOlder", "ReadsGeneration", "ReadsModules", "GenerationRefusal", "LeftOutModuleOf",
+	}
+	root := filepath.Join("..", "..")
+	err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if d.IsDir() || !strings.HasSuffix(path, ".go") || strings.HasSuffix(path, "nodeclare_test.go") {
+			return nil
+		}
+		body, err := os.ReadFile(path)
+		if err != nil {
+			return err
+		}
+		for _, word := range deleted {
+			if strings.Contains(string(body), word) {
+				t.Errorf("%s still names %q", path, word)
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+}

cmd/mesh-host/nodekey.go

@@ -2,7 +2,10 @@ package main
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"strings"
+	"sync"
 	"time"
 
 	"github.com/novox/mesh-host/internal/identity"
@@ -22,12 +25,77 @@ const (
 	nodeKeyLook = 30 * time.Second
 )
 
+// heardKey is the vault's own public key as its answer to node-key gave it (ADR 0547 clause 9, issue 1945): the key the
+// bus node hands the loaded list's hashes sealed to. One for the process, as the key stated is; kick is the follower of
+// the user list on the link open now, told when the key is first heard or changes.
+type heardKey struct {
+	mu   sync.Mutex
+	pem  string
+	kick func()
+}
+
+// vaultKey is the vault's key this engine heard.
+var vaultKey = &heardKey{}
+
+func (h *heardKey) get() string {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	return h.pem
+}
+
+// heard keeps the key a node-key answer gave, and tells the follower when it is a first or changed one. An answer
+// with no key (a vault before this one) changes nothing.
+func (h *heardKey) heard(answer json.RawMessage) {
+	var a struct {
+		VaultKey string `json:"vault_key"`
+	}
+	if json.Unmarshal(answer, &a) != nil || !strings.Contains(a.VaultKey, "PUBLIC KEY") {
+		return
+	}
+	h.mu.Lock()
+	changed := a.VaultKey != h.pem
+	h.pem = a.VaultKey
+	kick := h.kick
+	h.mu.Unlock()
+	if changed && kick != nil {
+		kick()
+	}
+}
+
+// following names the follower told when the key changes, and tells it at once when a key is known.
+func (h *heardKey) following(kick func()) {
+	h.mu.Lock()
+	h.kick = kick
+	known := h.pem != ""
+	h.mu.Unlock()
+	if known && kick != nil {
+		kick()
+	}
+}
+
+// nodeKeyReask is how often the key is stated again though it did not change, so a changed vault key is heard: the
+// vault takes the same key again and changes nothing (ADR 0547 clause 9).
+const nodeKeyReask = 10 * time.Minute
+
+// keyHearing is what the keeper does with the vault's own key in node-key's answers (ADR 0547 clause 9): heard takes
+// it from an answer; held says whether one is held, and while none is the key is stated again at every look, so a vault
+// delivered after this engine is heard within a look; every is how often it is stated again all the same, so a changed
+// vault key is heard.
+type keyHearing struct {
+	heard func(json.RawMessage)
+	held  func() bool
+	// look is how often it is stated again while no vault key is held; every how often once one is.
+	look, every time.Duration
+}
+
 // keepNodeKeyStated states the sealing key load answers to the vault at start, retrying with a growing wait from
 // retryFrom to retryUpTo while it does not answer, and states it again whenever the key changes. It says one line
-// when a key is stated and one when a try fails for another reason than the last, and returns when ctx ends.
+// when a key is stated and one when a try fails for another reason than the last, and returns when ctx ends. With
+// hearing, each answer goes to it, and the key is stated again while no vault key is held and at its interval.
 func keepNodeKeyStated(ctx context.Context, load func() (identity.SealingKey, error), ask vaultAsk, say func(string),
-	retryFrom, retryUpTo time.Duration) {
+	retryFrom, retryUpTo time.Duration, hearing *keyHearing) {
 	stated, lastFailure := "", ""
+	var askedAt time.Time
 	wait := retryFrom
 	fail := func(why string) {
 		if why != lastFailure {
@@ -40,17 +108,29 @@ func keepNodeKeyStated(ctx context.Context, load func() (identity.SealingKey, er
 	for {
 		delay := look
 		key, err := load()
+		again := false
+		if hearing != nil && stated != "" {
+			since := time.Since(askedAt)
+			held := hearing.held == nil || hearing.held()
+			again = (!held && since >= hearing.look) || (held && hearing.every > 0 && since >= hearing.every)
+		}
 		switch {
 		case err != nil:
 			fail(err.Error())
 			delay = wait
-		case key.Public != stated:
-			if _, err := ask("node-key", map[string]string{"key": key.Public}); err != nil {
+		case key.Public != stated || again:
+			if answer, err := ask("node-key", map[string]string{"key": key.Public}); err != nil {
 				fail(err.Error())
 				delay = wait
 			} else {
+				askedAt = time.Now()
+				if hearing != nil && hearing.heard != nil {
+					hearing.heard(answer)
+				}
+				if key.Public != stated {
+					say(fmt.Sprintf("mesh-host: this machine's sealing key %s is stated to the vault", key.Public))
+				}
 				stated, lastFailure, wait = key.Public, "", retryFrom
-				say(fmt.Sprintf("mesh-host: this machine's sealing key %s is stated to the vault", key.Public))
 			}
 		}
 		select {

cmd/mesh-host/nodekey_test.go

@@ -19,6 +19,10 @@ type keyVault struct {
 	stated []string
 	fail   int
 	verbs  []string
+	// keyless is how many answers carry no vault key (a vault before ADR 0547 clause 9's, or not yet started); key the
+	// vault's key the others carry.
+	keyless int
+	key     string
 }
 
 func (v *keyVault) ask(verb string, args any) (json.RawMessage, error) {
@@ -35,7 +39,12 @@ func (v *keyVault) ask(verb string, args any) (json.RawMessage, error) {
 	}
 	_ = json.Unmarshal(raw, &a)
 	v.stated = append(v.stated, a.Key)
-	return json.RawMessage(`{"recorded":true}`), nil
+	if v.key == "" || v.keyless > 0 {
+		v.keyless--
+		return json.RawMessage(`{"recorded":true}`), nil
+	}
+	answer, _ := json.Marshal(map[string]any{"recorded": true, "vault_key": v.key})
+	return answer, nil
 }
 
 func (v *keyVault) said() []string {
@@ -71,9 +80,14 @@ func TestTheEngineStatesItsSealingKeyToTheVaultAtStartRetriesAndRestatesAChange(
 	say := func(l string) { lmu.Lock(); lines = append(lines, l); lmu.Unlock() }
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	go keepNodeKeyStated(ctx, load, vault.ask, say, time.Millisecond, 5*time.Millisecond)
+	var hmu sync.Mutex
+	var answers []string
+	heard := func(a json.RawMessage) { hmu.Lock(); answers = append(answers, string(a)); hmu.Unlock() }
+	go keepNodeKeyStated(ctx, load, vault.ask, say, time.Millisecond, 5*time.Millisecond, &keyHearing{heard: heard})
 
 	waitFor(t, "the first key stated after two refusals", func() bool { return len(vault.said()) == 1 })
+	// Its answer is handed on, so the vault's own key in it is heard (ADR 0547 clause 9); refusals hand nothing.
+	waitFor(t, "the answer heard", func() bool { hmu.Lock(); defer hmu.Unlock(); return len(answers) == 1 })
 	if vault.said()[0] != first.Public {
 		t.Errorf("stated %q, want the engine's own key %q", vault.said()[0], first.Public)
 	}
@@ -102,11 +116,75 @@ func TestTheEngineStatesItsSealingKeyToTheVaultAtStartRetriesAndRestatesAChange(
 	if len(lines) == 0 {
 		t.Error("the engine said nothing")
 	}
+	asksAgainUntilItHearsTheVaultsKey(t)
 }
 
-// The statement a host makes names this contract (issue 786), one above the vault's box.
+// ADR 0547 clause 9: the vault's key is heard though the engine's own key never changes. While none is held the key
+// is stated again at each look, so a vault delivered after the engine (or answering no key yet) is heard; once one is
+// held, again only at the slow interval, so a changed vault key is heard; never more.
+func asksAgainUntilItHearsTheVaultsKey(t *testing.T) {
+	sealing, _ := identity.GenerateSealingKey()
+	load := func() (identity.SealingKey, error) { return sealing, nil }
+	pem := func(c string) string { return "-----BEGIN PUBLIC KEY-----\n" + c + "\n-----END PUBLIC KEY-----\n" }
+	for _, c := range []struct {
+		name        string
+		keyless     int
+		every       time.Duration
+		change      bool
+		wantAtLeast int
+		wantAtMost  int
+	}{
+		{name: "a vault with no key yet is asked again until it answers one, then not", keyless: 3, wantAtLeast: 4, wantAtMost: 4},
+		{name: "a held key is asked again at the slow interval, and a changed one heard", every: 20 * time.Millisecond,
+			change: true, wantAtLeast: 3, wantAtMost: 1 << 20},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			vault := &keyVault{keyless: c.keyless, key: pem("AAAA")}
+			h := &heardKey{}
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			go keepNodeKeyStated(ctx, load, vault.ask, func(string) {}, time.Millisecond, 5*time.Millisecond,
+				&keyHearing{heard: h.heard, held: func() bool { return h.get() != "" }, look: time.Millisecond, every: c.every})
+			waitFor(t, "the vault's key heard", func() bool { return h.get() == pem("AAAA") })
+			if c.change {
+				vault.mu.Lock()
+				vault.key = pem("BBBB")
+				vault.mu.Unlock()
+				waitFor(t, "the changed vault key heard", func() bool { return h.get() == pem("BBBB") })
+			}
+			time.Sleep(60 * time.Millisecond)
+			n := len(vault.said())
+			if n < c.wantAtLeast || n > c.wantAtMost {
+				t.Errorf("node-key asked %d times, want %d to %d", n, c.wantAtLeast, c.wantAtMost)
+			}
+		})
+	}
+}
+
+// The statement a host makes names this contract (issue 786), one above the vault's box. And the vault's key its
+// answer gives is kept, told to the follower once when first heard and again only when changed; an answer without one
+// (an older vault) or with no public key changes nothing (ADR 0547 clause 9).
 func TestTheNodeKeyContractIsThirteen(t *testing.T) {
 	if link.NodeKeyContract != 13 {
 		t.Errorf("NodeKeyContract %d", link.NodeKeyContract)
 	}
+	h := &heardKey{}
+	kicks := 0
+	h.following(func() { kicks++ })
+	h.heard(json.RawMessage(`{"recorded":true}`))
+	h.heard(json.RawMessage(`{"recorded":true,"vault_key":"not a key"}`))
+	if h.get() != "" || kicks != 0 {
+		t.Fatalf("an answer with no key was kept: %q, %d kicks", h.get(), kicks)
+	}
+	pem := "-----BEGIN PUBLIC KEY-----\nAAAA\n-----END PUBLIC KEY-----\n"
+	answer, _ := json.Marshal(map[string]any{"recorded": true, "vault_key": pem})
+	h.heard(answer)
+	h.heard(answer)
+	if h.get() != pem || kicks != 1 {
+		t.Fatalf("key %q, %d kicks, want the key and one", h.get(), kicks)
+	}
+	h.following(func() { kicks += 10 })
+	if kicks != 11 {
+		t.Fatalf("a follower named after the key was heard was not told: %d", kicks)
+	}
 }

cmd/mesh-host/order_test.go

@@ -1,95 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"strings"
-	"testing"
-
-	"github.com/novox/mesh-host/internal/link"
-	"github.com/novox/mesh-host/internal/store"
-)
-
-// A declaration carries no order, so a host cannot tell an older one from a newer (novox/hq
-// 04-ISSUES/107). Its only identity was the digest of its bytes: "not the last" could be said,
-// "older" could not.
-
-func keptWith(t *testing.T, sequence int64) store.Declared {
-	t.Helper()
-	return keptAt(t, link.Order{Sequence: sequence})
-}
-
-func keptAt(t *testing.T, order link.Order) store.Declared {
-	t.Helper()
-	body, err := json.Marshal(map[string]any{
-		"declaration": 1, "resources": []any{}, "owns_nothing": true, "sequence": order.Sequence,
-		"epoch": order.Epoch,
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	return store.Declared{Declaration: body, Signature: []byte("x")}
-}
-
-func TestAnOlderDeclarationFromTheMeshIsRefused(t *testing.T) {
-	err := refuseOlder(keptWith(t, 7), nil, link.Order{Sequence: 5})
-	if err == nil {
-		t.Fatal("sequence 5 was accepted over a kept 7")
-	}
-	if !strings.Contains(err.Error(), "older") || !strings.Contains(err.Error(), "nothing was applied") {
-		t.Fatalf("the refusal does not say what it is: %v", err)
-	}
-}
-
-func TestANewerOrEqualDeclarationIsNot(t *testing.T) {
-	if err := refuseOlder(keptWith(t, 7), nil, link.Order{Sequence: 8}); err != nil {
-		t.Fatalf("sequence 8 was refused over a kept 7: %v", err)
-	}
-	// Equal is the same declaration again, which reconciling is for.
-	if err := refuseOlder(keptWith(t, 7), nil, link.Order{Sequence: 7}); err != nil {
-		t.Fatalf("the same sequence was refused: %v", err)
-	}
-}
-
-func TestNoOrderClaimedMeansNoOrderCompared(t *testing.T) {
-	// An older controller sends none; a host that received before it understood them kept none.
-	// Refusing on a guess would strand a node the moment the controller is older than the host.
-	if err := refuseOlder(keptWith(t, 7), nil, link.Order{Sequence: 0}); err != nil {
-		t.Fatalf("a declaration claiming no order was refused: %v", err)
-	}
-	if err := refuseOlder(keptWith(t, 0), nil, link.Order{Sequence: 3}); err != nil {
-		t.Fatalf("a declaration was refused against a kept one that claimed no order: %v", err)
-	}
-	if err := refuseOlder(store.Declared{}, store.ErrNothingDeclared, link.Order{Sequence: 3}); err != nil {
-		t.Fatalf("a first declaration was refused: %v", err)
-	}
-}
-
-// **The lease epoch decides first** (novox/hq to-be 45 §6): a declaration from a controller that lost
-// its lease is refused whatever its sequence, and a new lease holder's is taken whatever its sequence.
-func TestAnOlderEpochIsRefusedAndANewerTaken(t *testing.T) {
-	kept := keptAt(t, link.Order{Epoch: 57, Sequence: 3})
-	err := refuseOlder(kept, nil, link.Order{Epoch: 41, Sequence: 12})
-	if err == nil || !strings.Contains(err.Error(), "epoch 41") || !strings.Contains(err.Error(), "epoch 57") {
-		t.Fatalf("an older epoch was not refused by name: %v", err)
-	}
-	if err := refuseOlder(kept, nil, link.Order{Epoch: 58, Sequence: 1}); err != nil {
-		t.Fatalf("a new lease holder's first declaration was refused for its sequence: %v", err)
-	}
-	if err := refuseOlder(kept, nil, link.Order{Epoch: 57, Sequence: 2}); err == nil {
-		t.Fatal("a lower sequence under the same epoch was accepted")
-	}
-	// A controller with no lease — older, or rolled back to a build from before it — is today's
-	// behaviour: no epoch compared.
-	if err := refuseOlder(kept, nil, link.Order{Sequence: 4}); err != nil {
-		t.Fatalf("a declaration with no epoch was refused for one: %v", err)
-	}
-	if held, older := olderThanKept(kept, nil, link.Order{Epoch: 41, Sequence: 12}); !older ||
-		held != (link.Order{Epoch: 57, Sequence: 3}) {
-		t.Fatalf("olderThanKept said %v, holding %+v", older, held)
-	}
-	// What is kept cannot be read: no order to compare, so nothing is refused on a guess.
-	if _, older := olderThanKept(store.Declared{Declaration: []byte("garbled")}, nil,
-		link.Order{Epoch: 41, Sequence: 1}); older {
-		t.Fatal("refused against a kept declaration nobody can read")
-	}
-}

cmd/mesh-host/ownresync.go

@@ -0,0 +1,94 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"sync"
+	"time"
+
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+
+	"github.com/novox/mesh-host/internal/identity"
+	"github.com/novox/mesh-host/internal/link"
+	"github.com/novox/mesh-host/internal/ownresync"
+	"github.com/novox/mesh-host/internal/selfcompose"
+)
+
+// composesNow is whose compositions this run of the agent applies, once decided ("" before).
+type composesNow struct {
+	mu  sync.Mutex
+	now string
+}
+
+func (c *composesNow) set(s string) { c.mu.Lock(); c.now = s; c.mu.Unlock() }
+func (c *composesNow) get() string  { c.mu.Lock(); defer c.mu.Unlock(); return c.now }
+
+// resyncStep is the step that hands the vault what runs of an own secret a shadow answer says another value of (issue
+// 1126, cause C4; internal/ownresync): one pass at a time, and the last answers taken again once the agent has decided
+// whose compositions it applies.
+type resyncStep struct {
+	r    *ownresync.Resync
+	one  sync.Mutex
+	mu   sync.Mutex
+	last map[string]delivery.CandidateAnswer
+	// tries and pending are the step taken again after a bound when a read or an ask the bus did not answer stopped it
+	// (Outcome.Retry, issue 1126, 2026-10-28), one wait at a time.
+	tries   int
+	pending bool
+}
+
+func ownResync(session *link.Session, node string, say func(string), env selfcompose.Env, composes *composesNow) *resyncStep {
+	return &resyncStep{r: ownresync.New(ownresync.Env{Node: node, Composes: composes.get, Running: env.Running,
+		Get: env.Get, Unseal: env.Unseal, Seal: identity.Seal, Say: say,
+		Ask: func(ctx context.Context, verb string, args map[string]any) (json.RawMessage, error) {
+			return session.AskVault(ctx, verb, args)
+		}})}
+}
+
+// take keeps answers as the last and takes them.
+func (s *resyncStep) take(ctx context.Context, answers map[string]delivery.CandidateAnswer) {
+	s.mu.Lock()
+	s.last = answers
+	s.mu.Unlock()
+	s.again(ctx)
+}
+
+// again takes the last answers, and once more after a bound (selfcompose.LaterWait) while the bus did not answer for one.
+func (s *resyncStep) again(ctx context.Context) {
+	s.one.Lock()
+	defer s.one.Unlock()
+	s.mu.Lock()
+	last := s.last
+	s.mu.Unlock()
+	if last == nil {
+		return
+	}
+	retry := false
+	for _, o := range s.r.Take(ctx, last) {
+		retry = retry || o.Retry
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if !retry {
+		s.tries = 0
+		return
+	}
+	if s.pending || ctx.Err() != nil {
+		return
+	}
+	wait := selfcompose.LaterWait(s.tries)
+	s.tries++
+	s.pending = true
+	go func() {
+		select {
+		case <-ctx.Done():
+		case <-time.After(wait):
+		}
+		s.mu.Lock()
+		s.pending = false
+		s.mu.Unlock()
+		if ctx.Err() == nil {
+			s.again(ctx)
+		}
+	}()
+}

cmd/mesh-host/probe_test.go

@@ -9,7 +9,6 @@ import (
 	"testing"
 
 	"git.novox.be/novox/mesh-sdk/go/declaration"
-	"github.com/novox/mesh-host/internal/link"
 	"github.com/novox/mesh-host/internal/system"
 )
 
@@ -127,83 +126,3 @@ func TestAPackageManagerThatIsNotThereRefusesWhole(t *testing.T) {
 		t.Error("the refused declaration touched the machine")
 	}
 }
-
-// Defends the review of novox/hq issue 233: **a re-apply whose result changed is said unasked**. A machine
-// reconciles every five minutes and speaks only when its account is news; how the apply went was not part of
-// it, so a package manager that stopped answering between deliveries was never said, and one that answered
-// again never cleared. Now a failure is said once, the same failure again is not, and a clean re-apply after it
-// is — which is what clears the mesh's condition.
-func TestAReapplyWhoseResultChangedIsSaidUnasked(t *testing.T) {
-	dir := t.TempDir()
-	conf := filepath.Join(dir, "elsewhere", "pacman.conf") // not declared: the apply cannot make it answer
-	pacmanAnsweringOnce(t, conf)
-	opts := options{state: filepath.Join(dir, "state.json")}
-	raw := []byte(`{"declaration":1,"resources":[` +
-		`{"id":"motd","type":"file","path":"` + filepath.Join(dir, "motd") + `","content":"hello\n"},` +
-		`{"id":"pacman.base","type":"package","package":"base"}]}`)
-	w := &adoptionWatch{}
-
-	// Clean once, as it was before: base installed while pacman answered.
-	if err := os.MkdirAll(filepath.Dir(conf), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(conf, []byte("[options]\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	clean := applyAndKeep(context.Background(), opts, raw, nil, nil, nil)
-	if faulty(clean) {
-		t.Fatalf("the first apply was not clean: %+v", clean)
-	}
-	w.said(clean)
-	if w.news(applyAndKeep(context.Background(), opts, raw, nil, nil, nil)) {
-		t.Error("a clean re-apply after a clean one was said, so every machine speaks every five minutes")
-	}
-
-	// The configuration goes: the re-apply fails, and that is news once.
-	if err := os.Remove(conf); err != nil {
-		t.Fatal(err)
-	}
-	failed := applyAndKeep(context.Background(), opts, raw, nil, nil, nil)
-	if !faulty(failed) {
-		t.Fatalf("the re-apply did not fail: %+v", failed)
-	}
-	if !w.news(failed) {
-		t.Fatal("a re-apply that failed after a clean one was not said, so the mesh never hears the machine fails")
-	}
-	w.said(failed)
-	if w.news(applyAndKeep(context.Background(), opts, raw, nil, nil, nil)) {
-		t.Error("the same failure was said again on the next re-apply")
-	}
-
-	// It comes back: the clean re-apply is news, and is what clears the mesh's condition.
-	if err := os.WriteFile(conf, []byte("[options]\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	again := applyAndKeep(context.Background(), opts, raw, nil, nil, nil)
-	if faulty(again) {
-		t.Fatalf("the re-apply did not come back clean: %+v", again)
-	}
-	if !w.news(again) {
-		t.Fatal("a clean re-apply after a failed one was not said, so the mesh's condition never clears")
-	}
-}
-
-// A refusal is news too, once, and a reconcile with nothing to say after a clean one stays silent.
-func TestARefusalIsSaidOnceAndNothingIsNotSaid(t *testing.T) {
-	w := &adoptionWatch{}
-	w.said(link.Report{})
-	if w.news(link.Report{}) {
-		t.Error("nothing was said again")
-	}
-	refused := link.Report{Refused: "pacman does not answer here"}
-	if !w.news(refused) {
-		t.Fatal("a refusal was not said")
-	}
-	w.said(refused)
-	if w.news(link.Report{Refused: "pacman does not answer here, at another time"}) {
-		t.Error("the same refusal in other words was said again")
-	}
-	if !w.news(link.Report{}) {
-		t.Error("a clean apply after a refusal was not said")
-	}
-}

cmd/mesh-host/reads-outside

@@ -0,0 +1 @@
+These tests read files outside this directory (the whole catalogue, the repository, or its root files): mesh-build-go never keeps this package's verdict (issue 1935).

cmd/mesh-host/recorded_test.go

@@ -0,0 +1,96 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"path/filepath"
+	"testing"
+
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+
+	"github.com/novox/mesh-host/internal/liveness"
+	"github.com/novox/mesh-host/internal/store"
+)
+
+// The record check reads the engine's applied state: a composition one of whose resources has no record there is not
+// recorded (issue 1945).
+func TestACompositionIsRecordedOnlyWhenEveryResourceIs(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "state.json")
+	var s store.State
+	s.Record(store.Applied{ID: "ca-trust.trust", Type: "file", Target: "/etc/ca"})
+	if err := store.Save(path, s); err != nil {
+		t.Fatal(err)
+	}
+	c := delivery.Composed{Node: "ace", Module: "ca-trust", Resources: []json.RawMessage{
+		json.RawMessage(`{"id":"ca-trust.trust","type":"file","module":"ca-trust","path":"/etc/ca","mode":"0644","content":"x"}`)}}
+	recorded := recordedIn(path, func(string) {})
+	if !recorded(context.Background(), c) {
+		t.Fatal("a composition whose every resource has a record was not recorded")
+	}
+	c.Resources = append(c.Resources, json.RawMessage(
+		`{"id":"ca-trust.more","type":"file","module":"ca-trust","path":"/etc/ca2","mode":"0644","content":"y"}`))
+	if recorded(context.Background(), c) {
+		t.Fatal("a composition with a resource the state holds no record of was recorded")
+	}
+}
+
+// The modules applied again are those with a missing resource, each once; one down but there is not among them.
+func TestTheModulesAppliedAgainAreThoseWithAMissingResource(t *testing.T) {
+	t.Run("1957: the machine shows a resource not active", testTheMachineShowsAResourceNotActive)
+	st := liveness.Statement{Resources: []liveness.State{
+		{Resource: liveness.Resource{Module: "matrix", ID: "matrix.homeserver"}, State: liveness.Unhealthy, Missing: true},
+		{Resource: liveness.Resource{Module: "matrix", ID: "matrix.db"}, State: liveness.Unhealthy, Missing: true},
+		{Resource: liveness.Resource{Module: "ca-trust", ID: "ca-trust.trust"}, State: liveness.Unhealthy, Missing: true},
+		{Resource: liveness.Resource{Module: "web", ID: "web.server"}, State: liveness.Unhealthy},
+	}}
+	if got := missingModules(st); len(got) != 2 || got[0] != "ca-trust" || got[1] != "matrix" {
+		t.Fatalf("applied again: %v", got)
+	}
+}
+
+// A module is applied again only for a resource newly missing: one still missing at the next change of the statement is
+// not acted on again, so a resource that cannot be made is not applied (and backed up) at every unrelated change. One
+// that comes back and goes again is newly missing again (the review of issue 1945).
+func TestOnlyANewlyMissingResourceAppliesItsModuleAgain(t *testing.T) {
+	t.Run("1957: a resource newly down is an edge", testOnlyAResourceNewlyDownIsAnEdge)
+	missing := func(ids ...string) liveness.Statement {
+		var st liveness.Statement
+		for _, id := range ids {
+			st.Resources = append(st.Resources, liveness.State{Resource: liveness.Resource{Module: "matrix", ID: id},
+				State: liveness.Unhealthy, Missing: true})
+		}
+		return st
+	}
+	var last map[string]bool
+	var got []string
+	got, last = newlyMissing(last, missing("matrix.homeserver"))
+	if len(got) != 1 {
+		t.Fatalf("first missing: %v", got)
+	}
+	got, last = newlyMissing(last, missing("matrix.homeserver"))
+	if len(got) != 0 {
+		t.Fatalf("still missing was acted on again: %v", got)
+	}
+	got, last = newlyMissing(last, missing())
+	got, last = newlyMissing(last, missing("matrix.homeserver"))
+	if len(got) != 1 {
+		t.Fatalf("missing again after it came back: %v", got)
+	}
+}
+
+// A file the provisioner client fills is left to it by the apply and has no record until the client writes it: it does
+// not make its composition unrecorded (the review of issue 1945).
+func TestAFilledFileDoesNotMakeItsCompositionUnrecorded(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "state.json")
+	var s store.State
+	s.Record(store.Applied{ID: "ca-trust.trust", Type: "file", Target: "/etc/ca"})
+	if err := store.Save(path, s); err != nil {
+		t.Fatal(err)
+	}
+	c := delivery.Composed{Node: "ace", Module: "ca-trust", Filled: []string{"/etc/ca-filled"}, Resources: []json.RawMessage{
+		json.RawMessage(`{"id":"ca-trust.trust","type":"file","module":"ca-trust","path":"/etc/ca","mode":"0644","content":"x"}`),
+		json.RawMessage(`{"id":"ca-trust.filled","type":"file","module":"ca-trust","path":"/etc/ca-filled","mode":"0644","owner-at-runtime":"owned"}`)}}
+	if !recordedIn(path, func(string) {})(context.Background(), c) {
+		t.Fatal("a filled file the client has not written made its composition unrecorded")
+	}
+}

cmd/mesh-host/unsaid_test.go

@@ -1,64 +0,0 @@
-package main
-
-import (
-	"os"
-	"path/filepath"
-	"reflect"
-	"testing"
-
-	"github.com/novox/mesh-host/internal/link"
-	"github.com/novox/mesh-host/internal/store"
-)
-
-// The last apply's report, kept beside the state until the mesh takes it (novox/hq issue 264).
-
-// What a host that died between applying and reporting kept is read back by the next one exactly —
-// the digest and the outcome, never a new account of the machine.
-func TestTheKeptReportSurvivesTheHost(t *testing.T) {
-	state := filepath.Join(t.TempDir(), "state.json")
-	made := link.Report{Declared: "sha256:d1", Applied: []string{"a"}, Failed: map[string]string{"b": "no room"},
-		Host: "v2"}
-	if err := unsaidBeside(state).Keep(made); err != nil {
-		t.Fatal(err)
-	}
-
-	kept, ok, err := unsaidBeside(state).Pending()
-	if err != nil || !ok {
-		t.Fatalf("nothing kept: %v", err)
-	}
-	if !reflect.DeepEqual(kept, made) {
-		t.Fatalf("kept %+v, made %+v", kept, made)
-	}
-
-	// Taken about another declaration, it stays; taken about this one, it goes.
-	if err := unsaidBeside(state).Said("sha256:other"); err != nil {
-		t.Fatal(err)
-	}
-	if _, ok, _ := unsaidBeside(state).Pending(); !ok {
-		t.Fatal("a report about another declaration cleared this one")
-	}
-	if err := unsaidBeside(state).Said("sha256:d1"); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(store.UnsaidPath(state)); !os.IsNotExist(err) {
-		t.Fatalf("the report was taken and is still kept: %v", err)
-	}
-}
-
-// A node that never applied anything has nothing to say again; and an apply refused before its
-// declaration was read clears an older report, which would otherwise be re-said after it.
-func TestNothingKeptWhenNothingWasApplied(t *testing.T) {
-	state := filepath.Join(t.TempDir(), "state.json")
-	if _, ok, err := unsaidBeside(state).Pending(); ok || err != nil {
-		t.Fatalf("a node that applied nothing has a report to say: %v %v", ok, err)
-	}
-	if err := unsaidBeside(state).Keep(link.Report{Declared: "sha256:d1"}); err != nil {
-		t.Fatal(err)
-	}
-	if err := unsaidBeside(state).Keep(link.Report{Refused: "forged"}); err != nil {
-		t.Fatal(err)
-	}
-	if _, ok, _ := unsaidBeside(state).Pending(); ok {
-		t.Fatal("an older report is kept after a later declaration was refused")
-	}
-}

cmd/mesh-host/userlist.go

@@ -0,0 +1,204 @@
+package main
+
+import (
+	"context"
+	"crypto/ed25519"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"git.novox.be/novox/mesh-sdk/go/declaration"
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"git.novox.be/novox/mesh-sdk/go/seal"
+	"github.com/novox/mesh-host/internal/apply"
+	"github.com/novox/mesh-host/internal/identity"
+	"github.com/novox/mesh-host/internal/link"
+	"github.com/novox/mesh-host/internal/store"
+	"github.com/novox/mesh-host/internal/system"
+	"github.com/novox/mesh-host/internal/userlist"
+)
+
+// The bridge of novox/hq ADR 0547 §8, wired: the bus node's engine writes the bus's user list alone from the newest
+// composition of the bus module, under the apply's two locks as a filled file is written (filling.go), and says what
+// it wrote in the bus module's have.
+
+// userListFollower is the follower of the bus's user list for one link: the node's composition bucket, the keys the
+// agent trusts, the write alone, and the have.
+func userListFollower(opts options, session *link.Session, composedBucket string, trusted func() []ed25519.PublicKey,
+	say link.Announce, wrote func()) *userlist.Follower {
+	return userlist.New(userlist.Env{
+		Node:     session.Membership.Node,
+		Composed: bucketWatch{session, composedBucket},
+		Trusted:  trusted,
+		Resolve: func(ctx context.Context, raw json.RawMessage) ([]byte, error) {
+			return resolveUserList(session.WithLink(ctx), raw)
+		},
+		OnDisk: userListOnDisk,
+		Write: func(ctx context.Context, module string, raw json.RawMessage, body []byte) (string, bool, error) {
+			digest, changed, err := writeUserListAlone(session.WithLink(ctx), opts, raw, body, say)
+			if changed && wrote != nil {
+				wrote()
+			}
+			return digest, changed, err
+		},
+		Report: func(ctx context.Context, module string, w userlist.Written) {
+			session.NoteUserList(ctx, module, w)
+		},
+		// From take-over, the grants part's list (ADR 0547 clauses 7, 8): its one key watched, its object read by name and
+		// opened with this machine's sealing key, the key's public half said in the have so the grants part seals to it.
+		Grants: bucketWatch{session, delivery.GrantsUserListBucket},
+		Fetch: func(ctx context.Context, name string) ([]byte, error) {
+			return session.GrantsObject(ctx, name, grantsListLimit)
+		},
+		Open: func(b seal.Box) ([]byte, error) {
+			key, err := identity.LoadSealingKey(identity.SealingKeyPath(opts.state))
+			if err != nil {
+				return nil, err
+			}
+			return key.OpenVaultBox(b)
+		},
+		Key: func() string {
+			key, err := identity.LoadSealingKey(identity.SealingKeyPath(opts.state))
+			if err != nil {
+				return ""
+			}
+			pem, err := key.PublicPEM()
+			if err != nil {
+				return ""
+			}
+			return pem
+		},
+		// The grants part's key as last heard, kept beside the node's state, followed while it cannot be watched; its
+		// watch tried again as a passing failure of the bus is (ADR 0547 clause 8).
+		Kept:    func() ([]byte, uint64) { return keptGrantsKey(opts) },
+		Keep:    func(value []byte, rev uint64) { keepGrantsKey(opts, value, rev, say) },
+		Backoff: link.Backoff,
+		// The vault's key from its answer to node-key: the loaded list's hashes are handed sealed to it (ADR 0547
+		// clause 9).
+		VaultKey: vaultKey.get,
+		Say:      announceOr(say),
+	})
+}
+
+// grantsListLimit is the largest sealed list the bus node reads: the live list is about a hundred kilobytes.
+const grantsListLimit = 16 << 20
+
+// userListFile is a user-list resource as the file it declares.
+func userListFile(raw []byte) (*declaration.File, error) {
+	r, err := declaration.ParseResource(raw)
+	if err != nil {
+		return nil, fmt.Errorf("the user list is not a resource: %w", err)
+	}
+	f, ok := r.(*declaration.File)
+	if !ok {
+		return nil, fmt.Errorf("the user list is a %s, not a file", r.Kind())
+	}
+	return f, nil
+}
+
+// resolveUserList is the list a user-list resource holds: its content, or the object its digest names in this node's
+// file bucket, fetched and verified (apply.ResolveFileReferences, ADR 0486 §1).
+func resolveUserList(ctx context.Context, raw []byte) ([]byte, error) {
+	f, err := userListFile(raw)
+	if err != nil {
+		return nil, err
+	}
+	d := &declaration.Declaration{Version: declaration.Version, Resources: []declaration.Resource{f}}
+	if err := apply.ResolveFileReferences(ctx, d, link.FilesFrom(ctx)); err != nil {
+		return nil, fmt.Errorf("the user list could not be had by its digest: %w", err)
+	}
+	return []byte(d.Resources[0].(*declaration.File).Content), nil
+}
+
+// userListOnDisk is what the user list's file holds on this machine now; nil when there is none.
+func userListOnDisk(raw json.RawMessage) ([]byte, error) {
+	f, err := userListFile(raw)
+	if err != nil {
+		return nil, err
+	}
+	body, err := os.ReadFile(f.Path)
+	if errors.Is(err, os.ErrNotExist) {
+		return nil, nil
+	}
+	return body, err
+}
+
+// writeUserListAlone writes one user-list resource alone (apply.WriteAlone) with body as its content, the node's state
+// read and saved under the apply's locks, and answers the digest of the file on the machine after.
+func writeUserListAlone(ctx context.Context, opts options, raw []byte, body []byte, say link.Announce) (string, bool, error) {
+	declared, err := userListFile(raw)
+	if err != nil {
+		return "", false, err
+	}
+	file := *declared
+	file.Content, file.Digest, file.Size = string(body), "", 0
+
+	applying.Lock()
+	defer applying.Unlock()
+	unlock, err := store.Lock(opts.state, nil)
+	if err != nil {
+		return "", false, err
+	}
+	defer unlock()
+	known, err := store.Load(opts.state)
+	if err != nil {
+		return "", false, err
+	}
+	built, err := system.For(builtFor)
+	if err != nil {
+		return "", false, err
+	}
+	out, updated, writeErr := apply.WriteAlone(ctx, built, &file, known, apply.ExecRunner, announceOr(say))
+	// Saved whichever way it went, as an apply's: what was written is on the machine either way.
+	if err := store.Save(opts.state, updated); err != nil {
+		writeErr = errors.Join(writeErr, errors.New("written, and the node's state could not be saved: "+err.Error()))
+	}
+	digest := ""
+	if body, err := os.ReadFile(file.Path); err == nil {
+		digest = userlist.Digest(body)
+	}
+	return digest, writeErr == nil && out.Action != "unchanged", writeErr
+}
+
+// grantsKeyPath is where the grants part's user-list key last heard is kept, beside the node's state.
+func grantsKeyPath(opts options) string {
+	return filepath.Join(filepath.Dir(opts.state), "grants-user-list.json")
+}
+
+type keptKey struct {
+	Revision uint64          `json:"revision"`
+	Value    json.RawMessage `json:"value"`
+}
+
+func keptGrantsKey(opts options) ([]byte, uint64) {
+	raw, err := os.ReadFile(grantsKeyPath(opts))
+	if err != nil {
+		return nil, 0
+	}
+	var k keptKey
+	if json.Unmarshal(raw, &k) != nil || len(k.Value) == 0 {
+		return nil, 0
+	}
+	return k.Value, k.Revision
+}
+
+func keepGrantsKey(opts options, value []byte, rev uint64, say link.Announce) {
+	path := grantsKeyPath(opts)
+	if value == nil {
+		if err := os.Remove(path); err != nil && !errors.Is(err, os.ErrNotExist) {
+			announceOr(say)("the grants part's user-list key kept on this machine could not be taken away: " + err.Error())
+		}
+		return
+	}
+	raw, _ := json.Marshal(keptKey{Revision: rev, Value: value})
+	tmp := path + ".new"
+	err := os.WriteFile(tmp, raw, 0o600)
+	if err == nil {
+		err = os.Rename(tmp, path)
+	}
+	if err != nil {
+		announceOr(say)("the grants part's user-list key could not be kept on this machine: " + err.Error())
+	}
+}

cmd/mesh-host/vaultbox_nats_test.go

@@ -3,7 +3,7 @@ package main
 // Issue 755's proof on a real bus (novox/hq ADR 0349 §16): a core credential the vault sealed to this machine crosses
 // the bus inside the declaration, which the controller carries and cannot open, and this engine opens it with its
 // sealing key and writes the value. A listener on every subject keeps every byte that crossed; the value is never
-// among them. Run against the throwaway bus merge-check.sh starts (MESH_TEST_NATS).
+// among them. Run against the throwaway bus the build module starts for the integration level (MESH_TEST_NATS).
 
 import (
 	"context"
@@ -22,7 +22,6 @@ import (
 	"git.novox.be/novox/mesh-sdk/go/declaration"
 	"github.com/novox/mesh-host/internal/apply"
 	"github.com/novox/mesh-host/internal/identity"
-	"github.com/novox/mesh-host/internal/link"
 	"github.com/novox/mesh-host/internal/store"
 	"github.com/novox/mesh-host/internal/system"
 )
@@ -61,14 +60,14 @@ func TestNatsTheEngineFillsACoreCredentialFromTheVaultsBoxWithNoValueInTheClear(
 	}
 	_ = tap.Flush()
 
-	// The engine hears its declaration on its own subject.
-	const node = "vaultbox"
+	// The engine hears the composition on a subject of the test (the node agent reads it from its bucket).
+	const subject = "mesh.test.vaultbox.composition"
 	engine, err := nats.Connect(url)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer engine.Close()
-	heard, err := engine.SubscribeSync(link.DeclareSubject(node))
+	heard, err := engine.SubscribeSync(subject)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -92,7 +91,7 @@ func TestNatsTheEngineFillsACoreCredentialFromTheVaultsBoxWithNoValueInTheClear(
 		t.Fatal(err)
 	}
 	defer controller.Close()
-	if err := controller.Publish(link.DeclareSubject(node), body); err != nil {
+	if err := controller.Publish(subject, body); err != nil {
 		t.Fatal(err)
 	}
 	_ = controller.Flush()
@@ -123,7 +122,7 @@ func TestNatsTheEngineFillsACoreCredentialFromTheVaultsBoxWithNoValueInTheClear(
 	mu.Lock()
 	all := strings.Join(crossed, "\n")
 	mu.Unlock()
-	if !strings.Contains(all, link.DeclareSubject(node)) || !strings.Contains(all, "vault-sealed") {
+	if !strings.Contains(all, subject) || !strings.Contains(all, "vault-sealed") {
 		t.Fatalf("the listener heard nothing of the declaration:\n%s", all)
 	}
 	for _, form := range []string{coreCredential, base64.StdEncoding.EncodeToString([]byte(coreCredential))} {

cmd/mesh-host/whatruns_test.go

@@ -0,0 +1,139 @@
+package main
+
+import (
+	"crypto/ed25519"
+	"encoding/json"
+	"errors"
+	"strings"
+	"testing"
+
+	"git.novox.be/novox/mesh-sdk/go/declaration"
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+
+	"github.com/novox/mesh-host/internal/agent"
+)
+
+func aFileOf(module, id string) json.RawMessage {
+	raw, _ := json.Marshal(map[string]any{"id": module + "." + id, "type": "file", "path": "/tmp/r6/" + module + "/" + id,
+		"content": "x", "module": module})
+	return raw
+}
+
+// What runs is the agent's compositions and the kept declaration's resources for each module the agent does not hold;
+// the node's own parts are the kept declaration's until the agent holds the node's composition (ADR 0539 §9). One module
+// under the agent must not make the rest invisible to the liveness, units, accounts, libraries, filling and the take act.
+func TestWhatRunsIsTheAgentsCompositionsAndTheKeptRest(t *testing.T) {
+	kept := &declaration.Declaration{Identities: []declaration.Identity{{Module: "db", Name: "mesh-db"}},
+		Libraries: []declaration.Library{{Library: "media"}}}
+	everything := []delivery.Composed{
+		{Node: "n1", Module: "web", Resources: []json.RawMessage{aFileOf("web", "a")}},
+		{Node: "n1", Module: "db", Resources: []json.RawMessage{aFileOf("db", "a")}}, // still the kept declaration's
+	}
+	d, err := whatRuns(everything, false, func() (*declaration.Declaration, error) { return kept, nil })
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(d.Resources) != 2 || len(d.Identities) != 1 || len(d.Libraries) != 1 {
+		t.Fatalf("%d resources, %d identities, %d libraries: the kept modules and the node's kept parts are missing",
+			len(d.Resources), len(d.Identities), len(d.Libraries))
+	}
+
+	// Once the agent holds the node's composition, its parts are the node's.
+	node := delivery.Composed{Node: "n1", Own: delivery.NodeOwn{Identities: []declaration.Identity{{Module: "web", Name: "mesh-web"}}}}
+	d, err = whatRuns(append(everything, node), true, func() (*declaration.Declaration, error) { return nil, errors.New("not read") })
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(d.Identities) != 1 || d.Identities[0].Name != "mesh-web" || len(d.Libraries) != 0 {
+		t.Fatalf("the node's parts: %+v %+v", d.Identities, d.Libraries)
+	}
+}
+
+// What the take act, the judgement of directories and the filling read is what runs, not the frozen kept declaration.
+func TestDeclaredNowReadsWhatRunsWhenTheAgentIsRunning(t *testing.T) {
+	setRunsHere(func(string, ed25519.PublicKey) (*declaration.Declaration, error) {
+		return &declaration.Declaration{Version: 1, Resources: nil, Provisioner: "from-agent"}, nil
+	})
+	defer setRunsHere(nil)
+	d, err := declaredNow("/nowhere", nil)
+	if err != nil || d.Provisioner != "from-agent" {
+		t.Fatalf("declaredNow read %+v (%v), not what runs", d, err)
+	}
+}
+
+// 1945/AC17 (unit): a resource the node's own composition shares with a running module's composition is declared once,
+// the module's: the declaration joined of both names each file once, so the filling writes it; the node's own resources
+// no module declares stay. (Live from 2026-10-25 12:43: "2 resources declare X" on every node.)
+func TestTheNodesOwnCopyOfAModulesResourceIsLeftOut(t *testing.T) {
+	own := delivery.Composed{Node: "n1", Resources: []json.RawMessage{aFileOf("zsh", "rc"), aFileOf("mesh-wireguard", "conf")},
+		Filled: []string{"/tmp/r6/zsh/rc"}}
+	zsh := delivery.Composed{Node: "n1", Module: "zsh", FP: "src2:aa", Resources: []json.RawMessage{aFileOf("zsh", "rc")},
+		Filled: []string{"/tmp/r6/zsh/rc"}}
+	d, err := declarationOf(own, zsh)
+	if err != nil {
+		t.Fatal(err)
+	}
+	at := map[string]int{}
+	for _, r := range d.Resources {
+		at[r.Target()]++
+	}
+	if at["/tmp/r6/zsh/rc"] != 1 || at["/tmp/r6/mesh-wireguard/conf"] != 1 || len(d.Resources) != 2 {
+		t.Errorf("the joined declaration declares %v, want each path once", at)
+	}
+	if !d.Fills("/tmp/r6/zsh/rc") {
+		t.Errorf("the filled path is no longer named")
+	}
+
+	// The same at the node's own apply: what the others declare is theirs.
+	trimmed, dropped := ownWithout(own, []delivery.Composed{zsh})
+	if len(trimmed.Resources) != 1 || len(dropped) != 1 || dropped[0] != "zsh.rc (zsh)" {
+		t.Errorf("the node's own without zsh's: %d resources, dropped %v", len(trimmed.Resources), dropped)
+	}
+	if len(own.Resources) != 2 {
+		t.Errorf("ownWithout changed its argument")
+	}
+	// A node's own composition alone is all of it.
+	if d, err := declarationOf(own); err != nil || len(d.Resources) != 2 {
+		t.Errorf("the node's own alone: %v (%v)", d, err)
+	}
+}
+
+// 1945/AC18 (unit): the kept declaration's filled paths go to the module whose file is at each path, the node's own to
+// the node's; and what runs from it, joined with the node's composition, names them filled.
+func TestTheKeptDeclarationsFilledPathsGoToTheirModules(t *testing.T) {
+	raw := []byte(`{"resources":[
+		{"id":"claude-code.settings","type":"file","module":"claude-code","path":"/etc/cc.json"},
+		{"id":"screen-lock.conf","type":"file","module":"screen-lock","path":"/etc/lock.conf"},
+		{"id":"host.motd","type":"file","path":"/etc/motd"},
+		{"id":"zsh.rc","type":"file","module":"zsh","path":"/etc/zshrc"}],
+		"filled_files":["/etc/cc.json","/etc/lock.conf","/etc/motd"]}`)
+	by, filled := splitKept(raw)
+	if len(by["claude-code"]) != 1 || len(by[agent.NodeModule]) != 1 {
+		t.Fatalf("resources by module: %v", by)
+	}
+	if strings.Join(filled["claude-code"], ",") != "/etc/cc.json" || strings.Join(filled["screen-lock"], ",") != "/etc/lock.conf" ||
+		strings.Join(filled[agent.NodeModule], ",") != "/etc/motd" || len(filled["zsh"]) != 0 {
+		t.Fatalf("filled by module: %v", filled)
+	}
+	cc := delivery.Composed{Node: "n1", Module: "claude-code", Resources: by["claude-code"], Filled: filled["claude-code"]}
+	node := delivery.Composed{Node: "n1"}
+	d, err := whatRuns([]delivery.Composed{cc, node}, true, func() (*declaration.Declaration, error) { return nil, errors.New("not read") })
+	if err != nil || !d.Fills("/etc/cc.json") {
+		t.Fatalf("what runs does not name claude-code's file filled: %v (%v)", d, err)
+	}
+	if splitBy, _ := splitKept([]byte("not json")); splitBy != nil {
+		t.Errorf("a kept declaration that does not read split into %v", splitBy)
+	}
+}
+
+// 1945/AC17 (unit, review): a resource of the node's own that shares only its target with a module's (another id: a
+// unit or a container of the same name) is not the module's, and is neither dropped nor left to be removed.
+func TestASharedTargetWithAnotherIDIsNotDropped(t *testing.T) {
+	ownFile, _ := json.Marshal(map[string]any{"id": "host.zshrc", "type": "file", "path": "/tmp/r6/zsh/rc", "content": "x"})
+	own := delivery.Composed{Node: "n1", Resources: []json.RawMessage{ownFile}}
+	zsh := delivery.Composed{Node: "n1", Module: "zsh", FP: "src2:aa", Resources: []json.RawMessage{aFileOf("zsh", "rc")}}
+	trimmed, dropped := ownWithout(own, []delivery.Composed{zsh})
+	if len(dropped) != 0 || len(trimmed.Resources) != 1 {
+		t.Errorf("a resource sharing only its target was dropped: %v", dropped)
+	}
+}

cmd/mesh-host/witnessing.go

@@ -41,8 +41,9 @@ func rolledBackHosts(statePath string) []string {
 	return upgrade.RolledBackVersions(verdicts)
 }
 
-// proving is this host waiting for the mesh to take a report it made under its own build — the
-// evidence its launcher's trial waits for — and acting on it once.
+// proving is this host waiting to write a have key under its own build — the evidence its launcher's trial waits for
+// (novox/hq ADR 0539 §9, ADR 0227 §8: the component replaced is never the only witness of its successor) — and acting
+// on it once.
 type proving struct {
 	statePath string
 	version   string
@@ -56,16 +57,14 @@ func unproved(statePath, version string) bool {
 	return err != nil || known != version
 }
 
-// heard is told every account of the machine the mesh has taken. The first one about a declaration,
-// made by this build, proves it.
-func (p *proving) heard(r link.Report) {
-	if r.Declared == "" || r.Refused != "" || r.Host != p.version {
-		return
-	}
+// haveWritten is told when this build has written a have key, or found the bucket already holding what it would write.
+// The first proves it. **A declaration's report does not**: a node-engine that receives none is not on trial for it, and
+// one that cannot write its haves is what the launcher keeps rolling back.
+func (p *proving) haveWritten() {
 	p.once.Do(func() {
 		retired, err := upgrade.Proved(p.statePath, upgrade.VersionsDir(""), p.version)
 		if err != nil {
-			p.say(fmt.Sprintf("this host reported under its own build %s, and proving it was not complete: %v", p.version, err))
+			p.say(fmt.Sprintf("this host wrote its first have under its own build %s, and proving it was not complete: %v", p.version, err))
 		}
 		if len(retired) > 0 {
 			p.say(fmt.Sprintf("host %s is proved; retired the host version(s) %s", p.version, strings.Join(retired, ", ")))
@@ -146,7 +145,7 @@ func launcherReplaced(pid int, proc, path string) bool {
 }
 
 // watchWhatThisHostPlaced judges the core builds this host placed, until ctx ends (to-be 45 §8).
-func watchWhatThisHostPlaced(ctx context.Context, node string, queue *link.Queue, say func(string)) {
+func watchWhatThisHostPlaced(ctx context.Context, node string, queue *link.Session, say func(string)) {
 	host, _ := os.Hostname()
 	w := &witness.Watcher{
 		Root: apply.DaemonRoot(), Node: node, Host: host,
@@ -159,7 +158,7 @@ func watchWhatThisHostPlaced(ctx context.Context, node string, queue *link.Queue
 		},
 		// Said now, not at the next report: the verdict is on every report from here, and the mesh
 		// is asked for one at once.
-		Concluded: func(link.Rollback) { queue.ReportAsked() },
+		Concluded: func(link.Rollback) { queue.FactsAsked(ctx) },
 		Say:       say,
 	}
 	w.Watch(ctx)

cmd/mesh-host/witnessing_test.go

@@ -13,9 +13,9 @@ import (
 	"github.com/novox/mesh-host/internal/upgrade"
 )
 
-// The first account the mesh takes from this build, about a declaration, proves it to the launcher;
-// nothing else does — a refusal, a report about no declaration, another build's report (to-be 45 §8).
-func TestOnlyAnAccountUnderThisBuildProvesIt(t *testing.T) {
+// The first have this build writes proves it to the launcher; nothing else does — not a report about a declaration, not
+// a facts event, not the haves of another build (novox/hq ADR 0539 §9, ADR 0227 §8). R6-A AC7.
+func TestOnlyAHaveUnderThisBuildProvesIt(t *testing.T) {
 	state := filepath.Join(t.TempDir(), "state.json")
 	t.Setenv("MESH_HOST_LIBEXEC", t.TempDir())
 	// Never the machine's own engine placed by hand: proving renews it (issue 356).
@@ -27,22 +27,20 @@ func TestOnlyAnAccountUnderThisBuildProvesIt(t *testing.T) {
 	var said []string
 	p := &proving{statePath: state, version: "2.0", say: func(s string) { said = append(said, s) }}
 
-	for _, r := range []link.Report{
-		{Host: "2.0", Refused: "no"},
-		{Host: "2.0"},
-		{Host: "1.0", Declared: "abc"},
-	} {
-		p.heard(r)
-		if !unproved(state, "2.0") {
-			t.Fatalf("%+v proved this build", r)
-		}
-		if got, _ := os.ReadFile(fallback); string(got) != "a stale engine placed by hand" {
-			t.Fatalf("%+v renewed the engine placed by hand", r)
-		}
+	// Facts said, a link opened, a declaration of the old kind reported: none of it is a have.
+	if !unproved(state, "2.0") {
+		t.Fatal("a build that wrote no have is proved")
 	}
-	p.heard(link.Report{Host: "2.0", Declared: "abc"})
+	if got, _ := os.ReadFile(fallback); string(got) != "a stale engine placed by hand" {
+		t.Fatal("the engine placed by hand was renewed before any have")
+	}
+
+	// The session tells the proof when it has a have key saying what it would write.
+	session := &link.Session{HaveWritten: p.haveWritten}
+	_ = session
+	p.haveWritten()
 	if unproved(state, "2.0") {
-		t.Fatalf("an account of a declaration under this build did not prove it (%v)", said)
+		t.Fatalf("the first have under this build did not prove it (%v)", said)
 	}
 	if got, _ := upgrade.ReadKnownGood(upgrade.KnownGoodPath(state)); got != "2.0" {
 		t.Fatalf("known-good is %q", got)
@@ -78,12 +76,6 @@ func TestAStandingRollbackIsSaidOnEveryReport(t *testing.T) {
 		got[0].Outcome != link.RolledBack {
 		t.Fatalf("what the report says is %+v", got)
 	}
-	if !worthSaying(link.Report{Rollbacks: got}) {
-		t.Fatal("a reconcile with a rollback standing does not say it")
-	}
-	if adoptionFingerprint(link.Report{Rollbacks: got}) == adoptionFingerprint(link.Report{}) {
-		t.Fatal("a rollback reached or ended is not news to the reconcile")
-	}
 }
 
 // The launcher running this host is known to have been replaced only when it certainly was: a shell

examples/foundation-first-node.lock

@@ -221,7 +221,7 @@
       "path": "/var/lib/nats-module/conf/accounts.conf",
       "mode": "0600",
       "create-once": true,
-      "content": "// The first user list, carried by the installer because at genesis there is no mesh to\n// compose one. A bootstrap credential, rotated with the store's and replaced by the\n// controller's own composition from its first start onward.\naccounts {\n  MESH {\n    jetstream: enabled\n    users = [\n      { user: \"controller\", password: \"$2a$10$AHqJgOifIVbU41KmATiMhuXFs8xa7Wl2HuN4UVBCXdN2jIQzjqApy\", permissions: {\n        publish: { allow: [\"$JS.ACK.CONTROL.controller.>\", \"$JS.ACK.EVENTS.controller.>\", \"$JS.ACK.DEAD_LETTER_NOTICES.controller.>\", \"$JS.API.>\", \"$KV.mesh-controller_asked.>\", \"$KV.mesh-controller_assignments.>\", \"$KV.mesh-controller_calls.>\", \"$KV.mesh-controller_hand-acts.>\", \"$KV.mesh-controller_conditions.>\", \"$KV.mesh-controller_condition-history.>\", \"$KV.mesh-controller_declared-config.>\", \"$KV.mesh-controller_lease.>\", \"$KV.mesh-controller_predefined.>\", \"$KV.SEAT_MESH_BUILD_MACHINE_cancelled.>\", \"$KV.SEAT_NODE_BUILD_AGENT_cancelled.>\", \"_INBOX.enrol.>\", \"mesh.assignment.>\", \"mesh.mod.*.tool.>\", \"mesh.node.>\", \"mesh.seat.mesh-build-machine.accept.>\", \"mesh.seat.node-build-agent.accept.>\", \"mesh.seat.mesh-build-machine.tool.>\", \"mesh.seat.node-build-agent.tool.>\", \"mesh.seat.mesh-controller.event.applied\", \"mesh.seat.mesh-controller.event.built-before\", \"mesh.seat.mesh-controller.event.refused\", \"mesh.seat.mesh-controller.event.rolled-back\", \"mesh.seat.mesh-controller.event.checked\", \"mesh.seat.mesh-controller.event.plan-moved\", \"mesh.seat.mesh-controller.event.assignment-changed\", \"mesh.seat.mesh-controller.event.declared-config-changed\", \"mesh.seat.mesh-controller.event.predefined-changed\", \"mesh.seat.mesh-controller.event.condition-raised\", \"mesh.seat.mesh-controller.event.condition-changed\", \"mesh.seat.mesh-controller.event.condition-cleared\", \"mesh.seat.mesh-controller.event.doctor-heartbeat\", \"mesh.seat.mesh-controller.event.secret-replaced\", \"mesh.seat.mesh-controller.event.healer-acted\", \"$SRV.INFO\", \"mesh.seat.node-intrusion-prevention.tool.banned.*\", \"mesh.seat.node-backup.tool.backed-up.*\", \"mesh.seat.node-backup.tool.now.*\", \"mesh.seat.mesh-delivery.tool.stalled\", \"mesh.seat.mesh-delivery.tool.close\", \"mesh.seat.node-launcher.tool.secret.*\", \"mesh.seat.mesh-delivery.tool.release\", \"mesh.seat.mesh-delivery.tool.stop\", \"mesh.seat.mesh-delivery.tool.times\", \"mesh.seat.mesh-delivery.tool.groups\", \"mesh.seat.node-service-manager.tool.restart.*\", \"mesh.seat.operator-channel.tool.tell\", \"mesh.seat.mesh-controller.tool.plans\", \"mesh.events.dead.>\", \"mesh.again.>\"] }\n        subscribe: { allow: [\"$JS.API.>\", \"$JS.EVENT.ADVISORY.CONSUMER.MAX_DELIVERIES.>\", \"$JS.EVENT.ADVISORY.CONSUMER.DELETED.>\", \"_DELIVER.controller\", \"_DELIVER.controller.>\", \"_INBOX.controller.>\", \"mesh.control.>\", \"mesh.mod.*.event.provisioner.failing\", \"mesh.mod.*.event.provisioner.recovered\", \"mesh.mod.*.event.provisioner.retirement\", \"mesh.mod.gitea.event.pull.merged\", \"mesh.mod.gitea.event.pull.updated\", \"mesh.mod.mesh-catalog.event.catching-up\", \"mesh.mod.mesh-catalog.event.upgraded\", \"mesh.seat.mesh-build-machine.event.built\", \"mesh.seat.node-build-agent.event.built\", \"mesh.seat.operator-channel.event.decided.mesh-controller\", \"mesh.seat.mesh-controller.tool.>\", \"$SRV.PING\", \"$SRV.INFO\", \"$SRV.PING.mesh-controller\", \"$SRV.PING.mesh-controller.>\", \"$SRV.INFO.mesh-controller\", \"$SRV.INFO.mesh-controller.>\", \"$SRV.STATS\", \"$SRV.STATS.mesh-controller\", \"$SRV.STATS.mesh-controller.>\"] }\n        allow_responses: { max: 1, ttl: \"1m\" }\n      } }\n    ]\n  }\n}\n"
+      "content": "// The first user list, carried by the installer because at genesis there is no mesh to\n// compose one. A bootstrap credential, rotated with the store's and replaced by the\n// controller's own composition from its first start onward.\naccounts {\n  MESH {\n    jetstream: enabled\n    users = [\n      { user: \"controller\", password: \"$2a$10$AHqJgOifIVbU41KmATiMhuXFs8xa7Wl2HuN4UVBCXdN2jIQzjqApy\", permissions: {\n        publish: { allow: [\"$JS.ACK.CONTROL.controller.>\", \"$JS.ACK.EVENTS.controller.>\", \"$JS.ACK.DEAD_LETTER_NOTICES.controller.>\", \"$JS.API.>\", \"$KV.mesh-controller_asked.>\", \"$KV.mesh-controller_assignments.>\", \"$KV.mesh-controller_calls.>\", \"$KV.mesh-controller_hand-acts.>\", \"$KV.mesh-controller_conditions.>\", \"$KV.mesh-controller_condition-history.>\", \"$KV.mesh-controller_declared-config.>\", \"$KV.mesh-controller_lease.>\", \"$KV.mesh-controller_predefined.>\", \"$KV.SEAT_MESH_BUILD_MACHINE_cancelled.>\", \"$KV.SEAT_NODE_BUILD_AGENT_cancelled.>\", \"_INBOX.enrol.>\", \"mesh.assignment.>\", \"mesh.mod.*.tool.>\", \"mesh.node.>\", \"mesh.seat.mesh-build-machine.accept.>\", \"mesh.seat.node-build-agent.accept.>\", \"mesh.seat.mesh-build-machine.tool.>\", \"mesh.seat.node-build-agent.tool.>\", \"mesh.seat.mesh-controller.event.applied\", \"mesh.seat.mesh-controller.event.built-before\", \"mesh.seat.mesh-controller.event.refused\", \"mesh.seat.mesh-controller.event.rolled-back\", \"mesh.seat.mesh-controller.event.checked\", \"mesh.seat.mesh-controller.event.assignment-changed\", \"mesh.seat.mesh-controller.event.declared-config-changed\", \"mesh.seat.mesh-controller.event.predefined-changed\", \"mesh.seat.mesh-controller.event.condition-raised\", \"mesh.seat.mesh-controller.event.condition-changed\", \"mesh.seat.mesh-controller.event.condition-cleared\", \"mesh.seat.mesh-controller.event.doctor-heartbeat\", \"mesh.seat.mesh-controller.event.secret-replaced\", \"mesh.seat.mesh-controller.event.healer-acted\", \"$SRV.INFO\", \"mesh.seat.node-intrusion-prevention.tool.banned.*\", \"mesh.seat.node-backup.tool.backed-up.*\", \"mesh.seat.node-backup.tool.now.*\", \"mesh.seat.mesh-delivery.tool.stalled\", \"mesh.seat.mesh-delivery.tool.close\", \"mesh.seat.node-launcher.tool.secret.*\", \"mesh.seat.mesh-delivery.tool.release\", \"mesh.seat.mesh-delivery.tool.stop\", \"mesh.seat.mesh-delivery.tool.times\", \"mesh.seat.mesh-delivery.tool.groups\", \"mesh.seat.node-service-manager.tool.restart.*\", \"mesh.seat.operator-channel.tool.tell\", \"mesh.seat.mesh-controller.tool.plans\", \"mesh.events.dead.>\", \"mesh.again.>\"] }\n        subscribe: { allow: [\"$JS.API.>\", \"$JS.EVENT.ADVISORY.CONSUMER.MAX_DELIVERIES.>\", \"$JS.EVENT.ADVISORY.CONSUMER.DELETED.>\", \"_DELIVER.controller\", \"_DELIVER.controller.>\", \"_INBOX.controller.>\", \"mesh.control.>\", \"mesh.mod.*.event.provisioner.failing\", \"mesh.mod.*.event.provisioner.recovered\", \"mesh.mod.*.event.provisioner.retirement\", \"mesh.mod.gitea.event.pull.merged\", \"mesh.mod.gitea.event.pull.updated\", \"mesh.mod.mesh-catalog.event.catching-up\", \"mesh.mod.mesh-catalog.event.upgraded\", \"mesh.seat.mesh-build-machine.event.built\", \"mesh.seat.node-build-agent.event.built\", \"mesh.seat.operator-channel.event.decided.mesh-controller\", \"mesh.seat.mesh-controller.tool.>\", \"$SRV.PING\", \"$SRV.INFO\", \"$SRV.PING.mesh-controller\", \"$SRV.PING.mesh-controller.>\", \"$SRV.INFO.mesh-controller\", \"$SRV.INFO.mesh-controller.>\", \"$SRV.STATS\", \"$SRV.STATS.mesh-controller\", \"$SRV.STATS.mesh-controller.>\"] }\n        allow_responses: { max: 1, ttl: \"1m\" }\n      } }\n    ]\n  }\n}\n"
     },
     // The upstream server, until the broker step adopts it: the `nats` module's own image, built by the
     // mesh, takes its place there once, on these same directories (ADR 0333 §3), as the bus's planned

go.mod

@@ -3,14 +3,20 @@ module github.com/novox/mesh-host
 go 1.26.0
 
 require (
-	git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261021153908-725590e06e75
+	git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261029145421-dbcaa29a1a38
+	github.com/nats-io/nats-server/v2 v2.11.17
 	github.com/nats-io/nats.go v1.54.0
 	golang.org/x/crypto v0.57.0
 	golang.org/x/sys v0.48.0
 )
 
 require (
+	github.com/antithesishq/antithesis-sdk-go v0.7.0-default-no-op // indirect
+	github.com/google/go-tpm v0.9.8 // indirect
 	github.com/klauspost/compress v1.20.0 // indirect
+	github.com/minio/highwayhash v1.0.4 // indirect
+	github.com/nats-io/jwt/v2 v2.8.1 // indirect
 	github.com/nats-io/nkeys v0.4.16 // indirect
 	github.com/nats-io/nuid v1.0.1 // indirect
+	golang.org/x/time v0.15.0 // indirect
 )

go.sum

@@ -1,7 +1,17 @@
-git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261021153908-725590e06e75 h1:AcYfyJpYaUufhI93VG76+b001msXY4XX7kuRjnf33HY=
-git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261021153908-725590e06e75/go.mod h1:ouERNpZizzwZ0HLEtAypsY9FR20FyUgUYRni6J7kVCY=
+git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261029145421-dbcaa29a1a38 h1:gJwMmK8isI9HwFM2WOCZXjiTqZmGQxs2UY38stk1ZOA=
+git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261029145421-dbcaa29a1a38/go.mod h1:ouERNpZizzwZ0HLEtAypsY9FR20FyUgUYRni6J7kVCY=
+github.com/antithesishq/antithesis-sdk-go v0.7.0-default-no-op h1:Z/MZK75wC/NSrkgqeNIa7jexam9uWzhLmFTSCPI/kn0=
+github.com/antithesishq/antithesis-sdk-go v0.7.0-default-no-op/go.mod h1:FQyySiasQQM8735Ddel3MRojmy4dA1IqCeyJ5jmPMbI=
+github.com/google/go-tpm v0.9.8 h1:slArAR9Ft+1ybZu0lBwpSmpwhRXaa85hWtMinMyRAWo=
+github.com/google/go-tpm v0.9.8/go.mod h1:h9jEsEECg7gtLis0upRBQU+GhYVH6jMjrFxI8u6bVUY=
 github.com/klauspost/compress v1.20.0 h1:a3C1ke2ohxFymNlb2HWAHjDeKCI90scRskErZkR0ezA=
 github.com/klauspost/compress v1.20.0/go.mod h1:LUdAzn7YLVvxLpc7y3V1m40wESHTgc1422pwwBSKYuI=
+github.com/minio/highwayhash v1.0.4 h1:asJizugGgchQod2ja9NJlGOWq4s7KsAWr5XUc9Clgl4=
+github.com/minio/highwayhash v1.0.4/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ=
+github.com/nats-io/jwt/v2 v2.8.1 h1:V0xpGuD/N8Mi+fQNDynXohVvp7ZztevW5io8CUWlPmU=
+github.com/nats-io/jwt/v2 v2.8.1/go.mod h1:nWnOEEiVMiKHQpnAy4eXlizVEtSfzacZ1Q43LIRavZg=
+github.com/nats-io/nats-server/v2 v2.11.17 h1:GKEghcFK6A+aFx11Yf1LjgLC3txAwvyhnYzhBIQZA8I=
+github.com/nats-io/nats-server/v2 v2.11.17/go.mod h1:B1sFVz4StNosQ903ak4N1G01Fl/9f8e06mXpFIE2K24=
 github.com/nats-io/nats.go v1.54.0 h1:vsXoOxjHp/GmPUN+EcI7uOf/uB+iAP+kEsAFNQN0yzA=
 github.com/nats-io/nats.go v1.54.0/go.mod h1:y+DZoD1oBOYfZTU681eTUiUjI0vbqYGixNVFHcjHJ0k=
 github.com/nats-io/nkeys v0.4.16 h1:rd5oAuLOb8mnAycB0xleuEBNS1pVVnN0fv/FF34Eypg=
@@ -10,5 +20,8 @@ github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
 github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
 golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
 golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
+golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
 golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
+golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
+golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=

internal/apply/alone.go

@@ -0,0 +1,67 @@
+package apply
+
+import (
+	"context"
+	"fmt"
+
+	"git.novox.be/novox/mesh-sdk/go/declaration"
+	"github.com/novox/mesh-host/internal/store"
+	"github.com/novox/mesh-host/internal/system"
+)
+
+// WriteAlone writes one file a module's composition declares, through the apply's own file step, and records it as an
+// apply would; nothing else of the module is applied, and nothing that reads the file is moved (novox/hq ADR 0547 §8).
+//
+// **For a file whose reader takes the change itself.** The bus's user list is the one it is for: the bus module's
+// entrypoint watches the file and signals the server to reload in place, so the list is in force without a want of the
+// bus, which nobody writes (ADR 0539 §15), and without the container being touched. A file that a service or a container
+// must be moved to read is not written alone: it goes through the module's apply, which moves what reads it.
+//
+// The file is written only when its content differs from what is there (the file step's own rule), read back, and
+// recorded under the module whose resource it is, so the module's next apply finds it as its own and writes nothing.
+// The caller holds the apply's lock. log is said the path, the action and the digest, never the content.
+func WriteAlone(ctx context.Context, sys system.System, file *declaration.File, known store.State, run Runner,
+	log func(string)) (Outcome, store.State, error) {
+	if log == nil {
+		log = func(string) {}
+	}
+	if file.Into != "" || file.CreateOnce || file.Sealed != "" || file.VaultSealed != nil || len(file.Secrets) > 0 {
+		return Outcome{}, known, &Error{Resource: file.ID, Err: fmt.Errorf("%s is not a whole file of plain content, "+
+			"and only such a file is written alone; nothing was written", file.Path)}
+	}
+	if file.IsReference() {
+		return Outcome{}, known, &Error{Resource: file.ID, Err: fmt.Errorf("%s is given by digest %s and was not "+
+			"resolved to its content; it is not written empty", file.Path, file.Digest)}
+	}
+	if held, isHeld := known.HeldAt(file.ID); isHeld {
+		return Outcome{}, known, &Error{Resource: file.ID, Err: fmt.Errorf("%s is held as found for a module not "+
+			"yet taken (%s), so nothing was written", file.Path, held.Why)}
+	}
+	was, _ := known.Find(file.ID)
+	if was.ID == "" {
+		// Only over a file the mesh wrote: a file this node holds no record of is the module's apply's to take, with
+		// the original kept, never this write's. A record of the path under another id (the declaration before the
+		// switch named it so) is the one written to, so no second record of the file is left for an apply to remove.
+		rec, ok := known.At(string(declaration.TypeFile), file.Path)
+		if !ok {
+			return Outcome{}, known, &Error{Resource: file.ID, Err: fmt.Errorf("this node holds no record of %s; it "+
+				"is written by the module's apply first, never alone", file.Path)}
+		}
+		renamed := *file
+		renamed.ID = rec.ID
+		file, was = &renamed, rec
+	}
+	in := inputs{declares: map[string]string{file.Identity(): declaredDigest(file)}, known: &known,
+		groups: groupsWanted([]declaration.Resource{file}), handed: Handed{}, dirsBefore: map[string]bool{},
+		files: map[string]bool{file.Path: true}}
+	outcome, err := applyOne(ctx, sys, file, run, map[string]bool{}, in, was, nil, nil)
+	if err != nil {
+		log(fmt.Sprintf("  failed %s (%s), alone: %v", file.ID, file.Path, err))
+		return outcome, known, &Error{Resource: file.ID, Err: err}
+	}
+	recordKeeping(&known, file, outcome, was)
+	if moved(outcome) {
+		log(fmt.Sprintf("  %s %s (%s), alone: %s", outcome.Action, file.ID, file.Path, outcome.wrote))
+	}
+	return outcome, known, nil
+}

internal/apply/alone_test.go

@@ -0,0 +1,90 @@
+package apply
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"git.novox.be/novox/mesh-sdk/go/declaration"
+	"github.com/novox/mesh-host/internal/store"
+)
+
+// Defends novox/hq ADR 0547 §8: the bus node writes the bus's user list alone, with no want, through the apply's own
+// file step: only when it differs, mode 0600, read back and recorded as the module's, and nothing else moves.
+func TestAFileWrittenAloneMovesNothingElse(t *testing.T) {
+	const was, now = "user a\n", "user a\nuser b\n"
+	for _, c := range []struct {
+		name, fields, before string
+		recorded             bool
+		recordedAs           string // the id the record has, when not the composition's
+		action, refused      string
+		after                string
+	}{
+		{name: "no record of it", fields: `"content":%q,"mode":"0600"`, before: was, refused: "holds no record", after: was},
+		{name: "changed", fields: `"content":%q,"mode":"0600"`, before: was, recorded: true, action: "updated", after: now},
+		{name: "the same", fields: `"content":%q,"mode":"0600"`, before: now, recorded: true, action: "unchanged", after: now},
+		{name: "recorded under the id from before the switch", fields: `"content":%q,"mode":"0600"`, before: was,
+			recorded: true, recordedAs: "bus-users", action: "updated", after: now},
+		{name: "absent with a record", fields: `"content":%q,"mode":"0600"`, recorded: true, action: "created", after: now},
+		{name: "written into", fields: `"content":%q,"into":"block","owner-at-runtime":"managed"`, before: was,
+			recorded: true, refused: "only such a file", after: was},
+		{name: "sealed", fields: `"sealed":"c2VhbGVk"`, before: was, recorded: true,
+			refused: "only such a file", after: was},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			path := filepath.Join(t.TempDir(), "accounts.conf")
+			if c.before != "" {
+				if err := os.WriteFile(path, []byte(c.before), 0o600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			fields := strings.Replace(c.fields, "%q", fmt.Sprintf("%q", now), 1)
+			d := parseTrusted(t, fmt.Sprintf(`{"declaration":1,"resources":[{"id":"nats.bus-users","module":"nats",
+			  "type":"file","path":%q,`+fields+`}]}`, path))
+			file := d.Resources[0].(*declaration.File)
+			known := store.State{}
+			id := file.ID
+			if c.recordedAs != "" {
+				id = c.recordedAs
+			}
+			if c.recorded {
+				known.Record(store.Applied{ID: id, Type: string(declaration.TypeFile), Module: "nats", Target: path,
+					Origin: store.OriginDeclared, Wrote: digestOf(c.before)})
+			}
+			calls := 0
+			counting := func(context.Context, string, ...string) (string, error) { calls++; return "", nil }
+			out, after, err := WriteAlone(context.Background(), archHost(t), file, known, counting, nil)
+			if c.refused != "" {
+				if err == nil || !strings.Contains(err.Error(), c.refused) {
+					t.Fatalf("not refused with %q: %v", c.refused, err)
+				}
+			} else if err != nil {
+				t.Fatal(err)
+			} else if out.Action != c.action {
+				t.Errorf("action %q, want %q", out.Action, c.action)
+			}
+			if got := readText(t, path); got != c.after {
+				t.Errorf("file holds %q, want %q", got, c.after)
+			}
+			if calls != 0 {
+				t.Errorf("%d commands were run: a file written alone moves nothing", calls)
+			}
+			if c.refused != "" {
+				return
+			}
+			if m := modeAt(t, path); m != 0o600 {
+				t.Errorf("mode %o", m)
+			}
+			rec, ok := after.Find(id)
+			if !ok || rec.Wrote != digestOf(now) || rec.Target != path {
+				t.Errorf("record %+v (found %v), want it to say %s was written", rec, ok, digestOf(now))
+			}
+			if n := len(after.Resources); n != 1 {
+				t.Errorf("%d records of one file", n)
+			}
+		})
+	}
+}

internal/apply/apply.go

@@ -21,7 +21,6 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -300,6 +299,60 @@ func ApplyMindingWindows(
 	unseal Unseal,
 	keep Keep,
 	windows *Windows,
+) (Report, store.State, error) {
+	return applyScoped(ctx, sys, d, nil, known, origin, run, log, unseal, keep, windows)
+}
+
+// Scope is what makes an apply one module's (novox/hq ADR 0429 §4, ADR 0539 §9): the module whose want changed, and
+// the resources the node's other modules hold, so a path, a unit or a group another module still asks for is neither
+// removed nor taken from it. Only that module's own records are orphans; a removed module is a Scope with an empty
+// declaration.
+type Scope struct {
+	// Module is the module applied. NodeModule (store.NodeModule) is the node's own composition.
+	Module string
+	// Others are the resources of every other module the node has a composition for.
+	Others []declaration.Resource
+}
+
+// owns reports whether a record belongs to the scope's module.
+func (sc *Scope) owns(a store.Applied) bool {
+	return store.OwnerOf(a, declaration.ModuleGuess) == sc.Module
+}
+
+// isNode is whether the scope is the node's own composition, the one that carries identities, groups, libraries and
+// the adoption.
+func (sc *Scope) isNode() bool { return sc == nil || sc.Module == store.NodeModule }
+
+// ApplyModule makes the machine match one module's declaration, and only that module's: everything else the node
+// runs is left as it is. d holds the module's resources; scope names the module and what the others hold.
+func ApplyModule(
+	ctx context.Context,
+	sys system.System,
+	d *declaration.Declaration,
+	scope Scope,
+	known store.State,
+	origin string,
+	run Runner,
+	log func(string),
+	unseal Unseal,
+	keep Keep,
+	windows *Windows,
+) (Report, store.State, error) {
+	return applyScoped(ctx, sys, d, &scope, known, origin, run, log, unseal, keep, windows)
+}
+
+func applyScoped(
+	ctx context.Context,
+	sys system.System,
+	d *declaration.Declaration,
+	scope *Scope,
+	known store.State,
+	origin string,
+	run Runner,
+	log func(string),
+	unseal Unseal,
+	keep Keep,
+	windows *Windows,
 ) (report Report, _ store.State, _ error) {
 	// Said whichever way the apply ended, failure included: a window being open is a fact about the
 	// machine, not about this apply.
@@ -326,7 +379,9 @@ func ApplyMindingWindows(
 	}
 	// What an unfinished apply found a unit as is kept only while its service is declared: one
 	// declared again later is read afresh, as any resource with no record is (novox/hq ADR 0118).
-	known.DropFoundUndeclared(declared, origin)
+	if scope == nil {
+		known.DropFoundUndeclared(declared, origin)
+	}
 
 	// Which units the mesh made, read before any removal can take a unit file's record away — so
 	// whichever order a module declared a unit and its file in, the unit is known for the mesh's
@@ -351,7 +406,11 @@ func ApplyMindingWindows(
 	// it back would stop or disable a unit the declaration says is running, every container on it
 	// with it, only for the declared one to start it again in the same apply. The record is
 	// forgotten; the unit's found state is the remaining record's to give back.
-	heldUnits := unitsHeld(d.Resources)
+	everything := d.Resources
+	if scope != nil {
+		everything = append(append([]declaration.Resource{}, d.Resources...), scope.Others...)
+	}
+	heldUnits := unitsHeld(everything)
 
 	// **A whole file still declared at its path by another resource is handed to it, never removed
 	// first** (novox/hq ADR 0223). A file can change owners between modules — the machine's resolver
@@ -361,20 +420,55 @@ func ApplyMindingWindows(
 	// and stayed so until the new resource's turn came, with every resource in between applied on a
 	// machine without it. The record going is kept until the one declaring the path now is recorded
 	// in its place: then it is forgotten, and what it kept of the original goes with the file.
-	heldFiles := filesHeld(d.Resources)
+	heldFiles := filesHeld(everything)
 	handedFiles := map[string]store.Applied{}
 
 	// **A group still asked for by another resource is not given back when one record of it goes**
 	// (novox/hq ADR 0252), on the unit's rule above: two modules may each want the account in one group,
 	// and the one going takes nothing the other still needs.
-	wanted := groupsWanted(d.Resources)
+	wanted := groupsWanted(everything)
 	// And what a record going hands to a resource that still asks for its group (novox/hq ADR 0252 §3).
 	handed := Handed{}
 
+	// **A resource another module's composition now holds is that module's, and is left** (issue 1945): a module that
+	// leaves the node's own composition for one of its own takes its resources with it, by their identity, and the node's
+	// own apply leaves each as it is, record and all, until that module's apply takes it. Removed, a node lost its
+	// resolver guard, its sudoers file and a running container between two applies.
+	heldByOthers := map[string]string{}
+	if scope != nil {
+		for _, r := range scope.Others {
+			heldByOthers[r.Identity()] = r.DeclaredModule()
+		}
+	}
+
 	removeOrphan := func(orphan store.Applied) error {
 		var action, detail string
 		var err error
+		if module, held := heldByOthers[orphan.ID]; held && !declared[orphan.ID] {
+			if module == "" {
+				module = "another module"
+			}
+			detail := "no longer declared here; the composition of " + module + " holds it, so it was left as it is"
+			report.Outcomes = append(report.Outcomes, Outcome{
+				ID: orphan.ID, Type: orphan.Type, Target: orphan.Target,
+				Action: "kept", Detail: detail,
+			})
+			log(fmt.Sprintf("  kept %s (%s): %s", orphan.ID, orphan.Target, detail))
+			return nil
+		}
 		if by, held := heldFiles[fileKey(orphan)]; held && by != orphan.ID {
+			if scope != nil && !declared[by] {
+				// Another module declares the path: it is that module's, so this record is let go and the file is
+				// neither removed nor taken from it (ADR 0539 §9).
+				known.Forget(orphan.ID)
+				detail := "no longer declared; " + by + " of another module still holds the path, so it was left as it is"
+				report.Outcomes = append(report.Outcomes, Outcome{
+					ID: orphan.ID, Type: orphan.Type, Target: orphan.Target,
+					Action: "forgotten", Detail: detail,
+				})
+				log(fmt.Sprintf("  forgotten %s (%s): %s", orphan.ID, orphan.Target, detail))
+				return nil
+			}
 			handedFiles[by] = orphan
 			return nil
 		}
@@ -482,20 +576,11 @@ func ApplyMindingWindows(
 	}
 	handover := map[string][]store.Applied{}
 	for _, orphan := range known.Orphans(declared, origin) {
-		if d.Adoption == nil && strings.HasPrefix(orphan.ID, declaration.AdoptionPrefix) {
-			protecting = append(protecting, orphan)
+		if scope != nil && !scope.owns(orphan) {
 			continue
 		}
-		// **A module the mesh left out is not a module the mesh removed** (novox/hq ADR 0163, rule
-		// 6): its resources are absent because a setting stored for it cannot compose, and the
-		// mesh said so by name. What the host wrote for it stays as it is, recorded, until the
-		// module is declared again or unassigned.
-		if module, left := d.LeftOutModuleOf(orphan.ID); left {
-			report.Outcomes = append(report.Outcomes, Outcome{
-				ID: orphan.ID, Type: orphan.Type, Target: orphan.Target,
-				Action: "unchanged", Detail: "kept: " + module + " was left out of this declaration by the mesh, not removed",
-			})
-			log(fmt.Sprintf("  kept %s (%s): %s was left out of this declaration by the mesh, not removed", orphan.ID, orphan.Target, module))
+		if d.Adoption == nil && strings.HasPrefix(orphan.ID, declaration.AdoptionPrefix) {
+			protecting = append(protecting, orphan)
 			continue
 		}
 		if by, replaced := replacedBy[orphan.ID]; replaced {
@@ -538,12 +623,7 @@ func ApplyMindingWindows(
 	// what is assigned: a carried bundle's silence is not an unassignment.
 	if origin == store.OriginDeclared {
 		for _, h := range append([]store.Held{}, known.Held...) {
-			if declared[h.ID] {
-				continue
-			}
-			if slices.Contains(d.LeftOut, h.Module) {
-				// Left out, not unassigned (ADR 0163, rule 6): still held for the module, as the
-				// mesh asked.
+			if declared[h.ID] || (scope != nil && h.Module != scope.Module) {
 				continue
 			}
 			known.Release(h.ID)
@@ -584,6 +664,7 @@ func ApplyMindingWindows(
 	in.refused = refusedPlaces(d.Resources)
 	in.agentHomes = rootNeverHomes(d)
 	in.dirsBefore = map[string]bool{}
+	in.files = declaredFiles(d.Resources)
 	for _, resource := range d.Resources {
 		in.declares[resource.Identity()] = declaredDigest(resource)
 		if dir, ok := resource.(*declaration.Directory); ok {
@@ -744,7 +825,7 @@ func ApplyMindingWindows(
 	in.held = heldRoots(verdicts, d.Libraries)
 	// A tool runner no longer put in a group leaves it before anything is applied, so its unit, which names the
 	// change under restart-on, is restarted in this same apply to lose it (ADR 0328 §11, ADR 0334 §2, ADR 0252 §3).
-	if origin == store.OriginDeclared {
+	if origin == store.OriginDeclared && scope.isNode() {
 		for _, o := range leaveRunners(ctx, sys, d.Libraries, d.Identities, &known, run, wanted) {
 			if o.Action == "restored" {
 				changed[o.changes] = true
@@ -1036,6 +1117,11 @@ func ApplyMindingWindows(
 		}
 		// Only now. The record follows the fact, never leads it.
 		recordApplied(&known, origin, resource, outcome, kept, keptMode, keptOwner)
+		if scope != nil {
+			known.SetModule(resource.Identity(), scope.Module)
+		} else if module, ours := d.ModuleOfID(resource.Identity()); ours {
+			known.SetModule(resource.Identity(), module)
+		}
 		appliedOK[resource.Identity()] = true
 		// Its module has been taken, and what was held for it is now the mesh's. A file written
 		// into, or a service whose lifecycle is the machine's, replaced nothing that was found, so
@@ -1137,8 +1223,21 @@ func ApplyMindingWindows(
 		}
 	}
 
+	// A file written or removed in a unit directory is read by the service manager only after a reload, whether or not
+	// a service reflects it: a drop-in on reboot.target is reflected by no service, and without the reload the next
+	// reboot still runs the target as it was loaded (issue 1126). Once per apply.
+	if at := unitFileMoved(report.Outcomes); at != "" {
+		if u, ok := sys.(unitReloader); ok {
+			if err := u.ReloadUnits(ctx, run); err != nil {
+				failures = append(failures, &Error{Resource: at, Err: fmt.Errorf("reloading the service manager's units: %w", err)})
+			} else {
+				log(fmt.Sprintf("  reloaded the service manager's units: %s changed", at))
+			}
+		}
+	}
+
 	// Only the mesh says what is assigned: a carried bundle's silence undeclares no identity and no folder.
-	if origin == store.OriginDeclared {
+	if origin == store.OriginDeclared && scope.isNode() {
 		// And an identity, then a library group, no longer declared goes, once what ran as it went above (ADR 0328
 		// §3, §4).
 		if tool, err := toolFor(sys); err == nil {
@@ -1157,7 +1256,7 @@ func ApplyMindingWindows(
 	// the mesh's derived filter among it — applied cleanly (novox/hq ADR 0100), and on every
 	// converged apply, not once (ADR 0168). Skipped, it is said: a step that does nothing is never
 	// silent (issue 143).
-	if len(failures) == 0 {
+	if len(failures) == 0 && scope.isNode() {
 		did, err := retireFirewall(ctx, d, origin, &known, run, log)
 		if err != nil {
 			return report, known, &Error{Resource: "the firewall found on this machine", Err: err, Done: report}
@@ -1168,7 +1267,7 @@ func ApplyMindingWindows(
 				return report, known, err
 			}
 		}
-	} else if rec := known.Firewall; origin == store.OriginDeclared && d.Adoption == nil && rec != nil &&
+	} else if rec := known.Firewall; len(failures) > 0 && scope.isNode() && origin == store.OriginDeclared && d.Adoption == nil && rec != nil &&
 		rec.Kind == string(firewall.UFW) && rec.WasActive && firewall.Active(ctx, run) {
 		report.Firewall = fmt.Sprintf("left in force: %d resource(s) failed, and the found firewall is retired only after a clean apply", len(failures))
 		log("  kept ufw in force: " + report.Firewall)
@@ -1333,6 +1432,16 @@ func applyOne(ctx context.Context, sys system.System, r declaration.Resource, ru
 				"created once it is (novox/hq ADR 0328 §9)"
 			return out, nil
 		}
+		// Not created or replaced before a file it mounts is there: the runtime would make the missing source a
+		// directory, and the file could never be written there (novox/hq issue 1873). The write of the file applies
+		// what reads it (WriteFilled, readsChange), this container among them.
+		if src := mountsAFileNotThere(res, in.files); src != "" {
+			out := begin(r)
+			out.Action = "waiting"
+			out.Detail = "not created: it mounts " + src + ", a file the declaration declares that is not there " +
+				"yet; created once it is (novox/hq issue 1873)"
+			return out, nil
+		}
 	}
 	// Nothing below a home is touched through a link an account put there (novox/hq ADR 0266).
 	// And nothing is unpacked or written into below an agent's home (agent_home_guard.go).
@@ -1482,6 +1591,9 @@ func applyDirectory(r *declaration.Directory, previous store.Applied, wasBefore
 	}
 	if existed && wasBefore {
 		ours := previous.Target != "" && filepath.Clean(previous.Target) == filepath.Clean(r.Path) && !previous.AsFound
+		// In the mesh's own tree, a directory the engine's own account owns was made by the mesh, on the way to
+		// something below it or by an earlier apply that did not record it: it is the mesh's (novox/hq issue 1873).
+		ours = ours || madeInTheMeshsTree(r.Path, before)
 		if !ours {
 			owned, err := ownedBy(r.Path, r.Owner)
 			if err != nil {
@@ -1557,6 +1669,30 @@ func applyDirectory(r *declaration.Directory, previous store.Applied, wasBefore
 	return out, nil
 }
 
+// madeInTheMeshsTree is whether a directory lies in the mesh's own tree (meshDataRoot, below it, never the root
+// itself) and belongs to the engine's own account: only that account makes a directory there, so it is the mesh's
+// and not found (novox/hq issue 1873). Anywhere else, or owned by any other account, issue 339's rule stands.
+func madeInTheMeshsTree(path string, found os.FileInfo) bool {
+	// By its text and by where it leads: a link in the tree pointing out of it leads outside, and what is there is
+	// not the tree's (review of issue 1873).
+	if !inTheMeshsTree(path) {
+		return false
+	}
+	uid, _, ok := ownerOf(found)
+	return ok && uid == os.Geteuid()
+}
+
+// inTheMeshsTree is whether a path lies strictly below the mesh's own tree, both as written and with every link in
+// it followed (resolved), against the tree's root resolved the same way (novox/hq issue 1873).
+func inTheMeshsTree(path string) bool {
+	root := filepath.Clean(meshDataRoot)
+	sep := string(filepath.Separator)
+	if !strings.HasPrefix(filepath.Clean(path), root+sep) {
+		return false
+	}
+	return strings.HasPrefix(resolved(filepath.Clean(path)), resolved(root)+sep)
+}
+
 // applyHandedOver gives a directory the operator handed to the mesh its declared mode and owner (novox/hq issue
 // 356). **No link, checked again at the moment of use**: the hand-over refused a link when it was recorded, and a
 // component of the path may have become one since — a parent swapped for a link to /etc would carry root's chmod
@@ -1606,6 +1742,19 @@ func applyHandedOver(r *declaration.Directory, out Outcome, mode os.FileMode) (O
 // keepFound, when not nil, is where the original of a file this host has no record of is kept
 // before it is written over (novox/hq ADR 0100): once, never overwritten, and named in the outcome.
 func applyFile(r *declaration.File, previous store.Applied, unseal Unseal, keepFound Keep) (Outcome, error) {
+	cleared, err := clearRuntimesEmptyDirectory(r.Path)
+	if err != nil {
+		return begin(r), err
+	}
+	out, err := applyFileAt(r, previous, unseal, keepFound)
+	if cleared != "" {
+		out.Detail = joinDetail(cleared, out.Detail)
+	}
+	return out, err
+}
+
+// applyFileAt writes a declared file: applyFile's work once its path is cleared of what a runtime left there.
+func applyFileAt(r *declaration.File, previous store.Applied, unseal Unseal, keepFound Keep) (Outcome, error) {
 	if r.Into == declaration.IntoBlock {
 		return applyBlock(r, previous)
 	}
@@ -1861,11 +2010,68 @@ type serviceReloader interface {
 	ReloadService(ctx context.Context, run system.Runner, unit string) error
 }
 
+// UnitDirs are the system service manager's unit directories: a file the apply writes or removes in one of them, or in a
+// drop-in directory below one, is read by the manager only after a reload (issue 1126). Replaceable in tests.
+var UnitDirs = []string{"/etc/systemd/system", "/run/systemd/system", "/usr/local/lib/systemd/system"}
+
+// unitFileMoved is the first file this apply wrote or removed in a unit directory or a drop-in directory below one,
+// or "" when it moved none.
+func unitFileMoved(outcomes []Outcome) string {
+	for _, o := range outcomes {
+		// Only what changed the file on disk, as MovesRoot reads it: skipped, held, kept, forgotten and waiting come
+		// back on every apply and change nothing.
+		if declaration.Type(o.Type) != declaration.TypeFile {
+			continue
+		}
+		switch o.Action {
+		case "created", "updated", "corrected", "removed":
+		default:
+			continue
+		}
+		at := filepath.Clean(o.Target)
+		for _, dir := range UnitDirs {
+			if rel, err := filepath.Rel(dir, at); err == nil && rel != "." && !strings.HasPrefix(rel, "..") {
+				return at
+			}
+		}
+	}
+	return ""
+}
+
 // unitReloader is a service manager that caches unit files and must be told to read them again.
 type unitReloader interface {
 	ReloadUnits(ctx context.Context, run system.Runner) error
 }
 
+// restReader is a service manager that can say whether a one-shot has nothing running now
+// (novox/hq issue 1126).
+type restReader interface {
+	ServiceAtRest(ctx context.Context, run system.Runner, unit string) (bool, error)
+}
+
+// declaredState is a unit's state as a declaration of want reads it. **A one-shot at rest is
+// stopped to a declaration that it be stopped** (novox/hq issue 1126): a one-shot that does not
+// linger reads "running" once it ran and worked — that is what a declaration that it run asks — but
+// it has no process between its runs, so it is also as stopped as it can be, and stopping it changes
+// nothing. Read only as "running", a boot-time cleanup declared stopped and enabled failed every
+// apply after the boot that ran it: "was asked to be stopped and is running".
+func declaredState(ctx context.Context, sys system.System, run Runner, unit, want string) (string, error) {
+	state, err := sys.ServiceState(ctx, run, unit)
+	if err != nil || want != "stopped" || state != "running" {
+		return state, err
+	}
+	if r, ok := sys.(restReader); ok {
+		rest, err := r.ServiceAtRest(ctx, run, unit)
+		if err != nil {
+			return "", err
+		}
+		if rest {
+			return "stopped", nil
+		}
+	}
+	return state, nil
+}
+
 // serviceSettle is how long the host waits before looking at a unit a second time. A test sets it
 // to nothing; on a machine it is the window in which a daemon that refuses its configuration dies.
 var serviceSettle = 2 * time.Second
@@ -2018,7 +2224,7 @@ func applyServiceIn(ctx context.Context, sys system.System, r *declaration.Servi
 	// own stopping from anybody else's (novox/hq ADR 0269).
 	out.declared = &store.FoundUnit{Unit: r.Unit, State: r.State, Boot: r.Boot}
 
-	before, err := sys.ServiceState(ctx, run, r.Unit)
+	before, err := declaredState(ctx, sys, run, r.Unit, r.State)
 	if err != nil {
 		return out, err
 	}
@@ -2029,7 +2235,7 @@ func applyServiceIn(ctx context.Context, sys system.System, r *declaration.Servi
 
 		// Read back. A service manager accepting a command says the transaction was accepted,
 		// not that the unit is running — one that starts and immediately dies satisfies it.
-		after, err := sys.ServiceState(ctx, run, r.Unit)
+		after, err := declaredState(ctx, sys, run, r.Unit, r.State)
 		if err == nil && r.State == "running" {
 			after, err = stayedRunning(ctx, sys, run, r.Unit)
 		}
@@ -2328,12 +2534,18 @@ func ExecRunner(ctx context.Context, name string, args ...string) (string, error
 	if err != nil {
 		var exit *exec.ExitError
 		if errors.As(err, &exit) {
-			// The words as they always were, and the exit underneath them, so a caller asks the
-			// code (system.ExitCode) rather than matching text that this line is free to reword.
-			return string(out), &exited{
-				words: fmt.Sprintf("%s exited %d: %s", name, exit.ExitCode(), strings.TrimSpace(string(exit.Stderr))),
-				exit:  exit,
+			words := fmt.Sprintf("%s exited %d: %s", name, exit.ExitCode(), strings.TrimSpace(string(exit.Stderr)))
+			if exit.ExitCode() == -1 {
+				// Killed, not exited: say by what, and the context's end when that is what killed it (issue 1945:
+				// "docker exited -1:" said nothing while a bus container was half replaced).
+				words = fmt.Sprintf("%s was %s", name, exit.String())
+				if ctx.Err() != nil {
+					words += " because its context ended: " + ctx.Err().Error()
+				}
 			}
+			// The words, and the exit underneath them, so a caller asks the code (system.ExitCode) rather than
+			// matching text that this line is free to reword.
+			return string(out), &exited{words: words, exit: exit}
 		}
 		return string(out), fmt.Errorf("%s: %w", name, err)
 	}
@@ -2438,6 +2650,9 @@ type inputs struct {
 	// held is the root of every library whose disk or mount is not there, with its name: no container that mounts
 	// it is created (novox/hq ADR 0328 §9).
 	held map[string]string
+	// files is the path of every file the declaration declares: a container mounting one that is not there yet waits
+	// for it (novox/hq issue 1873).
+	files map[string]bool
 	// handed is every group a record that went this apply handed to a resource still asking for it.
 	handed Handed
 }
@@ -2819,6 +3034,14 @@ func applyContainer(ctx context.Context, r *declaration.Container, run Runner,
 		return out, nil
 	}
 
+	aside := ""
+	if !existed {
+		// A container an engine set aside and then stopped before it ran the replacement (it died between the two):
+		// the set-aside one of this apply, put back if the replacement fails and removed once it runs (issue 1945).
+		if _, err := containerState(ctx, r.Name+asideSuffix, run); err == nil {
+			aside = r.Name + asideSuffix
+		}
+	}
 	switch {
 	case existed && (before.Spec == want || legacy) && before.Running && len(reasons) == 0:
 		out.Action = "unchanged"
@@ -2841,15 +3064,40 @@ func applyContainer(ctx context.Context, r *declaration.Container, run Runner,
 		if err := ensureImage(ctx, cri, r.Image, run); err != nil {
 			return out, fmt.Errorf("not replacing container %s, which keeps running: %w", r.Name, err)
 		}
-		if _, err := run(ctx, cri, "rm", "-f", r.Name); err != nil {
-			return out, fmt.Errorf("replacing container %s: %w", r.Name, err)
+		// **The running container is set aside, never removed, until its replacement runs** (issue 1945): stopped and
+		// renamed, so its name and ports are free, and started again under its own name when the replacement does not
+		// come up. Removed first, the bus's own container left a node without a bus when its replacement was never
+		// made (2026-10-25 at 11:23). A container set aside by an earlier apply that stopped midway goes first.
+		aside = r.Name + asideSuffix
+		_, _ = run(ctx, cri, "rm", "-f", aside)
+		if _, err := run(ctx, cri, "rename", r.Name, aside); err != nil {
+			return out, fmt.Errorf("replacing container %s: setting the running one aside: %w", r.Name, err)
 		}
+		if _, err := run(ctx, cri, "stop", aside); err != nil {
+			_, _ = run(ctx, cri, "rename", aside, r.Name)
+			return out, fmt.Errorf("replacing container %s: stopping the running one: %w", r.Name, err)
+		}
+	}
+
+	// putBack starts the container set aside again under its own name, after a replacement that did not come up.
+	putBack := func(cause error) error {
+		if aside == "" {
+			return cause
+		}
+		_, _ = run(ctx, cri, "rm", "-f", r.Name)
+		if _, err := run(ctx, cri, "rename", aside, r.Name); err != nil {
+			return fmt.Errorf("%w; and the container it replaced could not be put back: %v", cause, err)
+		}
+		if _, err := run(ctx, cri, "start", r.Name); err != nil {
+			return fmt.Errorf("%w; and the container it replaced could not be started again: %v", cause, err)
+		}
+		return fmt.Errorf("%w; the container it replaced was started again", cause)
 	}
 
 	args := detachedRunArgs(r, want)
 
 	if _, err := run(ctx, cri, args...); err != nil {
-		return out, fmt.Errorf("starting container %s: %w", r.Name, err)
+		return out, putBack(fmt.Errorf("starting container %s: %w", r.Name, err))
 	}
 
 	// Read back. `docker run --detach` returning an id says the container was created, not
@@ -2857,15 +3105,21 @@ func applyContainer(ctx context.Context, r *declaration.Container, run Runner,
 	// command exactly as one that came up does.
 	after, err := containerState(ctx, r.Name, run)
 	if err != nil {
-		return out, fmt.Errorf("started container %s and it is not there: %w", r.Name, err)
+		return out, putBack(fmt.Errorf("started container %s and it is not there: %w", r.Name, err))
 	}
 	if !after.Running {
-		return out, fmt.Errorf(
+		return out, putBack(fmt.Errorf(
 			"container %s was started and is not running. It exited; ask the runtime for its "+
-				"logs", r.Name)
+				"logs", r.Name))
 	}
 	if after.Spec != want {
-		return out, fmt.Errorf("container %s is not the one that was declared after creating it", r.Name)
+		return out, putBack(fmt.Errorf("container %s is not the one that was declared after creating it", r.Name))
+	}
+	// Only now, with the replacement running, is the container set aside removed.
+	if aside != "" {
+		if _, err := run(ctx, cri, "rm", "-f", aside); err != nil {
+			out.Detail = fmt.Sprintf("the container it replaced, set aside as %s, could not be removed: %v", aside, err)
+		}
 	}
 	// The found networks a per-machine setting keeps for it (novox/hq ADR 0163, rule 4), joined
 	// once it runs: a runtime starts a container on one network, and the others are connected.
@@ -2901,6 +3155,9 @@ func applyContainer(ctx context.Context, r *declaration.Container, run Runner,
 	return out, nil
 }
 
+// asideSuffix names a running container set aside while its replacement is started (issue 1945).
+const asideSuffix = ".replaced"
+
 // detachedRunArgs is the `docker run` that starts a service container and leaves it running.
 func detachedRunArgs(r *declaration.Container, want string) []string {
 	args := []string{"run", "--detach", "--name", r.Name, "--restart", "unless-stopped"}

internal/apply/apply_test.go

@@ -350,6 +350,42 @@ func TestAnUnknownServiceStateIsRefusedNotGuessed(t *testing.T) {
 	}
 }
 
+// A boot-time one-shot a package ships, declared stopped and enabled at boot, is satisfied while
+// nothing of it runs, whatever its last run did (novox/hq issue 1126). The kernel module's
+// linux-modules-cleanup.service failed on ace with "was asked to be stopped and is running": an
+// inactive one-shot with ExecMainStatus=0 reads "running", and stopping it changes nothing.
+func TestABootOneShotDeclaredStoppedIsSatisfiedAtRest(t *testing.T) {
+	for _, c := range []struct{ name, status string }{
+		{"exited 0: never ran, ran at boot, or unloaded", "0"},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			var asked []string
+			run := func(ctx context.Context, name string, args ...string) (string, error) {
+				args = oldShape(name, args)
+				switch args[0] {
+				case "show":
+					return "LoadState=loaded\nActiveState=inactive\nType=oneshot\nRemainAfterExit=no\n" +
+						"ExecMainStatus=" + c.status + "\n", nil
+				case "is-enabled":
+					return "enabled\n", nil
+				}
+				asked = append(asked, strings.Join(args, " "))
+				return "", nil
+			}
+			d := parse(t, `{"declaration":1,"resources":[
+			  {"id":"cleanup","type":"service","unit":"linux-modules-cleanup.service","state":"stopped","boot":"enabled"}
+			]}`)
+			_, _, err := Apply(context.Background(), archHost(t), d, store.State{}, store.OriginCarried, run, nil, nil)
+			if err != nil {
+				t.Fatalf("a one-shot at rest declared stopped failed: %v", err)
+			}
+			if len(asked) > 0 {
+				t.Errorf("the service manager was asked %q for a unit already as declared", asked)
+			}
+		})
+	}
+}
+
 func TestADroppedServiceIsGivenBackTheStateItWasFoundIn(t *testing.T) {
 	// novox/hq ADR 0118: undeclaring removes what the mesh made, gives back what it changed, and
 	// leaves what was the machine's. A service resource never installs a unit — so undeclaring it
@@ -1225,6 +1261,52 @@ func TestAServiceIsRestartedWhenWhatItReflectsChanges(t *testing.T) {
 		if reloaded < 0 || reloaded > stop {
 			t.Errorf("the service was restarted without the unit files being read again first; commands were %v", commands)
 		}
+
+		// A drop-in in a unit directory that no service reflects — the power module's bound on reboot.target
+		// (issue 1126) — is read by the service manager only after a reload: one per apply, and no restart.
+		// Unchanged, it reloads nothing.
+		units := filepath.Join(dir, "system")
+		saved := UnitDirs
+		UnitDirs = []string{units}
+		t.Cleanup(func() { UnitDirs = saved })
+		dropIn := filepath.Join(units, "reboot.target.d", "mesh-power.conf")
+		withDropIn := parse(t, fmt.Sprintf(`{"declaration":1,"resources":[
+		  {"id":"conf","type":"file","path":%q,"content":"second\n","mode":"0644"},
+		  {"id":"svc","type":"service","unit":"thing.service","state":"running","restart-on":["conf"]},
+		  {"id":"units","type":"directory","path":%q,"mode":"0755"},
+		  {"id":"drop-ins","type":"directory","path":%q,"mode":"0755"},
+		  {"id":"bound","type":"file","path":%q,"content":"[Unit]\nJobTimeoutSec=10min\n","mode":"0644"},
+		  {"id":"bound-too","type":"file","path":%q,"content":"[Unit]\nJobTimeoutSec=10min\n","mode":"0644"}
+		]}`, path, units, filepath.Dir(dropIn), dropIn, filepath.Join(filepath.Dir(dropIn), "other.conf")))
+		for _, row := range []struct {
+			name    string
+			reloads int
+		}{{"a drop-in written", 1}, {"the same drop-in again", 0}} {
+			commands = nil
+			if _, state, err = Apply(context.Background(), archHost(t), withDropIn, state,
+				store.OriginCarried, run, nil, nil); err != nil {
+				t.Fatal(err)
+			}
+			reloads := 0
+			for _, c := range commands {
+				if strings.Contains(c, "daemon-reload") {
+					reloads++
+				}
+				if strings.Contains(c, "stop thing.service") {
+					t.Errorf("%s: a drop-in no service reflects restarted one: %v", row.name, commands)
+				}
+			}
+			if reloads != row.reloads {
+				t.Errorf("%s: %d reloads, want %d; commands were %v", row.name, reloads, row.reloads, commands)
+			}
+		}
+		// A drop-in whose module is skipped behind its step, or held as found, comes back so on every apply: it moved
+		// nothing, and reloads nothing.
+		for _, action := range []string{"skipped", "held"} {
+			if at := unitFileMoved([]Outcome{{ID: "bound", Type: "file", Target: dropIn, Action: action}}); at != "" {
+				t.Errorf("a drop-in %s reloads the service manager (%s)", action, at)
+			}
+		}
 	}
 }
 

internal/apply/archive.go

@@ -290,3 +290,7 @@ func unpack(body []byte, into string) (int, error) {
 		}
 	}
 }
+
+// Fetch is an archive at source as the host fetches every archive it unpacks, at most maxArchive bytes: what the node's
+// own composer reads a moved module's templates archive with (issue 1126). Its digest is the caller's to check.
+func Fetch(ctx context.Context, source string) ([]byte, error) { return fetch(ctx, source) }

internal/apply/busy_test.go

@@ -33,6 +33,7 @@ func newBusyMachine() *aBusyMachine {
 }
 
 func (m *aBusyMachine) run(_ context.Context, _ string, args ...string) (string, error) {
+	args = asideShape(args)
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	switch args[0] {

internal/apply/containers_kept_test.go

@@ -20,6 +20,9 @@ func TestAContainerJoinsTheNetworksItKeeps(t *testing.T) {
 		if name != "docker" {
 			return "", errors.New("not installed")
 		}
+		if len(args) > 0 && args[0] == "container" && strings.HasSuffix(args[len(args)-1], asideSuffix) {
+			return "", errors.New("no such container") // nothing was left set aside
+		}
 		ran = append(ran, strings.Join(args, " "))
 		switch args[0] {
 		case "info":
@@ -75,69 +78,6 @@ func TestAContainerJoinsTheNetworksItKeeps(t *testing.T) {
 
 var specOfLast string
 
-// A module the mesh left out of a declaration is not a module the mesh removed (novox/hq ADR 0163,
-// rule 6): what the host wrote for it stays, recorded and said; what it holds for it stays held.
-// A module simply absent is removed as it always was.
-func TestALeftOutModuleIsNeitherRemovedNorForgotten(t *testing.T) {
-	var removed []string
-	gone := map[string]bool{}
-	run := func(_ context.Context, name string, args ...string) (string, error) {
-		args = oldShape(name, args)
-		if name != "docker" {
-			return "", nil
-		}
-		switch args[0] {
-		case "info":
-			return "29.0.0\n", nil
-		case "rm":
-			removed = append(removed, args[len(args)-1])
-			gone[args[len(args)-1]] = true
-		case "container":
-			if gone[args[len(args)-1]] {
-				return "", errors.New("no such container")
-			}
-			return "true\tspec", nil
-		}
-		return "", nil
-	}
-	known := store.State{
-		Resources: []store.Applied{
-			{ID: "web.server", Type: "container", Target: "web", Origin: store.OriginDeclared},
-			{ID: "old.server", Type: "container", Target: "old", Origin: store.OriginDeclared},
-		},
-		Held: []store.Held{{ID: "web.page", Module: "web", Kind: "file", Target: "/srv/web/index.html"}},
-	}
-	d := parse(t, `{"declaration":1,"left_out":["web"],"resources":[
-	  {"id":"notes.conf","type":"file","path":"`+t.TempDir()+`/notes.conf","content":"x"}
-	]}`)
-	report, state, err := Apply(context.Background(), archHost(t), d, known, store.OriginDeclared, run, nil, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(removed) != 1 || removed[0] != "old" {
-		t.Fatalf("removed %v; only the module that is absent goes", removed)
-	}
-	if _, kept := state.At("container", "web"); !kept {
-		t.Fatal("the left-out module's record was forgotten")
-	}
-	if _, held := state.HeldAt("web.page"); !held {
-		t.Fatal("the left-out module's hold was released")
-	}
-	said := false
-	for _, o := range report.Outcomes {
-		if o.ID == "web.server" && o.Action == "unchanged" && strings.Contains(o.Detail, "web was left out of this declaration by the mesh") {
-			said = true
-		}
-		if o.ID == "web.server" && o.Action != "unchanged" {
-			t.Errorf("the left-out module's container was %s", o.Action)
-		}
-	}
-	if !said {
-		t.Fatalf("keeping the left-out module's container was not said: %+v", report.Outcomes)
-	}
-}
-
-// A container's capabilities reach the runtime and are part of its spec (novox/hq ADR 0170).
 func TestACapabilityReachesTheRuntimeAndTheSpec(t *testing.T) {
 	var ran []string
 	run := func(_ context.Context, name string, args ...string) (string, error) {

internal/apply/exec_killed_test.go

@@ -0,0 +1,19 @@
+package apply
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+)
+
+// A command killed because its context ended says so, and why: "docker exited -1:" said nothing while novox's bus
+// container was half replaced (issue 1945, live on 2026-10-25 at 11:23).
+func TestACommandKilledByItsContextSaysWhy(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() { time.Sleep(50 * time.Millisecond); cancel() }()
+	_, err := ExecRunner(ctx, "sleep", "5")
+	if err == nil || !strings.Contains(err.Error(), "killed") || !strings.Contains(err.Error(), "context canceled") {
+		t.Fatalf("a command its context killed said: %v", err)
+	}
+}

internal/apply/filled.go

@@ -76,6 +76,7 @@ func WriteFilled(
 	in.refused = refusedPlaces(d.Resources)
 	in.agentHomes = rootNeverHomes(d)
 	in.dirsBefore = map[string]bool{}
+	in.files = declaredFiles(d.Resources)
 	// A container that reads the file and mounts a library whose disk or mount is not there is held, as a full apply
 	// holds it: not created over the missing disk (novox/hq ADR 0328 §9).
 	in.held = heldLibraries(ctx, d.Libraries)

internal/apply/filled_test.go

@@ -52,6 +52,24 @@ func TestAWriteOfAPathNotFilledIsRefused(t *testing.T) {
 	if _, err := os.Stat(other); err == nil {
 		t.Errorf("%s was written", other)
 	}
+	t.Run("a filled path two resources declare", func(t *testing.T) {
+		path := filepath.Join(t.TempDir(), "hosts")
+		if err := os.WriteFile(path, []byte(workstationHosts), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		d := parseTrusted(t, fmt.Sprintf(`{"declaration":1,"filled_files":[%q],"resources":[
+		  {"id":"a.hosts","type":"file","path":%q,"into":"block","content":"10.42.0.1 ace\n","owner-at-runtime":"managed"},
+		  {"id":"b.hosts","type":"file","path":%q,"into":"block","content":"10.42.0.2 g14\n","owner-at-runtime":"managed"}
+		]}`, path, path, path))
+		_, state, err := WriteFilled(context.Background(), archHost(t), d, store.State{}, path, []byte("6.6.6.6 evil\n"),
+			noServices, nil, nil, nil)
+		if err == nil || !strings.Contains(err.Error(), "2 resources declare") {
+			t.Fatalf("a path two resources declare was not refused: %v", err)
+		}
+		if got := readText(t, path); got != workstationHosts || len(state.Resources) != 0 {
+			t.Errorf("something was written or recorded: %q %+v", got, state.Resources)
+		}
+	})
 }
 
 // Each ownership is written by the write verb exactly as an apply of the declared file with the same content: the
@@ -112,6 +130,17 @@ func TestAFilledFileIsWrittenAsItsOwnershipSays(t *testing.T) {
 			}
 		})
 	}
+	t.Run("a filled file that carried a secret is not world-readable", func(t *testing.T) {
+		path := filepath.Join(t.TempDir(), "token.env")
+		d := filledDecl(t, path, `"content":"TOKEN=${secret:token}\n","secrets":{"token":"c2VhbGVk"},"owner-at-runtime":"owned"`, "")
+		if _, _, err := WriteFilled(context.Background(), archHost(t), d, store.State{}, path, []byte("TOKEN=abc\n"),
+			noServices, nil, nil, nil); err != nil {
+			t.Fatal(err)
+		}
+		if m := modeAt(t, path); m != 0o600 {
+			t.Errorf("a filled file that carried a secret is mode %o", m)
+		}
+	})
 }
 
 func contentOf(t *testing.T, fields string) string {
@@ -136,17 +165,6 @@ func modeAt(t *testing.T, path string) os.FileMode {
 
 // A file that carried a secret keeps the mode a secret is written with: the client filled the value, and the file
 // is no more readable for it.
-func TestAFilledFileThatCarriedASecretIsNotWorldReadable(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "token.env")
-	d := filledDecl(t, path, `"content":"TOKEN=${secret:token}\n","secrets":{"token":"c2VhbGVk"},"owner-at-runtime":"owned"`, "")
-	if _, _, err := WriteFilled(context.Background(), archHost(t), d, store.State{}, path, []byte("TOKEN=abc\n"),
-		noServices, nil, nil, nil); err != nil {
-		t.Fatal(err)
-	}
-	if m := modeAt(t, path); m != 0o600 {
-		t.Errorf("a filled file that carried a secret is mode %o", m)
-	}
-}
 
 func TestAWriteUnderReloadOnReloadsItsProgramOnce(t *testing.T) {
 	path := filepath.Join(t.TempDir(), "daemon.conf")
@@ -251,21 +269,3 @@ func count(lines []string, prefix string) int {
 
 // Two resources declaring one filled path — two modules' blocks in one file — are refused: the request carries the
 // content only, so it cannot say whose block it is, and nothing is written.
-func TestAFilledPathTwoResourcesDeclareIsRefused(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "hosts")
-	if err := os.WriteFile(path, []byte(workstationHosts), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	d := parseTrusted(t, fmt.Sprintf(`{"declaration":1,"filled_files":[%q],"resources":[
-	  {"id":"a.hosts","type":"file","path":%q,"into":"block","content":"10.42.0.1 ace\n","owner-at-runtime":"managed"},
-	  {"id":"b.hosts","type":"file","path":%q,"into":"block","content":"10.42.0.2 g14\n","owner-at-runtime":"managed"}
-	]}`, path, path, path))
-	_, state, err := WriteFilled(context.Background(), archHost(t), d, store.State{}, path, []byte("6.6.6.6 evil\n"),
-		noServices, nil, nil, nil)
-	if err == nil || !strings.Contains(err.Error(), "2 resources declare") {
-		t.Fatalf("a path two resources declare was not refused: %v", err)
-	}
-	if got := readText(t, path); got != workstationHosts || len(state.Resources) != 0 {
-		t.Errorf("something was written or recorded: %q %+v", got, state.Resources)
-	}
-}

internal/apply/hold_test.go

@@ -111,7 +111,10 @@ type fakeContainer struct {
 // options. The host passes `--` before every unit (third review of mesh-catalog #147), which
 // internal/system's own test holds; the fakes read the unit where they always did.
 func oldShape(name string, args []string) []string {
-	if name != "systemctl" || len(args) < 2 || args[len(args)-2] != "--" {
+	if name != "systemctl" {
+		return asideShape(args)
+	}
+	if len(args) < 2 || args[len(args)-2] != "--" {
 		return args
 	}
 	v := 0
@@ -1128,3 +1131,16 @@ func TestAPathTheMeshOnlySetAccessOnIsStillFound(t *testing.T) {
 		t.Errorf("it was re-moded to %o", info.Mode().Perm())
 	}
 }
+
+// asideShape reads the steps of a container set aside while its replacement starts (issue 1945) as the removal the
+// tests were written against: setting it aside is its removal, and what is done to the set-aside container afterwards
+// is no step of theirs.
+func asideShape(args []string) []string {
+	if len(args) == 3 && args[0] == "rename" && args[2] == args[1]+asideSuffix {
+		return []string{"rm", "-f", args[1]}
+	}
+	if len(args) > 0 && strings.HasSuffix(args[len(args)-1], asideSuffix) && (args[0] == "rm" || args[0] == "stop") {
+		return []string{"aside"}
+	}
+	return args
+}

internal/apply/judge_directories_test.go

@@ -11,7 +11,9 @@ import (
 
 // The read-only judgement of a node's directories (novox/hq issue 358): one line each — placed, would be refused
 // naming the link and who could replace it, or not there yet (placed: an apply makes it) — and nothing made or
-// changed.
+// changed. Who could replace the link is "every account", "the account X" or "the group X", by the account and the
+// directories the test runs as: the checker's isolated step runs as the account nobody, which owns / there (issue 1919,
+// R4g), so the test demands a who in any of the forms couldReplace and linkReplacer produce, not "every account" alone.
 func TestJudgeDirectoriesSaysWhatTheWalkWouldRefuseAndChangesNothing(t *testing.T) {
 	base := t.TempDir()
 	plain := filepath.Join(base, "plain")
@@ -39,7 +41,8 @@ func TestJudgeDirectoriesSaysWhatTheWalkWouldRefuseAndChangesNothing(t *testing.
 		t.Errorf("a directory the walk reaches is not said placed: %q", said)
 	}
 	if !strings.Contains(lines[2], "would be refused") || !strings.Contains(lines[2], filepath.Join(base, "linked")) ||
-		!strings.Contains(lines[2], "every account") {
+		!(strings.Contains(lines[2], "every account (") || strings.Contains(lines[2], "the account ") ||
+			strings.Contains(lines[2], "the group ")) {
 		t.Errorf("the linked directory is not said refused naming the link and who: %q", lines[2])
 	}
 	if _, err := os.Stat(filepath.Join(base, "missing")); !os.IsNotExist(err) {

internal/apply/library_test.go

@@ -11,6 +11,7 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"syscall"
 	"testing"
 	"time"
 
@@ -23,6 +24,23 @@ import (
 // The engine's half of ADR 0328's checks (novox/hq ADR 0328, "How it is checked", issue 567). The engine runs as
 // root; a test may not, and a non-root test gives its folders a group it is in itself.
 
+// canSetGroups skips aloud a test that gives a folder a group when this step cannot. **A step that cannot set a folder's
+// group judges nothing here** (issue 1919, R4g): the checker runs the tests in the build module's isolation, a user
+// namespace that maps no group but the step's own, so a chown to any other group is refused (EINVAL or EPERM). A test that
+// sets a group calls it first: the probe gives a file of the test's own that group, and when it is refused the test skips
+// aloud; outside such an isolation it runs and is judged.
+func canSetGroups(t *testing.T, gid int) {
+	t.Helper()
+	probe := filepath.Join(t.TempDir(), "probe")
+	if err := os.WriteFile(probe, nil, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chown(probe, -1, gid); errors.Is(err, syscall.EINVAL) || errors.Is(err, syscall.EPERM) {
+		t.Skipf("NOT JUDGED: this step cannot set a folder's group (a user namespace maps only its own account, as the "+
+			"checker's isolated step does): %v; issue 1919", err)
+	}
+}
+
 // testGID is a group the test may give its folders: any number as root, else one of its own added groups that is
 // no root group's.
 func testGID(t *testing.T) int {
@@ -121,6 +139,7 @@ func statOf(t *testing.T, path string) unix.Stat_t {
 // those folders alone, never what is in them; owner, owner's and others' bits unchanged.
 func TestALibraryIsKeptInItsGroup(t *testing.T) {
 	gid := testGID(t)
+	canSetGroups(t, gid)
 	libraries(t, nil, nil)
 	root := filepath.Join(t.TempDir(), "media")
 	if err := os.Mkdir(root, 0o755); err != nil {
@@ -170,6 +189,7 @@ func TestALibraryIsKeptInItsGroup(t *testing.T) {
 // Row 9: a missing sub-path is made with the root's owner, the library's group, group rwx and setgid.
 func TestAMissingSubPathIsMadeAsTheRootIs(t *testing.T) {
 	gid := testGID(t)
+	canSetGroups(t, gid)
 	libraries(t, nil, nil)
 	root := filepath.Join(t.TempDir(), "media")
 	if err := os.Mkdir(root, 0o751); err != nil {
@@ -226,6 +246,7 @@ func TestARootThatHoldsDataWaitsForTheOperatorsWord(t *testing.T) {
 // (the act's ask, internal/link); an undeclared library refused; a walk over its bound goes on from its cursor.
 func TestTheTakeActSetsTheGroupUnderTheRoot(t *testing.T) {
 	gid := testGID(t)
+	canSetGroups(t, gid)
 	libraries(t, nil, nil)
 	base := t.TempDir()
 	root := filepath.Join(base, "media")
@@ -512,6 +533,7 @@ func TestNoLibraryGroupIsRoot(t *testing.T) {
 // A library's filesystem that cannot be named this time is unknown, never a move; another filesystem at the root is.
 func TestALibraryNotNamedIsUnknownAndAnotherFilesystemIsAMove(t *testing.T) {
 	gid := testGID(t)
+	canSetGroups(t, gid)
 	base := t.TempDir()
 	pool := filepath.Join(base, "pool")
 	root := filepath.Join(pool, "media")
@@ -650,6 +672,7 @@ func TestALibraryIsNeverTheMachinesOwnTree(t *testing.T) {
 // and sample all in shape are kept; once taken, never asked again on that filesystem.
 func TestARootInShapeWithDataBelowNotInTheGroupWaits(t *testing.T) {
 	gid := testGID(t)
+	canSetGroups(t, gid)
 	libraries(t, nil, nil)
 	root := filepath.Join(t.TempDir(), "media")
 	movies := filepath.Join(root, "movies")
@@ -699,6 +722,7 @@ func TestARootInShapeWithDataBelowNotInTheGroupWaits(t *testing.T) {
 // file never keeps its setgid bit once regrouped.
 func TestRootsLinkedFilesAreLeftAndSetgidIsNeverKept(t *testing.T) {
 	gid := testGID(t)
+	canSetGroups(t, gid)
 	f, err := os.CreateTemp(t.TempDir(), "file")
 	if err != nil {
 		t.Fatal(err)
@@ -729,6 +753,7 @@ func TestRootsLinkedFilesAreLeftAndSetgidIsNeverKept(t *testing.T) {
 // waits for the operator's word as the root would, and nothing of it is changed; an empty one is kept.
 func TestASubPathHoldingOldDataWaitsForTheOperatorsWord(t *testing.T) {
 	gid := testGID(t)
+	canSetGroups(t, gid)
 	libraries(t, nil, nil)
 	root := filepath.Join(t.TempDir(), "media")
 	if err := os.Mkdir(root, 0o755); err != nil {
@@ -795,6 +820,7 @@ func TestAnApplyDoesNotWaitForATakeWalk(t *testing.T) {
 // the root alone, says whether the data is the library's already (§7).
 func TestTheSampleBeneathARootInShapeIsJudged(t *testing.T) {
 	gid := testGID(t)
+	canSetGroups(t, gid)
 	libraries(t, nil, nil)
 	root := filepath.Join(t.TempDir(), "media")
 	if err := os.MkdirAll(filepath.Join(root, "old"), 0o755); err != nil {

internal/apply/maintenance_window_test.go

@@ -270,6 +270,7 @@ func newRegistryMachine(spec string) *aRegistryMachine {
 }
 
 func (m *aRegistryMachine) run(_ context.Context, _ string, args ...string) (string, error) {
+	args = asideShape(args)
 	m.mu.Lock()
 	switch args[0] {
 	case "info", "image":

internal/apply/mesh_dirs.go

@@ -124,3 +124,8 @@ func JudgeDirectories(d *declaration.Declaration) string {
 		placed+refused+guarded+homed, placed, refused, guarded, homed)
 	return strings.Join(append([]string{head}, lines...), "\n")
 }
+
+// meshDataRoot is the mesh's own tree, where a module placed "mesh" keeps its directory (<data root>/mesh/<module>):
+// the engine's, 0755, so only the engine's account makes a directory in it (novox/hq issue 1873). A variable so a
+// test can place it.
+var meshDataRoot = "/var/lib/mesh"

internal/apply/mesh_tree_found_test.go

@@ -0,0 +1,100 @@
+//go:build linux
+
+package apply
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"git.novox.be/novox/mesh-sdk/go/declaration"
+	"github.com/novox/mesh-host/internal/store"
+)
+
+// novox/hq issue 1873: a module's directory in the mesh's own tree (<data root>/mesh/<module>, place "mesh") that is
+// there before its declaration, owned by the engine's own account, was made by the mesh on the way to something below
+// it: it is the mesh's, given its declared mode and owner, never used as found. Only the engine's account makes a
+// directory in a tree that is the engine's (0755, root); on ace and novox /var/lib/mesh/postgres was there as
+// root:root 0700 before postgres's data directory was applied, and the engine left it to root, so the postgres
+// provider, running as the operator's account, could not reach its own files.
+func TestADirectoryInTheMeshsOwnTreeMadeByTheEngineIsTheMeshs(t *testing.T) {
+	root := t.TempDir()
+	before := meshDataRoot
+	meshDataRoot = filepath.Join(root, "mesh")
+	t.Cleanup(func() { meshDataRoot = before })
+	made := filepath.Join(meshDataRoot, "postgres")
+	if err := os.MkdirAll(made, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chmod(made, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	decl := `{"id":"postgres.data","type":"directory","path":"` + made + `","mode":"0750"}`
+	var said []string
+	_, state, err := Apply(context.Background(), archHost(t), declare(t, decl), store.State{}, store.OriginDeclared,
+		noServices, func(line string) { said = append(said, line) }, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(strings.Join(said, "\n"), "WARNING postgres.data") {
+		t.Errorf("a directory the engine's account made in the mesh's tree was used as found: %q", said)
+	}
+	if a, _ := state.Find("postgres.data"); a.AsFound {
+		t.Error("it is recorded as found")
+	}
+	if info, _ := os.Stat(made); info.Mode().Perm() != 0o750 {
+		t.Errorf("it was not given its declared mode: %04o", info.Mode().Perm())
+	}
+
+	// Outside the mesh's tree the rule of issue 339 stands: found, used as found.
+	other := filepath.Join(root, "var-lib", "notes")
+	if err := os.MkdirAll(other, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	said = nil
+	decl = `{"id":"notes.data","type":"directory","path":"` + other + `","mode":"0750"}`
+	if _, _, err := Apply(context.Background(), archHost(t), declare(t, decl), store.State{}, store.OriginDeclared,
+		noServices, func(line string) { said = append(said, line) }, nil); err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(strings.Join(said, "\n"), "WARNING notes.data") {
+		t.Errorf("a directory found outside the mesh's tree was not used as found: %q", said)
+	}
+}
+
+// Review of issue 1873's fix: the tree is judged by where the path leads, not by its text. A root-only link inside the
+// mesh's tree pointing out of it (to /var/lib/systemd, say) would otherwise make a directory outside the tree, owned by
+// the engine's account, the mesh's to chown: issue 1873's fault again. It is used as found.
+func TestALinkInTheMeshsTreeLeadingOutOfItIsNotTheTree(t *testing.T) {
+	rootAlone(t, "")
+	root := t.TempDir()
+	before := meshDataRoot
+	meshDataRoot = filepath.Join(root, "mesh")
+	t.Cleanup(func() { meshDataRoot = before })
+	outside := filepath.Join(root, "var-lib", "systemd")
+	if err := os.MkdirAll(filepath.Join(outside, "data"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chmod(filepath.Join(outside, "data"), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(meshDataRoot, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(outside, filepath.Join(meshDataRoot, "postgres")); err != nil {
+		t.Fatal(err)
+	}
+	r := &declaration.Directory{ID: "postgres.data", Path: filepath.Join(meshDataRoot, "postgres", "data"), Mode: "0750"}
+	out, err := applyDirectory(r, store.Applied{}, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !out.asFound {
+		t.Errorf("a directory reached through a link out of the mesh's tree was taken as the mesh's: %+v", out)
+	}
+	if got := permOf(t, filepath.Join(outside, "data")); got != 0o700 {
+		t.Errorf("the directory outside the tree was given mode %o (was 700)", got)
+	}
+}

internal/apply/module_scope_test.go

@@ -0,0 +1,148 @@
+package apply
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+
+	"git.novox.be/novox/mesh-sdk/go/declaration"
+	"github.com/novox/mesh-host/internal/store"
+)
+
+// R6-A AC3: given two modules declaring one path, when one module's want changes, the shared path is neither removed
+// nor taken from the other module (novox/hq ADR 0539 §9).
+func TestASharedPathIsNeitherRemovedNorTakenFromTheOtherModule(t *testing.T) {
+	dir := t.TempDir()
+	shared := filepath.Join(dir, "shared.conf")
+	own := filepath.Join(dir, "a-own.conf")
+	a := declare(t, `{"id":"a.shared","type":"file","path":"`+shared+`","content":"x\n","module":"a"},
+	  {"id":"a.own","type":"file","path":"`+own+`","content":"a\n","module":"a"}`)
+	b := declare(t, `{"id":"b.shared","type":"file","path":"`+shared+`","content":"x\n","module":"b"}`)
+
+	state := store.State{}
+	var err error
+	_, state, err = ApplyModule(context.Background(), archHost(t), a, Scope{Module: "a", Others: b.Resources},
+		state, store.OriginDeclared, noServices, nil, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, state, err = ApplyModule(context.Background(), archHost(t), b, Scope{Module: "b", Others: a.Resources},
+		state, store.OriginDeclared, noServices, nil, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// A's want changes: it no longer declares the shared path, and b still does.
+	a2 := declare(t, `{"id":"a.own","type":"file","path":"`+own+`","content":"a\n","module":"a"}`)
+	report, state, err := ApplyModule(context.Background(), archHost(t), a2, Scope{Module: "a", Others: b.Resources},
+		state, store.OriginDeclared, noServices, nil, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !exists(shared) {
+		t.Fatal("the path another module still declares was removed")
+	}
+	if _, still := state.Find("b.shared"); !still {
+		t.Fatal("the other module's record was taken away")
+	}
+	if _, still := state.Find("a.shared"); still {
+		t.Fatal("the module's own record of the shared path was kept")
+	}
+	if o := outcomeOf(report, "a.shared"); o.Action != "forgotten" {
+		t.Fatalf("the shared path: %+v", o)
+	}
+}
+
+// R6-A AC4: given modules A and B on a node, when A's want is removed, only A's resources are removed and B is
+// untouched.
+func TestARemovedModuleTakesOnlyItsOwnResources(t *testing.T) {
+	dir := t.TempDir()
+	fa, fb := filepath.Join(dir, "a.conf"), filepath.Join(dir, "b.conf")
+	d := declare(t, `{"id":"a.conf","type":"file","path":"`+fa+`","content":"a\n","module":"a"},
+	  {"id":"b.conf","type":"file","path":"`+fb+`","content":"b\n","module":"b"}`)
+	_, state, err := Apply(context.Background(), archHost(t), d, store.State{}, store.OriginDeclared, noServices, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rec, _ := state.Find("a.conf"); rec.Module != "a" {
+		t.Fatalf("the owner was not recorded: %+v", rec)
+	}
+
+	gone := &declaration.Declaration{}
+	b := declare(t, `{"id":"b.conf","type":"file","path":"`+fb+`","content":"b\n","module":"b"}`)
+	report, state, err := ApplyModule(context.Background(), archHost(t), gone, Scope{Module: "a", Others: b.Resources},
+		state, store.OriginDeclared, noServices, nil, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if exists(fa) || !exists(fb) {
+		t.Fatalf("a's file exists %v, b's file exists %v", exists(fa), exists(fb))
+	}
+	if o := outcomeOf(report, "a.conf"); o.Action != "removed" {
+		t.Fatalf("a's file: %+v", o)
+	}
+	if _, still := state.Find("b.conf"); !still {
+		t.Fatal("b's record was removed")
+	}
+	if _, still := state.Find("a.conf"); still {
+		t.Fatal("a's record is still there")
+	}
+}
+
+// A record from before the owner was kept is read by its id, so the first removal after the switch is the module's too.
+func TestARecordWithoutAnOwnerBelongsToTheModuleItsIdNames(t *testing.T) {
+	dir := t.TempDir()
+	fa, fb := filepath.Join(dir, "a.conf"), filepath.Join(dir, "b.conf")
+	d := declare(t, `{"id":"a.conf","type":"file","path":"`+fa+`","content":"a\n"},
+	  {"id":"b.conf","type":"file","path":"`+fb+`","content":"b\n"}`)
+	_, state, err := Apply(context.Background(), archHost(t), d, store.State{}, store.OriginDeclared, noServices, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for i := range state.Resources {
+		state.Resources[i].Module = ""
+	}
+	_, state, err = ApplyModule(context.Background(), archHost(t), &declaration.Declaration{}, Scope{Module: "a"},
+		state, store.OriginDeclared, noServices, nil, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if exists(fa) || !exists(fb) {
+		t.Fatalf("a's file exists %v, b's file exists %v", exists(fa), exists(fb))
+	}
+}
+
+// A resource that leaves the node's own composition for its module's own is that module's now: the node's own apply
+// leaves it as it is, whatever its type, until the module's own apply takes it (issue 1945, live on 2026-10-25 at 02:32:
+// shanks and g14 lost systemd-resolved's guard, its resolver files and sudo's operator file, ace qbittorrent's server,
+// because the node's own apply removed every record no longer in it, the others holding the very same resources or not).
+func TestAResourceThatMovedToItsModulesCompositionIsLeftByTheNodesOwnApply(t *testing.T) {
+	dir := t.TempDir()
+	fact := filepath.Join(dir, "suffix")
+	gone := filepath.Join(dir, "gone.conf")
+	own := declare(t, `{"id":"systemd-resolved.fact-suffix","type":"file","path":"`+fact+`","content":"mesh\n"},
+	  {"id":"old.gone","type":"file","path":"`+gone+`","content":"g\n"}`)
+	_, state, err := ApplyModule(context.Background(), archHost(t), own, Scope{Module: store.NodeModule},
+		state0(), store.OriginDeclared, noServices, nil, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// systemd-resolved now has a composition of its own, not applied yet; old.gone is no module's any more.
+	moved := declare(t, `{"id":"systemd-resolved.fact-suffix","type":"file","path":"`+fact+`","content":"mesh\n","module":"systemd-resolved"}`)
+	report, state, err := ApplyModule(context.Background(), archHost(t), &declaration.Declaration{},
+		Scope{Module: store.NodeModule, Others: moved.Resources}, state, store.OriginDeclared, noServices, nil, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !exists(fact) {
+		t.Fatalf("the moved resource was removed: %+v", outcomeOf(report, "systemd-resolved.fact-suffix"))
+	}
+	if exists(gone) {
+		t.Fatal("a resource no composition holds any more was kept")
+	}
+	if _, still := state.Find("systemd-resolved.fact-suffix"); !still {
+		t.Fatal("the moved resource's record was dropped, so its module's apply would not know it")
+	}
+}
+
+func state0() store.State { return store.State{} }

internal/apply/mount_waits.go

@@ -0,0 +1,58 @@
+package apply
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+
+	"git.novox.be/novox/mesh-sdk/go/declaration"
+)
+
+// declaredFiles is the path of every file a declaration declares.
+func declaredFiles(resources []declaration.Resource) map[string]bool {
+	out := map[string]bool{}
+	for _, r := range resources {
+		if f, ok := r.(*declaration.File); ok {
+			out[filepath.Clean(f.Path)] = true
+		}
+	}
+	return out
+}
+
+// mountsAFileNotThere is the first mount source of a container that is a file the declaration declares and is not
+// on the machine yet, or "" (novox/hq issue 1873): the runtime makes a missing source a directory.
+func mountsAFileNotThere(c *declaration.Container, files map[string]bool) string {
+	for _, v := range c.Volumes {
+		src := mountSource(v)
+		if !filepath.IsAbs(src) || !files[filepath.Clean(src)] {
+			continue
+		}
+		if _, err := os.Lstat(src); errors.Is(err, os.ErrNotExist) {
+			return src
+		}
+	}
+	return ""
+}
+
+// clearRuntimesEmptyDirectory removes what a container runtime leaves at a file's path when it mounted the file before
+// it was there (novox/hq issue 1873): an empty directory, in the mesh's own tree by its path and by where its path
+// leads, owned by the engine's own account. It says what it removed, or "" when nothing was. Anything else at the path
+// is left for the write to meet as before: a directory with anything in it, or one outside the tree, is never removed.
+func clearRuntimesEmptyDirectory(path string) (string, error) {
+	info, err := os.Lstat(path)
+	if err != nil || !info.IsDir() || !inTheMeshsTree(path) {
+		return "", nil
+	}
+	if uid, _, ok := ownerOf(info); !ok || uid != os.Geteuid() {
+		return "", nil
+	}
+	entries, err := os.ReadDir(path)
+	if err != nil || len(entries) > 0 {
+		return "", nil
+	}
+	if err := os.Remove(path); err != nil {
+		return "", err
+	}
+	return "removed the empty directory a container runtime left at " + path + ", where this file belongs " +
+		"(novox/hq issue 1873)", nil
+}

internal/apply/mount_waits_test.go

@@ -0,0 +1,121 @@
+//go:build linux
+
+package apply
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/novox/mesh-host/internal/store"
+)
+
+// novox/hq issue 1873, its second fault: on ace the postgres container was replaced at 22:11:51 mounting
+// superuser.secret, a file the provisioner's client fills only after the apply; the runtime made the missing source
+// a directory, and every fill after it failed with "is a directory". A container whose mount source is a file the
+// declaration declares, not yet there, is not created or replaced: it waits, and the write of that file (WriteFilled)
+// applies what reads it, the container among them (readsChange), once the file is there.
+func TestAContainerWaitsForAFileItMountsAndIsMadeWhenTheFillLands(t *testing.T) {
+	secret := filepath.Join(t.TempDir(), "postgres", "superuser.secret")
+	d := filledDecl(t, secret, `"content":"","mode":"0600","owner-at-runtime":"owned"`,
+		`{"id":"postgres.server","type":"container","name":"postgres","image":"`+pinned+`","volumes":["`+
+			secret+`:/run/secrets/superuser:ro"]}`)
+	m := &machine{containers: map[string]*fakeContainer{}}
+	report, state, err := Apply(context.Background(), archHost(t), d, store.State{}, store.OriginDeclared, m.run, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if o := outcomeOf(report, "postgres.server"); o.Action != "waiting" || !strings.Contains(o.Detail, secret) {
+		t.Errorf("the container mounting a file not yet filled is %+v, not waiting for it", o)
+	}
+	if m.did("docker run") {
+		t.Fatalf("the container was made before the file it mounts was there: %v", m.asked)
+	}
+	if _, err := os.Lstat(secret); err == nil {
+		t.Fatal("something was made at the file's path before the fill")
+	}
+
+	report, _, err = WriteFilled(context.Background(), archHost(t), d, state, secret, []byte("s3cret"), m.run, nil,
+		nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !m.did("docker run") {
+		t.Fatalf("the container was not made when the file it mounts was filled: %v", m.asked)
+	}
+	if info, err := os.Lstat(secret); err != nil || !info.Mode().IsRegular() {
+		t.Fatalf("the filled file is not a file: %v %v", info, err)
+	}
+}
+
+// novox/hq issue 1873: what the runtime left on ace is cured by the mesh. A declared file whose path is an empty
+// directory in the mesh's own tree, the engine's account's, is the runtime's missing mount source: the engine
+// removes that empty directory and writes the file, and says so. A directory with anything in it, or one outside the
+// tree, is never removed: the write fails as before.
+func TestAnEmptyDirectoryTheRuntimeLeftAtAFilesPathIsReplacedByTheFile(t *testing.T) {
+	rootAlone(t, "")
+	root := t.TempDir()
+	before := meshDataRoot
+	meshDataRoot = filepath.Join(root, "mesh")
+	t.Cleanup(func() { meshDataRoot = before })
+
+	secret := filepath.Join(meshDataRoot, "postgres", "superuser.secret")
+	if err := os.MkdirAll(secret, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	d := filledDecl(t, secret, `"content":"","mode":"0600","owner-at-runtime":"owned"`, "")
+	m := &machine{containers: map[string]*fakeContainer{}}
+	report, _, err := WriteFilled(context.Background(), archHost(t), d, store.State{}, secret, []byte("s3cret"), m.run,
+		nil, nil, nil)
+	if err != nil {
+		t.Fatalf("the file was not written over the empty directory the runtime left: %v", err)
+	}
+	if info, err := os.Lstat(secret); err != nil || !info.Mode().IsRegular() {
+		t.Fatalf("%s is not a file: %v %v", secret, info, err)
+	}
+	if o := outcomeOf(report, "m.conf"); !strings.Contains(o.Detail, "empty directory") {
+		t.Errorf("the write did not say it removed the empty directory: %+v", o)
+	}
+
+	// Not empty: kept, and the write fails.
+	full := filepath.Join(meshDataRoot, "postgres", "reader.secret")
+	if err := os.MkdirAll(filepath.Join(full, "something"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	d = filledDecl(t, full, `"content":"","mode":"0600","owner-at-runtime":"owned"`, "")
+	if _, _, err := WriteFilled(context.Background(), archHost(t), d, store.State{}, full, []byte("x"), m.run, nil,
+		nil, nil); err == nil {
+		t.Error("a directory with something in it was replaced by a file")
+	}
+	if _, err := os.Stat(filepath.Join(full, "something")); err != nil {
+		t.Errorf("what was in the directory is gone: %v", err)
+	}
+
+	// Outside the tree: kept, and the write fails.
+	outside := filepath.Join(root, "var-lib", "postgres", "superuser.secret")
+	if err := os.MkdirAll(outside, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	d = filledDecl(t, outside, `"content":"","mode":"0600","owner-at-runtime":"owned"`, "")
+	if _, _, err := WriteFilled(context.Background(), archHost(t), d, store.State{}, outside, []byte("x"), m.run, nil,
+		nil, nil); err == nil {
+		t.Error("an empty directory outside the mesh's tree was replaced by a file")
+	}
+
+	// Reached through a link out of the tree: kept, and the write fails.
+	elsewhere := filepath.Join(root, "elsewhere")
+	if err := os.MkdirAll(filepath.Join(elsewhere, "x.secret"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(elsewhere, filepath.Join(meshDataRoot, "linked")); err != nil {
+		t.Fatal(err)
+	}
+	through := filepath.Join(meshDataRoot, "linked", "x.secret")
+	d = filledDecl(t, through, `"content":"","mode":"0600","owner-at-runtime":"owned"`, "")
+	_, _, _ = WriteFilled(context.Background(), archHost(t), d, store.State{}, through, []byte("x"), m.run, nil, nil, nil)
+	if info, err := os.Lstat(filepath.Join(elsewhere, "x.secret")); err != nil || !info.IsDir() {
+		t.Errorf("a directory outside the tree, reached through a link in it, was replaced: %v %v", info, err)
+	}
+}

internal/apply/process.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"time"
 
@@ -94,6 +95,14 @@ func applyProcess(ctx context.Context, r *declaration.Process, run Runner,
 		if r.Schedule != "" {
 			unit = r.Name + ".timer"
 		}
+		// The yielding slice is checked even then: a slice file removed by hand would leave the build unbound.
+		if wrote, err := placeYieldSlice(r); err != nil {
+			return out, err
+		} else if wrote {
+			if _, err := run(ctx, "systemctl", "daemon-reload"); err != nil {
+				return out, err
+			}
+		}
 		if active, err := run(ctx, "systemctl", "is-active", "--quiet", unit); err == nil {
 			_ = active
 			return out, nil
@@ -121,7 +130,12 @@ func applyProcess(ctx context.Context, r *declaration.Process, run Runner,
 		}
 		// Replaced rather than merged: the bundle is the whole of what it runs, and files left from a
 		// previous version would be loaded by a runtime that walks a directory.
-		if err := os.RemoveAll(at); err != nil {
+		// **Retired, never deleted under its process** (novox/hq issue 734): the old process runs until
+		// the restart below, from this directory and in it. Deleted here, every command it started
+		// before the restart failed with "getwd: no such file or directory" — a builder's toolchain probe
+		// refused three checks on 2026-10-26. Renamed aside, its process keeps a directory that exists,
+		// and the build is deleted once nothing runs from it, as a judged build's is.
+		if err := witness.Retire(daemonRoot, r.Name, at, time.Now()); err != nil {
 			return out, err
 		}
 	} else {
@@ -189,6 +203,9 @@ func applyProcess(ctx context.Context, r *declaration.Process, run Runner,
 	if err := os.WriteFile(unit, []byte(unitFor(r)), 0o644); err != nil {
 		return out, err
 	}
+	if _, err := placeYieldSlice(r); err != nil {
+		return out, err
+	}
 	if _, err := run(ctx, "systemctl", "daemon-reload"); err != nil {
 		return out, err
 	}
@@ -277,6 +294,7 @@ func unitFor(r *declaration.Process) string {
 	if r.User != "" {
 		fmt.Fprintf(&b, "User=%s\n", r.User)
 	}
+	writeYields(&b, r.Yields)
 	fmt.Fprintf(&b, "ExecStart=%s\n", strings.Join(runFrom(r), " "))
 	if r.Schedule != "" || r.RunOnce {
 		// Started by its timer, or once by the host, and expected to finish. Restarting it would have it run
@@ -293,6 +311,78 @@ func unitFor(r *declaration.Process) string {
 	return b.String()
 }
 
+// machineCPUs is how many processors this machine has, for a share of them in a quota. A variable only so a test can
+// fix it.
+var machineCPUs = runtime.NumCPU
+
+// writeYields writes how a process gives way to everything else on its machine (novox/hq ADR 0553, issue 1806): a
+// build seat's holder, whose builds must never slow the operator's desktop.
+//
+// **Into the node's one yielding slice**, where the CPU weight and the quota are (yieldSlice): every yielding process
+// of the machine shares them, so three build modules take one share together, never one each. **Per process**, what a
+// slice cannot say: Nice=19 for every process it starts, and the lowest best-effort IO level. The IO level binds only
+// where the disk's scheduler honours it (bfq); under `none`, the usual one for NVMe, it does nothing. Not the idle IO
+// class: a disk that is never idle would starve a build for good.
+//
+// The share is written into the unit as a comment, so a changed share changes the unit, the daemon's identity, and the
+// slice is written again.
+func writeYields(b *strings.Builder, y *declaration.Yields) {
+	if y == nil {
+		return
+	}
+	fmt.Fprintf(b, "# Yields: %s, %d%% of the machine shared in %s\n", y.Priority, y.CPUShare, declaration.YieldSlice)
+	fmt.Fprintf(b, "Slice=%s\n", declaration.YieldSlice)
+	if y.Priority == declaration.YieldIdle {
+		b.WriteString("Nice=19\nIOSchedulingClass=best-effort\nIOSchedulingPriority=7\n")
+	}
+}
+
+// yieldSlice is the node's one yielding slice (declaration.YieldSlice) for a process that yields: idle CPU weight and
+// IO weight 1 for an idle priority, and CPUQuota for its share of the processors this machine has (systemd counts a
+// quota in percent of one processor, so half of 24 is 1200%), at least one processor. At the top of the hierarchy, so
+// its weight and quota bind against the operator's user slice and the system's.
+//
+// The IO weight binds only where the disk's scheduler honours it (bfq, or the io.cost controller); under `none` it does
+// nothing, and the CPU bound is what holds.
+//
+// Every yielding process of a machine carries the node's one share (the composer's, ADR 0553 §3), so whichever writes
+// it writes the same file. Left in place when nothing yields any more: an empty slice binds nothing.
+func yieldSlice(y *declaration.Yields) string {
+	var b strings.Builder
+	b.WriteString("# Generated by the mesh. Do not edit — this file is replaced whenever a yielding\n")
+	b.WriteString("# process is declared again (novox/hq ADR 0553).\n")
+	b.WriteString("[Unit]\nDescription=The mesh's yielding processes: builds, at idle priority under one share\n\n")
+	b.WriteString("[Slice]\n")
+	if y.Priority == declaration.YieldIdle {
+		b.WriteString("CPUWeight=idle\nIOWeight=1\n")
+	}
+	if y.CPUShare > 0 {
+		quota := y.CPUShare * machineCPUs()
+		if quota < 100 {
+			quota = 100
+		}
+		fmt.Fprintf(&b, "CPUQuota=%d%%\n", quota)
+	}
+	return b.String()
+}
+
+// placeYieldSlice writes the yielding slice for a process that yields, when what is there differs, and says whether it
+// wrote: the caller reloads the service manager before it starts anything.
+func placeYieldSlice(r *declaration.Process) (bool, error) {
+	if r.Yields == nil {
+		return false, nil
+	}
+	path := filepath.Join(unitDir, declaration.YieldSlice)
+	want := yieldSlice(r.Yields)
+	if have, err := os.ReadFile(path); err == nil && string(have) == want {
+		return false, nil
+	}
+	if err := os.WriteFile(path, []byte(want), 0o644); err != nil {
+		return false, fmt.Errorf("the yielding slice %s: %w", path, err)
+	}
+	return true, nil
+}
+
 // timerFor is the cadence a scheduled process runs on.
 //
 // **The mesh's cron expression, handed to the machine's own timer.** The host already parses and

internal/apply/process_test.go

@@ -21,10 +21,16 @@ func aProcess() *declaration.Process {
 	}
 }
 
-// The unit the mesh writes says what it runs, where, and that it comes back.
+// The unit the mesh writes says what it runs, where, and that it comes back — and that it is the
+// mesh's: **generated whole and saying so**, because an edit that survives until the next declaration
+// and then vanishes is worse than one that is refused. The long-running mode stays up and is not a step.
 func TestTheUnitRunsWhatTheDaemonSaid(t *testing.T) {
 	unit := unitFor(aProcess())
+	if !strings.HasPrefix(unit, "#") {
+		t.Fatalf("the unit does not open saying it is generated:\n%s", unit)
+	}
 	for _, want := range []string{
+		"Do not edit",
 		"ExecStart=node index.js",
 		"WorkingDirectory=/var/lib/mesh/daemons/greeter",
 		"Restart=always",
@@ -34,14 +40,8 @@ func TestTheUnitRunsWhatTheDaemonSaid(t *testing.T) {
 			t.Fatalf("the unit does not say %q:\n%s", want, unit)
 		}
 	}
-}
-
-// **Generated whole and saying so.** Every managed file on a machine carries this, because an edit
-// that survives until the next declaration and then vanishes is worse than one that is refused.
-func TestTheUnitSaysItIsTheMeshs(t *testing.T) {
-	unit := unitFor(aProcess())
-	if !strings.HasPrefix(unit, "#") || !strings.Contains(unit, "Do not edit") {
-		t.Fatalf("the unit does not say it is generated:\n%s", unit)
+	if strings.Contains(unit, "Type=oneshot") {
+		t.Fatalf("a process that should stay up is declared a step:\n%s", unit)
 	}
 }
 
@@ -83,6 +83,60 @@ func TestAProcessRunsAsWhoItSaid(t *testing.T) {
 	if strings.Contains(unitFor(aProcess()), "User=") {
 		t.Fatalf("a process that named no user had one written for it:\n%s", unitFor(aProcess()))
 	}
+
+	// A process that yields (ADR 0553) runs in the node's one yielding slice at nice 19; the slice holds the idle weight
+	// and the quota for its share of the machine's processors; one that does not yield has none of it.
+	defer func(n func() int) { machineCPUs = n }(machineCPUs)
+	for _, c := range []struct {
+		cpus             int
+		y                *declaration.Yields
+		unit, slice, not []string
+	}{
+		{24, &declaration.Yields{Priority: declaration.YieldIdle, CPUShare: 50},
+			[]string{"Slice=meshyield.slice\n", "Nice=19\n", "IOSchedulingPriority=7\n", "50%"},
+			[]string{"CPUWeight=idle\n", "IOWeight=1\n", "CPUQuota=1200%\n"}, []string{"CPUQuota=", "CPUWeight="}},
+		{1, &declaration.Yields{CPUShare: 25}, []string{"Slice=meshyield.slice\n"}, []string{"CPUQuota=100%\n"},
+			[]string{"Nice="}},
+		{24, nil, nil, nil, []string{"Slice=", "Nice=", "CPUQuota="}},
+	} {
+		machineCPUs = func() int { return c.cpus }
+		p := aProcess()
+		p.Yields = c.y
+		unit := unitFor(p)
+		for _, w := range c.unit {
+			if !strings.Contains(unit, w) {
+				t.Errorf("yields %+v: the unit does not say %q:\n%s", c.y, w, unit)
+			}
+		}
+		for _, n := range c.not {
+			if strings.Contains(unit, n) {
+				t.Errorf("yields %+v: the unit says %q:\n%s", c.y, n, unit)
+			}
+		}
+		if c.y == nil {
+			continue
+		}
+		slice := yieldSlice(c.y)
+		for _, w := range c.slice {
+			if !strings.Contains(slice, w) {
+				t.Errorf("yields %+v on %d processors: the slice does not say %q:\n%s", c.y, c.cpus, w, slice)
+			}
+		}
+	}
+	// The slice is placed beside the units, once, and again only when it differs.
+	was := unitDir
+	unitDir = t.TempDir()
+	defer func() { unitDir = was }()
+	p := aProcess()
+	p.Yields = &declaration.Yields{Priority: declaration.YieldIdle, CPUShare: 50}
+	for i, want := range []bool{true, false} {
+		if wrote, err := placeYieldSlice(p); err != nil || wrote != want {
+			t.Errorf("placing %d: wrote %v (%v), want %v", i, wrote, err, want)
+		}
+	}
+	if b, err := os.ReadFile(filepath.Join(unitDir, "meshyield.slice")); err != nil || !strings.Contains(string(b), "[Slice]") {
+		t.Errorf("the slice file: %q %v", b, err)
+	}
 }
 
 // **Three modes, one kind.** A scheduled process is a timer plus a unit that finishes, not a unit
@@ -124,17 +178,6 @@ func TestACronBecomesATimersCalendar(t *testing.T) {
 	}
 }
 
-// And the long-running mode is unchanged by any of it: it stays up and comes back.
-func TestAProcessThatStaysUpIsStillRestartedWhenItExits(t *testing.T) {
-	unit := unitFor(aProcess())
-	if !strings.Contains(unit, "Restart=always") {
-		t.Fatalf("a process that should stay up is not restarted when it exits:\n%s", unit)
-	}
-	if strings.Contains(unit, "Type=oneshot") {
-		t.Fatalf("a process that should stay up is declared a step:\n%s", unit)
-	}
-}
-
 // **A unit file reinterprets a value in three ways nothing else does**, and a module's environment
 // routinely contains all three — a generated password is arbitrary bytes.
 func TestAnEnvironmentValueMeansWhatTheDeclarationSaid(t *testing.T) {

internal/apply/process_witness_test.go

@@ -3,7 +3,9 @@ package apply
 import (
 	"context"
 	"os"
+	"os/exec"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -103,3 +105,79 @@ func TestARolledBackBuildIsNotPlacedAgain(t *testing.T) {
 		t.Fatalf("the apply does not say why it kept the build before: %+v", o)
 	}
 }
+
+// **A process nobody judges keeps the directory it works in until its restart** (novox/hq issue 734).
+// On 2026-10-26 three checks on one builder were refused in the second a new build of it arrived: the
+// applier deleted the running build's directory before the restart, and the `go version` the old
+// process started in it failed with "getwd: no such file or directory". Here a process works in the
+// build's directory without running from it, as that `go version` did: the apply of a new build leaves
+// its directory in place, and the retired build goes once nothing works in it.
+func TestAProcessNobodyJudgesKeepsItsDirectoryUntilItsRestart(t *testing.T) {
+	if _, err := os.Stat("/proc/self/cwd"); err != nil {
+		t.Skip("which process works in a build is read from /proc")
+	}
+	units, bundles := t.TempDir(), t.TempDir()
+	wasUnits, wasBundles := unitDir, daemonRoot
+	unitDir, daemonRoot = units, bundles
+	t.Cleanup(func() { unitDir, daemonRoot = wasUnits, wasBundles })
+	run := func(ctx context.Context, name string, args ...string) (string, error) { return "", nil }
+
+	oldBody, oldDigest := anArchive(t, map[string]string{"mesh-build-go": "old\n"})
+	newBody, newDigest := anArchive(t, map[string]string{"mesh-build-go": "new\n"})
+	builder := func(body []byte, digest string) string {
+		return `{"id":"mesh-build-go.builder","type":"process","name":"mesh-build-go","source":"` + serving(t, body) +
+			`","digest":"` + digest + `","run":["./mesh-build-go"]}`
+	}
+	_, state, err := Apply(context.Background(), archHost(t), declare(t, builder(oldBody, oldDigest)), store.State{},
+		store.OriginDeclared, run, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	sleep, err := exec.LookPath("sleep")
+	if err != nil {
+		t.Skip("no sleep to run")
+	}
+	working := exec.Command(sleep, "60")
+	working.Dir = filepath.Join(bundles, "mesh-build-go")
+	if err := working.Start(); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = working.Process.Kill(); _ = working.Wait() })
+	cwd := filepath.Join("/proc", strconv.Itoa(working.Process.Pid), "cwd")
+	for deadline := time.Now().Add(5 * time.Second); ; {
+		if at, err := os.Readlink(cwd); err == nil && at == working.Dir {
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("PID %d does not work in %s within 5s", working.Process.Pid, working.Dir)
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	if _, _, err := Apply(context.Background(), archHost(t), declare(t, builder(newBody, newDigest)), state,
+		store.OriginDeclared, run, nil, nil); err != nil {
+		t.Fatal(err)
+	}
+	if got, _ := os.ReadFile(filepath.Join(bundles, "mesh-build-go", "mesh-build-go")); string(got) != "new\n" {
+		t.Fatalf("the new build is not where the unit runs it from: %q", got)
+	}
+	at, err := os.Readlink(cwd)
+	if err != nil || strings.HasSuffix(at, " (deleted)") {
+		t.Fatalf("the directory a running process works in was deleted before its restart: %q (%v)", at, err)
+	}
+	if got, _ := os.ReadFile(filepath.Join(at, "mesh-build-go")); string(got) != "old\n" {
+		t.Fatalf("the process's directory no longer holds its own build: %q", got)
+	}
+	if len(witness.Trials(bundles)) != 0 {
+		t.Fatal("a process nobody judges went on trial")
+	}
+
+	// Its process gone, the next look deletes the retired build and keeps nothing about the process.
+	_ = working.Process.Kill()
+	_ = working.Wait()
+	witness.SweepAll(bundles)
+	if _, err := os.Stat(witness.Dir(bundles, "mesh-build-go")); !os.IsNotExist(err) {
+		t.Fatalf("a retired build nothing works in was kept: %v", err)
+	}
+}

internal/apply/replace_image_test.go

@@ -91,3 +91,129 @@ func TestAReplacementImageIsPresentBeforeTheRunningContainerIsRemoved(t *testing
 		t.Errorf("order of runtime calls = %s, want the image pulled before rm", got)
 	}
 }
+
+// asideRun is a runtime whose container "store" runs from an older spec, recording the steps a replacement takes; run
+// fails when failRun, and the new container reads back as declared otherwise.
+func asideRun(t *testing.T, want string, failRun bool, order *[]string) Runner {
+	created := false
+	return func(ctx context.Context, name string, args ...string) (string, error) {
+		switch args[0] {
+		case "info":
+			return "27.0\n", nil
+		case "container":
+			if created {
+				return "true\t" + want, nil
+			}
+			return "true\tsome-older-spec", nil
+		case "image":
+			return "", nil
+		case "rm", "rename", "stop", "start":
+			*order = append(*order, strings.Join(args, " "))
+			return "", nil
+		case "run":
+			*order = append(*order, "run")
+			if failRun {
+				return "", errors.New("port is already allocated")
+			}
+			created = true
+			return "deadbeef\n", nil
+		}
+		return "", nil
+	}
+}
+
+// A container whose replacement does not come up is put back: the running one is set aside (renamed and stopped), never
+// removed before the new one runs, and started again under its name when the new one fails, the apply failing loudly.
+// Removed first, the bus's own container left novox without a bus when its replacement was never made (issue 1945,
+// live on 2026-10-25 at 11:23).
+func TestAContainerWhoseReplacementFailsIsPutBack(t *testing.T) {
+	d := parseTrusted(t, `{"declaration":1,"resources":[
+	  {"id":"store","type":"container","name":"store","image":"`+pinned+`","env":{"PGDATA":"/data"}}
+	]}`)
+	want := containerSpec(d.Resources[0].(*declaration.Container), inputs{})
+	var order []string
+	_, _, err := Apply(context.Background(), archHost(t), d, store.State{}, store.OriginCarried, asideRun(t, want, true, &order), nil, nil)
+	if err == nil || !strings.Contains(err.Error(), "started again") {
+		t.Fatalf("a failed replacement: %v", err)
+	}
+	got := strings.Join(order, "; ")
+	if !strings.Contains(got, "rename store store.replaced; stop store.replaced; run") ||
+		!strings.Contains(got, "rename store.replaced store; start store") {
+		t.Fatalf("the steps were %q", got)
+	}
+	if strings.Contains(got, "rm -f store;") && strings.Index(got, "rm -f store;") < strings.Index(got, "run") {
+		t.Fatalf("the running container was removed before its replacement ran: %q", got)
+	}
+}
+
+// A replacement that runs removes the container set aside, and only after it runs.
+func TestAReplacementThatRunsRemovesTheContainerSetAside(t *testing.T) {
+	d := parseTrusted(t, `{"declaration":1,"resources":[
+	  {"id":"store","type":"container","name":"store","image":"`+pinned+`","env":{"PGDATA":"/data"}}
+	]}`)
+	want := containerSpec(d.Resources[0].(*declaration.Container), inputs{})
+	var order []string
+	if _, _, err := Apply(context.Background(), archHost(t), d, store.State{}, store.OriginCarried, asideRun(t, want, false, &order), nil, nil); err != nil {
+		t.Fatal(err)
+	}
+	got := strings.Join(order, "; ")
+	run, removed := strings.Index(got, "run"), strings.LastIndex(got, "rm -f store.replaced")
+	if run < 0 || removed < run || strings.Contains(got, "start store") {
+		t.Fatalf("the steps were %q: the set-aside container is removed after the replacement runs", got)
+	}
+}
+
+// A container left set aside by an engine that stopped between setting it aside and running its replacement is the
+// set-aside one of the next apply: put back when the replacement fails, removed once it runs (the review of issue
+// 1945).
+func TestAContainerLeftAsideIsPutBackOrRemovedByTheNextApply(t *testing.T) {
+	d := parseTrusted(t, `{"declaration":1,"resources":[
+	  {"id":"store","type":"container","name":"store","image":"`+pinned+`","env":{"PGDATA":"/data"}}
+	]}`)
+	want := containerSpec(d.Resources[0].(*declaration.Container), inputs{})
+	for _, failRun := range []bool{true, false} {
+		var order []string
+		created := false
+		run := func(ctx context.Context, name string, args ...string) (string, error) {
+			switch args[0] {
+			case "info":
+				return "27.0\n", nil
+			case "container":
+				switch args[len(args)-1] {
+				case "store":
+					if created {
+						return "true\t" + want, nil
+					}
+					return "", errors.New("no such container")
+				case "store.replaced":
+					return "false\tsome-older-spec", nil
+				}
+				return "", errors.New("no such container")
+			case "image":
+				return "", nil
+			case "rm", "rename", "stop", "start":
+				order = append(order, strings.Join(args, " "))
+				return "", nil
+			case "run":
+				order = append(order, "run")
+				if failRun {
+					return "", errors.New("port is already allocated")
+				}
+				created = true
+				return "deadbeef\n", nil
+			}
+			return "", nil
+		}
+		_, _, err := Apply(context.Background(), archHost(t), d, store.State{}, store.OriginCarried, run, nil, nil)
+		got := strings.Join(order, "; ")
+		if failRun {
+			if err == nil || !strings.Contains(got, "rename store.replaced store; start store") {
+				t.Fatalf("a failed run beside a container left aside: %v; steps %q", err, got)
+			}
+			continue
+		}
+		if err != nil || !strings.Contains(got, "run; rm -f store.replaced") {
+			t.Fatalf("a run beside a container left aside: %v; steps %q", err, got)
+		}
+	}
+}

internal/apply/schedule.go

@@ -127,6 +127,17 @@ func (s *Scheduler) RecordWindowsIn(w *Windows) {
 // work on the predecessor's data, under the predecessor's service, which is the one thing an
 // adopted node must not do. Nil on a converged node, where nothing is held.
 func (s *Scheduler) Sync(d *declaration.Declaration, held map[string]bool) {
+	s.sync(d, held, nil)
+}
+
+// SyncModule is Sync for one module's declaration (novox/hq ADR 0539 §9): the schedules of that module are armed,
+// re-armed or forgotten, and the schedules of every other module are left as they are. owns says whether a scheduled
+// step's id is the module's.
+func (s *Scheduler) SyncModule(d *declaration.Declaration, held map[string]bool, owns func(id string) bool) {
+	s.sync(d, held, owns)
+}
+
+func (s *Scheduler) sync(d *declaration.Declaration, held map[string]bool, owns func(id string) bool) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
@@ -177,7 +188,7 @@ func (s *Scheduler) Sync(d *declaration.Declaration, held map[string]bool) {
 	}
 
 	for id := range s.jobs {
-		if !seen[id] {
+		if !seen[id] && (owns == nil || owns(id)) {
 			delete(s.jobs, id)
 		}
 	}

internal/bootstrap/builder_test.go

@@ -150,13 +150,19 @@ func TestAForgeManifestTheCatalogueDoesNotHaveIsNamed(t *testing.T) {
 
 // theCataloguesModule is a module's own manifest, never a copy: the clone beside a merge check (MESH_CHECK_BESIDE), where it
 // must be; else a checkout beside this one; else the test skips aloud. The catalogue holds it, but for the build agent,
-// which moved whole into the controller's repository (ADR 0420, issue 1019, issue 1151) and is read from there.
+// which moved whole into the controller's repository (ADR 0420, issue 1019, issue 1151) and was read from there.
+//
+// **The build agent is not there any more** (R4g, ADR 0524 section 5): the group deletes it from the controller with the seat
+// node-build-agent. Genesis still installs it as a new mesh's builder, and where genesis gets a builder instead is issue
+// 1152's decision, queued out of that milestone. Until then every test whose subject is the build agent's manifest skips
+// aloud here, and is judged again with issue 1152.
 func theCataloguesModule(t *testing.T, module string) []byte {
 	t.Helper()
-	repository := "mesh-catalog"
 	if module == BuilderModule {
-		repository = "mesh-controller"
+		t.Skipf("NOT JUDGED: genesis still installs build-agent, which left mesh-controller with R4g (ADR 0524 section 5); " +
+			"a new mesh cannot raise a builder until issue 1152 gives genesis one, and this test is judged again with it")
 	}
+	repository := "mesh-catalog"
 	inside := filepath.Join(repository, "modules", module, "module.json")
 	if root := os.Getenv("MESH_CHECK_BESIDE"); root != "" {
 		raw, err := os.ReadFile(filepath.Join(root, inside))

internal/bootstrap/bus_adoption_test.go

@@ -108,28 +108,35 @@ func TestABusStepThatEndsFailedIsRefused(t *testing.T) {
 	}
 }
 
-// The bundle's bus runs the release the module's image is built on, pinned by the same digest, so the
-// adoption changes no server release and is reversible as the step says (ADR 0333 §3).
+// The bundle's bus runs the release the module's server is, pinned by the same digest, so the adoption changes no
+// server release and is reversible as the step says (ADR 0333 §3). The module takes the server as an upstream
+// artifact, its image reference pinned by digest (issue 1641); it no longer builds an image on a NATS_BASE argument,
+// which this test read until issue 1875.
 func TestTheBundlesBusRunsTheReleaseTheModulesImageIsBuiltOn(t *testing.T) {
 	var m struct {
 		Build struct {
-			On []struct{ Arg, Image string } `json:"on"`
+			Artifacts []struct{ Name, Kind, From string } `json:"artifacts"`
 		} `json:"build"`
 	}
 	if err := json.Unmarshal(theCataloguesModule(t, BusModule), &m); err != nil {
 		t.Fatal(err)
 	}
-	base := ""
-	for _, on := range m.Build.On {
-		if on.Arg == "NATS_BASE" {
-			base = on.Image
+	from := ""
+	for _, a := range m.Build.Artifacts {
+		if a.Name == "server" && a.Kind == "upstream" {
+			from = a.From
 		}
 	}
+	name, digest, pinned := strings.Cut(from, "@")
+	if !pinned || !strings.HasPrefix(digest, "sha256:") {
+		t.Fatalf("the nats module's server is no upstream image pinned by digest: %q", from)
+	}
+	repository, _, _ := strings.Cut(name, ":")
 	rewritten, err := Rewrite(theRealBundle(t), held)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if got := containerNamed(rewritten.Declaration, "mesh-broker-nats").Image; got != base {
-		t.Errorf("the bundle raises the bus on %s; the nats module's image is built on %s", got, base)
+	if got, want := containerNamed(rewritten.Declaration, "mesh-broker-nats").Image, repository+"@"+digest; got != want {
+		t.Errorf("the bundle raises the bus on %s; the nats module's server is %s (%s)", got, want, from)
 	}
 }

internal/bootstrap/genesis_form_test.go

@@ -241,9 +241,16 @@ func TestAFileNothingOfTheControllerWritesIsStillRefused(t *testing.T) {
 // The controller's own manifest, as the mesh runs it, passes step 9 (issue 597): in a merge check the
 // node-engine's check has the controller cloned beside it (MESH_CHECK_BESIDE), where it must be; else a
 // checkout beside this one; else it skips aloud.
+//
+// The checker places the controller beside this repository (mesh-delivery's besideRules, since R4g, issue 1295), so a
+// MESH_CHECK_BESIDE without a mesh-controller directory, or without its module.json, fails. Only a run with no
+// MESH_CHECK_BESIDE and no checkout beside this one (a developer's clone alone) skips aloud.
 func TestTheControllersOwnManifestPassesStepNine(t *testing.T) {
 	var manifest []byte
 	if root := os.Getenv("MESH_CHECK_BESIDE"); root != "" {
+		if info, err := os.Stat(filepath.Join(root, "mesh-controller")); err != nil || !info.IsDir() {
+			t.Fatalf("the controller is not beside this check in MESH_CHECK_BESIDE=%s: the checker places mesh-controller beside the node-engine's check (mesh-delivery besideRules, issue 1295), and this test judges the controller's own manifest", root)
+		}
 		raw, err := os.ReadFile(filepath.Join(root, "mesh-controller", "module.json"))
 		if err != nil {
 			t.Fatalf("the controller is not beside this check in MESH_CHECK_BESIDE=%s: %v", root, err)

internal/bootstrap/genesis_toolchains_test.go

@@ -26,6 +26,11 @@ func TestTheBaseStepBuildsEveryToolchainAGenesisModuleIsCompiledIn(t *testing.T)
 		built[tc.Language] = true
 	}
 	for _, module := range genesisModules {
+		if module == BuilderModule {
+			t.Logf("NOT JUDGED: genesis still installs build-agent, which left mesh-controller with R4g (ADR 0524 section 5); " +
+				"only build-agent is set aside here until issue 1152 gives genesis a builder, the other modules are judged")
+			continue
+		}
 		var m struct {
 			Build struct {
 				Artifacts []struct {

internal/bootstrap/reads-outside

@@ -0,0 +1 @@
+These tests read files outside this directory (the repository's root files or other directories): mesh-build-go never keeps this package's verdict (issue 1935).

internal/bootstrap/rootsecrets.go

@@ -45,8 +45,10 @@ import (
 // onward, and the permanent controller is given it by `secret accept` (control.go deliverStores).
 const (
 	// StoreSuperuserFile is where the store's superuser password lives on the machine — the
-	// postgres module's own-secret path, so genesis and adoption write the same file.
-	StoreSuperuserFile = "/var/lib/postgres/superuser.secret"
+	// postgres module's own-secret path, so genesis and adoption write the same file: in the module's
+	// directory under <data root>/mesh, not in /var/lib/postgres, the postgresql package's own (novox/hq
+	// issue 1873).
+	StoreSuperuserFile = "/var/lib/mesh/postgres/superuser.secret"
 	// StoreDataDir is where the store keeps its data — the postgres module's data directory, so
 	// genesis raises the store where the module adopts it (novox/hq ADR 0338 §1).
 	StoreDataDir = "/var/lib/mesh-store"
@@ -207,7 +209,7 @@ func keptOrMade(path string, dryRun bool) (value string, made bool, err error) {
 
 // writeCredentialFile writes a credential as genesis keeps it.
 func writeCredentialFile(path, value string) error {
-	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+	if err := makeCredentialDir(filepath.Dir(path)); err != nil {
 		return err
 	}
 	// Written whole and renamed into place, at 0600, owned by whoever runs the installer — root,
@@ -227,6 +229,32 @@ func writeCredentialFile(path, value string) error {
 	return os.Rename(tmp, path)
 }
 
+// makeCredentialDir makes a credential's directory 0700 and every missing one above it 0755, the mode the mesh's
+// directories have (/var/lib/mesh above a module's own: novox/hq issue 1873), so a module's account still reaches its
+// own directory below one genesis made. A directory already there is left as it is.
+func makeCredentialDir(dir string) error {
+	dir = filepath.Clean(dir)
+	if _, err := os.Stat(dir); err == nil {
+		return nil
+	} else if !os.IsNotExist(err) {
+		return err
+	}
+	if parent := filepath.Dir(dir); parent != dir {
+		if _, err := os.Stat(parent); os.IsNotExist(err) {
+			if err := makeCredentialDir(parent); err != nil {
+				return err
+			}
+			if err := os.Chmod(parent, 0o755); err != nil {
+				return err
+			}
+		}
+	}
+	if err := os.Mkdir(dir, 0o700); err != nil && !os.IsExist(err) {
+		return err
+	}
+	return os.Chmod(dir, 0o700)
+}
+
 // readCredentialFile is a credential as genesis keeps it: the value alone, its line ending gone.
 // Missing is reported as os.IsNotExist so a caller can tell "not made yet" from "unreadable".
 func readCredentialFile(path string) (string, error) {

internal/bootstrap/rootsecrets_test.go

@@ -249,3 +249,27 @@ func TestTheFoundationFiltersBeforeAnythingListens(t *testing.T) {
 		}
 	}
 }
+
+// novox/hq issue 1873: the store's superuser file is the postgres module's own secret in its directory under
+// <data root>/mesh (/var/lib/mesh/postgres), no longer in /var/lib/postgres, the postgresql package's own. A
+// directory genesis makes on the way keeps the mode the mesh's directories have (0755, so every module's account
+// reaches its own below it); only the credential's own directory is closed, 0700.
+func TestTheStoreSuperuserFileLiesInTheModulesOwnDirectory(t *testing.T) {
+	if StoreSuperuserFile != "/var/lib/mesh/postgres/superuser.secret" {
+		t.Errorf("the store's superuser file is %s, not the postgres module's /var/lib/mesh/postgres/superuser.secret", StoreSuperuserFile)
+	}
+	dir := t.TempDir()
+	store := dir + "/mesh/postgres/superuser.secret"
+	if _, err := rootSecretsAt(store, dir+"/genesis/bus", dir+"/genesis/bus.bcrypt", false); err != nil {
+		t.Fatal(err)
+	}
+	for path, want := range map[string]os.FileMode{dir + "/mesh": 0o755, dir + "/mesh/postgres": 0o700} {
+		st, err := os.Stat(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if st.Mode().Perm() != want {
+			t.Errorf("%s is made %04o, not %04o", path, st.Mode().Perm(), want)
+		}
+	}
+}

internal/bootstrap/store_layout_test.go

@@ -66,11 +66,11 @@ func TestTheBundleRaisesTheStoreAsTheCataloguesPostgresModuleDeclaresIt(t *testi
 		if _, has := ours.Env["POSTGRES_PASSWORD"]; has {
 			t.Error("the bundle's store takes its password from its environment; the module reads a file")
 		}
-		// The module's own directory for its state is <data root>/<module>, where genesis keeps the
-		// superuser's file (StoreSuperuserFile).
+		// The module's own directory is <data root>/mesh/<module>, where genesis keeps the superuser's
+		// file (StoreSuperuserFile; novox/hq issue 1873).
 		var theirs []string
 		for _, v := range r.Volumes {
-			theirs = append(theirs, strings.ReplaceAll(v, "${dir:state}", "/var/lib/postgres"))
+			theirs = append(theirs, strings.ReplaceAll(v, "${dir:data}", "/var/lib/mesh/postgres"))
 		}
 		if strings.Join(ours.Volumes, " ") != strings.Join(theirs, " ") {
 			t.Errorf("the bundle's store mounts %v; the module's %v", ours.Volumes, theirs)

internal/filling/filling.go

@@ -29,6 +29,7 @@ import (
 	"path/filepath"
 	"sort"
 	"strconv"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -87,6 +88,28 @@ type Engine struct {
 	// change. Called holding the lock, with the declaration read under it.
 	Place func(ctx context.Context, d *declaration.Declaration, path string, content []byte) (action, digest string,
 		err error)
+
+	// owed is what this engine refused or failed to write since it last told the client to fill again (Knock).
+	owed owed
+}
+
+// owed is the writes a later declaration may let through: a path refused as not named as filled, a write refused
+// while the declaration named no provisioner account, and a path whose write failed. The client is told to fill
+// again only once a declaration may end one (Knock): it has no other way to learn that the declaration changed.
+type owed struct {
+	mu        sync.Mutex
+	unnamed   map[string]bool // refused: the declaration did not name it as filled
+	failed    map[string]bool // attempted, and the write or what reads it failed
+	noAccount bool            // refused: the declaration named no provisioner account
+}
+
+func (o *owed) add(kind *map[string]bool, path string) {
+	o.mu.Lock()
+	defer o.mu.Unlock()
+	if *kind == nil {
+		*kind = map[string]bool{}
+	}
+	(*kind)[path] = true
 }
 
 // Accepts reads the declaration and judges the account.
@@ -95,7 +118,21 @@ func (e *Engine) Accepts(uid uint32) error {
 	if err != nil {
 		return fmt.Errorf("this node's declaration cannot be read, so no write is accepted: %w", err)
 	}
-	return JudgeAccount(d, uid, e.UIDOf)
+	if err := JudgeAccount(d, uid, e.UIDOf); err != nil {
+		e.oweAccount(d)
+		return err
+	}
+	return nil
+}
+
+// oweAccount remembers a refusal a declaration naming the provisioner's account may end.
+func (e *Engine) oweAccount(d *declaration.Declaration) {
+	if d.Provisioner != "" {
+		return // another account than the client's: no declaration lets it through
+	}
+	e.owed.mu.Lock()
+	e.owed.noAccount = true
+	e.owed.mu.Unlock()
 }
 
 // Write takes the apply's lock, reads the declaration under it, judges the account and the path again — the
@@ -114,18 +151,87 @@ func (e *Engine) Write(ctx context.Context, uid uint32, req Request) Answer {
 		return Refusal(req.Path, "this node's declaration cannot be read, so nothing was written: "+err.Error())
 	}
 	if err := JudgeAccount(d, uid, e.UIDOf); err != nil {
+		e.oweAccount(d)
 		return Refusal(req.Path, err.Error())
 	}
 	if err := JudgePath(d, req.Path); err != nil {
+		e.owed.add(&e.owed.unnamed, req.Path)
 		return Refusal(req.Path, err.Error())
 	}
 	action, digest, err := e.Place(ctx, d, req.Path, req.Content)
 	if err != nil {
+		e.owed.add(&e.owed.failed, req.Path)
 		return Answer{Path: req.Path, Action: action, Digest: digest, Failed: err.Error()}
 	}
 	return Answer{Path: req.Path, Action: action, Digest: digest}
 }
 
+// Knock tells the provisioner's client to fill again when the declaration this node applies now may let through a
+// write this engine refused or failed (issue 1873; ace, 2026-10-25 21:17: mesh-build-go's files were refused as not
+// named as filled 32 s before its want arrived, and nothing filled them after the apply that named them): a path
+// refused as not named that the declaration now names, a write refused while no provisioner account was named once
+// one is, and any path whose write failed. Called once a module's apply or removal settled (the node agent's
+// Settled, after what runs holds it): an event of the engine's own, never a timer. It holds the apply's lock, as a
+// write does, so a write judged by the declaration before the apply settled has recorded its refusal before Knock
+// reads what is owed, and one judged after is judged by the settled declaration. The client is told by touching the
+// write socket, whose attributes it watches (mesh-provisioner-client socketwatch.go, IN_ATTRIB), and then fills every
+// module it holds again. A refusal the declaration still does not end is kept for the next apply. It answers what it
+// told the client of, for the journal; nothing when it told nothing. With nothing owed it reads no declaration.
+func (e *Engine) Knock(socket string) (string, error) {
+	unlock, err := e.Lock()
+	if err != nil {
+		return "", fmt.Errorf("the apply's lock could not be taken, so the provisioner's client is not told to fill "+
+			"again: %w", err)
+	}
+	defer unlock()
+	e.owed.mu.Lock()
+	nothing := len(e.owed.unnamed) == 0 && len(e.owed.failed) == 0 && !e.owed.noAccount
+	e.owed.mu.Unlock()
+	if nothing {
+		return "", nil
+	}
+	d, err := e.Declared()
+	if err != nil {
+		return "", fmt.Errorf("this node's declaration cannot be read, so the provisioner's client is not told to "+
+			"fill again: %w", err)
+	}
+	e.owed.mu.Lock()
+	var why []string
+	for _, p := range sortedSet(e.owed.unnamed) {
+		if d.Fills(p) {
+			why = append(why, p+" (now named as filled)")
+			delete(e.owed.unnamed, p)
+		}
+	}
+	for _, p := range sortedSet(e.owed.failed) {
+		why = append(why, p+" (its write failed)")
+		delete(e.owed.failed, p)
+	}
+	if e.owed.noAccount && d.Provisioner != "" {
+		why = append(why, "every file (the provisioner's account is named now)")
+		e.owed.noAccount = false
+	}
+	e.owed.mu.Unlock()
+	if len(why) == 0 {
+		return "", nil
+	}
+	now := time.Now()
+	if err := os.Chtimes(socket, now, now); err != nil {
+		return "", fmt.Errorf("the provisioner's client could not be told to fill %s again: %w",
+			strings.Join(why, ", "), err)
+	}
+	return strings.Join(why, ", "), nil
+}
+
+func sortedSet(m map[string]bool) []string {
+	out := make([]string, 0, len(m))
+	for k := range m {
+		out = append(out, k)
+	}
+	sort.Strings(out)
+	return out
+}
+
 // JudgeAccount refuses every account but the one the declaration names as the provisioner's client's, by its user
 // id here — and every account while the declaration names none.
 func JudgeAccount(d *declaration.Declaration, uid uint32, uidOf func(string) (uint32, error)) error {

internal/filling/filling_test.go

@@ -88,6 +88,138 @@ func TestAnUndeclaredPathIsRefused(t *testing.T) {
 	if len(e.placed) != 0 {
 		t.Errorf("placed %v", e.placed)
 	}
+
+	// A refusal a later declaration ends is followed by a knock on the socket, which the provisioner's client watches,
+	// once a declaration applied after it ends it, and only then (ace, 2026-10-25 21:17: mesh-build-go's files refused
+	// 32 s before its want, and never filled after the apply that named them).
+	socket := filepath.Join(t.TempDir(), "fill.sock")
+	if err := os.WriteFile(socket, nil, 0o666); err != nil {
+		t.Fatal(err)
+	}
+	long := time.Now().Add(-time.Hour)
+	knocked := func() bool {
+		info, err := os.Stat(socket)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return info.ModTime().After(long.Add(time.Minute))
+	}
+	namesOther := strings.NewReplacer(`"filled_files":["/etc/m/m.conf"]`,
+		`"filled_files":["/etc/m/m.conf","/etc/m/other.conf"]`, `"content":"y"}`,
+		`"content":"y","owner-at-runtime":"owned"}`).Replace(withAccount)
+	failing := errors.New("is a directory")
+	var mu2 sync.Mutex // guards the race row's count of declaration reads
+	for _, row := range []struct {
+		name    string
+		before  string // the declaration the write is judged by
+		account uint32
+		path    string
+		place   error
+		after   string // the declaration applied afterwards
+		knock   string // what the knock names; "" for none
+		twice   bool   // a second knock names nothing
+	}{
+		{name: "an undeclared path the next declaration does not name either", before: withAccount,
+			account: provisionerUID, path: "/etc/m/other.conf", after: withAccount},
+		{name: "an undeclared path the next declaration names", before: withAccount, account: provisionerUID,
+			path: "/etc/m/other.conf", after: namesOther, knock: "/etc/m/other.conf (now named as filled)", twice: true},
+		{name: "a write refused while no account was named, then named", before: withoutAccount,
+			account: provisionerUID, path: "/etc/m/m.conf", after: withAccount,
+			knock: "every file (the provisioner's account is named now)", twice: true},
+		{name: "a write that failed", before: withAccount, account: provisionerUID, path: "/etc/m/m.conf",
+			place: failing, after: withAccount, knock: "/etc/m/m.conf (its write failed)", twice: true},
+		{name: "another account, refused whatever is declared", before: withAccount, account: 1000,
+			path: "/etc/m/m.conf", after: withAccount},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			if err := os.Chtimes(socket, long, long); err != nil {
+				t.Fatal(err)
+			}
+			e := newEngine(t, row.before, &sync.Mutex{})
+			if row.place != nil {
+				e.Place = func(context.Context, *declaration.Declaration, string, []byte) (string, string, error) {
+					return "", "", row.place
+				}
+			}
+			_ = e.Accepts(row.account)
+			e.Write(context.Background(), row.account, Request{Path: row.path, Content: []byte("x")})
+			after := declared(t, row.after)
+			e.Declared = func() (*declaration.Declaration, error) { return after, nil }
+			told, err := e.Knock(socket)
+			if err != nil || told != row.knock || knocked() != (row.knock != "") {
+				t.Fatalf("knock told %q (%v), socket touched %v; want %q", told, err, knocked(), row.knock)
+			}
+			if row.twice {
+				if err := os.Chtimes(socket, long, long); err != nil {
+					t.Fatal(err)
+				}
+				if told, _ := e.Knock(socket); told != "" || knocked() {
+					t.Fatalf("a second knock told %q: what was told is no longer owed", told)
+				}
+			}
+		})
+	}
+
+	// The race (review of this fix): a write judged by the declaration before the apply settled, its refusal not yet
+	// recorded when Knock runs. Knock waits for the apply's lock the write holds, so it sees that refusal and knocks.
+	t.Run("a write still judging when the apply settles", func(t *testing.T) {
+		if err := os.Chtimes(socket, long, long); err != nil {
+			t.Fatal(err)
+		}
+		before, after := declared(t, withAccount), declared(t, namesOther)
+		judging, release := make(chan struct{}), make(chan struct{})
+		var mu sync.Mutex
+		knockLocking := make(chan struct{}, 1)
+		calls := 0
+		e := newEngine(t, withAccount, &mu)
+		e.Declared = func() (*declaration.Declaration, error) {
+			mu2.Lock()
+			calls++
+			first := calls == 1
+			mu2.Unlock()
+			if first {
+				close(judging)
+				<-release
+				return before, nil
+			}
+			return after, nil
+		}
+		e.Lock = func() (func(), error) {
+			mu2.Lock()
+			second := calls > 0
+			mu2.Unlock()
+			if second {
+				knockLocking <- struct{}{}
+			}
+			mu.Lock()
+			return mu.Unlock, nil
+		}
+		wrote := make(chan Answer)
+		go func() { wrote <- e.Write(context.Background(), provisionerUID, Request{Path: "/etc/m/other.conf"}) }()
+		<-judging
+		type result struct {
+			told string
+			err  error
+		}
+		knocked2 := make(chan result, 1)
+		go func() { told, err := e.Knock(socket); knocked2 <- result{told, err} }()
+		// Released once Knock waits for the lock, or once it has answered without taking it.
+		var r result
+		select {
+		case <-knockLocking:
+			close(release)
+			r = <-knocked2
+		case r = <-knocked2:
+			close(release)
+		}
+		if a := <-wrote; a.Refused == "" {
+			t.Fatalf("the write was not refused: %+v", a)
+		}
+		if r.err != nil || r.told != "/etc/m/other.conf (now named as filled)" || !knocked() {
+			t.Fatalf("knock told %q (%v), socket touched %v: the refusal still being judged was missed", r.told, r.err,
+				knocked())
+		}
+	})
 }
 
 func TestAnotherAccountIsRefused(t *testing.T) {

internal/link/asked_test.go

@@ -1,130 +0,0 @@
-package link
-
-import (
-	"context"
-	"strings"
-	"testing"
-	"time"
-)
-
-// The `report` verb (novox/hq to-be 45 §6), what healer H1 asks a machine whose send went unreported:
-// the node says again what it last applied, as an ordinary report through the one queue.
-
-// **Asked, the reconcile's account is said even when it is not news** — the mesh asked because it does
-// not know, and silence would be the very fault it is asking about.
-func TestAskedToReportSaysWhatWasLastAppliedEvenWhenNotNews(t *testing.T) {
-	m, _ := aMember(t)
-	l := newQuietLink()
-	var lines []string
-	q := aQueue(m, (&applies{}).apply, &keptInMemory{})
-	q.Say = func(s string) { lines = append(lines, s) }
-	q.Reconcile = func(context.Context) (Report, bool) {
-		return Report{Declared: "d-kept", Order: Order{Epoch: 7, Sequence: 12}, Applied: []string{"a"}}, true
-	}
-	q.News = func(Report) bool { return false }
-	q.attach(context.Background(), l)
-	ctx, stop := context.WithCancel(context.Background())
-	worker := runWorker(ctx, q)
-
-	q.ReconcileDue() // an ordinary reconcile: not news, not said
-	time.Sleep(50 * time.Millisecond)
-	if n := len(l.said()); n != 0 {
-		t.Fatalf("an ordinary reconcile that is not news said %d report(s)", n)
-	}
-	q.ReportAsked()
-	eventually(t, "asked, the node said nothing", func() bool { return len(l.said()) == 1 })
-	stop()
-	<-worker
-	r := l.said()[0]
-	if r.Declared != "d-kept" || r.Sequence != 12 || r.Epoch != 7 || r.ReportSequence == 0 || r.Node != m.Node {
-		t.Fatalf("the account said is not the one kept, in order: %+v", r)
-	}
-	if !strings.Contains(strings.Join(lines, "\n"), "asked by the mesh") {
-		t.Errorf("being asked is not said in the journal: %q", lines)
-	}
-}
-
-// **A delivery waiting answers the question better**: it is applied, once, and its report is the answer.
-func TestAskedWhileADeliveryWaitsIsThatDeliverysReport(t *testing.T) {
-	m, key := aMember(t)
-	l := newQuietLink()
-	a := &applies{}
-	q := aQueue(m, a.apply, &keptInMemory{})
-	reconciled := 0
-	q.Reconcile = func(context.Context) (Report, bool) { reconciled++; return Report{}, true }
-	q.attach(context.Background(), l)
-	q.Deliver(ordered(t, key, "new", 7, 13))
-	q.ReportAsked()
-	ctx, stop := context.WithCancel(context.Background())
-	worker := runWorker(ctx, q)
-	eventually(t, "the delivery was never reported", func() bool { return len(l.said()) == 1 })
-	time.Sleep(50 * time.Millisecond)
-	stop()
-	<-worker
-	if reconciled != 0 || len(l.said()) != 1 || l.said()[0].Sequence != 13 {
-		t.Fatalf("reconciled %d, said %+v", reconciled, l.said())
-	}
-}
-
-// askingLink is a quiet link the mesh can ask.
-type askingLink struct {
-	*quietLink
-	asks chan struct{}
-}
-
-func (l askingLink) AskedToReport() <-chan struct{} { return l.asks }
-
-// **The link hands the question to the queue**: asked on the link, the account is said on it.
-func TestALinkThatIsAskedHandsItToTheQueue(t *testing.T) {
-	m, _ := aMember(t)
-	l := askingLink{quietLink: newQuietLink(), asks: make(chan struct{}, 1)}
-	q := aQueue(m, (&applies{}).apply, &keptInMemory{})
-	q.Reconcile = func(context.Context) (Report, bool) { return Report{Declared: "d-kept"}, true }
-	ctx, stop := context.WithCancel(context.Background())
-	defer stop()
-	worker := runWorker(ctx, q)
-	served := make(chan error, 1)
-	go func() { served <- serve(ctx, l, m, q, nil, time.Second) }()
-	l.asks <- struct{}{}
-	eventually(t, "asked on the link, nothing was said", func() bool {
-		for _, r := range l.said() {
-			if r.Declared == "d-kept" {
-				return true
-			}
-		}
-		return false
-	})
-	stop()
-	<-served
-	<-worker
-}
-
-// **Against a real server**: the question on the node's own subject reaches it, and another's does not.
-func TestNatsTheMeshAsksANodeToReport(t *testing.T) {
-	conn, js := aBus(t)
-	l := &natsLink{conn: conn, js: js, node: "asked"}
-	l.hearAsks()
-	defer l.Close()
-	if err := conn.Publish(AskReportSubject("another"), []byte(`{}`)); err != nil {
-		t.Fatal(err)
-	}
-	if err := conn.Publish(AskReportSubject("asked"), []byte(`{"by":"the controller's healer H1"}`)); err != nil {
-		t.Fatal(err)
-	}
-	if err := conn.Flush(); err != nil {
-		t.Fatal(err)
-	}
-	select {
-	case <-l.AskedToReport():
-	case <-time.After(5 * time.Second):
-		t.Fatal("the question on the node's own subject never reached it")
-	}
-	select {
-	case <-l.AskedToReport():
-		t.Fatal("asked twice: another node's question reached this one")
-	case <-time.After(200 * time.Millisecond):
-	}
-	if AskReportSubject("asked") != "mesh.node.asked.ask.report" {
-		t.Fatalf("the subject %q is not the one the controller asks on and grants", AskReportSubject("asked"))
-	}
-}

internal/link/asktool_nats_test.go

@@ -25,8 +25,8 @@ func TestNatsAToolCheckIsAskedOnTheLink(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	q := &Queue{Membership: Membership{Node: node}}
-	q.attach(t.Context(), &natsLink{conn: conn, js: js, node: node})
+	q := &Session{Membership: Membership{Node: node}}
+	q.Attach(t.Context(), &natsLink{conn: conn, js: js, node: node})
 	ctx, cancel := context.WithTimeout(t.Context(), 2*time.Second)
 	defer cancel()
 	a, err := q.AskTool(ctx, "sensors", "sensors_health")

internal/link/files.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"git.novox.be/novox/mesh-sdk/go/declaration"
+	"git.novox.be/novox/mesh-sdk/go/delivery"
 	"github.com/nats-io/nats.go"
 )
 
@@ -92,7 +93,32 @@ func (b OverNATS) FileObject(ctx context.Context, name string, limit int64) ([]b
 	if err != nil {
 		return nil, err
 	}
-	stream := declaration.FileStreamPrefix + bucket
+	return objectByName(ctx, js, bucket, declaration.FileStreamPrefix+bucket, name, limit)
+}
+
+// GrantsObject reads one object of the grants part's bucket of sealed user lists by its name (novox/hq ADR 0547 clause 7),
+// with the same subjects and nothing more as FileObject: the bus node is granted exactly those (mesh-sdk
+// buscompose.GrantsUserListFollows).
+func (b OverNATS) GrantsObject(ctx context.Context, name string, limit int64) ([]byte, error) {
+	js := b.JS
+	wait := 10 * time.Second
+	if at, ok := ctx.Deadline(); ok {
+		if wait = time.Until(at); wait <= 0 {
+			return nil, context.DeadlineExceeded
+		}
+	}
+	if b.Conn != nil {
+		bounded, err := b.Conn.JetStream(nats.MaxWait(wait))
+		if err != nil {
+			return nil, err
+		}
+		js = bounded
+	}
+	return objectByName(ctx, js, delivery.GrantsUserListObjects, delivery.GrantsUserListObjectStream, name, limit)
+}
+
+// objectByName is one object of bucket (its stream stream) by its name, no larger than limit, verified against its digest.
+func objectByName(ctx context.Context, js nats.JetStreamContext, bucket, stream, name string, limit int64) ([]byte, error) {
 	meta, err := js.GetLastMsg(stream, "$O."+bucket+".M."+base64.URLEncoding.EncodeToString([]byte(name)),
 		nats.DirectGet(), nats.Context(ctx))
 	if err != nil {
@@ -109,7 +135,7 @@ func (b OverNATS) FileObject(ctx context.Context, name string, limit int64) ([]b
 		return nil, fmt.Errorf("the object %s was deleted from the bucket %s", name, bucket)
 	}
 	if info.Size > uint64(limit) {
-		return nil, fmt.Errorf("the object is larger than the %d bytes the declaration names", limit)
+		return nil, fmt.Errorf("the object is larger than the %d bytes allowed", limit)
 	}
 	if info.Size == 0 {
 		return []byte{}, nil
@@ -142,6 +168,28 @@ func (l *natsLink) FileObject(ctx context.Context, name string, limit int64) ([]
 	return OverNATS{Conn: l.conn, JS: l.js, Node: l.node}.FileObject(ctx, name, limit)
 }
 
+func (l *natsLink) GrantsObject(ctx context.Context, name string, limit int64) ([]byte, error) {
+	return OverNATS{Conn: l.conn, JS: l.js, Node: l.node}.GrantsObject(ctx, name, limit)
+}
+
+// GrantsObjects is a link that can read an object of the grants part's bucket of sealed user lists.
+type GrantsObjects interface {
+	GrantsObject(ctx context.Context, name string, limit int64) ([]byte, error)
+}
+
+// GrantsObject reads an object of the grants part's bucket by its name on the link open now.
+func (q *Session) GrantsObject(ctx context.Context, name string, limit int64) ([]byte, error) {
+	q.init()
+	q.mu.Lock()
+	bus := q.bus
+	q.mu.Unlock()
+	g, ok := bus.(GrantsObjects)
+	if bus == nil || !ok {
+		return nil, ErrNoLink
+	}
+	return g.GrantsObject(ctx, name, limit)
+}
+
 var (
 	_ FilesBus = OverNATS{}
 	_ FilesBus = (*natsLink)(nil)

internal/link/handover_test.go

@@ -184,7 +184,7 @@ func (l handingLink) HearHandOvers(h HandOverFunc) { l.given <- h }
 func TestALinkThatHearsHandOversIsGivenTheQueues(t *testing.T) {
 	m, _ := aMember(t)
 	l := handingLink{quietLink: newQuietLink(), given: make(chan HandOverFunc, 1)}
-	q := aQueue(m, (&applies{}).apply, &keptInMemory{})
+	q := &Session{Membership: m, Timeout: time.Second}
 	q.HandOver = func(path, by string) (string, error) { return "the queue's: " + path + " by " + by, nil }
 	ctx, stop := context.WithCancel(context.Background())
 	served := make(chan error, 1)

internal/link/have.go

@@ -6,7 +6,9 @@ import (
 	"errors"
 	"fmt"
 	"sort"
+	"strings"
 	"sync"
+	"time"
 
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 )
@@ -36,24 +38,127 @@ type haveState struct {
 	mu      sync.Mutex
 	modules map[string]ModuleFact
 	health  map[string]delivery.Health
-	node    *delivery.HaveNode
+	// words is, by module, what the last look found of the resource that made its health failed or waits: the have says
+	// it, so a failed health is never without words (issue 1496: "the node gave no words" hid a directory used as found).
+	words map[string]string
+	// looked says a look's health was taken: a running module it judges no resource of then has nothing that could be
+	// down, and is ok (issue 1945).
+	looked bool
+	node   *delivery.HaveNode
+	// nodeComposed is the digest of the node's own composition it runs (ADR 0539 §9), kept beside the node's facts.
+	nodeComposed string
+	// nodeSealed is, on a node composing its own, each value its own composition carries sealed to its key (ADR 0547 §3,
+	// issue 1126): kept in its key so a restart reuses them and applies nothing again.
+	nodeSealed delivery.Seals
+	// nodeCandidates is the node's answer to each placement candidate proposal (novox/hq ADR 0559 §4), written into its key.
+	nodeCandidates map[string]delivery.CandidateAnswer
+	// nodeComposes and nodeComposesWhy are whose compositions the node applies and why (HaveNode.Composes), written into
+	// its key.
+	nodeComposes, nodeComposesWhy string
 	// written is the build of each module this node-engine wrote a have key for and that the declaration it applied
 	// still holds; removed is each such module the latest declaration no longer holds, with the build its key last
 	// said, until the key is written once with the phase removed (issue 1369, novox/hq ADR 0408 §4: never deleted).
 	written map[string]string
 	removed map[string]string
+	// userList is what the bus node's engine last wrote of the bus's user list, by the module whose have says it (novox/hq
+	// ADR 0547 §8); kept apart from the module's fact, which every apply replaces.
+	userList map[string]delivery.UserListWritten
+	// userListNoKey is each module whose user list was said to have no have key to ride on, so it is said once.
+	userListNoKey map[string]bool
+	// unjudged is each module whose composition moved (an apply began, or the fact names another build) and that no look
+	// has judged since it stopped moving: its health is not yet judged, never the last look's of what ran before.
+	unjudged map[string]bool
+}
+
+// inMotion says a module's phase is one of a change still under way: what a look finds of it then judges nothing of the
+// composition being applied (a container stopped to be replaced reads unhealthy), so its health is not yet judged.
+func inMotion(phase string) bool {
+	switch delivery.Phase(phase) {
+	case delivery.PhaseBackingUp, delivery.PhaseApplying, delivery.PhaseChecking:
+		return true
+	}
+	return false
+}
+
+// healthOf is the health a module's have carries: unknown (not yet judged) while its change is under way or until a look
+// after it, the last look's otherwise. The caller holds the lock.
+func (s *haveState) healthOf(module string, f ModuleFact) delivery.Health {
+	if inMotion(f.Phase) {
+		return delivery.HealthUnknown
+	}
+	if got, known := s.health[module]; known {
+		return got
+	}
+	if s.unjudged[module] {
+		return delivery.HealthUnknown
+	}
+	return nothingJudged(f, s.looked)
+}
+
+// moved marks a module's health not yet judged when its fact f is a change under way, or names another composition than
+// the fact before it: the last look judged what ran before. The caller holds the lock.
+func (s *haveState) moved(f ModuleFact) {
+	if prev, known := s.modules[f.Module]; inMotion(f.Phase) || known && (prev.FP != f.FP || prev.Composed != f.Composed) {
+		delete(s.health, f.Module)
+		if s.unjudged == nil {
+			s.unjudged = map[string]bool{}
+		}
+		s.unjudged[f.Module] = true
+	}
+}
+
+// owed says some module left motion and no look judged it since. The caller holds the lock.
+func (s *haveState) owed() bool {
+	for module, f := range s.modules {
+		if s.unjudged[module] && !inMotion(f.Phase) {
+			return true
+		}
+	}
+	return false
+}
+
+// takeLook keeps a look's health: of a module still in motion nothing, since the look judged what is being replaced;
+// of every other module what the look found, which is then judged. The caller holds the lock.
+func (s *haveState) takeLook(h *Health) {
+	next, words := moduleHealths(h)
+	for module, f := range s.modules {
+		if inMotion(f.Phase) {
+			delete(next, module)
+			delete(words, module)
+			if s.unjudged == nil {
+				s.unjudged = map[string]bool{}
+			}
+			s.unjudged[module] = true
+			continue
+		}
+		delete(s.unjudged, module)
+	}
+	s.health, s.words, s.looked = next, words, true
+}
+
+// wordsOf is what a have says of its health when the apply said nothing: the words of the resource that made it failed
+// or waits, while it is so. The caller holds the lock.
+func (s *haveState) wordsOf(module string, health delivery.Health) string {
+	if health != delivery.HealthFailed && health != delivery.HealthWaits {
+		return ""
+	}
+	return s.words[module]
 }
 
 // moduleHealths is the health of each module a look names, from the states of its resources: failed when any is
-// unhealthy, waits when any waits (waiting, starting, held), ok when all are healthy, unknown otherwise.
-func moduleHealths(h *Health) map[string]delivery.Health {
-	out := map[string]delivery.Health{}
+// unhealthy, waits when any waits (waiting, starting, held), ok when all are healthy, unknown otherwise; and, for a
+// module failed or waiting, the words of the first resource that made it so. A directory used as found is not the
+// module's health: it says nothing of how the module runs, waits for the operator's hand-over and keeps its own
+// condition, raised from the same statement (issue 1496: on ace mesh-build-node's cache directory, there before the
+// mesh, made its have failed while its check answered healthy, and the assigner held its version on every node).
+func moduleHealths(h *Health) (map[string]delivery.Health, map[string]string) {
+	out, words := map[string]delivery.Health{}, map[string]string{}
 	if h == nil {
-		return out
+		return out, words
 	}
 	rank := map[string]int{}
 	for _, r := range h.Resources {
-		if r.Module == "" {
+		if r.Module == "" || usedAsFound(r) {
 			continue
 		}
 		var this int
@@ -69,12 +174,32 @@ func moduleHealths(h *Health) map[string]delivery.Health {
 		}
 		if was, seen := rank[r.Module]; !seen || this > was {
 			rank[r.Module] = this
+			if this >= 2 {
+				words[r.Module] = resourceWords(r)
+			}
 		}
 	}
 	for module, r := range rank {
 		out[module] = [...]delivery.Health{delivery.HealthOK, delivery.HealthUnknown, delivery.HealthWaits, delivery.HealthFailed}[r]
+		if r < 2 {
+			delete(words, module)
+		}
 	}
-	return out
+	return out, words
+}
+
+// usedAsFound says a resource of a statement is a directory used as found (issue 339).
+func usedAsFound(r ResourceHealth) bool {
+	return r.Kind == KindDirectory && strings.HasPrefix(r.Reason, ReasonUsedAsFound)
+}
+
+// resourceWords is one resource's state in the words a have carries: its id, its state and why.
+func resourceWords(r ResourceHealth) string {
+	w := r.Resource + " " + r.State
+	if why := strings.TrimSpace(r.Reason); why != "" {
+		w += ": " + why
+	}
+	return w
 }
 
 // nodeFacts is the node's own facts of a report, each as the JSON the report carries it in.
@@ -97,11 +222,22 @@ func nodeFacts(r Report) delivery.HaveNode {
 }
 
 // noteApply takes what an apply's report says of the modules and the node.
-func (q *Queue) noteApply(r Report) bool {
-	if r.Modules == nil {
-		return false
-	}
+func (q *Session) noteApply(r Report) bool {
 	s := &q.haves
+	if r.Modules == nil {
+		// Facts that say nothing of any module (the node agent writes those, ADR 0539 §9): the node's own key and the
+		// health the facts carry.
+		if r.Refused != "" {
+			return false
+		}
+		s.mu.Lock()
+		defer s.mu.Unlock()
+		if r.Health != nil {
+			s.takeLook(r.Health)
+		}
+		s.node = q.nodeFactsWithRecord(r, s.node)
+		return true
+	}
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	next := map[string]ModuleFact{}
@@ -136,41 +272,68 @@ func (q *Queue) noteApply(r Report) bool {
 	for module := range next {
 		delete(s.removed, module) // added back: its have is written with its new phase
 	}
+	for module := range s.modules {
+		if _, held := next[module]; !held {
+			delete(s.unjudged, module)
+		}
+	}
+	for _, f := range next {
+		s.moved(f)
+	}
 	s.modules = next
 	if r.Health != nil {
-		s.health = moduleHealths(r.Health)
+		s.takeLook(r.Health)
 	}
-	n := nodeFacts(r)
-	s.node = &n
+	if s.owed() {
+		q.oweHealth()
+	}
+	s.node = q.nodeFactsWithRecord(r, s.node)
 	return true
 }
 
+// nodeFactsWithRecord is the node's own facts of a report with its record (ADR 0555 §3): a report that says nothing of
+// the machine leaves the record last made standing, and one without a health statement keeps the contract last stated.
+func (q *Session) nodeFactsWithRecord(r Report, before *delivery.HaveNode) *delivery.HaveNode {
+	n := nodeFacts(r)
+	if q.Keys != nil {
+		n.Record = recordOf(q.Membership.Node, r, q.Keys())
+	}
+	if before != nil && before.Record != nil {
+		switch {
+		case n.Record == nil:
+			n.Record = before.Record
+		case n.Record.Contract == 0:
+			n.Record.Contract = before.Record.Contract
+		}
+	}
+	return &n
+}
+
 // noteHealth takes a look's health, and says whether any module's changed.
-func (q *Queue) noteHealth(h Health) bool {
+func (q *Session) noteHealth(h Health) bool {
 	s := &q.haves
 	s.mu.Lock()
 	defer s.mu.Unlock()
-	next := moduleHealths(&h)
+	said := func(module string, f ModuleFact) string {
+		health := s.healthOf(module, f)
+		return string(health) + "\x00" + s.wordsOf(module, health)
+	}
+	before := map[string]string{}
+	for module, f := range s.modules {
+		before[module] = said(module, f)
+	}
+	s.takeLook(&h)
 	changed := false
-	for module := range s.modules {
-		want, ok := next[module]
-		if !ok {
-			want = delivery.HealthUnknown
-		}
-		have, known := s.health[module]
-		if !known {
-			have = delivery.HealthUnknown
-		}
-		if have != want {
+	for module, f := range s.modules {
+		if said(module, f) != before[module] {
 			changed = true
 		}
 	}
-	s.health = next
 	return changed
 }
 
 // sayHave is a line in the node-engine's log, if it has one.
-func (q *Queue) sayHave(s string) {
+func (q *Session) sayHave(s string) {
 	if q.Say != nil {
 		q.Say(s)
 	}
@@ -180,7 +343,7 @@ func (q *Queue) sayHave(s string) {
 // §4, issue 1132): each module's have, and the node's own facts. It reads the key first and writes nothing when the value
 // is the same, otherwise writes over the revision it read, and creates the key when there is none. A write the bucket
 // refuses is said and left: the next apply or look writes again, and the report was sent before this ran.
-func (q *Queue) writeHaves(ctx context.Context, bus Bus) {
+func (q *Session) writeHaves(ctx context.Context, bus Bus) {
 	hb, ok := bus.(HaveBus)
 	if !ok || bus == nil {
 		return
@@ -188,7 +351,7 @@ func (q *Queue) writeHaves(ctx context.Context, bus Bus) {
 	s := &q.haves
 	s.mu.Lock()
 	defer s.mu.Unlock()
-	if s.modules == nil && s.node == nil && len(s.removed) == 0 {
+	if s.modules == nil && s.node == nil && len(s.removed) == 0 && len(s.userList) == 0 {
 		return
 	}
 	node := q.Membership.Node
@@ -199,6 +362,7 @@ func (q *Queue) writeHaves(ctx context.Context, bus Bus) {
 	bucket, err := hb.HaveBind(write)
 	if err != nil {
 		q.sayHave(fmt.Sprintf("could not bind the have bucket, and wrote nothing there; the next apply or look writes again: %v", err))
+		q.haveFailed(err)
 		return
 	}
 	modules := make([]string, 0, len(s.modules))
@@ -208,13 +372,24 @@ func (q *Queue) writeHaves(ctx context.Context, bus Bus) {
 	sort.Strings(modules)
 	for _, module := range modules {
 		f := s.modules[module]
-		h := delivery.Have{V: delivery.Version, Build: f.Build, Phase: delivery.PhaseRunning,
-			Health: delivery.HealthUnknown, Detail: f.Detail}
-		if f.Failed {
+		h := delivery.Have{V: delivery.Version, FP: f.FP, Composed: f.Composed, Build: f.Build,
+			Phase: delivery.PhaseRunning, Health: delivery.HealthUnknown, Detail: f.Detail}
+		if delivery.Phase(f.Phase) == delivery.PhaseWaitingYes {
+			h.Judgement, h.Waits = delivery.Judgement(f.Judgement), f.Waits
+		}
+		switch {
+		case f.Phase != "":
+			h.Phase = delivery.Phase(f.Phase)
+		case f.Failed:
 			h.Phase = delivery.PhaseFailed
 		}
-		if got, known := s.health[module]; known {
-			h.Health = got
+		h.SealedAt = f.Sealed
+		h.Health = s.healthOf(module, f)
+		if h.Detail == "" {
+			h.Detail = s.wordsOf(module, h.Health)
+		}
+		if w, ok := s.userList[module]; ok {
+			h.UserList = &w
 		}
 		key, err := delivery.HaveKey(node, module)
 		if err != nil {
@@ -240,28 +415,78 @@ func (q *Queue) writeHaves(ctx context.Context, bus Bus) {
 	if !q.writeRemoved(write, bucket, node) {
 		return
 	}
+	if !q.writeUserListsAlone(write, bucket, node) {
+		return
+	}
 	if s.node != nil {
 		key, err := delivery.HaveNodeKey(node)
 		if err == nil {
 			var raw []byte
-			if raw, err = delivery.EncodeHaveNode(*s.node); err == nil {
-				want := *s.node
-				q.putHave(write, bucket, key, raw, func(current []byte) bool {
+			facts := *s.node
+			facts.Composed = s.nodeComposed
+			facts.SealedAt = s.nodeSealed
+			facts.Candidates = s.nodeCandidates
+			facts.Composes, facts.ComposesWhy = s.nodeComposes, s.nodeComposesWhy
+			if raw, err = delivery.EncodeHaveNode(facts); err == nil {
+				want := facts
+				if !q.putHave(write, bucket, key, raw, func(current []byte) bool {
 					c, err := delivery.DecodeHaveNode(current)
 					return err == nil && delivery.SameHaveNode(c, want)
-				})
+				}) {
+					return
+				}
 			}
 		}
 		if err != nil {
 			q.sayHave(fmt.Sprintf("cannot write this node's own facts: %v", err))
 		}
 	}
+	q.haveSucceeded()
+}
+
+// haveFailed takes a failure of a pass over the have bucket: a transient one (the bus reloading its accounts, a
+// reconnect) writes the pass again after a backoff (Backoff), one pending at a time, since no apply or look may come
+// for minutes and the haves would say what is no longer so. Another failure waits for the next apply or look, as before.
+func (q *Session) haveFailed(err error) {
+	if !Transient(err) {
+		return
+	}
+	q.haveAgain.Lock()
+	defer q.haveAgain.Unlock()
+	if q.haveAgainPending {
+		return
+	}
+	q.haveAgainPending = true
+	q.haveAgainTries++
+	wait := haveBackoff(q.haveAgainTries)
+	q.sayHave(fmt.Sprintf("the have bucket did not answer (try %d); written again in %s", q.haveAgainTries, wait))
+	time.AfterFunc(wait, func() {
+		q.haveAgain.Lock()
+		q.haveAgainPending = false
+		q.haveAgain.Unlock()
+		q.mu.Lock()
+		bus := q.bus
+		q.mu.Unlock()
+		if bus != nil {
+			q.writeHaves(context.Background(), bus) // a link opened later writes them anyway
+		}
+	})
+}
+
+// haveBackoff is the wait before a write of the haves again; a test shortens it.
+var haveBackoff = Backoff
+
+// haveSucceeded takes a pass that wrote every have: the next transient failure waits the first backoff again.
+func (q *Session) haveSucceeded() {
+	q.haveAgain.Lock()
+	q.haveAgainTries = 0
+	q.haveAgain.Unlock()
 }
 
 // writeRemoved writes, once, each module the applied declaration no longer holds and this node-engine wrote a have key
 // for, with the phase removed over the revision it reads (issue 1369). The key is never deleted, and a key that is not
 // in the bucket is not created. False when the pass should stop. The caller holds the lock of the haves.
-func (q *Queue) writeRemoved(ctx context.Context, b HaveBucket, node string) bool {
+func (q *Session) writeRemoved(ctx context.Context, b HaveBucket, node string) bool {
 	s := &q.haves
 	gone := make([]string, 0, len(s.removed))
 	for module := range s.removed {
@@ -294,6 +519,7 @@ func (q *Queue) writeRemoved(ctx context.Context, b HaveBucket, node string) boo
 			continue
 		case err != nil:
 			q.sayHave(fmt.Sprintf("could not read %s in the have bucket, and wrote nothing more there: %v", key, err))
+			q.haveFailed(err)
 			return false
 		}
 		if c, err := delivery.DecodeHave(current); err == nil && c.Phase == delivery.PhaseRemoved {
@@ -302,6 +528,7 @@ func (q *Queue) writeRemoved(ctx context.Context, b HaveBucket, node string) boo
 		}
 		if err := b.Set(ctx, key, raw, revision); err != nil {
 			q.sayHave(fmt.Sprintf("could not write %s in the have bucket; the next apply or look writes it again: %v", key, err))
+			q.haveFailed(err)
 			return false
 		}
 		delete(s.removed, module)
@@ -309,9 +536,81 @@ func (q *Queue) writeRemoved(ctx context.Context, b HaveBucket, node string) boo
 	return true
 }
 
+// writeUserListsAlone writes the user list of each module this node-engine holds no fact of (no apply here said its have)
+// into that module's key as the bucket holds it, keeping every other field the key says (novox/hq ADR 0547 §8). The have
+// of a module is one value with parts from more than one source: the apply's (fingerprint, digest, build, phase, health)
+// and the user-list follower's. Written only on the pass over the modules this engine applied, the follower's part was
+// lost whenever the bus module's apply was not this engine's to say (2026-10-26 on the bus node: the bus module had no
+// want and had left the declaration, so its key kept an older engine's value and the vault read no hashes in it). A key
+// that does not exist is not created: a have says a phase, and nothing here knows it; that is said once. False when the
+// pass should stop. The caller holds the lock of the haves.
+func (q *Session) writeUserListsAlone(ctx context.Context, b HaveBucket, node string) bool {
+	s := &q.haves
+	alone := make([]string, 0, len(s.userList))
+	for module := range s.userList {
+		_, held := s.modules[module]
+		_, gone := s.removed[module]
+		if !held && !gone {
+			alone = append(alone, module)
+		}
+	}
+	sort.Strings(alone)
+	for _, module := range alone {
+		key, err := delivery.HaveKey(node, module)
+		if err != nil {
+			q.sayHave(fmt.Sprintf("module %q has no key in the have bucket: %v", module, err))
+			continue
+		}
+		if ctx.Err() != nil {
+			q.sayHave(fmt.Sprintf("the time for writing the have bucket ran out before %s; the next apply or look writes it", key))
+			return false
+		}
+		current, revision, err := b.Get(ctx, key)
+		switch {
+		case errors.Is(err, ErrHaveAbsent):
+			if !s.userListNoKey[module] {
+				if s.userListNoKey == nil {
+					s.userListNoKey = map[string]bool{}
+				}
+				s.userListNoKey[module] = true
+				q.sayHave(fmt.Sprintf("the bus's user list written for %s is in no have: %s does not exist and no apply on "+
+					"this node says %s's phase, so it is written once one does", module, key, module))
+			}
+			continue
+		case err != nil:
+			q.sayHave(fmt.Sprintf("could not read %s in the have bucket, and wrote nothing more there: %v", key, err))
+			q.haveFailed(err)
+			return false
+		}
+		delete(s.userListNoKey, module)
+		h, err := delivery.DecodeHave(current)
+		if err != nil {
+			q.sayHave(fmt.Sprintf("the bus's user list is not written in %s: its value cannot be read: %v", key, err))
+			continue
+		}
+		w := s.userList[module]
+		next := h
+		next.UserList = &w
+		if delivery.SameHave(h, next) {
+			continue
+		}
+		raw, err := delivery.EncodeHave(next)
+		if err != nil {
+			q.sayHave(fmt.Sprintf("cannot encode %s: %v", key, err))
+			continue
+		}
+		if err := b.Set(ctx, key, raw, revision); err != nil {
+			q.sayHave(fmt.Sprintf("could not write %s in the have bucket; the next apply or look writes it again: %v", key, err))
+			q.haveFailed(err)
+			return false
+		}
+	}
+	return true
+}
+
 // putHave reads a key and writes it unless same says it already holds the value. False when the pass should stop: the
 // bucket failed, the error is said once, and the rest wait for the next pass.
-func (q *Queue) putHave(ctx context.Context, b HaveBucket, key string, value []byte, same func([]byte) bool) bool {
+func (q *Session) putHave(ctx context.Context, b HaveBucket, key string, value []byte, same func([]byte) bool) bool {
 	if ctx.Err() != nil {
 		q.sayHave(fmt.Sprintf("the time for writing the have bucket ran out before %s; the next apply or look writes it", key))
 		return false
@@ -322,13 +621,253 @@ func (q *Queue) putHave(ctx context.Context, b HaveBucket, key string, value []b
 		revision = 0
 	case err != nil:
 		q.sayHave(fmt.Sprintf("could not read %s in the have bucket, and wrote nothing more there: %v", key, err))
+		q.haveFailed(err)
 		return false
 	case same(current):
+		q.haveWritten()
 		return true
 	}
 	if err := b.Set(ctx, key, value, revision); err != nil {
 		q.sayHave(fmt.Sprintf("could not write %s in the have bucket; the next apply or look writes it again: %v", key, err))
+		q.haveFailed(err)
 		return false
 	}
+	q.haveWritten()
 	return true
 }
+
+// haveWritten tells the caller this node-engine has a have key in the bucket saying what it says now: written by it, or
+// already holding the same. It is what proves a node-engine on trial to its launcher (novox/hq ADR 0539 §9): the first
+// have under its own build, not a declaration's report.
+func (q *Session) haveWritten() {
+	if q.HaveWritten != nil {
+		q.HaveWritten()
+	}
+}
+
+// NoteModule takes how one module's apply came out and writes its have where it differs from the bucket's (novox/hq ADR
+// 0539 §9): the node agent's word for a module, with the fingerprint and the digest it runs. It keeps the module's last
+// health, which a look changes without an apply.
+func (q *Session) NoteModule(ctx context.Context, f ModuleFact) {
+	q.init()
+	s := &q.haves
+	s.mu.Lock()
+	if s.modules == nil {
+		s.modules = map[string]ModuleFact{}
+	}
+	// A change under way, or a fact naming another composition than the one looked at, leaves the module's health not
+	// yet judged until a look after it: the last look judged what ran before (2026-10-25, the canary of the controller on
+	// novox held on a have saying applying and failed two seconds before its launch said healthy).
+	s.moved(f)
+	s.modules[f.Module] = f
+	delete(s.removed, f.Module)
+	// Out of motion and not judged: a look is owed now, not at the loop's next statement (review of fix 15, B1).
+	owe := !inMotion(f.Phase) && s.unjudged[f.Module]
+	s.mu.Unlock()
+	if owe {
+		q.oweHealth()
+	}
+	q.mu.Lock()
+	bus := q.bus
+	q.mu.Unlock()
+	q.writeHaves(ctx, bus)
+}
+
+// NoteUserList takes what the bus node's engine wrote of the bus's user list, and writes it in the bus module's have
+// where it differs from the bucket's (novox/hq ADR 0547 §8). A module this engine has said no have of yet carries it
+// from its first have on.
+func (q *Session) NoteUserList(ctx context.Context, module string, w delivery.UserListWritten) {
+	q.init()
+	s := &q.haves
+	s.mu.Lock()
+	if s.userList == nil {
+		s.userList = map[string]delivery.UserListWritten{}
+	}
+	s.userList[module] = w
+	s.mu.Unlock()
+	q.mu.Lock()
+	bus := q.bus
+	q.mu.Unlock()
+	q.writeHaves(ctx, bus)
+}
+
+// NoteRemoved takes that a module's own resources were removed, and writes its have with the phase removed once (issue
+// 1369): the key is never deleted.
+func (q *Session) NoteRemoved(ctx context.Context, module, build string) {
+	q.init()
+	s := &q.haves
+	s.mu.Lock()
+	if s.removed == nil {
+		s.removed = map[string]string{}
+	}
+	if f, ok := s.modules[module]; ok && build == "" {
+		build = f.Build
+	}
+	s.removed[module] = build
+	delete(s.modules, module)
+	delete(s.written, module)
+	delete(s.unjudged, module)
+	s.mu.Unlock()
+	q.mu.Lock()
+	bus := q.bus
+	q.mu.Unlock()
+	q.writeHaves(ctx, bus)
+}
+
+// NoteNode takes the digest of the node's own composition it runs and the values it carries sealed to the node's key
+// (nil for a composition the node did not make itself), and writes the node's key where it differs.
+func (q *Session) NoteNode(ctx context.Context, composed string, sealed delivery.Seals) {
+	q.init()
+	s := &q.haves
+	s.mu.Lock()
+	s.nodeComposed = composed
+	s.nodeSealed = sealed
+	if s.node == nil {
+		n := delivery.HaveNode{V: delivery.Version}
+		s.node = &n
+	}
+	s.mu.Unlock()
+	q.mu.Lock()
+	bus := q.bus
+	q.mu.Unlock()
+	q.writeHaves(ctx, bus)
+}
+
+// NoteCandidates takes the node's answers to the placement candidates, by proposal (its shadow composer's, novox/hq ADR
+// 0559 §4), and writes the node's key where it differs; a proposal left out is no longer answered.
+func (q *Session) NoteCandidates(ctx context.Context, answers map[string]delivery.CandidateAnswer) {
+	q.init()
+	s := &q.haves
+	s.mu.Lock()
+	s.nodeCandidates = answers
+	if len(answers) == 0 {
+		s.nodeCandidates = nil
+	}
+	// Before the node's facts are first said, its key is not written for an answer alone: it would carry no record. The
+	// answers ride with the first facts.
+	known := s.node != nil
+	s.mu.Unlock()
+	if !known {
+		return
+	}
+	q.mu.Lock()
+	bus := q.bus
+	q.mu.Unlock()
+	q.writeHaves(ctx, bus)
+}
+
+// NoteComposes says, in the node's own key, whose compositions the node applies (delivery.ComposesOwn or
+// delivery.ComposesController) and why: written at each start of its agent, so a node returning to the controller's
+// compositions says so where every have is read (issue 1126).
+func (q *Session) NoteComposes(ctx context.Context, composes, why string) {
+	q.init()
+	s := &q.haves
+	s.mu.Lock()
+	changed := s.nodeComposes != composes || s.nodeComposesWhy != why
+	s.nodeComposes, s.nodeComposesWhy = composes, why
+	known := s.node != nil
+	s.mu.Unlock()
+	if !known || !changed {
+		return // said with the node's first facts
+	}
+	q.mu.Lock()
+	bus := q.bus
+	q.mu.Unlock()
+	q.writeHaves(ctx, bus)
+}
+
+// ReadNodeHave is the node's own key as the bucket holds it, and whether it holds one: what the node's own composition
+// it last ran is and carries sealed, read after a restart (ADR 0547 §3).
+func (q *Session) ReadNodeHave(ctx context.Context) (delivery.HaveNode, bool) {
+	n, ok, _ := q.ReadNodeHaveErr(ctx)
+	return n, ok
+}
+
+// ReadNodeHaveErr is ReadNodeHave telling the key absent (false, nil) from one that could not be read (false, the
+// error): a bus that did not answer is never kept as a node that ran nothing (issue 1126, 2026-10-28).
+func (q *Session) ReadNodeHaveErr(ctx context.Context) (delivery.HaveNode, bool, error) {
+	q.init()
+	q.mu.Lock()
+	bus := q.bus
+	q.mu.Unlock()
+	hb, ok := bus.(HaveBus)
+	if !ok || bus == nil {
+		return delivery.HaveNode{}, false, ErrNotLinkedHaves
+	}
+	key, err := delivery.HaveNodeKey(q.Membership.Node)
+	if err != nil {
+		return delivery.HaveNode{}, false, err
+	}
+	read, cancel := context.WithTimeout(ctx, q.timeout())
+	defer cancel()
+	bucket, err := hb.HaveBind(read)
+	if err != nil {
+		return delivery.HaveNode{}, false, err
+	}
+	value, _, err := bucket.Get(read, key)
+	if errors.Is(err, ErrHaveAbsent) {
+		return delivery.HaveNode{}, false, nil
+	}
+	if err != nil {
+		return delivery.HaveNode{}, false, err
+	}
+	n, err := delivery.DecodeHaveNode(value)
+	if err != nil {
+		return delivery.HaveNode{}, false, nil // a key no engine can read names nothing it runs
+	}
+	return n, true, nil
+}
+
+// ReadHave is the have this node-engine last wrote for a module, and whether the bucket holds one. A bucket that cannot
+// be read answers as none: the agent then compares with the declaration it kept, and applies only what differs.
+func (q *Session) ReadHave(ctx context.Context, module string) (delivery.Have, bool) {
+	h, ok, _ := q.ReadHaveErr(ctx, module)
+	return h, ok
+}
+
+// ErrNotLinkedHaves is a have read with no link to the bus open that can bind the have bucket.
+var ErrNotLinkedHaves = errors.New("no link to the bus that binds the have bucket is open")
+
+// ReadHaveErr is ReadHave telling a key absent (false, nil) from one that could not be read (false, the error): a bus
+// that does not answer for a moment is not a module that never ran (issue 1126).
+func (q *Session) ReadHaveErr(ctx context.Context, module string) (delivery.Have, bool, error) {
+	q.init()
+	q.mu.Lock()
+	bus := q.bus
+	q.mu.Unlock()
+	hb, ok := bus.(HaveBus)
+	if !ok || bus == nil {
+		return delivery.Have{}, false, ErrNotLinkedHaves
+	}
+	key, err := delivery.HaveKey(q.Membership.Node, module)
+	if err != nil {
+		return delivery.Have{}, false, err
+	}
+	read, cancel := context.WithTimeout(ctx, q.timeout())
+	defer cancel()
+	bucket, err := hb.HaveBind(read)
+	if err != nil {
+		return delivery.Have{}, false, err
+	}
+	value, _, err := bucket.Get(read, key)
+	if errors.Is(err, ErrHaveAbsent) {
+		return delivery.Have{}, false, nil
+	}
+	if err != nil {
+		return delivery.Have{}, false, err
+	}
+	h, err := delivery.DecodeHave(value)
+	if err != nil {
+		return delivery.Have{}, false, nil // a have no engine can read names nothing it runs
+	}
+	return h, true, nil
+}
+
+// nothingJudged is the health of a module a look judged no resource of: ok when it was looked at and the module applied
+// and runs (nothing of it could be down), unknown otherwise.
+func nothingJudged(f ModuleFact, looked bool) delivery.Health {
+	if looked && !f.Failed && (f.Phase == "" || f.Phase == string(delivery.PhaseRunning)) {
+		return delivery.HealthOK
+	}
+	return delivery.HealthUnknown
+}

internal/link/have_nats_integration_test.go

@@ -4,7 +4,6 @@ package link
 
 import (
 	"context"
-	"encoding/json"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -32,26 +31,20 @@ func TestNatsHavesAreWrittenOnceAndOnlyOnChange(t *testing.T) {
 		_ = kv.Purge(node + "." + name)
 	}
 
-	m, key := aMember(t)
+	m, _ := aMember(t)
 	m.Node = node
 	var failB atomic.Bool
-	var applied atomic.Int32
 	failB.Store(true)
-	apply := func(_ context.Context, raw, _ []byte) Report {
-		applied.Add(1)
-		var d struct{ Order }
-		_ = json.Unmarshal(raw, &d)
-		return Report{Declared: digest(raw), Order: d.Order, Applied: []string{"a.x", "b.x"},
+	facts := func() Report {
+		return Report{Applied: []string{"a.x", "b.x"},
 			Modules: []ModuleFact{{Module: "a", Build: "b-1"},
 				{Module: "b", Build: "b-2", Failed: failB.Load(), Detail: "b.x failed: no space"}},
 			Health:  healthOf(map[string]string{"a": StateHealthy, "b": StateHealthy}),
 			Windows: []Window{{Step: "backup", Holds: []string{"db"}}}}
 	}
-	q := aQueue(m, apply, &keptInMemory{})
-	q.attach(context.Background(), OverNATS{Conn: conn, JS: js})
-	ctx, stop := context.WithCancel(context.Background())
-	worker := runWorker(ctx, q)
-	defer func() { stop(); <-worker }()
+	q := &Session{Membership: m, Timeout: 2 * time.Second}
+	q.Attach(context.Background(), OverNATS{Conn: conn, JS: js})
+	ctx := context.Background()
 
 	revisions := func() map[string]uint64 {
 		out := map[string]uint64{}
@@ -62,14 +55,14 @@ func TestNatsHavesAreWrittenOnceAndOnlyOnChange(t *testing.T) {
 		}
 		return out
 	}
-	arrives := func(what string, id string, seq int64) {
-		want := applied.Load() + 1
-		q.Deliver(ordered(t, key, id, 7, seq))
-		eventually(t, what, func() bool { return applied.Load() >= want })
+	arrives := func(what string) {
+		if !q.SayFacts(ctx, facts()) {
+			t.Fatal(what + ": the facts were not taken")
+		}
 		time.Sleep(300 * time.Millisecond)
 	}
-	arrives("the first apply", "one", 1)
-	eventually(t, "the three keys were never written", func() bool { return len(revisions()) == 3 })
+	arrives("the first facts")
+	eventuallyHeld(t, "the three keys were never written", func() bool { return len(revisions()) == 3 })
 	first := revisions()
 
 	a, _ := kv.Get(node + ".a")
@@ -87,7 +80,7 @@ func TestNatsHavesAreWrittenOnceAndOnlyOnChange(t *testing.T) {
 		t.Fatalf("the node key holds %+v (%v)", hn, err)
 	}
 
-	arrives("the second apply", "two", 2)
+	arrives("the second facts")
 	time.Sleep(200 * time.Millisecond)
 	for name, rev := range revisions() {
 		if rev != first[name] {
@@ -96,8 +89,8 @@ func TestNatsHavesAreWrittenOnceAndOnlyOnChange(t *testing.T) {
 	}
 
 	failB.Store(false)
-	arrives("the third apply", "three", 3)
-	eventually(t, "b was never updated", func() bool { return revisions()["b"] > first["b"] })
+	arrives("the third facts")
+	eventuallyHeld(t, "b was never updated", func() bool { return revisions()["b"] > first["b"] })
 	if now := revisions(); now["a"] != first["a"] || now["node"] != first["node"] {
 		t.Errorf("a key that did not change moved: %v from %v", now, first)
 	}

internal/link/have_test.go

@@ -4,12 +4,15 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"strings"
 	"sync"
 	"testing"
 	"time"
 
+	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"github.com/nats-io/nats.go"
 )
 
 // What the node-engine writes beside its report: a module's have, and the node's own facts (novox/hq ADR 0429 §4,
@@ -26,6 +29,8 @@ type haveLink struct {
 	binds                int
 	setTries             int
 	bindFails, bindStuck bool
+	// bindNoResponders fails that many binds with the bus's no responders, as while it reloads its accounts.
+	bindNoResponders int
 }
 
 type haveEntry struct {
@@ -51,7 +56,14 @@ func (l *haveLink) HaveBind(ctx context.Context) (HaveBucket, error) {
 	l.hmu.Lock()
 	l.binds++
 	stuck, refuse := l.bindStuck, l.bindFails
+	reloading := l.bindNoResponders > 0
+	if reloading {
+		l.bindNoResponders--
+	}
 	l.hmu.Unlock()
+	if reloading {
+		return nil, fmt.Errorf("binding node-engine_have: %w", nats.ErrNoResponders)
+	}
 	if stuck {
 		<-ctx.Done()
 		return nil, ctx.Err()
@@ -126,20 +138,20 @@ func healthOf(states map[string]string) *Health {
 }
 
 func appliedModules() Report {
-	return Report{Declared: "d1", Applied: []string{"a.x", "b.x"},
+	return Report{Applied: []string{"a.x", "b.x"},
 		Modules: []ModuleFact{{Module: "a", Build: "b-1"}, {Module: "b", Build: "b-2", Failed: true, Detail: "b.x failed: no space"}},
 		Health:  healthOf(map[string]string{"a": StateHealthy, "b": StateUnhealthy})}
 }
 
-func aHaveQueue(l *haveLink) (*Queue, *[]string) {
+func aHaveQueue(l *haveLink) (*Session, *[]string) {
 	var said []string
 	var mu sync.Mutex
-	q := &Queue{Membership: Membership{Node: "n1"}, Timeout: time.Second, Say: func(s string) {
+	q := &Session{Membership: Membership{Node: "n1"}, Timeout: time.Second, Say: func(s string) {
 		mu.Lock()
 		said = append(said, s)
 		mu.Unlock()
 	}}
-	q.attach(context.Background(), l)
+	q.Attach(context.Background(), l)
 	return q, &said
 }
 
@@ -148,7 +160,7 @@ func aHaveQueue(l *haveLink) (*Queue, *[]string) {
 func TestAnAppliedModuleIsWrittenRunningAndAFailedOneFailed(t *testing.T) {
 	l := newHaveLink()
 	q, _ := aHaveQueue(l)
-	q.tell(context.Background(), appliedModules(), applied)
+	q.SayFacts(context.Background(), appliedModules())
 	a, b := l.have(t, "n1.a"), l.have(t, "n1.b")
 	if a.Phase != delivery.PhaseRunning || a.Build != "b-1" || a.Health != delivery.HealthOK {
 		t.Errorf("a: %+v", a)
@@ -168,7 +180,7 @@ func TestAHaveIsWrittenOnlyWhenItDiffers(t *testing.T) {
 	l.put(t, "n1.a", delivery.Have{V: delivery.Version, Build: "b-1", Phase: delivery.PhaseRunning, Health: delivery.HealthOK})
 	l.put(t, "n1.b", delivery.Have{V: delivery.Version, Build: "b-0", Phase: delivery.PhaseRunning, Health: delivery.HealthOK})
 	q, _ := aHaveQueue(l)
-	q.tell(context.Background(), appliedModules(), applied)
+	q.SayFacts(context.Background(), appliedModules())
 	if l.kv["n1.a"].rev != 1 {
 		t.Errorf("a equal to the bucket was written again, to revision %d", l.kv["n1.a"].rev)
 	}
@@ -176,7 +188,7 @@ func TestAHaveIsWrittenOnlyWhenItDiffers(t *testing.T) {
 		t.Errorf("b was not updated over its last revision: %+v at %d", l.have(t, "n1.b"), l.kv["n1.b"].rev)
 	}
 	before := l.setCount()
-	q.tell(context.Background(), appliedModules(), applied)
+	q.SayFacts(context.Background(), appliedModules())
 	if l.setCount() != before {
 		t.Errorf("an apply that changed nothing wrote %d keys", l.setCount()-before)
 	}
@@ -186,26 +198,36 @@ func TestAHaveIsWrittenOnlyWhenItDiffers(t *testing.T) {
 func TestAModulesHealthFollowsTheLook(t *testing.T) {
 	l := newHaveLink()
 	q, _ := aHaveQueue(l)
-	rep := Report{Declared: "d1", Modules: []ModuleFact{{Module: "a", Build: "b"}, {Module: "b", Build: "b"},
-		{Module: "c", Build: "b"}, {Module: "d", Build: "b"}}}
-	q.tell(context.Background(), rep, applied)
-	for _, m := range []string{"a", "b", "c", "d"} {
+	rep := Report{Modules: []ModuleFact{{Module: "a", Build: "b"}, {Module: "b", Build: "b"},
+		{Module: "c", Build: "b"}, {Module: "d", Build: "b"}, {Module: "e", Build: "b"}}}
+	q.SayFacts(context.Background(), rep)
+	for _, m := range []string{"a", "b", "c", "d", "e"} {
 		if h := l.have(t, "n1."+m).Health; h != delivery.HealthUnknown {
 			t.Errorf("%s with no look is %s, want unknown", m, h)
 		}
 	}
 	h := healthOf(map[string]string{"a": StateHealthy, "b": StateUnhealthy, "c": StateStarting})
+	h.Resources[slicesIndex(h.Resources, "b.server")].Reason = ReasonRestarting
+	// 1496: a directory used as found is not the module's health (e runs healthy beside one); a failed or waiting module's
+	// have says the words of the resource that made it so.
 	h.Resources = append(h.Resources, ResourceHealth{Module: "a", Resource: "a.two", State: StateWaiting},
-		ResourceHealth{Module: "b", Resource: "b.two", State: StateHealthy}, ResourceHealth{Module: "d", Resource: "d.x", State: StateUnknown})
+		ResourceHealth{Module: "b", Resource: "b.two", State: StateHealthy}, ResourceHealth{Module: "d", Resource: "d.x", State: StateUnknown},
+		ResourceHealth{Module: "e", Resource: "e.server", State: StateHealthy},
+		ResourceHealth{Module: "e", Resource: "e.cache", Kind: KindDirectory, State: StateUnhealthy, Reason: ReasonUsedAsFound + " owned by 1:1"})
 	if !q.SayHealth(context.Background(), *h) {
 		t.Fatal("not said")
 	}
 	for m, want := range map[string]delivery.Health{"a": delivery.HealthWaits, "b": delivery.HealthFailed,
-		"c": delivery.HealthWaits, "d": delivery.HealthUnknown} {
+		"c": delivery.HealthWaits, "d": delivery.HealthUnknown, "e": delivery.HealthOK} {
 		if got := l.have(t, "n1."+m).Health; got != want {
 			t.Errorf("%s is %s, want %s", m, got, want)
 		}
 	}
+	for m, want := range map[string]string{"a": "a.two waiting", "b": "b.server unhealthy: restarting", "d": "", "e": ""} {
+		if got := l.have(t, "n1."+m).Detail; got != want {
+			t.Errorf("%s says %q, want %q", m, got, want)
+		}
+	}
 	before := l.setCount()
 	h2 := *h
 	q.SayHealth(context.Background(), h2)
@@ -214,8 +236,8 @@ func TestAModulesHealthFollowsTheLook(t *testing.T) {
 	}
 	h2.Resources = []ResourceHealth{{Module: "a", Resource: "a.server", State: StateHealthy}}
 	q.SayHealth(context.Background(), h2)
-	if got := l.have(t, "n1.a").Health; got != delivery.HealthOK {
-		t.Errorf("a after a healthy look is %s", got)
+	if got := l.have(t, "n1.a"); got.Health != delivery.HealthOK || got.Detail != "" {
+		t.Errorf("a after a healthy look is %s, saying %q", got.Health, got.Detail)
 	}
 }
 
@@ -230,7 +252,7 @@ func TestTheReportIsSentFirstAndTheNodeKeyCarriesTheNodesFacts(t *testing.T) {
 	rep.Strays = []Stray{{Kind: "container", Name: "old"}}
 	rep.Filters = []Filter{{Where: "inet mesh", Owner: "mesh"}}
 	rep.Profile = map[string]any{"cores": 8}
-	q.tell(context.Background(), rep, applied)
+	q.SayFacts(context.Background(), rep)
 	if len(l.events) < 2 || l.events[0] != "report" {
 		t.Fatalf("the report was not first: %v", l.events)
 	}
@@ -248,6 +270,43 @@ func TestTheReportIsSentFirstAndTheNodeKeyCarriesTheNodesFacts(t *testing.T) {
 	if !delivery.SameHaveNode(got, want) {
 		t.Errorf("the node key holds %+v, want %+v", got, want)
 	}
+
+	// 1126 (ADR 0555 §3): with its keys, the node key carries the node's record: the profile's present capabilities and
+	// networks, the outward links, the health's contract and the public keys; a report that changes none of it writes
+	// nothing, a changed fact writes the key once, and a report without a profile or health leaves them standing.
+	keys := RecordKeys{TunnelKey: "tk", SealingKey: "sk", ServingKey: "pk", Certificate: "cert"}
+	q.Keys = func() RecordKeys { return keys }
+	rep.Profile = map[string]any{"capabilities": []any{map[string]any{"name": "systemd", "present": true},
+		map[string]any{"name": "docker", "present": false}, map[string]any{"name": "apt", "present": true}},
+		"machine": map[string]any{"networks": []any{map[string]any{"link": "eth0", "network": "192.0.2.0/24"}}}}
+	rep.Outward = []string{"eth0"}
+	rep.Health = &Health{Contract: NodeKeyContract}
+	q.SayFacts(context.Background(), rep)
+	if got, err = delivery.DecodeHaveNode(l.kv["n1.node"].value); err != nil || got.Record == nil {
+		t.Fatalf("the node key holds no record: %+v, %v", got, err)
+	}
+	wantRecord := delivery.NodeRecord{V: delivery.Version, Node: "n1", TunnelKey: "tk", SealingKey: "sk", ServingKey: "pk",
+		Certificate: "cert", Capabilities: []string{"apt", "systemd"}, OutwardLinks: []string{"eth0"}, NetworksSaid: true,
+		Networks: []catalogue.AttachedNetwork{{Link: "eth0", Network: "192.0.2.0/24"}}, Contract: NodeKeyContract}
+	if !delivery.SameNodeRecord(*got.Record, wantRecord) {
+		t.Errorf("record = %+v, want %+v", *got.Record, wantRecord)
+	}
+	at := l.kv["n1.node"].rev
+	q.SayFacts(context.Background(), rep)
+	if l.kv["n1.node"].rev != at {
+		t.Errorf("a report changing nothing wrote the node key again")
+	}
+	keys.Certificate = "cert-2"
+	q.SayFacts(context.Background(), rep)
+	if got, _ = delivery.DecodeHaveNode(l.kv["n1.node"].value); l.kv["n1.node"].rev != at+1 || got.Record.Certificate != "cert-2" {
+		t.Errorf("a new certificate: revision %d (was %d), record %+v", l.kv["n1.node"].rev, at, got.Record)
+	}
+	bare := rep
+	bare.Health = nil
+	q.SayFacts(context.Background(), bare)
+	if got, _ = delivery.DecodeHaveNode(l.kv["n1.node"].value); got.Record.Contract != NodeKeyContract {
+		t.Errorf("a report without a health statement dropped the contract: %+v", got.Record)
+	}
 }
 
 // 1132/AC7: a write the bucket refuses is said in the log; the report went out, and the next apply writes again.
@@ -255,7 +314,7 @@ func TestAFailedHaveWriteIsSaidAndNeverBlocksTheReport(t *testing.T) {
 	l := newHaveLink()
 	l.failing = true
 	q, said := aHaveQueue(l)
-	if !q.tell(context.Background(), appliedModules(), applied) {
+	if !q.SayFacts(context.Background(), appliedModules()) {
 		t.Fatal("the report did not go out")
 	}
 	if len(l.said()) != 1 {
@@ -267,7 +326,7 @@ func TestAFailedHaveWriteIsSaidAndNeverBlocksTheReport(t *testing.T) {
 	l.hmu.Lock()
 	l.failing = false
 	l.hmu.Unlock()
-	q.tell(context.Background(), appliedModules(), applied)
+	q.SayFacts(context.Background(), appliedModules())
 	if l.have(t, "n1.a").Phase != delivery.PhaseRunning {
 		t.Error("the next apply did not write again")
 	}
@@ -276,39 +335,19 @@ func TestAFailedHaveWriteIsSaidAndNeverBlocksTheReport(t *testing.T) {
 // A link without a bucket, and a report with no module facts (a refusal), write nothing and say nothing wrong.
 func TestNoBucketAndNoFactsWriteNothing(t *testing.T) {
 	plain := newQuietLink()
-	q := &Queue{Membership: Membership{Node: "n1"}, Timeout: time.Second}
-	q.attach(context.Background(), plain)
-	if !q.tell(context.Background(), appliedModules(), applied) {
+	q := &Session{Membership: Membership{Node: "n1"}, Timeout: time.Second}
+	q.Attach(context.Background(), plain)
+	if !q.SayFacts(context.Background(), appliedModules()) {
 		t.Fatal("the report did not go out")
 	}
 	l := newHaveLink()
 	q2, _ := aHaveQueue(l)
-	q2.tell(context.Background(), Report{Refused: "no"}, applied)
+	q2.SayFacts(context.Background(), Report{Refused: "no"})
 	if l.setCount() != 0 {
 		t.Errorf("a refusal wrote %d keys", l.setCount())
 	}
 }
 
-// 1132/AC5: a reconcile whose report is not news still writes the have keys that differ, so a node-engine that
-// restarted writes them again; and writes nothing when they are the same.
-func TestASilentReconcileStillWritesTheHaves(t *testing.T) {
-	l := newHaveLink()
-	q, _ := aHaveQueue(l)
-	q.Reconcile = func(context.Context) (Report, bool) { return appliedModules(), true }
-	q.reconcile(context.Background(), false)
-	if len(l.said()) != 0 {
-		t.Fatalf("a reconcile that is not news said %d reports", len(l.said()))
-	}
-	if l.have(t, "n1.a").Phase != delivery.PhaseRunning {
-		t.Error("the reconcile wrote no have")
-	}
-	before := l.setCount()
-	q.reconcile(context.Background(), false)
-	if l.setCount() != before {
-		t.Errorf("an unchanged reconcile wrote %d keys", l.setCount()-before)
-	}
-}
-
 // 1132/AC7: a bind that fails, or never answers, writes nothing and returns within the queue's timeout; a write that
 // fails ends the pass, and is said once.
 func TestAFailedBindOrWriteEndsThePassAndReturnsInTime(t *testing.T) {
@@ -321,7 +360,7 @@ func TestAFailedBindOrWriteEndsThePassAndReturnsInTime(t *testing.T) {
 		q, said := aHaveQueue(l)
 		q.Timeout = 100 * time.Millisecond
 		start := time.Now()
-		if !q.tell(context.Background(), appliedModules(), applied) {
+		if !q.SayFacts(context.Background(), appliedModules()) {
 			t.Fatalf("%s: the report did not go out", name)
 		}
 		if took := time.Since(start); took > time.Second {
@@ -334,14 +373,32 @@ func TestAFailedBindOrWriteEndsThePassAndReturnsInTime(t *testing.T) {
 	l := newHaveLink()
 	l.failing = true
 	q, said := aHaveQueue(l)
-	q.tell(context.Background(), appliedModules(), applied)
+	q.SayFacts(context.Background(), appliedModules())
 	if l.binds != 1 || l.setTries != 1 || len(*said) != 1 {
 		t.Errorf("a failed write: binds %d, writes tried %d, said %v; want one of each and one line", l.binds, l.setTries, *said)
 	}
+	// A bind that meets no responders while the bus reloads its accounts (2026-10-25 23:04:24, four in one second on the
+	// bus node) is written again after a backoff, with no apply or look to come.
+	defer func(was func(int) time.Duration) { haveBackoff = was }(haveBackoff)
+	haveBackoff = func(int) time.Duration { return time.Millisecond }
+	l = newHaveLink()
+	l.bindNoResponders = 1
+	q, _ = aHaveQueue(l)
+	q.SayFacts(context.Background(), appliedModules())
+	deadline := time.Now().Add(3 * time.Second)
+	for l.setCount() == 0 && time.Now().Before(deadline) {
+		time.Sleep(5 * time.Millisecond)
+	}
+	if l.setCount() == 0 {
+		t.Fatal("a bind that met no responders was not written again")
+	}
+	if l.have(t, "n1.a").Phase != delivery.PhaseRunning {
+		t.Error("the have written again does not say running")
+	}
 }
 
 func onlyA() Report {
-	return Report{Declared: "d2", Applied: []string{"a.x"}, Modules: []ModuleFact{{Module: "a", Build: "b-1"}},
+	return Report{Applied: []string{"a.x"}, Modules: []ModuleFact{{Module: "a", Build: "b-1"}},
 		Health: healthOf(map[string]string{"a": StateHealthy})}
 }
 
@@ -350,9 +407,9 @@ func onlyA() Report {
 func TestAModuleLeavingTheDeclarationIsWrittenRemoved(t *testing.T) {
 	l := newHaveLink()
 	q, _ := aHaveQueue(l)
-	q.tell(context.Background(), appliedModules(), applied)
+	q.SayFacts(context.Background(), appliedModules())
 	revA, revB := l.kv["n1.a"].rev, l.kv["n1.b"].rev
-	q.tell(context.Background(), onlyA(), applied)
+	q.SayFacts(context.Background(), onlyA())
 	b := l.have(t, "n1.b")
 	if b.Phase != delivery.PhaseRemoved || b.Build != "b-2" {
 		t.Errorf("b: %+v", b)
@@ -364,7 +421,7 @@ func TestAModuleLeavingTheDeclarationIsWrittenRemoved(t *testing.T) {
 		t.Errorf("a changed: %+v at %d", l.have(t, "n1.a"), l.kv["n1.a"].rev)
 	}
 	before := l.setCount()
-	q.tell(context.Background(), onlyA(), applied)
+	q.SayFacts(context.Background(), onlyA())
 	if l.setCount() != before {
 		t.Errorf("a second apply without b wrote %d keys, removed is written once", l.setCount()-before)
 	}
@@ -374,13 +431,13 @@ func TestAModuleLeavingTheDeclarationIsWrittenRemoved(t *testing.T) {
 func TestARemovedModuleAddedBackIsWrittenWithItsNewPhase(t *testing.T) {
 	l := newHaveLink()
 	q, _ := aHaveQueue(l)
-	q.tell(context.Background(), appliedModules(), applied)
-	q.tell(context.Background(), onlyA(), applied)
-	q.tell(context.Background(), appliedModules(), applied)
+	q.SayFacts(context.Background(), appliedModules())
+	q.SayFacts(context.Background(), onlyA())
+	q.SayFacts(context.Background(), appliedModules())
 	if b := l.have(t, "n1.b"); b.Phase != delivery.PhaseFailed || b.Build != "b-2" {
 		t.Errorf("b after it came back: %+v", b)
 	}
-	q.tell(context.Background(), onlyA(), applied)
+	q.SayFacts(context.Background(), onlyA())
 	if b := l.have(t, "n1.b"); b.Phase != delivery.PhaseRemoved {
 		t.Errorf("b removed again: %+v", b)
 	}
@@ -392,19 +449,19 @@ func TestAModuleNeverWrittenIsNotWrittenRemoved(t *testing.T) {
 	l := newHaveLink()
 	l.put(t, "n1.c", delivery.Have{V: delivery.Version, Build: "b-9", Phase: delivery.PhaseRunning, Health: delivery.HealthOK})
 	q, _ := aHaveQueue(l)
-	q.tell(context.Background(), appliedModules(), applied)
-	q.tell(context.Background(), onlyA(), applied)
+	q.SayFacts(context.Background(), appliedModules())
+	q.SayFacts(context.Background(), onlyA())
 	if c := l.have(t, "n1.c"); c.Phase != delivery.PhaseRunning || l.kv["n1.c"].rev != 1 {
 		t.Errorf("c, which this node-engine never wrote, changed: %+v at %d", c, l.kv["n1.c"].rev)
 	}
 	// a key that vanished from the bucket is not created by the removal
 	l2 := newHaveLink()
 	q2, _ := aHaveQueue(l2)
-	q2.tell(context.Background(), appliedModules(), applied)
+	q2.SayFacts(context.Background(), appliedModules())
 	l2.hmu.Lock()
 	delete(l2.kv, "n1.b")
 	l2.hmu.Unlock()
-	q2.tell(context.Background(), onlyA(), applied)
+	q2.SayFacts(context.Background(), onlyA())
 	if _, there := l2.kv["n1.b"]; there {
 		t.Error("the removal created a key that was not there")
 	}
@@ -414,15 +471,15 @@ func TestAModuleNeverWrittenIsNotWrittenRemoved(t *testing.T) {
 func TestARefusedRemovalIsWrittenByTheNextPass(t *testing.T) {
 	l := newHaveLink()
 	q, _ := aHaveQueue(l)
-	q.tell(context.Background(), appliedModules(), applied)
+	q.SayFacts(context.Background(), appliedModules())
 	l.hmu.Lock()
 	l.failing = true
 	l.hmu.Unlock()
-	q.tell(context.Background(), onlyA(), applied)
+	q.SayFacts(context.Background(), onlyA())
 	l.hmu.Lock()
 	l.failing = false
 	l.hmu.Unlock()
-	q.tell(context.Background(), onlyA(), applied)
+	q.SayFacts(context.Background(), onlyA())
 	if b := l.have(t, "n1.b"); b.Phase != delivery.PhaseRemoved {
 		t.Errorf("b: %+v", b)
 	}
@@ -437,7 +494,7 @@ func TestARestartedNodeEngineWritesTheRemovalFromTheReportsBefore(t *testing.T)
 	q, _ := aHaveQueue(l) // fresh: nothing written by this process
 	r := onlyA()
 	r.Before = []string{"a", "b", "c"}
-	q.tell(context.Background(), r, applied)
+	q.SayFacts(context.Background(), r)
 	if b := l.have(t, "n1.b"); b.Phase != delivery.PhaseRemoved {
 		t.Errorf("b: %+v", b)
 	}
@@ -448,3 +505,283 @@ func TestARestartedNodeEngineWritesTheRemovalFromTheReportsBefore(t *testing.T)
 		t.Errorf("a was written, revision %d", l.kv["n1.a"].rev)
 	}
 }
+
+// R6-A AC7: the first have this node-engine writes — or finds already saying what it would write — is told to the
+// proof, which proves a node-engine on trial to its launcher (novox/hq ADR 0539 §9); a write the bucket refuses is not.
+func TestTheFirstHaveWrittenIsToldToTheProof(t *testing.T) {
+	l := newHaveLink()
+	l.failing = true
+	q, _ := aHaveQueue(l)
+	var told int
+	q.HaveWritten = func() { told++ }
+	q.SayFacts(context.Background(), appliedModules())
+	if told != 0 {
+		t.Fatalf("a refused write proved the build %d time(s)", told)
+	}
+	l.hmu.Lock()
+	l.failing = false
+	l.hmu.Unlock()
+	q.SayFacts(context.Background(), appliedModules())
+	if told == 0 {
+		t.Fatal("a have written under this build was not told")
+	}
+
+	// The bucket already holds what this node-engine would write: a restart with nothing changed still proves it.
+	same := newHaveLink()
+	q2, _ := aHaveQueue(same)
+	q2.SayFacts(context.Background(), appliedModules())
+	again, _ := aHaveQueue(same)
+	told = 0
+	again.HaveWritten = func() { told++ }
+	again.SayFacts(context.Background(), appliedModules())
+	if told == 0 {
+		t.Fatal("a have already saying the same was not told")
+	}
+}
+
+// R6-A AC6: an applied module's have names its fingerprint and the digest of the composition applied; a health check that
+// fails after the module's start window gives health failed, and the have keeps both.
+func TestAnAppliedModulesHaveNamesTheFingerprintAndTheDigestAndFollowsItsHealth(t *testing.T) {
+	l := newHaveLink()
+	q, _ := aHaveQueue(l)
+	fp := "src2:" + strings.Repeat("a", 64)
+	dig := "sha256:" + strings.Repeat("b", 64)
+	q.NoteModule(context.Background(), ModuleFact{Module: "web", FP: fp, Composed: dig})
+	h := l.have(t, "n1.web")
+	if h.FP != fp || h.Composed != dig || h.Phase != delivery.PhaseRunning || h.Health != delivery.HealthUnknown {
+		t.Fatalf("the have after the apply: %+v", h)
+	}
+	// Starting: it waits. Past its start window the check fails: failed.
+	q.SayHealth(context.Background(), *healthOf(map[string]string{"web": StateStarting}))
+	if got := l.have(t, "n1.web"); got.Health != delivery.HealthWaits || got.FP != fp || got.Composed != dig {
+		t.Fatalf("while it starts: %+v", got)
+	}
+	q.SayHealth(context.Background(), *healthOf(map[string]string{"web": StateUnhealthy}))
+	if got := l.have(t, "n1.web"); got.Health != delivery.HealthFailed || got.FP != fp || got.Composed != dig {
+		t.Fatalf("a failing check after the start window: %+v", got)
+	}
+
+	// The bus's user list written alone rides on the module's have, and an apply after it keeps it (ADR 0547 §8).
+	w := delivery.UserListWritten{Source: "n1.web." + fp, Revision: 4, Wanted: dig, Digest: dig, Users: 3,
+		At: time.Date(2026, 10, 25, 21, 0, 0, 0, time.UTC)}
+	q.NoteUserList(context.Background(), "web", w)
+	if got := l.have(t, "n1.web"); got.UserList == nil || got.UserList.Revision != 4 || got.FP != fp {
+		t.Fatalf("the user list is not in the have: %+v", got)
+	}
+	q.NoteModule(context.Background(), ModuleFact{Module: "web", FP: fp, Composed: dig})
+	if got := l.have(t, "n1.web"); got.UserList == nil || got.UserList.Users != 3 {
+		t.Fatalf("an apply lost the user list: %+v", got)
+	}
+
+	// A module held for a failed backup says so and what it keeps running; removed is written once, over its key.
+	q.NoteModule(context.Background(), ModuleFact{Module: "web", FP: fp, Composed: dig, Phase: string(delivery.PhaseHeld), Detail: "the repository is locked"})
+	if got := l.have(t, "n1.web"); got.Phase != delivery.PhaseHeld || got.Detail == "" {
+		t.Fatalf("held: %+v", got)
+	}
+	q.NoteRemoved(context.Background(), "web", "")
+	if got := l.have(t, "n1.web"); got.Phase != delivery.PhaseRemoved {
+		t.Fatalf("removed: %+v", got)
+	}
+	q.NoteNode(context.Background(), dig, delivery.Seals{"core-box#sealed": "core"})
+	if n, err := delivery.DecodeHaveNode(l.kv["n1.node"].value); err != nil || n.Composed != dig || len(n.SealedAt) != 1 || n.SealedAt["core-box#sealed"] != "core" {
+		t.Fatalf("the node key, with its own composition's sealed values by slot: %+v %v", n, err)
+	}
+	if n, ok := q.ReadNodeHave(context.Background()); !ok || n.Composed != dig || len(n.SealedAt) != 1 {
+		t.Fatalf("the node key read back: %+v %v", n, ok)
+	}
+	// The node's answers to placement candidates ride in the same key (ADR 0559 §4), and go when no group is answered.
+	answers := map[string]delivery.CandidateAnswer{"p-1": {Proposal: "p-1", Revision: 1, Verdict: delivery.CandidateSame, Same: []string{"web"}}}
+	q.NoteCandidates(context.Background(), answers)
+	if n, err := delivery.DecodeHaveNode(l.kv["n1.node"].value); err != nil || n.Candidates["p-1"].Proposal != "p-1" || n.Composed != dig {
+		t.Fatalf("the node key with its answers: %+v %v", n, err)
+	}
+	q.NoteCandidates(context.Background(), nil)
+	if n, _ := delivery.DecodeHaveNode(l.kv["n1.node"].value); n.Candidates != nil {
+		t.Fatalf("an answer left after its group went: %+v", n.Candidates)
+	}
+}
+
+// A module applied and running that has nothing long-running to judge is ok once the engine has looked: there is nothing
+// of it that could be down. Unknown kept it from ever being healthy, so the assigner's canary rule held every other node
+// of mesh-host back for good (issue 1945, live on 2026-10-25: ace's have of mesh-host said unknown, and novox and shanks
+// never got the new node-engine). A failed one stays failed, and before any look it is unknown.
+func TestAModuleWithNothingToJudgeIsOkOnceLookedAt(t *testing.T) {
+	l := newHaveLink()
+	q, _ := aHaveQueue(l)
+	q.SayFacts(context.Background(), Report{Modules: []ModuleFact{{Module: "mesh-host", Build: "b"}, {Module: "web", Build: "b"},
+		{Module: "broken", Build: "b", Failed: true, Detail: "x"}}})
+	if h := l.have(t, "n1.mesh-host").Health; h != delivery.HealthUnknown {
+		t.Fatalf("before any look: %s", h)
+	}
+	if !q.SayHealth(context.Background(), *healthOf(map[string]string{"web": StateHealthy})) {
+		t.Fatal("not said")
+	}
+	if h := l.have(t, "n1.mesh-host").Health; h != delivery.HealthOK {
+		t.Fatalf("a running module with nothing to judge after a look: %s", h)
+	}
+	if h := l.have(t, "n1.broken").Health; h == delivery.HealthOK {
+		t.Fatalf("a failed module was said ok")
+	}
+}
+
+// A have an older engine left unknown is written over with this engine's health once the module is said again, as the
+// node agent says a module it finds running on its own have: a packages-only module (xorg, nothing long-running) is ok
+// after a look, so the assigner no longer holds back what requires its provision (2026-10-25, g14 and shanks).
+func TestAModuleSaidAgainOverAnOlderEnginesUnknownIsWrittenWithThisEnginesHealth(t *testing.T) {
+	l := newHaveLink()
+	fp := "src2:" + strings.Repeat("a", 64)
+	dig := "sha256:" + strings.Repeat("b", 64)
+	l.put(t, "n1.xorg", delivery.Have{V: delivery.Version, FP: fp, Composed: dig, Phase: delivery.PhaseRunning,
+		Health: delivery.HealthUnknown})
+	q, _ := aHaveQueue(l)
+	if !q.SayHealth(context.Background(), *healthOf(map[string]string{"web": StateHealthy})) {
+		t.Fatal("not said")
+	}
+	if h := l.have(t, "n1.xorg"); h.Health != delivery.HealthUnknown {
+		t.Fatalf("a module the session does not hold was written: %+v", h)
+	}
+	q.NoteModule(context.Background(), ModuleFact{Module: "xorg", FP: fp, Composed: dig})
+	if h := l.have(t, "n1.xorg"); h.Health != delivery.HealthOK || h.FP != fp || h.Composed != dig || h.Phase != delivery.PhaseRunning {
+		t.Fatalf("said again after a look: %+v", h)
+	}
+}
+
+// A module's health is not yet judged (unknown) while its change is under way and until a look after it, never failed
+// from a look at what was being replaced: on 2026-10-25 15:27:36 the controller's canary on novox was held on a have
+// saying applying and failed, two seconds before its launch said healthy.
+func TestAHealthIsNotJudgedWhileAModuleIsApplied(t *testing.T) {
+	l := newHaveLink()
+	q, _ := aHaveQueue(l)
+	ctx := context.Background()
+	old := ModuleFact{Module: "ctl", FP: "src2:" + strings.Repeat("a", 64), Composed: "sha256:" + strings.Repeat("1", 64)}
+	q.NoteModule(ctx, old)
+	q.SayHealth(ctx, *healthOf(map[string]string{"ctl": StateUnhealthy}))
+	if h := l.have(t, "n1.ctl"); h.Health != delivery.HealthFailed {
+		t.Fatalf("the running module's failed look was not said: %+v", h)
+	}
+	next := ModuleFact{Module: "ctl", FP: "src2:" + strings.Repeat("b", 64), Composed: "sha256:" + strings.Repeat("2", 64)}
+	applying := next
+	applying.Phase = string(delivery.PhaseApplying)
+	q.NoteModule(ctx, applying)
+	if h := l.have(t, "n1.ctl"); h.Phase != delivery.PhaseApplying || h.Health != delivery.HealthUnknown {
+		t.Fatalf("applying carried the last look's health: %+v", h)
+	}
+	q.SayHealth(ctx, *healthOf(map[string]string{"ctl": StateUnhealthy}))
+	if h := l.have(t, "n1.ctl"); h.Health != delivery.HealthUnknown {
+		t.Fatalf("a look during the apply judged it: %+v", h)
+	}
+	q.NoteModule(ctx, next)
+	if h := l.have(t, "n1.ctl"); h.Phase != delivery.PhaseRunning || h.Health != delivery.HealthUnknown {
+		t.Fatalf("running before a look after the apply: %+v", h)
+	}
+	q.SayHealth(ctx, *healthOf(map[string]string{"ctl": StateHealthy}))
+	if h := l.have(t, "n1.ctl"); h.Health != delivery.HealthOK {
+		t.Fatalf("the look after the apply was not taken: %+v", h)
+	}
+}
+
+// A fact naming another composition than the one looked at, with no apply phase between, is not judged by the old look.
+func TestAHealthIsNotCarriedOverToAnotherComposition(t *testing.T) {
+	l := newHaveLink()
+	q, _ := aHaveQueue(l)
+	ctx := context.Background()
+	q.NoteModule(ctx, ModuleFact{Module: "ctl", FP: "src2:" + strings.Repeat("a", 64)})
+	q.SayHealth(ctx, *healthOf(map[string]string{"ctl": StateUnhealthy}))
+	q.NoteModule(ctx, ModuleFact{Module: "ctl", FP: "src2:" + strings.Repeat("b", 64)})
+	if h := l.have(t, "n1.ctl"); h.Health != delivery.HealthUnknown {
+		t.Fatalf("the old composition's look judged the new one: %+v", h)
+	}
+}
+
+// A declaration's report naming another composition of a module, with no health of its own, does not carry the old
+// look's health over; and a module removed leaves nothing marked unjudged behind.
+func TestADeclarationReportMovesAHealthAndARemovalForgetsIt(t *testing.T) {
+	l := newHaveLink()
+	q, _ := aHaveQueue(l)
+	ctx := context.Background()
+	q.SayFacts(ctx, Report{Applied: []string{"a.x"}, Modules: []ModuleFact{{Module: "a", Build: "b-1"}},
+		Health: healthOf(map[string]string{"a": StateUnhealthy})})
+	if h := l.have(t, "n1.a"); h.Health != delivery.HealthFailed {
+		t.Fatalf("the failed look was not said: %+v", h)
+	}
+	q.SayFacts(ctx, Report{Applied: []string{"a.x"}, Modules: []ModuleFact{{Module: "a", Build: "b-1", FP: "src2:" + strings.Repeat("c", 64)}}})
+	if h := l.have(t, "n1.a"); h.Health != delivery.HealthUnknown {
+		t.Fatalf("the old composition's look judged the new one: %+v", h)
+	}
+	select {
+	case <-q.HealthOwed():
+	default:
+		t.Fatal("a module out of motion and unjudged owed no look")
+	}
+	q.NoteRemoved(ctx, "a", "")
+	q.haves.mu.Lock()
+	left := q.haves.unjudged["a"]
+	q.haves.mu.Unlock()
+	if left {
+		t.Fatal("a removed module is still marked unjudged")
+	}
+}
+
+// ADR 0547 §8, 2026-10-26 on the bus node: the bus's user list of a module this engine says no have of (no want, and no
+// longer in the declaration) still reaches the module's key, merged into what the key says, every other field kept; a
+// key that does not exist is not made up and is said once; a writer that drops the list again is written over.
+func TestAUserListReachesTheHaveOfAModuleNoApplyHereSays(t *testing.T) {
+	l := newHaveLink()
+	older := delivery.Have{V: delivery.Version, Build: "build-1", Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
+	l.put(t, "n1.nats", older)
+	q, said := aHaveQueue(l)
+	dig := "sha256:" + strings.Repeat("c", 64)
+	w := delivery.UserListWritten{Source: "n1.nats", Revision: 7, Wanted: dig, Digest: dig, Users: 58,
+		At: time.Date(2026, 10, 26, 12, 26, 51, 0, time.UTC)}
+	q.NoteUserList(context.Background(), "nats", w)
+	got := l.have(t, "n1.nats")
+	if got.UserList == nil || got.UserList.Users != 58 || got.UserList.Digest != dig {
+		t.Fatalf("the user list is not in the have: %+v", got)
+	}
+	if got.Build != "build-1" || got.Phase != delivery.PhaseRunning || got.Health != delivery.HealthOK {
+		t.Fatalf("the merge lost the key's own fields: %+v", got)
+	}
+	rev := l.kv["n1.nats"].rev
+	q.NoteUserList(context.Background(), "nats", w)
+	if l.kv["n1.nats"].rev != rev {
+		t.Errorf("the same list was written again, to revision %d", l.kv["n1.nats"].rev)
+	}
+
+	// Another writer replaces the value without the list: the next pass merges it back.
+	l.put(t, "n1.nats", older)
+	q.SayFacts(context.Background(), Report{})
+	if got := l.have(t, "n1.nats"); got.UserList == nil || got.Build != "build-1" {
+		t.Fatalf("a value written without the list kept it out: %+v", got)
+	}
+
+	// No key at all: nothing is created, said once; the module's first have carries the list.
+	q.NoteUserList(context.Background(), "other", w)
+	q.NoteUserList(context.Background(), "other", w)
+	if _, ok := l.kv["n1.other"]; ok {
+		t.Fatalf("a have was made up for a module no apply says")
+	}
+	n := 0
+	for _, s := range *said {
+		if strings.Contains(s, "is in no have") {
+			n++
+		}
+	}
+	if n != 1 {
+		t.Errorf("the missing key was said %d times: %q", n, *said)
+	}
+	fp := "src2:" + strings.Repeat("a", 64)
+	q.NoteModule(context.Background(), ModuleFact{Module: "other", FP: fp, Composed: dig})
+	if got := l.have(t, "n1.other"); got.UserList == nil || got.FP != fp {
+		t.Fatalf("the first have of the module lost the list: %+v", got)
+	}
+}
+
+// slicesIndex is the index of the resource with id in rs, or -1.
+func slicesIndex(rs []ResourceHealth, id string) int {
+	for i, r := range rs {
+		if r.Resource == id {
+			return i
+		}
+	}
+	return -1
+}

internal/link/health_test.go

@@ -23,14 +23,14 @@ func (l *sayingLink) Health(_ context.Context, node string, body []byte) error {
 }
 
 func TestAHealthStatementIsSaidOnTheLinkOpenNow(t *testing.T) {
-	q := &Queue{Membership: Membership{Node: "anchor"}}
+	q := &Session{Membership: Membership{Node: "anchor"}}
 	h := Health{Contract: LivenessContract, At: time.Now().UTC(),
 		Resources: []ResourceHealth{{Module: "letta", Resource: "letta.server", State: StateUnhealthy, Reason: ReasonRestarting}}}
 	if q.SayHealth(t.Context(), h) {
 		t.Fatal("said with no link open")
 	}
 	l := &sayingLink{quietLink: newQuietLink()}
-	q.attach(t.Context(), l)
+	q.Attach(t.Context(), l)
 	if !q.SayHealth(t.Context(), h) || len(l.said) != 1 {
 		t.Fatalf("not said on the open link: %d", len(l.said))
 	}
@@ -42,8 +42,8 @@ func TestAHealthStatementIsSaidOnTheLinkOpenNow(t *testing.T) {
 		t.Fatalf("said %+v", got)
 	}
 	// A link that cannot say it is not an error: the next report carries the statement.
-	q.detach(l)
-	q.attach(t.Context(), newQuietLink())
+	q.Detach(l)
+	q.Attach(t.Context(), newQuietLink())
 	if q.SayHealth(t.Context(), h) {
 		t.Fatal("said on a link that cannot")
 	}
@@ -77,22 +77,22 @@ func TestAToolsAnswerIsHealthyOnlyWhenItSaysSo(t *testing.T) {
 // the link was up, because the NATS link could not Ask). With no link open, and with a link that cannot
 // ask, the check fails and says which.
 func TestAToolCheckIsAskedOnTheLinkTheEngineHolds(t *testing.T) {
-	q := &Queue{Membership: Membership{Node: "anchor"}}
+	q := &Session{Membership: Membership{Node: "anchor"}}
 	if _, err := q.AskTool(t.Context(), "sensors", "sensors_health"); err == nil || err.Error() != "no link to the bus is open" {
 		t.Fatalf("with no link open: %v", err)
 	}
 
 	quiet := newQuietLink()
-	q.attach(t.Context(), quiet)
+	q.Attach(t.Context(), quiet)
 	if _, err := q.AskTool(t.Context(), "sensors", "sensors_health"); err == nil || err.Error() != "the link to the bus open now cannot ask a tool" {
 		t.Fatalf("on a link that cannot ask: %v", err)
 	}
-	q.detach(quiet)
+	q.Detach(quiet)
 
 	// The link Open returns, with no connection under it: the question must reach its Ask (and fail
 	// there), never stop at the queue's assertion.
 	held := &natsLink{node: "anchor"}
-	q.attach(t.Context(), held)
+	q.Attach(t.Context(), held)
 	_, err := q.AskTool(t.Context(), "sensors", "sensors_health")
 	if err == nil {
 		t.Fatal("asked on no connection and was answered")

internal/link/hearing.go

@@ -8,9 +8,8 @@ import (
 
 // What a host hears, as the host's own words for it.
 //
-// The outbound half is behind `Bus` (bus.go); this is the other half — dialling, and the
-// declarations that arrive. The run loop reads its own words for a declaration rather than the
-// client library's delivery type, so nothing past this file knows what carried it.
+// The outbound half is behind `Bus` (bus.go); this is the other half — dialling, and what the controller asks of this
+// node. A node hears no declaration: it follows its wants (novox/hq ADR 0539).
 //
 // **The host still imports nothing of the mesh's own** (novox/hq ADR 0005). This is its own
 // interface over its own libraries, and it agrees with the controller only because a conformance
@@ -21,12 +20,9 @@ import (
 // One interface rather than two, because dialling once is what keeps both halves of a node on the
 // same connection.
 type Link interface {
-	// Bus is what this node says: what it applied, and that it is here.
+	// Bus is what this node says: its facts, and that it is here.
 	Bus
 
-	// Declarations is what the mesh tells this node to be.
-	Declarations() <-chan Declaration
-
 	// Lost says the link ended, and why.
 	//
 	// **Read rather than discovered.** A node that finds out by noticing silence is a node that
@@ -38,31 +34,12 @@ type Link interface {
 	Close()
 }
 
-// Asked is a link that hears the mesh asking this node to say again what it last applied (novox/hq
-// to-be 45 §6, the `report` verb). Optional: a link without it is never asked, and the mesh then sends
-// the current declaration again instead.
+// Asked is a link that hears the mesh asking this node to say its facts again. Optional: a link without it is never
+// asked.
 type Asked interface {
 	AskedToReport() <-chan struct{}
 }
 
-// Declaration is one thing the mesh told this node to be.
-//
-// **Handled, once — after the report is published.** A node that dies between applying and
-// reporting leaves the declaration with the mesh and applies it again on return, which is safe
-// because applying is reconciliation: it converges rather than repeating.
-//
-// There is one way of being done rather than two. A declaration set aside because a newer arrived
-// with it is settled exactly as an applied one is, and the difference between them is a fact the
-// *report* carries — a second method here would be a distinction the bus does not make.
-type Declaration interface {
-	// Body is the signed declaration as it arrived, bytes unchanged: a node verifies what it
-	// received rather than what it re-encoded.
-	Body() []byte
-
-	// Handled settles it. Called after the report for it has been published, either way.
-	Handled() error
-}
-
 // Open opens this node's link to its mesh.
 //
 // Named Open rather than Dial because Dial is this package's raw TLS dial, which the enrolment path

internal/link/hearing_nats.go

@@ -11,37 +11,16 @@ import (
 	"github.com/nats-io/nats.go"
 )
 
-// The host's link on the bus being built.
-//
-// Two things a host does here that it cannot do on the other bus, and one it must not try.
-//
-// **It declares nothing.** On the bus the mesh has, a host declares its own queue on connecting,
-// because a queue that is not there means a node that hears nothing. Here the object it reads
-// through is a durable consumer, and a host's account reaches no part of the JetStream API — by
-// design, because the controller is the only writer of consumer definitions (design 25 §3). So the
-// host **binds** to a consumer the controller made when this node enrolled, and a missing one is
-// said as what it is rather than quietly created with whatever configuration this client happens to
-// default to.
-//
-// **It gets order for free, and keeps the drain anyway.** The declaration subject is last-per-subject
-// (design 29 §4), so a node that was away receives exactly the current declaration rather than a
-// queue of superseded ones, and the stream's sequence orders them definitively — the wire-level
-// answer to novox/hq issue 107. What the drain in run.go still answers is the live case: three
-// pushes to a *connected* node are three deliveries whatever the stream later retains.
+// The host's link on the bus: one connection, and what is asked of this node over it. The node hears no declaration
+// (novox/hq ADR 0539): it watches its wants and its compositions, and says its facts.
 
 // EnrolSubject is where a joining machine asks. One subject for every node, because a machine
 // enrolling has no name the mesh has agreed to yet — which is why its authority to publish here is
 // the whole of what its enrolment user may do.
 const EnrolSubject = "mesh.control.enrol"
 
-// DeclareSubject is where this node's declaration lands. Its own, and no other node's: a host's
-// account subscribes exactly this and the subject is the authority on which node a declaration is
-// for.
-func DeclareSubject(node string) string { return "mesh.node." + node + ".declare" }
-
-// AskReportSubject is where the mesh asks this node to say again what it last applied (novox/hq to-be 45
-// §6): its own, on core NATS and off any stream. The answer is an ordinary report on its report subject,
-// the one thing it already says — nobody's inbox is answered.
+// AskReportSubject is where the mesh asks this node to say its facts again: its own, on core NATS and off any stream.
+// The answer is the facts event on its report subject — nobody's inbox is answered.
 func AskReportSubject(node string) string { return "mesh.node." + node + ".ask.report" }
 
 // natsURL is a bus address as the client wants it. A membership records host and port, because that
@@ -58,7 +37,6 @@ func natsURL(address string) string {
 type natsLink struct {
 	conn    *nats.Conn
 	js      nats.JetStreamContext
-	sub     *nats.Subscription
 	asking  *nats.Subscription
 	asked   chan struct{}
 	handing *nats.Subscription
@@ -72,9 +50,8 @@ type natsLink struct {
 	moving *nats.Subscription
 	node   string
 	// signer is the mesh's key, which a hand-over ask is verified with as a declaration is (issue 356).
-	signer  ed25519.PublicKey
-	arrived chan Declaration
-	lost    chan error
+	signer ed25519.PublicKey
+	lost   chan error
 }
 
 func dialNats(ctx context.Context, m Membership, timeout time.Duration) (Link, error) {
@@ -123,27 +100,10 @@ func dialNats(ctx context.Context, m Membership, timeout time.Duration) (Link, e
 
 	l := &natsLink{
 		conn: conn, js: js, node: m.Node, signer: m.Signer,
-		arrived: make(chan Declaration, drainDepth),
-		lost:    make(chan error, 1),
-		asked:   make(chan struct{}, 1),
+		lost:  make(chan error, 1),
+		asked: make(chan struct{}, 1),
 	}
 
-	// Bound to the consumer the controller made for this node, named after the node because that is
-	// what the node's own ack grant allows (`$JS.ACK.NODES.<node>.>`).
-	feed := make(chan *nats.Msg, drainDepth)
-	// The subject as well as the binding: the client checks what is asked for against the
-	// consumer's own filter, and an empty subject is refused rather than taken to mean "whatever
-	// that consumer delivers".
-	sub, err := js.ChanSubscribe(DeclareSubject(m.Node), feed, nats.Bind("NODES", m.Node))
-	if err != nil {
-		conn.Close()
-		return nil, fmt.Errorf(
-			"this node cannot read its declarations: %w. The mesh creates that when a node enrols, "+
-				"and a host may not create one itself — so this is the mesh's to answer, not this "+
-				"machine's", err)
-	}
-	l.sub = sub
-
 	l.hearAsks()
 
 	conn.SetDisconnectErrHandler(func(_ *nats.Conn, err error) {
@@ -159,29 +119,6 @@ func dialNats(ctx context.Context, m Membership, timeout time.Duration) (Link, e
 		}
 	})
 
-	go func() {
-		defer close(l.arrived)
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			case msg, ok := <-feed:
-				if !ok {
-					select {
-					case l.lost <- errors.New("the bus stopped delivering"):
-					default:
-					}
-					return
-				}
-				select {
-				case l.arrived <- natsDeclaration{msg}:
-				case <-ctx.Done():
-					return
-				}
-			}
-		}
-	}()
-
 	return l, nil
 }
 
@@ -299,14 +236,10 @@ func (l *natsLink) HearMoveSecrets(handle MoveSecretFunc) {
 	}
 }
 
-func (l *natsLink) Declarations() <-chan Declaration { return l.arrived }
-func (l *natsLink) AskedToReport() <-chan struct{}   { return l.asked }
-func (l *natsLink) Lost() <-chan error               { return l.lost }
+func (l *natsLink) AskedToReport() <-chan struct{} { return l.asked }
+func (l *natsLink) Lost() <-chan error             { return l.lost }
 
 func (l *natsLink) Close() {
-	if l.sub != nil {
-		_ = l.sub.Unsubscribe()
-	}
 	if l.asking != nil {
 		_ = l.asking.Unsubscribe()
 	}
@@ -375,12 +308,3 @@ var (
 	_ Asker     = (*natsLink)(nil)
 	_ Asked     = (*natsLink)(nil)
 )
-
-// natsDeclaration is one declaration off the NODES stream.
-type natsDeclaration struct{ msg *nats.Msg }
-
-func (d natsDeclaration) Body() []byte { return d.msg.Data }
-
-// Handled acknowledges it. The ack goes to this node's own ack subject, which is the one thing
-// besides its reports a node's account may publish.
-func (d natsDeclaration) Handled() error { return d.msg.Ack() }

internal/link/hearing_nats_test.go

@@ -1,337 +0,0 @@
-package link
-
-import (
-	"context"
-	"crypto/ed25519"
-	"encoding/json"
-	"fmt"
-	"os"
-	"reflect"
-	"testing"
-	"time"
-
-	"github.com/nats-io/nats.go"
-)
-
-// The host's link against a real server, because every claim here is about one.
-//
-// Whether binding to a consumer the host did not create works, whether a declaration on the node's
-// own subject arrives, whether acknowledging it removes it from the consumer's pending — none of
-// that can be reasoned out, and the first two are the ones that would leave a node silently hearing
-// nothing:
-//
-//	docker run -d --rm --name t -p 14223:4222 nats:2.10-alpine -js
-//	MESH_TEST_NATS=nats://127.0.0.1:14223 go test ./internal/link/ -run TestNats
-
-func aBus(t *testing.T) (*nats.Conn, nats.JetStreamContext) {
-	t.Helper()
-	url := os.Getenv("MESH_TEST_NATS")
-	if url == "" {
-		t.Skip("MESH_TEST_NATS unset")
-	}
-	conn, err := nats.Connect(url)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(conn.Close)
-	js, err := conn.JetStream()
-	if err != nil {
-		t.Fatal(err)
-	}
-	// **Ensured and purged, not deleted and recreated.** Delete-then-add looked like a reset and is
-	// not one: a test that did that inherited the previous test's messages, and the symptom was a
-	// declaration counted as delivered twice — which reads as a redelivery bug in the code under
-	// test rather than as a dirty stream. Purge is defined to empty a stream; recreating one is a
-	// race with the server's own teardown.
-	for _, want := range []*nats.StreamConfig{
-		{Name: "NODES", Subjects: []string{"mesh.node.*.declare"}, MaxMsgsPerSubject: 1},
-		{Name: "CONTROL", Subjects: []string{"mesh.control.*.report", "mesh.control.enrol"},
-			Retention: nats.WorkQueuePolicy},
-	} {
-		if _, err := js.StreamInfo(want.Name); err != nil {
-			if _, err := js.AddStream(want); err != nil {
-				t.Fatal(err)
-			}
-		}
-		if err := js.PurgeStream(want.Name); err != nil {
-			t.Fatal(err)
-		}
-	}
-	return conn, js
-}
-
-// theMeshMakes is the consumer the controller creates when a node enrols. Made here by the test
-// because the host may not: its account reaches no part of the JetStream API, which is the whole
-// reason this binds rather than subscribes.
-//
-// Removed afterwards, and each test names its own node: two tests sharing a consumer name share its
-// delivery count and its pending list, and the first thing that goes wrong reads as a fault in the
-// host rather than in the test beside it.
-func theMeshMakes(t *testing.T, js nats.JetStreamContext, node string) {
-	t.Helper()
-	t.Cleanup(func() { _ = js.DeleteConsumer("NODES", node) })
-	if _, err := js.AddConsumer("NODES", &nats.ConsumerConfig{
-		Durable:        node,
-		FilterSubject:  DeclareSubject(node),
-		AckPolicy:      nats.AckExplicitPolicy,
-		AckWait:        300 * time.Second,
-		DeliverSubject: "_DELIVER." + node,
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func signedBy(t *testing.T, key ed25519.PrivateKey, declaration []byte) []byte {
-	t.Helper()
-	body, err := json.Marshal(Signed{
-		Declaration: declaration, Signature: ed25519.Sign(key, declaration),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	return body
-}
-
-// A declaration on this node's own subject reaches the host, is applied, and acknowledging it
-// empties the consumer — which is what tells the mesh the node has it.
-func TestNatsADeclarationReachesTheHostAndIsSettled(t *testing.T) {
-	conn, js := aBus(t)
-	const node = "settling"
-	theMeshMakes(t, js, node)
-
-	public, private, _ := ed25519.GenerateKey(nil)
-	m := Membership{Node: node, Signer: public}
-
-	// Dialled directly rather than through Open: the test server has no TLS, and what is being
-	// checked is the subscription and the settling, not the pin — which PinnedConfig owns and its
-	// own tests cover.
-	l := &natsLink{conn: conn, js: js, node: node,
-		arrived: make(chan Declaration, drainDepth), lost: make(chan error, 1)}
-	feed := make(chan *nats.Msg, drainDepth)
-	sub, err := js.ChanSubscribe(DeclareSubject(node), feed, nats.Bind("NODES", node))
-	if err != nil {
-		t.Fatalf("the host could not bind to the consumer the mesh made for it: %v", err)
-	}
-	defer func() { _ = sub.Unsubscribe() }()
-	go func() {
-		for msg := range feed {
-			l.arrived <- natsDeclaration{msg}
-		}
-	}()
-
-	if _, err := js.Publish(DeclareSubject(node),
-		signedBy(t, private, []byte(`{"declared":"d1"}`))); err != nil {
-		t.Fatal(err)
-	}
-
-	select {
-	case d := <-l.Declarations():
-		report := handleBody(context.Background(), m, d.Body(),
-			func(context.Context, []byte, []byte) Report {
-				return Report{Applied: []string{"store"}}
-			})
-		if report.Refused != "" {
-			t.Fatalf("a declaration the mesh signed was refused: %s", report.Refused)
-		}
-		if err := d.Handled(); err != nil {
-			t.Fatalf("the node could not acknowledge its own declaration: %v", err)
-		}
-	case <-time.After(8 * time.Second):
-		t.Fatal("no declaration reached the host")
-	}
-
-	// **Nothing pending is the property**; a delivery count is not. Delivery is at-least-once by
-	// design, so pinning "delivered exactly once" would be asserting something the mesh does not
-	// rely on. What matters is that the acknowledgement landed, so the mesh can tell the node has
-	// it — and that no redelivery was needed to get there, which is what would say the node was
-	// too slow to answer for its own ack wait.
-	deadline := time.Now().Add(5 * time.Second)
-	var last string
-	for time.Now().Before(deadline) {
-		info, err := js.ConsumerInfo("NODES", node)
-		switch {
-		case err != nil:
-			last = err.Error()
-		case info.NumAckPending == 0 && info.NumRedelivered == 0:
-			return
-		default:
-			last = fmt.Sprintf("pending %d, redelivered %d", info.NumAckPending, info.NumRedelivered)
-		}
-		time.Sleep(20 * time.Millisecond)
-	}
-	t.Fatalf("the declaration was not settled, so the mesh cannot tell the node has it: %s", last)
-}
-
-// **A node that was away gets exactly the current declaration and nothing older.** Three pushed
-// while nothing is listening leave one on the stream, and it is the newest — the wire-level answer
-// to novox/hq issue 107, and the half of the drain that stops being the host's problem.
-func TestNatsANodeThatWasAwayGetsOnlyTheNewest(t *testing.T) {
-	_, js := aBus(t)
-	const node = "returning"
-	_, private, _ := ed25519.GenerateKey(nil)
-
-	for _, id := range []string{"d1", "d2", "d3"} {
-		if _, err := js.Publish(DeclareSubject(node),
-			signedBy(t, private, []byte(`{"declared":"`+id+`"}`))); err != nil {
-			t.Fatal(err)
-		}
-	}
-	info, err := js.StreamInfo("NODES")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if info.State.Msgs != 1 {
-		t.Fatalf("%d declarations survived for one node; a node that was away would apply a backlog "+
-			"of things nobody wants any more", info.State.Msgs)
-	}
-
-	theMeshMakes(t, js, node)
-	feed := make(chan *nats.Msg, drainDepth)
-	sub, err := js.ChanSubscribe(DeclareSubject(node), feed, nats.Bind("NODES", node))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer func() { _ = sub.Unsubscribe() }()
-
-	select {
-	case msg := <-feed:
-		if want := declaredIn(signedBy(t, private, []byte(`{"declared":"d3"}`))); declaredIn(msg.Data) != want {
-			t.Fatalf("the node was given %q rather than the newest", msg.Data)
-		}
-	case <-time.After(8 * time.Second):
-		t.Fatal("the node that was away was given nothing")
-	}
-}
-
-// A report goes through the stream: it must survive the controller's store restarting.
-func TestNatsAReportIsKept(t *testing.T) {
-	conn, js := aBus(t)
-	bus := OverNATS{Conn: conn, JS: js}
-	ctx := context.Background()
-
-	body, _ := json.Marshal(Report{Node: "anchor", Declared: "d1"})
-	if err := bus.Report(ctx, "anchor", body); err != nil {
-		t.Fatal(err)
-	}
-
-	info, err := js.StreamInfo("CONTROL")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if info.State.Msgs != 1 {
-		t.Fatalf("%d messages were kept; a report must be, once", info.State.Msgs)
-	}
-}
-
-// **One apply queue, against a real bus** (novox/hq to-be 45 §6, R2). A declaration is being applied
-// when two more are pushed and the five-minute reconcile comes due: the worker applies the one in
-// hand, then only the newest — the reconcile is that apply — and the mesh's stream holds one account
-// per apply, each naming the order it applied, numbered in the order they were made. Every
-// declaration delivered is settled.
-func TestNatsTheQueueAppliesTheNewestOnceAndReportsInOrder(t *testing.T) {
-	conn, js := aBus(t)
-	const node = "queueing"
-	theMeshMakes(t, js, node)
-	public, private, _ := ed25519.GenerateKey(nil)
-	m := Membership{Node: node, Signer: public}
-
-	ctx, stop := context.WithCancel(context.Background())
-	defer stop()
-	l := &natsLink{conn: conn, js: js, node: node,
-		arrived: make(chan Declaration, drainDepth), lost: make(chan error, 1)}
-	feed := make(chan *nats.Msg, drainDepth)
-	sub, err := js.ChanSubscribe(DeclareSubject(node), feed, nats.Bind("NODES", node))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer func() { _ = sub.Unsubscribe() }()
-	go func() {
-		for msg := range feed {
-			l.arrived <- natsDeclaration{msg}
-		}
-	}()
-	reports, err := js.SubscribeSync(ReportSubject(node), nats.BindStream("CONTROL"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer func() { _ = reports.Unsubscribe() }()
-
-	a := &applies{}
-	inFirst, release := make(chan struct{}, 1), make(chan struct{})
-	reconciled := 0
-	q := &Queue{Membership: m, Timeout: 5 * time.Second, Unsaid: &keptInMemory{},
-		Apply: func(ctx context.Context, raw, sig []byte) Report {
-			r := a.apply(ctx, raw, sig)
-			if r.Sequence == 1 {
-				inFirst <- struct{}{}
-				<-release
-			}
-			return r
-		},
-		Reconcile: func(context.Context) (Report, bool) { reconciled++; return Report{}, false },
-	}
-	worker := runWorker(ctx, q)
-	go func() { _ = serve(ctx, l, m, q, nil, 5*time.Second) }()
-
-	push := func(id string, sequence int64) {
-		inner, _ := json.Marshal(map[string]any{"declaration": 1, "epoch": 7, "sequence": sequence,
-			"resources": []any{map[string]any{"id": id}}})
-		if _, err := js.Publish(DeclareSubject(node), signedBy(t, private, inner)); err != nil {
-			t.Fatal(err)
-		}
-	}
-	push("one", 1)
-	select {
-	case <-inFirst:
-	case <-time.After(8 * time.Second):
-		t.Fatal("the first declaration never reached the worker")
-	}
-	push("two", 2)
-	push("three", 3)
-	q.ReconcileDue()
-	time.Sleep(2 * drainWindow) // the link gathers both and hands them to the queue
-	close(release)
-
-	var heard []Report
-	for len(accounts(heard)) < 2 {
-		msg, err := reports.NextMsg(8 * time.Second)
-		if err != nil {
-			t.Fatalf("the mesh heard %+v and then nothing: %v", heard, err)
-		}
-		var r Report
-		if err := json.Unmarshal(msg.Data, &r); err != nil {
-			t.Fatal(err)
-		}
-		heard = append(heard, r)
-		_ = msg.Ack()
-	}
-	stop()
-	<-worker
-
-	if got := a.all(); !reflect.DeepEqual(got, []string{"one", "three"}) {
-		t.Fatalf("applied %v; the one in hand and then only the newest were wanted", got)
-	}
-	if reconciled != 0 {
-		t.Fatal("the reconcile applied beside the delivery it was due with")
-	}
-	accounted := accounts(heard)
-	if accounted[0].Sequence != 1 || accounted[1].Sequence != 3 || accounted[1].Epoch != 7 {
-		t.Fatalf("the accounts do not name what was applied: %+v", accounted)
-	}
-	for i := 1; i < len(heard); i++ {
-		if heard[i].ReportSequence <= heard[i-1].ReportSequence {
-			t.Fatalf("the reports left out of the order they were made: %+v", heard)
-		}
-	}
-	deadline := time.Now().Add(5 * time.Second)
-	for {
-		info, err := js.ConsumerInfo("NODES", node)
-		if err == nil && info.NumAckPending == 0 {
-			break
-		}
-		if time.Now().After(deadline) {
-			t.Fatalf("a delivered declaration was left unsettled: %+v %v", info, err)
-		}
-		time.Sleep(20 * time.Millisecond)
-	}
-}

internal/link/held_note_test.go

@@ -1,46 +0,0 @@
-package link
-
-import (
-	"strings"
-	"testing"
-)
-
-// The count that did not add up was the only symptom sixteen held resources had, and reading it meant
-// opening the node's state file by hand (novox/hq 04-ISSUES/125). The line that says what an apply did
-// says what it did not, too.
-
-func TestTheApplyLineSaysWhatItHeldAndForWhichModule(t *testing.T) {
-	got := heldNote([]Held{
-		{ID: "ca", Module: "route-proxy", Kind: "directory"},
-		{ID: "certs", Module: "route-proxy", Kind: "directory"},
-		{ID: "server", Module: "route-proxy", Kind: "container"},
-		{ID: "mail", Module: "mailu", Kind: "container"},
-	})
-	if !strings.Contains(got, "4 held") {
-		t.Fatalf("the count of what was held is not in the line: %q", got)
-	}
-	// The module is the thing an operator can act on: `take` takes a module.
-	if !strings.Contains(got, "route-proxy: 3") || !strings.Contains(got, "mailu: 1") {
-		t.Fatalf("the line does not break the holds down by module: %q", got)
-	}
-	// Ordered, so two machines holding the same things read the same and a diff of two reports is
-	// about what changed.
-	if strings.Index(got, "mailu") > strings.Index(got, "route-proxy") {
-		t.Fatalf("modules are not in a stated order: %q", got)
-	}
-	// It says why, because "held" alone reads as a failure and this is correct behaviour.
-	if !strings.Contains(got, "taken") {
-		t.Fatalf("the line does not say a hold ends when the module is taken: %q", got)
-	}
-}
-
-func TestAnApplyThatHeldNothingSaysNothingExtra(t *testing.T) {
-	// A converged machine holds nothing, which is most applies. Reporting "0 held" on every one of
-	// them is how a line stops being read.
-	if got := heldNote(nil); got != "" {
-		t.Fatalf("an apply with no holds added %q to its line", got)
-	}
-	if got := heldNote([]Held{}); got != "" {
-		t.Fatalf("an apply with no holds added %q to its line", got)
-	}
-}

internal/link/history_integration_test.go

@@ -0,0 +1,126 @@
+//go:build integration
+
+package link
+
+import (
+	"context"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	natsserver "github.com/nats-io/nats-server/v2/server"
+	"github.com/nats-io/nats.go"
+)
+
+// The revisions a bucket keeps of a key, read over a real bus: oldest first, a delete and a purge said as deleted, and
+// none for a key that never was (issue 1945: the node agent takes the composition its want names from them).
+func TestNatsAKeysRevisionsAreReadBack(t *testing.T) {
+	// A second account reads as a node's does: refused the one bucket "denied-it" (the seat's state before its grant arrives).
+	srv, err := natsserver.NewServer(&natsserver.Options{Port: -1, JetStream: true, StoreDir: t.TempDir(), NoLog: true, NoSigs: true,
+		Users: []*natsserver.User{{Username: "admin", Password: "a"}, {Username: "node", Password: "n", Permissions: &natsserver.Permissions{
+			Publish: &natsserver.SubjectPermission{Allow: []string{">"}, Deny: []string{"$JS.API.*.*.KV_denied-it", "$JS.API.*.*.*.KV_denied-it", "$JS.API.*.*.*.KV_denied-it.>", "$KV.denied-it.>"}}}}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	go srv.Start()
+	if !srv.ReadyForConnections(10 * time.Second) {
+		t.Fatal("the bus did not come up")
+	}
+	t.Cleanup(srv.Shutdown)
+	conn, err := nats.Connect(srv.ClientURL(), nats.UserInfo("admin", "a"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(conn.Close)
+	js, err := conn.JetStream()
+	if err != nil {
+		t.Fatal(err)
+	}
+	kv, err := js.CreateKeyValue(&nats.KeyValueConfig{Bucket: "composed-it", History: 10})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, v := range []string{"one", "two", "three"} {
+		if _, err := kv.PutString("it.node-tools.x", v); err != nil {
+			t.Fatal(err)
+		}
+	}
+	bus := OverNATS{Conn: conn, JS: js}
+	ctx := context.Background()
+	got, err := bus.KVHistory(ctx, "composed-it", "it.node-tools.x")
+	if err != nil || len(got) != 3 || string(got[0].Value) != "one" || string(got[2].Value) != "three" ||
+		got[0].Revision >= got[2].Revision {
+		t.Fatalf("three revisions read back as %+v (%v)", got, err)
+	}
+	if err := kv.Delete("it.node-tools.x"); err != nil {
+		t.Fatal(err)
+	}
+	got, err = bus.KVHistory(ctx, "composed-it", "it.node-tools.x")
+	if err != nil || len(got) != 4 || !got[3].Deleted {
+		t.Fatalf("after a delete: %+v (%v)", got, err)
+	}
+	if err := kv.Purge("it.node-tools.x"); err != nil {
+		t.Fatal(err)
+	}
+	got, err = bus.KVHistory(ctx, "composed-it", "it.node-tools.x")
+	if err != nil || len(got) != 1 || !got[0].Deleted {
+		t.Fatalf("after a purge: %+v (%v)", got, err)
+	}
+	if got, err := bus.KVHistory(ctx, "composed-it", "it.never.x"); err != nil || len(got) != 0 {
+		t.Fatalf("a key that never was: %+v (%v)", got, err)
+	}
+
+	// A bucket that is not there, and one the account may not read, are errors at once, never a wait: the node agent
+	// follows its placement key by one watch at its start (endWhenPlaced) and, refused, stays on the controller's compositions and says why.
+	if _, err := bus.KVWatch(ctx, "never-it", ">"); err == nil {
+		t.Error("a watch of a bucket that is not there gave no error")
+	}
+	if _, err := js.CreateKeyValue(&nats.KeyValueConfig{Bucket: "denied-it", History: 1}); err != nil {
+		t.Fatal(err)
+	}
+	nodeConn, err := nats.Connect(srv.ClientURL(), nats.UserInfo("node", "n"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(nodeConn.Close)
+	started := time.Now()
+	wctx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+	if _, err := (OverNATS{Conn: nodeConn}).KVWatch(wctx, "denied-it", ">"); err == nil || wctx.Err() != nil {
+		t.Errorf("a watch the account may not make: error %v after %s, context %v", err, time.Since(started), wctx.Err())
+	} else {
+		t.Logf("a refused watch is an error after %s: %v", time.Since(started).Round(time.Millisecond), err)
+	}
+
+	// A bucket made after the watch was asked is then watched, on the bus's word that it was created and with no timer;
+	// a bucket the account may not read is no waiting but the error (endWhenPlaced, the shadow's candidates).
+	q := &Session{Membership: Membership{Node: "n1"}}
+	q.Attach(ctx, OverNATS{Conn: conn, JS: js})
+	var waited atomic.Int32
+	actx, acancel := context.WithTimeout(ctx, 20*time.Second)
+	defer acancel()
+	ch, err := q.KVWatchAwait(actx, "later-it", ">", func(error) { waited.Add(1) })
+	if err != nil || waited.Load() != 1 {
+		t.Fatalf("a bucket not there yet: watch %v, waiting told %d time(s)", err, waited.Load())
+	}
+	select {
+	case u := <-ch:
+		t.Fatalf("an update before the bucket exists: %+v", u)
+	case <-time.After(200 * time.Millisecond):
+	}
+	later, err := js.CreateKeyValue(&nats.KeyValueConfig{Bucket: "later-it", History: 1})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := later.PutString("placement.n1", "v"); err != nil {
+		t.Fatal(err)
+	}
+	for seen := false; !seen; {
+		select {
+		case u := <-ch:
+			seen = u.Key == "placement.n1" && string(u.Value) == "v"
+		case <-actx.Done():
+			t.Fatal("the bucket made after the watch was never watched")
+		}
+	}
+}

internal/link/messages.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 	"time"
 
+	"git.novox.be/novox/mesh-sdk/go/delivery"
 	"git.novox.be/novox/mesh-sdk/go/health"
 )
 
@@ -18,22 +19,6 @@ const (
 	KeyReport = "report"
 )
 
-// Signed is a declaration and the signature over it.
-//
-// novox/hq ADR 0004: the transport is verified once at connect, and **each declaration is
-// verified by its signature, every time**. The two are different questions — a node connects to
-// the broker and takes instruction from the control plane behind it, and pinning only the first
-// would make the second transitive.
-//
-// The signature is over Declaration exactly as it arrived, bytes unchanged. Re-encoding before
-// verifying would mean checking a signature over something other than what was sent, and any
-// difference in key order or spacing would break it — so the raw message is what is signed and
-// what is checked.
-type Signed struct {
-	Declaration []byte `json:"declaration"`
-	Signature   []byte `json:"signature"`
-}
-
 // Report is what a node says after applying, and it is a statement rather than a write.
 //
 // A node states; the context that owns the data writes (novox/hq ADR 0006). The difference is the
@@ -51,14 +36,6 @@ type Report struct {
 	// Refused is set when the declaration was rejected whole rather than applied in part.
 	Refused string `json:"refused,omitempty"`
 
-	// Superseded names the newer declaration this one was set aside for, unapplied.
-	//
-	// A machine asked to be five successive things becomes the last one (novox/hq issue 031):
-	// when several declarations are waiting, the host applies the newest and acknowledges the
-	// rest without applying them. Each of those is still reported, because silence reads as a
-	// machine that ignored an instruction and "applied" would be a lie — this is the third word.
-	Superseded string `json:"superseded,omitempty"`
-
 	// Carried are the machine's ports held by what this host raised from its own bundle.
 	//
 	// **So the mesh can assign around what it did not put here** (novox/hq ADR 0038). A node
@@ -70,62 +47,13 @@ type Report struct {
 	// machine saying what is true of it, not asking for anything.
 	Carried []int `json:"carried,omitempty"`
 
-	// Declared is the digest of the declaration this report is about — sha256 of the exact bytes
-	// the mesh sent, which the mesh recorded when it sent them.
-	//
-	// **Which declaration, not when.** The mesh compared its send time to this report's arrival
-	// to decide whether a machine had caught up, and lost the race it invited: an apply started
-	// under the previous declaration finishes after the next one is sent, its report lands newer
-	// than the send, and the machine reads as caught up with words it has not read yet. Clocks
-	// cannot answer "which"; the digest is the answer itself.
-	Declared string `json:"declared,omitempty"`
-
-	// Order is where the declaration this report is about stands — its `epoch` and `sequence`, as
-	// the declaration carried them — so the mesh orders reports by what they are about rather than
-	// by when they arrived (novox/hq to-be 45 §6). On the wire as two top-level keys beside
-	// `declared`; absent for a declaration that claimed no order, and for a report about none.
+	// Writer, and Order — the node-engine's own epoch and sequence — say who wrote these facts and where they stand
+	// among everything it wrote (novox/hq ADR 0227 §2, ADR 0539 §9): the epoch is one per start of the node-engine,
+	// the sequence one higher for every facts event, so the controller refuses older facts by this order. On the
+	// wire as three top-level keys.
+	Writer string `json:"writer,omitempty"`
 	Order
 
-	// ReportSequence is this node-engine's own order among everything it reports: one higher for
-	// every report it makes, kept on disk so it goes on increasing across restarts and self-updates
-	// (to-be 45 §6). With the declaration's order it lets the mesh refuse an older report about the
-	// same declaration — a reconcile's account overtaking the apply that followed it (novox/hq issue
-	// 267) is then refused by number rather than set aside by digest. A report said again because
-	// it never reached the mesh (issue 264) carries the number it was made with.
-	//
-	// Zero claims no order: every report an older host makes, and a one-shot report a command makes
-	// (a rekey). **Its presence also says this host reads a declaration's `epoch`**, which is how the
-	// mesh knows it may send one: an older host decodes a declaration strictly and refuses a key it
-	// does not know.
-	ReportSequence int64 `json:"report_sequence,omitempty"`
-
-	// OlderThan is set on a report refusing a declaration older than one this node has applied: the
-	// order of the newer declaration it holds (to-be 45 §6, rule 2). The refused declaration is the
-	// report's own Declared and Order, and Refused says it in words. Applying it would make the
-	// machine into something a controller that lost its lease said, after one that holds it.
-	OlderThan *Order `json:"older_than,omitempty"`
-
-	// RefusedOlder is how many declarations this node-engine has refused as older, ever — kept on
-	// disk with the report sequence. On every report, so a count missed with a lost refusal is still
-	// read from the next one: what the mesh's stale-writer watchdog (to-be 45 §3, S13) counts.
-	RefusedOlder int64 `json:"refused_older,omitempty"`
-
-	// ReadsGeneration says this node-engine reads a declaration's assignment generation and its
-	// put-back mark (novox/hq issue 234), on every report it makes: the controller sends them only to a
-	// machine that said so, because an older node-engine decodes strictly and refuses a key it does not
-	// know, whole. A node-engine rolled back says so no longer.
-	ReadsGeneration bool `json:"reads_generation,omitempty"`
-
-	// ReadsModules says this node-engine reads a resource's `module` and a declaration's `builds` (novox/hq ADR 0429
-	// §4, issue 1132), on every report it makes, beside ReadsGeneration: the controller sends them only to a machine
-	// that said so, for the same reason.
-	ReadsModules bool `json:"reads_modules,omitempty"`
-
-	// OlderGeneration is set on a report refusing a declaration composed from an older assignment
-	// generation than this machine applied (novox/hq issue 234). The refused declaration is the report's
-	// own Declared and Order, so the controller can name who sent it from its record of sends.
-	OlderGeneration *GenerationRefusal `json:"older_generation,omitempty"`
-
 	// Held is what this adopted node found and is keeping as it was until its module is taken
 	// (novox/hq ADR 0100). Without it an adopted node reads as converged.
 	Held []Held `json:"held,omitempty"`
@@ -647,52 +575,14 @@ type Rollback struct {
 	At  time.Time `json:"at"`
 }
 
-// Order is where a declaration stands among everything the mesh has sent this node (novox/hq to-be
-// 45 §6): the controller's lease **epoch** it was sent under, and its **sequence** — one higher for
-// every send to this node (04-ISSUES/107). The declaration carries both inside what is signed, as
-// top-level `epoch` and `sequence` beside `declaration`; a report carries back the pair of the
-// declaration it is about.
-//
-// Zero in either is "no order claimed", never "first": every declaration an older controller sent,
-// and the bundle genesis applies.
+// Order is where a writer's saying stands among everything it said (novox/hq ADR 0227 §2): its **epoch**, and its
+// **sequence** within it. A node-engine's epoch is the time it started, so a later start orders after an earlier one
+// with nothing kept on disk.
 type Order struct {
 	Epoch    int64 `json:"epoch,omitempty"`
 	Sequence int64 `json:"sequence,omitempty"`
 }
 
-// Older says whether a declaration of this order is older than one of order `than`, which this node
-// has applied — the one rule by which a node-engine refuses a declaration (to-be 45 §6: "older epoch;
-// same epoch, lower sequence").
-//
-// **Only when both claim an epoch.** A declaration with none is an older controller's — or a
-// controller rolled back to a build from before the lease — and one kept with none is what this host
-// held before any controller had a lease. Neither has an order to compare, and refusing on a guess
-// would strand the machine the moment the controller is older than the host: without an epoch, today's
-// behaviour stands. A higher epoch is a new lease holder and is never older, whatever its sequence.
-func (o Order) Older(than Order) bool {
-	if o.Epoch <= 0 || than.Epoch <= 0 {
-		return false
-	}
-	if o.Epoch != than.Epoch {
-		return o.Epoch < than.Epoch
-	}
-	return o.Sequence > 0 && than.Sequence > 0 && o.Sequence < than.Sequence
-}
-
-// Supersedes says whether a declaration of order `o`, arriving after one of order `before`, takes its
-// place among what is waiting to be applied. By epoch when both claim one and they differ, then by
-// sequence when both claim one, and by arrival when they do not — what the drain had to go on before
-// declarations said where they stand (04-ISSUES/107).
-func (o Order) Supersedes(before Order) bool {
-	if o.Epoch > 0 && before.Epoch > 0 && o.Epoch != before.Epoch {
-		return o.Epoch > before.Epoch
-	}
-	if o.Sequence > 0 && before.Sequence > 0 {
-		return o.Sequence >= before.Sequence
-	}
-	return true
-}
-
 // Words is an order as a person reads it in a log line. Not String: Report embeds Order, and a
 // Stringer promoted onto every report would print each one as its order alone.
 func (o Order) Words() string {
@@ -842,18 +732,21 @@ type FoundFirewall struct {
 	RetiredBy string `json:"retired_by,omitempty"`
 }
 
-// GenerationRefusal is a declaration refused for the assignment generation it was composed from: that
-// generation, and the highest this machine applied (novox/hq issue 234).
-type GenerationRefusal struct {
-	Generation int64 `json:"generation"`
-	Applied    int64 `json:"applied"`
-}
-
-// ModuleFact is how one module's part of an apply came out: the build the node was sent for it, and whether every
-// resource of it applied. Detail names the failing resource and its error (issue 1132).
+// ModuleFact is how one module's part of an apply came out (novox/hq ADR 0539 §9): the fingerprint FP the module runs and
+// the digest Composed of the composition applied for it, beside the build the node was sent, the Phase it is in (empty
+// is running, or failed when Failed), and whether every resource of it applied. Detail names the failing resource and its
+// error (issue 1132).
 type ModuleFact struct {
-	Module string
-	Build  string
-	Failed bool
-	Detail string
+	Module   string
+	Build    string
+	FP       string
+	Composed string
+	Phase    string
+	Failed   bool
+	Detail   string
+	// Judgement and Waits are, in phase waiting-yes, the judgement of the move and the composition waiting (ADR 0547 §3).
+	Judgement string
+	Waits     string
+	// Sealed is the values the composition it names carries sealed to this node's key, by slot (delivery.Have.SealedAt).
+	Sealed delivery.Seals
 }

internal/link/messages_test.go

@@ -1,115 +1,10 @@
 package link
 
 import (
-	"context"
-	"crypto/ed25519"
 	"encoding/json"
 	"testing"
 )
 
-// verified runs what Run does to a delivery body, without a broker: unmarshal, check the
-// signature, and only then apply. Isolating it keeps this test about the check rather than about
-// the bus, which is tested against a real one in the lab.
-func verified(t *testing.T, signer ed25519.PublicKey, body []byte) (Report, bool) {
-	t.Helper()
-	applied := false
-	report := handleBody(context.Background(), Membership{Node: "anchor", Signer: signer}, body,
-		func(context.Context, []byte, []byte) Report {
-			applied = true
-			return Report{Applied: []string{"something"}}
-		})
-	return report, applied
-}
-
-func signedBody(t *testing.T, private ed25519.PrivateKey, declaration string) []byte {
-	t.Helper()
-	raw, err := json.Marshal(Signed{
-		Declaration: []byte(declaration),
-		Signature:   ed25519.Sign(private, []byte(declaration)),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	return raw
-}
-
-func TestTheMeshsOwnDeclarationIsApplied(t *testing.T) {
-	public, private, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	report, applied := verified(t, public, signedBody(t, private, `{"declaration":1}`))
-	if !applied {
-		t.Fatalf("a declaration the mesh signed was not applied: %s", report.Refused)
-	}
-}
-
-// Defends novox/hq ADR 0002: everything reaching a node arrives over the broker — and therefore
-// ADR 0004's consequence, that the broker is not trusted to say who is speaking.
-//
-// A transport nobody authenticates per-message would let whatever holds the connection attribute
-// a declaration to any node it liked.
-func TestAForgedDeclarationIsNeverApplied(t *testing.T) {
-	// The check that stands between "the mesh changes this machine" and "anybody does". The host
-	// applies whatever the link delivers, so a forged declaration is the whole machine.
-	public, _, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, other, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	report, applied := verified(t, public, signedBody(t, other, `{"declaration":1}`))
-	if applied {
-		t.Fatal("a declaration signed by another key was applied")
-	}
-	if report.Refused != ErrForged.Error() {
-		t.Errorf("refused, but not as a forgery: %q", report.Refused)
-	}
-}
-
-func TestATamperedDeclarationIsNeverApplied(t *testing.T) {
-	// A broker that changed the declaration in flight, keeping the signature. This is what makes
-	// pinning the transport insufficient on its own.
-	public, private, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	raw, err := json.Marshal(Signed{
-		Declaration: []byte(`{"declaration":1,"resources":["something else entirely"]}`),
-		Signature:   ed25519.Sign(private, []byte(`{"declaration":1}`)),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	report, applied := verified(t, public, raw)
-	if applied {
-		t.Fatal("a declaration altered after signing was applied")
-	}
-	if report.Refused != ErrForged.Error() {
-		t.Errorf("refused, but not as a forgery: %q", report.Refused)
-	}
-}
-
-func TestAMalformedMessageIsToldApartFromAForgery(t *testing.T) {
-	// novox/hq ADR 0004 requires these to be distinguishable: one means somebody is trying, the
-	// other means something is broken, and they need different responses from a person.
-	public, _, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	report, applied := verified(t, public, []byte("this is not a message"))
-	if applied {
-		t.Fatal("something unparseable was applied")
-	}
-	if report.Refused == ErrForged.Error() {
-		t.Error("a malformed message was reported as a forgery; those must be distinguishable")
-	}
-}
-
 func TestTheWireFormatIsExactlyTheseFieldNames(t *testing.T) {
 	// The contract with the control plane, which defines these separately. A matching test lives
 	// there; rename a field on either side and both fail.
@@ -117,7 +12,9 @@ func TestTheWireFormatIsExactlyTheseFieldNames(t *testing.T) {
 		value  any
 		expect []string
 	}{
-		{Signed{Declaration: []byte("{}"), Signature: []byte("x")}, []string{"declaration", "signature"}},
+		// novox/hq ADR 0539 §9: the node's facts carry the node-engine's own writer, epoch and sequence.
+		{Report{Node: "n", Writer: Writer, Order: Order{Epoch: 1, Sequence: 2}},
+			[]string{"node", "writer", "epoch", "sequence"}},
 		{Report{Node: "n", Applied: []string{"a"}, Failed: map[string]string{"k": "v"}, Refused: "r"},
 			[]string{"node", "applied", "failed", "refused"}},
 		// novox/hq ADR 0100: what an adopted node holds, the firewall it was found with, and what

internal/link/movesecret.go

@@ -173,7 +173,7 @@ const VaultWithin = 15 * time.Second
 
 // AskVault asks one of the vault's verbs in this node's engine's own name over the link open now, and answers its
 // result, or its refusal as an error.
-func (q *Queue) AskVault(ctx context.Context, verb string, args any) (json.RawMessage, error) {
+func (q *Session) AskVault(ctx context.Context, verb string, args any) (json.RawMessage, error) {
 	q.init()
 	q.mu.Lock()
 	bus := q.bus

internal/link/movesecret_test.go

@@ -112,8 +112,8 @@ func TestNatsAMoveIsAskedOfTheNodeAndTheVaultIsAskedInItsName(t *testing.T) {
 	}
 	defer vault.Unsubscribe()
 	l := &natsLink{conn: conn, js: js, node: m.Node, signer: m.Signer}
-	q := &Queue{Membership: m}
-	q.attach(t.Context(), l)
+	q := &Session{Membership: m}
+	q.Attach(t.Context(), l)
 	l.HearMoveSecrets(func(s MoveSecret) (MovedSecret, error) {
 		raw, err := q.AskVault(t.Context(), "move-in", map[string]string{"module": s.Module})
 		if err != nil || !strings.Contains(string(raw), `"call":"c1"`) {
@@ -135,7 +135,7 @@ func TestNatsAMoveIsAskedOfTheNodeAndTheVaultIsAskedInItsName(t *testing.T) {
 	if err := json.Unmarshal(reply.Data, &said); err != nil || said.Secret != "own/"+m.Node+"/postgres/superuser-password" {
 		t.Fatalf("answered %s, %v", reply.Data, err)
 	}
-	if _, err := (&Queue{Membership: Membership{Node: "nowhere"}}).AskVault(t.Context(), "move-in", nil); !errors.Is(err, ErrNotAsked) {
+	if _, err := (&Session{Membership: Membership{Node: "nowhere"}}).AskVault(t.Context(), "move-in", nil); !errors.Is(err, ErrNotAsked) {
 		t.Fatalf("a queue with no link asked the vault: %v", err)
 	}
 }

internal/link/newest_test.go

@@ -1,79 +0,0 @@
-package link
-
-import (
-	"sync"
-	"testing"
-	"time"
-)
-
-type said struct {
-	body []byte
-
-	mu      sync.Mutex
-	handled bool
-}
-
-func (s *said) Body() []byte { return s.body }
-func (s *said) Handled() error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.handled = true
-	return nil
-}
-func (s *said) wasHandled() bool {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	return s.handled
-}
-
-func arriving(bodies ...string) chan Declaration {
-	ch := make(chan Declaration, 8)
-	for _, b := range bodies {
-		ch <- &said{body: []byte(b)}
-	}
-	return ch
-}
-
-// newest is what the queue's worker would take from what the link gathered behind `first`.
-func newest(arriving <-chan Declaration, first Declaration, window time.Duration) (Declaration, []Declaration) {
-	return pick(gather(arriving, first, window))
-}
-
-// A machine asked to be five things becomes the last one: what is already waiting supersedes what
-// arrived first, and everything set aside is named so it can be reported.
-func TestWhatIsAlreadyWaitingSupersedesWhatArrivedFirst(t *testing.T) {
-	waiting := arriving("two", "three", "four")
-	apply, superseded := newest(waiting, &said{body: []byte("one")}, 50*time.Millisecond)
-	if string(apply.Body()) != "four" {
-		t.Fatalf("applied %q, not the newest", apply.Body())
-	}
-	if len(superseded) != 3 || string(superseded[0].Body()) != "one" ||
-		string(superseded[2].Body()) != "three" {
-		t.Fatalf("set aside %d: %v", len(superseded), superseded)
-	}
-}
-
-// One declaration with nothing behind it is applied as it always was, after the window.
-func TestALoneDeclarationIsAppliedAfterTheWindow(t *testing.T) {
-	began := time.Now()
-	apply, superseded := newest(arriving(), &said{body: []byte("only")}, 30*time.Millisecond)
-	if string(apply.Body()) != "only" || len(superseded) != 0 {
-		t.Fatalf("got %q with %d set aside", apply.Body(), len(superseded))
-	}
-	if time.Since(began) < 30*time.Millisecond {
-		t.Fatal("did not wait the window for a straggler")
-	}
-}
-
-// A straggler within the window is taken; one after it is the next push.
-func TestAStragglerWithinTheWindowIsTaken(t *testing.T) {
-	waiting := arriving()
-	go func() {
-		time.Sleep(20 * time.Millisecond)
-		waiting <- &said{body: []byte("late")}
-	}()
-	apply, superseded := newest(waiting, &said{body: []byte("first")}, 100*time.Millisecond)
-	if string(apply.Body()) != "late" || len(superseded) != 1 {
-		t.Fatalf("got %q with %d set aside", apply.Body(), len(superseded))
-	}
-}

internal/link/nothing_alive_test.go

@@ -35,7 +35,7 @@ func (l *listeningForAlive) count() int {
 func TestTheLinkLoopPublishesNoAlive(t *testing.T) {
 	m, _ := aMember(t)
 	l := &listeningForAlive{quietLink: newQuietLink()}
-	q := aQueue(m, nil, &keptInMemory{})
+	q := &Session{Membership: m, Timeout: time.Second}
 
 	ctx, stop := context.WithCancel(context.Background())
 	done := make(chan error, 1)

internal/link/order_test.go

@@ -1,50 +0,0 @@
-package link
-
-import (
-	"encoding/json"
-	"testing"
-	"time"
-)
-
-// The drain picked the last to arrive. A backlog longer than the batch, or a broker that split a
-// burst, delivered a superseded declaration last (novox/hq 04-ISSUES/107).
-
-func sequenced(t *testing.T, n int64) *said {
-	t.Helper()
-	inner, err := json.Marshal(map[string]any{"declaration": 1, "resources": []any{}, "sequence": n})
-	if err != nil {
-		t.Fatal(err)
-	}
-	body, err := json.Marshal(Signed{Declaration: inner, Signature: []byte("s")})
-	if err != nil {
-		t.Fatal(err)
-	}
-	return &said{body: body}
-}
-
-func TestTheDrainKeepsTheHighestSequenceNotTheLastToArrive(t *testing.T) {
-	waiting := make(chan Declaration, 8)
-	waiting <- sequenced(t, 9)
-	waiting <- sequenced(t, 4) // arrived last, composed earlier
-	latest, aside := newest(waiting, sequenced(t, 8), 30*time.Millisecond)
-	if got := orderOf(latest.Body()).Sequence; got != 9 {
-		t.Fatalf("the drain kept sequence %d, and 9 was waiting", got)
-	}
-	if len(aside) != 2 {
-		t.Fatalf("%d set aside, wanted 2 (the 8 and the late 4)", len(aside))
-	}
-}
-
-func TestWithoutSequencesTheLastToArriveStillWins(t *testing.T) {
-	// The behaviour this had before, kept for a controller that sends no order.
-	apply, aside := newest(arriving("two", "three"), &said{body: []byte("one")}, 30*time.Millisecond)
-	if string(apply.Body()) != "three" || len(aside) != 2 {
-		t.Fatalf("applied %q with %d set aside", apply.Body(), len(aside))
-	}
-}
-
-func TestAnUnreadableBodyClaimsNoOrder(t *testing.T) {
-	if got := orderOf([]byte("not json")); got != (Order{}) {
-		t.Fatalf("garbage claimed %+v", got)
-	}
-}