mesh-delivery-checker: Pin mesh-sdk at 43788bb, the group's head: a check ask runs every level after a failure

Claude-Session: https://claude.ai/code/session_01NcbgfJ9Gum47zkFKWRaovL

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/asks.go

@@ -0,0 +1,161 @@
+package main
+
+import (
+	"context"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"git.novox.be/novox/mesh-sdk/go/buildstep"
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
+
+	"mesh-delivery-assigner/internal/assign"
+)
+
+// AssignerModule is the asker the assigner's compose asks name.
+const AssignerModule = "mesh-delivery-assigner"
+
+// composeAsks are the compose asks the assigner put on the Go build seat's check stream (novox/hq ADR 0482 clause 4,
+// issues 1622 and 1623), by what each composes: one ask per key, put once and followed by a watch of its step key until
+// it ends, which wakes a pass. No timer: an ask that waits in the stream waits (its backlog is the view's and the
+// watchman's to show). A restart forgets them and asks again; the build module keeps a composer built for a commit, so a
+// second ask builds nothing.
+type composeAsks struct {
+	ctx   context.Context
+	asker buildrun.Asker
+	wake  func()
+	logf  func(string, ...any)
+	now   func() time.Time
+
+	mu   sync.Mutex
+	asks map[string]*composeAsk
+}
+
+type composeAsk struct {
+	id     string
+	cancel context.CancelFunc
+	ran    *assign.Ran
+}
+
+func newComposeAsks(ctx context.Context, asker buildrun.Asker, wake func(), logf func(string, ...any)) *composeAsks {
+	return &composeAsks{ctx: ctx, asker: asker, wake: wake, logf: logf, now: time.Now, asks: map[string]*composeAsk{}}
+}
+
+// get is the end of the ask that composes key, or nil and its id while it runs. The first get of a key puts the ask.
+// A job its layout refuses ends at once, failed with why: never silent.
+func (a *composeAsks) get(key string, job delivery.ComposeJob) (*assign.Ran, string) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if k, ok := a.asks[key]; ok {
+		return k.ran, k.id
+	}
+	ask := delivery.StepAsk{ID: buildstep.NewID(), Kind: delivery.AskCheck, Language: delivery.AskGo, Asker: AssignerModule,
+		At: a.now(), Compose: &job}
+	ctx, cancel := context.WithCancel(a.ctx)
+	k := &composeAsk{id: ask.ID, cancel: cancel}
+	a.asks[key] = k
+	if err := a.asker.Put(ctx, ask); err != nil {
+		a.logf("the compose ask %s for %s could not be put: %v", ask.ID, key, err)
+		k.ran = &assign.Ran{State: delivery.StepFailed, Reason: "the compose ask could not be put on the Go build seat: " + err.Error()}
+		cancel()
+		return k.ran, k.id
+	}
+	go func() {
+		step, err := a.asker.Wait(ctx, ask)
+		if ctx.Err() != nil {
+			return
+		}
+		ran := assign.RanOf(step)
+		if err != nil {
+			ran = assign.Ran{State: delivery.StepFailed, Reason: "the compose ask's step could not be followed: " + err.Error()}
+		}
+		a.mu.Lock()
+		k.ran = &ran
+		a.mu.Unlock()
+		a.wake()
+	}()
+	return nil, k.id
+}
+
+// sweep forgets, and stops following, every ask whose key no pass asked for this time: a candidate gone or moved on.
+func (a *composeAsks) sweep(seen map[string]bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for key, k := range a.asks {
+		if !seen[key] {
+			k.cancel()
+			delete(a.asks, key)
+		}
+	}
+}
+
+// composeAtHead is the composition of a group with a mesh-sdk member: the composer at its head and at each reader's
+// mesh-sdk, asked of the Go build seat, and the verdict once every ask ended; until then the verdict waits, naming the
+// asks. The keys it used are marked in seen.
+func (p *passer) composeAtHead(ctx context.Context, m assign.Mesh, ch assign.Change, seen map[string]bool, began time.Time) delivery.CompositionVerdict {
+	waiting := func(words string) delivery.CompositionVerdict {
+		return delivery.CompositionVerdict{Group: ch.Group, Heads: ch.Heads, State: delivery.CompositionWaits, Words: words}
+	}
+	head, err := assign.HeadJob(m, ch)
+	if err != nil {
+		return delivery.CompositionVerdict{Group: ch.Group, Heads: ch.Heads, State: delivery.CompositionFail, SDK: "mesh-sdk " + ch.SDKHead,
+			Words: "the compose ask at the group's mesh-sdk head cannot be made: " + err.Error()}
+	}
+	var pending []string
+	key := "head." + ch.Group + "." + ch.Heads + "." + ch.SDKHead
+	seen[key] = true
+	headRan, id := p.asks.get(key, head)
+	if headRan == nil {
+		pending = append(pending, "mesh-sdk "+ch.SDKHead+" (ask "+id+")")
+	}
+	var readers []assign.Reader
+	var notJudged []string
+	for _, module := range sortedNames(assign.ReaderModules) {
+		repository := assign.ReaderModules[module]
+		var commits []string
+		member := false
+		if h := ch.Members[repository]; h != "" {
+			commits, member = []string{h}, true
+		} else {
+			commits = p.w.runningCommits(module)
+		}
+		if len(commits) == 0 {
+			notJudged = append(notJudged, "not judged whether "+module+" reads the group's manifests: the builder's log holds no done "+
+				"trunk build of it, and the group holds no member of "+repository)
+			continue
+		}
+		for _, commit := range commits {
+			job, err := assign.ReaderJob(ch, module, repository, commit)
+			if err != nil {
+				readers = append(readers, assign.Reader{Module: module, Commit: commit, Member: member,
+					Ran: assign.Ran{State: delivery.StepFailed, Reason: err.Error()}})
+				continue
+			}
+			rkey := "reader." + ch.Group + "." + ch.Heads + "." + module + "." + commit
+			seen[rkey] = true
+			ran, rid := p.asks.get(rkey, job)
+			if ran == nil {
+				pending = append(pending, module+" at "+commit+" (ask "+rid+")")
+				continue
+			}
+			readers = append(readers, assign.Reader{Module: module, Commit: commit, Member: member, Ran: *ran})
+		}
+	}
+	if len(pending) > 0 {
+		return waiting("composing on the Go build seat with the mesh-sdk of " + strings.Join(pending, ", "))
+	}
+	v := assign.FromComposer(m, ch, *headRan, readers, time.Since(began))
+	v.Warnings = append(v.Warnings, notJudged...)
+	return v
+}
+
+func sortedNames(m map[string]string) []string {
+	out := make([]string, 0, len(m))
+	for k := range m {
+		out = append(out, k)
+	}
+	sort.Strings(out)
+	return out
+}

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compose_integration_test.go

@@ -0,0 +1,179 @@
+//go:build integration
+
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/nats-io/nats.go/jetstream"
+
+	"git.novox.be/novox/mesh-sdk/go/composer"
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+)
+
+// holder is a test holder of the Go build seat: it takes every ask from the seat's check worker, as mesh-build-go does,
+// and answers a compose ask by running mesh-sdk's composer over the request filled from the indexer's manifests (the
+// linked composer standing for the one the build module builds at the asked commit), writing its step on its node's key.
+type holder struct {
+	mu   sync.Mutex
+	asks []delivery.StepAsk
+}
+
+func (h *holder) taken() []delivery.StepAsk {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	return append([]delivery.StepAsk(nil), h.asks...)
+}
+
+func (b *bed) hold(t *testing.T) *holder {
+	t.Helper()
+	seat, _ := delivery.AskStream(delivery.AskGo)
+	worker, _ := delivery.AskWorker(delivery.AskGo, delivery.AskCheck)
+	subject, _ := delivery.AskSubject(delivery.AskGo, delivery.AskCheck)
+	cons, err := b.js.CreateOrUpdateConsumer(b.ctx, seat, jetstream.ConsumerConfig{Durable: worker, FilterSubject: subject, AckPolicy: jetstream.AckExplicitPolicy})
+	if err != nil {
+		t.Fatal(err)
+	}
+	steps := b.buckets[delivery.StepsBucket(goBuildModule)]
+	h := &holder{}
+	cc, err := cons.Consume(func(m jetstream.Msg) {
+		a, err := delivery.DecodeStepAsk(m.Data())
+		if err != nil || a.Compose == nil {
+			t.Errorf("the seat was put an ask that is not a compose: %v %s", err, m.Data())
+			m.Ack()
+			return
+		}
+		h.mu.Lock()
+		h.asks = append(h.asks, a)
+		h.mu.Unlock()
+		req, err := composer.Decode(a.Compose.Request)
+		if err == nil {
+			err = composer.Fill(&req, func(digest string) ([]byte, error) {
+				key, _ := delivery.ManifestsKey(digest)
+				e, err := b.buckets[delivery.ManifestsBucket].Get(b.ctx, key)
+				if err != nil {
+					return nil, err
+				}
+				man, err := delivery.DecodeManifest(e.Value())
+				return []byte(man.JSON), err
+			})
+		}
+		step := delivery.Step{ID: a.ID, Tool: "compose", Node: "ace", State: delivery.StepPassed, Started: time.Now().UTC(), Ended: time.Now().UTC()}
+		if err != nil {
+			step.State, step.Reason = delivery.StepFailed, err.Error()
+		} else if v, err := composer.Run(req); err != nil {
+			step.State, step.Reason = delivery.StepFailed, err.Error()
+		} else {
+			vr, _ := json.Marshal(v)
+			step.Result, _ = json.Marshal(delivery.ComposeAnswer{Built: true, Key: "composer-0123456789abcdef", Verdict: vr})
+		}
+		raw, err := delivery.EncodeStep(step)
+		if err != nil {
+			t.Errorf("the step cannot be written: %v", err)
+		}
+		key, _ := delivery.AskStepKey("ace", a.ID)
+		if _, err := steps.Put(b.ctx, key, raw); err != nil {
+			t.Errorf("the step %s: %v", key, err)
+		}
+		m.Ack()
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(cc.Stop)
+	return h
+}
+
+// 1622/AC1-AC3 and 1623 on the bus: started whole, the assigner composes a group holding a mesh-sdk pull request by
+// asking the Go build seat for the composer at the member's head, and for the composer at the mesh-sdk the running
+// node-engine pins; it waits naming the asks while they run, writes the verdict from their answers naming the mesh-sdk the
+// head's composer was built with, and asks nothing more on a later pass of the same heads.
+func TestAGroupWithAnSDKMemberIsComposedByTheComposerAtItsHead(t *testing.T) {
+	b := startBed(t, "")
+	trunk := b.manifest(t, "web", `{"module":"web","version":"1"}`)
+	changed := b.manifest(t, "web", `{"module":"web","version":"2"}`)
+	mod, err := delivery.EncodeModule(delivery.Module{FP2: delivery.SourcePrefix2 + strings.Repeat("a", 64), Manifest: trunk, Repository: "novox/web", Commit: strings.Repeat("1", 40), Path: delivery.RootPath})
+	if err != nil {
+		t.Fatal(err)
+	}
+	b.putJSON(t, delivery.ModulesBucket, "web", mod)
+	b.place(t, "g14", "web")
+	running := strings.Repeat("3", 40)
+	b.place(t, "novox", "mesh-host")
+	b.built(t, "mesh-host", "novox/mesh-host", running)
+	sdkHead := strings.Repeat("4", 40)
+	heads := []delivery.Head{{Repository: "novox/mesh-sdk", Number: 80, Head: sdkHead}, {Repository: "novox/web", Number: 7, Head: strings.Repeat("2", 40)}}
+	hash, _ := delivery.HeadsHash(heads)
+	pulls := []delivery.CandidatePull{{Head: heads[0]}, {Head: heads[1],
+		Modules: []string{"web"}, Fps: map[string]delivery.CandidateModule{"web": {FP2: delivery.SourcePrefix2 + strings.Repeat("b", 64), Manifest: changed}}}}
+	cand, err := delivery.EncodeCandidate(delivery.Candidate{Group: "feat/x", HeadsHash: hash, Pulls: pulls, FPSet: delivery.FingerprintSet(pulls)})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ckey, _ := delivery.CandidatesKey("feat/x")
+	b.putJSON(t, delivery.CandidatesBucket, ckey, cand)
+	b.start(t)
+	key, _ := delivery.CompositionKey("feat/x", hash)
+	// No holder takes the asks yet: the composition waits, naming them.
+	waits := b.verdict(t, key, func(v delivery.CompositionVerdict) bool { return v.State == delivery.CompositionWaits })
+	if !strings.Contains(waits.Words, "mesh-sdk "+sdkHead) || !strings.Contains(waits.Words, "mesh-host at "+running) {
+		t.Fatalf("the waiting composition says %q, want the head's and the running node-engine's asks", waits.Words)
+	}
+	h := b.hold(t)
+	v := b.verdict(t, key, func(v delivery.CompositionVerdict) bool { return v.State != delivery.CompositionWaits })
+	if v.State != delivery.CompositionPass || len(v.Machines) != 1 || v.Machines[0] != "g14" || v.SDK == "" {
+		t.Fatalf("composition = %+v, want a pass on g14", v)
+	}
+	asks := h.taken()
+	if len(asks) != 2 {
+		t.Fatalf("the seat was asked %d composes, want two (the head, the running node-engine)", len(asks))
+	}
+	byRepo := map[string]delivery.StepAsk{}
+	for _, a := range asks {
+		byRepo[a.Compose.Fetch["repository"].(string)] = a
+		if a.Asker != AssignerModule || a.Kind != delivery.AskCheck || a.Language != delivery.AskGo {
+			t.Errorf("ask = %+v", a)
+		}
+	}
+	if a := byRepo["novox/mesh-sdk"]; a.Compose == nil || a.Compose.Fetch["commit"] != sdkHead || a.Compose.Dir != "go" {
+		t.Errorf("the head's ask = %+v", a.Compose)
+	}
+	if a := byRepo["novox/mesh-host"]; a.Compose == nil || a.Compose.Fetch["commit"] != running || a.Compose.Dir != delivery.RootPath {
+		t.Errorf("the running node-engine's ask = %+v", a.Compose)
+	}
+	// A later pass of the same heads (woken by any change) asks nothing more.
+	on, _ := delivery.EncodePresence(delivery.Presence{Online: true})
+	b.putJSON(t, delivery.PresenceBucket, "ace", on)
+	time.Sleep(500 * time.Millisecond)
+	if n := len(h.taken()); n != 2 {
+		t.Errorf("a later pass of the same heads asked again: %d asks", n)
+	}
+}
+
+// verdict waits for the composition under key to satisfy ok, and answers it.
+func (b *bed) verdict(t *testing.T, key string, ok func(delivery.CompositionVerdict) bool) delivery.CompositionVerdict {
+	t.Helper()
+	var last delivery.CompositionVerdict
+	for deadline := time.Now().Add(10 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) {
+		e, err := b.buckets[delivery.AssignerCompositionsBucket].Get(b.ctx, key)
+		if errors.Is(err, jetstream.ErrKeyNotFound) {
+			continue
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
+		if last, err = delivery.DecodeCompositionVerdict(e.Value()); err != nil {
+			t.Fatal(err)
+		}
+		if ok(last) {
+			return last
+		}
+	}
+	t.Fatalf("no composition under %s as wanted after 10 s; last %+v", key, last)
+	return last
+}

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/composed.go

@@ -1,73 +0,0 @@
-package main
-
-import (
-	"sort"
-	"strings"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// Every node's published compositions, read only to compare (novox/hq ADR 0593 §8): each node's engine writes its own
-// `composed-<node>` (delivery.ComposedRead, one bucket per node), and `mesh-wants.upgrade` with compare names, for every
-// node, the composition its own have runs beside the newest it published of each module and of the node, so a person sees
-// where they part. The assigner composes nothing and never writes these.
-
-// publishedRow is one composition a node published: the module ("node" for its own), the fingerprint, the digest, or why
-// it was refused or cannot be read.
-type publishedRow struct {
-	Key     string `json:"key"`
-	Module  string `json:"module"`
-	FP      string `json:"fp,omitempty"`
-	Digest  string `json:"digest,omitempty"`
-	Refused string `json:"refused,omitempty"`
-	Unread  string `json:"unread,omitempty"`
-}
-
-// published is, by node, every composition it published, sorted by key, from every key of the per-node state (a key
-// names its node first): each value decoded and digested here, as the node-engine digests it (delivery.ComposedDigestOf).
-// A value or key that does not read is named with why, never left out.
-func published(values map[string][]byte) map[string][]publishedRow {
-	byNode := map[string]map[string][]byte{}
-	for key, raw := range values {
-		node, _, _ := strings.Cut(key, ".")
-		if byNode[node] == nil {
-			byNode[node] = map[string][]byte{}
-		}
-		byNode[node][key] = raw
-	}
-	out := map[string][]publishedRow{}
-	for node, keys := range byNode {
-		var rows []publishedRow
-		for key, raw := range keys {
-			row := publishedRow{Key: key}
-			_, module, fp, isNode, err := delivery.ParseComposedKey(key)
-			switch {
-			case err != nil:
-				row.Unread = err.Error()
-			case isNode:
-				row.Module = "node"
-			default:
-				row.Module, row.FP = module, fp
-			}
-			if err == nil {
-				c, derr := delivery.DecodeComposed(raw)
-				switch {
-				case derr != nil:
-					row.Unread = derr.Error()
-				case c.Refused != "":
-					row.Refused = c.Refused
-				default:
-					if d, err := delivery.ComposedDigestOf(c); err != nil {
-						row.Unread = err.Error()
-					} else {
-						row.Digest = d
-					}
-				}
-			}
-			rows = append(rows, row)
-		}
-		sort.Slice(rows, func(i, j int) bool { return rows[i].Key < rows[j].Key })
-		out[node] = rows
-	}
-	return out
-}

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/integration_test.go

@@ -5,7 +5,6 @@ package main
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"maps"
@@ -13,7 +12,6 @@ import (
 	"path/filepath"
 	"slices"
 	"strings"
-	"sync"
 	"testing"
 	"time"
 
@@ -21,22 +19,15 @@ import (
 	"github.com/nats-io/nats.go"
 	"github.com/nats-io/nats.go/jetstream"
 
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
-	oc "git.novox.be/novox/mesh-contracts/go/seats/operatorchannel"
 	stdio "git.novox.be/novox/mesh-sdk/go"
 	"git.novox.be/novox/mesh-sdk/go/announce"
+	"git.novox.be/novox/mesh-sdk/go/asks"
 	"git.novox.be/novox/mesh-sdk/go/buscompose"
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
+	"git.novox.be/novox/mesh-sdk/go/compose/judge"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 	"git.novox.be/novox/mesh-sdk/go/health"
 	"git.novox.be/novox/mesh-sdk/go/process"
-	"git.novox.be/novox/mesh-sdk/go/provisions"
-	"mesh-delivery-assigner/internal/judge"
-
-	"git.novox.be/novox/mesh-contracts/go/seats/nodeengine"
-	"git.novox.be/novox/mesh-delivery/sdk/enginereads"
-	"git.novox.be/novox/mesh-delivery/sdk/graph"
-	"git.novox.be/novox/mesh-sdk/go/views"
 
 	"mesh-delivery-assigner/internal/assign"
 )
@@ -100,31 +91,13 @@ func startBed(t *testing.T, leaveOut string) *bed {
 		Subjects: []string{buscompose.LogSubject(delivery.BuilderModule, delivery.BuilderLog) + ".>"}, AllowDirect: true}); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: "EVENTS", Subjects: []string{"mesh.mod.*.event.>", "mesh.seat.*.event.>"}}); err != nil {
-		t.Fatal(err)
-	}
-	// The assigner's durable consumer on EVENTS, as the grants part makes it from the manifest's consumes: a node-engine seat's
-	// event names the engine's machine last, so the filter is the event with every machine (mesh-grants buscompose
-	// machineEvent; the grants part's own test holds the derivation).
-	if _, err := js.CreateOrUpdateConsumer(ctx, "EVENTS", jetstream.ConsumerConfig{Durable: "n1_mesh-delivery-assigner",
-		FilterSubjects: []string{enginereads.SubjectPrefix + "*"}, AckPolicy: jetstream.AckExplicitPolicy}); err != nil {
+	if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: "EVENTS", Subjects: []string{"mesh.mod.*.event.>"}}); err != nil {
 		t.Fatal(err)
 	}
 	// The operator-channel seat's stream of conditions, which the assigner says its conditions on.
 	if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: "CONDITIONS", Subjects: []string{"mesh.seat.operator-channel.accept.condition.>"}}); err != nil {
 		t.Fatal(err)
 	}
-	// The indexer as the owner of its manifests and modules (DLV-F2r), with the real owner's side.
-	serveIndexer(t, b, nc)
-	// The assigner's views family and its marks (ADR 0615 §5, ADR 0619 §2), on its old sections.
-	if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: "ASSIGNER_VIEWS", Subjects: []string{"mesh.stream.mesh-delivery-assigner.event.views.>"}}); err != nil {
-		t.Fatal(err)
-	}
-	if kv, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: marksBucket, History: 1}); err != nil {
-		t.Fatal(err)
-	} else {
-		b.buckets[marksBucket] = kv
-	}
 	// The Go build seat's work queue, as the broker derives it from the seat's accepted kinds (delivery.AskStream).
 	seat, _ := delivery.AskStream(delivery.AskGo)
 	if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: seat, Subjects: []string{"mesh.seat.node-build-go.accept.>"},
@@ -317,6 +290,19 @@ func (b *bed) place(t *testing.T, node, module string) {
 	}
 }
 
+// built appends the end of a done trunk build of module at commit to the builder's log, as the builder does.
+func (b *bed) built(t *testing.T, module, repository, commit string) {
+	t.Helper()
+	raw, err := delivery.EncodeBuildLogEntry(delivery.BuildLogEntry{Event: delivery.BuildEndedEvent, Module: module, FP: delivery.SourcePrefix2 + strings.Repeat("c", 64),
+		Repository: repository, Directory: delivery.RootPath, Commit: commit, Node: "novox", At: time.Now().UTC(), Outcome: delivery.BuildDone})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := b.js.Publish(b.ctx, buscompose.LogSubject(delivery.BuilderModule, delivery.BuilderLog)+"."+module, raw); err != nil {
+		t.Fatal(err)
+	}
+}
+
 // compose says the node's own composition is the digest d (a letter repeated), as its have names it (`<node>.node`): a
 // placed node composes its own (ADR 0571 §6), and the controller's composition is read no more. It answers the digest.
 func (b *bed) compose(t *testing.T, node string, d byte) string {
@@ -347,6 +333,62 @@ func (b *bed) manifest(t *testing.T, module, body string) string {
 	return digest
 }
 
+// 1297/AC1: against the real bus, a fixture change touching one module on one machine is composed and answered within
+// seconds under the checker's key of the check, naming the machine composed and the mesh-sdk it composed with.
+func TestAChangeIsComposedOnTheBus(t *testing.T) {
+	b := startBed(t, "")
+	trunk := b.manifest(t, "web", `{"module":"web","version":"1"}`)
+	changed := b.manifest(t, "web", `{"module":"web","version":"2"}`)
+	mod, err := delivery.EncodeModule(delivery.Module{FP2: delivery.SourcePrefix2 + strings.Repeat("a", 64), Manifest: trunk, Repository: "novox/web", Commit: strings.Repeat("1", 40), Path: delivery.RootPath})
+	if err != nil {
+		t.Fatal(err)
+	}
+	b.putJSON(t, delivery.ModulesBucket, "web", mod)
+	b.place(t, "g14", "web")
+	b.place(t, "ace", "other")
+	heads := []delivery.Head{{Repository: "novox/web", Number: 7, Head: strings.Repeat("2", 40)}}
+	hash, _ := delivery.HeadsHash(heads)
+	// 1927/AC1: the candidate carries the fingerprint set the SDK computes, as the indexer writes it.
+	pulls := []delivery.CandidatePull{{Head: heads[0],
+		Modules: []string{"web"}, Fps: map[string]delivery.CandidateModule{"web": {FP2: delivery.SourcePrefix2 + strings.Repeat("b", 64), Manifest: changed}}}}
+	cand, err := delivery.EncodeCandidate(delivery.Candidate{Group: "feat/x", HeadsHash: hash, Pulls: pulls, FPSet: delivery.FingerprintSet(pulls)})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ckey, _ := delivery.CandidatesKey("feat/x")
+	b.putJSON(t, delivery.CandidatesBucket, ckey, cand)
+	began := time.Now()
+	b.start(t)
+	key, _ := delivery.CompositionKey("feat/x", hash)
+	var v delivery.CompositionVerdict
+	for deadline := time.Now().Add(10 * time.Second); ; time.Sleep(50 * time.Millisecond) {
+		if time.Now().After(deadline) {
+			t.Fatalf("no composition under %s after 10 s", key)
+		}
+		e, err := b.buckets[delivery.AssignerCompositionsBucket].Get(b.ctx, key)
+		if err != nil {
+			continue
+		}
+		if v, err = delivery.DecodeCompositionVerdict(e.Value()); err != nil {
+			t.Fatal(err)
+		}
+		break
+	}
+	if v.State != delivery.CompositionPass || len(v.Machines) != 1 || v.Machines[0] != "g14" || v.SDK == "" {
+		t.Fatalf("composition = %+v, want a pass on g14 alone naming its mesh-sdk", v)
+	}
+	if took := time.Since(began); took > 5*time.Second {
+		t.Errorf("the composition took %s", took)
+	}
+	// 1622/AC3: a group without a mesh-sdk member builds no composer: no ask is put on the Go build seat.
+	seat, _ := delivery.AskStream(delivery.AskGo)
+	if st, err := b.js.Stream(b.ctx, seat); err != nil {
+		t.Fatal(err)
+	} else if info, err := st.Info(b.ctx); err != nil || info.State.Msgs != 0 {
+		t.Errorf("a group without a mesh-sdk member put %d asks on the Go build seat (%v)", info.State.Msgs, err)
+	}
+}
+
 // get waits for a key of one of the bed's buckets and answers its value.
 func (b *bed) get(t *testing.T, bucket, key string) []byte {
 	t.Helper()
@@ -366,19 +408,6 @@ func (b *bed) get(t *testing.T, bucket, key string) []byte {
 // raises the condition naming g14, web and the canary rule; once ace runs F healthy, g14's first want names F and the condition is
 // cleared.
 func TestWantsAreWrittenAndNoDifferenceIs(t *testing.T) {
-	// DLV-F5r (ADR 0621 §3): the indexer's runtime starts together with the assigner and answers its first views only
-	// after the assigner asked; within the bound the assigner writes the wants from what they answer.
-	up := make(chan struct{})
-	indexerLate = up
-	// ADR 0631 §2: while the indexer does not answer, past the first-view bound the assigner raises the condition naming
-	// the indexer and graph, and reads nothing of the indexer's state; the answer clears it.
-	firstViewBound, firstViewWait = 300*time.Millisecond, 50*time.Millisecond
-	t.Cleanup(func() { indexerLate, firstViewBound, firstViewWait = nil, 0, 0 })
-	for _, name := range append(append([]string{}, readBuckets...), watched...) {
-		if strings.HasPrefix(name, delivery.IndexerModule+"_") {
-			t.Errorf("the assigner reads the indexer's state %s itself", name)
-		}
-	}
 	b := startBed(t, "")
 	fNew, fOld := delivery.SourcePrefix2+strings.Repeat("b", 64), delivery.SourcePrefix2+strings.Repeat("a", 64)
 	digest := b.manifest(t, "web", `{"module":"web","version":"1"}`)
@@ -406,31 +435,6 @@ func TestWantsAreWrittenAndNoDifferenceIs(t *testing.T) {
 	}
 	b.compose(t, "shanks", 'a')
 	b.start(t)
-	// DLV-F5r (ADR 0621 §1-§3, design 25 § 12 on a fresh mesh): the assigner asks nothing of the bus module (its manifest
-	// has no bus-state entry, the bed runs no bus module and holds no binding of one), and while it still waits on the
-	// indexer its runtime of its own answers each first-view tool to the readers its manifest's callers lists name, at
-	// its mark, and refuses every other account, the assigner's own included.
-	firstViewsBeforeAnyNewFormState(t, b, map[string][]string{
-		"placement":    {"n1.mesh-grants", "n1.node-tools", "n1.mesh-delivery-indexer"},
-		"seat-holders": {"n1.node-tools"},
-		"wants":        {"n1.mesh-grants"},
-	})
-	graphKey, _, _ := views.UnansweredFinding(delivery.AssignerModule, views.Status{Owner: delivery.IndexerModule, State: graph.State}, time.Now())
-	graphRaised := func() bool {
-		e, err := b.buckets[assign.FindingsBucket].Get(b.ctx, graphKey)
-		return err == nil && strings.Contains(string(e.Value()), delivery.IndexerModule+".graph")
-	}
-	for deadline := time.Now().Add(10 * time.Second); !graphRaised(); time.Sleep(50 * time.Millisecond) {
-		if time.Now().After(deadline) {
-			t.Fatalf("with the indexer down, no condition names its graph (finding %s)", graphKey)
-		}
-	}
-	close(up)
-	for deadline := time.Now().Add(10 * time.Second); graphRaised(); time.Sleep(50 * time.Millisecond) {
-		if time.Now().After(deadline) {
-			t.Fatalf("the indexer answered, and the condition naming its graph stands (finding %s)", graphKey)
-		}
-	}
 
 	wkey, _ := delivery.WantKey("ace", "web")
 	want, err := delivery.DecodeWant(b.get(t, delivery.AssignerWantsBucket, wkey))
@@ -440,18 +444,15 @@ func TestWantsAreWrittenAndNoDifferenceIs(t *testing.T) {
 	if w := b.wantNow(t, "shanks", "web", "shanks' first want at what it runs", func(w delivery.Want) bool { return w.FP != "" }); w.FP != fOld || w.Composed != "" || !w.Self || w.Newest != fNew {
 		t.Errorf("shanks' want = %+v, want the fingerprint it runs, the node composing it, held back from F", w)
 	}
-	// DLV-O5 (ADR 0615 §5, ADR 0619 §2): each want is said on the assigner's views family, its value whole at its revision,
-	// and the first view at the mark followed by those events holds it as the bucket does; a waiter on put never wakes.
-	b.viewsHold(t, "wants", wkey)
-	var neither oc.Condition
+	var neither asks.Condition
 	for deadline := time.Now().Add(10 * time.Second); time.Now().Before(deadline) && neither.Key == ""; time.Sleep(100 * time.Millisecond) {
 		for k, c := range b.conditionsSaid(t) {
-			if strings.HasSuffix(k, ".neither") && c.State == occ.StateRaised {
+			if strings.HasSuffix(k, ".neither") && c.State == asks.StateRaised {
 				neither = c
 			}
 		}
 	}
-	if neither.Subject.Machine != "g14" || !strings.HasPrefix(neither.Subject.ID, "g14.web") || neither.Severity != occ.SeverityUrgent || !strings.Contains(neither.Explanation, "canary") {
+	if neither.Subject.Machine != "g14" || !strings.HasPrefix(neither.Subject.ID, "g14.web") || neither.Severity != asks.SeverityUrgent || !strings.Contains(neither.Explanation, "canary") {
 		t.Errorf("the condition of web on neither list on g14 = %+v", neither)
 	}
 	if keys, err := b.buckets[delivery.AssignerDifferencesBucket].Keys(b.ctx); err == nil && len(keys) != 0 {
@@ -471,7 +472,7 @@ func TestWantsAreWrittenAndNoDifferenceIs(t *testing.T) {
 	cleared := false
 	for deadline := time.Now().Add(10 * time.Second); time.Now().Before(deadline) && !cleared; time.Sleep(100 * time.Millisecond) {
 		c, ok := b.conditionsSaid(t)[neither.Key]
-		cleared = ok && c.State == occ.StateCleared
+		cleared = ok && c.State == asks.StateCleared
 	}
 	if !cleared {
 		t.Errorf("the condition of web on neither list on g14 was not cleared once g14 got its want")
@@ -502,173 +503,6 @@ func TestWantsAreWrittenAndNoDifferenceIs(t *testing.T) {
 	if !self {
 		t.Error("ace's own want does not say it composes its own once placed")
 	}
-
-	// ADR 0603 (L3, D15): one source revision changes a provider (db), its new consumer (app) and a build module (tool, whose
-	// recipe moved: ace runs its first build and the second, under the agreed toolchain, is the one the source revision names).
-	// The keys are written as their writers write them: the indexer's modules and manifests, the builder's builds, the
-	// controller's grants, the placement seat's placement and the provisioner's provisions. The build module's want moves at
-	// once and the provider's with it; the consumer's waits for its provision, with the words naming it, and moves once the
-	// provisioner provides it (rule 8, ADR 0570 §4): nothing waits for a turn or an order, only for a key.
-	offer := `"provides":[{"name":"database","scope":"mesh","answered-by":"helper"}]`
-	dbDigest := b.manifest(t, "db", `{"module":"db","version":"1",`+offer+`}`)
-	appDigest := b.manifest(t, "app", `{"module":"app","version":"1","requires":["database"]}`)
-	toolDigest := b.manifest(t, "tool", `{"module":"tool","version":"1"}`)
-	asked := func(state, why string) {
-		raw, err := provisions.Encode(provisions.Provision{V: provisions.Version, Provision: "database", Consumer: provisions.End{Module: "app", Node: "ace"},
-			Provider: provisions.End{Module: "db", Node: "ace"}, State: state, Why: why, At: time.Now()})
-		if err != nil {
-			t.Fatal(err)
-		}
-		b.putJSON(t, provisions.ProvisionsBucket, "ace.app.database", raw)
-	}
-	// The provisioner keys it from the manifests, as soon as they are known and whether the provider is placed yet or not.
-	asked(provisions.Asked, "the provider's build is not done")
-	fpOf := func(c byte) string { return delivery.SourcePrefix2 + strings.Repeat(string(c), 64) }
-	toolOld := fpOf('1')
-	for module, row := range map[string]struct {
-		fp, digest string
-	}{"db": {fpOf('2'), dbDigest}, "app": {fpOf('3'), appDigest}, "tool": {fpOf('4'), toolDigest}} {
-		mod, _ := delivery.EncodeModule(delivery.Module{FP2: row.fp, Manifest: row.digest, Repository: "novox/" + module, Commit: strings.Repeat("2", 40), Path: delivery.RootPath})
-		b.putJSON(t, delivery.ModulesBucket, module, mod)
-		fps := []string{row.fp}
-		if module == "tool" {
-			fps = append(fps, toolOld)
-		}
-		for _, fp := range fps {
-			built, _ := delivery.EncodeBuilderBuild(delivery.BuilderBuild{State: delivery.BuildDone, By: "builder.novox.1", Step: "pushed", Manifest: row.digest})
-			bkey, _ := delivery.BuilderBuildKey(module, fp)
-			b.putJSON(t, delivery.BuilderBuildsBucket, bkey, built)
-			gkey, _ := delivery.PartGrantKey(module, fp)
-			grant, _ := delivery.EncodeGrant(delivery.Grant{})
-			b.putJSON(t, delivery.PartGrantsBucket, gkey, grant)
-		}
-		b.place(t, "ace", module)
-	}
-	runsOld, _ := delivery.EncodeHave(delivery.Have{FP: toolOld, Phase: delivery.PhaseRunning, Health: delivery.HealthOK})
-	b.putJSON(t, delivery.HaveBucket, "ace.tool", runsOld)
-	if w := b.wantNow(t, "ace", "tool", "the build module's want at the second build", func(w delivery.Want) bool { return w.FP == fpOf('4') }); w.FP != fpOf('4') {
-		t.Errorf("tool's want = %+v", w)
-	}
-	b.wantNow(t, "ace", "db", "the provider's want at its fingerprint", func(w delivery.Want) bool { return w.FP == fpOf('2') })
-	if e, err := b.buckets[delivery.AssignerWantsBucket].Get(b.ctx, "want.ace.app"); err == nil {
-		t.Errorf("app was wanted while its provision was asked: %s", e.Value())
-	}
-	asked(provisions.Provided, "")
-	if w := b.wantNow(t, "ace", "app", "the consumer's want once its provision is provided", func(w delivery.Want) bool { return w.FP == fpOf('3') }); w.FP != fpOf('3') {
-		t.Errorf("app's want = %+v", w)
-	}
-
-	// ADR 0618 §1, §3, §4, ADR 0624 §2: ace's engine answers the node-engine seat's manifest-reads; a build written only in a
-	// form it does not state is held on ace, naming the form, and moves once the engine says manifest-reads-changed on its
-	// subject and states the form; no timer moves it. g14's engine answers nothing and has no record: read as the baseline.
-	stated := catalogue.ManifestReads()
-	var statedMu sync.Mutex
-	nc, err := nats.Connect(b.srv.ClientURL())
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer nc.Close()
-	if _, err := nc.Subscribe("mesh.seat.node-engine.tool.manifest-reads.ace", func(m *nats.Msg) {
-		statedMu.Lock()
-		answer, _ := json.Marshal(nodeengine.ManifestReadsAnswer{V: 1, Node: "ace", ManifestReads: stated, StatedAt: time.Now().Format(time.RFC3339Nano)})
-		statedMu.Unlock()
-		reply, _ := json.Marshal(map[string]any{"result": json.RawMessage(answer), "node": "ace"})
-		_ = m.Respond(reply)
-	}); err != nil {
-		t.Fatal(err)
-	}
-	say := func(why string) {
-		body, _ := json.Marshal(nodeengine.ManifestReadsChangedEvent{V: 1, Node: "ace", ManifestReads: stated, At: time.Now().Format(time.RFC3339Nano), Why: why})
-		if _, err := b.js.Publish(b.ctx, enginereads.SubjectPrefix+"ace", body); err != nil {
-			t.Fatal(err)
-		}
-	}
-	say(enginereads.ReadsStarted)
-	formsOld, formsNew := fpOf('5'), fpOf('6')
-	formsDigest := b.manifest(t, "forms", `{"module":"forms","version":"1"}`)
-	formsAt := func(fp string) {
-		mod, _ := delivery.EncodeModule(delivery.Module{FP2: fp, Manifest: formsDigest, Repository: "novox/forms", Commit: strings.Repeat("3", 40), Path: delivery.RootPath})
-		b.putJSON(t, delivery.ModulesBucket, "forms", mod)
-	}
-	for _, fp := range []string{formsOld, formsNew} {
-		build := delivery.BuilderBuild{State: delivery.BuildDone, By: "builder.novox.1", Step: "pushed", Manifest: formsDigest}
-		if fp == formsNew {
-			build.Needs = []string{"form:new"}
-		}
-		built, err := delivery.EncodeBuilderBuild(build)
-		if err != nil {
-			t.Fatal(err)
-		}
-		bkey, _ := delivery.BuilderBuildKey("forms", fp)
-		b.putJSON(t, delivery.BuilderBuildsBucket, bkey, built)
-		gkey, _ := delivery.PartGrantKey("forms", fp)
-		grant, _ := delivery.EncodeGrant(delivery.Grant{})
-		b.putJSON(t, delivery.PartGrantsBucket, gkey, grant)
-	}
-	runsFormsOld, _ := delivery.EncodeHave(delivery.Have{FP: formsOld, Phase: delivery.PhaseRunning, Health: delivery.HealthOK})
-	b.putJSON(t, delivery.HaveBucket, "ace.forms", runsFormsOld)
-	b.place(t, "ace", "forms")
-	formsAt(formsOld)
-	b.wantNow(t, "ace", "forms", "the want at what ace runs, a build in the first form", func(w delivery.Want) bool { return w.FP == formsOld })
-	formsAt(formsNew)
-	statement := func(node string, ok func(enginereads.Statement) bool) enginereads.Statement {
-		var last enginereads.Statement
-		for deadline := time.Now().Add(15 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) {
-			if e, err := b.buckets[engineReadsBucket].Get(b.ctx, node); err == nil {
-				if last, err = enginereads.Decode(e.Value()); err == nil && ok(last) {
-					return last
-				}
-			}
-		}
-		t.Fatalf("%s's engine reads are %+v", node, last)
-		return last
-	}
-	statement("ace", func(s enginereads.Statement) bool { return s.From == enginereads.FromVerb && s.Answered })
-	if s := statement("g14", func(s enginereads.Statement) bool { return !s.Answered }); s.From != enginereads.FromNone {
-		t.Errorf("g14, whose engine answers nothing and which has no record, reads %+v", s)
-	}
-	if w := b.wantNow(t, "ace", "forms", "the want held on ace, naming the form", func(w delivery.Want) bool {
-		return w.Newest == formsNew && strings.Contains(w.Words, "form:new")
-	}); w.FP != formsOld || w.Rule != delivery.RuleComposed {
-		t.Errorf("forms' want = %+v, want it held at what ace runs under rule 7", w)
-	}
-	statedMu.Lock()
-	stated = append(slices.Clone(stated), "form:new")
-	statedMu.Unlock()
-	say(enginereads.ReadsStarted)
-	b.wantNow(t, "ace", "forms", "the want moved once ace's engine said it reads the form", func(w delivery.Want) bool { return w.FP == formsNew })
-	// assigner_engine_reads asks ace's engine again through the state: the assigner answers there with what it states now.
-	again, err := enginereads.AskAgainOf(bedState{b, engineReadsBucket}, "ace", "n1.ada", "a person asks", time.Now(), 15*time.Second)
-	if err != nil || again.From != enginereads.FromVerb || !slices.Contains(again.ManifestReads, "form:new") || again.AskAgain != nil {
-		t.Errorf("the ask again of ace answered %+v, %v", again, err)
-	}
-}
-
-// bedState is one of the bed's buckets as the engine reads' tool reads it.
-type bedState struct {
-	b      *bed
-	bucket string
-}
-
-func (s bedState) Keys() ([]string, error) { return s.b.buckets[s.bucket].Keys(s.b.ctx) }
-func (s bedState) Get(key string) ([]byte, uint64, bool, error) {
-	e, err := s.b.buckets[s.bucket].Get(s.b.ctx, key)
-	if err != nil {
-		return nil, 0, false, nil
-	}
-	return e.Value(), e.Revision(), true, nil
-}
-func (s bedState) Put(key string, value []byte) (uint64, error) {
-	return s.b.buckets[s.bucket].Put(s.b.ctx, key, value)
-}
-func (s bedState) Delete(key string) error { return s.b.buckets[s.bucket].Delete(s.b.ctx, key) }
-func (s bedState) Await(key string, after uint64, done func([]byte) bool, bound time.Duration) ([]byte, error) {
-	for deadline := time.Now().Add(bound); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) {
-		if v, rev, found, _ := s.Get(key); found && rev > after && done(v) {
-			return v, nil
-		}
-	}
-	return nil, fmt.Errorf("no answer at %s within %s", key, bound)
 }
 
 // 1297/B9 (the assigner's half, ADR 0528 clause 6): started whole, the assigner holds a fingerprint whose health check
@@ -693,7 +527,7 @@ func TestAHeldFingerprintIsAskedAbout(t *testing.T) {
 		t.Fatalf("held = %+v, %v", h, err)
 	}
 	akey, _ := delivery.HoldAskKey("web", fNew)
-	a, err := decodeAsk(akey, b.get(t, delivery.AssignerAsksBucket, akey))
+	a, err := delivery.DecodeAssignerAsk(akey, b.get(t, delivery.AssignerAsksBucket, akey))
 	if err != nil || a.Asking <= 0 || a.Ask.ID != delivery.AskingID(akey, a.Asking) || len(a.Ask.Options) != 2 {
 		t.Fatalf("the ask = %+v, %v", a, err)
 	}
@@ -702,27 +536,27 @@ func TestAHeldFingerprintIsAskedAbout(t *testing.T) {
 // conditionsSaid reads what the assigner said of its conditions, by finding key: each a finding in its own bucket, which
 // the condition keeper carries (novox/hq ADR 0590 §3, issue 1126), raised while it stands and cleared once deleted, each
 // with the words its last finding said and the subject the finding names (`<module>[.<fingerprint>]`).
-func (b *bed) conditionsSaid(t *testing.T) map[string]oc.Condition {
+func (b *bed) conditionsSaid(t *testing.T) map[string]asks.Condition {
 	t.Helper()
 	w, err := b.buckets[assign.FindingsBucket].WatchAll(b.ctx, jetstream.IncludeHistory())
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer w.Stop()
-	out := map[string]oc.Condition{}
+	out := map[string]asks.Condition{}
 	for e := range w.Updates() {
 		if e == nil {
 			return out
 		}
 		c := out[e.Key()]
-		c.Key, c.State = e.Key(), occ.StateCleared
+		c.Key, c.State = e.Key(), asks.StateCleared
 		if e.Operation() == jetstream.KeyValuePut {
 			f, err := health.DecodeFinding(e.Value())
 			if err != nil {
 				t.Fatal(err)
 			}
-			c = oc.Condition{Key: e.Key(), State: occ.StateRaised, Severity: string(f.Severity), Explanation: f.Explanation,
-				Resolved: f.Resolved, Subject: oc.ConditionSubject{Scope: string(f.Subject.Scope), ID: f.Subject.ID, Machine: f.Subject.Machine}}
+			c = asks.Condition{Key: e.Key(), State: asks.StateRaised, Severity: string(f.Severity), Explanation: f.Explanation,
+				Resolved: f.Resolved, Subject: asks.Scope{Scope: string(f.Subject.Scope), ID: f.Subject.ID, Machine: f.Subject.Machine}}
 		}
 		out[e.Key()] = c
 	}
@@ -749,7 +583,7 @@ func TestAFailedDataModuleIsAskedToRestore(t *testing.T) {
 	b.start(t)
 
 	akey, _ := delivery.RestoreAskKey("ace", "mail", fNew)
-	a, err := decodeAsk(akey, b.get(t, delivery.AssignerAsksBucket, akey))
+	a, err := delivery.DecodeAssignerAsk(akey, b.get(t, delivery.AssignerAsksBucket, akey))
 	if err != nil || len(a.Ask.Options) != 2 || a.Ask.Options[0].ID != "restore" || a.Ask.Options[1].ID != "leave-stopped" {
 		t.Fatalf("the restore ask = %+v, %v", a, err)
 	}
@@ -759,7 +593,7 @@ func TestAFailedDataModuleIsAskedToRestore(t *testing.T) {
 	key := ""
 	for deadline := time.Now().Add(10 * time.Second); time.Now().Before(deadline) && key == ""; time.Sleep(100 * time.Millisecond) {
 		for k, c := range b.conditionsSaid(t) {
-			if c.State == occ.StateRaised && strings.HasPrefix(c.Subject.ID, "mail.") && strings.HasSuffix(k, ".held") {
+			if c.State == asks.StateRaised && strings.HasPrefix(c.Subject.ID, "mail.") && strings.HasSuffix(k, ".held") {
 				if c.Subject.Machine != "ace" || !strings.Contains(c.Explanation, "connection refused") {
 					t.Fatalf("the condition = %+v, want it to name ace and the check's words", c)
 				}
@@ -877,7 +711,7 @@ func (b *bed) wantNow(t *testing.T, node, module, what string, ok func(delivery.
 // answer says the teller wrote the operator's answer to the ask that stands at key (its warrant names that asking's id).
 func (b *bed) answer(t *testing.T, key, option string) {
 	t.Helper()
-	a, err := decodeAsk(key, b.get(t, delivery.AssignerAsksBucket, key))
+	a, err := delivery.DecodeAssignerAsk(key, b.get(t, delivery.AssignerAsksBucket, key))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -927,7 +761,7 @@ func TestAReleaseAnswerWritesTheWantAgain(t *testing.T) {
 	for deadline := time.Now().Add(10 * time.Second); time.Now().Before(deadline); time.Sleep(100 * time.Millisecond) {
 		cleared := false
 		for k, c := range b.conditionsSaid(t) {
-			cleared = cleared || (strings.HasPrefix(k, "module.web.") && c.State == occ.StateCleared && strings.HasSuffix(k, ".held"))
+			cleared = cleared || (strings.HasPrefix(k, "module.web.") && c.State == asks.StateCleared && strings.HasSuffix(k, ".held"))
 		}
 		if cleared {
 			return
@@ -937,17 +771,17 @@ func TestAReleaseAnswerWritesTheWantAgain(t *testing.T) {
 }
 
 // askNow waits for the backup ask at key to be the one numbered asking and answers it.
-func (b *bed) askNow(t *testing.T, key string, asking int) decodedAsk {
+func (b *bed) askNow(t *testing.T, key string, asking int) delivery.AssignerAsk {
 	t.Helper()
 	for deadline := time.Now().Add(15 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) {
 		if e, err := b.buckets[delivery.AssignerAsksBucket].Get(b.ctx, key); err == nil {
-			if a, err := decodeAsk(key, e.Value()); err == nil && a.Asking == asking {
+			if a, err := delivery.DecodeAssignerAsk(key, e.Value()); err == nil && a.Asking == asking {
 				return a
 			}
 		}
 	}
 	t.Fatalf("the ask at %s never became asking %d", key, asking)
-	return decodedAsk{}
+	return delivery.AssignerAsk{}
 }
 
 // 1906/D4 (ADR 0539 §16), whole on the bus: a module held on a node because its backup failed is asked about, and the answer
@@ -1017,7 +851,7 @@ func TestAHoldIsLiftedOnceEveryNodeRunsItHealthy(t *testing.T) {
 			continue
 		}
 		for k, c := range b.conditionsSaid(t) {
-			if strings.HasPrefix(k, "module.web.") && c.State == occ.StateCleared && strings.HasSuffix(k, ".held") {
+			if strings.HasPrefix(k, "module.web.") && c.State == asks.StateCleared && strings.HasSuffix(k, ".held") {
 				if w := b.wantNow(t, "ace", "web", "the want at the lifted fingerprint", func(w delivery.Want) bool { return w.FP == fNew }); w.Rule != 0 {
 					t.Errorf("the want = %+v", w)
 				}
@@ -1042,7 +876,7 @@ func TestAHoldWrittenAgainAfterALiftAndARestartIsAskedAgain(t *testing.T) {
 	_, stop := b.startStoppable(t)
 	hkey, _ := delivery.HeldKey("web", fNew)
 	akey, _ := delivery.HoldAskKey("web", fNew)
-	first, err := decodeAsk(akey, b.get(t, delivery.AssignerAsksBucket, akey))
+	first, err := delivery.DecodeAssignerAsk(akey, b.get(t, delivery.AssignerAsksBucket, akey))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1057,7 +891,7 @@ func TestAHoldWrittenAgainAfterALiftAndARestartIsAskedAgain(t *testing.T) {
 	b.answerTo(t, akey, "keep", first.Ask.ID) // an answer to the first hold, which the later hold must not take
 	b.putJSON(t, delivery.HaveBucket, "ace.web", failed)
 	b.start(t)
-	again, err := decodeAsk(akey, b.get(t, delivery.AssignerAsksBucket, akey))
+	again, err := delivery.DecodeAssignerAsk(akey, b.get(t, delivery.AssignerAsksBucket, akey))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1116,7 +950,7 @@ func (s bedStore) history(string, string) ([]stdio.StateRevision, error) { retur
 func TestAProposalIsAnsweredApprovedAndWritten(t *testing.T) {
 	b := startBed(t, "")
 	if _, err := b.js.CreateStream(b.ctx, jetstream.StreamConfig{Name: "MOD_" + delivery.AssignerModule + "_placement",
-		Subjects: placementSubjects()}); err != nil { // the seat's four events: the views family has a stream of its own
+		Subjects: []string{process.ModuleStreamSubject(delivery.AssignerModule, ">")}}); err != nil {
 		t.Fatal(err)
 	}
 	heard := make(chan delivery.PlacementEvent, 16)
@@ -1287,17 +1121,16 @@ func TestAProposalIsAnsweredApprovedAndWritten(t *testing.T) {
 		t.Error("a declined proposal wrote its key")
 	}
 
-	// ADR 0593 §8: a node that does not answer is named as giving no answer once its pulse key's time to live ends, heard on
-	// the bus with no timer of the assigner's, and the proposal is decided on the answers it has: asked, not failed.
+	// ADR 0567 §4: a node that does not answer fails the verdict once its pulse key's time to live ends, heard on the bus
+	// with no timer of the assigner's, naming it.
 	q, err = verbs.doPropose(map[string]any{"why": "again", "changes": `[{"op":"take-off","node":"laptop","module":"web"}]`}, "op")
 	if err != nil {
 		t.Fatal(err)
 	}
 	silent := q.(proposed).Proposal
-	decided := proposalNow(silent.ID, "decided without its silent nodes", func(p delivery.PlacementProposal) bool { return p.State == delivery.ProposalAsked })
-	if decided.Verdict == nil || decided.Verdict.State != delivery.VerdictPass ||
-		!strings.Contains(strings.Join(decided.Verdict.Notes, "; "), "no answer from") || !strings.Contains(strings.Join(decided.Verdict.Notes, "; "), "laptop (offline)") {
-		t.Errorf("the silent node's verdict = %+v", decided.Verdict)
+	failed := proposalNow(silent.ID, "failed for a silent node", func(p delivery.PlacementProposal) bool { return p.State == delivery.ProposalFailed })
+	if failed.Verdict == nil || !strings.Contains(strings.Join(failed.Verdict.Fails, "; "), "laptop (offline) did not answer") {
+		t.Errorf("the silent node's verdict = %+v", failed.Verdict)
 	}
 
 	// 774/S59 (ADR 0587 §7): a joining node is written on the enrolment's warrant with no node to answer and no ask raised,
@@ -1346,270 +1179,3 @@ func TestAProposalIsAnsweredApprovedAndWritten(t *testing.T) {
 		t.Error("the removed node's key stays")
 	}
 }
-
-// viewsHold waits until a follower of state, from a first view at its mark and the views family's events, holds key as
-// the bucket does, and checks that no views event landed where a waiter on the assigner's put waits.
-func (b *bed) viewsHold(t *testing.T, state, key string) {
-	t.Helper()
-	kv, marks := b.buckets[viewedStates[state]], b.buckets[marksBucket]
-	src := func(kv jetstream.KeyValue) views.Source { return bedSource{b.ctx, kv} }
-	st, err := b.js.Stream(b.ctx, "ASSIGNER_VIEWS")
-	if err != nil {
-		t.Fatal(err)
-	}
-	for deadline := time.Now().Add(20 * time.Second); ; time.Sleep(50 * time.Millisecond) {
-		f := &views.Follower{Owner: delivery.AssignerModule, Tool: state, State: state, Ask: func(context.Context, string) (views.Answer, error) {
-			return views.FirstView(delivery.AssignerModule, state, src(kv), src(marks), "", time.Now())
-		}}
-		if err := f.Start(b.ctx); err != nil {
-			t.Fatal(err)
-		}
-		info, _ := st.Info(b.ctx)
-		gap := false
-		for seq := info.State.FirstSeq; seq > 0 && seq <= info.State.LastSeq; seq++ {
-			m, err := st.GetMsg(b.ctx, seq)
-			if err != nil || views.StateOfEvent(m.Subject) != state {
-				continue
-			}
-			e, err := views.DecodeEvent(m.Data)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if g, _ := f.Apply(e); g {
-				gap = true
-			}
-		}
-		e, err := kv.Get(b.ctx, key)
-		v, ok := f.Get(key)
-		if err == nil && ok && !gap && string(v) == string(e.Value()) && f.Status().Revision >= e.Revision() {
-			break
-		}
-		if time.Now().After(deadline) {
-			t.Fatalf("the views family holds %s.%s as %s at %d (gap %v), the bucket %v", state, key, v, f.Status().Revision, gap, err)
-		}
-	}
-	ev, err := b.js.Stream(b.ctx, "EVENTS")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := ev.GetLastMsgForSubject(b.ctx, "mesh.mod.mesh-delivery-assigner.event.put"); err == nil {
-		t.Errorf("a waiter on put woke: the bus holds a put")
-	}
-}
-
-// bedSource is a bucket as a views.Source.
-type bedSource struct {
-	ctx context.Context
-	kv  jetstream.KeyValue
-}
-
-func (s bedSource) Keys() ([]string, error) {
-	k, err := s.kv.Keys(s.ctx)
-	if errors.Is(err, jetstream.ErrNoKeysFound) {
-		return nil, nil
-	}
-	return k, err
-}
-
-func (s bedSource) Get(key string) (*views.Entry, bool, error) {
-	e, err := s.kv.Get(s.ctx, key)
-	if errors.Is(err, jetstream.ErrKeyNotFound) {
-		return nil, false, nil
-	}
-	if err != nil {
-		return nil, false, err
-	}
-	return &views.Entry{Value: e.Value(), Revision: e.Revision()}, true, nil
-}
-
-// placementSubjects are the subjects of the seat's four events on the assigner's stream placement.
-func placementSubjects() []string {
-	var out []string
-	for _, e := range delivery.PlacementEvents {
-		out = append(out, process.ModuleStreamSubject(delivery.AssignerModule, e))
-	}
-	return out
-}
-
-// indexerLate, when set before the bed is made, fails every ask of the indexer's first views until it is closed: the
-// indexer down, its runtime coming up after the assigner asked (DLV-F5r, ADR 0631 §2).
-var indexerLate chan struct{}
-
-// serveIndexer is the indexer as the owner of its manifests, modules and module graph (ADR 0615, ADR 0621, ADR 0631): its
-// buckets, which a test fills as the indexer writes them; its views family said by the views emitter onto INDEXER_VIEWS,
-// read by the assigner's durable consumer; and its first-view tools of the three answered from the buckets at their marks.
-func serveIndexer(t *testing.T, b *bed, nc *nats.Conn) {
-	t.Helper()
-	marks, err := b.js.CreateKeyValue(b.ctx, jetstream.KeyValueConfig{Bucket: delivery.IndexerModule + "_" + views.MarksState, History: 1})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := b.js.CreateStream(b.ctx, jetstream.StreamConfig{Name: "INDEXER_VIEWS", Subjects: []string{"mesh.stream.mesh-delivery-indexer.event.views.>"}}); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := b.js.CreateOrUpdateConsumer(b.ctx, "INDEXER_VIEWS", jetstream.ConsumerConfig{Durable: "n1_mesh-delivery-assigner", AckPolicy: jetstream.AckExplicitPolicy}); err != nil {
-		t.Fatal(err)
-	}
-	em := views.Emitter{Owner: delivery.IndexerModule, Subject: func(e string) string { return process.ModuleStreamSubject(delivery.IndexerModule, e) },
-		Publish: views.JetStreamPublish(b.js), Marks: marks}
-	for state, bucket := range indexerFirstViews {
-		kv, err := b.js.CreateKeyValue(b.ctx, jetstream.KeyValueConfig{Bucket: bucket, History: 5})
-		if err != nil {
-			t.Fatal(err)
-		}
-		b.buckets[bucket] = kv
-		if err := em.Start(b.ctx, state, kv, nil); err != nil {
-			t.Fatal(err)
-		}
-		late := indexerLate
-		sub, err := nc.Subscribe("mesh.mod.mesh-delivery-indexer.call."+state+".>", func(m *nats.Msg) {
-			if late != nil { // its runtime comes up after the assigner started (DLV-F5r): until then every ask fails, as on a down indexer
-				select {
-				case <-late:
-				default:
-					_ = m.Respond([]byte(`{"error":"the indexer's runtime is not up"}`))
-					return
-				}
-			}
-			var args struct {
-				After string `json:"after"`
-			}
-			_ = json.Unmarshal(m.Data, &args)
-			a, err := views.FirstView(delivery.IndexerModule, state, bedSource{b.ctx, kv}, bedSource{b.ctx, marks}, args.After, time.Now())
-			out := map[string]any{"result": a, "node": "n0"}
-			if err != nil {
-				out = map[string]any{"error": err.Error()}
-			}
-			raw, _ := json.Marshal(out)
-			_ = m.Respond(raw)
-		})
-		if err != nil {
-			t.Fatal(err)
-		}
-		t.Cleanup(func() { _ = sub.Unsubscribe() })
-	}
-}
-
-// firstViewsBeforeAnyNewFormState serves the assigner's first-view tools as its runtime of its own does (the tools bundle's
-// viewTools over the bed's buckets, the env its manifest's bundle writes, the caller the runtime proves from the subject's
-// last token), before any new-form state exists, and asks each from every reader granted and from the others.
-func firstViewsBeforeAnyNewFormState(t *testing.T, b *bed, granted map[string][]string) {
-	t.Helper()
-	raw, err := os.ReadFile(filepath.Join("..", "..", "module.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	m, err := catalogue.Decode(raw)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(m.BusState) != 0 {
-		t.Fatalf("the assigner asks bus state of the bus module: %+v", m.BusState)
-	}
-	var manifest struct {
-		Build struct {
-			Artifacts []struct {
-				Kind string            `json:"kind"`
-				Env  map[string]string `json:"env"`
-			} `json:"artifacts"`
-		} `json:"build"`
-	}
-	if err := json.Unmarshal(raw, &manifest); err != nil {
-		t.Fatal(err)
-	}
-	env := map[string]string{}
-	for _, a := range manifest.Build.Artifacts {
-		if a.Kind == "bundle" {
-			env = a.Env
-		}
-	}
-	state := func(name string) views.Source {
-		if name == views.MarksState {
-			return bedSource{b.ctx, b.buckets[marksBucket]}
-		}
-		return bedSource{b.ctx, b.buckets[viewedStates[name]]}
-	}
-	// The runtime: one bundle on a pair of pipes, a call on mesh.mod.<module>.call.<tool>.<caller token> handed to it with
-	// the caller in _meta, its answer replied as the tool runner replies ({result, error, node}).
-	inR, inW := io.Pipe()
-	outR, outW := io.Pipe()
-	t.Cleanup(func() { inW.Close(); outW.Close() })
-	go func() {
-		_ = stdio.ServeOn(delivery.AssignerModule, viewTools(func(k string) string { return env[k] }, state, time.Now), inR, outW)
-	}()
-	answers := make(chan map[string]any, 16)
-	go func() {
-		dec := json.NewDecoder(outR)
-		for {
-			var line map[string]any
-			if dec.Decode(&line) != nil {
-				return
-			}
-			if _, asked := line["method"]; !asked {
-				answers <- line
-			}
-		}
-	}()
-	one := make(chan struct{}, 1) // one call at a time on the pipe, so each answer is its call's
-	nc, err := nats.Connect(b.srv.ClientURL())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(nc.Close)
-	sub, err := nc.Subscribe("mesh.mod."+delivery.AssignerModule+".call.*.*", func(msg *nats.Msg) {
-		one <- struct{}{}
-		defer func() { <-one }()
-		tokens := strings.Split(msg.Subject, ".")
-		var args map[string]any
-		_ = json.Unmarshal(msg.Data, &args)
-		call, _ := json.Marshal(map[string]any{"jsonrpc": "2.0", "id": "c", "method": "tools/call", "params": map[string]any{"name": tokens[4],
-			"arguments": args, "_meta": map[string]any{stdio.MetaCaller: strings.ReplaceAll(tokens[5], "~", ".")}}})
-		if _, err := inW.Write(append(call, '\n')); err != nil {
-			return
-		}
-		a := <-answers
-		res, _ := a["result"].(map[string]any)
-		content, _ := res["content"].([]any)
-		text := ""
-		if len(content) == 1 {
-			text, _ = content[0].(map[string]any)["text"].(string)
-		}
-		out := map[string]any{"result": json.RawMessage(text), "node": "n1"}
-		if isErr, _ := res["isError"].(bool); isErr || len(content) != 1 {
-			out = map[string]any{"error": text}
-		}
-		reply, _ := json.Marshal(out)
-		_ = msg.Respond(reply)
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _ = sub.Unsubscribe() })
-	ask := func(user, tool string) (views.Answer, error) {
-		return views.AskVia(func(key string, body any) (json.RawMessage, error) {
-			data, _ := json.Marshal(body)
-			msg, err := nc.Request("mesh.mod."+delivery.AssignerModule+".call."+tool+"."+strings.ReplaceAll(user, ".", "~"), data, 5*time.Second)
-			if err != nil {
-				return nil, err
-			}
-			return msg.Data, nil
-		}, tool)(b.ctx, "")
-	}
-	readers := []string{"n1.mesh-grants", "n1.node-tools", "n1.mesh-delivery-indexer", "n1.mesh-delivery-assigner", "n1.mesh-delivery-builder"}
-	for tool, allowed := range granted {
-		for _, user := range readers {
-			a, err := ask(user, tool)
-			switch {
-			case slices.Contains(allowed, user) && err != nil:
-				t.Errorf("%s's first view of %s before any new-form state: %v", user, tool, err)
-			case slices.Contains(allowed, user):
-				keys, _ := b.buckets[viewedStates[tool]].Keys(b.ctx)
-				if a.Owner != delivery.AssignerModule || a.State != tool || len(a.Values) != len(keys) {
-					t.Errorf("%s's first view of %s = %+v, the state holds %v", user, tool, a, keys)
-				}
-			case err == nil || !strings.Contains(err.Error(), "refused"):
-				t.Errorf("%s, granted no first view of %s, was answered %+v, %v", user, tool, a, err)
-			}
-		}
-	}
-}

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go

@@ -15,23 +15,23 @@ import (
 	"os"
 	"os/signal"
 	"slices"
+	"sync/atomic"
 	"syscall"
 	"time"
 
 	"github.com/nats-io/nats.go"
 	"github.com/nats-io/nats.go/jetstream"
 
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
-	oc "git.novox.be/novox/mesh-contracts/go/seats/operatorchannel"
+	stdio "git.novox.be/novox/mesh-sdk/go"
 	"git.novox.be/novox/mesh-sdk/go/announce"
+	"git.novox.be/novox/mesh-sdk/go/asks"
+	"git.novox.be/novox/mesh-sdk/go/buscompose"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 	"git.novox.be/novox/mesh-sdk/go/health"
 	"git.novox.be/novox/mesh-sdk/go/process"
 	"git.novox.be/novox/mesh-sdk/go/provisions"
 
-	"git.novox.be/novox/mesh-delivery/sdk/enginereads"
-	"git.novox.be/novox/mesh-sdk/go/views"
-
 	"mesh-delivery-assigner/internal/assign"
 )
 
@@ -56,33 +56,33 @@ func main() {
 // readBuckets are the buckets of other parts the assigner reads, each named in its manifest's reads (the manifest test
 // holds the two lists equal), so the controller's broker grants exactly these.
 var readBuckets = []string{
+	buscompose.ResolvedBucket,
 	delivery.PartGrantsBucket,
 	delivery.AnswersBucket,
 	delivery.BuilderBuildsBucket,
+	delivery.CandidatesBucket,
+	delivery.ManifestsBucket,
+	delivery.ModulesBucket,
 	delivery.PresenceBucket,
 	delivery.HaveBucket,
+	delivery.StepsBucket(goBuildModule),
 	provisions.ProvisionsBucket,
-	delivery.SourceBucket,
-	delivery.MergesBucket,
+	keptBucket,
 }
 
-// readFamilies are the states kept one bucket per node the assigner reads, each named in its manifest's reads: every
-// node's compositions, which mesh-wants.upgrade compares (novox/hq ADR 0593 §8).
-var readFamilies = []string{delivery.ComposedRead}
+// readLogs are the logs of other parts the assigner reads, each named in its manifest's reads: the builder's log, whose
+// newest done trunk build of a module names the commit a reader of the manifests runs at (novox/hq ADR 0571 clause 1).
+var readLogs = []string{delivery.BuildLogRead}
+
+// goBuildModule is the Go build module, which takes the assigner's compose asks on its seat's check stream and writes
+// their steps in its steps state (novox/hq ADR 0482 clause 4).
+const goBuildModule = "mesh-build-go"
 
 // ownBuckets are the assigner's own states, as its manifest declares them: the seat mesh-placement's three among them
 // (ADR 0567 §1), named after the assigner as every module state is.
-var ownBuckets = []string{delivery.AssignerAsksBucket, delivery.AssignerDifferencesBucket,
+var ownBuckets = []string{delivery.AssignerAsksBucket, delivery.AssignerCompositionsBucket, delivery.AssignerDifferencesBucket,
 	delivery.AssignerPutsBucket, delivery.AssignerWantsBucket, delivery.PlacementBucket, delivery.PlacementProposalsBucket,
-	delivery.PlacementCandidatesBucket, delivery.PlacementPulsesBucket, assign.FindingsBucket, assign.PoliciesBucket, delivery.SeatHoldersBucket,
-	engineReadsBucket}
-
-// engineReadsState is the assigner's state of what each node's engine states it reads (ADR 0618 §3), one key `<node>`, as
-// the verb manifest-reads last answered it or the fallback read it: what assigner_engine_reads lists and asks again.
-const engineReadsState = "engine-reads"
-
-// engineReadsBucket is that state's bucket.
-const engineReadsBucket = delivery.AssignerModule + "_" + engineReadsState
+	delivery.PlacementCandidatesBucket, delivery.PlacementPulsesBucket, assign.FindingsBucket, assign.PoliciesBucket, delivery.SeatHoldersBucket}
 
 // seatBuckets are the seat's states, new with it: until the controller has made them from the manifest and the bus grants
 // them, the assigner starts without them and binds each once the bus says it was created (issue 1790's kind).
@@ -90,7 +90,7 @@ var seatBuckets = []string{delivery.PlacementBucket, delivery.PlacementProposals
 	delivery.PlacementPulsesBucket}
 
 // keptStates is what the assigner keeps and who may read it (ADR 0495 §2-§3): its wants by the watchman and the view
-// (and the node agent from release 6), its differences by the view, its asks by the view
+// (and the node agent from release 6), its differences by the view, its compositions by the checker, its asks by the view
 // and the teller, its puts by whoever follows one (ADR 0546), and the seat mesh-placement's placement, proposals and
 // candidates by the node agents, the grants part, mesh-config and the view (ADR 0567 §9), and its placement by
 // the builder, the checker and the indexer, through mesh-sdk's toolchain gate (issue 774, ADR 0549 §3).
@@ -100,15 +100,13 @@ var keptStates = []announce.State{
 	{Name: delivery.PlacementCandidatesState, Readable: true},
 	{Name: delivery.PlacementPulsesState, Readable: true},
 	{Name: "asks", Readable: true},
+	{Name: "compositions", Readable: true},
 	{Name: "differences", Readable: true},
 	{Name: "puts", Readable: true},
 	{Name: "wants", Readable: true},
 	{Name: health.FindingsState, Readable: true},
 	{Name: delivery.AssignerPoliciesState, Readable: true},
 	{Name: delivery.SeatHoldersState, Readable: true},
-	{Name: views.MarksState, Readable: true},  // what its views family said each state up to (views.go)
-	{Name: views.StatusState, Readable: true}, // its first views of the indexer's states (views.go)
-	{Name: engineReadsState, Readable: true},
 }
 
 // buckets is every bucket the assigner opened, by name.
@@ -137,6 +135,11 @@ func open(ctx context.Context, js process.BucketOpener, logf func(string, ...any
 			logf("the bucket %s cannot be opened (%v): it is bound once the bus says it was made", name, err)
 			continue
 		}
+		if name == keptBucket && err != nil {
+			// mesh-config's held values (ADR 0565 §5): without them a composition lays none, said in the journal.
+			logf("the bucket %s cannot be opened (%v): no held value is laid on a composition until it is bound", name, err)
+			continue
+		}
 		if name == provisions.ProvisionsBucket && err != nil {
 			// The seat mesh-provisioner's state, with its own delivery (ADR 0570 §4): bound once the bus says it was made;
 			// until then no want waits for a provision, as before.
@@ -155,18 +158,6 @@ func open(ctx context.Context, js process.BucketOpener, logf func(string, ...any
 			logf("the bucket %s cannot be opened (%v): the assigner's conditions are said straight to the router until it starts again", name, err)
 			continue
 		}
-		if (name == delivery.SourceBucket || name == delivery.MergesBucket) && err != nil {
-			// The gate's source and merges (ADR 0601 §1): without them no release is known to carry a build, so every move of
-			// a record module is asked of a person, as before.
-			logf("the bucket %s cannot be opened (%v): no release's Approve answers a record ask until it is bound", name, err)
-			continue
-		}
-		if name == engineReadsBucket && err != nil {
-			// New with ADR 0618 §3: without it the statements the verb answers are kept in memory only, and
-			// assigner_engine_reads lists nothing.
-			logf("the bucket %s cannot be opened (%v): what each node's engine reads is kept in memory only until it starts again", name, err)
-			continue
-		}
 		if name == delivery.PartGrantsBucket && err != nil {
 			// The grants part's grants (ADR 0571 clause 9): without them no module counts as granted until it is bound.
 			logf("the bucket %s cannot be opened (%v): no grant is read until it is bound once the bus says it was made", name, err)
@@ -184,8 +175,8 @@ func open(ctx context.Context, js process.BucketOpener, logf func(string, ...any
 // states and those new with a delivery of their own, bound once made, and the two that choose the grants' source.
 func startsWithout(name string) bool {
 	switch name {
-	case delivery.SeatHoldersBucket, provisions.ProvisionsBucket, assign.PoliciesBucket, assign.FindingsBucket,
-		delivery.AssignerPutsBucket, delivery.SourceBucket, delivery.MergesBucket, engineReadsBucket:
+	case delivery.SeatHoldersBucket, keptBucket, provisions.ProvisionsBucket, assign.PoliciesBucket, assign.FindingsBucket,
+		delivery.AssignerPutsBucket:
 		return true
 	}
 	return slices.Contains(seatBuckets, name) || name == delivery.PartGrantsBucket
@@ -220,21 +211,10 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
 	thisNode = account.Node
 	logger.Printf("started on the account %s, reading %d buckets", account.User, len(kvs))
 	findings := findingsOf(ctx, kvs, logger.Printf)
-	// Each change of the states its readers read is said on its views family (ADR 0615 §5, ADR 0619 §2); a watch of it
-	// that ends stops the program, as a watch of what a pass reads does.
-	viewErrs := make(chan error, len(viewedStates))
-	startViews(ctx, js, conn, account, kvs, findings, viewErrs, logger.Printf)
-	go func() {
-		select {
-		case <-ctx.Done():
-		case err := <-viewErrs:
-			logger.Printf("%v: the assigner stops, and is started again", err)
-			conn.Close()
-		}
-	}()
-	iv := &indexerViews{js: js, account: account, call: said.Call, findings: findings, logf: logger.Printf,
-		status: process.AwaitBucket(ctx, js, conn, firstViewsBucket, "assigner_first_views reads nothing and assigner_first_view_again is not heard", logger.Printf)}
-	return follow(ctx, js, conn, kvs, findings.Say(sayVia(ctx, js)), findings, emitting{said}, iv, logger)
+	buildLog := func(handle func(stdio.LogEntry) error) error {
+		return said.ReadLog(delivery.BuilderModule, delivery.BuilderLog).Watch("", stdio.LogFromAll, handle)
+	}
+	return follow(ctx, js, conn, kvs, findings.Say(sayVia(ctx, js)), findings, emitting{said}, buildLog, logger)
 }
 
 // findingsOf is where the assigner's said conditions go as findings (issue 1952 WM6): its findings bucket, which the
@@ -266,9 +246,12 @@ func (e emitting) Emit(eventType string, body any) error { return e.Conn.Emit(ev
 // watched are the buckets whose every value a pass reads; the manifests are read by digest when a pass needs one, and
 // watched only for keys, so a manifest that arrives wakes a composition that waits for it.
 var watched = []string{
+	buscompose.ResolvedBucket,
 	delivery.PartGrantsBucket,
 	delivery.AnswersBucket,
 	delivery.BuilderBuildsBucket,
+	delivery.CandidatesBucket,
+	delivery.ModulesBucket,
 	delivery.PlacementBucket,
 	delivery.PlacementProposalsBucket,
 	delivery.PlacementCandidatesBucket,
@@ -276,19 +259,18 @@ var watched = []string{
 	delivery.PresenceBucket,
 	delivery.HaveBucket,
 	delivery.AssignerAsksBucket,
+	delivery.AssignerCompositionsBucket,
 	delivery.AssignerDifferencesBucket,
 	delivery.AssignerWantsBucket,
 	assign.PoliciesBucket,
 	provisions.ProvisionsBucket,
+	keptBucket,
 	delivery.SeatHoldersBucket,
-	delivery.SourceBucket,
-	delivery.MergesBucket,
-	engineReadsBucket,
 }
 
 // follow watches every bucket a pass reads and makes a pass at start, once every watch handed what stands, and after
 // each change; changes that come during a pass make one more. It returns when ctx ends or a watch ends.
-func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber, kvs buckets, say func(oc.Condition) error, findings assign.Findings, bus caller, iv *indexerViews, logger *log.Logger) error {
+func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber, kvs buckets, say func(asks.Condition) error, findings assign.Findings, bus caller, buildLog logWatch, logger *log.Logger) error {
 	w := newWorld()
 	dirty := make(chan struct{}, 1)
 	wake := func() {
@@ -297,18 +279,24 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber,
 		default:
 		}
 	}
+	// The builder's log (ADR 0571 clause 1): every entry it keeps before the first pass, then each new one as it is appended;
+	// a module's newer done trunk build makes a pass, as a composition waiting on its commit is judged then. Where it cannot be
+	// read, a composition names no running reader of the manifests until the assigner starts again, and it is said.
+	if buildLog != nil {
+		var first atomic.Bool
+		if err := buildLog(func(le stdio.LogEntry) error {
+			if w.putBuilt(le.Value) && first.Load() {
+				wake()
+			}
+			return nil
+		}); err != nil {
+			logger.Printf("%s is not read (%v): no composition is judged against a running reader of the manifests until the assigner starts again",
+				delivery.BuildLogRead, err)
+		}
+		first.Store(true)
+	}
 	errs := make(chan error, len(watched)+2)
 	settled := make(chan struct{}, len(watched)+2)
-	// What each node's engine reads (ADR 0618 §3, §4): asked through the seat's verb, kept in the state engine-reads, read
-	// from the node's record where the engine does not answer (the fallback, said in the journal).
-	reads := &enginereads.Keeper{Fallback: w.recordReads, Changed: wake, Logf: logger.Printf}
-	if bus != nil {
-		reads.Call = bus.CallOn
-	}
-	if kv := kvs[engineReadsBucket]; kv != nil {
-		reads.Put = func(node string, v []byte) error { _, err := kv.Put(ctx, node, v); return err }
-		reads.Delete = func(node string) error { return kv.Delete(ctx, node) }
-	}
 	watch := func(name string, opts ...jetstream.WatchOpt) error {
 		kw, err := kvs[name].WatchAll(ctx, opts...)
 		if err != nil {
@@ -342,10 +330,6 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber,
 					if e.Operation() == jetstream.KeyValuePut {
 						value = e.Value()
 					}
-					if name == engineReadsBucket {
-						reads.Heard(e.Key(), value, value == nil) // it wakes a pass when a statement changed
-						continue
-					}
 					w.putEntry(name, e.Key(), value, e.Revision(), e.Created())
 					wake()
 				}
@@ -393,18 +377,15 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber,
 		}
 		started++
 		var opts []jetstream.WatchOpt
-		if name == delivery.HaveBucket || name == delivery.SourceBucket {
-			// what each node ran healthy before, for a set-back; and the release behind each source revision (ADR 0601 §1)
-			opts = append(opts, jetstream.IncludeHistory())
+		if name == delivery.HaveBucket {
+			opts = append(opts, jetstream.IncludeHistory()) // what each node ran healthy before, for a set-back
 		}
 		if err := watch(name, opts...); err != nil {
 			return err
 		}
 	}
-	// The indexer's manifests, modules and module graph, through its first views and views family, never its buckets
-	// (DLV-F2r, ADR 0631): the first pass waits for the three answers, as it waits for every watch to hand what stands.
-	if iv != nil {
-		started += iv.start(ctx, w, wake, settled)
+	if err := watch(delivery.ManifestsBucket, jetstream.MetaOnly()); err != nil {
+		return err
 	}
 	// The seat's states arrive with the same delivery as this assigner (ADR 0567 §1): one not on the bus at this start is
 	// bound once the bus says it was created, and watched from then on, with no restart (issue 1790's kind). Until then no
@@ -421,7 +402,7 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber,
 		}
 	}
 	// And the two that choose where grants are read from, with the same delivery as the grants part that writes one.
-	for _, name := range []string{delivery.PartGrantsBucket, assign.PoliciesBucket, provisions.ProvisionsBucket, delivery.SeatHoldersBucket} {
+	for _, name := range []string{delivery.PartGrantsBucket, assign.PoliciesBucket, provisions.ProvisionsBucket, keptBucket, delivery.SeatHoldersBucket} {
 		if kvs[name] == nil && js != nil {
 			name := name
 			process.AwaitBucket(ctx, js, nc, name, "until then the bucket is not read",
@@ -436,7 +417,7 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber,
 		logger.Printf("the bucket %s is open and watched", a.name)
 		return watch(a.name)
 	}
-	for range started {
+	for range started + 1 {
 		select {
 		case <-ctx.Done():
 			return nil
@@ -445,14 +426,8 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber,
 		case <-settled:
 		}
 	}
-	p := &passer{kvs: kvs, w: w, logf: logger.Printf, say: say, findings: findings, said: map[string]bool{}, answeredAt: map[string]uint64{},
-		reads: reads}
-	// The node-engine seat's manifest-reads-changed, for one node (ADR 0618 §4): that node is asked again, with no timer.
-	// Heard on the assigner's durable consumer on EVENTS, which the grants part makes from the manifest's consumes; where it
-	// is not there yet, a node is asked again only when it comes back online.
-	if js != nil {
-		hearReadsChanged(ctx, js, reads, findings, logger.Printf)
-	}
+	p := &passer{kvs: kvs, w: w, logf: logger.Printf, say: say, findings: findings, said: map[string]bool{}, answeredAt: map[string]uint64{}}
+	p.asks = newComposeAsks(ctx, buildrun.Asker{Publisher: buildrun.JetStreamAsks{JS: js}, Waiter: buildrun.JetStreamAsks{JS: js}}, wake, logger.Printf)
 	if bus != nil && kvs[delivery.AssignerPutsBucket] != nil {
 		p.acts = newPutActs(bus, wake, logger.Printf)
 	}
@@ -503,13 +478,13 @@ var PutsReopenEvery = time.Minute
 
 // sayVia publishes a condition on the operator-channel seat's one subject for conditions, under the assigner's own name
 // (ADR 0437 clause 9).
-func sayVia(ctx context.Context, js jetstream.JetStream) func(oc.Condition) error {
-	return func(c oc.Condition) error {
-		subject, err := occ.ConditionSubject(delivery.AssignerModule)
+func sayVia(ctx context.Context, js jetstream.JetStream) func(asks.Condition) error {
+	return func(c asks.Condition) error {
+		subject, err := asks.ConditionSubject(delivery.AssignerModule)
 		if err != nil {
 			return err
 		}
-		data, err := occ.EncodeCondition(c)
+		data, err := asks.EncodeCondition(c)
 		if err != nil {
 			return err
 		}
@@ -517,39 +492,3 @@ func sayVia(ctx context.Context, js jetstream.JetStream) func(oc.Condition) erro
 		return err
 	}
 }
-
-// hearReadsChanged hears the node-engine seat's event manifest-reads-changed on the assigner's durable consumer on EVENTS,
-// and asks the node it names again. Any other event the consumer hands is acknowledged and left.
-func hearReadsChanged(ctx context.Context, js jetstream.JetStream, reads *enginereads.Keeper, findings assign.Findings, logf func(string, ...any)) {
-	account := process.Account{Node: thisNode, Module: delivery.AssignerModule}
-	w := notHeardWriter(findings, logf)
-	cons, err := account.EventConsumer(ctx, js, process.EventsStream)
-	if err != nil {
-		w.NotHeard(process.EventsStream, enginereads.Event+" is not heard until the assigner starts again (a node is asked again when it comes back online)",
-			fmt.Errorf("the consumer %s on %s does not exist yet: %w", account.EventConsumerName(), process.EventsStream, err))
-		return
-	}
-	cc, err := process.HearEvents(cons, func(m jetstream.Msg) {
-		if err := m.Ack(); err != nil {
-			logf("acknowledging %s: %v", m.Subject(), err)
-		}
-		node, ours, err := enginereads.NodeOf(m.Subject(), m.Data())
-		switch {
-		case !ours:
-		case err != nil:
-			logf("%s holds what is not %s, and %s is asked again all the same: %v", m.Subject(), enginereads.Event, node, err)
-			reads.AskNode(node, enginereads.Event+" that does not read")
-		default:
-			reads.AskNode(node, enginereads.Event)
-		}
-	}, logf)
-	if err != nil {
-		w.NotHeard(process.EventsStream, enginereads.Event+" is not heard until the assigner starts again", err)
-		return
-	}
-	w.Heard(process.EventsStream)
-	go func() {
-		<-ctx.Done()
-		cc.Stop()
-	}()
-}

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main_test.go

@@ -18,20 +18,14 @@ import (
 
 	"github.com/nats-io/nats.go/jetstream"
 
-	oc "git.novox.be/novox/mesh-contracts/go/seats/operatorchannel"
+	"git.novox.be/novox/mesh-sdk/go/asks"
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
-	"git.novox.be/novox/mesh-sdk/go/process"
 )
 
 // 1297/B2a: the buckets the program opens are exactly the manifest's reads and states, as the broker names them
 // (`<module>.<state>` read as the bucket `<module>_<state>`), so it is granted what it reads and reads nothing else.
 func TestOpensWhatItsManifestNames(t *testing.T) {
-	// Review round 2: the assigner's views emitter writes its finding view-unsaid (Emitter.Findings set) when it keeps findings.
-	findings := assign.Findings{Put: func(string, []byte) error { return nil }, Delete: func(string) error { return nil }}
-	if viewsEmitter(nil, process.Account{}, nil, findings, nil, t.Logf).Findings == nil {
-		t.Error("the assigner's views emitter writes no view-unsaid finding")
-	}
 	// 1297/B2a: without a credential the program does not start, and says why.
 	if err := run(context.Background(), func(string) string { return "" }, io.Discard); err == nil || !strings.Contains(err.Error(), "MESH_BROKER_FILE") {
 		t.Errorf("run without a credential = %v", err)
@@ -46,14 +40,14 @@ func TestOpensWhatItsManifestNames(t *testing.T) {
 	}
 	var reads []string
 	for _, r := range m.Reads {
-		if slices.Contains(readFamilies, r) {
-			continue // a state kept one bucket per node, read by its prefix (ADR 0593 §6), not one bucket
+		if slices.Contains(readLogs, r) {
+			continue // a log, read through its own reader (ADR 0571 clause 1), not a bucket
 		}
 		reads = append(reads, strings.Replace(r, ".", "_", 1))
 	}
-	for _, l := range readFamilies {
+	for _, l := range readLogs {
 		if !slices.Contains(m.Reads, l) {
-			t.Errorf("the program reads the per-node state %s, the manifest does not name it", l)
+			t.Errorf("the program reads the log %s, the manifest does not name it", l)
 		}
 	}
 	var states []string
@@ -63,7 +57,7 @@ func TestOpensWhatItsManifestNames(t *testing.T) {
 	for _, pair := range []struct {
 		what       string
 		code, want []string
-	}{{"reads", readBuckets, reads}, {"states", append(slices.Clone(ownBuckets), marksBucket, firstViewsBucket), states}} { // the marks are bound by the views family (views.go)
+	}{{"reads", readBuckets, reads}, {"states", ownBuckets, states}} {
 		got, want := slices.Sorted(slices.Values(pair.code)), slices.Sorted(slices.Values(pair.want))
 		if !reflect.DeepEqual(got, want) {
 			t.Errorf("the program's %s are %v, the manifest's %v", pair.what, got, want)
@@ -73,7 +67,7 @@ func TestOpensWhatItsManifestNames(t *testing.T) {
 	for _, s := range keptStates {
 		kept = append(kept, m.Module+"_"+s.Name)
 	}
-	if got, want := slices.Sorted(slices.Values(kept)), slices.Sorted(slices.Values(append(slices.Clone(ownBuckets), marksBucket, firstViewsBucket))); !reflect.DeepEqual(got, want) {
+	if got, want := slices.Sorted(slices.Values(kept)), slices.Sorted(slices.Values(ownBuckets)); !reflect.DeepEqual(got, want) {
 		t.Errorf("the program announces %v, keeps %v", got, want)
 	}
 	// ADR 0546: whatever keeps the puts' bucket from opening (not there, not granted, no answer in time), the assigner opens
@@ -119,7 +113,7 @@ func TestOpensWhatItsManifestNames(t *testing.T) {
 	}
 	kvs[delivery.AssignerPutsBucket].(*watchKV).closed = true
 	kvs[delivery.AssignerWantsBucket].(*watchKV).wrote = wrote
-	go follow(ctx, nil, nil, kvs, func(oc.Condition) error { return nil }, assign.Findings{}, nil, nil, log.New(io.Discard, "", 0))
+	go follow(ctx, nil, nil, kvs, func(asks.Condition) error { return nil }, assign.Findings{}, nil, nil, log.New(io.Discard, "", 0))
 	select {
 	case key := <-wrote:
 		if key != "want.ace.node" {

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass.go

@@ -10,12 +10,11 @@ import (
 	"strings"
 	"time"
 
-	oc "git.novox.be/novox/mesh-contracts/go/seats/operatorchannel"
+	"git.novox.be/novox/mesh-sdk/go/asks"
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 	"git.novox.be/novox/mesh-sdk/go/provisions"
-
-	"git.novox.be/novox/mesh-delivery/sdk/enginereads"
+	"git.novox.be/novox/mesh-sdk/go/sdkversion"
 
 	"mesh-delivery-assigner/internal/assign"
 )
@@ -29,7 +28,7 @@ type passer struct {
 	sdk  string
 	// say publishes a condition to the operator; said is, by condition key and state, what this process has said, so a
 	// pass says a condition once and a restart says it again (the router keeps one per key).
-	say  func(oc.Condition) error
+	say  func(asks.Condition) error
 	said map[string]bool
 	// findings is the assigner's findings bucket (its said conditions, ADR 0564 §2).
 	findings assign.Findings
@@ -41,6 +40,7 @@ type passer struct {
 	unplaced map[string]bool
 	// answeredAt is, by the id of a backup ask, how many values the have had when its answer was written into the want.
 	answeredAt map[string]uint64
+	asks       *composeAsks
 	// now is the clock; nil is time.Now.
 	now func() time.Time
 	// neither is, by node and module, each module on neither list whose condition this process raised (issue 1945). Nil until the
@@ -70,40 +70,6 @@ type passer struct {
 	// saidWaits is the last said of the seat's wait for its states (sayWaits).
 	saidWaits string
 	intended  map[string]map[string]map[string]bool
-	// reads keeps what each node's engine states it reads, asked through the node-engine seat's verb (ADR 0618 §3); nil reads
-	// each node's record, as the rules did before the verb. online is, by node, whether the last pass saw it online.
-	reads  *enginereads.Keeper
-	online map[string]bool
-}
-
-// engineReads sets what the rules read of each node's engine (ADR 0618 §3, §4): the statement the verb manifest-reads
-// answered, or its record where the verb was not answered (the fallback) or not asked yet. A node is asked when the
-// assigner first hears of it, and again when it comes back online, since an engine built before the event says none.
-func (p *passer) engineReads(n assign.Nodes) {
-	if p.reads == nil {
-		return
-	}
-	known := p.w.knownNodes()
-	first := p.online == nil
-	for _, node := range known {
-		switch {
-		case first:
-			p.reads.AskNode(node, "the assigner started")
-		case !p.reads.Known(node):
-			p.reads.AskNode(node, "first heard of")
-		case !first && n.Online[node] && !p.online[node]:
-			p.reads.AskNode(node, "back online")
-		}
-	}
-	p.online = maps.Clone(n.Online)
-	if p.online == nil {
-		p.online = map[string]bool{}
-	}
-	for node, reads := range p.reads.Reads(known) {
-		if p.reads.Known(node) {
-			n.Reads[node] = reads
-		}
-	}
 }
 
 func (p *passer) clock() time.Time {
@@ -115,6 +81,7 @@ func (p *passer) clock() time.Time {
 
 func (p *passer) pass(ctx context.Context) {
 	p.placementSeat(ctx)
+	p.compositions(ctx)
 	p.wants(ctx)
 	p.puts(ctx)
 	p.nodeWants(ctx)
@@ -143,7 +110,7 @@ func (p *passer) nodeWants(ctx context.Context) {
 // the hold of a fingerprint whose health check failed. The assigner compares its wants with nothing the controller
 // sends: the differences bucket is kept read-only with its history (ADR 0539 §8).
 func (p *passer) wants(ctx context.Context) {
-	get := p.w.getter(delivery.ManifestsBucket) // the indexer's manifests, as its first view and views family say them
+	get := kvGetter(p.kvs[delivery.ManifestsBucket])
 	assigned := p.w.assigned()
 	trunk := p.w.trunk()
 	manifests := map[string]catalogue.Manifest{}
@@ -156,7 +123,6 @@ func (p *passer) wants(ctx context.Context) {
 		}
 	}
 	nodes := p.w.nodes(manifests, assigned)
-	p.engineReads(nodes)
 	nodesOf := map[string][]string{}
 	for node, modules := range assigned {
 		for _, m := range modules {
@@ -192,14 +158,10 @@ func (p *passer) wants(ctx context.Context) {
 	defer func() { p.sayNeither(neither, stale, left) }()
 	// Where grants are read from, once for the pass: the grants part's (issue 774, ADR 0571 clause 9).
 	grants := p.w.grantsBucket()
-	// The verb edges, once for the pass (ADR 0614 §2, §3).
-	moduleGraph := p.moduleGraph()
-	served := p.served(ctx, get, moduleGraph, nodes)
-	offering := p.offering(ctx, get, manifests, nodes) // bus state (ADR 0614 §5)
 	for name := range names {
 		fp := trunk[name].FP2
 		name := name
-		m := assign.Module{Name: name, FP: fp, Manifest: manifests[name], Needs: trunk[name].Needs, Chosen: chosenOf(chosen, name), Provisions: provisionsOf(name), Answering: answering(manifests, nodes), Offered: offered(manifests), Nodes: nodesOf[name], Now: time.Now(), Puts: puts[name], FormNeeds: p.w.buildNeeds(name, fp),
+		m := assign.Module{Name: name, FP: fp, Manifest: manifests[name], Chosen: chosenOf(chosen, name), Provisions: provisionsOf(name), Answering: answering(manifests, nodes), Nodes: nodesOf[name], Now: time.Now(), Puts: puts[name],
 			Self: func(node string) bool { return placed[node] },
 			Composed: func(node, fp string) (delivery.ComposedDigest, bool) {
 				return p.w.composed(node, name, fp) // a placed node's own: the digest its own have names (ADR 0571 §6)
@@ -215,8 +177,7 @@ func (p *passer) wants(ctx context.Context) {
 			Allowed: func(node, digest string) bool {
 				key, err := delivery.RecordAskKey(node, name, digest)
 				return err == nil && p.answeredWith(key, assign.OptionYes)
-			},
-			Release: func(fp string) (string, bool) { return p.w.release(name, fp) }}
+			}}
 		if fp != "" {
 			held, _ := delivery.HeldKey(name, fp)
 			grant, _ := delivery.PartGrantKey(name, fp)
@@ -233,10 +194,6 @@ func (p *passer) wants(ctx context.Context) {
 				p.clearHeld(name, fp)
 			}
 		}
-		if served != nil {
-			m.Invokes, m.Served = keptInvokes(moduleGraph, name), served
-		}
-		m.Offering = offering
 		last := map[string]string{}
 		for _, node := range m.Nodes {
 			last[node] = p.w.lastHealthy(node, name, fp)
@@ -521,6 +478,57 @@ func (p *passer) sayNeither(now, stale map[string]neitherOne, left map[string]st
 	}
 }
 
+// compositions writes the composition check's verdict of every group the indexer holds a candidate for, under the
+// checker's key of that check: waits, with why, while the indexer holds what it composes from only in part.
+func (p *passer) compositions(ctx context.Context) {
+	if p.sdk == "" {
+		p.sdk = sdkversion.Version()
+	}
+	written := p.w.read(delivery.AssignerCompositionsBucket)
+	trunk := p.w.trunk()
+	var mesh *assign.Mesh
+	seen := map[string]bool{}
+	if p.asks != nil {
+		defer p.asks.sweep(seen)
+	}
+	for key, value := range p.w.read(delivery.CandidatesBucket) {
+		c, err := delivery.DecodeCandidate(value)
+		if err != nil {
+			p.logf("the candidate %s cannot be read, so it is not composed: %v", key, err)
+			continue
+		}
+		out, err := delivery.CompositionKey(c.Group, c.HeadsHash)
+		if err != nil {
+			p.logf("the candidate %s names no composition key: %v", key, err)
+			continue
+		}
+		began := time.Now()
+		ch, waits := p.w.change(ctx, kvGetter(p.kvs[delivery.ManifestsBucket]), c, trunk)
+		var v delivery.CompositionVerdict
+		if waits != "" {
+			v = delivery.CompositionVerdict{Group: c.Group, Heads: c.HeadsHash, State: delivery.CompositionWaits, Words: waits}
+		} else {
+			if mesh == nil {
+				m := p.w.mesh(ctx, kvGetter(p.kvs[delivery.ManifestsBucket]))
+				mesh = &m
+			}
+			if ch.SDKHead != "" && p.asks != nil {
+				// A group with a mesh-sdk member is composed by the composer built at its head (ADR 0482 clauses 3 to 5).
+				v = p.composeAtHead(ctx, *mesh, ch, seen, began)
+			} else {
+				v = assign.Compose(*mesh, ch, p.sdk, time.Since(began))
+			}
+		}
+		if before, err := delivery.DecodeCompositionVerdict(written[out]); err == nil {
+			before.Took, before.V = v.Took, 0
+			if delivery.SameCompositionVerdict(before, v) {
+				continue
+			}
+		}
+		p.put(ctx, delivery.AssignerCompositionsBucket, out, func() ([]byte, error) { return delivery.EncodeCompositionVerdict(v) })
+	}
+}
+
 // put writes one key of the assigner's own bucket; a write that fails is said and made again at the next pass.
 func (p *passer) put(ctx context.Context, bucket, key string, encode func() ([]byte, error)) {
 	value, err := encode()
@@ -554,7 +562,7 @@ func (p *passer) holdAsk(ctx context.Context, module, fp string, fresh *delivery
 	asking := int(now.Unix())
 	h := p.heldHold(module, fp, fresh)
 	a := assign.HoldAsk(key, module, fp, h.Node, h.Words, asking, now)
-	p.put(ctx, delivery.AssignerAsksBucket, key, func() ([]byte, error) { return assign.EncodeAsk(key, a) })
+	p.put(ctx, delivery.AssignerAsksBucket, key, func() ([]byte, error) { return delivery.EncodeAssignerAsk(key, a) })
 }
 
 // lift takes away a hold the assigner lifted by itself, since every node that runs the module runs the held fingerprint healthy
@@ -737,7 +745,7 @@ func (p *passer) restoreAsk(ctx context.Context, module, node, fp string) {
 	}
 	words := p.heldHold(module, fp, nil).Words
 	a := assign.RestoreAsk(key, node, module, fp, words, time.Now())
-	p.put(ctx, delivery.AssignerAsksBucket, key, func() ([]byte, error) { return assign.EncodeAsk(key, a) })
+	p.put(ctx, delivery.AssignerAsksBucket, key, func() ([]byte, error) { return delivery.EncodeAssignerAsk(key, a) })
 }
 
 // answeredWith says whether the teller wrote an answer to the ask at key as it stands now and the option chosen is option. The
@@ -749,12 +757,12 @@ func (p *passer) answeredWith(key, option string) bool {
 	if !ok || a.Option != option {
 		return false
 	}
-	_, ask, err := assign.DecodeAsk(key, p.w.value(delivery.AssignerAsksBucket, key))
+	ask, err := delivery.DecodeAssignerAsk(key, p.w.value(delivery.AssignerAsksBucket, key))
 	if err != nil {
 		return false
 	}
 	id, _, _ := strings.Cut(a.Warrant, "@")
-	return id == ask.ID
+	return id == ask.Ask.ID
 }
 
 // clearHeld clears, once, the condition of a hold the operator released.
@@ -779,7 +787,7 @@ func (p *passer) recordAsk(ctx context.Context, module, fp string, need assign.R
 		return
 	}
 	a := assign.RecordAsk(key, need.Node, module, fp, need, time.Now())
-	p.put(ctx, delivery.AssignerAsksBucket, key, func() ([]byte, error) { return assign.EncodeAsk(key, a) })
+	p.put(ctx, delivery.AssignerAsksBucket, key, func() ([]byte, error) { return delivery.EncodeAssignerAsk(key, a) })
 }
 
 // backups sees to the modules held on a node because the backup before an apply failed (the have's phase held, ADR 0539 §16):
@@ -810,7 +818,7 @@ func (p *passer) backups(ctx context.Context) {
 		if err != nil {
 			continue
 		}
-		current, currentAsk, there := assign.DecodeAsk(akey, p.w.read(delivery.AssignerAsksBucket)[akey])
+		current, there := delivery.DecodeAssignerAsk(akey, p.w.read(delivery.AssignerAsksBucket)[akey])
 		if there != nil || assign.BackupAskDigest(current) != want.Composed {
 			after := -1
 			if there == nil {
@@ -820,7 +828,7 @@ func (p *passer) backups(ctx context.Context) {
 			continue
 		}
 		answer, answered := p.w.answer(akey)
-		if router, _, _ := strings.Cut(answer.Warrant, "@"); !answered || router != currentAsk.ID ||
+		if router, _, _ := strings.Cut(answer.Warrant, "@"); !answered || router != current.Ask.ID ||
 			(answer.Option != delivery.BackupAgain && answer.Option != delivery.BackupSkip) {
 			continue // not answered yet: the ask stands
 		}
@@ -831,7 +839,7 @@ func (p *passer) backups(ctx context.Context) {
 			if wkey, err := delivery.WantKey(node, module); err == nil {
 				w := want
 				p.put(ctx, delivery.AssignerWantsBucket, wkey, func() ([]byte, error) { return delivery.EncodeWant(w) })
-				p.answeredAt[currentAsk.ID] = haveChanges
+				p.answeredAt[current.Ask.ID] = haveChanges
 			}
 			continue
 		}
@@ -839,8 +847,8 @@ func (p *passer) backups(ctx context.Context) {
 			continue
 		}
 		// The answer is in the want. The node retried and the backup failed again when the have took another value since.
-		if seen, known := p.answeredAt[currentAsk.ID]; !known {
-			p.answeredAt[currentAsk.ID] = haveChanges // after a restart: wait for the next failure
+		if seen, known := p.answeredAt[current.Ask.ID]; !known {
+			p.answeredAt[current.Ask.ID] = haveChanges // after a restart: wait for the next failure
 		} else if haveChanges > seen {
 			p.backupAsk(ctx, akey, node, module, want, have.Detail, assign.NextBackupAsking(current.Asking))
 		}
@@ -850,7 +858,7 @@ func (p *passer) backups(ctx context.Context) {
 // backupAsk writes the backup ask at its asking and raises the condition of the failed backup, once.
 func (p *passer) backupAsk(ctx context.Context, key, node, module string, want delivery.Want, words string, asking int) {
 	a := assign.BackupAsk(key, node, module, want.FP, want.Composed, words, asking, time.Now())
-	p.put(ctx, delivery.AssignerAsksBucket, key, func() ([]byte, error) { return assign.EncodeAsk(key, a) })
+	p.put(ctx, delivery.AssignerAsksBucket, key, func() ([]byte, error) { return delivery.EncodeAssignerAsk(key, a) })
 	c := assign.BackupCondition(node, module, want.FP, words, true)
 	if p.say == nil || p.said[c.Key] {
 		return
@@ -865,9 +873,7 @@ func (p *passer) backupAsk(ctx context.Context, key, node, module string, want d
 // yeses writes a placed node's wants naming the build alone, and sees to the moves a node that composes its own judged a
 // person must allow (ADR 0547 §3): for a have of phase
 // waiting-yes it raises the record ask once, naming the composition waiting and the node's judgement, and on a yes writes
-// the want again naming it; a yes once written is kept while the want stays at its build, so the node is not asked again. A
-// move of the build alone (the have says so) to a build an approved release carries is given its yes by that Approve, the
-// want naming the release, with no ask (ADR 0601 §1).
+// the want again naming it; a yes once written is kept while the want stays at its build, so the node is not asked again.
 func (p *passer) yeses(ctx context.Context, module string, m assign.Module, before map[string]delivery.Want, out *assign.Outcome) {
 	for _, node := range m.Nodes {
 		if m.Self == nil || !m.Self(node) {
@@ -884,37 +890,25 @@ func (p *passer) yeses(ctx context.Context, module string, m assign.Module, befo
 		if w.Removed {
 			continue
 		}
-		yes, release := "", ""
+		yes := ""
 		if had && was.FP == w.FP {
-			yes, release = was.Yes, was.Release
+			yes = was.Yes
 		}
 		key, err := delivery.HaveKey(node, module)
 		if err != nil {
 			continue
 		}
 		if h, err := delivery.DecodeHave(p.w.value(delivery.HaveBucket, key)); err == nil && h.Phase == delivery.PhaseWaitingYes && h.Waits != yes {
-			switch {
-			case m.Allowed != nil && m.Allowed(node, h.Waits):
-				yes, release = h.Waits, ""
-			case h.BuildAlone && h.FP != w.FP && m.Release != nil:
-				// A move of the build alone, to the build an approved release carries: that Approve is the yes (ADR 0601 §1),
-				// named in the want. A move that changes a setting or a secret too, or one the node could not tell, is asked.
-				if r, ok := m.Release(w.FP); ok {
-					yes, release = h.Waits, r
-					break
-				}
-				p.recordAsk(ctx, module, w.FP, assign.RecordNeed{Node: node, Digest: h.Waits, Judgement: h.Judgement, Words: h.Detail})
-			default:
+			if m.Allowed != nil && m.Allowed(node, h.Waits) {
+				yes = h.Waits
+			} else {
 				p.recordAsk(ctx, module, w.FP, assign.RecordNeed{Node: node, Digest: h.Waits, Judgement: h.Judgement, Words: h.Detail})
 			}
 		}
 		// A want carried over from before the node composed its own may still name the controller's composition; a placed
 		// node's want names the build alone (ADR 0547 §2).
-		if yes == "" {
-			release = ""
-		}
-		if yes != w.Yes || release != w.Release || w.Composed != "" || !w.Self {
-			w.Yes, w.Release, w.Composed, w.Self = yes, release, "", true
+		if yes != w.Yes || w.Composed != "" || !w.Self {
+			w.Yes, w.Composed, w.Self = yes, "", true
 			out.Wants[node] = w
 		}
 	}
@@ -1131,26 +1125,6 @@ func (p *passer) seatHolders(ctx context.Context) {
 	}
 }
 
-// offered says whether some manifest of the trunk, or a module the mesh provides itself, offers a provision under its name
-// (a module offers its own name too, catalogue.Manifest.Offers): what a requirement nobody offers is told from.
-func offered(manifests map[string]catalogue.Manifest) func(string) bool {
-	names := map[string]bool{}
-	add := func(m catalogue.Manifest) {
-		for _, o := range m.Offers() {
-			names[o] = true
-		}
-	}
-	for _, m := range manifests {
-		add(m)
-	}
-	for _, module := range delivery.ProvidedModules() {
-		if m, _, err := delivery.ProvidedManifest(module); err == nil {
-			add(m)
-		}
-	}
-	return func(provision string) bool { return names[provision] }
-}
-
 // answering is, by provision, the manifests of the modules placed on some node that provide it: what a want's
 // provisions are judged by (catalogue.Awaited, issue 774). A provider in the catalogue placed nowhere answers nobody.
 func answering(manifests map[string]catalogue.Manifest, n assign.Nodes) func(string) []catalogue.Manifest {

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass_test.go

@@ -13,16 +13,10 @@ import (
 
 	"github.com/nats-io/nats.go/jetstream"
 
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
-	oc "git.novox.be/novox/mesh-contracts/go/seats/operatorchannel"
-	"git.novox.be/novox/mesh-sdk/go/busretry"
+	"git.novox.be/novox/mesh-sdk/go/asks"
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 
-	"git.novox.be/novox/mesh-contracts/go/seats/nodeengine"
-	"git.novox.be/novox/mesh-delivery/sdk/enginereads"
-	"git.novox.be/novox/mesh-delivery/sdk/graph"
-
 	"mesh-delivery-assigner/internal/assign"
 )
 
@@ -95,7 +89,7 @@ func TestAHoldAskedAgainAfterALiftAndARestartHasANewID(t *testing.T) {
 	held := &delivery.Held{Node: "ace", Words: "health failed"}
 	first := newPasser(kvs, time.Date(2026, 10, 25, 1, 0, 0, 0, time.UTC))
 	first.holdAsk(context.Background(), "web", fpTest, held)
-	a1, err := decodeAsk(key, asksKV.values[key])
+	a1, err := delivery.DecodeAssignerAsk(key, asksKV.values[key])
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -105,7 +99,7 @@ func TestAHoldAskedAgainAfterALiftAndARestartHasANewID(t *testing.T) {
 	}
 	again := newPasser(kvs, time.Date(2026, 10, 25, 2, 0, 0, 0, time.UTC)) // started again: it remembers nothing
 	again.holdAsk(context.Background(), "web", fpTest, held)
-	a2, err := decodeAsk(key, asksKV.values[key])
+	a2, err := delivery.DecodeAssignerAsk(key, asksKV.values[key])
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -117,24 +111,16 @@ func TestAHoldAskedAgainAfterALiftAndARestartHasANewID(t *testing.T) {
 // 1906/H4: an answer counts only for the asking it answered: an answer to an earlier hold of the same fingerprint, or to an ask
 // taken away, is not taken for the hold that stands now.
 func TestAnAnswerCountsOnlyForTheAskingItAnswered(t *testing.T) {
-	// ADR 0603 §5: a provision is offered by a manifest's provides, by a module's own name, and by a module the mesh provides
-	// itself (mesh-addressing, mesh-wireguard's); nothing else.
-	off := offered(map[string]catalogue.Manifest{"node-tools": {Module: "node-tools"}, "db": {Module: "db", Provides: []catalogue.Offer{{Name: "database"}}}})
-	for provision, want := range map[string]bool{"node-tools": true, "database": true, "mesh-addressing": true, "queue": false} {
-		if off(provision) != want {
-			t.Errorf("offered(%s) = %v, want %v", provision, !want, want)
-		}
-	}
 	key, _ := delivery.HoldAskKey("web", fpTest)
 	p := newPasser(buckets{}, time.Now())
 	put := func(asking int) string {
 		a := assign.HoldAsk(key, "web", fpTest, "ace", "health failed", asking, time.Now())
-		v, err := assign.EncodeAsk(key, a)
+		v, err := delivery.EncodeAssignerAsk(key, a)
 		if err != nil {
 			t.Fatal(err)
 		}
 		p.w.put(delivery.AssignerAsksBucket, key, v)
-		return mustAskID(a)
+		return a.Ask.ID
 	}
 	first := put(100)
 	v, _ := delivery.EncodeAnswer(delivery.Answer{Option: "release", Warrant: first + "@2026-10-25T01:00:00Z", Words: "the operator"})
@@ -154,89 +140,6 @@ func TestAnAnswerCountsOnlyForTheAskingItAnswered(t *testing.T) {
 		t.Error("an answer to an ask taken away was taken")
 	}
 	t.Run("a put of the bus acts on the operator's warrant alone", putOfTheBus)
-	// ADR 0614 §4: the rules read what each node's engine states it reads from its record in `<node>.node`; a node with no
-	// record, or one that states nothing, is read as stating nothing (the rules then read the baseline).
-	t.Run("the rules read what each node's engine reads", func(t *testing.T) {
-		w := newWorld()
-		for node, reads := range map[string][]string{"ace": {"word:module", "word:tool-runner"}, "g14": nil} {
-			raw, err := delivery.EncodeHaveNode(delivery.HaveNode{Record: &delivery.NodeRecord{Node: node, ManifestReads: reads}})
-			if err != nil {
-				t.Fatal(err)
-			}
-			key, _ := delivery.HaveNodeKey(node)
-			w.put(delivery.HaveBucket, key, raw)
-		}
-		n := w.nodes(nil, nil)
-		if !slices.Equal(n.Reads["ace"], []string{"word:module", "word:tool-runner"}) || len(n.Reads["g14"]) != 0 || len(n.Reads["novox"]) != 0 {
-			t.Errorf("the nodes' reads are %v", n.Reads)
-		}
-		// ADR 0618 §3: with the verb asked, a node's reads are what its engine answered; where the engine answers it does not
-		// serve the verb, its record is read once in its place (the fallback, issue 774); a node asked again when it comes
-		// back online, since an engine built before the event says none.
-		asked := map[string]int{}
-		call := func(node, key string, _ any) (json.RawMessage, error) {
-			asked[node]++
-			if node == "g14" || key != enginereads.Invoke {
-				return nil, &busretry.Answered{Words: "the seat node-engine serves no verb manifest-reads"}
-			}
-			return json.Marshal(nodeengine.ManifestReadsAnswer{V: 1, Node: node, ManifestReads: []string{"form:new"}, StatedAt: time.Now().Format(time.RFC3339Nano)})
-		}
-		p := &passer{w: w, reads: &enginereads.Keeper{Call: call, Fallback: w.recordReads, Sync: true}}
-		on, _ := delivery.EncodePresence(delivery.Presence{Online: false})
-		w.put(delivery.PresenceBucket, "ace", on)
-		n = w.nodes(nil, nil)
-		p.engineReads(n)
-		if !slices.Equal(n.Reads["ace"], []string{"form:new"}) || len(n.Reads["g14"]) != 0 || asked["ace"] != 1 {
-			t.Errorf("with the verb the nodes' reads are %v (asked %v)", n.Reads, asked)
-		}
-		if s := p.reads.Statements(); s["ace"].From != enginereads.FromVerb || s["g14"].From != enginereads.FromRecord {
-			t.Errorf("the statements are %+v", s)
-		}
-		p.engineReads(w.nodes(nil, nil))
-		on, _ = delivery.EncodePresence(delivery.Presence{Online: true})
-		w.put(delivery.PresenceBucket, "ace", on)
-		p.engineReads(w.nodes(nil, nil))
-		if asked["ace"] != 2 {
-			t.Errorf("ace, back online, was asked %d times, want 2", asked["ace"])
-		}
-		// The contract carries no checks, so its reader judges what the engine says (mesh-contracts seats/nodeengine): an
-		// answer or an event that does not hold is no statement, and an event's node is its subject's last token.
-		now := time.Now().Format(time.RFC3339Nano)
-		for _, row := range []struct {
-			name  string
-			raw   string
-			stays bool
-		}{
-			{"a whole answer", `{"v":1,"node":"ace","manifest-reads":["form:new"],"stated-at":"` + now + `"}`, true},
-			{"an engine stating nothing", `{"v":1,"node":"ace","stated-at":"` + now + `"}`, true},
-			{"another layout", `{"v":2,"node":"ace","stated-at":"` + now + `"}`, false},
-			{"no node", `{"v":1,"node":"","stated-at":"` + now + `"}`, false},
-			{"a node that is no token", `{"v":1,"node":"a.ce","stated-at":"` + now + `"}`, false},
-			{"another node's answer", `{"v":1,"node":"g14","stated-at":"` + now + `"}`, false},
-			{"an empty capability", `{"v":1,"node":"ace","manifest-reads":[""],"stated-at":"` + now + `"}`, false},
-			{"a time that is no time", `{"v":1,"node":"ace","stated-at":"yesterday"}`, false},
-		} {
-			s := enginereads.Ask(func(string, string, any) (json.RawMessage, error) { return json.RawMessage(row.raw), nil }, "ace", time.Now())
-			if (s.From == enginereads.FromVerb) != row.stays || !s.Answered {
-				t.Errorf("answer %s: %+v", row.name, s)
-			}
-		}
-		for _, row := range []struct {
-			name, subject, raw string
-			ours, fails        bool
-		}{
-			{"the event", enginereads.SubjectPrefix + "ace", `{"v":1,"node":"ace","at":"` + now + `","why":"returned"}`, true, false},
-			{"another reason", enginereads.SubjectPrefix + "ace", `{"v":1,"node":"ace","at":"` + now + `","why":"bored"}`, true, true},
-			{"another node in the body", enginereads.SubjectPrefix + "ace", `{"v":1,"node":"g14","at":"` + now + `","why":"started"}`, true, true},
-			{"a time that is no time", enginereads.SubjectPrefix + "ace", `{"v":1,"node":"ace","at":"x","why":"started"}`, true, true},
-			{"another event", "mesh.seat.node-engine.event.done.ace", `{}`, false, false},
-		} {
-			_, ours, err := enginereads.NodeOf(row.subject, []byte(row.raw))
-			if ours != row.ours || (err != nil) != row.fails {
-				t.Errorf("event %s: ours %v, %v", row.name, ours, err)
-			}
-		}
-	})
 }
 
 // memEntry is a value a memKV holds, as a bucket's Get answers it.
@@ -398,8 +301,8 @@ func putOfTheBus(t *testing.T) {
 	if got.Step != delivery.PutPerson || got.Ask != akey {
 		t.Fatalf("composed, the put stands at %s (%s), ask %q", got.Step, got.Words, got.Ask)
 	}
-	a, err := decodeAsk(akey, asksKV.values[akey])
-	if err != nil || a.Ask.Options[0].Level != occ.Approve {
+	a, err := delivery.DecodeAssignerAsk(akey, asksKV.values[akey])
+	if err != nil || a.Ask.Options[0].Level != asks.Approve {
 		t.Fatalf("the ask is %+v, %v; want a yes that approves", a, err)
 	}
 	if _, there := wantsKV.values["want.novox.nats"]; there {
@@ -447,7 +350,7 @@ func putOfTheBus(t *testing.T) {
 		t.Fatal(err)
 	}
 	again := step()
-	a2, err := decodeAsk(akey, asksKV.values[akey])
+	a2, err := delivery.DecodeAssignerAsk(akey, asksKV.values[akey])
 	if again.Step != delivery.PutPerson || err != nil || a2.Ask.ID == a.Ask.ID {
 		t.Fatalf("put again, it stands at %s (%s); its ask %q, %v; the first ask was %q", again.Step, again.Words, a2.Ask.ID, err, a.Ask.ID)
 	}
@@ -477,13 +380,11 @@ func putOfTheBus(t *testing.T) {
 func TestAModuleOnNeitherListIsRaisedOnceAndClearedOnce(t *testing.T) {
 	// A pair only one source names is a condition of the same kind (issue 1126): folded here to hold the count.
 	aPlacementAloneNamesWhereModulesRun(t)
-	// The verb edges a want waits on come from the graph and what runs (ADR 0614 §2, §3): folded here to hold the count.
-	aWantWaitsOnTheVerbEdgesTheGraphKeeps(t)
 	t.Run("gathers", testThePassGathersTheModulesOnNeitherList)
 	p := newPasser(buckets{}, time.Date(2026, 10, 25, 15, 0, 0, 0, time.UTC))
-	var said []oc.Condition
+	var said []asks.Condition
 	failing := true
-	p.say = func(c oc.Condition) error {
+	p.say = func(c asks.Condition) error {
 		if failing {
 			failing = false
 			return errors.New("the channel is away")
@@ -498,7 +399,7 @@ func TestAModuleOnNeitherListIsRaisedOnceAndClearedOnce(t *testing.T) {
 	p.sayNeither(one, nil, nil) // the say fails
 	p.sayNeither(one, nil, nil)
 	p.sayNeither(one, nil, nil)
-	if len(said) != 1 || said[0].State != occ.StateRaised || said[0].Subject.Machine != "g14" || said[0].Subject.ID != "screen-lock" {
+	if len(said) != 1 || said[0].State != asks.StateRaised || said[0].Subject.Machine != "g14" || said[0].Subject.ID != "screen-lock" {
 		t.Fatalf("said = %+v, want one raised condition of screen-lock on g14", said)
 	}
 	if !strings.Contains(strings.Join(logged, "\n"), "screen-lock") {
@@ -507,21 +408,20 @@ func TestAModuleOnNeitherListIsRaisedOnceAndClearedOnce(t *testing.T) {
 	wants := map[string]string{"g14.screen-lock": ""}
 	p.sayNeither(map[string]neitherOne{}, nil, wants)
 	p.sayNeither(map[string]neitherOne{}, nil, wants)
-	if len(said) != 2 || said[1].State != occ.StateCleared || said[1].Key != said[0].Key {
+	if len(said) != 2 || said[1].State != asks.StateCleared || said[1].Key != said[0].Key {
 		t.Errorf("said = %+v, want the condition cleared once under its key", said)
 	}
 	if last := logged[len(logged)-1]; last != "screen-lock on g14 has a want again" {
 		t.Errorf("the clear said %q", last)
 	}
-	// 1945: a module that leaves neither list with no want is cleared in words saying so, never "has a want again". The bus is
-	// on neither list by a rule as any module (ADR 0601 §1), nothing for the operator to do.
-	bus := map[string]neitherOne{"novox.nats": {node: "novox", module: "nats", holding: assign.Holding{Rule: delivery.RuleGrant, Words: "no credential"}}}
+	// 1945 (the bus bar): a module that leaves neither list with no want is cleared in words saying so, never "has a want again".
+	bus := map[string]neitherOne{"novox.nats": {node: "novox", module: "nats", holding: assign.Holding{Bus: true, Words: "the bus moves only by the operator's put"}}}
 	p.sayNeither(bus, nil, nil)
-	if c := said[len(said)-1]; c.State != occ.StateRaised || !strings.HasPrefix(c.Explanation, occ.NothingToDo) || !strings.Contains(c.Explanation, "rule 6 holds its first want back: no credential") {
+	if c := said[len(said)-1]; c.State != asks.StateRaised || !strings.HasPrefix(c.Explanation, asks.NeedsYou) || !strings.Contains(c.Explanation, "the bus moves only by the operator's put") {
 		t.Errorf("the bus's neither condition = %+v", c)
 	}
 	p.sayNeither(map[string]neitherOne{}, nil, map[string]string{"novox.nats": "it is held, and its held condition says so"})
-	if c := said[len(said)-1]; c.State != occ.StateCleared || strings.Contains(c.Resolved, "has a want") {
+	if c := said[len(said)-1]; c.State != asks.StateCleared || strings.Contains(c.Resolved, "has a want") {
 		t.Errorf("a module that left neither list with no want was cleared as %+v", c)
 	}
 	if last := logged[len(logged)-1]; last != "nats on novox is no longer on neither list and has no want: it is held, and its held condition says so" {
@@ -574,6 +474,7 @@ func testThePassGathersTheModulesOnNeitherList(t *testing.T) {
 		{nil, assign.Outcome{Rules: map[string]assign.Holding{"shanks": {Rule: delivery.RuleGrant, Words: "no credential"}}}, "rofi on shanks gets no want: rule 6: no credential"},
 		{nil, wanted, "rofi on shanks has a want"},
 		{map[string]delivery.Want{"shanks": wanted.Wants["shanks"]}, assign.Outcome{}, ""},
+		{nil, assign.Outcome{Rules: map[string]assign.Holding{"shanks": {Bus: true, Words: "the bus moves only by the operator's put"}}}, "rofi on shanks gets no want: the bus moves only by the operator's put"},
 	} {
 		logged = nil
 		p.sayNoWant("rofi", []string{"shanks"}, c.before, c.out)
@@ -583,16 +484,16 @@ func testThePassGathersTheModulesOnNeitherList(t *testing.T) {
 	}
 	// 1496, ADR 0557 §1: a failure that is the node's own (its fingerprint healthy elsewhere, not held) raises the node's condition
 	// once, naming the node, the module, F and the have's words, and clears it once when it ends.
-	var conds []oc.Condition
-	p.say = func(c oc.Condition) error { conds = append(conds, c); return nil }
+	var conds []asks.Condition
+	p.say = func(c asks.Condition) error { conds = append(conds, c); return nil }
 	failing := map[string]assign.NodeFailure{"shanks": {Others: []string{"ace"}, Words: "health failed, phase running: w"}}
 	for i, c := range []struct {
 		failed map[string]assign.NodeFailure
 		state  string // the condition said in this pass, "" for none
 	}{
-		{failing, occ.StateRaised},
+		{failing, asks.StateRaised},
 		{failing, ""},
-		{nil, occ.StateCleared},
+		{nil, asks.StateCleared},
 		{nil, ""},
 	} {
 		conds = nil
@@ -600,7 +501,7 @@ func testThePassGathersTheModulesOnNeitherList(t *testing.T) {
 		switch {
 		case c.state == "" && len(conds) != 0, c.state != "" && (len(conds) != 1 || conds[0].State != c.state):
 			t.Errorf("node failed, pass %d said %+v, want %q", i, conds, c.state)
-		case c.state == occ.StateRaised && (conds[0].Key != "mesh-delivery-assigner.failed-alone.shanks.rofi" ||
+		case c.state == asks.StateRaised && (conds[0].Key != "mesh-delivery-assigner.failed-alone.shanks.rofi" ||
 			!strings.Contains(conds[0].Explanation, "failed on shanks (health failed, phase running: w), while it runs healthy on ace")):
 			t.Errorf("node failed, raised %+v", conds[0])
 		}
@@ -611,7 +512,7 @@ func testThePassGathersTheModulesOnNeitherList(t *testing.T) {
 	p.sayNodeFailed("rofi", fpTest, []string{"shanks"}, assign.Nodes{}, assign.Outcome{NodeFailed: failing}, false)
 	p.sayNodeFailed("rofi", fpTest, nil, assign.Nodes{}, assign.Outcome{}, false)
 	p.sayNodeFailed("rofi", fpTest, nil, assign.Nodes{}, assign.Outcome{}, false)
-	if len(conds) != 2 || conds[1].State != occ.StateCleared || conds[1].Key != "mesh-delivery-assigner.failed-alone.shanks.rofi" {
+	if len(conds) != 2 || conds[1].State != asks.StateCleared || conds[1].Key != "mesh-delivery-assigner.failed-alone.shanks.rofi" {
 		t.Errorf("a node leaving the module said %+v, want one raise and one clear", conds)
 	}
 	known := assign.Nodes{Online: map[string]bool{"ace": true, "g14": false},
@@ -627,11 +528,11 @@ func testThePassGathersTheModulesOnNeitherList(t *testing.T) {
 		conds = nil
 		fresh := newPasser(buckets{}, time.Date(2026, 10, 26, 22, 0, 0, 0, time.UTC))
 		fresh.logf = func(string, ...any) {}
-		fresh.say = func(c oc.Condition) error { conds = append(conds, c); return nil }
+		fresh.say = func(c asks.Condition) error { conds = append(conds, c); return nil }
 		fresh.sayNodeFailed("rofi", fpTest, nil, c.known, assign.Outcome{}, true)
 		var keys []string
 		for _, cond := range conds {
-			if cond.State == occ.StateCleared {
+			if cond.State == asks.StateCleared {
 				keys = append(keys, cond.Key)
 			}
 		}
@@ -648,8 +549,8 @@ func TestTheFirstPassAfterAStartClearsWhatAPreviousProcessRaised(t *testing.T) {
 	t.Run("a held module", testAHeldModuleRaisesNoNeitherAndClearsAStandingOne)
 	wantsKV := &memKV{values: map[string][]byte{}}
 	p := newPasser(buckets{delivery.AssignerWantsBucket: wantsKV, delivery.AssignerAsksBucket: &memKV{values: map[string][]byte{}}}, time.Now())
-	var said []oc.Condition
-	p.say = func(c oc.Condition) error { said = append(said, c); return nil }
+	var said []asks.Condition
+	p.say = func(c asks.Condition) error { said = append(said, c); return nil }
 	mod, _ := delivery.EncodeModule(delivery.Module{FP2: fpTest, Repository: "novox/web", Commit: strings.Repeat("1", 40), Path: delivery.RootPath})
 	p.w.put(delivery.ModulesBucket, "web", mod)
 	placeOn(t, p.w, "g14", "web")
@@ -663,7 +564,7 @@ func TestTheFirstPassAfterAStartClearsWhatAPreviousProcessRaised(t *testing.T) {
 	p.wants(context.Background())
 	cleared := map[string]bool{}
 	for _, c := range said {
-		if c.State != occ.StateCleared {
+		if c.State != asks.StateCleared {
 			t.Errorf("the first pass raised %+v", c)
 		}
 		cleared[c.Key] = true
@@ -684,10 +585,10 @@ func TestTheFirstPassAfterAStartClearsWhatAPreviousProcessRaised(t *testing.T) {
 // neither condition for it, a neither condition this process raised for it before is cleared, and so is one a previous process
 // raised (the first pass after a start), each once.
 func testAHeldModuleRaisesNoNeitherAndClearsAStandingOne(t *testing.T) {
-	setup := func() (*passer, *[]oc.Condition) {
+	setup := func() (*passer, *[]asks.Condition) {
 		p := newPasser(buckets{delivery.AssignerWantsBucket: &memKV{values: map[string][]byte{}}, delivery.AssignerAsksBucket: &memKV{values: map[string][]byte{}}}, time.Now())
-		said := &[]oc.Condition{}
-		p.say = func(c oc.Condition) error { *said = append(*said, c); return nil }
+		said := &[]asks.Condition{}
+		p.say = func(c asks.Condition) error { *said = append(*said, c); return nil }
 		mod, _ := delivery.EncodeModule(delivery.Module{FP2: fpTest, Repository: "novox/resolved", Commit: strings.Repeat("1", 40), Path: delivery.RootPath})
 		p.w.put(delivery.ModulesBucket, "systemd-resolved", mod)
 		placeOn(t, p.w, "shanks", "systemd-resolved")
@@ -701,12 +602,12 @@ func testAHeldModuleRaisesNoNeitherAndClearsAStandingOne(t *testing.T) {
 		return p, said
 	}
 	key := assign.NeitherCondition("shanks", "systemd-resolved", assign.Holding{}, false).Key
-	neithers := func(said []oc.Condition) (raised, cleared int) {
+	neithers := func(said []asks.Condition) (raised, cleared int) {
 		for _, c := range said {
 			if c.Key != key {
 				continue
 			}
-			if c.State == occ.StateRaised {
+			if c.State == asks.StateRaised {
 				raised++
 			} else {
 				cleared++
@@ -765,8 +666,8 @@ func TestAsksOfAFingerprintTheTrunkLeftBehindAreTakenAway(t *testing.T) {
 		t.Run(c.name, func(t *testing.T) {
 			asksKV, wantsKV := &memKV{values: map[string][]byte{}}, &memKV{values: map[string][]byte{}}
 			p := newPasser(buckets{delivery.AssignerAsksBucket: asksKV, delivery.AssignerWantsBucket: wantsKV}, time.Now())
-			var said []oc.Condition
-			p.say = func(c oc.Condition) error { said = append(said, c); return nil }
+			var said []asks.Condition
+			p.say = func(c asks.Condition) error { said = append(said, c); return nil }
 			for _, key := range all {
 				k, _ := delivery.ParseAnyAskKey(key)
 				var a delivery.AssignerAsk
@@ -780,7 +681,7 @@ func TestAsksOfAFingerprintTheTrunkLeftBehindAreTakenAway(t *testing.T) {
 				default:
 					a = assign.BackupAsk(key, k.Node, k.Module, k.FP, digOld, "w", 2, time.Now())
 				}
-				v, err := assign.EncodeAsk(key, a)
+				v, err := delivery.EncodeAssignerAsk(key, a)
 				if err != nil {
 					t.Fatal(err)
 				}
@@ -794,13 +695,13 @@ func TestAsksOfAFingerprintTheTrunkLeftBehindAreTakenAway(t *testing.T) {
 			heldOld, _ := delivery.HeldKey("web", fpOld)
 			wantsKV.values[heldOld] = []byte("x")
 			p.w.put(delivery.AssignerWantsBucket, heldOld, []byte("x"))
-			firstAsk, _ := decodeAsk(holdOld, asksKV.values[holdOld])
+			firstAsk, _ := delivery.DecodeAssignerAsk(holdOld, asksKV.values[holdOld])
 			p.staleAsks(context.Background(), c.trunk)
 			// the held record and condition of a fingerprint whose hold ask went are taken away with it
 			heldOld, _ = delivery.HeldKey("web", fpOld)
 			_, heldThere := wantsKV.values[heldOld]
-			cleared := slices.ContainsFunc(said, func(c oc.Condition) bool {
-				return c.Key == assign.HeldCondition("web", fpOld, "", "", false, false).Key && c.State == occ.StateCleared
+			cleared := slices.ContainsFunc(said, func(c asks.Condition) bool {
+				return c.Key == assign.HeldCondition("web", fpOld, "", "", false, false).Key && c.State == asks.StateCleared
 			})
 			if gone := slices.Contains(c.gone, holdOld); !heldThere || cleared != gone {
 				t.Errorf("hold ask of the old fingerprint gone = %v: its held record stays = %v (must), its condition cleared = %v", gone, heldThere, cleared)
@@ -817,8 +718,8 @@ func TestAsksOfAFingerprintTheTrunkLeftBehindAreTakenAway(t *testing.T) {
 				p.now = func() time.Time { return time.Now().Add(time.Hour) }
 				p.holdAsk(context.Background(), "web", fpOld, nil)
 				p.heldCondition(context.Background(), "web", fpOld, nil, false)
-				again, err := decodeAsk(holdOld, asksKV.values[holdOld])
-				raised := slices.ContainsFunc(said, func(c oc.Condition) bool { return c.State == occ.StateRaised })
+				again, err := delivery.DecodeAssignerAsk(holdOld, asksKV.values[holdOld])
+				raised := slices.ContainsFunc(said, func(c asks.Condition) bool { return c.State == asks.StateRaised })
 				if err != nil || again.Ask.ID == firstAsk.Ask.ID || !raised {
 					t.Errorf("the trunk returned to the held fingerprint: ask %q (first %q, %v), condition raised again = %v", again.Ask.ID, firstAsk.Ask.ID, err, raised)
 				}
@@ -829,9 +730,9 @@ func TestAsksOfAFingerprintTheTrunkLeftBehindAreTakenAway(t *testing.T) {
 	t.Run("a clear that failed to be said is said at the next pass, and the ask goes after it", func(t *testing.T) {
 		asksKV, wantsKV := &memKV{values: map[string][]byte{}}, &memKV{values: map[string][]byte{}}
 		p := newPasser(buckets{delivery.AssignerAsksBucket: asksKV, delivery.AssignerWantsBucket: wantsKV}, time.Now())
-		var said []oc.Condition
+		var said []asks.Condition
 		fail := true
-		p.say = func(c oc.Condition) error {
+		p.say = func(c asks.Condition) error {
 			if fail {
 				fail = false
 				return errors.New("router unreachable")
@@ -840,7 +741,7 @@ func TestAsksOfAFingerprintTheTrunkLeftBehindAreTakenAway(t *testing.T) {
 			return nil
 		}
 		a := assign.HoldAsk(holdOld, "web", fpOld, "novox", "w", 1, time.Now())
-		v, err := assign.EncodeAsk(holdOld, a)
+		v, err := delivery.EncodeAssignerAsk(holdOld, a)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -851,7 +752,7 @@ func TestAsksOfAFingerprintTheTrunkLeftBehindAreTakenAway(t *testing.T) {
 			t.Fatalf("after a failed clear: ask left = %v, conditions said = %d; want the ask kept and nothing said", there, len(said))
 		}
 		p.staleAsks(context.Background(), trunkOf(fpNew))
-		if _, there := asksKV.values[holdOld]; there || len(said) != 1 || said[0].State != occ.StateCleared {
+		if _, there := asksKV.values[holdOld]; there || len(said) != 1 || said[0].State != asks.StateCleared {
 			t.Errorf("at the next pass: ask left = %v, conditions said = %v; want the ask gone and the clear said", there, said)
 		}
 	})
@@ -887,89 +788,38 @@ func mustKey(key string, err error) string {
 func TestARecordAskOfAHeldBackNodeSurvivesPassesAndItsYesMovesTheWant(t *testing.T) {
 	// A placed node's yes comes from its have (issue 1126): folded here to hold the count.
 	aPlacedNodesWantsNameTheBuildAloneAndItsYesComesFromItsHave(t)
-	aReleasesApproveAnswersTheMoveOfItsBuildAlone(t)
-}
-
-// ADR 0601 §1: a placed node's have waiting for a yes to a move of the build alone, to a build an approved release carries, is
-// given its yes by that Approve, the want naming the release, and no record ask is raised; a move that changes a setting or a
-// secret too, one at the build it runs, and one no approved release carries are asked of a person as before.
-func aReleasesApproveAnswersTheMoveOfItsBuildAlone(t *testing.T) {
-	fpOld := delivery.SourcePrefix2 + strings.Repeat("a", 64)
-	waiting, was := "sha256:"+strings.Repeat("e", 64), "sha256:"+strings.Repeat("d", 64)
-	commit := strings.Repeat("1", 40)
-	for _, c := range []struct {
-		name       string
-		alone      bool
-		at         string // the fingerprint the have runs
-		mergedAt   string // the commit the release merged web at; "" for no merge of the release
-		fpSrc      uint64 // the source revision at which web's fingerprint last changed
-		yes, asked bool
-	}{
-		{"the build alone, its release approved", true, fpOld, commit, 7, true, false},
-		{"a setting changed too", false, fpOld, commit, 7, false, true},
-		{"a setting changed at the build it runs", true, fpTest, commit, 7, false, true},
-		{"no approved release carries it", true, fpOld, "", 7, false, true},
-		{"the release merged another commit", true, fpOld, strings.Repeat("2", 40), 7, false, true},
-		// Its fingerprint last moved at another release's revision, which merged nothing of web: that Approve answers nothing.
-		{"a fingerprint another release moved", true, fpOld, commit, 8, false, true},
-		// Review rounds 1 and 2: moved by a recompute after the release (a toolchain, a package, a base) with no merge, the
-		// indexer writes fp-src 0, not known, though Src is still the release's: asked of a person.
-		{"a fingerprint moved by a recompute after the release", true, fpOld, commit, 0, false, true},
-	} {
-		asksKV := &memKV{values: map[string][]byte{}}
-		p := newPasser(buckets{delivery.AssignerAsksBucket: asksKV}, time.Now())
-		p.logf = t.Logf
-		mod, _ := delivery.EncodeModule(delivery.Module{FP2: fpTest, Repository: "novox/web", Commit: commit, Src: 7, FPSrc: c.fpSrc, Path: delivery.RootPath})
-		p.w.put(delivery.ModulesBucket, "web", mod)
-		src, _ := delivery.EncodeSource(delivery.Source{Group: "feat/web", Heads: map[string]string{"novox/web": commit}})
-		p.w.putEntry(delivery.SourceBucket, delivery.SourceMainKey, src, 7, time.Now())
-		later, _ := delivery.EncodeSource(delivery.Source{Group: "feat/other", Heads: map[string]string{"novox/web": commit, "novox/x": commit}})
-		p.w.putEntry(delivery.SourceBucket, delivery.SourceMainKey, later, 8, time.Now()) // a later merge leaves revision 7's release
-		if c.mergedAt != "" {
-			merge, err := delivery.EncodeMerge(delivery.Merge{Group: "feat/web", Ask: "merge.feat_web.0123456789ab", Pulls: []delivery.MergePull{
-				{Head: delivery.Head{Repository: "novox/web", Number: 3, Head: strings.Repeat("3", 40)}, State: delivery.MergeMerged, Commit: c.mergedAt}}})
-			if err != nil {
-				t.Fatal(err)
-			}
-			p.w.put(delivery.MergesBucket, "feat/web", merge)
-			other, err := delivery.EncodeMerge(delivery.Merge{Group: "feat/other", Ask: "merge.feat_other.0123456789ab", Pulls: []delivery.MergePull{
-				{Head: delivery.Head{Repository: "novox/x", Number: 4, Head: strings.Repeat("4", 40)}, State: delivery.MergeMerged, Commit: commit}}})
-			if err != nil {
-				t.Fatal(err)
-			}
-			p.w.put(delivery.MergesBucket, "feat/other", other)
-		}
-		have, _ := delivery.EncodeHave(delivery.Have{FP: c.at, Composed: was, Phase: delivery.PhaseWaitingYes, Health: delivery.HealthOK,
-			Judgement: delivery.JudgedRecreates, Waits: waiting, Detail: "it recreates web.server", BuildAlone: c.alone})
-		p.w.put(delivery.HaveBucket, "g14.web", have)
-		m := assign.Module{Name: "web", FP: fpTest, Nodes: []string{"g14"}, Self: func(string) bool { return true },
-			Release: func(fp string) (string, bool) { return p.w.release("web", fp) }}
-		out := assign.Outcome{Wants: map[string]delivery.Want{"g14": {FP: fpTest, Self: true}}}
-		p.yeses(context.Background(), "web", m, map[string]delivery.Want{"g14": {FP: fpOld, Self: true}}, &out)
-		w := out.Wants["g14"]
-		if got := w.Yes == waiting && w.Release == "feat/web"; got != c.yes || (!c.yes && (w.Yes != "" || w.Release != "")) {
-			t.Errorf("%s: the want is %+v", c.name, w)
-		}
-		akey, _ := delivery.RecordAskKey("g14", "web", waiting)
-		if _, there := asksKV.values[akey]; there != c.asked {
-			t.Errorf("%s: a record ask raised %v, want %v", c.name, there, c.asked)
-		}
-	}
 }
 
 // 774/S26/AC1 (ADR 0549 §5, ADR 0567 §8): the seat's placement alone names where modules run: no controller state is read, so a
-// module in an assignment only is no module of its node, and before any placement is read nothing is placed.
+// module in an assignment only is no module of its node; before any placement is read nothing is placed and the check composes
+// no input; placed, the check composes over the input the nodes compose from (frombus, 1126, ADR 0547 §2).
 func aPlacementAloneNamesWhereModulesRun(t *testing.T) {
 	p := newPasser(buckets{}, time.Date(2026, 10, 26, 18, 0, 0, 0, time.UTC))
 	p.w.put("mesh-controller_assignments", "g14.b", []byte(`{"node":"g14","module":"b","build":"b-1"}`)) // read no more
 	if got := p.w.assigned(); len(got) != 0 {
 		t.Fatalf("before any placement: assigned %v", got)
 	}
+	none := func(context.Context, string) ([]byte, error) { return nil, errNotThere }
+	if m := p.w.mesh(context.Background(), none); m.Input != nil || m.InputUnread != "" {
+		t.Errorf("before any placement the check composes over %+v (%q)", m.Input, m.InputUnread)
+	}
 	placeOn(t, p.w, "g14", "c", "a")
 	placeOn(t, p.w, "n2", "d")
 	if got := p.w.assigned(); !slices.Equal(got["g14"], []string{"a", "c"}) || !slices.Equal(got["n2"], []string{"d"}) || len(got) != 2 {
 		t.Errorf("the placement alone: assigned %v", got)
 	}
+	if m := p.w.mesh(context.Background(), none); m.Input != nil || !strings.Contains(m.InputUnread, "g14") {
+		t.Errorf("a placed node with no record: input %+v, unread %q", m.Input, m.InputUnread)
+	}
+	placeOn(t, p.w, "g14", "a", "b", "c")
+	rec, _ := delivery.EncodeHaveNode(delivery.HaveNode{Record: &delivery.NodeRecord{Node: "g14", TunnelKey: "k"}})
+	p.w.put(delivery.HaveBucket, "g14.node", rec)
+	rec2, _ := delivery.EncodeHaveNode(delivery.HaveNode{Record: &delivery.NodeRecord{Node: "n2", TunnelKey: "k2"}})
+	p.w.put(delivery.HaveBucket, "n2.node", rec2)
+	m := p.w.mesh(context.Background(), none)
+	if m.Input == nil || len(m.Input.Nodes) != 2 || !slices.Equal(m.Input.Nodes[0].Assigned, []string{"a", "b", "c"}) || m.Input.Nodes[0].Place.Key != "k" {
+		t.Errorf("the check's input from the bus: %+v (%q)", m.Input, m.InputUnread)
+	}
 }
 
 // 1126 (ADR 0547 §2 to §4): a node the catalogue places composes its own: its wants name the build alone and its own want
@@ -1040,7 +890,7 @@ func aPlacedNodesWantsNameTheBuildAloneAndItsYesComesFromItsHave(t *testing.T) {
 	if wantsKV.puts != wantPuts {
 		t.Fatalf("a want put unchanged reached the bucket")
 	}
-	a, err := decodeAsk(akey, asksKV.values[akey])
+	a, err := delivery.DecodeAssignerAsk(akey, asksKV.values[akey])
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1077,8 +927,8 @@ func TestAnApprovedPlacementCallsNoControllerVerb(t *testing.T) {
 		t.Fatalf("calls = %d, said = %v", len(bus.calls), said)
 	}
 
-	var conds []oc.Condition
-	p.say = func(c oc.Condition) error { conds = append(conds, c); return nil }
+	var conds []asks.Condition
+	p.say = func(c asks.Condition) error { conds = append(conds, c); return nil }
 	fails := 1
 	p.findings.Keys = func() ([]string, error) {
 		if fails > 0 {
@@ -1090,85 +940,8 @@ func TestAnApprovedPlacementCallsNoControllerVerb(t *testing.T) {
 	p.clearStaleCalls()
 	p.clearStaleCalls()
 	p.clearStaleCalls()
-	if len(conds) != 2 || conds[0].State != occ.StateCleared || conds[0].Key != "mesh-delivery-assigner.controller-call.anchor.web" ||
+	if len(conds) != 2 || conds[0].State != asks.StateCleared || conds[0].Key != "mesh-delivery-assigner.controller-call.anchor.web" ||
 		conds[1].Key != "mesh-delivery-assigner.controller-pin.laptop.db" {
 		t.Fatalf("the old conditions cleared = %+v", conds)
 	}
 }
-
-// ADR 0614 §2, §3: of what a module invokes, the pass keeps as edges the verbs the graph does not leave out and another
-// module serves; a verb is served once a running healthy build's manifest (the builder's build, the indexer's manifest)
-// serves it, and a build whose manifest cannot be read counts what the graph says its module serves. No graph read: no wait.
-func aWantWaitsOnTheVerbEdgesTheGraphKeeps(t *testing.T) {
-	p := newPasser(buckets{}, time.Now())
-	fp := func(c string) string { return delivery.SourcePrefix2 + strings.Repeat(c, 64) }
-	if p.served(context.Background(), nil, graph.Graph{}, assign.Nodes{}) != nil {
-		t.Error("with no graph read, a want waits on a verb")
-	}
-	for module, n := range map[string]graph.Node{
-		"caller": {FP: fp("c"), Repository: "novox/caller", Invokes: []string{"seat:x.v", "loop.l", "none.t", "caller.own"}, LeftOut: []string{"loop.l"},
-			Serves: []string{"caller.own"}},
-		"server": {FP: fp("e"), Repository: "novox/server", Serves: []string{"seat:x.v", "seat:x.w"}},
-		"loop":   {FP: fp("1"), Repository: "novox/loop", Serves: []string{"loop.l"}},
-		"late":   {FP: fp("2"), Repository: "novox/late", Serves: []string{"late.t"}},
-	} {
-		raw, err := graph.Encode(n)
-		if err != nil {
-			t.Fatal(err)
-		}
-		p.w.put(graph.Bucket, module, raw)
-	}
-	g := p.moduleGraph()
-	if got := keptInvokes(g, "caller"); !slices.Equal(got, []string{"seat:x.v"}) || keptInvokes(g, "unknown") != nil {
-		t.Errorf("the kept verb edges of caller = %v", got)
-	}
-	digest := strings.Repeat("d", 64)
-	man, _ := delivery.EncodeManifest(delivery.Manifest{Module: "server", JSON: `{"module":"server","claims":[{"name":"x","scope":"mesh","serves":["w"]}]}`})
-	get := func(_ context.Context, key string) ([]byte, error) {
-		if key == digest {
-			return man, nil
-		}
-		return nil, errNotThere
-	}
-	build, _ := delivery.EncodeBuilderBuild(delivery.BuilderBuild{State: delivery.BuildDone, Manifest: digest})
-	key, _ := delivery.BuilderBuildKey("server", fp("f"))
-	p.w.put(delivery.BuilderBuildsBucket, key, build)
-	running := delivery.Have{Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
-	at := func(f string) delivery.Have { h := running; h.FP = f; return h }
-	served := p.served(context.Background(), get, g, assign.Nodes{Haves: map[string]map[string]delivery.Have{
-		"g14": {"server": at(fp("f")), "late": at(fp("2"))}}})
-	for v, want := range map[string]bool{"seat:x.w": true, "seat:x.v": false, "late.t": true} {
-		if served(v) != want {
-			t.Errorf("served(%s) = %v, want %v: the running server's manifest serves w alone, late's is not read", v, served(v), want)
-		}
-	}
-	// ADR 0614 §5: bus-state counts as offered only from a healthy build on a node present; the bus module's build on an
-	// offline node offers nothing, and one whose manifest is not read counts its trunk manifest's offer.
-	bus := map[string]catalogue.Manifest{"bus": {Module: "bus", Provides: []catalogue.Offer{{Name: graph.BusState, Scope: catalogue.ScopeMesh}}}}
-	for _, online := range []bool{false, true} {
-		offering := p.offering(context.Background(), get, bus, assign.Nodes{Online: map[string]bool{"n2": online},
-			Haves: map[string]map[string]delivery.Have{"n2": {"bus": at(fp("2"))}}})
-		if offering(graph.BusState) != online {
-			t.Errorf("with the bus module's node online %v, bus-state offered %v", online, offering(graph.BusState))
-		}
-	}
-}
-
-// decodedAsk is an asks-state value with the router's ask it carries decoded (mesh-sdk keeps it as raw JSON).
-type decodedAsk struct {
-	Asking int
-	Ask    oc.Ask
-}
-
-func decodeAsk(key string, data []byte) (decodedAsk, error) {
-	a, ask, err := assign.DecodeAsk(key, data)
-	return decodedAsk{Asking: a.Asking, Ask: ask}, err
-}
-
-func mustAskID(a delivery.AssignerAsk) string {
-	ask, err := assign.AskOf(a)
-	if err != nil {
-		panic(err)
-	}
-	return ask.ID
-}

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/puts.go

@@ -10,7 +10,7 @@ import (
 	"sync"
 	"time"
 
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
+	"git.novox.be/novox/mesh-sdk/go/asks"
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 	"git.novox.be/novox/mesh-sdk/go/handacts"
@@ -99,7 +99,7 @@ func (p *passer) puts(ctx context.Context) {
 	}
 	assigned := p.w.assigned()
 	trunk := p.w.trunk()
-	get := p.w.getter(delivery.ManifestsBucket) // the indexer's manifests, as its first view and views family say them
+	get := kvGetter(p.kvs[delivery.ManifestsBucket])
 	wanted := p.w.wantsOf()
 	modules := make([]string, 0, len(all))
 	for m := range all {
@@ -195,15 +195,14 @@ func (p *passer) putWorld(node, module string, put delivery.Put, manifest catalo
 		w.Recorded = policy == catalogue.PolicyRecord
 		if akey, err := delivery.RecordAskKey(node, module, d.Digest); err == nil && put.Ask == akey {
 			// Only this put's own ask counts: an ask (and its answer) of an earlier put under the same key is another asking.
-			if a, ask, err := assign.DecodeAsk(akey, p.w.value(delivery.AssignerAsksBucket, akey)); err == nil && a.Asking == assign.PutAsking(put) {
+			if a, err := delivery.DecodeAssignerAsk(akey, p.w.value(delivery.AssignerAsksBucket, akey)); err == nil && a.Asking == assign.PutAsking(put) {
 				switch {
 				case p.answeredWith(akey, assign.OptionYes):
 					w.Answer = assign.OptionYes
 				case p.answeredWith(akey, assign.OptionNo):
 					w.Answer = assign.OptionNo
 				default:
-					expires := assign.ExpiresAt(ask)
-					w.AskExpired = !expires.IsZero() && w.Now.After(expires)
+					w.AskExpired = !a.Ask.Expires.IsZero() && w.Now.After(a.Ask.Expires)
 				}
 			}
 		}
@@ -243,13 +242,13 @@ func (p *passer) actOn(ctx context.Context, node, module, id string, w assign.Pu
 		// The put's own ask, written again over one an earlier put left under the key (its asking differs), so the teller
 		// raises it anew under its own id.
 		akey := next.Put.Ask
-		current, _, err := assign.DecodeAsk(akey, p.w.value(delivery.AssignerAsksBucket, akey))
+		current, err := delivery.DecodeAssignerAsk(akey, p.w.value(delivery.AssignerAsksBucket, akey))
 		if err != nil || current.Asking != assign.PutAsking(next.Put) {
 			a, err := assign.PutAsk(akey, node, module, next.Put, *w.Composed, w.Bus, w.Now)
 			if err != nil {
 				p.logf("the ask about putting %s on %s is not written: %v", module, node, err)
 			} else {
-				p.put(ctx, delivery.AssignerAsksBucket, akey, func() ([]byte, error) { return assign.EncodeAsk(akey, a) })
+				p.put(ctx, delivery.AssignerAsksBucket, akey, func() ([]byte, error) { return delivery.EncodeAssignerAsk(akey, a) })
 			}
 		}
 	}
@@ -258,15 +257,15 @@ func (p *passer) actOn(ctx context.Context, node, module, id string, w assign.Pu
 	}
 }
 
-// performs checks that the act about to be performed is the one the yes of the ask at key bound (occ.Performs).
-func (p *passer) performs(key string, act occ.Act) error {
-	_, ask, err := assign.DecodeAsk(key, p.w.value(delivery.AssignerAsksBucket, key))
+// performs checks that the act about to be performed is the one the yes of the ask at key bound (asks.Option.Performs).
+func (p *passer) performs(key string, act asks.Act) error {
+	a, err := delivery.DecodeAssignerAsk(key, p.w.value(delivery.AssignerAsksBucket, key))
 	if err != nil {
 		return fmt.Errorf("the ask %s cannot be read: %w", key, err)
 	}
-	for _, o := range ask.Options {
+	for _, o := range a.Ask.Options {
 		if o.ID == assign.OptionYes {
-			return occ.Performs(o, act)
+			return o.Performs(act)
 		}
 	}
 	return fmt.Errorf("the ask %s offers no yes", key)

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/seat.go

@@ -15,13 +15,15 @@ import (
 	"github.com/nats-io/nats.go"
 	"github.com/nats-io/nats.go/jetstream"
 
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
+	"git.novox.be/novox/mesh-sdk/go/asks"
+	"git.novox.be/novox/mesh-sdk/go/compose"
+	"git.novox.be/novox/mesh-sdk/go/compose/frombus"
+	"git.novox.be/novox/mesh-sdk/go/compose/judge"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 	"git.novox.be/novox/mesh-sdk/go/handacts"
 	"git.novox.be/novox/mesh-sdk/go/process"
 
 	"mesh-delivery-assigner/internal/assign"
-	"mesh-delivery-assigner/internal/judge"
 )
 
 // The seat mesh-placement's holder in the assigner's process (novox/hq ADR 0567 §2-§8): each pass follows every open
@@ -124,7 +126,7 @@ func (p *passer) sayWaits(unbound []string) {
 	if p.say == nil || p.said[c.Key] && p.saidWaits == state {
 		return
 	}
-	if c.State == occ.StateCleared && p.saidWaits == "" {
+	if c.State == asks.StateCleared && p.saidWaits == "" {
 		return // nothing was raised by this process
 	}
 	if err := p.say(c); err != nil {
@@ -243,16 +245,11 @@ func (p *passer) ask(ctx context.Context, prop delivery.PlacementProposal, akey,
 		p.logf("the ask about the proposal %s is not written: %v", prop.ID, err)
 		return prop, false
 	}
-	placed, err := assign.AskOf(a)
-	if err != nil {
-		p.logf("the ask about the proposal %s is not written: %v", prop.ID, err)
-		return prop, false
-	}
-	p.put(ctx, delivery.AssignerAsksBucket, akey, func() ([]byte, error) { return assign.EncodeAsk(akey, a) })
+	p.put(ctx, delivery.AssignerAsksBucket, akey, func() ([]byte, error) { return delivery.EncodeAssignerAsk(akey, a) })
 	if pk, err := delivery.PulseAskKey(prop.ID); err == nil {
-		p.pulse(ctx, pk, assign.ExpiresAt(placed).Sub(p.clock()))
+		p.pulse(ctx, pk, a.Ask.Expires.Sub(p.clock()))
 	}
-	prop.State, prop.Ask = delivery.ProposalAsked, placed.ID
+	prop.State, prop.Ask = delivery.ProposalAsked, a.Ask.ID
 	return prop, true
 }
 
@@ -357,35 +354,67 @@ func moved(prop delivery.PlacementProposal, revs map[string]uint64) bool {
 	return false
 }
 
-// intendedOf is, by proposal and the revisions it was laid over, what Intended computed, kept while this process runs.
+// intended is, by proposal and the revisions it was laid over, what Intended computed, kept while this process runs.
 func (p *passer) intendedOf(prop delivery.PlacementProposal, current map[string]delivery.Placement, cands map[string]delivery.PlacementCandidate) map[string]map[string]bool {
 	key := fmt.Sprint(prop.ID, prop.Base)
 	if got, ok := p.intended[key]; ok {
 		return got
 	}
-	got, _ := p.compute(prop, current, cands)
+	got, _, _ := p.compute(prop, current, cands)
 	p.intended[key] = got
 	return got
 }
 
-// compute is what the proposal changes on each node by its placement, and the nodes that answer it: every node with a
-// placement or a record (judge.Intended, ADR 0593 §8). The holder composes nothing: each node says what its compositions
-// change in its answer.
-func (p *passer) compute(prop delivery.PlacementProposal, current map[string]delivery.Placement, cands map[string]delivery.PlacementCandidate) (map[string]map[string]bool, []string) {
+// compute composes every node with the current placement and with the proposal laid over it (judge.Intended).
+func (p *passer) compute(prop delivery.PlacementProposal, current map[string]delivery.Placement, cands map[string]delivery.PlacementCandidate) (map[string]map[string]bool, []string, []string) {
 	laid := map[string]*delivery.Placement{}
 	for _, node := range prop.Nodes() {
 		if c, ok := cands[node]; ok && !c.Reached {
 			laid[node] = c.Placement
 		}
 	}
+	get := kvGetter(p.kvs[delivery.ManifestsBucket])
+	r := worldReader{w: p.w, manifests: get}
+	// A read that fails is said, never dropped silently (novox/hq ADR 0578 §3); a refused manifest no longer fails it, and
+	// its module is held, named in the input's Refused.
+	var now, with *compose.Input
+	if in, err := frombus.Input(context.Background(), r, frombus.Mesh{}, frombus.Scope{Every: true}); err == nil {
+		now = &in
+	} else if p.logf != nil {
+		p.logf("proposal %s: the current composition input cannot be read, so what it changes is judged without it: %v", prop.ID, err)
+	}
+	if in, err := frombus.Input(context.Background(), r, frombus.Mesh{}, frombus.Scope{Every: true, Placements: laid}); err == nil {
+		with = &in
+	} else if p.logf != nil {
+		p.logf("proposal %s: the composition input with the proposal cannot be read, so what it changes is judged without it: %v", prop.ID, err)
+	}
+	if now != nil && len(now.Refused) > 0 && p.logf != nil {
+		var held []string
+		for _, m := range slices.Sorted(maps.Keys(now.Refused)) {
+			held = append(held, m+" ("+now.Refused[m]+")")
+		}
+		p.logf("proposal %s: held as refused by the indexer's judge: %s", prop.ID, strings.Join(held, "; "))
+	}
 	nodes := map[string]bool{}
 	for n := range current {
 		nodes[n] = true
 	}
-	for n := range p.w.records() {
-		nodes[n] = true
+	if records, err := r.Records(context.Background()); err == nil {
+		for n := range records {
+			nodes[n] = true
+		}
 	}
-	return judge.Intended(current, laid, slices.Sorted(maps.Keys(nodes)))
+	names := make([]string, 0, len(nodes))
+	for n := range nodes {
+		names = append(names, n)
+	}
+	fps := map[string]string{}
+	for name, m := range p.w.trunk() {
+		if m.FP2 != "" {
+			fps[name] = m.FP2
+		}
+	}
+	return judge.Intended(now, with, current, laid, names, fps)
 }
 
 // mustAnswer finds the nodes the proposal must hear from (§3), writes a reached candidate for each whose key it does not
@@ -396,7 +425,7 @@ func (p *passer) mustAnswer(ctx context.Context, prop delivery.PlacementProposal
 			return // the verbs write the candidates before the proposal: wait to hear them
 		}
 	}
-	intended, must := p.compute(prop, current, cands)
+	intended, must, notes := p.compute(prop, current, cands)
 	p.intended[fmt.Sprint(prop.ID, prop.Base)] = intended
 	for _, node := range must {
 		if _, ok := cands[node]; ok {
@@ -418,6 +447,9 @@ func (p *passer) mustAnswer(ctx context.Context, prop delivery.PlacementProposal
 		}
 	}
 	prop.Must = must
+	if len(notes) > 0 {
+		prop.Words = strings.TrimPrefix(prop.Words+"; "+strings.Join(notes, "; "), "; ")
+	}
 	p.writeProposal(ctx, prop, rev)
 }
 
@@ -451,7 +483,7 @@ func (p *passer) lays(ctx context.Context) (func(string) bool, func(string) bool
 			held[name] = true
 		}
 	}
-	records := p.w.records()
+	records, _ := worldReader{w: p.w}.Records(ctx)
 	return func(m string) bool { return held[m] }, func(n string) bool { _, ok := records[n]; return ok }
 }
 

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/seat_tools_test.go

@@ -127,8 +127,7 @@ func TestTheSeatsVerbs(t *testing.T) {
 		}
 	}
 	for _, stream := range raw0.Streams {
-		// The views family is no seat's stream: the readers of the assigner's states follow it (ADR 0615 §5).
-		if stream.Name != viewsStream && !reads["stream "+stream.Name] {
+		if !reads["stream "+stream.Name] {
 			t.Errorf("no verb reads the seat's stream %s", stream.Name)
 		}
 	}
@@ -368,16 +367,9 @@ func TestTheSeatsVerbs(t *testing.T) {
 func wantsVerbs(t *testing.T) {
 	fpOld, fpNew := delivery.SourcePrefix2+strings.Repeat("1", 64), delivery.SourcePrefix2+strings.Repeat("2", 64)
 	st := memStore{}
-	for _, state := range []string{modulesState, manifestsState, policiesState, haveState, putsState, "findings", delivery.ComposedRead} {
+	for _, state := range []string{modulesState, manifestsState, policiesState, haveState, putsState, "findings"} {
 		st[state] = &memKV{values: map[string][]byte{}}
 	}
-	// ADR 0593 §6, §8: what each node published, every node's bucket as one state: anchor's own composition and its web at
-	// a fingerprint, and laptop's web refused there.
-	webKey, _ := delivery.ComposedKey("anchor", "web", fpNew)
-	refusedKey, _ := delivery.ComposedKey("laptop", "web", fpNew)
-	st[delivery.ComposedRead].values["anchor.node"], _ = delivery.EncodeComposed(delivery.Composed{Node: "anchor"})
-	st[delivery.ComposedRead].values[webKey], _ = delivery.EncodeComposed(delivery.Composed{Node: "anchor", Module: "web", FP: fpNew})
-	st[delivery.ComposedRead].values[refusedKey], _ = delivery.EncodeComposed(delivery.Composed{Node: "laptop", Module: "web", FP: fpNew, Refused: "a required value is unset"})
 	manifest := func(name, extra string) {
 		raw := `{"module":"` + name + `","version":"1"` + extra + `}`
 		digest := delivery.ManifestDigest([]byte(raw))
@@ -386,7 +378,7 @@ func wantsVerbs(t *testing.T) {
 	}
 	manifest("web", "")
 	manifest("photos", `,"upgrade":{"policy":"record","why":"a person checks the albums"}`)
-	manifest("nats", `,"provides":[{"name":"mesh-bus","scope":"mesh"}],"upgrade":{"policy":"record","why":"its streams"}`)
+	manifest("nats", `,"provides":[{"name":"mesh-bus","scope":"mesh"}]`)
 	for node, fp := range map[string]string{"anchor": fpOld, "laptop": fpNew} {
 		st[haveState].values[node+".nats"], _ = delivery.EncodeHave(delivery.Have{FP: fp, Phase: delivery.PhaseRunning, Health: delivery.HealthOK})
 	}
@@ -407,7 +399,7 @@ func wantsVerbs(t *testing.T) {
 	if p := policyOf("photos"); p.Policy != catalogue.PolicyRecord || p.From != catalogue.FromModule {
 		t.Errorf("photos = %+v", p)
 	}
-	if p := policyOf("nats"); p.Policy != catalogue.PolicyRecord || p.From != catalogue.FromModule { // the policy its manifest says (issue 774)
+	if p := policyOf("nats"); p.Policy != catalogue.PolicyRecord || p.From != catalogue.FromBus {
 		t.Errorf("nats = %+v", p)
 	}
 	// compare: each node's own composition is the digest its have names, and the assigner's findings; nothing splits, the
@@ -417,11 +409,6 @@ func wantsVerbs(t *testing.T) {
 		got["composed"].(map[string]string)["anchor"] != "sha256:"+strings.Repeat("c", 64) || len(got["composed"].(map[string]string)) != 1 {
 		t.Errorf("compare = %+v", got)
 	}
-	pub, _ := out.(map[string]any)["published"].(map[string][]publishedRow)
-	if a, l := pub["anchor"], pub["laptop"]; len(a) != 2 || a[0].Module != "node" || a[1].Module != "web" || a[1].FP != fpNew ||
-		!strings.HasPrefix(a[1].Digest, "sha256:") || len(l) != 1 || l[0].Refused != "a required value is unset" || l[0].Digest != "" {
-		t.Errorf("published = %+v (unread %v)", pub, out.(map[string]any)["published-unread"])
-	}
 	// Read by watch (issue 1953 L5f): the same answer, each watched state started once, and no get per key of the
 	// large states (the modules, their manifests, the composed record).
 	watches := map[string]int{}
@@ -472,12 +459,8 @@ func wantsVerbs(t *testing.T) {
 		len(said) != 1 || !strings.HasPrefix(said[0], "policy-changed policy-changed.web.") {
 		t.Errorf("chosen %+v, asked %v, said %v", c, asked, said)
 	}
-	// A person may choose the bus's policy as any module's (ADR 0601 §1: no part treats the module that provides the bus apart).
-	if _, err := w.doUpgrade(map[string]any{"module": "nats", "policy": "roll", "why": "x"}, "op"); err != nil {
-		t.Errorf("a person's policy for the bus was refused: %v", err)
-	}
-	if _, err := w.doUpgrade(map[string]any{"module": "nats", "policy": "default", "why": "back to the module"}, "op"); err != nil {
-		t.Fatal(err)
+	if _, err := w.doUpgrade(map[string]any{"module": "nats", "policy": "roll", "why": "x"}, "op"); err == nil {
+		t.Error("the bus was given a policy")
 	}
 	if _, err := w.doUpgrade(map[string]any{"module": "web", "policy": "roll"}, "op"); err == nil {
 		t.Error("a policy without why was set")

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/tools.go

@@ -14,8 +14,6 @@ import (
 
 	stdio "git.novox.be/novox/mesh-sdk/go"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
-
-	"git.novox.be/novox/mesh-delivery/sdk/enginereads"
 )
 
 // The assigner's tools (novox/hq ADR 0546), served through the tool runner from its bundle: a process never serves (ADR
@@ -23,9 +21,6 @@ import (
 // every step as the event put. They are the module's own tools; the seat mesh-placement's verbs are served beside them
 // (seat_tools.go, ADR 0567 §10).
 
-// engineReadsTool lists what each node's engine reads, as the assigner uses it, and asks one node's engine again.
-const engineReadsTool = "assigner_engine_reads"
-
 // putsState is the assigner's state of puts, as the runtime names a module's own state.
 const putsState = "puts"
 
@@ -363,9 +358,6 @@ func serveTools() error {
 	})
 	wants.watched = stdio.NewWatchedStates() // the large states read whole from one watched copy (ADR 0580 clause 3)
 	tools = append(tools, wants.tools()...)
-	tools = append(tools, viewTools(os.Getenv, keptSource, time.Now)...)
-	// What each node's engine reads, as the assigner uses it (ADR 0618 §3): its own state engine-reads, asked again through it.
-	tools = append(tools, enginereads.Tool(engineReadsTool, "the assigner", enginereads.KeptState(stdio.State(engineReadsState)), false, time.Now))
 	return stdio.Serve("", tools)
 }
 

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/verbs.go

@@ -1,128 +0,0 @@
-package main
-
-import (
-	"context"
-	"slices"
-
-	"git.novox.be/novox/mesh-sdk/go/catalogue"
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-
-	"git.novox.be/novox/mesh-delivery/sdk/graph"
-
-	"mesh-delivery-assigner/internal/assign"
-)
-
-// The verb edges a want waits on (novox/hq ADR 0614 §2, §3): the module graph the indexer writes names what each module
-// invokes and serves and which of its verb edges it leaves out on a cycle (one place decides the cycle); a want waits for
-// each kept edge until a build serving its verb runs healthy, read from the haves, the builder's builds and the indexer's
-// manifests, as a provider is counted (ADR 0603 §5).
-
-// moduleGraph is the module graph as the indexer's first view and views family last said it (ADR 0631); a key that
-// does not decode is left out, so its module waits on no verb.
-func (p *passer) moduleGraph() graph.Graph {
-	g := graph.Graph{}
-	for key, raw := range p.w.read(graph.Bucket) {
-		module, err := graph.ParseKey(key)
-		if err != nil {
-			continue
-		}
-		if n, err := graph.Decode(raw); err == nil {
-			g[module] = n
-		}
-	}
-	return g
-}
-
-// keptInvokes are the verbs of module the graph keeps as edges: each it invokes and does not leave out, that a module
-// other than itself serves. A verb no module of the graph serves is no edge, so it holds nothing; nil when the graph holds
-// no node of module.
-func keptInvokes(g graph.Graph, module string) []string {
-	n, ok := g[module]
-	if !ok {
-		return nil
-	}
-	var out []string
-	for _, v := range n.Invokes {
-		if slices.Contains(n.LeftOut, v) {
-			continue
-		}
-		if slices.ContainsFunc(g.Servers(v), func(s string) bool { return s != module }) {
-			out = append(out, v)
-		}
-	}
-	return out
-}
-
-// served is, for this pass, whether a build serving a verb runs healthy on some node (graph.Served): every running healthy
-// have's build (the builder's builds key of its module and fingerprint) names its manifest, and the verbs that manifest
-// serves are served. A healthy build whose manifest cannot be read counts what the graph says its module serves, said in
-// the log, so a build read late never holds its callers for good; nil when the graph holds nothing, and no want waits on
-// a verb.
-func (p *passer) served(ctx context.Context, get getter, g graph.Graph, n assign.Nodes) func(string) bool {
-	if len(g) == 0 {
-		return nil
-	}
-	served, unread := graph.Served(n.Haves, func(module, fp string) ([]string, bool) { return p.servesOf(ctx, get, module, fp) },
-		func(module string) []string { return g[module].Serves })
-	if len(unread) > 0 {
-		p.logf("the manifest of the running build of %v cannot be read, so what the module graph says they serve is counted as served", unread)
-	}
-	return served
-}
-
-// offering is, for this pass, whether a build whose manifest offers a provision runs healthy on a node present (ADR 0603
-// §5, ADR 0614 §5): every running healthy have on an online node, its build's manifest read as servesOf reads it. A
-// healthy build whose manifest cannot be read counts what its module's trunk manifest offers, so a build read late never
-// holds a consumer for good.
-func (p *passer) offering(ctx context.Context, get getter, trunk map[string]catalogue.Manifest, n assign.Nodes) func(string) bool {
-	offered := map[string]bool{}
-	for node, haves := range n.Haves {
-		if !n.Online[node] {
-			continue
-		}
-		for module, h := range haves {
-			if h.Phase != delivery.PhaseRunning || h.Health != delivery.HealthOK {
-				continue
-			}
-			m, ok := p.manifestOf(ctx, get, module, h.FP)
-			if !ok {
-				m = trunk[module]
-			}
-			for _, o := range m.Offers() {
-				offered[o] = true
-			}
-		}
-	}
-	return func(provision string) bool { return offered[provision] }
-}
-
-// servesOf are the verbs the manifest of module's build at fp serves (graph.ServesOf), and whether it could be read.
-func (p *passer) servesOf(ctx context.Context, get getter, module, fp string) ([]string, bool) {
-	m, ok := p.manifestOf(ctx, get, module, fp)
-	if !ok {
-		return nil, false
-	}
-	return graph.ServesOf(m), true
-}
-
-// manifestOf is the manifest of module's build at fp (the builder's build names its digest in the indexer's manifests),
-// and whether it could be read.
-func (p *passer) manifestOf(ctx context.Context, get getter, module, fp string) (catalogue.Manifest, bool) {
-	key, err := delivery.BuilderBuildKey(module, fp)
-	if err != nil {
-		return catalogue.Manifest{}, false
-	}
-	raw := p.w.value(delivery.BuilderBuildsBucket, key)
-	if raw == nil {
-		return catalogue.Manifest{}, false
-	}
-	b, err := delivery.DecodeBuilderBuild(raw)
-	if err != nil || b.Manifest == "" {
-		return catalogue.Manifest{}, false
-	}
-	got := p.w.manifest(ctx, get, b.Manifest)
-	if got.err != "" {
-		return catalogue.Manifest{}, false
-	}
-	return got.manifest, true
-}

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/views.go

@@ -1,235 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"slices"
-	"time"
-
-	"github.com/nats-io/nats.go/jetstream"
-
-	stdio "git.novox.be/novox/mesh-sdk/go"
-	"git.novox.be/novox/mesh-sdk/go/catalogue"
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-	"git.novox.be/novox/mesh-sdk/go/handacts"
-	"git.novox.be/novox/mesh-sdk/go/health"
-	"git.novox.be/novox/mesh-sdk/go/process"
-
-	"git.novox.be/novox/mesh-sdk/go/views"
-
-	"git.novox.be/novox/mesh-delivery/sdk/graph"
-	"git.novox.be/novox/mesh-delivery/sdk/heard"
-
-	"mesh-delivery-assigner/internal/assign"
-)
-
-// viewsStream is the assigner's views family on its old streams section, beside placement (ADR 0619 §2, ADR 0615 §5),
-// as its manifest's `streams` names it; indexerViewsStream is the indexer's, as the indexer's manifest names it.
-const (
-	viewsStream        = "assigner-views"
-	indexerViewsStream = "indexer-views"
-)
-
-// marksBucket is the assigner's state of what its views family said each state up to.
-var marksBucket = delivery.AssignerModule + "_" + views.MarksState
-
-// viewedTool is one tool over one state of the assigner's.
-type viewedTool struct{ tool, state, words string }
-
-// firstViewTools are the assigner's first-view tools (ADR 0621 §1): each answers only its callers list
-// (views.CallersEnv), which the manifest writes.
-var firstViewTools = []viewedTool{
-	{"placement", delivery.PlacementState, "where each module is placed: the seat mesh-placement's placement, by module."},
-	{"seat-holders", delivery.SeatHoldersState, "who holds which seat on which node."},
-	{"wants", "wants", "what each node should run: want.<node>.<module>, its fingerprint and the rule that gave it."},
-}
-
-// readTools are the assigner's ordinary read tools, one per state its readers read (design 25 § 12.2).
-var readTools = []viewedTool{
-	{"assigner_read_placement", delivery.PlacementState, "where each module is placed, by module."},
-	{"assigner_read_seat_holders", delivery.SeatHoldersState, "who holds which seat on which node."},
-	{"assigner_read_wants", "wants", "what each node should run: want.<node>.<module>."},
-	{"assigner_read_findings", health.FindingsState, "the assigner's findings, which the condition keeper raises and clears."},
-	{"assigner_read_asks", "asks", "the asks the assigner put to a person, and their answers."},
-	{"assigner_read_differences", "differences", "every difference between a want and what a node runs."},
-}
-
-// viewedStates are the states the views family says, each by its bucket: the six its readers read.
-var viewedStates = map[string]string{
-	delivery.PlacementState:   delivery.PlacementBucket,
-	delivery.SeatHoldersState: delivery.SeatHoldersBucket,
-	"wants":                   delivery.AssignerWantsBucket,
-	health.FindingsState:      assign.FindingsBucket,
-	"asks":                    delivery.AssignerAsksBucket,
-	"differences":             delivery.AssignerDifferencesBucket,
-}
-
-// viewTools are the assigner's first-view and read tools, reading only its own states, so they answer as soon as its
-// runtime of its own is connected (ADR 0621 §3).
-func viewTools(getenv func(string) string, state func(string) views.Source, now func() time.Time) []stdio.Tool {
-	marks := state(views.MarksState)
-	var out []stdio.Tool
-	for _, t := range firstViewTools {
-		out = append(out, views.FirstViewTool(delivery.AssignerModule, t.tool, t.state, t.words, views.ParseCallers(getenv(views.CallersEnv(t.tool))), state(t.state), marks, now))
-	}
-	for _, t := range readTools {
-		out = append(out, views.ReadTool(delivery.AssignerModule, t.tool, t.state, t.words, state(t.state), marks, now))
-	}
-	// Its own first views, of the indexer's manifests, modules and graph (DLV-F3r, ADR 0631 §2): read, and asked again by hand.
-	return append(out, views.StatusTools(delivery.AssignerModule, "assigner_first_views", "assigner_first_view_again", stdio.State(views.StatusState), handacts.Recorder{Ask: stdio.Ask}, now)...)
-}
-
-func keptSource(name string) views.Source { return views.KeptSource{State: stdio.State(name)} }
-
-// startViews says each change of the assigner's viewed states on its views family, once its marks state is bound,
-// each state as soon as its bucket is (kvs, or bound once it appears). A watch that ends is sent on errs.
-func startViews(ctx context.Context, js jetstream.JetStream, nc process.Subscriber, account process.Account, kvs buckets, findings assign.Findings, errs chan<- error, logf func(string, ...any)) {
-	tooLarge := func(state, key string, size int) {
-		if findings.Put == nil {
-			return
-		}
-		k, v, err := views.TooLargeFinding(delivery.AssignerModule, state, key, size, time.Now())
-		if err == nil {
-			err = findings.Put(k, v)
-		}
-		if err != nil {
-			logf("views: the finding of %s.%s too large is not written: %v", state, key, err)
-		}
-	}
-	process.AwaitBucket(ctx, js, nc, marksBucket, "no change is said on the views family, so every reader waits on its first view", logf).Ready(func(mk jetstream.KeyValue) {
-		em := viewsEmitter(js, account, mk, findings, tooLarge, logf)
-		for _, state := range []string{"asks", "differences", health.FindingsState, delivery.PlacementState, delivery.SeatHoldersState, "wants"} {
-			state := state
-			start := func(kv jetstream.KeyValue) {
-				if err := em.Start(ctx, state, kv, errs); err != nil {
-					logf("%v: its readers ask its first view at each change until the assigner starts again", err)
-				}
-			}
-			if kv := kvs[viewedStates[state]]; kv != nil {
-				start(kv)
-				continue
-			}
-			process.AwaitBucket(ctx, js, nc, viewedStates[state], "its changes are not said on the views family", logf).Ready(start)
-		}
-	})
-}
-
-// viewsEmitter is the assigner's emitter of its views family: a change not said past views.Bound is its finding
-// view-unsaid, in its findings (review round 2); with no findings state it is said in the log only.
-func viewsEmitter(js jetstream.JetStream, account process.Account, mk jetstream.KeyValue, findings assign.Findings, tooLarge func(string, string, int), logf func(string, ...any)) views.Emitter {
-	em := views.Emitter{Owner: delivery.AssignerModule, Subject: account.StreamSubject, Publish: views.JetStreamPublish(js), Marks: mk, TooLarge: tooLarge, Logf: logf}
-	if findings.Put != nil && findings.Delete != nil {
-		em.Findings = assignerFindings{findings}
-	}
-	return em
-}
-
-// assignerFindings is the assigner's findings as views.Emitter's Findings.
-type assignerFindings struct{ f assign.Findings }
-
-func (a assignerFindings) Put(key string, value []byte) error { return a.f.Put(key, value) }
-func (a assignerFindings) Delete(key string) error            { return a.f.Delete(key) }
-
-// firstViewsBucket is the assigner's own state of its first views (views.StatusState).
-var firstViewsBucket = delivery.AssignerModule + "_" + views.StatusState
-
-// indexerViews are the assigner's first views of the indexer's manifests, modules and module graph (ADR 0615 §1,
-// ADR 0621 §2, ADR 0631; DLV-F2r): asked at the start through the indexer's tools, then followed on indexer-views, asking once more on a gap;
-// past the bound its finding names the indexer and the tool, cleared by the answer.
-type indexerViews struct {
-	js       jetstream.JetStream
-	account  process.Account
-	call     func(string, any) (json.RawMessage, error)
-	findings assign.Findings
-	status   *process.AwaitedBucket
-	logf     func(string, ...any)
-}
-
-// indexerFirstViews are the indexer's states the assigner takes by first view and the views family, each by the name of
-// the indexer's bucket the world keeps it under: manifests and modules (ADR 0621 §2), and the module graph, whose verb
-// edges a want waits on (ADR 0614 §2, §3; ADR 0631 §1).
-var indexerFirstViews = map[string]string{"manifests": delivery.ManifestsBucket, "modules": delivery.ModulesBucket, graph.State: graph.Bucket}
-
-// firstViewBound and firstViewWait are each first view's bound before its condition is raised, and its first wait
-// between two failed asks; zero is the views package's (views.Bound, two minutes, ADR 0615 §6; and a first wait of five
-// seconds). A test shortens them.
-var firstViewBound, firstViewWait time.Duration
-
-// start asks the three first views, each answer taken into w under the indexer's bucket names and settled once (a pass waits
-// for it), and hears the views family; it answers how many settles to wait for.
-func (iv *indexerViews) start(ctx context.Context, w *world, wake func(), settled chan<- struct{}) int {
-	finding := func(s views.Status, raised bool) {
-		if iv.findings.Put == nil {
-			return
-		}
-		key, value, err := views.UnansweredFinding(delivery.AssignerModule, s, time.Now())
-		if err == nil && raised {
-			err = iv.findings.Put(key, value)
-		} else if err == nil {
-			err = iv.findings.Delete(key)
-		}
-		if err != nil {
-			iv.logf("views: the finding of the first view %s is not written: %v", s.Tool, err)
-		}
-	}
-	followers := map[string]*views.Follower{}
-	var all []*views.Follower
-	for state, bucket := range indexerFirstViews {
-		bucket := bucket
-		tool := delivery.IndexerModule + "." + state
-		f := &views.Follower{Owner: delivery.IndexerModule, Tool: tool, State: state, Ask: views.AskVia(iv.call, tool), Logf: iv.logf,
-			Bound: firstViewBound, Wait: firstViewWait,
-			Raise: func(s views.Status) { finding(s, true) }, Clear: func(s views.Status) { finding(s, false) },
-			Changed: func(key string, value json.RawMessage, deleted bool, at time.Time) {
-				if deleted {
-					value = nil
-				}
-				w.putEntry(bucket, key, value, 0, at)
-				wake()
-			}}
-		followers[state] = f
-		all = append(all, f)
-		go func() {
-			if f.Start(ctx) == nil {
-				settled <- struct{}{}
-			}
-		}()
-	}
-	if iv.status != nil {
-		iv.status.Ready(func(kv jetstream.KeyValue) {
-			for _, f := range all {
-				f.Said = views.KeepStatus(ctx, kv, iv.logf)
-			}
-			if err := views.HearAgain(ctx, kv, all, iv.logf); err != nil {
-				iv.logf("views: assigner_first_view_again is not heard (%v) until the assigner starts again", err)
-			}
-		})
-	}
-	// Not heard, the indexer's views family is the finding family-not-heard until it binds (ADR 0615 §5).
-	stream := catalogue.StreamBusName(indexerViewsStream)
-	_ = notHeardWriter(iv.findings, iv.logf).Bind(stream, "the indexer's manifests, modules and graph are the first views' alone until the assigner starts again", func() error {
-		cons, err := iv.account.EventConsumer(ctx, iv.js, stream)
-		if err != nil {
-			return fmt.Errorf("the consumer %s on %s does not exist yet: %w", iv.account.EventConsumerName(), stream, err)
-		}
-		_, err = process.HearEvents(cons, views.Hear(ctx, followers, iv.logf), iv.logf)
-		return err
-	})
-	return len(all)
-}
-
-// notHeardWriter writes the assigner's finding of a family it does not hear into its findings (heard.Writer); with no
-// findings state it is said in the log alone.
-func notHeardWriter(findings assign.Findings, logf func(string, ...any)) heard.Writer {
-	w := heard.Writer{Observer: delivery.AssignerModule, Logf: logf, Put: findings.Put}
-	if findings.Delete != nil {
-		w.Delete = func(key string) error {
-			if keys, err := findings.Keys(); err == nil && !slices.Contains(keys, key) {
-				return nil // none stands
-			}
-			return findings.Delete(key)
-		}
-	}
-	return w
-}

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/wants_tools.go

@@ -20,7 +20,7 @@ import (
 // The seat mesh-wants' verbs (novox/hq ADR 0565 §7, §8, §9, §15; issue 1953 D4-D6), served through the tool runner beside the
 // put tools and mesh-placement's verbs. `upgrade` reads and sets a person's upgrade policy, kept in the state `policies`
 // (each set recorded as a hand act and said as policy-changed), and with compare lists the digest of the composition each node's
-// own have names beside every composition each node published (ADR 0593 §8, composed.go); `bus` says what a bus upgrade would do. The assigner's process reads
+// own have names (the controller writes no policy any more, so no module's policy differs); `bus` says what a bus upgrade would do. The assigner's process reads
 // `policies` when it judges a move and writes the finding policy-split while a split stands.
 
 // The states the verbs read, as the runtime names them.
@@ -158,12 +158,6 @@ func (s *wantsTools) doUpgrade(args map[string]any, by string) (any, error) {
 			}
 		}
 		out := map[string]any{"composed": composed}
-		// And what every node published (ADR 0593 §8), read only to compare.
-		if values, err := s.values(delivery.ComposedRead); err != nil {
-			out["published-unread"] = err.Error()
-		} else {
-			out["published"] = published(values)
-		}
 		// The assigner's findings, its said conditions as the condition keeper reads them (§15).
 		if found, err := s.values(health.FindingsState); err != nil {
 			out["findings-unread"] = err.Error()
@@ -197,14 +191,18 @@ func (s *wantsTools) doUpgrade(args map[string]any, by string) (any, error) {
 }
 
 // setPolicy writes a person's choice of a module's policy, or deletes it for default, records the act in the hand-act log
-// and says policy-changed. The bus's choice is a person's as any module's (ADR 0601 §1).
+// and says policy-changed. The bus is never rolled: a choice for it is refused.
 func (s *wantsTools) setPolicy(module, policy, why, by string, manifests map[string]catalogue.Manifest) (any, error) {
 	if module == "" {
 		return nil, errors.New("a policy is set for one module: name it")
 	}
-	if _, ok := manifests[module]; !ok {
+	m, ok := manifests[module]
+	if !ok {
 		return nil, fmt.Errorf("the indexer holds no manifest of %s", module)
 	}
+	if catalogue.ProvidesBus(m) {
+		return nil, fmt.Errorf("%s is the bus, which is never rolled whoever says so (novox/hq ADR 0236): its step is the put on the operator's warrant", module)
+	}
 	if why == "" {
 		return nil, errors.New("a person's policy says why")
 	}

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/world.go

@@ -3,15 +3,20 @@ package main
 import (
 	"context"
 	"errors"
-	"maps"
+	"fmt"
 	"slices"
 	"sort"
+	"strings"
 	"sync"
 	"time"
 
 	"github.com/nats-io/nats.go/jetstream"
 
+	stdio "git.novox.be/novox/mesh-sdk/go"
+	"git.novox.be/novox/mesh-sdk/go/buscompose"
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
+	"git.novox.be/novox/mesh-sdk/go/compose"
+	"git.novox.be/novox/mesh-sdk/go/compose/frombus"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 
 	"mesh-delivery-assigner/internal/assign"
@@ -38,9 +43,6 @@ type world struct {
 	// placement is the seat's state placement assembled node by node from its keys in either form (mesh-sdk
 	// delivery.PlacementKeys; research 072 row 37): the one reader of its keys in the assigner.
 	placement *delivery.PlacementKeys
-	// sourceGroups is, by revision of the gate's source.main, the release (group) that moved it, from every revision its
-	// history keeps (watched with history): a build's source revision names the release that carries it (ADR 0601 §1).
-	sourceGroups map[uint64]string
 }
 
 // entryMeta is a value's revision in its bucket and when it was written.
@@ -58,8 +60,7 @@ type parsed struct {
 
 func newWorld() *world {
 	return &world{values: map[string]map[string][]byte{}, manifests: map[string]parsed{}, healthy: map[string][]string{}, changes: map[string]uint64{},
-		meta: map[string]entryMeta{}, trunkBuilt: map[string]delivery.BuildLogEntry{}, placement: delivery.NewPlacementKeys(),
-		sourceGroups: map[uint64]string{}}
+		meta: map[string]entryMeta{}, trunkBuilt: map[string]delivery.BuildLogEntry{}, placement: delivery.NewPlacementKeys()}
 }
 
 // putEntry is put, keeping the value's revision and the time it was written.
@@ -75,44 +76,6 @@ func (w *world) putEntry(bucket, key string, value []byte, revision uint64, at t
 	if bucket == delivery.PlacementBucket {
 		_, _ = w.placement.Put(key, value, revision, false) // put took it already; this is its revision
 	}
-	if bucket == delivery.SourceBucket && key == delivery.SourceMainKey {
-		if s, err := delivery.DecodeSource(value); err == nil && s.Group != "" {
-			w.sourceGroups[revision] = s.Group
-		}
-	}
-}
-
-// release is the release whose Approve carries module's build fp (ADR 0601 §1), and whether one does: the trunk's value of
-// the module names fp, the source revision at which that fingerprint last changed (FPSrc, never the Src of its last merge,
-// which a recompute with no merge keeps) names the release that moved it, and the gate's merge of that release, which it
-// writes on the operator's Approve, holds the module's own trunk merge among its merged pull requests. Any of them
-// unknown: none, and the move is asked of a person.
-func (w *world) release(module, fp string) (string, bool) {
-	t, ok := w.trunk()[module]
-	if !ok || fp == "" || t.FP2 != fp || t.FPSrc == 0 || t.Commit == "" {
-		return "", false
-	}
-	w.mu.Lock()
-	group := w.sourceGroups[t.FPSrc]
-	w.mu.Unlock()
-	key, err := delivery.MergesKey(group)
-	if group == "" || err != nil {
-		return "", false
-	}
-	raw := w.value(delivery.MergesBucket, key)
-	if raw == nil {
-		return "", false
-	}
-	merge, err := delivery.DecodeMerge(raw)
-	if err != nil {
-		return "", false
-	}
-	for _, pull := range merge.Pulls {
-		if pull.State == delivery.MergeMerged && pull.Commit == t.Commit && delivery.SameRepository(pull.Repository, t.Repository) {
-			return group, true
-		}
-	}
-	return "", false
 }
 
 // metaOf is the revision and time of the value a bucket holds at key, as the watch said them.
@@ -198,19 +161,6 @@ func kvGetter(kv jetstream.KeyValue) getter {
 	}
 }
 
-// getter reads a key of a bucket the world holds: errNotThere where it holds none.
-func (w *world) getter(bucket string) getter {
-	return func(_ context.Context, key string) ([]byte, error) {
-		w.mu.Lock()
-		defer w.mu.Unlock()
-		v, ok := w.values[bucket][key]
-		if !ok {
-			return nil, errNotThere
-		}
-		return v, nil
-	}
-}
-
 // manifest reads the manifest of a digest from the indexer's bucket once and keeps it: a digest's manifest never changes.
 func (w *world) manifest(ctx context.Context, get getter, digest string) parsed {
 	w.mu.Lock()
@@ -299,11 +249,63 @@ func (w *world) trunk() map[string]delivery.Module {
 	return out
 }
 
-// records is each node's record in its own have key (`<node>.node`): the nodes a placement proposal is answered by,
-// with those placement names (ADR 0593 §8).
-func (w *world) records() map[string]delivery.NodeRecord {
+// mesh is the mesh as the trunk holds it, for the composition check.
+func (w *world) mesh(ctx context.Context, manifests getter) assign.Mesh {
+	m := assign.Mesh{Manifests: map[string]catalogue.Manifest{}, Unreadable: map[string]string{}, Digests: map[string]string{}}
+	m.Assigned = w.assigned()
+	for name, mod := range w.trunk() {
+		if mod.Manifest == "" {
+			continue
+		}
+		m.Digests[name] = mod.Manifest
+		// The indexer's verdict on it, carried in its value (ADR 0578 §3, §5): a refused module is held and named as one
+		// that cannot be read, and its verdict goes into the composer's input.
+		if v := mod.VerdictOf(name); v != nil {
+			if refused, _ := delivery.TakeManifestVerdict(v); refused {
+				if m.Verdicts == nil {
+					m.Verdicts = map[string]delivery.ManifestVerdict{}
+				}
+				m.Verdicts[name] = *v
+				m.Unreadable[name] = v.Why()
+				continue
+			}
+		}
+		p := w.manifest(ctx, manifests, mod.Manifest)
+		if p.err != "" {
+			m.Unreadable[name] = p.err
+			continue
+		}
+		m.Manifests[name] = p.manifest
+	}
+	// Once the catalogue places the nodes, the check composes over the input they compose from (ADR 0547 §2, ADR 0549
+	// §3): one composer's input for the check and the nodes. An input that cannot be read is said, and the nodes and their
+	// assignments alone are composed, as before any placement.
+	if _, seeded := w.placed(); seeded {
+		in, err := frombus.Input(ctx, worldReader{w: w, manifests: manifests}, frombus.Mesh{}, frombus.Scope{Every: true})
+		if err != nil {
+			m.InputUnread = err.Error()
+		} else {
+			m.Input = &in
+		}
+	}
+	return m
+}
+
+// worldReader is what the assigner watched as frombus reads the bus: the seat's placement, the indexer's modules, each node's
+// record in its own have key, the manifests by digest; the check reads no config value, own secret or credential (the
+// composition it asks resolves, and stands in for what it does not carry).
+type worldReader struct {
+	w         *world
+	manifests getter
+}
+
+func (r worldReader) Placements(context.Context) (map[string]delivery.Placement, error) {
+	return r.w.placements(), nil
+}
+
+func (r worldReader) Records(context.Context) (map[string]delivery.NodeRecord, error) {
 	out := map[string]delivery.NodeRecord{}
-	for key, value := range w.read(delivery.HaveBucket) {
+	for key, value := range r.w.read(delivery.HaveBucket) {
 		node, _, isNode, err := delivery.ParseHaveKey(key)
 		if err != nil || !isNode {
 			continue
@@ -312,7 +314,136 @@ func (w *world) records() map[string]delivery.NodeRecord {
 			out[node] = *h.Record
 		}
 	}
-	return out
+	return out, nil
+}
+
+func (r worldReader) Modules(context.Context) (map[string]delivery.Module, error) {
+	return r.w.trunk(), nil
+}
+
+func (r worldReader) Manifest(ctx context.Context, digest string) ([]byte, error) {
+	key, err := delivery.ManifestsKey(digest)
+	if err != nil {
+		return nil, err
+	}
+	raw, err := r.manifests(ctx, key)
+	if err != nil {
+		return nil, err
+	}
+	m, err := delivery.DecodeManifest(raw)
+	if err != nil {
+		return nil, err
+	}
+	return []byte(m.JSON), nil
+}
+
+// Values is one module's config values on one node as mesh-config resolved them, each a value its source lays
+// (catalogue.LaidValue): the holder composes every node a proposal touches with them (ADR 0567 §9).
+func (r worldReader) Values(_ context.Context, node, module string) (map[string]any, error) {
+	var out map[string]any
+	prefix := node + "." + module + "."
+	for key, raw := range r.w.read(buscompose.ResolvedBucket) {
+		name, ok := strings.CutPrefix(key, prefix)
+		if !ok || strings.Contains(name, ".") {
+			continue
+		}
+		if v, laid := catalogue.LaidValue(raw); laid {
+			if out == nil {
+				out = map[string]any{}
+			}
+			out[name] = v
+		}
+	}
+	return out, nil
+}
+
+func (worldReader) OwnSecrets(context.Context, string) ([]compose.OwnSecretRow, error) {
+	return nil, nil
+}
+
+func (worldReader) Credentials(context.Context, string, []compose.CredentialKey, []compose.CredentialKey) ([]compose.Credential, []compose.Issued, error) {
+	return nil, nil, nil
+}
+
+// Build and Archive are read only for a node composing itself (frombus.Scope without Every): the check of every node
+// composes from the manifests the indexer read, and reads no build and no archive.
+func (worldReader) Build(context.Context, string, string) (*delivery.BuilderBuild, error) {
+	return nil, nil
+}
+
+func (worldReader) Archive(_ context.Context, url, _ string) ([]byte, error) {
+	return nil, fmt.Errorf("the composition check reads no archive (%s)", url)
+}
+
+func (r worldReader) Served(ctx context.Context, node, module string, keys []string) (map[string]any, error) {
+	all, err := r.Values(ctx, node, module)
+	var out map[string]any
+	for _, k := range keys {
+		if v, ok := all[k]; ok {
+			if out == nil {
+				out = map[string]any{}
+			}
+			out[k] = v
+		}
+	}
+	return out, err
+}
+
+// change is a candidate's change for the composition check, or why the composition waits for it.
+func (w *world) change(ctx context.Context, manifests getter, c delivery.Candidate, trunk map[string]delivery.Module) (assign.Change, string) {
+	ch := assign.Change{Group: c.Group, Heads: c.HeadsHash, Manifests: map[string]catalogue.Manifest{}, Unreadable: map[string]string{},
+		Twice: map[string][]string{}, Digests: map[string]string{}, Members: map[string]string{}}
+	heads := map[string]string{}
+	for _, p := range c.Pulls {
+		heads[fmt.Sprintf("%s#%d", p.Repository, p.Number)] = p.Head.Head
+	}
+	ch.Held = assign.HeldOf(w.read(keptBucket), heads)
+	definedIn := map[string]map[string]bool{}
+	for _, p := range c.Pulls {
+		if p.Repository == assign.SDKRepository {
+			ch.SDKHead = p.Head.Head
+		}
+		ch.Members[p.Repository] = p.Head.Head
+		for _, name := range p.Modules {
+			fp, ok := p.Fps[name]
+			if !ok || fp.Manifest == "" {
+				if ok && fp.None2 == noModuleWords {
+					ch.Removed = append(ch.Removed, name)
+					continue
+				}
+				return ch, fmt.Sprintf("the indexer holds no manifest of %s for %s#%d yet", name, p.Repository, p.Number)
+			}
+			if fp.FP2 != "" && fp.FP2 != trunk[name].FP2 {
+				ch.Rebuilt++
+			}
+			got := w.manifest(ctx, manifests, fp.Manifest)
+			if strings.HasPrefix(got.err, "the indexer holds no manifest") {
+				return ch, got.err
+			}
+			ch.Digests[name] = fp.Manifest
+			if got.err != "" {
+				ch.Unreadable[name] = got.err
+				continue
+			}
+			ch.Manifests[got.module] = got.manifest
+			if definedIn[got.module] == nil {
+				definedIn[got.module] = map[string]bool{}
+			}
+			definedIn[got.module][p.Repository] = true
+			if t, ok := trunk[got.module]; ok && t.Repository != "" && t.Repository != p.Repository {
+				definedIn[got.module][t.Repository] = true
+			}
+		}
+	}
+	for name, repos := range definedIn {
+		if len(repos) > 1 {
+			for r := range repos {
+				ch.Twice[name] = append(ch.Twice[name], r)
+			}
+			sort.Strings(ch.Twice[name])
+		}
+	}
+	return ch, ""
 }
 
 // online is, by node, whether the watchman holds the node online.
@@ -352,8 +483,7 @@ func (w *world) wantsOf() map[string]map[string]delivery.Want {
 
 // nodes is what the six rules read of the nodes: presence, haves, and every provision's providers with their nodes.
 func (w *world) nodes(manifests map[string]catalogue.Manifest, assigned map[string][]string) assign.Nodes {
-	n := assign.Nodes{Online: map[string]bool{}, Haves: map[string]map[string]delivery.Have{}, Providers: map[string]map[string][]string{},
-		Reads: map[string][]string{}}
+	n := assign.Nodes{Online: map[string]bool{}, Haves: map[string]map[string]delivery.Have{}, Providers: map[string]map[string][]string{}}
 	for key, value := range w.read(delivery.PresenceBucket) {
 		node, _, _, err := delivery.ParsePresenceKey(key)
 		if err != nil || node == "" {
@@ -365,14 +495,7 @@ func (w *world) nodes(manifests map[string]catalogue.Manifest, assigned map[stri
 	}
 	for key, value := range w.read(delivery.HaveBucket) {
 		node, module, isNode, err := delivery.ParseHaveKey(key)
-		if err != nil {
-			continue
-		}
-		if isNode {
-			// What the node's engine reads (ADR 0614 §4); a record that states none is read as the baseline.
-			if h, err := delivery.DecodeHaveNode(value); err == nil && h.Record != nil {
-				n.Reads[node] = h.Record.ManifestReads
-			}
+		if err != nil || isNode {
 			continue
 		}
 		if h, err := delivery.DecodeHave(value); err == nil {
@@ -434,42 +557,6 @@ func (w *world) built(module, fp string) bool {
 	return err == nil && b.State == delivery.BuildDone
 }
 
-// buildNeeds are the reference forms the builder's done build of module at fp is written in (the build key's needs, ADR
-// 0618 §1): nil when it is not done or names none.
-func (w *world) buildNeeds(module, fp string) []string {
-	key, err := delivery.BuilderBuildKey(module, fp)
-	if err != nil {
-		return nil
-	}
-	b, err := delivery.DecodeBuilderBuild(w.value(delivery.BuilderBuildsBucket, key))
-	if err != nil || b.State != delivery.BuildDone {
-		return nil
-	}
-	return b.Needs
-}
-
-// recordReads is what node's record `<node>.node` states its engine reads (ADR 0614 §4), and whether the assigner holds
-// a record of it: the fallback where the engine does not answer the verb manifest-reads (enginereads.FromRecord).
-func (w *world) recordReads(node string) ([]string, bool) {
-	r, ok := w.records()[node]
-	return r.ManifestReads, ok
-}
-
-// knownNodes is every node the assigner hears of: placed, with a record, or with a presence.
-func (w *world) knownNodes() []string {
-	set := map[string]bool{}
-	for node := range w.placedNodes() {
-		set[node] = true
-	}
-	for node := range w.records() {
-		set[node] = true
-	}
-	for node := range w.online() {
-		set[node] = true
-	}
-	return slices.Sorted(maps.Keys(set))
-}
-
 // composed is the composition of module for node: a placed node composes its own, and its composition is the digest its own
 // have names (ADR 0571 §6); an unplaced node has none, so it gets no want (and the pass says so, unplacedFindings). The
 // controller's copy (mesh-controller_composed) is read no more (issue 774).
@@ -507,6 +594,40 @@ func (w *world) changed(bucket, key string) uint64 {
 	return w.changes[bucket+"|"+key]
 }
 
+// logWatch follows the builder's log: handle each entry it keeps, then each new one (process.LogReader.Watch).
+type logWatch func(handle func(stdio.LogEntry) error) error
+
+// putBuilt takes one entry of the builder's log in: a done trunk build's end (no ref) naming a full commit, newer than the
+// module's last, becomes the module's running commit. It answers whether the commit changed.
+func (w *world) putBuilt(raw []byte) bool {
+	e, err := delivery.DecodeBuildLogEntry(raw)
+	if err != nil || e.Event != delivery.BuildEndedEvent || e.Outcome != delivery.BuildDone || e.Ref != "" || len(e.Commit) != 40 {
+		return false
+	}
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	have, ok := w.trunkBuilt[e.Module]
+	if ok && !e.At.After(have.At) {
+		return false
+	}
+	w.trunkBuilt[e.Module] = e
+	return !ok || have.Commit != e.Commit
+}
+
+// runningCommits is the commit of module's newest done trunk build in the builder's log (ADR 0571 clause 1): the commit a
+// reader of the manifests runs at (novox/hq ADR 0482 clause 5, issue 1623); none when the log holds no such build.
+func (w *world) runningCommits(module string) []string {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if e, ok := w.trunkBuilt[module]; ok {
+		return []string{e.Commit}
+	}
+	return nil
+}
+
+// keptBucket is mesh-config's `kept`: the approved held values of open pull requests (ADR 0565 §5).
+var keptBucket = "mesh-config_" + delivery.MeshConfigKeptState
+
 // ownComposed is a placed node's own composition, as the digest its own have names (`<node>.node` of the haves, Composed):
 // what rule 7 reads. A node whose have names none is not composed yet.
 func (w *world) ownComposed(node string) (delivery.ComposedDigest, bool) {

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/world_test.go

@@ -2,12 +2,15 @@ package main
 
 import (
 	"context"
+	"os"
 	"slices"
 	"strings"
 	"testing"
 	"time"
 
 	"git.novox.be/novox/mesh-sdk/go/delivery"
+
+	"mesh-delivery-assigner/internal/assign"
 )
 
 // fakeManifests is the indexer's manifests bucket in memory.
@@ -42,6 +45,76 @@ func pull(repo string, number int, modules map[string]delivery.CandidateModule)
 	return p
 }
 
+// 1297/B3b: a candidate's change reads each module's manifest by its digest, counts the modules rebuilt, takes a
+// module with no manifest in the preview as removed, a mesh-sdk member's head, and a module the trunk holds from
+// another repository as defined twice.
+func TestTheChangeOfACandidate(t *testing.T) {
+	theWorldCountsTheValuesAKeyTakes(t)
+	f := fakeManifests{}
+	web := f.add(t, "web", `{"module":"web","version":"2"}`)
+	mail := f.add(t, "mail", `{"module":"mail","version":"1"}`)
+	trunk := map[string]delivery.Module{"web": {FP2: fp('a'), Repository: "novox/web"}, "mail": {FP2: fp('c'), Repository: "novox/mail"}}
+	c := delivery.Candidate{Group: "g", HeadsHash: "0123456789ab", Pulls: []delivery.CandidatePull{
+		pull("novox/web", 1, map[string]delivery.CandidateModule{"web": {FP2: fp('b'), Manifest: web}, "old": {None2: noModuleWords}}),
+		pull("novox/other", 2, map[string]delivery.CandidateModule{"mail": {FP2: fp('c'), Manifest: mail}}),
+		pull(assign.SDKRepository, 3, nil),
+	}}
+	ch, waits := newWorld().change(context.Background(), f.get, c, trunk)
+	if waits != "" {
+		t.Fatalf("the change waits: %s", waits)
+	}
+	if ch.Manifests["web"].Version != "2" || ch.Rebuilt != 1 || !slices.Equal(ch.Removed, []string{"old"}) || ch.SDKHead != strings.Repeat("3", 40) {
+		t.Errorf("change = %+v", ch)
+	}
+	if !slices.Equal(ch.Twice["mail"], []string{"novox/mail", "novox/other"}) || len(ch.Twice) != 1 {
+		t.Errorf("twice = %v, want mail in novox/mail and novox/other", ch.Twice)
+	}
+}
+
+// 1297/B3b: a candidate whose module has no manifest digest yet, or whose manifest the indexer does not hold yet, waits,
+// saying for what; a manifest that does not decode is the change's, not a wait (one with a field the assigner does not
+// know is decoded with it set aside, novox/hq ADR 0578 §6).
+func TestAChangeWaitsForItsManifests(t *testing.T) {
+	f := fakeManifests{}
+	bad := f.add(t, "web", `{"module":"web","version":"2","requires":"x"}`)
+	for _, c := range []delivery.CandidatePull{
+		pull("novox/web", 1, map[string]delivery.CandidateModule{"web": {None2: "no preview yet"}}),
+		pull("novox/web", 1, map[string]delivery.CandidateModule{"web": {FP2: fp('b'), Manifest: strings.Repeat("9", 64)}}),
+	} {
+		_, waits := newWorld().change(context.Background(), f.get, delivery.Candidate{Group: "g", HeadsHash: "0123456789ab", Pulls: []delivery.CandidatePull{c}}, nil)
+		if waits == "" {
+			t.Errorf("a change without its manifest %+v does not wait", c.Fps)
+		}
+	}
+	ch, waits := newWorld().change(context.Background(), f.get, delivery.Candidate{Group: "g", HeadsHash: "0123456789ab",
+		Pulls: []delivery.CandidatePull{pull("novox/web", 1, map[string]delivery.CandidateModule{"web": {FP2: fp('b'), Manifest: bad}})}}, nil)
+	if waits != "" || ch.Unreadable["web"] == "" {
+		t.Errorf("an unreadable manifest: waits %q, change %+v", waits, ch)
+	}
+}
+
+// A manifest of the change whose config value falls back to a predefined key (novox/hq ADR 0348 §7) is read, not
+// unreadable for the catalogue's predefined.json the assigner never holds: the merge gate judges the fallback in the
+// catalogue, and the indexer reads it the same way (catalogue.ParseManifestForInputs, issue 1751). A group whose
+// mesh-catalog member touched pacman and xterm failed its composition on this (group check 18df81380db3). The manifest is
+// xterm's module.json from mesh-catalog at 835bf22b.
+func TestAManifestFallingBackToAPredefinedKeyIsReadable(t *testing.T) {
+	raw, err := os.ReadFile("testdata/catalogue-835bf22b-xterm.module.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(raw), `"predefined"`) {
+		t.Fatal("the fixture names no predefined key")
+	}
+	f := fakeManifests{}
+	xterm := f.add(t, "xterm", string(raw))
+	ch, waits := newWorld().change(context.Background(), f.get, delivery.Candidate{Group: "g", HeadsHash: "0123456789ab",
+		Pulls: []delivery.CandidatePull{pull("novox/mesh-catalog", 1, map[string]delivery.CandidateModule{"xterm": {FP2: fp('b'), Manifest: xterm}})}}, nil)
+	if waits != "" || ch.Unreadable["xterm"] != "" || ch.Manifests["xterm"].Module != "xterm" {
+		t.Errorf("xterm: waits %q, unreadable %q, want read", waits, ch.Unreadable["xterm"])
+	}
+}
+
 // Review round 1 (items 3 and 4): the world counts the values a key takes, so a have written again after an answer is seen.
 func theWorldCountsTheValuesAKeyTakes(t *testing.T) {
 	w := newWorld()

modules/mesh-delivery-assigner/go.mod

@@ -3,32 +3,20 @@ module mesh-delivery-assigner
 go 1.26.0
 
 require (
-	git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261104174359-05b3e2e1b94f
+	git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261102112556-abf5eace7791
 	github.com/nats-io/nats-server/v2 v2.11.17
 	github.com/nats-io/nats.go v1.54.0
 )
 
 require (
-	git.novox.be/novox/mesh-contracts/go v0.0.0-20261104174344-ae5266e77639 // indirect
-	github.com/antithesishq/antithesis-sdk-go v0.8.0-default-no-op // indirect
+	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.1 // 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.2 // 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/crypto v0.57.0 // indirect
 	golang.org/x/sys v0.48.0 // indirect
-	golang.org/x/time v0.16.0 // indirect
+	golang.org/x/time v0.15.0 // indirect
 )
-
-require git.novox.be/novox/mesh-delivery/sdk v0.0.0-00010101000000-000000000000
-
-require (
-	git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient v0.0.0-20261104174344-ae5266e77639
-	git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient v0.0.0-20261104174344-ae5266e77639
-	git.novox.be/novox/mesh-contracts/go/seats/nodeengine v0.0.0-20261104174344-ae5266e77639
-	git.novox.be/novox/mesh-contracts/go/seats/operatorchannel v0.0.0-20261104174344-ae5266e77639
-)
-
-replace git.novox.be/novox/mesh-delivery/sdk => ../../sdk

modules/mesh-delivery-assigner/go.sum

@@ -1,25 +1,15 @@
-git.novox.be/novox/mesh-contracts/go v0.0.0-20261104174344-ae5266e77639 h1:Zt7CfWt2S2W/fVgWNyW2u2+xwz051LXvGxVTNIyfhdM=
-git.novox.be/novox/mesh-contracts/go v0.0.0-20261104174344-ae5266e77639/go.mod h1:0dD1XEJBJ0G5UYDQxSZI84nuujb6m3tOpJl4C8rQVvg=
-git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient v0.0.0-20261104174344-ae5266e77639 h1:3FTxvHrv3Hv+ZUbp/ezTrndqdgiS+Z6EUG2XGYJNJr8=
-git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient v0.0.0-20261104174344-ae5266e77639/go.mod h1:/V/1wfyQwjE9VbPLsFtkf6uX+SHKUXX34s5JscDuGAs=
-git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient v0.0.0-20261104174344-ae5266e77639 h1:19PhtrCOwia711Oqdyafvs5EKTVmmgk5Gdb4leCkq3w=
-git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient v0.0.0-20261104174344-ae5266e77639/go.mod h1:Dj6fbL8Evgy72EWO3Gl3L3Ra8N/nJSzgEVwSGmeRam0=
-git.novox.be/novox/mesh-contracts/go/seats/nodeengine v0.0.0-20261104174344-ae5266e77639 h1:YQ6eJvc+RYUVIVf+oX+R4TC1dYL8TLLMZ0/JPDU1tp4=
-git.novox.be/novox/mesh-contracts/go/seats/nodeengine v0.0.0-20261104174344-ae5266e77639/go.mod h1:TB20TsQuOd5aer+cXL6PbaYyg2RvgL1R4MzD61Oks3A=
-git.novox.be/novox/mesh-contracts/go/seats/operatorchannel v0.0.0-20261104174344-ae5266e77639 h1:K/1yIkqAWKGtLEtJ0PibijIdpo5YATL/9IUVXFoEglM=
-git.novox.be/novox/mesh-contracts/go/seats/operatorchannel v0.0.0-20261104174344-ae5266e77639/go.mod h1:osh0jQyNqYDM27tbxQo6HeUEXgLq9XUewKzNhUXadog=
-git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261104174359-05b3e2e1b94f h1:jDsfDMd48MXY9Zershc3eRxnhmx2sSpUfQkLq5jAIds=
-git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261104174359-05b3e2e1b94f/go.mod h1:08OomDXdwVN8/87nyDtv5R3rH/6LoP8SFFXz30bTYCM=
-github.com/antithesishq/antithesis-sdk-go v0.8.0-default-no-op h1:1BOWQJweNyvZMlpAHXGLiZQn9S+QXGcz3xh94lC0w6E=
-github.com/antithesishq/antithesis-sdk-go v0.8.0-default-no-op/go.mod h1:FQyySiasQQM8735Ddel3MRojmy4dA1IqCeyJ5jmPMbI=
+git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261102112556-abf5eace7791 h1:7SYIDPMxbPBr8dMB6k9fYsgVt4ZyWVL41q4LMFsfAvs=
+git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261102112556-abf5eace7791/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.1 h1:T7kKElXUMXrUJ2E9QhQhxFtcK5rPyLdsGZvdbLMPdiQ=
-github.com/klauspost/compress v1.20.1/go.mod h1:LUdAzn7YLVvxLpc7y3V1m40wESHTgc1422pwwBSKYuI=
+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.2 h1:XXRgB60MSTnqsRwejQurVDs/hcv2dkt+86GjI+I/bMc=
-github.com/nats-io/jwt/v2 v2.8.2/go.mod h1:Ag/56sq9OblL4JgdYufDd16Egb17Kr/8WwwuO/forVc=
+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=
@@ -33,5 +23,5 @@ golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZ
 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.16.0 h1:vMb6ptszcQMkcwiRTAuNNU50gom6++Q/6gY2hDM6VDE=
-golang.org/x/time v0.16.0/go.mod h1:rVKOqvZeKvrDKTQiAHJ7wmwP0RzleSphoEA9RcdLA0s=
+golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
+golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=

modules/mesh-delivery-assigner/internal/assign/askjson.go

@@ -1,68 +0,0 @@
-package assign
-
-import (
-	"encoding/json"
-	"fmt"
-	"time"
-
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
-	oc "git.novox.be/novox/mesh-contracts/go/seats/operatorchannel"
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// assignerAsk is the asking-th ask a, as the asks state holds it: the router's ask as JSON (delivery.AssignerAsk.Ask).
-func assignerAsk(asking int, a oc.Ask) delivery.AssignerAsk {
-	raw, err := json.Marshal(a)
-	if err != nil { // an oc.Ask holds only strings, bools and a slice of them: it cannot fail
-		panic(fmt.Sprintf("assign: the ask %q does not marshal: %v", a.ID, err))
-	}
-	return delivery.AssignerAsk{Asking: asking, Ask: raw}
-}
-
-// AskOf is the router's ask an asks-state value carries.
-func AskOf(a delivery.AssignerAsk) (oc.Ask, error) {
-	var ask oc.Ask
-	if err := json.Unmarshal(a.Ask, &ask); err != nil {
-		return oc.Ask{}, fmt.Errorf("assign: the value carries no router's ask: %w", err)
-	}
-	return ask, nil
-}
-
-// EncodeAsk is delivery.EncodeAssignerAsk at key, after the checks every keeper of an ask owes (occ.Carried, ADR 0627 §4):
-// the ask's id is delivery.AskingID(key, asking), and it offers at least one option.
-func EncodeAsk(key string, a delivery.AssignerAsk) ([]byte, error) {
-	if _, err := checkedAsk(key, a); err != nil {
-		return nil, err
-	}
-	return delivery.EncodeAssignerAsk(key, a)
-}
-
-func checkedAsk(key string, a delivery.AssignerAsk) (oc.Ask, error) {
-	ask, err := occ.Carried(a.Ask, delivery.AskingID(key, a.Asking))
-	if err != nil {
-		return oc.Ask{}, fmt.Errorf("assign: %w", err)
-	}
-	return ask, nil
-}
-
-// DecodeAsk reads the ask at key (delivery.DecodeAssignerAsk) with the router's ask it carries.
-func DecodeAsk(key string, data []byte) (delivery.AssignerAsk, oc.Ask, error) {
-	a, err := delivery.DecodeAssignerAsk(key, data)
-	if err != nil {
-		return delivery.AssignerAsk{}, oc.Ask{}, err
-	}
-	ask, err := checkedAsk(key, a)
-	if err != nil {
-		return delivery.AssignerAsk{}, oc.Ask{}, err
-	}
-	return a, ask, nil
-}
-
-// ExpiresAt is when the ask ends unanswered; the zero time for an ask that names none.
-func ExpiresAt(a oc.Ask) time.Time {
-	t, err := occ.Time(a.Expires)
-	if err != nil {
-		return time.Time{}
-	}
-	return t
-}

modules/mesh-delivery-assigner/internal/assign/asks.go

@@ -6,8 +6,7 @@ import (
 	"strings"
 	"time"
 
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
-	oc "git.novox.be/novox/mesh-contracts/go/seats/operatorchannel"
+	"git.novox.be/novox/mesh-sdk/go/asks"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 )
 
@@ -16,21 +15,21 @@ import (
 // record's: the machine whose health check failed and the hold's words (issue 1906). asking numbers the writing: 0 the first, a
 // larger number an ask written again after a hold lifted by itself, so the router takes it as new.
 func HoldAsk(key, module, fp, node, words string, asking int, now time.Time) delivery.AssignerAsk {
-	return assignerAsk(asking, oc.Ask{
+	return delivery.AssignerAsk{Asking: asking, Ask: asks.Ask{
 		ID:       delivery.AskingID(key, asking),
 		Headline: fmt.Sprintf("%s is held at %s", module, short(fp)),
 		Explanation: fmt.Sprintf("The health check of %s failed on %s at %s (%s), so the assigner holds that version and wants "+
 			"no node to move to it. It lifts the hold by itself once every node that runs %s runs it healthy; releasing it "+
 			"lets the wants move to it now.", module, node, short(fp), words, module),
-		Options: []oc.Option{
-			{ID: "keep", Label: "Keep it held", Does: "the version stays held", Level: occ.Acknowledge},
-			{ID: "release", Label: "Release it", Does: "the version is released and the wants move to it by the rules again", Level: occ.Acknowledge},
+		Options: []asks.Option{
+			{ID: "keep", Label: "Keep it held", Does: "the version stays held", Level: asks.Acknowledge},
+			{ID: "release", Label: "Release it", Does: "the version is released and the wants move to it by the rules again", Level: asks.Acknowledge},
 		},
-		Who:      occ.Operator,
-		Expires:  occ.FormatTime(now.Add(7 * 24 * time.Hour)),
+		Who:      asks.Operator,
+		Expires:  now.Add(7 * 24 * time.Hour),
 		OnExpiry: "the version stays held",
 		About:    key,
-	})
+	}}
 }
 
 // The options of the restore ask (ADR 0537 §3, ADR 0539 §19), and what each does on the node.
@@ -43,41 +42,41 @@ const (
 // not set back by itself, since a set-back would lose the writes made since. words is the check's words. Restore sets the
 // node back to the last healthy fingerprint and loses the newer writes; leaving it stopped keeps the data as it is.
 func RestoreAsk(key, node, module, fp, words string, now time.Time) delivery.AssignerAsk {
-	return assignerAsk(0, oc.Ask{
+	return delivery.AssignerAsk{Ask: asks.Ask{
 		ID:       delivery.AskingID(key, 0),
 		Headline: fmt.Sprintf("%s failed its health check on %s", module, node),
 		Explanation: fmt.Sprintf("%s holds data, and its health check failed on %s at %s: %s. Setting it back to the version that ran healthy "+
 			"would lose the writes made since; leaving it stopped keeps the data as it is.", module, node, short(fp), words),
-		Options: []oc.Option{
-			{ID: OptionRestore, Label: "Restore it", Does: "the node is set back to the last healthy version and the newer writes are lost", Level: occ.Acknowledge},
-			{ID: OptionLeaveStopped, Label: "Leave it stopped", Does: "the module stays as it is on the node and the data is kept", Level: occ.Acknowledge},
+		Options: []asks.Option{
+			{ID: OptionRestore, Label: "Restore it", Does: "the node is set back to the last healthy version and the newer writes are lost", Level: asks.Acknowledge},
+			{ID: OptionLeaveStopped, Label: "Leave it stopped", Does: "the module stays as it is on the node and the data is kept", Level: asks.Acknowledge},
 		},
-		Who:      occ.Operator,
-		Expires:  occ.FormatTime(now.Add(7 * 24 * time.Hour)),
+		Who:      asks.Operator,
+		Expires:  now.Add(7 * 24 * time.Hour),
 		OnExpiry: "the module stays as it is on the node",
 		About:    key,
-	})
+	}}
 }
 
 // HeldCondition is the condition the assigner raises when it holds a fingerprint of a module (ADR 0429 §6, ADR 0539 §19), or
 // clears (raised false) when the hold is released. It names the module, the node whose health check failed and the check's
 // words, under the assigner's own name (ADR 0437 clause 9), keyed by the held fingerprint. needsYou is true for a module holding
 // data, whose restore ask waits for the operator.
-func HeldCondition(module, fp, node, words string, raised, needsYou bool) oc.Condition {
+func HeldCondition(module, fp, node, words string, raised, needsYou bool) asks.Condition {
 	key := delivery.AssignerModule + ".held." + module + "." + strings.TrimPrefix(fp, delivery.SourcePrefix2)
-	subject := oc.ConditionSubject{Scope: "module", ID: module, Machine: node}
+	subject := asks.Scope{Scope: "module", ID: module, Machine: node}
 	if !raised {
-		return oc.Condition{Key: key, Subject: subject, State: occ.StateCleared}
+		return asks.Condition{Key: key, Subject: subject, State: asks.StateCleared}
 	}
-	c := oc.Condition{Key: key, Severity: occ.SeverityWarning, Subject: subject, State: occ.StateRaised,
+	c := asks.Condition{Key: key, Severity: asks.SeverityWarning, Subject: subject, State: asks.StateRaised,
 		Summary:  fmt.Sprintf("%s is held at %s", module, short(fp)),
 		Headline: fmt.Sprintf("%s is held at %s", module, short(fp))}
 	what := fmt.Sprintf("The health check of %s failed on %s at %s: %s. The assigner holds that version and wants no node to move to it.", module, node, short(fp), words)
 	if needsYou {
 		c.Needs = "answer whether to restore " + module + " on " + node
-		c.Explanation = occ.NeedsYou + c.Needs + ". " + what
+		c.Explanation = asks.NeedsYou + c.Needs + ". " + what
 	} else {
-		c.Explanation = occ.NothingToDo + " " + what + " Nodes that wanted it are set back to the version that ran healthy."
+		c.Explanation = asks.NothingToDo + " " + what + " Nodes that wanted it are set back to the version that ran healthy."
 	}
 	return c
 }
@@ -86,22 +85,22 @@ func HeldCondition(module, fp, node, words string, raised, needsYou bool) oc.Con
 // node while other nodes run it healthy (ADR 0557 §1, issue 1496): the failure is the node's, so nothing is held or set back and
 // the node keeps its want. It names the node, the module, fp and the have's words, keyed by node and module, and is cleared
 // (raised false) once the node no longer fails alone.
-func NodeFailedCondition(node, module, fp string, f NodeFailure, raised bool) oc.Condition {
+func NodeFailedCondition(node, module, fp string, f NodeFailure, raised bool) asks.Condition {
 	key := delivery.AssignerModule + ".failed-alone." + node + "." + module
-	subject := oc.ConditionSubject{Scope: "module", ID: module, Machine: node}
+	subject := asks.Scope{Scope: "module", ID: module, Machine: node}
 	if !raised {
-		return oc.Condition{Key: key, Subject: subject, State: occ.StateCleared,
+		return asks.Condition{Key: key, Subject: subject, State: asks.StateCleared,
 			Resolved: fmt.Sprintf("%s on %s no longer fails its health check alone.", module, node)}
 	}
 	headline := fmt.Sprintf("%s fails on %s alone", module, node)
-	if n := len([]rune(headline)); n > occ.HeadlineLength {
-		headline = string([]rune(headline)[:occ.HeadlineLength])
+	if n := len([]rune(headline)); n > asks.HeadlineLength {
+		headline = string([]rune(headline)[:asks.HeadlineLength])
 	}
-	return oc.Condition{Key: key, Severity: occ.SeverityWarning, Subject: subject, State: occ.StateRaised,
+	return asks.Condition{Key: key, Severity: asks.SeverityWarning, Subject: subject, State: asks.StateRaised,
 		Summary: headline, Headline: headline,
 		Explanation: fmt.Sprintf("%s The health check of %s at %s failed on %s (%s), while it runs healthy on %s. The failure is %s's, "+
 			"so the assigner holds nothing and sets no node back, and %s keeps its want. This clears once %s runs it healthy or "+
-			"another version is the newest.", occ.NothingToDo, module, short(fp), node, f.Words, strings.Join(f.Others, ", "), node,
+			"another version is the newest.", asks.NothingToDo, module, short(fp), node, f.Words, strings.Join(f.Others, ", "), node,
 			node, node)}
 }
 
@@ -109,28 +108,36 @@ func NodeFailedCondition(node, module, fp string, f NodeFailure, raised bool) oc
 // gives up every module with a fingerprint of the new form, so nothing applies it there and its files are gone. It is raised (urgent)
 // naming the module, the node and the rule holding its first want back with the rule's words, under the assigner's own name keyed by
 // node and module, and cleared (raised false) when the node has a want for it again.
-func NeitherCondition(node, module string, h Holding, raised bool) oc.Condition {
+func NeitherCondition(node, module string, h Holding, raised bool) asks.Condition {
 	key := delivery.AssignerModule + ".neither." + node + "." + module
-	subject := oc.ConditionSubject{Scope: "module", ID: module, Machine: node}
+	subject := asks.Scope{Scope: "module", ID: module, Machine: node}
 	if !raised {
-		return oc.Condition{Key: key, Subject: subject, State: occ.StateCleared,
+		return asks.Condition{Key: key, Subject: subject, State: asks.StateCleared,
 			Resolved: fmt.Sprintf("%s on %s has a want again, so its own composition is applied there.", module, node)}
 	}
 	headline := fmt.Sprintf("%s on %s is on no list", module, node)
-	if n := len([]rune(headline)); n > occ.HeadlineLength {
-		headline = string([]rune(headline)[:occ.HeadlineLength])
+	if n := len([]rune(headline)); n > asks.HeadlineLength {
+		headline = string([]rune(headline)[:asks.HeadlineLength])
 	}
-	return oc.Condition{Key: key, Severity: occ.SeverityUrgent, Subject: subject, State: occ.StateRaised,
+	if h.Bus {
+		needs := fmt.Sprintf("put %s on %s with assigner_put", module, node)
+		return asks.Condition{Key: key, Severity: asks.SeverityUrgent, Subject: subject, State: asks.StateRaised,
+			Summary: headline, Headline: headline, Needs: needs,
+			Explanation: fmt.Sprintf("%s%s. %s is assigned to %s, but the node holds no want for it and the node's own composition does not "+
+				"hold it either, so nothing applies it there. The assigner never moves the bus: %s. This clears once the node has a want for it.",
+				asks.NeedsYou, needs, module, node, h.Words)}
+	}
+	return asks.Condition{Key: key, Severity: asks.SeverityUrgent, Subject: subject, State: asks.StateRaised,
 		Summary: headline, Headline: headline,
 		Explanation: fmt.Sprintf("%s %s is assigned to %s, but the node holds no want for it and the node's own composition does not "+
 			"hold it either, so nothing applies it there. The assigner's rule %d holds its first want back: %s. The assigner writes the want once the "+
-			"rule holds, and clears this.", occ.NothingToDo, module, node, h.Rule, h.Words)}
+			"rule holds, and clears this.", asks.NothingToDo, module, node, h.Rule, h.Words)}
 }
 
 // NeitherLeftCondition clears the neither condition of module on node when it is no longer on neither list: why is "" when the
 // node has a live want for it again, else why it has none (it is held, its move waits for an ask, the node no longer runs it), so
 // the clear never says a want the node does not hold (issue 1945: "nats on novox has a want again" while it had none).
-func NeitherLeftCondition(node, module, why string) oc.Condition {
+func NeitherLeftCondition(node, module, why string) asks.Condition {
 	c := NeitherCondition(node, module, Holding{}, false)
 	if why != "" {
 		c.Resolved = fmt.Sprintf("%s on %s is no longer on neither list and has no want: %s.", module, node, why)
@@ -139,7 +146,7 @@ func NeitherLeftCondition(node, module, why string) oc.Condition {
 }
 
 // LiftedCondition clears the condition of a held fingerprint the assigner lifted by itself, saying why (issue 1906).
-func LiftedCondition(module, fp string) oc.Condition {
+func LiftedCondition(module, fp string) asks.Condition {
 	c := HeldCondition(module, fp, "", "", false, false)
 	c.Resolved = LiftedWords(module, fp) + "."
 	return c
@@ -162,20 +169,20 @@ func RecordAsk(key, node, module, fp string, need RecordNeed, now time.Time) del
 		delivery.JudgedMovesData: "moves the module's data",
 		delivery.JudgedCannot:    "cannot be judged: " + need.Words,
 	}[need.Judgement]
-	return assignerAsk(0, oc.Ask{
+	return delivery.AssignerAsk{Ask: asks.Ask{
 		ID:       delivery.AskingID(key, 0),
 		Headline: fmt.Sprintf("%s waits for your yes on %s", module, node),
 		Explanation: fmt.Sprintf("%s is recorded: a person takes each of its moves. The next one on %s (version %s) %s. "+
 			"The node is told to apply it only after you say yes.", module, node, short(fp), what),
-		Options: []oc.Option{
-			{ID: OptionYes, Label: "Yes, move it", Does: "the node is told to apply the new composition of " + module, Level: occ.Acknowledge},
-			{ID: OptionNo, Label: "No, not now", Does: "the node keeps what it runs", Level: occ.Acknowledge},
+		Options: []asks.Option{
+			{ID: OptionYes, Label: "Yes, move it", Does: "the node is told to apply the new composition of " + module, Level: asks.Acknowledge},
+			{ID: OptionNo, Label: "No, not now", Does: "the node keeps what it runs", Level: asks.Acknowledge},
 		},
-		Who:      occ.Operator,
-		Expires:  occ.FormatTime(now.Add(7 * 24 * time.Hour)),
+		Who:      asks.Operator,
+		Expires:  now.Add(7 * 24 * time.Hour),
 		OnExpiry: "the node keeps what it runs",
 		About:    key,
-	})
+	}}
 }
 
 // NextBackupAsking is the number of the asking that follows the one numbered after (a negative number: none yet). Numbers 0 and 1
@@ -193,11 +200,7 @@ var backupDigest = regexp.MustCompile(`\(composition (sha256:[0-9a-f]{64})\)`)
 // none. An answer is taken for the composition of the ask it answers, and a new revision at the same fingerprint is asked again
 // under a new number (ADR 0539 §16).
 func BackupAskDigest(a delivery.AssignerAsk) string {
-	ask, err := AskOf(a)
-	if err != nil {
-		return ""
-	}
-	if m := backupDigest.FindStringSubmatch(ask.Explanation); m != nil {
+	if m := backupDigest.FindStringSubmatch(a.Ask.Explanation); m != nil {
 		return m[1]
 	}
 	return ""
@@ -213,33 +216,33 @@ func BackupAnswerWords(option string, asking int) string {
 // without a backup. digest is the composition about to be applied and asking the number of the asking, 0 the first; words are the
 // backup's own words, from the node's have.
 func BackupAsk(key, node, module, fp, digest, words string, asking int, now time.Time) delivery.AssignerAsk {
-	return assignerAsk(asking, oc.Ask{
+	return delivery.AssignerAsk{Asking: asking, Ask: asks.Ask{
 		ID:       delivery.AskingID(key, asking),
 		Headline: fmt.Sprintf("The backup of %s failed on %s", module, node),
 		Explanation: fmt.Sprintf("The backup before applying %s at %s on %s failed: %s. %s keeps running what it has until you answer. (composition %s)",
 			module, short(fp), node, words, module, digest),
-		Options: []oc.Option{
-			{ID: OptionBackupAgain, Label: "Back up again", Does: "the node tries the backup again before it applies", Level: occ.Acknowledge},
-			{ID: OptionBackupSkip, Label: "Go on without a backup", Does: "the node applies the new version without a backup", Level: occ.Acknowledge},
+		Options: []asks.Option{
+			{ID: OptionBackupAgain, Label: "Back up again", Does: "the node tries the backup again before it applies", Level: asks.Acknowledge},
+			{ID: OptionBackupSkip, Label: "Go on without a backup", Does: "the node applies the new version without a backup", Level: asks.Acknowledge},
 		},
-		Who:      occ.Operator,
-		Expires:  occ.FormatTime(now.Add(7 * 24 * time.Hour)),
+		Who:      asks.Operator,
+		Expires:  now.Add(7 * 24 * time.Hour),
 		OnExpiry: "the module keeps running what it has",
 		About:    key,
-	})
+	}}
 }
 
 // BackupCondition is the condition raised when a backup before an apply fails and the module is held on the node (ADR 0539 §16),
 // naming the node, the module and the backup's words; cleared under the same key.
-func BackupCondition(node, module, fp, words string, raised bool) oc.Condition {
+func BackupCondition(node, module, fp, words string, raised bool) asks.Condition {
 	key := delivery.AssignerModule + ".backup." + node + "." + module + "." + strings.TrimPrefix(fp, delivery.SourcePrefix2)
-	subject := oc.ConditionSubject{Scope: "module", ID: module, Machine: node}
+	subject := asks.Scope{Scope: "module", ID: module, Machine: node}
 	if !raised {
-		return oc.Condition{Key: key, Subject: subject, State: occ.StateCleared}
+		return asks.Condition{Key: key, Subject: subject, State: asks.StateCleared}
 	}
 	headline := fmt.Sprintf("The backup of %s failed on %s", module, node)
 	needs := "answer whether to back up again or go on without a backup"
-	return oc.Condition{Key: key, Severity: occ.SeverityWarning, Subject: subject, State: occ.StateRaised,
+	return asks.Condition{Key: key, Severity: asks.SeverityWarning, Subject: subject, State: asks.StateRaised,
 		Summary: headline, Headline: headline, Needs: needs,
-		Explanation: occ.NeedsYou + needs + ". The backup before applying " + module + " at " + short(fp) + " on " + node + " failed: " + words + "."}
+		Explanation: asks.NeedsYou + needs + ". The backup before applying " + module + " at " + short(fp) + " on " + node + " failed: " + words + "."}
 }

modules/mesh-delivery-assigner/internal/assign/asks_test.go

@@ -1,14 +1,12 @@
 package assign
 
 import (
-	"fmt"
 	"slices"
 	"strings"
 	"testing"
 	"time"
 
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
-	oc "git.novox.be/novox/mesh-contracts/go/seats/operatorchannel"
+	"git.novox.be/novox/mesh-sdk/go/asks"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 	"git.novox.be/novox/mesh-sdk/go/health"
 )
@@ -22,42 +20,27 @@ func TestTheHoldAskIsValid(t *testing.T) {
 	}
 	now := time.Now()
 	a := HoldAsk(key, "mail", fNew, "ace", "health failed, phase running: connection refused", 0, now)
-	if err := occ.Check(mustAsk(t, a), now); err != nil {
+	if err := a.Ask.Check(now); err != nil {
 		t.Errorf("the router refuses the ask: %v", err)
 	}
-	if _, err := EncodeAsk(key, a); err != nil {
+	if _, err := delivery.EncodeAssignerAsk(key, a); err != nil {
 		t.Errorf("the ask cannot be written: %v", err)
 	}
 	// 1906/H3: the ask names the machine whose check failed and the hold's words.
-	if !strings.Contains(mustAsk(t, a).Explanation, "on ace") || !strings.Contains(mustAsk(t, a).Explanation, "connection refused") {
-		t.Errorf("the ask does not name the node and the hold's words: %q", mustAsk(t, a).Explanation)
+	if !strings.Contains(a.Ask.Explanation, "on ace") || !strings.Contains(a.Ask.Explanation, "connection refused") {
+		t.Errorf("the ask does not name the node and the hold's words: %q", a.Ask.Explanation)
 	}
 	// 1906/H2: an ask written again after a lift is another asking, under an id of its own.
 	again := HoldAsk(key, "mail", fNew, "ace", "x", 7, now)
-	if again.Asking != 7 || mustAsk(t, again).ID != delivery.AskingID(key, 7) || mustAsk(t, again).ID == mustAsk(t, a).ID {
-		t.Errorf("the asking after a lift = %d %s", again.Asking, mustAsk(t, again).ID)
+	if again.Asking != 7 || again.Ask.ID != delivery.AskingID(key, 7) || again.Ask.ID == a.Ask.ID {
+		t.Errorf("the asking after a lift = %d %s", again.Asking, again.Ask.ID)
 	}
-	if _, err := EncodeAsk(key, again); err != nil {
+	if _, err := delivery.EncodeAssignerAsk(key, again); err != nil {
 		t.Errorf("the ask asked again cannot be written: %v", err)
 	}
 	if _, err := delivery.ViewAnswerKey(key); err != nil {
 		t.Errorf("the view may not answer it: %v", err)
 	}
-	// The join (A1d ruling 1): mesh-sdk no longer refuses another id, no option or no ask in an assigner's ask; EncodeAsk does.
-	t.Run("EncodeAsk refuses what mesh-sdk no longer does", func(t *testing.T) {
-		good := HoldAsk(key, "mail", fNew, "ace", "x", 0, time.Unix(100, 0))
-		other := good
-		other.Asking = 3 // its id is the asking 0's
-		empty := good
-		ask := mustAsk(t, good)
-		ask.Options = nil
-		empty.Ask = assignerAsk(0, ask).Ask
-		for name, a := range map[string]delivery.AssignerAsk{"another id": other, "no option": empty, "no ask": {}} {
-			if _, err := EncodeAsk(key, a); err == nil {
-				t.Errorf("%s: written", name)
-			}
-		}
-	})
 }
 
 // 1906/D3 (ADR 0539 §19): the ask about a data module held on a node is a valid ask of the router and of mesh-sdk's layout at
@@ -69,24 +52,24 @@ func TestTheRestoreAskIsValid(t *testing.T) {
 	}
 	now := time.Now()
 	a := RestoreAsk(key, "ace", "mail", fNew, "connection refused", now)
-	if err := occ.Check(mustAsk(t, a), now); err != nil {
+	if err := a.Ask.Check(now); err != nil {
 		t.Errorf("the router refuses the ask: %v", err)
 	}
-	if _, err := EncodeAsk(key, a); err != nil {
+	if _, err := delivery.EncodeAssignerAsk(key, a); err != nil {
 		t.Errorf("the ask cannot be written: %v", err)
 	}
 	if _, err := delivery.ViewAnswerKey(key); err != nil {
 		t.Errorf("the view may not answer it: %v", err)
 	}
 	var ids []string
-	for _, o := range mustAsk(t, a).Options {
+	for _, o := range a.Ask.Options {
 		ids = append(ids, o.ID)
 	}
 	if len(ids) != 2 || ids[0] != OptionRestore || ids[1] != OptionLeaveStopped {
 		t.Errorf("options = %v", ids)
 	}
-	if !strings.Contains(mustAsk(t, a).Explanation, "connection refused") || !strings.Contains(mustAsk(t, a).Explanation, "ace") {
-		t.Errorf("the ask does not name the node and the check's words: %q", mustAsk(t, a).Explanation)
+	if !strings.Contains(a.Ask.Explanation, "connection refused") || !strings.Contains(a.Ask.Explanation, "ace") {
+		t.Errorf("the ask does not name the node and the check's words: %q", a.Ask.Explanation)
 	}
 }
 
@@ -100,13 +83,13 @@ func TestTheAssignersConditions(t *testing.T) {
 
 func heldConditionNamesModuleNodeAndWords(t *testing.T) {
 	c := HeldCondition("mail", fNew, "ace", "connection refused", true, true)
-	if _, err := occ.EncodeCondition(c); err != nil {
+	if _, err := asks.EncodeCondition(c); err != nil {
 		t.Fatalf("the condition is refused: %v", err)
 	}
-	if c.State != occ.StateRaised || c.Subject.ID != "mail" || c.Subject.Machine != "ace" || !strings.Contains(c.Explanation, "connection refused") || !strings.Contains(c.Key, "mail") {
+	if c.State != asks.StateRaised || c.Subject.ID != "mail" || c.Subject.Machine != "ace" || !strings.Contains(c.Explanation, "connection refused") || !strings.Contains(c.Key, "mail") {
 		t.Errorf("condition = %+v", c)
 	}
-	if got := HeldCondition("mail", fNew, "", "", false, false); got.State != occ.StateCleared || got.Key != c.Key {
+	if got := HeldCondition("mail", fNew, "", "", false, false); got.State != asks.StateCleared || got.Key != c.Key {
 		t.Errorf("cleared = %+v", got)
 	}
 }
@@ -114,10 +97,10 @@ func heldConditionNamesModuleNodeAndWords(t *testing.T) {
 // 1906/H2: a hold lifted by itself clears the held condition under its key, saying why.
 func liftedHoldClearsItsConditionSayingWhy(t *testing.T) {
 	c := LiftedCondition("mail", fNew)
-	if _, err := occ.EncodeCondition(c); err != nil {
+	if _, err := asks.EncodeCondition(c); err != nil {
 		t.Fatalf("the condition is refused: %v", err)
 	}
-	if c.State != occ.StateCleared || c.Key != HeldCondition("mail", fNew, "ace", "x", true, false).Key || !strings.Contains(c.Resolved, "lifted its hold by itself") {
+	if c.State != asks.StateCleared || c.Key != HeldCondition("mail", fNew, "ace", "x", true, false).Key || !strings.Contains(c.Resolved, "lifted its hold by itself") {
 		t.Errorf("condition = %+v", c)
 	}
 }
@@ -129,7 +112,7 @@ func liftedHoldClearsItsConditionSayingWhy(t *testing.T) {
 func saidConditionsAreFindings(t *testing.T) {
 	at := time.Date(2026, 10, 29, 21, 0, 0, 0, time.UTC)
 	for _, c := range []struct {
-		raised, cleared oc.Condition
+		raised, cleared asks.Condition
 		key             string
 	}{
 		{HeldCondition("mail", fNew, "ace", "refused", true, true), LiftedCondition("mail", fNew), "module.mail." + strings.TrimPrefix(fNew, delivery.SourcePrefix2) + ".held"},
@@ -144,7 +127,7 @@ func saidConditionsAreFindings(t *testing.T) {
 			puts[k] = got
 			return err
 		}, Delete: func(k string) error { deletes = append(deletes, k); return nil }, Now: func() time.Time { return at }}
-		say := f.Say(func(oc.Condition) error { said++; return nil })
+		say := f.Say(func(asks.Condition) error { said++; return nil })
 		if err := say(c.raised); err != nil {
 			t.Fatalf("%s: %v", c.key, err)
 		}
@@ -156,11 +139,11 @@ func saidConditionsAreFindings(t *testing.T) {
 		if err := say(c.cleared); err != nil || !slices.Equal(deletes, []string{c.key}) || said != 0 {
 			t.Fatalf("%s: deleted %v, said %d (%v)", c.key, deletes, said, err)
 		}
-		if err := (Findings{}).Say(func(oc.Condition) error { said++; return nil })(c.raised); err != nil || said != 1 {
+		if err := (Findings{}).Say(func(asks.Condition) error { said++; return nil })(c.raised); err != nil || said != 1 {
 			t.Fatalf("%s: with no findings bucket said %d (%v), want straight once", c.key, said, err)
 		}
 	}
-	if _, _, _, err := FindingOf(oc.Condition{Key: "another.x", State: occ.StateRaised}, at); err == nil {
+	if _, _, _, err := FindingOf(asks.Condition{Key: "another.x", State: asks.StateRaised}, at); err == nil {
 		t.Error("a condition not the assigner's is a finding")
 	}
 }
@@ -181,24 +164,24 @@ func TestTheRecordAndBackupAsksAreValid(t *testing.T) {
 	dgst := "sha256:" + strings.Repeat("b", 64)
 	b := BackupAsk(bkey, "ace", "mail", fNew, dgst, "no space left", 0, now)
 	for key, a := range map[string]delivery.AssignerAsk{rkey: r, bkey: b} {
-		if err := occ.Check(mustAsk(t, a), now); err != nil {
+		if err := a.Ask.Check(now); err != nil {
 			t.Errorf("%s: the router refuses the ask: %v", key, err)
 		}
-		if _, err := EncodeAsk(key, a); err != nil {
+		if _, err := delivery.EncodeAssignerAsk(key, a); err != nil {
 			t.Errorf("%s: cannot be written: %v", key, err)
 		}
 		if _, err := delivery.ViewAnswerKey(key); err != nil {
 			t.Errorf("%s: the view may not answer it: %v", key, err)
 		}
 	}
-	if !strings.Contains(mustAsk(t, r).Explanation, "gone") || mustAsk(t, r).Options[0].ID != OptionYes {
-		t.Errorf("the record ask = %+v", mustAsk(t, r))
+	if !strings.Contains(r.Ask.Explanation, "gone") || r.Ask.Options[0].ID != OptionYes {
+		t.Errorf("the record ask = %+v", r.Ask)
 	}
-	if !strings.Contains(mustAsk(t, b).Explanation, "no space left") || mustAsk(t, b).Options[0].ID != delivery.BackupAgain || mustAsk(t, b).Options[1].ID != delivery.BackupSkip {
-		t.Errorf("the backup ask = %+v", mustAsk(t, b))
+	if !strings.Contains(b.Ask.Explanation, "no space left") || b.Ask.Options[0].ID != delivery.BackupAgain || b.Ask.Options[1].ID != delivery.BackupSkip {
+		t.Errorf("the backup ask = %+v", b.Ask)
 	}
 	// the id binds the ask to the composition and to its number (review round 1, items 3 and 4)
-	if again := BackupAsk(bkey, "ace", "mail", fNew, dgst, "x", NextBackupAsking(0), now); mustAsk(t, again).ID == mustAsk(t, b).ID {
+	if again := BackupAsk(bkey, "ace", "mail", fNew, dgst, "x", NextBackupAsking(0), now); again.Ask.ID == b.Ask.ID {
 		t.Errorf("asked again under the same id")
 	}
 	if NextBackupAsking(-1) != 0 || NextBackupAsking(0) != 2 || NextBackupAsking(2) != 3 {
@@ -211,7 +194,7 @@ func TestTheRecordAndBackupAsksAreValid(t *testing.T) {
 		t.Errorf("two answers of the same option are one want value")
 	}
 	c := BackupCondition("ace", "mail", fNew, "no space left", true)
-	if _, err := occ.EncodeCondition(c); err != nil {
+	if _, err := asks.EncodeCondition(c); err != nil {
 		t.Errorf("the backup condition is refused: %v", err)
 	}
 	// ADR 0546 clauses 7 and 8: a put's ask is valid at the record ask's key; for the bus its yes approves and binds the act,
@@ -223,39 +206,32 @@ func TestTheRecordAndBackupAsksAreValid(t *testing.T) {
 		if err != nil {
 			t.Fatalf("bus %v: %v", bus, err)
 		}
-		if err := occ.Check(mustAsk(t, a), now); err != nil {
+		if err := a.Ask.Check(now); err != nil {
 			t.Errorf("bus %v: the router refuses the put's ask: %v", bus, err)
 		}
-		if _, err := EncodeAsk(rkey, a); err != nil {
+		if _, err := delivery.EncodeAssignerAsk(rkey, a); err != nil {
 			t.Errorf("bus %v: the put's ask cannot be written: %v", bus, err)
 		}
-		viewed := delivery.ViewAnswerFits(delivery.ViewAnswer{Asking: mustAsk(t, a).ID, Option: OptionYes}, rkey, a)
-		yes := mustAsk(t, a).Options[0]
-		// mesh-sdk gives no refusal by level any more: the teller refuses an option a view cannot answer (its level is not
-		// acknowledge), as it did through the sdk before.
-		if viewed == nil {
-			if o, ok := occ.OptionOf(mustAsk(t, a), OptionYes); ok && o.Level != "" && o.Level != occ.Acknowledge {
-				viewed = fmt.Errorf("only a channel that proves who answered takes the option %s", o.ID)
-			}
-		}
+		viewed := delivery.ViewAnswerFits(delivery.ViewAnswer{Asking: a.Ask.ID, Option: OptionYes}, a)
+		yes := a.Ask.Options[0]
 		switch {
-		case !strings.Contains(mustAsk(t, a).Explanation, "the bus's user list"):
-			t.Errorf("bus %v: the put's ask does not say why: %s", bus, mustAsk(t, a).Explanation)
-		case bus && (yes.Level != occ.Approve || yes.Binds == "" || viewed == nil || expiresAt(t, a).After(now.Add(occ.ApproveLasts))):
-			t.Errorf("bus: the yes is %+v, the view's answer %v, expiring %s", yes, viewed, expiresAt(t, a))
-		case !bus && (yes.Level != occ.Acknowledge || viewed != nil):
+		case !strings.Contains(a.Ask.Explanation, "the bus's user list"):
+			t.Errorf("bus %v: the put's ask does not say why: %s", bus, a.Ask.Explanation)
+		case bus && (yes.Level != asks.Approve || yes.Binds == "" || viewed == nil || a.Ask.Expires.After(now.Add(asks.ApproveLasts))):
+			t.Errorf("bus: the yes is %+v, the view's answer %v, expiring %s", yes, viewed, a.Ask.Expires)
+		case !bus && (yes.Level != asks.Acknowledge || viewed != nil):
 			t.Errorf("a recorded module: the yes is %+v, the view's answer %v", yes, viewed)
 		}
 		later := put
 		later.At = now.Add(time.Minute)
 		b, _ := PutAsk(rkey, "ace", "mail", later, d, bus, now)
-		if mustAsk(t, b).ID == mustAsk(t, a).ID || b.Asking != PutAsking(later) {
-			t.Errorf("bus %v: a later put's ask is asking %d under id %q, the earlier's %q", bus, b.Asking, mustAsk(t, b).ID, mustAsk(t, a).ID)
+		if b.Ask.ID == a.Ask.ID || b.Asking != PutAsking(later) {
+			t.Errorf("bus %v: a later put's ask is asking %d under id %q, the earlier's %q", bus, b.Asking, b.Ask.ID, a.Ask.ID)
 		}
-		if err := occ.Performs(yes, PutAct("ace", "mail", fNew, dgst)); err != nil {
+		if err := yes.Performs(PutAct("ace", "mail", fNew, dgst)); err != nil {
 			t.Errorf("bus %v: the yes does not perform the act it bound: %v", bus, err)
 		}
-		if err := occ.Performs(yes, PutAct("ace", "mail", fNew, dig(fOld))); bus && err == nil {
+		if err := yes.Performs(PutAct("ace", "mail", fNew, dig(fOld))); bus && err == nil {
 			t.Errorf("bus: the yes performs another composition's act")
 		}
 	}
@@ -265,29 +241,14 @@ func TestTheRecordAndBackupAsksAreValid(t *testing.T) {
 // under the assigner's own name keyed by node and module, and is cleared under the same key.
 func TestTheNeitherConditionNamesModuleNodeAndRule(t *testing.T) {
 	c := NeitherCondition("g14", "i3status-rust", Holding{Rule: delivery.RuleProviders, Words: "no provider of x11-display runs healthy on g14 or at its canary"}, true)
-	if _, err := occ.EncodeCondition(c); err != nil {
+	if _, err := asks.EncodeCondition(c); err != nil {
 		t.Fatalf("the condition is refused: %v", err)
 	}
-	if c.State != occ.StateRaised || c.Severity != occ.SeverityUrgent || c.Subject.ID != "i3status-rust" || c.Subject.Machine != "g14" ||
+	if c.State != asks.StateRaised || c.Severity != asks.SeverityUrgent || c.Subject.ID != "i3status-rust" || c.Subject.Machine != "g14" ||
 		!strings.Contains(c.Explanation, "x11-display") || !strings.Contains(c.Explanation, "rule 5") || c.Key != "mesh-delivery-assigner.neither.g14.i3status-rust" {
 		t.Errorf("condition = %+v", c)
 	}
-	if got := NeitherCondition("g14", "i3status-rust", Holding{}, false); got.State != occ.StateCleared || got.Key != c.Key {
+	if got := NeitherCondition("g14", "i3status-rust", Holding{}, false); got.State != asks.StateCleared || got.Key != c.Key {
 		t.Errorf("cleared = %+v", got)
 	}
 }
-
-// mustAsk is the router's ask an asks-state value carries.
-func mustAsk(t *testing.T, a delivery.AssignerAsk) oc.Ask {
-	t.Helper()
-	ask, err := AskOf(a)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return ask
-}
-
-func expiresAt(t *testing.T, a delivery.AssignerAsk) time.Time {
-	t.Helper()
-	return ExpiresAt(mustAsk(t, a))
-}

modules/mesh-delivery-assigner/internal/assign/compose.go

@@ -0,0 +1,368 @@
+// Package assign is the assigner's judgement, as functions over what it read from the bus: the composition check of a
+// change (novox/hq ADR 0446 clauses 1 to 5, ADR 0528 clause 5, issue 1297), the six rules of what each node should
+// run (ADR 0429 §6, ADR 0528 clause 3) and the comparison with what the controller sends (ADR 0528 clause 4). It reads
+// and writes nothing itself: the program hands it what it watched and writes what it answers.
+package assign
+
+import (
+	"encoding/json"
+	"fmt"
+	"slices"
+	"sort"
+	"strings"
+	"time"
+
+	"git.novox.be/novox/mesh-sdk/go/catalogue"
+	"git.novox.be/novox/mesh-sdk/go/compose"
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+)
+
+// SDKRepository is the repository of mesh-sdk: a group with a member there changes the composition itself.
+const SDKRepository = "novox/mesh-sdk"
+
+// NotJudged names, in a composition's warnings, the failures of ADR 0446 clause 1 the assigner cannot judge from the
+// bus, because what they need is only in the controller's facts snapshot, which is not on the bus yet (issue 1461;
+// the design limit of R4g, issue 1297): said on every verdict, never passed silently.
+const NotJudged = "not judged until the facts snapshot is on the bus (issue 1461): a consumer left out of a grant, a " +
+	"credential left bound elsewhere, a stored setting the changed definition cannot keep, and a new module the " +
+	"node-engine's validator would refuse"
+
+// Mesh is the mesh as the trunk holds it: every module's manifest by name, the manifests that cannot be read with
+// why, and each node's open assignments.
+type Mesh struct {
+	Manifests  map[string]catalogue.Manifest
+	Unreadable map[string]string
+	Assigned   map[string][]string
+	// Digests is every trunk module's manifest digest in the indexer's manifests bucket, readable or not: what a
+	// composer at another mesh-sdk reads (issue 1622).
+	Digests map[string]string
+	// Input is the rest of the mesh as the nodes compose from it, filled by mesh-sdk's frombus from the catalogue's
+	// placement and the nodes' records (novox/hq ADR 0547 §2, ADR 0549 §3, issue 1126), so the check and the nodes share
+	// one composer's input; nil before any placement is read, when the nodes and their assignments alone are composed.
+	Input *compose.Input
+	// InputUnread says why that input could not be read from the bus, when it could not: the check then composes the
+	// nodes and their assignments alone, and says so in its warnings.
+	InputUnread string
+	// Verdicts are the indexer's refusals of trunk manifests, by module, as their values carry them (novox/hq ADR 0578
+	// §3): each such module is in Unreadable too, and the composer's input carries the verdict (§5).
+	Verdicts map[string]delivery.ManifestVerdict
+}
+
+// Change is a group's change as the indexer's candidate holds it: the manifest of every module it moves or adds, those
+// it cannot read and why, the modules it removes, every module defined twice with where, the heads of a mesh-sdk
+// member (empty when none), and how many modules it rebuilds.
+type Change struct {
+	Group, Heads string
+	Manifests    map[string]catalogue.Manifest
+	Unreadable   map[string]string
+	Removed      []string
+	Twice        map[string][]string
+	SDKHead      string
+	Rebuilt      int
+	// Digests is the manifest digest of every module the change moves or adds, readable by the assigner or not, and
+	// Members the head of each member by repository: what a composer at the group's mesh-sdk reads (issues 1622, 1623).
+	Digests map[string]string
+	Members map[string]string
+	// Held are the approved held values of the group's pull requests at the heads judged (mesh-config's `kept`, novox/hq ADR
+	// 0565 §5, ADR 0502 §4): each laid over its module's values on its node in the change's composition, and named.
+	Held []delivery.KeptValue
+}
+
+// HeldOf are the held values kept for the pull requests the candidate names, each at the head it names: one of another
+// pull request, or at another head, is never laid (ADR 0502 §4). kept is mesh-config's `kept` by key.
+func HeldOf(kept map[string][]byte, heads map[string]string) []delivery.KeptValue {
+	var out []delivery.KeptValue
+	for _, raw := range kept {
+		var k delivery.KeptValue
+		if json.Unmarshal(raw, &k) != nil || k.Node == "" || k.Module == "" || k.Key == "" {
+			continue
+		}
+		if head, ok := heads[k.Pull]; ok && head == k.Head {
+			out = append(out, k)
+		}
+	}
+	sort.Slice(out, func(i, j int) bool {
+		a, b := out[i], out[j]
+		return a.Pull+a.Node+a.Module+a.Key < b.Pull+b.Node+b.Module+b.Key
+	})
+	return out
+}
+
+// layHeld lays each held value over its module's values on its node, as a layer of its own after the rest, and answers
+// the words that name each; judged first against the head's declaration of its key (catalogue.ValueProblems), a value the
+// declaration refuses, or a key it does not declare, is a failure.
+func layHeld(in *compose.Input, held []delivery.KeptValue) (said, fails []string) {
+	for _, k := range held {
+		var v any
+		if err := json.Unmarshal(k.Value, &v); err != nil {
+			said = append(said, fmt.Sprintf("the held value %s of %s on %s for %s cannot be read, so it is not laid: %v", k.Key, k.Module, k.Node, k.Pull, err))
+			continue
+		}
+		d, declared := in.Catalogue[k.Module].Settings[k.Key]
+		if !declared {
+			fails = append(fails, fmt.Sprintf("the held value %s of %s on %s for %s: the head declares no such key", k.Key, k.Module, k.Node, k.Pull))
+			continue
+		}
+		if problems := catalogue.ValueProblems(d, v); len(problems) > 0 {
+			fails = append(fails, fmt.Sprintf("the held value %s of %s on %s for %s does not hold to the head's declaration: %s", k.Key, k.Module,
+				k.Node, k.Pull, strings.Join(problems, "; ")))
+			continue
+		}
+		at := slices.IndexFunc(in.Nodes, func(n compose.Node) bool { return n.Name == k.Node })
+		if at < 0 {
+			said = append(said, fmt.Sprintf("the held value %s of %s for %s names %s, which runs no module of the mesh: not laid", k.Key, k.Module, k.Pull, k.Node))
+			continue
+		}
+		if in.Nodes[at].Settings == nil {
+			in.Nodes[at].Settings = map[string][]catalogue.Layer{}
+		}
+		in.Nodes[at].Settings[k.Module] = append(in.Nodes[at].Settings[k.Module], catalogue.Layer{From: "held for " + k.Pull, Values: map[string]any{k.Key: v}})
+		said = append(said, fmt.Sprintf("held value laid: %s of %s on %s, held for %s at %.12s, approved by %s (novox/hq ADR 0502 §4)", k.Key, k.Module, k.Node, k.Pull, k.Head, k.Approved))
+	}
+	return said, fails
+}
+
+// Touched is the machines a change touches (ADR 0446 clause 3): those running a module the change moves, adds or
+// removes, those running a consumer of a provision such a module provides (before or after), and those running a
+// provider of a provision such a module requires after the change. A module the change adds that is assigned nowhere
+// touches no machine. A change of placement is no change of a repository (ADR 0567 §4): the seat
+// mesh-placement judges it.
+func Touched(m Mesh, c Change) []string {
+	moved := map[string]bool{}
+	for name := range c.Manifests {
+		moved[name] = true
+	}
+	for name := range c.Unreadable {
+		moved[name] = true
+	}
+	for _, name := range c.Removed {
+		moved[name] = true
+	}
+	provided, required := map[string]bool{}, map[string]bool{}
+	for name := range moved {
+		for _, man := range []catalogue.Manifest{m.Manifests[name], c.Manifests[name]} {
+			for _, o := range man.Provides {
+				provided[o.Name] = true
+			}
+		}
+		for _, r := range c.Manifests[name].Requires {
+			required[r] = true
+		}
+	}
+	var out []string
+	for node, modules := range m.Assigned {
+		for _, mod := range modules {
+			man := m.Manifests[mod]
+			if moved[mod] || slices.ContainsFunc(man.Requires, func(r string) bool { return provided[r] }) ||
+				slices.ContainsFunc(man.Provides, func(o catalogue.Offer) bool { return required[o.Name] }) {
+				out = append(out, node)
+				break
+			}
+		}
+	}
+	sort.Strings(out)
+	return out
+}
+
+// input is the composition's input for the mesh's catalogue and assignments: the nodes by name with what is assigned
+// to them, and every seat the assigned modules claim as held there. What the bus does not carry (places on the
+// private network, settings, credentials, licences) is left empty, so a trunk composition and a change's are made
+// with the same gaps and compared (ADR 0446 clause 1: what was already broken is said and fails nothing).
+func input(catalog map[string]catalogue.Manifest, assigned map[string][]string) compose.Input {
+	in := compose.Input{Catalogue: catalog}
+	nodes := make([]string, 0, len(assigned))
+	for n := range assigned {
+		nodes = append(nodes, n)
+	}
+	sort.Strings(nodes)
+	for _, n := range nodes {
+		in.Nodes = append(in.Nodes, compose.Node{Name: n, Assigned: slices.Clone(assigned[n])})
+		for _, mod := range assigned[n] {
+			for _, cl := range catalog[mod].Claims {
+				scope := cl.Scope
+				if seat, ok := catalogue.SeatNamed(cl.Name); ok && scope == "" {
+					scope = seat.Scope
+				}
+				in.Holdings = append(in.Holdings, catalogue.Held{Claim: cl.Name, Scope: scope, Node: n, Module: mod})
+			}
+		}
+	}
+	return in
+}
+
+// Compose is the composition check of change c over the mesh m, composed with the mesh-sdk version sdk: every touched
+// machine resolved as the trunk holds it and as the change leaves it. It fails on a manifest of the change that cannot
+// be read, a module a machine runs that the change removes, a module defined twice, and a machine that resolves on the
+// trunk and not with the change; a machine that does not resolve on either is said and fails nothing. It warns past
+// CompositionRebuildWarning modules rebuilt, says what it does not judge (NotJudged), and for a group with a mesh-sdk
+// member says it composed with its own mesh-sdk, not the member's head (issue 1621). took is how long it took.
+func Compose(m Mesh, c Change, sdk string, took time.Duration) delivery.CompositionVerdict {
+	v := delivery.CompositionVerdict{Group: c.Group, Heads: c.Heads, SDK: sdk, Took: took.Milliseconds()}
+	var fails []string
+	failAt := func(machine, words string) {
+		if v.Machine == "" && machine != "" {
+			v.Machine = machine
+		}
+		fails = append(fails, words)
+	}
+	for _, name := range sortedKeys(c.Unreadable) {
+		failAt("", fmt.Sprintf("the manifest of %s cannot be read: %s", name, c.Unreadable[name]))
+	}
+	for _, name := range sortedKeys(c.Twice) {
+		failAt("", fmt.Sprintf("%s is defined twice, in %s", name, strings.Join(c.Twice[name], " and ")))
+	}
+	machines := Touched(m, c)
+	v.Machines = machines
+	for _, node := range machines {
+		for _, name := range c.Removed {
+			if slices.Contains(m.Assigned[node], name) {
+				failAt(node, fmt.Sprintf("%s runs %s, which the change removes from its source", node, name))
+			}
+		}
+	}
+	trunk := input(m.Manifests, m.Assigned)
+	changed := map[string]catalogue.Manifest{}
+	for name, man := range m.Manifests {
+		changed[name] = man
+	}
+	for name, man := range c.Manifests {
+		changed[name] = man
+	}
+	for _, name := range c.Removed {
+		delete(changed, name)
+	}
+	after := input(changed, m.Assigned)
+	laid, heldFails := layHeld(&after, c.Held)
+	v.Warnings = append(v.Warnings, laid...)
+	for _, f := range heldFails {
+		failAt("", f)
+	}
+	for _, node := range machines {
+		_, before := compose.Resolve(trunk, node)
+		_, now := compose.Resolve(after, node)
+		switch {
+		case now == nil:
+		case before != nil:
+			v.Warnings = append(v.Warnings, fmt.Sprintf("%s does not compose on the trunk either, so the change is not blamed: %v", node, before))
+		default:
+			failAt(node, fmt.Sprintf("%s composes on the trunk and not with the change: %v", node, now))
+		}
+	}
+	if c.SDKHead != "" {
+		v.Warnings = append(v.Warnings, fmt.Sprintf("composed with the assigner's own mesh-sdk %s, not the group's mesh-sdk head %s, "+
+			"and a field the running controller cannot read is not judged (issues 1621, 1622, 1623)", sdk, c.SDKHead))
+	}
+	return finish(v, m, c, machines, fails)
+}
+
+// finish adds what every composition says beside its own judgement (more modules rebuilt than CompositionRebuildWarning,
+// what is not judged, the machines not composed, a change that touches none) and its state from fails.
+func finish(v delivery.CompositionVerdict, m Mesh, c Change, machines []string, fails []string) delivery.CompositionVerdict {
+	if c.Rebuilt > delivery.CompositionRebuildWarning {
+		v.Warnings = append(v.Warnings, fmt.Sprintf("the merge rebuilds %d modules, more than %d", c.Rebuilt, delivery.CompositionRebuildWarning))
+	}
+	v.Warnings = append(v.Warnings, NotJudged)
+	if could := CouldRun(m, c, machines); len(could) > 0 {
+		v.Warnings = append(v.Warnings, "not judged until the facts snapshot is on the bus (issue 1461, ADR 0537 clause 1): "+
+			"the machines that could run a moved or added module and are not assigned it: "+strings.Join(could, ", "))
+	}
+	if grants := GrantsAlone(m, c, machines); len(grants) > 0 {
+		v.Warnings = append(v.Warnings, "not judged until the facts snapshot is on the bus (issue 1461, ADR 0537 clause 1): "+
+			"the machines whose grants alone the change alters: "+strings.Join(grants, ", "))
+	}
+	if len(machines) == 0 {
+		v.Warnings = append(v.Warnings, "the change touches no machine: no module it moves is assigned anywhere")
+	}
+	if len(fails) > 0 {
+		v.State, v.Words = delivery.CompositionFail, strings.Join(fails, "; ")
+		return v
+	}
+	v.State = delivery.CompositionPass
+	return v
+}
+
+// CouldRun is, by name, every machine of the mesh not composed that is not assigned a module the change moves or adds
+// (ADR 0537 clause 1): which of them could run it, the bus does not say (capabilities, settings and places are only in
+// the facts snapshot), so each is named as not judged.
+func CouldRun(m Mesh, c Change, composed []string) []string {
+	var out []string
+	for node, modules := range m.Assigned {
+		if slices.Contains(composed, node) {
+			continue
+		}
+		for name := range c.Manifests {
+			if !slices.Contains(modules, name) {
+				out = append(out, node)
+				break
+			}
+		}
+	}
+	sort.Strings(out)
+	return out
+}
+
+// grantsOf is what of a manifest makes grants: its bus declarations and the provisions it requires and offers.
+func grantsOf(man catalogue.Manifest) string {
+	var offers []string
+	for _, o := range man.Provides {
+		offers = append(offers, o.Name)
+	}
+	return fmt.Sprint(man.Requires, offers, man.Reads, man.State, man.Emits, man.Consumes, man.Invokes, man.Claims, man.Grants)
+}
+
+// GrantsAlone is, by name, every machine not composed whose grants alone the change alters (ADR 0537 clause 1): for a
+// moved module whose grants differ from the trunk's, the machines assigned the bus's holder (whose user list carries
+// every module's bus grants) and those assigned a provider of a provision it requires, before or after.
+func GrantsAlone(m Mesh, c Change, composed []string) []string {
+	provisions := map[string]bool{}
+	altered := false
+	for name, man := range c.Manifests {
+		before, had := m.Manifests[name]
+		if had && grantsOf(before) == grantsOf(man) {
+			continue
+		}
+		altered = true
+		for _, r := range append(slices.Clone(man.Requires), before.Requires...) {
+			provisions[r] = true
+		}
+	}
+	if !altered {
+		return nil
+	}
+	var out []string
+	for node, modules := range m.Assigned {
+		if slices.Contains(composed, node) {
+			continue
+		}
+		for _, mod := range modules {
+			man := m.Manifests[mod]
+			if man.ClaimsSeat("mesh-broker") || slices.ContainsFunc(man.Provides, func(o catalogue.Offer) bool { return provisions[o.Name] }) {
+				out = append(out, node)
+				break
+			}
+		}
+	}
+	sort.Strings(out)
+	return out
+}
+
+// withOverlay is base with every manifest of over laid over it, a copy.
+func withOverlay(base, over map[string]catalogue.Manifest) map[string]catalogue.Manifest {
+	out := make(map[string]catalogue.Manifest, len(base)+len(over))
+	for name, man := range base {
+		out[name] = man
+	}
+	for name, man := range over {
+		out[name] = man
+	}
+	return out
+}
+
+func sortedKeys[V any](m map[string]V) []string {
+	out := make([]string, 0, len(m))
+	for k := range m {
+		out = append(out, k)
+	}
+	sort.Strings(out)
+	return out
+}

modules/mesh-delivery-assigner/internal/assign/compose_test.go

@@ -0,0 +1,169 @@
+package assign
+
+import (
+	"encoding/json"
+	"slices"
+	"strconv"
+	"strings"
+	"testing"
+
+	"git.novox.be/novox/mesh-sdk/go/catalogue"
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+)
+
+func meshOf() Mesh {
+	return Mesh{
+		Manifests: map[string]catalogue.Manifest{
+			"mail":  {Module: "mail", Version: "1", Requires: []string{"database"}},
+			"store": {Module: "store", Version: "1", Provides: []catalogue.Offer{{Name: "database"}}},
+			"web":   {Module: "web", Version: "1"},
+		},
+		Assigned: map[string][]string{"ace": {"mail", "store"}, "g14": {"web"}},
+	}
+}
+
+func hasWarning(v delivery.CompositionVerdict, part string) bool {
+	return slices.ContainsFunc(v.Warnings, func(w string) bool { return strings.Contains(w, part) })
+}
+
+// 1297/AC1 (its unit half): a change touching one module on one machine composes that machine alone, passes, names
+// the machine and the mesh-sdk it composed with, and says what it did not judge.
+func TestAChangeOfOneModuleComposesItsMachine(t *testing.T) {
+	c := Change{Group: "g", Heads: "0123456789ab", Manifests: map[string]catalogue.Manifest{"web": {Module: "web", Version: "2"}}}
+	v := Compose(meshOf(), c, "v0.1.14-x", 0)
+	if v.State != delivery.CompositionPass || !slices.Equal(v.Machines, []string{"g14"}) || v.SDK != "v0.1.14-x" {
+		t.Fatalf("composition = %+v, want a pass on g14 alone", v)
+	}
+	if !hasWarning(v, "issue 1461") {
+		t.Errorf("the verdict does not say what it did not judge: %v", v.Warnings)
+	}
+	if _, err := delivery.EncodeCompositionVerdict(v); err != nil {
+		t.Errorf("the verdict cannot be written: %v", err)
+	}
+	// 1953/D7 (ADR 0565 §5, ADR 0502 §4): the group's own pull request's held value at its head is laid and named, judged
+	// against the head's declaration; one of another pull request or another head is not laid.
+	web, err := catalogue.Decode([]byte(`{"module":"web","version":"2","config":{"port":{"type":"number","default":80,"description":"the port, a number","runtime":true}}}`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	kept := map[string][]byte{}
+	for i, k := range []delivery.KeptValue{
+		{Pull: "novox/x#1", Head: "h1", Node: "g14", Module: "web", Key: "port", Value: json.RawMessage(`81`), Approved: "op"},
+		{Pull: "novox/x#2", Head: "h2", Node: "g14", Module: "web", Key: "port", Value: json.RawMessage(`82`)},
+		{Pull: "novox/x#1", Head: "old", Node: "g14", Module: "web", Key: "other", Value: json.RawMessage(`1`)},
+	} {
+		kept[strconv.Itoa(i)], _ = json.Marshal(k)
+	}
+	held := HeldOf(kept, map[string]string{"novox/x#1": "h1"})
+	if len(held) != 1 || string(held[0].Value) != "81" {
+		t.Fatalf("held = %+v, want #1's at its head alone", held)
+	}
+	c = Change{Group: "g", Heads: "0123456789ab", Manifests: map[string]catalogue.Manifest{"web": web}, Held: held}
+	if v := Compose(meshOf(), c, "x", 0); v.State != delivery.CompositionPass || !hasWarning(v, "held value laid: port of web on g14, held for novox/x#1") {
+		t.Errorf("composition = %+v", v)
+	}
+	c.Held[0].Value = json.RawMessage(`"eighty"`)
+	if v := Compose(meshOf(), c, "x", 0); v.State != delivery.CompositionFail || !strings.Contains(v.Words, "does not hold to the head's declaration") {
+		t.Errorf("a held value the declaration refuses: %+v", v)
+	}
+}
+
+// 1297/AC2 and B3c: a change that removes a module a machine runs fails, naming the machine and the module; a machine that
+// composes on the trunk and not with the change fails it, naming the machine and why (the consumer's machine is touched when
+// its provider changes); what was already broken on the trunk is said and fails nothing. One table (three tests merged).
+func TestAChangeThatBreaksAMachineFailsAndWhatWasBrokenFailsNothing(t *testing.T) {
+	broken := meshOf()
+	broken.Manifests["store"] = catalogue.Manifest{Module: "store", Version: "1"}
+	for _, c := range []struct {
+		name  string
+		mesh  Mesh
+		c     Change
+		state string
+		must  func(delivery.CompositionVerdict) bool
+	}{
+		{"removing a module a machine runs", meshOf(), Change{Group: "g", Heads: "0123456789ab", Removed: []string{"web"}}, delivery.CompositionFail,
+			func(v delivery.CompositionVerdict) bool {
+				return v.Machine == "g14" && strings.Contains(v.Words, "g14 runs web")
+			}},
+		{"a machine the change breaks", meshOf(), Change{Group: "g", Heads: "0123456789ab", Manifests: map[string]catalogue.Manifest{"store": {Module: "store", Version: "2"}}},
+			delivery.CompositionFail, func(v delivery.CompositionVerdict) bool {
+				return v.Machine == "ace" && strings.Contains(v.Words, "database")
+			}},
+		{"what was broken before", broken, Change{Group: "g", Heads: "0123456789ab", Manifests: map[string]catalogue.Manifest{"mail": {Module: "mail", Version: "2", Requires: []string{"database"}}}},
+			delivery.CompositionPass, func(v delivery.CompositionVerdict) bool { return hasWarning(v, "on the trunk either") }},
+	} {
+		if v := Compose(c.mesh, c.c, "sdk", 0); v.State != c.state || !c.must(v) {
+			t.Errorf("%s: composition = %+v", c.name, v)
+		}
+	}
+}
+
+// 1297/B3c: an unreadable manifest and a module defined twice fail; more than twelve rebuilt modules warn.
+func TestUnreadableTwiceAndWide(t *testing.T) {
+	c := Change{Group: "g", Heads: "0123456789ab", Unreadable: map[string]string{"web": "unknown field \"scope\""}, Rebuilt: 13}
+	v := Compose(meshOf(), c, "sdk", 0)
+	if v.State != delivery.CompositionFail || !strings.Contains(v.Words, "web cannot be read") || !hasWarning(v, "rebuilds 13 modules") {
+		t.Fatalf("composition = %+v", v)
+	}
+	c = Change{Group: "g", Heads: "0123456789ab", Twice: map[string][]string{"web": {"novox/a", "novox/b"}}, Rebuilt: 12}
+	v = Compose(meshOf(), c, "sdk", 0)
+	if v.State != delivery.CompositionFail || !strings.Contains(v.Words, "web is defined twice") || hasWarning(v, "rebuilds") {
+		t.Fatalf("composition = %+v", v)
+	}
+}
+
+// 1622's criterion as R4g delivers it: a group with a mesh-sdk member is composed with the assigner's own mesh-sdk, and
+// the verdict says so, naming the member's head it did not use; a group without one says nothing of it.
+func TestAGroupWithAnSDKMemberSaysWhichSDKComposedIt(t *testing.T) {
+	c := Change{Group: "g", Heads: "0123456789ab", Manifests: map[string]catalogue.Manifest{"web": {Module: "web", Version: "2"}}, SDKHead: "f625d98713e4"}
+	v := Compose(meshOf(), c, "v0.1.14-own", 0)
+	if !hasWarning(v, "not the group's mesh-sdk head f625d98713e4") || !hasWarning(v, "v0.1.14-own") || !hasWarning(v, "1623") {
+		t.Errorf("the verdict does not say it composed with its own mesh-sdk: %v", v.Warnings)
+	}
+	c.SDKHead = ""
+	if v := Compose(meshOf(), c, "v0.1.14-own", 0); hasWarning(v, "mesh-sdk head") {
+		t.Errorf("a group without a mesh-sdk member says it has one: %v", v.Warnings)
+	}
+}
+
+// 1297/B3a: the machines touched are those running a moved module or a consumer of what it provides; an added module
+// assigned nowhere touches none, and the verdict says so.
+func TestTouched(t *testing.T) {
+	m := meshOf()
+	if got := Touched(m, Change{Manifests: map[string]catalogue.Manifest{"store": m.Manifests["store"]}}); !slices.Equal(got, []string{"ace"}) {
+		t.Errorf("touched by store = %v", got)
+	}
+	m.Assigned["g14"] = append(m.Assigned["g14"], "mail")
+	if got := Touched(m, Change{Manifests: map[string]catalogue.Manifest{"store": m.Manifests["store"]}}); !slices.Equal(got, []string{"ace", "g14"}) {
+		t.Errorf("touched by store with a consumer on g14 = %v", got)
+	}
+	c := Change{Group: "g", Heads: "0123456789ab", Manifests: map[string]catalogue.Manifest{"new": {Module: "new", Version: "1"}}}
+	if v := Compose(m, c, "sdk", 0); len(v.Machines) != 0 || !hasWarning(v, "touches no machine") || v.State != delivery.CompositionPass {
+		t.Errorf("an added module assigned nowhere: %+v", v)
+	}
+}
+
+// ADR 0537 clause 1: every verdict names, by machine, those that could run a moved or added module and are not assigned
+// it, and those whose grants alone the change alters (the bus's machine, a provider of what the module requires), as not
+// judged; shanks, providing what web now requires, is composed and so named in neither. A change that alters no grant
+// names none of the second.
+func TestTheMachinesNotJudgedAreNamed(t *testing.T) {
+	m := meshOf()
+	m.Manifests["bus"] = catalogue.Manifest{Module: "bus", Version: "1", Claims: []catalogue.Claim{{Name: "mesh-broker", Scope: "mesh"}}}
+	m.Manifests["db"] = catalogue.Manifest{Module: "db", Version: "1", Provides: []catalogue.Offer{{Name: "cache"}}}
+	m.Assigned["novox"] = []string{"bus"}
+	m.Assigned["shanks"] = []string{"db"}
+	c := Change{Group: "g", Heads: "0123456789ab", Manifests: map[string]catalogue.Manifest{
+		"web": {Module: "web", Version: "2", Reads: []string{"mesh-controller.assignments"}, Requires: []string{"cache"}}}}
+	v := Compose(m, c, "sdk", 0)
+	if !hasWarning(v, "could run a moved or added module and are not assigned it: ace, novox") || !slices.Contains(v.Machines, "shanks") {
+		t.Errorf("the machines that could run web are not named: %v", v.Warnings)
+	}
+	if !hasWarning(v, "whose grants alone the change alters: novox") {
+		t.Errorf("the machines whose grants alone change are not named: %v", v.Warnings)
+	}
+	c.Manifests["web"] = catalogue.Manifest{Module: "web", Version: "3"}
+	if v := Compose(meshOf(), c, "sdk", 0); hasWarning(v, "grants alone") {
+		t.Errorf("a change altering no grant names machines whose grants change: %v", v.Warnings)
+	}
+}

modules/mesh-delivery-assigner/internal/assign/composer.go

@@ -0,0 +1,263 @@
+package assign
+
+import (
+	"encoding/json"
+	"fmt"
+	"slices"
+	"sort"
+	"strings"
+	"time"
+
+	"git.novox.be/novox/mesh-sdk/go/compose"
+	"git.novox.be/novox/mesh-sdk/go/composer"
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+)
+
+// The cases of a group's composition at its mesh-sdk head: the trunk as it is, and the trunk with the change.
+const (
+	CaseTrunk  = "trunk"
+	CaseChange = "change"
+)
+
+// SDKDir is the directory of mesh-sdk's Go module in its repository, where the composer is built at a head; a reader's
+// composer is built at its repository's root, at the mesh-sdk its go.mod pins.
+const SDKDir = "go"
+
+// The modules whose mesh-sdk reads the manifests a plan sends (ADR 0482 clause 5): the node-engine composes and applies
+// them, the controller being gone (novox/hq ADR 0590, issue 1126). Each is judged at its repository.
+var ReaderModules = map[string]string{"mesh-host": "novox/mesh-host"}
+
+// HeadJob is the compose job of a group with a mesh-sdk member (ADR 0482 clauses 3 and 4, issue 1622): the composer
+// built at the member's head composes the machines the change touches, as the trunk holds them and as the change leaves
+// them, every manifest named by its digest in the indexer's bucket, the seats held from the claims (the assigner's input).
+func HeadJob(m Mesh, c Change) (delivery.ComposeJob, error) {
+	trunk, change := map[string]composer.Manifest{}, map[string]composer.Manifest{}
+	for name, digest := range m.Digests {
+		trunk[name] = composer.Manifest{Digest: digest}
+		change[name] = composer.Manifest{Digest: digest}
+	}
+	for name, digest := range c.Digests {
+		change[name] = composer.Manifest{Digest: digest}
+	}
+	for _, name := range c.Removed {
+		delete(change, name)
+	}
+	in, fromClaims := plainInput(m.Assigned), true
+	if m.Input != nil {
+		// The input the nodes compose from, without its catalogue: the cases carry the manifests (issue 1126).
+		in = *m.Input
+		in.Catalogue = nil
+		fromClaims = len(in.Holdings) == 0
+	}
+	// Each trunk manifest the indexer refused goes in with its verdict, so the composer holds and names it (ADR 0578 §5);
+	// a manifest the change brings has no verdict of the indexer yet, and the checker's judge judges it (§2).
+	changeVerdicts := map[string]delivery.ManifestVerdict{}
+	for name, v := range m.Verdicts {
+		if _, changed := c.Digests[name]; !changed {
+			changeVerdicts[name] = v
+		}
+	}
+	changeCase := composer.Case{Name: CaseChange, Manifests: change, Verdicts: changeVerdicts}
+	req := composer.Request{V: composer.Version, Input: in, Depth: composer.DepthResolve,
+		HoldingsFromClaims: fromClaims, Machines: Touched(m, c),
+		Cases: []composer.Case{{Name: CaseTrunk, Manifests: trunk, Verdicts: m.Verdicts}, changeCase}}
+	return job(SDKRepository, c.SDKHead, SDKDir, req, "the mesh-sdk head of "+c.Group)
+}
+
+// ReaderJob is the compose job that reads the manifests a group changes with the mesh-sdk a reader module pins at
+// commit (ADR 0482 clause 5, issue 1623): no machine is composed, every changed manifest is only read.
+func ReaderJob(c Change, module, repository, commit string) (delivery.ComposeJob, error) {
+	changed := map[string]composer.Manifest{}
+	for name, digest := range c.Digests {
+		changed[name] = composer.Manifest{Digest: digest}
+	}
+	req := composer.Request{V: composer.Version, Cases: []composer.Case{{Name: CaseChange, Manifests: changed}}}
+	return job(repository, commit, delivery.RootPath, req, module+" at "+commit)
+}
+
+func job(repository, commit, dir string, req composer.Request, reader string) (delivery.ComposeJob, error) {
+	raw, err := json.Marshal(req)
+	if err != nil {
+		return delivery.ComposeJob{}, err
+	}
+	return delivery.ComposeJob{Fetch: map[string]any{"repository": repository, "commit": commit}, Dir: dir,
+		Package: composer.Package, Request: raw, Reader: reader}, nil
+}
+
+// plainInput is the composition's input without its catalogue: the nodes by name with what is assigned to them (the
+// composer derives the seats held from the claims, as input does).
+func plainInput(assigned map[string][]string) compose.Input {
+	var in compose.Input
+	nodes := make([]string, 0, len(assigned))
+	for n := range assigned {
+		nodes = append(nodes, n)
+	}
+	sort.Strings(nodes)
+	for _, n := range nodes {
+		in.Nodes = append(in.Nodes, compose.Node{Name: n, Assigned: slices.Clone(assigned[n])})
+	}
+	return in
+}
+
+// Ran is one compose ask's end: its step's state and reason, and the composer's verdict when the step passed.
+type Ran struct {
+	State   string
+	Reason  string
+	Verdict *composer.Verdict
+}
+
+// RanOf reads a compose ask's end from its step value; a step that passed with an answer that cannot be read is a
+// failure, named.
+func RanOf(step delivery.Step) Ran {
+	r := Ran{State: step.State, Reason: step.Reason}
+	if step.State != delivery.StepPassed {
+		return r
+	}
+	var a delivery.ComposeAnswer
+	var v composer.Verdict
+	if err := json.Unmarshal(step.Result, &a); err != nil {
+		return Ran{State: delivery.StepFailed, Reason: "the compose step's answer cannot be read: " + err.Error()}
+	}
+	if err := json.Unmarshal(a.Verdict, &v); err != nil || v.V != composer.Version {
+		return Ran{State: delivery.StepFailed, Reason: fmt.Sprintf("the composer's verdict cannot be read (version %d): %v", v.V, err)}
+	}
+	r.Verdict = &v
+	return r
+}
+
+func caseOf(v *composer.Verdict, name string) (composer.CaseVerdict, bool) {
+	if v == nil {
+		return composer.CaseVerdict{}, false
+	}
+	for _, c := range v.Cases {
+		if c.Name == name {
+			return c, true
+		}
+	}
+	return composer.CaseVerdict{}, false
+}
+
+// Reader is one module whose mesh-sdk reads the group's manifests, at the commit judged: the group's member head when
+// the group holds one in its repository, else a build its node runs.
+type Reader struct {
+	Module, Commit string
+	Member         bool
+	Ran            Ran
+}
+
+// FromComposer is the composition check of a group with a mesh-sdk member, judged from the composer built at its head
+// (ADR 0482 clauses 3 to 5, issues 1622 and 1623): the same failures as Compose, read from the composer's two cases, the
+// verdict naming the mesh-sdk the composer was built with; a trunk manifest the head's mesh-sdk cannot decode fails too
+// (the group would deliver a reader that cannot read it). A reader that cannot read a changed manifest is a warning,
+// never a failure: it decodes leniently and sets a field it does not know aside (novox/hq ADR 0578 §6, which changes
+// ADR 0482 §5).
+func FromComposer(m Mesh, c Change, head Ran, readers []Reader, took time.Duration) delivery.CompositionVerdict {
+	v := delivery.CompositionVerdict{Group: c.Group, Heads: c.Heads, SDK: "mesh-sdk " + c.SDKHead, Took: took.Milliseconds()}
+	machines := Touched(m, c)
+	v.Machines = machines
+	var fails []string
+	if head.State != delivery.StepPassed {
+		v.Words = fmt.Sprintf("the composer at mesh-sdk %s did not run: %s %s", c.SDKHead, head.State, head.Reason)
+		v.State = delivery.CompositionFail
+		return v
+	}
+	if head.Verdict.SDK != "" {
+		v.SDK = head.Verdict.SDK
+	}
+	trunk, okT := caseOf(head.Verdict, CaseTrunk)
+	change, okC := caseOf(head.Verdict, CaseChange)
+	if !okT || !okC {
+		v.State, v.Words = delivery.CompositionFail, "the composer's verdict holds no trunk or no change case"
+		return v
+	}
+	failAt := func(machine, words string) {
+		if v.Machine == "" && machine != "" {
+			v.Machine = machine
+		}
+		fails = append(fails, words)
+	}
+	for _, name := range sortedKeys(c.Digests) {
+		if r := change.Manifests[name]; !r.Accepted {
+			failAt("", fmt.Sprintf("the manifest of %s cannot be read by mesh-sdk %s: %s", name, c.SDKHead, r.Refused))
+		}
+	}
+	for _, name := range sortedKeys(trunk.Manifests) {
+		if _, changed := c.Digests[name]; changed || slices.Contains(c.Removed, name) || trunk.Manifests[name].Accepted {
+			continue
+		}
+		if _, before := m.Unreadable[name]; before {
+			continue // already unreadable on the trunk: not the group's doing
+		}
+		failAt("", fmt.Sprintf("mesh-sdk %s refuses the trunk's manifest of %s, which the group does not change: %s", c.SDKHead, name, trunk.Manifests[name].Refused))
+	}
+	for _, name := range sortedKeys(c.Twice) {
+		failAt("", fmt.Sprintf("%s is defined twice, in %s", name, strings.Join(c.Twice[name], " and ")))
+	}
+	for _, node := range machines {
+		for _, name := range c.Removed {
+			if slices.Contains(m.Assigned[node], name) {
+				failAt(node, fmt.Sprintf("%s runs %s, which the change removes from its source", node, name))
+			}
+		}
+		before, now := trunk.Machines[node], change.Machines[node]
+		switch {
+		case now.Composes:
+		case !before.Composes:
+			v.Warnings = append(v.Warnings, fmt.Sprintf("%s does not compose on the trunk either, so the change is not blamed: %s", node, before.Reason))
+		default:
+			failAt(node, fmt.Sprintf("%s composes on the trunk and not with the change: %s", node, now.Reason))
+		}
+	}
+	readerFails, readerWarnings := judgeReaders(c, change, readers)
+	fails = append(fails, readerFails...)
+	v.Warnings = append(v.Warnings, readerWarnings...)
+	if m.InputUnread != "" {
+		v.Warnings = append(v.Warnings, "composed over the nodes and their assignments alone: the input the nodes compose from "+
+			"cannot be read from the bus ("+m.InputUnread+")")
+	}
+	return finish(v, m, c, machines, fails)
+}
+
+// NoComposer says whether a compose step failed because the mesh-sdk it was built at has no composer command (a mesh-sdk
+// from before issue 1621): Go's words for a package its module does not hold.
+func NoComposer(reason string) bool {
+	for _, words := range []string{"cannot find package", "no required module provides package", "is not in std", "cannot find module providing package", "does not contain package"} {
+		if strings.Contains(reason, words) {
+			return true
+		}
+	}
+	return false
+}
+
+func judgeReaders(c Change, head composer.CaseVerdict, readers []Reader) (fails, warnings []string) {
+	for _, r := range readers {
+		at := r.Module + " at " + r.Commit
+		if r.Member {
+			at = r.Module + "'s member head " + r.Commit
+		}
+		if r.Ran.State != delivery.StepPassed {
+			if NoComposer(r.Ran.Reason) {
+				warnings = append(warnings, fmt.Sprintf("not judged whether %s reads the group's manifests: the mesh-sdk it pins has no "+
+					"composer command (before issue 1621)", at))
+				continue
+			}
+			fails = append(fails, fmt.Sprintf("the composer of the mesh-sdk %s pins did not run: %s %s", at, r.Ran.State, r.Ran.Reason))
+			continue
+		}
+		read, ok := caseOf(r.Ran.Verdict, CaseChange)
+		if !ok {
+			fails = append(fails, fmt.Sprintf("the composer of the mesh-sdk %s pins answered no change case", at))
+			continue
+		}
+		for _, name := range sortedKeys(c.Digests) {
+			if !head.Manifests[name].Accepted || read.Manifests[name].Accepted {
+				continue
+			}
+			// ADR 0578 §6: no longer a failure; the reader sets what it does not know aside, and the part that needs it takes
+			// the newer package (ADR 0573 §2).
+			warnings = append(warnings, fmt.Sprintf("the manifest of %s uses what %s (mesh-sdk %s) cannot read: %s; it reads the rest "+
+				"once it takes mesh-sdk %s", name, at, r.Ran.Verdict.SDK, read.Manifests[name].Refused, c.SDKHead))
+		}
+	}
+	return fails, warnings
+}

modules/mesh-delivery-assigner/internal/assign/composer_test.go

@@ -0,0 +1,225 @@
+package assign
+
+import (
+	"encoding/json"
+	"slices"
+	"strings"
+	"testing"
+	"time"
+
+	"git.novox.be/novox/mesh-sdk/go/catalogue"
+	"git.novox.be/novox/mesh-sdk/go/compose"
+	"git.novox.be/novox/mesh-sdk/go/composer"
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+)
+
+var testTime = time.Date(2026, 10, 24, 3, 0, 0, 0, time.UTC)
+
+const sdkHead = "1111111111111111111111111111111111111111"
+
+// raws are the manifests of meshOf as their repositories hold them, by digest, as the indexer keeps them; `web2` is web
+// with a field `shares` that the assigner's own mesh-sdk does not read (the shape of issue 1593).
+var raws = map[string]string{
+	"d-mail":  `{"module": "mail", "version": "1", "requires": ["postgres-database"]}`,
+	"d-store": `{"module": "store", "version": "1", "provides": [{"name": "postgres-database"}]}`,
+	"d-web":   `{"module": "web", "version": "1"}`,
+	"d-web2":  `{"module": "web", "version": "2", "shares": ["photos"]}`,
+}
+
+// asTheHeadReads is how mesh-sdk at the group's head reads each manifest: as the assigner's own reads it, but for the
+// field it adds, which it accepts. The head's composer is built and run by the Go build module (ADR 0482 clause 4); here
+// its verdict is made by mesh-sdk's composer.Run over the same request, with `web2` read as the head reads it.
+var asTheHeadReads = map[string]string{"d-web2": `{"module": "web", "version": "2"}`}
+
+func digestedMesh() Mesh {
+	m := meshOf()
+	m.Digests = map[string]string{"mail": "d-mail", "store": "d-store", "web": "d-web"}
+	return m
+}
+
+// webShares is a group of mesh-sdk and mesh-catalog whose catalogue member gives web the field only the SDK head reads:
+// the assigner's own reader refuses it (Unreadable), as the indexer's manifest is read in world.change.
+func webShares(members map[string]string) Change {
+	// As an older reader refused it; the field set aside by the lenient decoder is named the same (ADR 0578 §6).
+	m, _ := catalogue.Decode([]byte(raws["d-web2"]))
+	return Change{Group: "g", Heads: "0123456789ab", SDKHead: sdkHead, Manifests: map[string]catalogue.Manifest{},
+		Unreadable: map[string]string{"web": m.SetAside()}, Digests: map[string]string{"web": "d-web2"}, Members: members}
+}
+
+// run is the composer's step for a job, as the build module answers it: the request filled from the indexer's digests
+// (with read standing in for how that mesh-sdk reads a digest), run, and its verdict put in a passed step.
+func run(t *testing.T, job delivery.ComposeJob, read map[string]string) Ran {
+	t.Helper()
+	req, err := composer.Decode(job.Request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := composer.Fill(&req, func(d string) ([]byte, error) {
+		if r, ok := read[d]; ok {
+			return []byte(r), nil
+		}
+		return []byte(raws[d]), nil
+	}); err != nil {
+		t.Fatal(err)
+	}
+	v, err := composer.Run(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	v.SDK = "(devel) " + job.Fetch["commit"].(string)
+	vr, _ := json.Marshal(v)
+	ans, _ := json.Marshal(delivery.ComposeAnswer{Built: true, Key: "composer-0", Verdict: vr})
+	return RanOf(delivery.Step{State: delivery.StepPassed, Result: ans})
+}
+
+// 1622/AC1: a group holding a mesh-sdk pull request is composed by the composer built at the member's head: the job
+// fetches mesh-sdk at that head, builds mesh-sdk's composer command in its Go module, and hands it the trunk and the
+// change by digest, never the manifests' bytes, composing the machines the change touches.
+func TestAGroupWithAnSDKMemberAsksTheComposerAtItsHead(t *testing.T) {
+	c := webShares(nil)
+	job, err := HeadJob(digestedMesh(), c)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if job.Fetch["repository"] != SDKRepository || job.Fetch["commit"] != sdkHead || job.Dir != "go" || job.Package != composer.Package {
+		t.Fatalf("job = %+v", job)
+	}
+	ask := delivery.StepAsk{ID: "mh3k2x9qa1b2c5", Kind: delivery.AskCheck, Language: delivery.AskGo, Asker: "mesh-delivery-assigner",
+		At: testTime, Compose: &job}
+	if _, err := delivery.EncodeStepAsk(ask); err != nil {
+		t.Fatalf("the ask is refused by its layout: %v", err)
+	}
+	req, err := composer.Decode(job.Request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(req.Cases) != 2 || req.Cases[0].Name != CaseTrunk || req.Cases[1].Name != CaseChange {
+		t.Fatalf("cases = %+v", req.Cases)
+	}
+	if req.Cases[0].Manifests["web"].Digest != "d-web" || req.Cases[1].Manifests["web"].Digest != "d-web2" || len(req.Cases[1].Manifests["web"].Raw) != 0 {
+		t.Errorf("the cases do not name web by its trunk and its change digest: %+v", req.Cases)
+	}
+	if !slices.Equal(req.Machines, []string{"g14"}) || req.Depth != composer.DepthResolve || !req.HoldingsFromClaims {
+		t.Errorf("request = machines %v, depth %q, holdings from claims %v", req.Machines, req.Depth, req.HoldingsFromClaims)
+	}
+
+	// 1126 (ADR 0547 §2, ADR 0549 §3): once the catalogue places the nodes, the check composes over the input the nodes
+	// compose from (frombus), its catalogue left to the cases, and the seats held as placement says.
+	m := digestedMesh()
+	m.Input = &compose.Input{Catalogue: map[string]catalogue.Manifest{"web": {Module: "web"}},
+		Nodes:    []compose.Node{{Name: "g14", Assigned: []string{"web"}, Place: compose.Place{Endpoint: "g14.example:51820"}}},
+		Holdings: []catalogue.Held{{Claim: "web-seat", Scope: "mesh", Node: "g14", Module: "web"}}}
+	placedJob, err := HeadJob(m, c)
+	if err != nil {
+		t.Fatal(err)
+	}
+	placed, err := composer.Decode(placedJob.Request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if placed.Input.Catalogue != nil || len(placed.Input.Nodes) != 1 || placed.Input.Nodes[0].Place.Endpoint != "g14.example:51820" ||
+		len(placed.Input.Holdings) != 1 || placed.HoldingsFromClaims {
+		t.Errorf("the placed check's request = %+v, holdings from claims %v", placed.Input, placed.HoldingsFromClaims)
+	}
+}
+
+// 1622/AC2, AC3: a catalogue member using a field only the SDK head reads passes with the head's composer, and the
+// verdict names the mesh-sdk the composer was built with; with the assigner's own mesh-sdk it fails.
+func TestAFieldTheGroupAddsPassesWithTheHeadsComposer(t *testing.T) {
+	c := webShares(map[string]string{"novox/mesh-controller": "2222222222222222222222222222222222222222"})
+	job, _ := HeadJob(digestedMesh(), c)
+	head := run(t, job, asTheHeadReads)
+	v := FromComposer(digestedMesh(), c, head, nil, 0)
+	if v.State != delivery.CompositionPass || v.SDK != "(devel) "+sdkHead || !slices.Equal(v.Machines, []string{"g14"}) {
+		t.Fatalf("with the head's composer: %+v", v)
+	}
+	if _, err := delivery.EncodeCompositionVerdict(v); err != nil {
+		t.Errorf("the verdict cannot be written: %v", err)
+	}
+	own := Compose(digestedMesh(), c, "v0.1.14-own", 0)
+	if own.State != delivery.CompositionFail || !strings.Contains(own.Words, "shares") {
+		t.Fatalf("with the assigner's own mesh-sdk: %+v, want a fail naming the field", own)
+	}
+}
+
+// 1623/AC1, AC2 as ADR 0578 §6 changes them: the group of mesh-sdk and mesh-catalog adding and using a field, without a
+// controller member, passes with a warning naming the field and mesh-controller, whose running build pins an older
+// mesh-sdk that cannot read it: a reader sets a field it does not know aside, so it fails nothing. With a controller
+// member pinned to the SDK head it passes with no such warning.
+func TestAFieldTheRunningControllerCannotReadIsAWarning(t *testing.T) {
+	c := webShares(nil)
+	job, _ := HeadJob(digestedMesh(), c)
+	head := run(t, job, asTheHeadReads)
+	running := "3333333333333333333333333333333333333333"
+	rjob, err := ReaderJob(c, "mesh-controller", "novox/mesh-controller", running)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rjob.Fetch["commit"] != running || rjob.Dir != delivery.RootPath {
+		t.Fatalf("reader job = %+v", rjob)
+	}
+	// The running controller's mesh-sdk, older than the lenient decoder, refuses web2 for its field.
+	old := Ran{State: delivery.StepPassed, Verdict: &composer.Verdict{V: composer.Version, SDK: "v0.1.13", Cases: []composer.CaseVerdict{
+		{Name: CaseChange, Manifests: map[string]composer.ManifestRead{"web": {Refused: `json: unknown field "shares"`}}}}}}
+	v := FromComposer(digestedMesh(), c, head, []Reader{{Module: "mesh-controller", Commit: running, Ran: old}}, 0)
+	if v.State != delivery.CompositionPass || !hasWarning(v, "shares") || !hasWarning(v, "mesh-controller at "+running) {
+		t.Fatalf("without a controller member: %+v, want a pass warning of the field and mesh-controller", v)
+	}
+	member := "2222222222222222222222222222222222222222"
+	pinned := run(t, rjob, asTheHeadReads)
+	v = FromComposer(digestedMesh(), c, head, []Reader{{Module: "mesh-controller", Commit: member, Member: true, Ran: pinned}}, 0)
+	if v.State != delivery.CompositionPass {
+		t.Fatalf("with a controller member pinned to the head: %+v, want a pass", v)
+	}
+}
+
+// 1623: a reader whose mesh-sdk has no composer command (before issue 1621) is said, not failed; a reader's composer that
+// failed for another cause fails the group, loud.
+func TestAReaderWithNoComposerIsSaidAndAnotherFailureFails(t *testing.T) {
+	c := webShares(nil)
+	job, _ := HeadJob(digestedMesh(), c)
+	head := run(t, job, asTheHeadReads)
+	none := Ran{State: delivery.StepFailed, Reason: "go build: no required module provides package git.novox.be/novox/mesh-sdk/go/cmd/mesh-compose"}
+	v := FromComposer(digestedMesh(), c, head, []Reader{{Module: "mesh-host", Commit: "abc", Ran: none}}, 0)
+	if v.State != delivery.CompositionPass || !hasWarning(v, "mesh-host at abc") || !hasWarning(v, "before issue 1621") {
+		t.Fatalf("a reader with no composer: %+v", v)
+	}
+	broke := Ran{State: delivery.StepFailed, Reason: "the fetch could not reach the forge"}
+	v = FromComposer(digestedMesh(), c, head, []Reader{{Module: "mesh-host", Commit: "abc", Ran: broke}}, 0)
+	if v.State != delivery.CompositionFail || !strings.Contains(v.Words, "could not reach the forge") {
+		t.Fatalf("a reader whose composer failed: %+v", v)
+	}
+}
+
+// 1622: the head's composer that did not run fails the composition naming why, never passes it; a trunk manifest the
+// head's mesh-sdk refuses fails it too, since the group would deliver a reader that refuses it.
+func TestTheHeadsComposerFailingOrRefusingTheTrunkFails(t *testing.T) {
+	c := webShares(nil)
+	v := FromComposer(digestedMesh(), c, Ran{State: delivery.StepRefused, Reason: "the guard refuses it"}, nil, 0)
+	if v.State != delivery.CompositionFail || !strings.Contains(v.Words, "the guard refuses it") || !strings.Contains(v.Words, sdkHead) {
+		t.Fatalf("a head composer that did not run: %+v", v)
+	}
+	job, _ := HeadJob(digestedMesh(), c)
+	strict := map[string]string{"d-web2": asTheHeadReads["d-web2"], "d-mail": `{"module": "mail", "version": "1", "requires": "x"}`}
+	v = FromComposer(digestedMesh(), c, run(t, job, strict), nil, 0)
+	if v.State != delivery.CompositionFail || !strings.Contains(v.Words, "refuses the trunk's manifest of mail") {
+		t.Fatalf("a head that refuses a trunk manifest: %+v", v)
+	}
+	// ADR 0578 §5: a trunk manifest the indexer refused goes into the composer's input with its verdict, in both cases;
+	// the composer holds and names it, and the group is not blamed for it.
+	m := digestedMesh()
+	m.Verdicts = map[string]delivery.ManifestVerdict{"mail": {Module: "mail", State: delivery.VerdictRefused, Problems: []string{"it is wrong"}}}
+	m.Unreadable = map[string]string{"mail": m.Verdicts["mail"].Why()}
+	job, _ = HeadJob(m, c)
+	var req composer.Request
+	if err := json.Unmarshal(job.Request, &req); err != nil || !req.Cases[0].Verdicts["mail"].Refused() || !req.Cases[1].Verdicts["mail"].Refused() {
+		t.Fatalf("the request carries no verdict: %+v %v", req.Cases, err)
+	}
+	head := run(t, job, asTheHeadReads)
+	if trunk, _ := caseOf(head.Verdict, CaseTrunk); !strings.Contains(trunk.Manifests["mail"].Refused, "refused the manifest of mail: it is wrong") {
+		t.Fatalf("the composer did not name the refusal: %+v", trunk.Manifests["mail"])
+	}
+	if v = FromComposer(m, c, head, nil, 0); v.State != delivery.CompositionPass {
+		t.Fatalf("a refusal on the trunk blamed the group: %+v", v)
+	}
+}

modules/mesh-delivery-assigner/internal/assign/findings.go

@@ -6,8 +6,7 @@ import (
 	"strings"
 	"time"
 
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
-	oc "git.novox.be/novox/mesh-contracts/go/seats/operatorchannel"
+	"git.novox.be/novox/mesh-sdk/go/asks"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 	"git.novox.be/novox/mesh-sdk/go/health"
 )
@@ -25,7 +24,7 @@ var FindingsBucket = health.FindingsBucket(delivery.AssignerModule)
 // FindingOf is a said condition as a finding: its key `<scope>.<id>.<kind>`, from the condition's own key
 // `mesh-delivery-assigner.<kind>.<id…>` (the subject's id when the key names none), its words unchanged. raised is false for
 // a clear, whose key is to be deleted; value is nil then.
-func FindingOf(c oc.Condition, at time.Time) (key string, value []byte, raised bool, err error) {
+func FindingOf(c asks.Condition, at time.Time) (key string, value []byte, raised bool, err error) {
 	rest, ok := strings.CutPrefix(c.Key, delivery.AssignerModule+".")
 	if !ok || rest == "" {
 		return "", nil, false, fmt.Errorf("the condition %q is not the assigner's", c.Key)
@@ -39,10 +38,10 @@ func FindingOf(c oc.Condition, at time.Time) (key string, value []byte, raised b
 		scope = health.ScopeModule
 	}
 	key = health.FindingKey(scope, id, kind)
-	if c.State == occ.StateCleared {
+	if c.State == asks.StateCleared {
 		return key, nil, false, nil
 	}
-	if c.State != occ.StateRaised {
+	if c.State != asks.StateRaised {
 		return "", nil, false, fmt.Errorf("the condition %s is neither raised nor cleared", c.Key)
 	}
 	summary := c.Summary
@@ -71,8 +70,8 @@ type Findings struct {
 // Say is say with each condition written as a finding (or its finding deleted), which the condition keeper carries, the
 // one source since the controller's end (novox/hq ADR 0590 §3); said straight to the router only where there is no
 // findings bucket at all. A finding that cannot be written is the error.
-func (f Findings) Say(say func(oc.Condition) error) func(oc.Condition) error {
-	return func(c oc.Condition) error {
+func (f Findings) Say(say func(asks.Condition) error) func(asks.Condition) error {
+	return func(c asks.Condition) error {
 		var errs []error
 		if f.Put != nil {
 			now := time.Now

modules/mesh-delivery-assigner/internal/assign/placement.go

@@ -3,21 +3,20 @@ package assign
 import (
 	"strings"
 
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
-	oc "git.novox.be/novox/mesh-contracts/go/seats/operatorchannel"
+	"git.novox.be/novox/mesh-sdk/go/asks"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 )
 
 // SeatWaitsCondition is the assigner's word on the seat mesh-placement while a state of the seat is not bound (ADR 0567
 // §1): raised naming each, cleared when none is left.
-func SeatWaitsCondition(unbound []string) oc.Condition {
+func SeatWaitsCondition(unbound []string) asks.Condition {
 	key := delivery.AssignerModule + ".seat-states"
-	subject := oc.ConditionSubject{Scope: "module", ID: delivery.AssignerModule}
+	subject := asks.Scope{Scope: "module", ID: delivery.AssignerModule}
 	if len(unbound) == 0 {
-		return oc.Condition{Key: key, Subject: subject, State: occ.StateCleared, Resolved: "the seat mesh-placement holds all its states."}
+		return asks.Condition{Key: key, Subject: subject, State: asks.StateCleared, Resolved: "the seat mesh-placement holds all its states."}
 	}
 	why := "the seat waits for its states: " + strings.Join(unbound, ", ") + " are not on the bus or not granted yet"
-	return oc.Condition{Key: key, Severity: occ.SeverityWarning, Subject: subject, State: occ.StateRaised,
+	return asks.Condition{Key: key, Severity: asks.SeverityWarning, Subject: subject, State: asks.StateRaised,
 		Summary: "the seat waits for its states", Headline: "the seat waits for its states",
-		Explanation: occ.NothingToDo + " " + why + "; each is bound at the next pass once it is, with no restart."}
+		Explanation: asks.NothingToDo + " " + why + "; each is bound at the next pass once it is, with no restart."}
 }

modules/mesh-delivery-assigner/internal/assign/policy.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"time"
 
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
+	"git.novox.be/novox/mesh-sdk/go/asks"
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 	"git.novox.be/novox/mesh-sdk/go/health"
@@ -16,7 +16,7 @@ import (
 
 // A person's upgrade policy is the assigner's (novox/hq ADR 0565 §7, §8, issue 1953 D4, D5): kept in its state `policies`, one
 // key per module, set and taken back through `mesh-wants.upgrade`. Every reader takes one derivation, mesh-sdk's
-// catalogue.Upgrade: a person's choice over the module's word, its irreplaceable data and the default, the bus as any module (ADR 0601 §1).
+// catalogue.Upgrade: a person's choice over the module's word, its irreplaceable data and the default, the bus never rolled.
 
 // PoliciesBucket is the assigner's state `policies`.
 var PoliciesBucket = delivery.AssignerModule + "_" + delivery.AssignerPoliciesState
@@ -70,7 +70,7 @@ func ProvisionFailedFinding(key string, p provisions.Provision, at time.Time) ([
 	return health.EncodeFinding(health.Finding{Key: ProvisionFailedKey(key), Kind: KindProvisionFailed,
 		Subject:  health.Subject{Scope: health.ScopeProvider, ID: key, Machine: p.Consumer.Node, Also: also(p.Provider.Node, p.Consumer.Node)},
 		Severity: health.Warning, Summary: summary, Headline: clipHeadline(p.Consumer.Module + " waits for a provision that failed"),
-		Explanation: occ.NothingToDo + " " + summary + ". It clears once the provider provides it.",
+		Explanation: asks.NothingToDo + " " + summary + ". It clears once the provider provides it.",
 		Resolved:    p.Provision + " for " + p.Consumer.Module + " is provided", Evidence: []health.Evidence{{At: at.UTC(), Said: p.Why}},
 		Source: "assigner." + KindProvisionFailed, Observer: delivery.AssignerModule, At: at.UTC()})
 }
@@ -102,7 +102,7 @@ func ProvisionMissingFinding(key string, bound time.Duration, at time.Time) ([]b
 	return health.EncodeFinding(health.Finding{Key: ProvisionMissingKey(key), Kind: KindProvisionMissing,
 		Subject:  health.Subject{Scope: health.ScopeProvider, ID: key, Machine: node},
 		Severity: health.Warning, Summary: summary, Headline: clipHeadline(module + " on " + node + " lacks " + provision),
-		Explanation: occ.NothingToDo + " " + summary + ". It clears once the provision has its key.",
+		Explanation: asks.NothingToDo + " " + summary + ". It clears once the provision has its key.",
 		Resolved:    provision + " for " + module + " on " + node + " has its key", Evidence: []health.Evidence{{At: at.UTC(), Said: summary}},
 		Source: "assigner." + KindProvisionMissing, Observer: delivery.AssignerModule, At: at.UTC()})
 }
@@ -122,7 +122,7 @@ func UnplacedFinding(node string, at time.Time) ([]byte, error) {
 	return health.EncodeFinding(health.Finding{Key: UnplacedKey(node), Kind: KindUnplaced,
 		Subject: health.Subject{Scope: health.ScopeMachine, ID: node, Machine: node}, Severity: health.Warning, Summary: summary,
 		Headline: clipHeadline(node + " has no placement"), Needs: "place it with mesh-placement.propose.",
-		Explanation: occ.NeedsYou + "place it with mesh-placement.propose. " + summary + ".",
+		Explanation: asks.NeedsYou + "place it with mesh-placement.propose. " + summary + ".",
 		Resolved:    node + " is placed", Evidence: []health.Evidence{{At: at.UTC(), Said: summary}},
 		Source: "assigner." + KindUnplaced, Observer: delivery.AssignerModule, At: at.UTC()})
 }

modules/mesh-delivery-assigner/internal/assign/put.go

@@ -4,8 +4,7 @@ import (
 	"fmt"
 	"time"
 
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
-	oc "git.novox.be/novox/mesh-contracts/go/seats/operatorchannel"
+	"git.novox.be/novox/mesh-sdk/go/asks"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 )
 
@@ -211,15 +210,15 @@ func PutAsking(p delivery.Put) int {
 }
 
 // PutAct is the act a bus put's yes binds and that is performed when its want is written.
-func PutAct(node, module, fp, composed string) occ.Act {
-	return occ.Act{"put": "want", "node": node, "module": module, "fp": fp, "composed": composed}
+func PutAct(node, module, fp, composed string) asks.Act {
+	return asks.Act{"put": "want", "node": node, "module": module, "fp": fp, "composed": composed}
 }
 
 // PutAsk is the ask about a put's move (ADR 0546 clauses 7 and 8), under the record ask's key of the composition so the
 // teller relays it and its answer as any record ask's. For the bus its yes is of level approve and binds the act, so only a
 // channel that proves who answered takes it (ADR 0259), never the view.
 func PutAsk(key, node, module string, p delivery.Put, d delivery.ComposedDigest, bus bool, now time.Time) (delivery.AssignerAsk, error) {
-	yes := oc.Option{ID: OptionYes, Label: "Yes, put it", Does: "the node is told to apply " + module + " at " + short(p.FP), Level: occ.Acknowledge}
+	yes := asks.Option{ID: OptionYes, Label: "Yes, put it", Does: "the node is told to apply " + module + " at " + short(p.FP), Level: asks.Acknowledge}
 	what := map[delivery.Judgement]string{
 		delivery.JudgedRecreates: "recreates a container",
 		delivery.JudgedMovesData: "moves the module's data",
@@ -228,26 +227,26 @@ func PutAsk(key, node, module string, p delivery.Put, d delivery.ComposedDigest,
 		delivery.JudgedUnchanged: "changes nothing the node runs",
 	}[d.Judgement]
 	explanation := fmt.Sprintf("Asked to put %s at version %s on %s: %s. The move %s.", module, short(p.FP), node, p.Why, what)
-	expires := occ.FormatTime(now.Add(7 * 24 * time.Hour))
+	expires := now.Add(7 * 24 * time.Hour)
 	if bus {
-		binds, err := occ.ActDigest(PutAct(node, module, p.FP, d.Digest))
+		binds, err := asks.ActDigest(PutAct(node, module, p.FP, d.Digest))
 		if err != nil {
 			return delivery.AssignerAsk{}, err
 		}
-		yes.Level, yes.Binds = occ.Approve, binds
+		yes.Level, yes.Binds = asks.Approve, binds
 		yes.Does = "the bus's streams are snapshotted, then " + node + " is told to apply the bus at " + short(p.FP)
 		explanation += " It is the mesh's bus: every module reconnects while it restarts, and its streams are snapshotted first."
-		expires = occ.FormatTime(now.Add(occ.ApproveLasts))
+		expires = now.Add(asks.ApproveLasts)
 	}
-	return assignerAsk(PutAsking(p), oc.Ask{
+	return delivery.AssignerAsk{Ask: asks.Ask{
 		ID:          delivery.AskingID(key, PutAsking(p)),
 		Headline:    fmt.Sprintf("Put %s on %s?", module, node),
 		Explanation: explanation,
-		Options: []oc.Option{yes,
-			{ID: OptionNo, Label: "No", Does: "the node keeps what it runs, and the put is refused", Level: occ.Acknowledge}},
-		Who:      occ.Operator,
+		Options: []asks.Option{yes,
+			{ID: OptionNo, Label: "No", Does: "the node keeps what it runs, and the put is refused", Level: asks.Acknowledge}},
+		Who:      asks.Operator,
 		Expires:  expires,
 		OnExpiry: "the node keeps what it runs",
 		About:    key,
-	}), nil
+	}, Asking: PutAsking(p)}, nil
 }

modules/mesh-delivery-assigner/internal/assign/seat.go

@@ -7,8 +7,7 @@ import (
 	"strings"
 	"time"
 
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
-	oc "git.novox.be/novox/mesh-contracts/go/seats/operatorchannel"
+	"git.novox.be/novox/mesh-sdk/go/asks"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 )
 
@@ -171,15 +170,15 @@ const (
 
 // CallClearedCondition clears the condition of a refused controller call a previous process raised, for its pair (node and
 // module, or node and provision for a pin).
-func CallClearedCondition(kind, node, module string) oc.Condition {
-	return oc.Condition{Key: delivery.AssignerModule + "." + kind + "." + node + "." + module,
-		Subject: oc.ConditionSubject{Scope: "module", ID: module, Machine: node}, State: occ.StateCleared,
+func CallClearedCondition(kind, node, module string) asks.Condition {
+	return asks.Condition{Key: delivery.AssignerModule + "." + kind + "." + node + "." + module,
+		Subject: asks.Scope{Scope: "module", ID: module, Machine: node}, State: asks.StateCleared,
 		Resolved: "the assigner calls no verb of the controller any more: placement is the one source."}
 }
 
 // PlacementAct is the act an approved proposal's yes binds: writing exactly its changes at its base revisions.
-func PlacementAct(p delivery.PlacementProposal) occ.Act {
-	return occ.Act{"placement": "write", "proposal": p.ID, "changes": delivery.ChangesDigest(p)}
+func PlacementAct(p delivery.PlacementProposal) asks.Act {
+	return asks.Act{"placement": "write", "proposal": p.ID, "changes": delivery.ChangesDigest(p)}
 }
 
 // PlacementAsking is a proposal's asking number: each judging that raises its ask again (again, a key moved) is
@@ -191,29 +190,29 @@ func PlacementAsking(p delivery.PlacementProposal, at time.Time) int {
 // PlacementAsk is the authorising ask about a proposal (§5): an Approve that binds its act, so only a channel that
 // proves who answered takes it, with the brief of the verdict by node (judge.Brief) as its explanation.
 func PlacementAsk(key string, p delivery.PlacementProposal, brief string, asking int, now time.Time) (delivery.AssignerAsk, error) {
-	binds, err := occ.ActDigest(PlacementAct(p))
+	binds, err := asks.ActDigest(PlacementAct(p))
 	if err != nil {
 		return delivery.AssignerAsk{}, err
 	}
 	nodes := p.Nodes()
 	headline := fmt.Sprintf("Change placement on %s?", strings.Join(nodes, ", "))
-	if n := len([]rune(headline)); n > occ.HeadlineLength {
+	if n := len([]rune(headline)); n > asks.HeadlineLength {
 		headline = fmt.Sprintf("Change placement on %d machines?", len(nodes))
 	}
-	return assignerAsk(asking, oc.Ask{
+	return delivery.AssignerAsk{Ask: asks.Ask{
 		ID:          delivery.AskingID(key, asking),
 		Headline:    headline,
 		Explanation: brief,
-		Options: []oc.Option{
+		Options: []asks.Option{
 			{ID: OptionYes, Label: "Approve", Does: "the placement of " + strings.Join(nodes, ", ") + " is written as proposed",
-				Level: occ.Approve, Binds: binds},
-			{ID: OptionNo, Label: "Decline", Does: "nothing is written, and the proposal ends", Level: occ.Acknowledge},
+				Level: asks.Approve, Binds: binds},
+			{ID: OptionNo, Label: "Decline", Does: "nothing is written, and the proposal ends", Level: asks.Acknowledge},
 		},
-		Who:      occ.Operator,
-		Expires:  occ.FormatTime(now.Add(occ.ApproveLasts)),
+		Who:      asks.Operator,
+		Expires:  now.Add(asks.ApproveLasts),
 		OnExpiry: "nothing is written, and the proposal ends",
 		About:    key,
-	}), nil
+	}, Asking: asking}, nil
 }
 
 // Rest is what a proposal leaves to write once the keys of written are: its changes of the other nodes, to be laid again

modules/mesh-delivery-assigner/internal/assign/seat_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 	"time"
 
-	occ "git.novox.be/novox/mesh-contracts/go/clients/operatorchannelclient"
+	"git.novox.be/novox/mesh-sdk/go/asks"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 )
 
@@ -81,7 +81,7 @@ func TestThePlacementSeatDecides(t *testing.T) {
 	// The seat says it waits while one of its states is not bound, naming it, and clears once all are.
 	for _, unbound := range [][]string{{delivery.PlacementPulsesBucket}, nil} {
 		c := SeatWaitsCondition(unbound)
-		if _, err := occ.EncodeCondition(c); err != nil || (len(unbound) > 0) != (c.State == occ.StateRaised) ||
+		if _, err := asks.EncodeCondition(c); err != nil || (len(unbound) > 0) != (c.State == asks.StateRaised) ||
 			(len(unbound) > 0 && !strings.Contains(c.Explanation, "the seat waits for its states: "+delivery.PlacementPulsesBucket)) {
 			t.Errorf("waiting for %v: %+v, %v", unbound, c, err)
 		}
@@ -92,12 +92,12 @@ func TestThePlacementSeatDecides(t *testing.T) {
 		t.Fatalf("writes = %+v, %v", writes, err)
 	}
 	a, err := PlacementAsk("placement.p-one", p, "move web (proposed by operator@laptop)", 7, time.Unix(100, 0))
-	if err != nil || occ.Check(mustAsk(t, a), time.Unix(100, 0)) != nil || mustAsk(t, a).Options[0].Level != occ.Approve || occ.Performs(mustAsk(t, a).Options[0], PlacementAct(p)) != nil {
+	if err != nil || a.Ask.Check(time.Unix(100, 0)) != nil || a.Ask.Options[0].Level != asks.Approve || a.Ask.Options[0].Performs(PlacementAct(p)) != nil {
 		t.Fatalf("the ask = %+v, %v", a, err)
 	}
 	q := p
 	q.Changes = append(slices.Clone(p.Changes), delivery.PlacementProposalChange{Op: delivery.OpUnpin, Node: "laptop", Provision: "x"})
-	if occ.Performs(mustAsk(t, a).Options[0], PlacementAct(q)) == nil {
+	if a.Ask.Options[0].Performs(PlacementAct(q)) == nil {
 		t.Error("the ask's yes binds changes it was not asked about")
 	}
 }

modules/mesh-delivery-assigner/internal/assign/verbs.go

@@ -1,38 +0,0 @@
-package assign
-
-import (
-	"slices"
-
-	"git.novox.be/novox/mesh-delivery/sdk/graph"
-)
-
-// verbWaiting says why the module's want on node waits for a verb it invokes (novox/hq ADR 0614 §2): the first seat verb or
-// module tool of Invokes (the module graph's verb edges, those it leaves out on a cycle not among them, §3) that no
-// running healthy build serves. Nil Served (nothing read of what runs) waits for none, and a verb a running build serves
-// already adds no wait. It holds under the provisions' rule (RuleProvisions): no reader knows a rule number of its own
-// yet, so the words name the edge (graph.VerbWaitWords, which the delivery view reads).
-func (m Module) verbWaiting(node string) (string, bool) {
-	if m.Served == nil {
-		return "", false
-	}
-	for _, v := range slices.Sorted(slices.Values(m.Invokes)) {
-		if !m.Served(v) {
-			return graph.VerbWaitWords(v, m.Name, node), true
-		}
-	}
-	return "", false
-}
-
-// busStateWaiting says why the module's want on node waits for bus state (ADR 0614 §5): its manifest asks bus state (a
-// bus-state entry, as the module graph reads it) and no build whose manifest offers bus-state runs healthy on a node
-// present. The provision bus-state is answered with no credential of a consumer's own, so ADR 0603 §5 counts the
-// provider's own have and no provisioner key is waited for, handed or not. Nil Offering (nothing read of what runs) waits
-// for none, and neither does a module that offers bus-state itself. It holds under the provisions' rule, its words naming bus state (graph.BusStateWaitWords).
-func (m Module) busStateWaiting(node string) (string, bool) {
-	if len(m.Manifest.BusState) == 0 || m.Offering == nil || m.Offering(graph.BusState) ||
-		slices.Contains(m.Manifest.Offers(), graph.BusState) { // the bus module offering it waits on nobody for it
-
-		return "", false
-	}
-	return graph.BusStateWaitWords(m.Name, node), true
-}

modules/mesh-delivery-assigner/internal/assign/wants.go

@@ -11,9 +11,6 @@ import (
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 	"git.novox.be/novox/mesh-sdk/go/provisions"
-
-	"git.novox.be/novox/mesh-delivery/sdk/forms"
-	"git.novox.be/novox/mesh-delivery/sdk/graph"
 )
 
 // Module is what the six rules read of one module (ADR 0429 §6, ADR 0528 clause 3): its newest fingerprint F at the
@@ -39,21 +36,6 @@ type Module struct {
 	// Answering is the manifests of the modules placed somewhere that provide a provision: what catalogue.Awaited
 	// judges a want's provisions by (issue 774). Nil: none known, and no key is waited for that is not there.
 	Answering func(provision string) []catalogue.Manifest
-	// Offered says whether any module offers a provision by name or by its own name (catalogue.Manifest.Offers) among every
-	// manifest the trunk holds and the modules the mesh provides itself, placed or not. Nil: not known, and no requirement
-	// is waited on for want of an offer.
-	Offered func(provision string) bool
-	// Invokes are the seat verbs and module tools the module graph says the module invokes and keeps as edges to the
-	// modules serving them, those it leaves out on a cycle not among them (ADR 0614 §2, §3): the want waits until each is
-	// served (Served). Nil: no graph node is read, and no want waits on a verb.
-	Invokes []string
-	// Served says whether a build serving a seat verb or module tool runs healthy, counted from its holder's have (ADR 0614
-	// §2, as ADR 0603 §5 counts a provider's). Nil: nothing is read of what runs, and no want waits on a verb.
-	Served func(invoke string) bool
-	// Offering says whether a build whose manifest offers a provision runs healthy on a node present, counted from the
-	// provider's own have (ADR 0603 §5): what a want asking bus state waits for (ADR 0614 §5). Nil: nothing is read of what
-	// runs, and no want waits on bus state.
-	Offering func(provision string) bool
 	// Chosen is a person's choice of the module's upgrade policy (the assigner's `policies`, ADR 0565 §7); nil: none.
 	Chosen *catalogue.PersonPolicy
 	Nodes  []string
@@ -63,10 +45,6 @@ type Module struct {
 	// Allowed says whether the operator answered yes to the record ask about the move of this module on node to the composition
 	// with this digest (ADR 0539 §14). Nil: none did.
 	Allowed func(node, digest string) bool
-	// Release names the release whose Approve carries the build fp, as mesh-delivery's gate holds it for the release's heads,
-	// read by the build's source revision (ADR 0601 §1): that Approve is the yes to a move of the build alone. False when no
-	// approved release is known to carry it. Nil: none is read.
-	Release func(fp string) (string, bool)
 	// Released is a hold on FP the operator released (ADR 0539 §19): FP is not held again by a health check that failed.
 	Released bool
 	// Restored says whether the operator answered "restore" to the restore ask of this data module on node: it is then set back
@@ -78,13 +56,6 @@ type Module struct {
 	Now time.Time
 	// Puts are the puts of the module, by node (ADR 0546): while one owns a node's want (PutOwns), the rules pass over it.
 	Puts map[string]delivery.Put
-	// Needs are the reader capabilities the manifest at FP needs (the indexer's modules value, catalogue.ManifestNeeds, ADR
-	// 0614 §4): a node's want moves only while that node's engine states each of them. Nil: none.
-	Needs []string
-	// FormNeeds are the reference forms the module's build at FP is written in (`form:<name>`, the builder's build key's
-	// needs, ADR 0618 §1): a node's want is held only while that node's engine reads none of them (ADR 0624 §2). Nil: the
-	// build names none, and holds nothing.
-	FormNeeds []string
 	// Self says whether node composes the module itself: the catalogue's placement names the node (ADR 0547 §2). It is the one
 	// source of a want's Self: every want the rules write or keep is derived from it (selfDerived), so a want written Self while
 	// the node was placed does not outlive the placement (issue 1126). Nil: no node does.
@@ -106,9 +77,6 @@ type Nodes struct {
 	Haves  map[string]map[string]delivery.Have
 	// Providers is, by provision, the modules that provide it, with the nodes each is assigned to.
 	Providers map[string]map[string][]string
-	// Reads is, by node, the reader capabilities its node-engine states in its node record (delivery.NodeRecord.ManifestReads,
-	// ADR 0614 §4). A node with none, or none read, is read as stating the baseline (catalogue.StatedManifestReads).
-	Reads map[string][]string
 }
 
 // healthy says whether a have runs fp healthy.
@@ -162,42 +130,15 @@ func holds(m Module, node string, n Nodes, ordering bool) (bool, int, string) {
 		return false, delivery.RuleGrant, fmt.Sprintf("the controller has not issued the credential of %s on %s for %s", m.Name, node,
 			short(m.FP))
 	}
-	if words, lacking := m.readerLacking(node, n); lacking {
-		return false, delivery.RuleComposed, words
-	}
 	if _, ok := m.composition(node, m.FP); !ok {
 		return false, delivery.RuleComposed, fmt.Sprintf("%s has named no composition of its own for %s at %s yet", node, m.Name, short(m.FP))
 	}
 	if words, waiting := m.provisionWaiting(node); waiting {
 		return false, delivery.RuleProvisions, words
 	}
-	if words, waiting := m.verbWaiting(node); waiting {
-		return false, delivery.RuleProvisions, words
-	}
-	if words, waiting := m.busStateWaiting(node); waiting {
-		return false, delivery.RuleProvisions, words
-	}
 	return true, 0, ""
 }
 
-// readerLacking says why the module's want on node is held for the node's engine (ADR 0614 §4): a reader capability its
-// manifest needs that the engine does not state, read as the baseline when it states none. It is held under rule 7 (the
-// composition), since no rule of its own is numbered in this release, with words naming the capability; it moves once the
-// engine states it. The node-engine's own new build is held only by a word of its own manifest no engine states.
-//
-// A build's reference forms hold the want only when the engine reads none of them (ADR 0624 §2): every engine reads a
-// first form, so a build written in one is never held by its forms; the words name the forms it reads none of.
-func (m Module) readerLacking(node string, n Nodes) (string, bool) {
-	missing := catalogue.MissingManifestReads(m.Needs, n.Reads[node])
-	if len(missing) == 0 && forms.Current.Held(m.FormNeeds, n.Reads[node]) {
-		missing = slices.Clone(m.FormNeeds)
-	}
-	if len(missing) == 0 {
-		return "", false
-	}
-	return graph.ReaderWaitWords(node, missing, m.Name, short(m.FP)), true // the words the delivery view names the edge by
-}
-
 // provisionWaiting says why the module's want on node waits for a provision (ADR 0570 §4): a provision it requires that has
 // no key yet, or the first of its keys that is not provided. Nil Provisions (the seat's state not on the bus) waits for none.
 func (m Module) provisionWaiting(node string) (string, bool) {
@@ -208,36 +149,8 @@ func (m Module) provisionWaiting(node string) (string, bool) {
 		return fmt.Sprintf("provision %s has no key yet for %s on %s", missing[0], m.Name, node), true
 	}
 	keyed := m.Provisions(node)
-	// Only a provision the newest manifest still requires is waited on (ADR 0603 §9): a key of an older revision's edge,
-	// asked or retiring for the operator's answer (ADR 0570 §5), holds nothing. A requirement catalogue.Awaited leaves out is
-	// not waited on when something offers it (a module's own name, a module the mesh provides itself, a provision the
-	// composition does not key: optional, a toolchain on the module's own machine, a login the controller makes). One that
-	// nothing offers is waited on (ADR 0603 §5: an unknown provider has provided nothing), so a consumer never moves ahead of
-	// a provider whose module the indexer has not yet taken in; it holds loudly, since the watchman raises the hold past its
-	// bound (ADR 0603 §8).
-	needed := m.Manifest.Requires
-	if m.Answering != nil {
-		needed = catalogue.Awaited(m.Manifest, m.Answering)
-		have := map[string]bool{}
-		for _, p := range keyed {
-			have[p.Provision] = true
-		}
-		for _, r := range slices.Sorted(slices.Values(m.Manifest.Requires)) {
-			if have[r] && !m.Manifest.OptionalRequires[r] && !slices.Contains(needed, r) {
-				needed = append(needed, r) // the provisioner keys it from the manifests, whoever is placed yet
-				continue
-			}
-			if m.Offered == nil || m.Manifest.OptionalRequires[r] || len(m.Answering(r)) > 0 || m.Offered(r) || slices.Contains(needed, r) {
-				continue
-			}
-			needed = append(needed, r)
-			if !have[r] {
-				return fmt.Sprintf("no module offers %s yet for %s on %s: an unknown provider has provided nothing, so the want waits for one, and the watchman raises it past its bound", r, m.Name, node), true
-			}
-		}
-	}
 	for _, key := range slices.Sorted(maps.Keys(keyed)) {
-		if p := keyed[key]; p.State != provisions.Provided && slices.Contains(needed, p.Provision) {
+		if p := keyed[key]; p.State != provisions.Provided {
 			words := fmt.Sprintf("the provision %s of %s on %s is %s, not provided", key, m.Name, node, p.State)
 			if p.Why != "" {
 				words += ": " + p.Why
@@ -355,18 +268,29 @@ type RecordNeed struct {
 	Words     string
 }
 
-// Holding is a rule holding a node back, and why. The bus module is held back by the rules alone, as every module (ADR 0601 §1,
-// §2): no bar of its own.
+// Holding is a rule holding a node back, and why. Bus marks the bar on the bus instead of one of the seven rules (Rule is then
+// 0): the bus moves only by the operator's put (ADR 0539 §15, ADR 0546 §8), never by the assigner (issue 1945: nats on novox,
+// running an old-form build, got no want and the pass said nothing).
 type Holding struct {
 	Rule  int
 	Words string
+	Bus   bool
 }
 
-// Reason is the holding in words: the rule and its words.
+// Reason is the holding in words: the rule and its words, or for the bus bar its words alone.
 func (h Holding) Reason() string {
+	if h.Bus {
+		return h.Words
+	}
 	return fmt.Sprintf("rule %d: %s", h.Rule, h.Words)
 }
 
+// BusBarWords say why the assigner writes no want moving the bus on node: it runs prev, the trunk builds fp, and only the
+// operator's put moves it (ADR 0539 §15, ADR 0546 §8). The words reach the operator, so they name no record.
+func BusBarWords(node, prev, fp string) string {
+	return fmt.Sprintf("only your put moves the bus: %s runs %s, the trunk builds %s; put it with assigner_put", node, short(prev), short(fp))
+}
+
 // Wants is the pass of one module m: for each of its nodes, the want by the six rules, starting from the want written
 // before (wants, by node); lastHealthy is, by node, the newest fingerprint other than m.FP the node ran healthy. A failed
 // health check of m.FP on a node holds it: every node wanting m.FP is set back to its last healthy fingerprint, but a
@@ -501,6 +425,14 @@ func Wants(m Module, n Nodes, wants map[string]delivery.Want, lastHealthy map[st
 			if need, wait := at.mustAsk(node, asked, hadLive, ran, running.FP, running.Composed == "", d); wait {
 				if need != nil {
 					out.Record = append(out.Record, *need)
+				} else if prev, barred := at.busBar(asked, hadLive, running.FP); barred {
+					// The bus is barred: no want moves it but the operator's put. Said, never silent (issue 1945): its holding is named,
+					// and a node that runs it with no live want has it on neither list, so its condition stays raised.
+					h := Holding{Bus: true, Words: BusBarWords(node, prev, at.FP)}
+					out.Rules[node] = h
+					if !hadLive && running.Phase != delivery.PhaseRemoved && !held {
+						out.Neither[node] = h
+					}
 				}
 				continue
 			}
@@ -727,10 +659,10 @@ func short(fp string) string {
 	return part[:12]
 }
 
-// mustAsk says whether the move to the composition d on node waits for the operator's yes (need names the ask, ADR 0539 §14). A
-// module the node never ran (it has no want and no have), a move judged neither, a module that is not of policy record and a want
-// that stays are written as any want. The bus module is no exception: it moves by the rules (ADR 0601 §1), its node backing up its
-// streams before it applies (§2); the assigner asks no snapshot for it.
+// mustAsk says whether the move to the composition d on node waits: for the operator's yes (need names the ask) or, for the bus,
+// for the operator's hand (ADR 0539 §14, §15). A module the node never ran (it has no want and no have), a move judged neither, a module that is not of
+// policy record and a want that stays are written as any want; so is a revision of the bus module's composition at the
+// same fingerprint judged neither (a user list only, §7).
 func (m Module) mustAsk(node string, before delivery.Want, had, ran bool, running string, haveNamesNoComposition bool, d delivery.ComposedDigest) (*RecordNeed, bool) {
 	if (!had && !ran) || before.Removed || (before.FP == m.FP && before.Composed == d.Digest) {
 		return nil, false
@@ -742,6 +674,9 @@ func (m Module) mustAsk(node string, before delivery.Want, had, ran bool, runnin
 	if !had && ran && running == m.FP && haveNamesNoComposition && d.Judgement == delivery.JudgedUnchanged {
 		return nil, false
 	}
+	if _, barred := m.busBar(before, had, running); barred {
+		return nil, true // the bus is never moved by the assigner; the operator writes its want (§15)
+	}
 	if !m.recorded(d) || d.Judgement == delivery.JudgedNeither || d.Judgement == delivery.JudgedUnchanged {
 		return nil, false
 	}
@@ -751,7 +686,17 @@ func (m Module) mustAsk(node string, before delivery.Want, had, ran bool, runnin
 	return &RecordNeed{Node: node, Digest: d.Digest, Judgement: d.Judgement, Words: d.Words}, true
 }
 
-// recorded says whether the module is of policy record: a person's choice at the assigner over the manifest's word (ADR
+// busBar says whether m is the bus and the move would take it off the fingerprint it ran before, prev: its want's, or with no
+// readable want the one its have names (ADR 0539 §15 bars a new one).
+func (m Module) busBar(before delivery.Want, had bool, running string) (prev string, barred bool) {
+	prev = before.FP
+	if !had {
+		prev = running
+	}
+	return prev, catalogue.ProvidesBus(m.Manifest) && prev != m.FP
+}
+
+// recorded says whether the module is of policy record: a person's choice at the assigner over everything but the bus (ADR
 // 0565 §7, catalogue.Upgrade); for a module with none, as the controller holds it beside the composition's digest until the
 // lease write (ADR 0539 §14); on a composition made by hand, which carries none, as the manifest derives it.
 func (m Module) recorded(d delivery.ComposedDigest) bool {

modules/mesh-delivery-assigner/internal/assign/wants_test.go

@@ -9,8 +9,6 @@ import (
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 	"git.novox.be/novox/mesh-sdk/go/provisions"
-
-	"git.novox.be/novox/mesh-delivery/sdk/graph"
 )
 
 func fpOf(c byte) string { return delivery.SourcePrefix2 + strings.Repeat(string(c), 64) }
@@ -106,123 +104,6 @@ func TestEachRuleHoldsTheWantBack(t *testing.T) {
 			t.Errorf("provided provisions held g14's want: %+v (%s)", out.Wants["g14"], out.Rules["g14"].Words)
 		}
 	}
-	// ADR 0614 §4: a want is held on a node whose engine does not state a reader capability the manifest needs, under rule 7
-	// with the capability as its words, and moves once the engine states it; an engine stating nothing reads the baseline,
-	// so a manifest of the baseline's words, the node-engine's own new build among them, is not held.
-	hostNeeds, err := catalogue.ManifestNeeds([]byte(`{"module":"mesh-host","version":"1","slug":"host","build":{"artifacts":[` +
-		`{"name":"host-arch","kind":"bundle","language":"go","system":"arch","from":"cmd/mesh-host"}]},"consumes":["restic.backed-up"],` +
-		`"state":[{"name":"health"}],"config":{"x":{"type":"number","minimum":1,"default":50,"runtime":true}},` +
-		`"resources":[{"id":"k","type":"file","path":"/var/lib/k","content":"${config:x}\n"}]}`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, c := range []struct {
-		why   string
-		name  string
-		needs []string
-		reads map[string][]string
-		held  bool
-		// forms are the build's reference forms (ADR 0624 §2), and names what the hold's words name.
-		forms []string
-		names string
-	}{
-		{"a word the baseline lacks, on engines stating nothing", "mail", []string{"word:module", "word:tool-runner"}, nil, true, nil, "word:tool-runner"},
-		{"the same, once both engines state it", "mail", []string{"word:module", "word:tool-runner"},
-			map[string][]string{"ace": catalogue.ManifestReads(), "g14": catalogue.ManifestReads()}, false, nil, ""},
-		{"the baseline's words on engines stating nothing", "mail", []string{"word:claims.serves", "seat:mesh-catalog", "form:config"}, nil, false, nil, ""},
-		{"the node-engine's new build, whose contract has more words than its manifest uses", "mesh-host", hostNeeds, nil, false, nil, ""},
-		// ADR 0624 §2, with form:new a form no engine reads unless it states it and artifact-store the first form.
-		{"g14 back stating {old}, a build carrying {old,new}: moves", "mail", nil, map[string][]string{"g14": {"word:module"}}, false,
-			[]string{"form:artifact-store", "form:new"}, ""},
-		{"an engine stating nothing, a build carrying the baseline's form: moves", "mail", nil, nil, false, []string{"form:artifact-store"}, ""},
-		{"a build carrying {new} only: held, naming the form", "mail", nil, map[string][]string{"g14": {"word:module"}}, true,
-			[]string{"form:new"}, "form:new"},
-		{"the same, once g14's engine states it", "mail", nil, map[string][]string{"g14": {"form:new"}}, false, []string{"form:new"}, ""},
-		{"a manifest needing an unstated word, its build in the first form: held, naming the word", "mail", []string{"word:tool-runner"}, nil, true,
-			[]string{"form:artifact-store"}, "word:tool-runner"},
-	} {
-		m, n := ready()
-		m.Name, m.Needs, n.Reads, m.FormNeeds = c.name, c.needs, c.reads, c.forms
-		n.Haves["ace"][c.name], n.Haves["g14"][c.name] = n.Haves["ace"]["mail"], n.Haves["g14"]["mail"]
-		out := Wants(m, n, wantedOld(), nil)
-		if moved := out.Wants["g14"].FP == fNew; moved == c.held {
-			t.Errorf("%s: g14's want %+v, held by %+v", c.why, out.Wants["g14"], out.Rules["g14"])
-		}
-		if r := out.Rules["g14"]; c.held && (r.Rule != delivery.RuleComposed || !strings.Contains(r.Words, c.names) ||
-			!strings.Contains(r.Words, "node-engine of g14")) {
-			t.Errorf("%s: held by %+v, want rule 7 naming the capability", c.why, r)
-		}
-		if w := out.Wants["g14"]; c.held && (w.Rule != delivery.RuleComposed || w.Newest != fNew) {
-			t.Errorf("%s: g14's want %+v, want it kept at what it runs and naming rule 7", c.why, w)
-		}
-	}
-	// ADR 0614 §2, §3: a want waits, under the provisions' rule, until each verb it invokes is served by a running build,
-	// and moves once one is; a verb a running build serves already adds no wait, and an edge the graph leaves out on a cycle
-	// is not among Invokes, so it holds nothing; nothing read of what runs waits for none.
-	for _, c := range []struct {
-		name    string
-		invokes []string
-		served  []string
-		nilRead bool
-		holds   string
-	}{
-		{"a verb no running build serves", []string{"store.store_put", "seat:mesh-catalog.modules"}, []string{"store.store_put"}, false, "seat:mesh-catalog.modules"},
-		{"once a build serving it runs", []string{"seat:mesh-catalog.modules"}, []string{"seat:mesh-catalog.modules"}, false, ""},
-		{"an edge left out on a cycle", nil, nil, false, ""},
-		{"nothing read of what runs", []string{"seat:mesh-catalog.modules"}, nil, true, ""},
-		// ADR 0614 §5: a module asking bus state is held while no build offering bus-state runs, and moves once one does.
-		{"bus state no running build offers", nil, nil, false, graph.BusState},
-		{"bus state a running build offers", nil, []string{graph.BusState}, false, ""},
-		{"bus state its own module offers", nil, nil, false, ""},
-	} {
-		m, n := ready()
-		m.Invokes = c.invokes
-		if !c.nilRead {
-			m.Served = func(v string) bool { return slices.Contains(c.served, v) }
-		}
-		if strings.HasPrefix(c.name, "bus state") {
-			m.Manifest.BusState = []catalogue.BusStateEntry{{Name: "cache", Storage: "key-value"}}
-			m.Offering = func(p string) bool { return slices.Contains(c.served, p) }
-			if c.name == "bus state its own module offers" {
-				m.Manifest.Provides = []catalogue.Offer{{Name: graph.BusState, Scope: catalogue.ScopeMesh}}
-			}
-		}
-		words := graph.VerbWaitWords(c.holds, "mail", "g14")
-		if c.holds == graph.BusState {
-			words = graph.BusStateWaitWords("mail", "g14")
-		}
-		out := Wants(m, n, wantedOld(), nil)
-		if c.holds == "" {
-			if out.Wants["g14"].FP != fNew {
-				t.Errorf("%s: held %+v", c.name, out.Rules["g14"])
-			}
-			continue
-		}
-		if out.Wants["g14"].FP == fNew || out.Rules["g14"].Rule != delivery.RuleProvisions || out.Rules["g14"].Words != words {
-			t.Errorf("%s: want %+v, held by %+v", c.name, out.Wants["g14"], out.Rules["g14"])
-		}
-	}
-	// ADR 0603 §9: the newest source revision governs. The module now at fNew no longer requires the database an older revision
-	// asked for and requires oidc instead; the seat's keys follow the newest manifest, so the older edge is no wait: a provided
-	// oidc moves the want, an asked one holds it and names oidc and never database.
-	for _, c := range []struct {
-		name         string
-		state, older string
-		moves        bool
-	}{{"the replaced edge provided, the older edge retiring", provisions.Provided, provisions.Retiring, true},
-		{"the replaced edge provided, the older edge asked", provisions.Provided, provisions.Asked, true},
-		{"the replaced edge asked, the older edge retiring", provisions.Asked, provisions.Retiring, false}} {
-		m, n := ready()
-		m.Manifest.Requires = []string{"oidc"}
-		m.Provisions = func(node string) map[string]provisions.Provision {
-			return map[string]provisions.Provision{node + ".mail.oidc": {Provision: "oidc", State: c.state},
-				node + ".mail.database": {Provision: "database", State: c.older, Why: "the operator's answer"}}
-		}
-		out := Wants(m, n, wantedOld(), nil)
-		if got := out.Wants["g14"].FP == fNew; got != c.moves || (!c.moves && (!strings.Contains(out.Rules["g14"].Words, "oidc") || strings.Contains(out.Rules["g14"].Words, "database"))) {
-			t.Errorf("%s: want %+v, held by %q", c.name, out.Wants["g14"], out.Rules["g14"].Words)
-		}
-	}
 	// 1954/D1 (the lead, 2026-10-29): a required provision with no key yet holds the want, named; and only one the
 	// composition keys (catalogue.Awaited, issue 774), replaying 2026-10-30: grafana (not handed) waited on ace for
 	// oidc-client, which the controller still makes, and mesh-build-go (handed) for go-toolchain on its own machine.
@@ -274,24 +155,6 @@ func TestEachRuleHoldsTheWantBack(t *testing.T) {
 			}
 		}
 	}
-	// ADR 0603 §5: a requirement nobody offers is an unknown provider and waits, loudly; one something offers (a module's own
-	// name, a module the mesh provides itself) is left to catalogue.Awaited as before and does not.
-	for _, c := range []struct {
-		name, requires string
-		offered        bool
-	}{{"a module's own name (node-tools)", "node-tools", true}, {"a module the mesh provides itself (mesh-addressing)", "mesh-addressing", true},
-		{"a provision nobody offers", "database", false}} {
-		m, n := ready()
-		m.Manifest.Requires = []string{c.requires}
-		m.Answering = func(string) []catalogue.Manifest { return nil }
-		m.Offered = func(p string) bool { return c.offered && p == c.requires }
-		m.Provisions = func(string) map[string]provisions.Provision { return map[string]provisions.Provision{} }
-		out := Wants(m, n, wantedOld(), nil)
-		if got := out.Wants["g14"].FP == fNew; got != c.offered || (!c.offered && (out.Rules["g14"].Rule != delivery.RuleProvisions ||
-			!strings.Contains(out.Rules["g14"].Words, "no module offers database yet") || !strings.Contains(out.Rules["g14"].Words, "past its bound"))) {
-			t.Errorf("%s: want %+v, held by %+v", c.name, out.Wants["g14"], out.Rules["g14"])
-		}
-	}
 	// 1960: rule 5 holds no want, and no module is left without a first want for a provider down or a node offline; the
 	// provider down is said (Unreached). novox on 2026-10-29: route-proxy down held de-spiegel and link2pay, minio not
 	// healthy held photos, and novox offline left a module with no canary.
@@ -776,13 +639,11 @@ func TestAMoveJudgedNeitherOrNeverRunOrNotRecordedIsWrittenAtOnce(t *testing.T)
 
 // 1906/D4 (ADR 0539 §7, §15): the bus module's new fingerprint is never written by the assigner, but a revision of its
 // composition at the same fingerprint that only changes the user list (judged neither) is written at once.
-func TestTheBusMovesByTheRulesAndItsUserListRevisionIsWrittenAtOnce(t *testing.T) {
+func TestTheBusIsNotMovedButItsUserListRevisionIsWrittenAtOnce(t *testing.T) {
 	m, n, _ := movingTo(delivery.JudgedNeither)
 	m.Manifest.Provides = []catalogue.Offer{{Name: "mesh-bus"}}
-	// ADR 0601 §1, §2: the bus module's want is written by the rules, as any module's, and no snapshot is asked for it: its node
-	// backs its streams up before it applies.
-	if out := Wants(m, n, wantedOld(), nil); out.Wants["ace"].FP != fNew || len(out.Record) != 0 || len(out.Neither) != 0 {
-		t.Errorf("the bus did not move by the rules: %+v", out)
+	if out := Wants(m, n, wantedOld(), nil); out.Wants["ace"].FP == fNew {
+		t.Errorf("the bus moved to a new fingerprint: %+v", out.Wants["ace"])
 	}
 	running := map[string]delivery.Want{"ace": {FP: fNew, Composed: dig(fOld)}, "g14": {FP: fNew, Composed: dig(fOld)}}
 	out := Wants(m, n, running, nil)
@@ -835,6 +696,23 @@ func TestTheBusMovesByTheRulesAndItsUserListRevisionIsWrittenAtOnce(t *testing.T
 		t.Errorf("a held bus did not take its user-list revision as a put: %+v", w)
 	}
 	m.Puts = nil
+	// 1945 (the bus bar made loud): a node that runs the bus at an old-form build and holds no want for it gets none, since only
+	// the operator's put moves the bus, and the pass says so: a holding naming the bar, and the node on neither list so its
+	// condition stays raised. A node with a live want keeps it and is not on neither list.
+	m.Composed = composedEverywhere
+	n.Haves["ace"]["mail"] = delivery.Have{FP: "b-1700000000-oldform", Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
+	out = Wants(m, n, map[string]delivery.Want{"g14": {FP: fOld, Composed: dig(fOld)}}, nil)
+	if w, wrote := out.Wants["ace"]; wrote {
+		t.Errorf("the bus bar wrote ace's want %+v", w)
+	}
+	h, on := out.Neither["ace"]
+	if !on || !h.Bus || out.Rules["ace"] != h || !strings.Contains(h.Words, "only your put moves the bus") || !strings.Contains(h.Words, "ace runs b-1700000000-oldform") ||
+		!strings.Contains(h.Words, "assigner_put") {
+		t.Errorf("the barred bus on ace: neither %+v (%v), rules %+v", h, on, out.Rules["ace"])
+	}
+	if _, on := out.Neither["g14"]; on || out.Wants["g14"].FP == fNew {
+		t.Errorf("g14 has a live want: neither %+v, its want %+v", out.Neither, out.Wants["g14"])
+	}
 	stepsOfAPut(t)
 }
 
@@ -1011,8 +889,8 @@ func TestTheRecordPolicyIsTheOneTheControllerHolds(t *testing.T) {
 	}
 }
 
-// A node that runs the bus with no readable want gets its want by the rules, at the fingerprint it runs or at a new one alike: the
-// bus has no bar of its own (ADR 0601 §1).
+// Review round 1, item 2 (ADR 0539 §15): a node that runs the bus with no readable want compares the new fingerprint with the one
+// it runs, from its have: the same fingerprint is not a new one (written by the rules), another is barred.
 func TestTheBusWithNoWantIsComparedWithWhatItRuns(t *testing.T) {
 	m, n, _ := movingTo(delivery.JudgedNeither)
 	m.Manifest.Provides = []catalogue.Offer{{Name: "mesh-bus"}}
@@ -1021,8 +899,8 @@ func TestTheBusWithNoWantIsComparedWithWhatItRuns(t *testing.T) {
 		t.Errorf("the bus runs F with no want and was not given one: %+v %v", w, ok)
 	}
 	n.Haves["ace"]["mail"] = delivery.Have{FP: fOld, Phase: delivery.PhaseRunning, Health: delivery.HealthOK}
-	if w, ok := Wants(m, n, nil, nil).Wants["ace"]; !ok || w.FP != fNew {
-		t.Errorf("the bus running an older fingerprint with no want was not given its want by the rules: %+v %v", w, ok)
+	if w, ok := Wants(m, n, nil, nil).Wants["ace"]; ok {
+		t.Errorf("the bus was moved to a new fingerprint with no want: %+v", w)
 	}
 }
 

modules/mesh-delivery-assigner/internal/judge/judge.go

@@ -1,332 +0,0 @@
-// Package judge is how the seat mesh-placement's holder judges a proposal (novox/hq ADR 0567 §3, §4, as ADR 0593 §8
-// changes them): what it changes on each node by its placement (Intended), every node answering it, and the verdict of
-// their answers (JudgeAnswers). The assigner's own (ADR 0593 §1), moved back from mesh-sdk's compose/judge: the holder
-// composes nothing, since every composition is its node's engine's, and a node answers through the candidates path
-// with what it composed. It holds no bus client and no timer: the holder gives it what it read.
-package judge
-
-import (
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	nec "git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient"
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// AnswerBound is how long the holder waits for a node's answer after its candidate was written: the time to live of the
-// node's pulse key (delivery.PulseAnswerKey), whose expiry names it as giving no answer, never passed. The same answer
-// bound a check gives a node (ADR 0593 §8, §7: 60 seconds, nec.AnswerBound). A variable so a test on the bus
-// can shorten it.
-var AnswerBound = nec.AnswerBound
-
-// Intended is, by node, the modules whose placed entry the proposal changes there, and the nodes that answer it: every
-// node (ADR 0593 §8, changing ADR 0567 §4's list of the nodes that must answer), sorted. current is the placement as it
-// stands, laid the proposal's placements by node (nil removes the node's key) and nodes every node with a record. A
-// node's set holds the modules the proposal adds, removes or whose placed entry differs on that node; a node with no
-// key now gets an empty set (§7: the seed is answered as the same). What a node's compositions change beyond its own
-// placement it says itself in its answer, marked in the brief as not computed.
-func Intended(current map[string]delivery.Placement, laid map[string]*delivery.Placement, nodes []string) (intended map[string]map[string]bool, must []string) {
-	intended = map[string]map[string]bool{}
-	all := map[string]bool{}
-	for _, n := range nodes {
-		all[n] = true
-	}
-	for n := range laid {
-		all[n] = true
-	}
-	for node := range all {
-		must = append(must, node)
-		set := map[string]bool{}
-		intended[node] = set
-		before, placed := current[node]
-		after, changesKey := laid[node]
-		if !changesKey || !placed {
-			continue // untouched, or new to placement: every answer must be the same
-		}
-		var afterModules []delivery.PlacedModule
-		if after != nil {
-			afterModules = after.Modules
-		}
-		entries := map[string]delivery.PlacedModule{}
-		for _, m := range before.Modules {
-			entries[m.Module] = m
-		}
-		seen := map[string]bool{}
-		for _, m := range afterModules {
-			seen[m.Module] = true
-			if e, ok := entries[m.Module]; !ok || !reflect.DeepEqual(e, m) {
-				set[m.Module] = true
-			}
-		}
-		for name := range entries {
-			if !seen[name] {
-				set[name] = true
-			}
-		}
-	}
-	sort.Strings(must)
-	return intended, must
-}
-
-// JudgeAnswers is the verdict of a proposal's answers (§4). answers is by node its HaveNode.Candidates entry for the
-// proposal (nil when it has none) and revisions by node the revision of its candidate key: an answer counts when it
-// names the proposal and that revision. It fails on a refusal by a node that must answer; a node of Must with no answer
-// that counts is waited for while its pulse key stands, and once it has ended (pulsing false: the bound's expiry, heard
-// on the bus) is named as giving no answer and the proposal decided on the answers it has (ADR 0593 §8).
-// A difference fails nothing: one Intended computed is listed under Intended, one it did not under Unintended, both
-// shown in the ask's brief. The seed alone fails on any difference.
-func JudgeAnswers(p delivery.PlacementProposal, intended map[string]map[string]bool, answers map[string]*delivery.CandidateAnswer,
-	revisions map[string]uint64, online map[string]bool, pulsing map[string]bool, now time.Time) delivery.PlacementVerdict {
-	v := delivery.PlacementVerdict{At: now.UTC(), Intended: map[string][]string{}, Unintended: map[string][]string{}, Carried: map[string][]string{},
-		Answers: map[string]delivery.CandidateAnswer{}}
-	for node, set := range intended {
-		for m := range set {
-			v.Intended[node] = append(v.Intended[node], m)
-		}
-		sort.Strings(v.Intended[node])
-	}
-	must := p.Must
-	if len(must) == 0 {
-		must = p.Nodes()
-	}
-	for _, node := range must {
-		a := answers[node]
-		if a == nil || a.Proposal != p.ID || a.Revision == 0 || a.Revision != revisions[node] {
-			v.Silent = append(v.Silent, node)
-			continue
-		}
-		v.Answers[node] = *a
-		if a.Refused != "" {
-			v.Fails = append(v.Fails, fmt.Sprintf("%s cannot compose the proposal: %s", node, a.Refused))
-			continue
-		}
-		for _, r := range a.Refusals {
-			v.Fails = append(v.Fails, fmt.Sprintf("%s refuses the proposal for %s: %s", node, r.Module, r.Why))
-		}
-		want := intended[node]
-		differs := func(module, words string) {
-			if p.Seed {
-				// The seed carries what its nodes found, each named in the brief for the operator who approves it.
-				v.Carried[node] = append(v.Carried[node], words)
-				return
-			}
-			if !want[module] {
-				v.Unintended[node] = append(v.Unintended[node], module)
-			}
-		}
-		for _, d := range a.Differs {
-			differs(d.Module, differenceWords(d))
-		}
-		for _, d := range a.Added {
-			differs(d.Module, "would run "+d.Module)
-		}
-		for _, m := range a.Removed {
-			differs(m, "would stop running "+m)
-		}
-		sort.Strings(v.Unintended[node])
-	}
-	if len(v.Intended) == 0 {
-		v.Intended = nil
-	}
-	if len(v.Unintended) == 0 {
-		v.Unintended = nil
-	}
-	if len(v.Carried) == 0 {
-		v.Carried = nil
-	}
-	if len(v.Answers) == 0 {
-		v.Answers = nil
-	}
-	var waiting, gone []string
-	for _, node := range v.Silent {
-		named := node
-		if online != nil && !online[node] {
-			named += " (offline)"
-		}
-		if pulsing[node] {
-			waiting = append(waiting, named)
-		} else {
-			gone = append(gone, named)
-		}
-	}
-	if len(waiting) > 0 {
-		v.Notes = append(v.Notes, fmt.Sprintf("waits for the answers of %s, each for %s from its candidate's write",
-			strings.Join(waiting, ", "), AnswerBound))
-	}
-	if len(gone) > 0 {
-		// ADR 0593 §8: decided on the answers it has; that node's own composition judges again when it applies (§9).
-		v.Notes = append(v.Notes, fmt.Sprintf("no answer from %s within %s of its candidate's write: decided on the answers "+
-			"it has, and that node's own composition judges again when it applies", strings.Join(gone, ", "), AnswerBound))
-	}
-	switch {
-	case len(v.Fails) > 0:
-		v.State = delivery.VerdictFail
-	case len(waiting) > 0:
-		v.State = delivery.VerdictWaits
-	default:
-		v.State = delivery.VerdictPass
-	}
-	return v
-}
-
-// Brief is the verdict as the ask's brief shows it, by node (§5): what the proposal changes and what each node answered
-// beside it, marked, and what stays held as the node holds it today, with the proposal's why.
-func Brief(p delivery.PlacementProposal, v delivery.PlacementVerdict) string {
-	var b strings.Builder
-	fmt.Fprintf(&b, "%s (proposed by %s)", p.Why, p.By)
-	nodes := map[string]bool{}
-	for n := range v.Intended {
-		nodes[n] = true
-	}
-	for n := range v.Unintended {
-		nodes[n] = true
-	}
-	for _, n := range p.Nodes() {
-		nodes[n] = true
-	}
-	for n, a := range v.Answers {
-		if len(a.Held) > 0 {
-			nodes[n] = true
-		}
-	}
-	for n := range v.Carried {
-		nodes[n] = true
-	}
-	names := make([]string, 0, len(nodes))
-	for n := range nodes {
-		names = append(names, n)
-	}
-	sort.Strings(names)
-	for _, n := range names {
-		fmt.Fprintf(&b, "; %s:", n)
-		if m := v.Intended[n]; len(m) > 0 {
-			fmt.Fprintf(&b, " changes %s", strings.Join(m, ", "))
-		} else {
-			b.WriteString(" composes the same")
-		}
-		if m := v.Unintended[n]; len(m) > 0 {
-			fmt.Fprintf(&b, "; also differs, not computed: %s", strings.Join(m, ", "))
-		}
-		if m := v.Carried[n]; len(m) > 0 {
-			fmt.Fprintf(&b, "; the seed carries: %s", strings.Join(m, "; "))
-		}
-		if held := v.Answers[n].Held; len(held) > 0 {
-			var names []string
-			for _, h := range held {
-				today := h.Today
-				if today == "" {
-					today = "held"
-				}
-				names = append(names, h.Module+" ("+today+")")
-			}
-			fmt.Fprintf(&b, "; stays as today: %s", strings.Join(names, ", "))
-		}
-	}
-	return b.String()
-}
-
-// differenceWords names one module's difference: the module, the first field that differs in it with its value as it
-// runs and as the seed composes it, each cut to about 60 characters ("(value cut)" where a body shown is cut before the
-// field), and how many fields more; or the resource and why when no body is shown.
-func differenceWords(d delivery.ModuleDiffers) string {
-	for _, b := range d.Bodies {
-		if len(b.Paths) == 0 {
-			continue
-		}
-		path := b.Paths[0]
-		words := fmt.Sprintf("%s: %s %s → %s", d.Module, fieldName(b.Running, b.Composed, path),
-			valueAt(b.Running, path), valueAt(b.Composed, path))
-		if n := len(b.Paths) - 1; n > 0 {
-			words += fmt.Sprintf(" (and %d more fields)", n)
-		}
-		return words
-	}
-	if d.Resource != "" {
-		return fmt.Sprintf("%s: %s (%s)", d.Module, d.Resource, d.Why)
-	}
-	return fmt.Sprintf("%s: %s", d.Module, d.Why)
-}
-
-// shownValue bounds a value named in a brief.
-const shownValue = 60
-
-// walk follows a differing path (delivery.DifferingPaths: keys joined by dots, a key may hold dots, and a JSON value
-// written in a string is read as JSON) through a body, answering the keys it passed and the value at its end.
-func walk(body, path string) (keys []string, value any, ok bool) {
-	var v any
-	if json.Unmarshal([]byte(body), &v) != nil {
-		return nil, nil, false
-	}
-	rest := path
-	for rest != "" {
-		if s, isString := v.(string); isString {
-			var inner any
-			if json.Unmarshal([]byte(s), &inner) != nil {
-				return nil, nil, false
-			}
-			v = inner
-		}
-		switch t := v.(type) {
-		case map[string]any:
-			best := ""
-			for k := range t {
-				if (rest == k || strings.HasPrefix(rest, k+".")) && len(k) > len(best) {
-					best = k
-				}
-			}
-			if best == "" {
-				return nil, nil, false
-			}
-			keys, v, rest = append(keys, best), t[best], strings.TrimPrefix(strings.TrimPrefix(rest, best), ".")
-		case []any:
-			seg, after, _ := strings.Cut(rest, ".")
-			n, err := strconv.Atoi(seg)
-			if err != nil || n < 0 || n >= len(t) {
-				return nil, nil, false
-			}
-			keys, v, rest = append(keys, seg), t[n], after
-		default:
-			return nil, nil, false
-		}
-	}
-	return keys, v, true
-}
-
-// valueAt is the value at path in a shown body, cut to shownValue, or why it is not shown.
-func valueAt(body, path string) string {
-	if body == "" {
-		return "(none)"
-	}
-	_, v, ok := walk(body, path)
-	if !ok {
-		return "(value cut)"
-	}
-	s, isString := v.(string)
-	if !isString {
-		raw, _ := json.Marshal(v)
-		s = string(raw)
-	}
-	if r := []rune(s); len(r) > shownValue {
-		s = string(r[:shownValue-1]) + "…"
-	}
-	return s
-}
-
-// fieldName is the differing field as a person reads it: its parent's name and its own, `PARENT[key]`, from whichever
-// body reaches it; the path's end when neither does.
-func fieldName(running, composed, path string) string {
-	for _, body := range []string{running, composed} {
-		if keys, _, ok := walk(body, path); ok && len(keys) > 0 {
-			if len(keys) == 1 {
-				return keys[0]
-			}
-			return keys[len(keys)-2] + "[" + keys[len(keys)-1] + "]"
-		}
-	}
-	return path
-}

modules/mesh-delivery-assigner/internal/judge/judge_test.go

@@ -1,91 +0,0 @@
-package judge
-
-import (
-	"slices"
-	"strings"
-	"testing"
-	"time"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// ADR 0567 §3, §4 (rows moved from the assigner's check of a pull request's placement, ADR 0559 §5): what a proposal
-// changes by node, and the verdict of the answers: differences shown and failing nothing, a refusal and a silent node
-// failing, a later answer judging again, the seed failing on any difference.
-func TestJudge(t *testing.T) {
-	current := map[string]delivery.Placement{"anchor": {Node: "anchor", Modules: []delivery.PlacedModule{{Module: "mail"}}}, "server": {Node: "server"}}
-	laid := map[string]*delivery.Placement{
-		"anchor": {Node: "anchor", Modules: []delivery.PlacedModule{{Module: "mail", Ports: map[string]int{"25": 2525}}, {Module: "web"}}},
-		"laptop": {Node: "laptop", Modules: []delivery.PlacedModule{{Module: "web"}}}}
-	// ADR 0593 §8: every node answers; what the placement changes is read from the placement alone.
-	got, must := Intended(current, laid, []string{"anchor", "laptop", "server"})
-	if !got["anchor"]["mail"] || !got["anchor"]["web"] || len(got["laptop"]) != 0 || len(got["server"]) != 0 ||
-		!slices.Equal(must, []string{"anchor", "laptop", "server"}) {
-		t.Errorf("intended = %v, must %v: want anchor's mail and web, nothing elsewhere, every node answering", got, must)
-	}
-
-	at := time.Date(2026, 10, 27, 2, 0, 0, 0, time.UTC)
-	p := delivery.PlacementProposal{ID: "p-one", By: "op", Why: "move web", Written: at, Base: map[string]uint64{"anchor": 3, "laptop": 0},
-		Must: []string{"anchor", "laptop"}}
-	revisions := map[string]uint64{"anchor": 7, "laptop": 8}
-	intended := map[string]map[string]bool{"anchor": {"web": true}}
-	same := func(rev uint64) *delivery.CandidateAnswer {
-		return &delivery.CandidateAnswer{Proposal: "p-one", Revision: rev, Verdict: delivery.CandidateSame, Same: []string{"mail"}}
-	}
-	differs := func(rev uint64, module string) *delivery.CandidateAnswer {
-		return &delivery.CandidateAnswer{Proposal: "p-one", Revision: rev, Verdict: delivery.CandidateDiffers,
-			Differs: []delivery.ModuleDiffers{{Module: module, Why: "the port differs"}}}
-	}
-	for _, row := range []struct {
-		name    string
-		seed    bool
-		answers map[string]*delivery.CandidateAnswer
-		pulsing map[string]bool
-		state   string
-		words   string
-		marked  string
-	}{
-		{"all the same", false, map[string]*delivery.CandidateAnswer{"anchor": same(7), "laptop": same(8)}, nil, delivery.VerdictPass, "", ""},
-		{"a module added where intended", false, map[string]*delivery.CandidateAnswer{"anchor": {Proposal: "p-one", Revision: 7, Verdict: delivery.CandidateDiffers,
-			Added: []delivery.ModuleAdded{{Module: "web", Unissued: []string{"its own secret"}}}}, "laptop": same(8)}, nil, delivery.VerdictPass, "", ""},
-		{"a difference not computed passes, marked", false, map[string]*delivery.CandidateAnswer{"anchor": differs(7, "mail"), "laptop": same(8)}, nil, delivery.VerdictPass, "", "mail"},
-		{"the seed carries a difference, named", true, map[string]*delivery.CandidateAnswer{"anchor": same(7), "laptop": {Proposal: "p-one", Revision: 8,
-			Verdict: delivery.CandidateDiffers, Differs: []delivery.ModuleDiffers{{Module: "node-tools", Resource: "node-tools.runtime", Why: "the resource differs",
-				Bodies: []delivery.ResourceBodies{{ID: "node-tools.runtime", Paths: []string{"env.MESH_OWNED_PATHS./etc/resolv.conf", "env.MESH_TOOL_MODULES"},
-					Running:  `{"env":{"MESH_OWNED_PATHS":"{\"/etc/hosts\":\"hostname\",\"/etc/resolv.conf\":\"networkmanager (node-uplink)\"}"}}`,
-					Composed: `{"env":{"MESH_OWNED_PATHS":"{\"/etc/hosts\":\"hostname\",\"/etc/resolv.conf\":\"systemd-resolved (node-resolver)\"}","MESH_TOOL_MODULES":"… (cut at 8192 bytes)`}}}}}}, nil, delivery.VerdictPass, "", ""},
-		{"a refusal", false, map[string]*delivery.CandidateAnswer{"anchor": same(7), "laptop": {Proposal: "p-one", Revision: 8, Verdict: delivery.CandidateRefused,
-			Refusals: []delivery.ModuleRefused{{Module: "web", Why: "no own secret"}}}}, nil, delivery.VerdictFail, "laptop refuses", ""},
-		{"a node not answering, within its bound", false, map[string]*delivery.CandidateAnswer{"anchor": same(7)}, map[string]bool{"laptop": true}, delivery.VerdictWaits, "laptop (offline)", ""},
-		{"an answer of an earlier revision, past its bound, is no answer and decided without it", false, map[string]*delivery.CandidateAnswer{"anchor": same(6), "laptop": same(8)}, nil, delivery.VerdictPass, "no answer from anchor", ""},
-		{"a module held as today passes, shown in the brief", false, map[string]*delivery.CandidateAnswer{"anchor": same(7), "laptop": {Proposal: "p-one", Revision: 8,
-			Verdict: delivery.CandidateSame, Held: []delivery.ModuleRefused{{Module: "spiegel", Why: "a required value is unset"}}}}, nil, delivery.VerdictPass, "", ""},
-		{"its later answer", false, map[string]*delivery.CandidateAnswer{"anchor": same(7), "laptop": same(8)}, nil, delivery.VerdictPass, "", ""},
-	} {
-		q := p
-		q.Seed = row.seed
-		v := JudgeAnswers(q, intended, row.answers, revisions, map[string]bool{"anchor": true}, row.pulsing, at)
-		all := strings.Join(append(append([]string{}, v.Fails...), v.Notes...), "; ")
-		if v.State != row.state || !strings.Contains(all, row.words) {
-			t.Errorf("%s: %s, %q", row.name, v.State, all)
-		}
-		if row.seed && row.state == delivery.VerdictPass && !strings.Contains(Brief(q, v), "the seed carries: node-tools: MESH_OWNED_PATHS[/etc/resolv.conf] networkmanager (node-uplink) → (value cut) (and 1 more fields)") {
-			t.Errorf("%s: the brief does not name it: %s", row.name, Brief(q, v))
-		}
-		if row.seed && row.state == delivery.VerdictPass {
-			whole := row.answers["laptop"].Differs[0]
-			whole.Bodies = []delivery.ResourceBodies{{ID: "r", Paths: []string{"env.MESH_OWNED_PATHS./etc/resolv.conf"},
-				Running:  `{"env":{"MESH_OWNED_PATHS":"{\"/etc/resolv.conf\":\"networkmanager (node-uplink)\"}"}}`,
-				Composed: `{"env":{"MESH_OWNED_PATHS":"{\"/etc/resolv.conf\":\"systemd-resolved (node-resolver)\"}"}}`}}
-			if got := differenceWords(whole); got != "node-tools: MESH_OWNED_PATHS[/etc/resolv.conf] networkmanager (node-uplink) → systemd-resolved (node-resolver)" {
-				t.Errorf("the difference is named %q", got)
-			}
-		}
-		if strings.HasPrefix(row.name, "a module held as today") && !strings.Contains(Brief(q, v), "stays as today: spiegel (held)") {
-			t.Errorf("%s: the brief does not show it: %s", row.name, Brief(q, v))
-		}
-		if row.marked != "" && (!slices.Contains(v.Unintended["anchor"], row.marked) || !strings.Contains(Brief(q, v), "not computed: "+row.marked)) {
-			t.Errorf("%s: the difference is not marked: %+v, %s", row.name, v.Unintended, Brief(q, v))
-		}
-	}
-}

modules/mesh-delivery-assigner/manifest_test.go

@@ -8,8 +8,6 @@ import (
 
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
-
-	"git.novox.be/novox/mesh-sdk/go/views"
 )
 
 func load(t *testing.T) catalogue.Manifest {
@@ -35,13 +33,9 @@ func TestManifest(t *testing.T) {
 	}
 	reads := slices.Clone(m.Reads)
 	slices.Sort(reads)
-	// ADR 0593 §8: it composes nothing, so it reads no candidate, held or resolved value, compose step or build log; it reads
-	// every node's published compositions to compare them, and the gate's source and merges, for the release that carries a build (ADR 0601 §1).
-	// DLV-F2r (ADR 0615 §1, ADR 0631 §1): the indexer's manifests, modules and module graph (whose verb edges a want waits
-	// on, ADR 0614 §2, §3) are read through its first views and views family, none of the indexer's states by reads.
-	want := []string{"mesh-delivery-builder.builds", "mesh-delivery-gate.merges", "mesh-delivery-gate.source",
-		"mesh-delivery-teller.answers", "mesh-delivery-watchman.presence", "mesh-grants.grants", "mesh-host.composed",
-		"mesh-provisioner.provisions", "node-engine.have"}
+	want := []string{"mesh-build-go.steps", "mesh-config.kept", "mesh-config.resolved",
+		"mesh-delivery-builder.build-log", "mesh-delivery-builder.builds", "mesh-delivery-indexer.candidates", "mesh-delivery-indexer.manifests",
+		"mesh-delivery-indexer.modules", "mesh-delivery-teller.answers", "mesh-delivery-watchman.presence", "mesh-grants.grants", "mesh-provisioner.provisions", "node-engine.have"}
 	if !reflect.DeepEqual(reads, want) {
 		t.Errorf("reads = %v, want exactly %v", reads, want)
 	}
@@ -49,9 +43,8 @@ func TestManifest(t *testing.T) {
 	for _, s := range m.State {
 		states[s.Name] = s.History
 	}
-	if want := map[string]int{"asks": 5, "differences": 64, "puts": 20, "wants": 20,
-		"placement": 64, "proposals": 5, "candidates": 5, "pulses": 0, "findings": 5, "policies": 20, "seat-holders": 5, views.MarksState: 1, views.StatusState: 1,
-		"engine-reads": 1}; !reflect.DeepEqual(states, want) {
+	if want := map[string]int{"asks": 5, "compositions": 5, "differences": 64, "puts": 20, "wants": 20,
+		"placement": 64, "proposals": 5, "candidates": 5, "pulses": 0, "findings": 5, "policies": 20, "seat-holders": 5}; !reflect.DeepEqual(states, want) {
 		t.Errorf("state = %v, want %v", states, want)
 	}
 	if _, ok := m.OwnSecrets["broker"]; !ok || len(m.OwnSecrets) != 1 {
@@ -60,10 +53,10 @@ func TestManifest(t *testing.T) {
 	if m.SecretsOwner != "mesh-delivery-assigner" {
 		t.Errorf("secrets-owner = %q", m.SecretsOwner)
 	}
-	// 1906/D3: it says its conditions on the operator channel; it asks the Go build seat nothing since the composition is
-	// the node-engine's (ADR 0593 §7).
-	if !slices.Equal(m.Uses, []string{"operator-channel"}) {
-		t.Errorf("uses = %v, want exactly operator-channel", m.Uses)
+	// 1906/D3: it says its conditions on the operator channel; 1622: it puts its compose asks on the Go build seat, as the
+	// checker puts its checks.
+	if !slices.Equal(m.Uses, []string{"node-build-go", "operator-channel"}) {
+		t.Errorf("uses = %v, want exactly node-build-go and operator-channel", m.Uses)
 	}
 	// ADR 0546: it serves its own tools (put, release, puts) from its bundle through the tool runner (the artifact loads the
 	// module), says each put's step as the event put, and calls the hand-act seat and the bus node's backup holder.
@@ -82,42 +75,16 @@ func TestManifest(t *testing.T) {
 	if seat, _ := catalogue.SeatNamed(catalogue.PlacementSeat); catalogue.CanHold(m, seat) != nil {
 		t.Errorf("the assigner cannot hold the seat: %v", catalogue.CanHold(m, seat))
 	}
-	// ADR 0621 §1: the first-view tools placement, seat-holders and wants and design 25 § 12.2's six read tools, of the
-	// program's bundle, which runs in a runtime of its own on the assigner's account; ADR 0618 §3: and assigner_engine_reads,
-	// which lists and asks again what each node's engine reads.
-	if !slices.Equal(m.Tools, []string{"assigner_put", "assigner_release", "assigner_puts", "placement", "seat-holders", "wants",
-		"assigner_read_placement", "assigner_read_seat_holders", "assigner_read_wants", "assigner_read_findings", "assigner_read_asks", "assigner_read_differences",
-		"assigner_first_views", "assigner_first_view_again", "assigner_engine_reads"}) {
-		t.Errorf("the assigner serves tools %v, want its three put tools, three first views, six read tools and assigner_engine_reads", m.Tools)
+	if !slices.Equal(m.Tools, []string{"assigner_put", "assigner_release", "assigner_puts"}) {
+		t.Errorf("the assigner serves tools %v, want its three put tools", m.Tools)
 	}
-	if m.RunsAs != m.Module || m.SecretsOwner != m.RunsAs {
-		t.Errorf("runs-as = %q: the bundle runs on the assigner's own account (ADR 0621 §1)", m.RunsAs)
-	}
-	// ADR 0621 §2: each first-view tool answers exactly its readers, never the assigner.
-	callers := map[string]string{"placement": "mesh-grants,node-tools,mesh-delivery-indexer", "seat-holders": "node-tools", "wants": "mesh-grants"}
-	env := m.Build.Artifacts[0].Env
-	for tool, list := range callers {
-		if env[views.CallersEnv(tool)] != list || views.ParseCallers(env[views.CallersEnv(tool)]).Allows("n1."+m.Module) {
-			t.Errorf("%s callers = %q, want %q", tool, env[views.CallersEnv(tool)], list)
-		}
-	}
-	// ADR 0619 §2, ADR 0615 §5: its views family beside placement on its old streams section.
-	if len(m.Streams) != 2 || m.Streams[1].Name != "assigner-views" || !slices.Equal(m.Streams[1].Events, []string{views.EventPattern}) ||
-		m.Streams[1].MaxAgeDays != views.StreamDays || m.Streams[1].MaxMiB != views.StreamMiB || m.Streams[1].Retention != "" {
-		t.Errorf("streams = %+v, want placement and assigner-views", m.Streams)
-	}
-	if m.Streams[0].Name != delivery.PlacementStream || m.Streams[0].MaxAgeDays != delivery.PlacementStreamDays ||
+	if len(m.Streams) != 1 || m.Streams[0].Name != delivery.PlacementStream || m.Streams[0].MaxAgeDays != delivery.PlacementStreamDays ||
 		!slices.Equal(slices.Sorted(slices.Values(m.Streams[0].Events)), slices.Sorted(slices.Values(delivery.PlacementEvents))) {
 		t.Errorf("streams = %+v, want placement carrying the seat's four events for %d days", m.Streams, delivery.PlacementStreamDays)
 	}
-	// ADR 0618 §4: and it hears each node's engine say its reads changed.
-	if !slices.Equal(m.Consumes, []string{"mesh-delivery-indexer.views.graph", "mesh-delivery-indexer.views.manifests", "mesh-delivery-indexer.views.modules", "node-engine.manifest-reads-changed"}) {
-		t.Errorf("consumes = %v, want the indexer's views of graph, manifests and modules and the engines' reads changed", m.Consumes)
-	}
-	if want := []string{"mesh-delivery-indexer.graph", "mesh-delivery-indexer.manifests", "mesh-delivery-indexer.modules",
+	if want := []string{
 		"seat:mesh-hand-acts.hand-act", "seat:mesh-hand-acts.hand-acts", "seat:mesh-hand-acts.warranted", // ADR 0565 §9, §11: the seat alone
-		"seat:node-backup.backed-up", "seat:node-backup.now",
-		"seat:node-engine.manifest-reads"}; !slices.Equal(slices.Sorted(slices.Values(m.Invokes)), want) { // ADR 0618 §3
+		"seat:node-backup.backed-up", "seat:node-backup.now"}; !slices.Equal(slices.Sorted(slices.Values(m.Invokes)), want) {
 		t.Errorf("invokes = %v, want %v", m.Invokes, want)
 	}
 	if !slices.Equal(m.Emits, []string{"put"}) {

modules/mesh-delivery-assigner/module.json

@@ -2,7 +2,6 @@
   "module": "mesh-delivery-assigner",
   "version": "1",
   "slug": "assigner",
-  "runs-as": "mesh-delivery-assigner",
   "claims": [
     {
       "name": "mesh-placement",
@@ -25,35 +24,30 @@
     }
   ],
   "reads": [
+    "mesh-build-go.steps",
+    "mesh-config.kept",
+    "mesh-config.resolved",
+    "mesh-delivery-builder.build-log",
     "mesh-delivery-builder.builds",
-    "mesh-delivery-gate.merges",
-    "mesh-delivery-gate.source",
+    "mesh-delivery-indexer.candidates",
+    "mesh-delivery-indexer.manifests",
+    "mesh-delivery-indexer.modules",
     "mesh-delivery-teller.answers",
     "mesh-delivery-watchman.presence",
     "mesh-grants.grants",
-    "mesh-host.composed",
     "mesh-provisioner.provisions",
     "node-engine.have"
   ],
   "uses": [
+    "node-build-go",
     "operator-channel"
   ],
-  "consumes": [
-    "mesh-delivery-indexer.views.graph",
-    "mesh-delivery-indexer.views.manifests",
-    "mesh-delivery-indexer.views.modules",
-    "node-engine.manifest-reads-changed"
-  ],
   "invokes": [
-    "mesh-delivery-indexer.graph",
-    "mesh-delivery-indexer.manifests",
-    "mesh-delivery-indexer.modules",
     "seat:mesh-hand-acts.hand-act",
     "seat:mesh-hand-acts.hand-acts",
     "seat:mesh-hand-acts.warranted",
     "seat:node-backup.backed-up",
-    "seat:node-backup.now",
-    "seat:node-engine.manifest-reads"
+    "seat:node-backup.now"
   ],
   "emits": [
     "put"
@@ -61,19 +55,7 @@
   "tools": [
     "assigner_put",
     "assigner_release",
-    "assigner_puts",
-    "placement",
-    "seat-holders",
-    "wants",
-    "assigner_read_placement",
-    "assigner_read_seat_holders",
-    "assigner_read_wants",
-    "assigner_read_findings",
-    "assigner_read_asks",
-    "assigner_read_differences",
-    "assigner_first_views",
-    "assigner_first_view_again",
-    "assigner_engine_reads"
+    "assigner_puts"
   ],
   "state": [
     { "name": "placement", "history": 64 },
@@ -81,15 +63,13 @@
     { "name": "candidates", "history": 5 },
     { "name": "pulses", "key-ttl": true },
     { "name": "asks", "history": 5 },
+    { "name": "compositions", "history": 5 },
     { "name": "differences", "history": 64 },
     { "name": "puts", "history": 20 },
     { "name": "wants", "history": 20 },
     { "name": "findings", "history": 5 },
     { "name": "policies", "history": 20 },
-    { "name": "seat-holders", "history": 5 },
-    { "name": "view-marks", "history": 1 },
-    { "name": "first-views", "history": 1 },
-    { "name": "engine-reads", "history": 1 }
+    { "name": "seat-holders", "history": 5 }
   ],
   "streams": [
     {
@@ -101,8 +81,7 @@
         "placement-withdrawn"
       ],
       "max-age-days": 30
-    },
-    { "name": "assigner-views", "events": ["views.**"], "max-age-days": 7, "max-mib": 256 }
+    }
   ],
   "own-secrets": {
     "broker": "${dir:state}/broker"
@@ -152,12 +131,7 @@
         "binary": "mesh-delivery-assigner",
         "loads": [
           "mesh-delivery-assigner"
-        ],
-        "env": {
-          "MESH_VIEW_CALLERS_PLACEMENT": "mesh-grants,node-tools,mesh-delivery-indexer",
-          "MESH_VIEW_CALLERS_SEAT_HOLDERS": "node-tools",
-          "MESH_VIEW_CALLERS_WANTS": "mesh-grants"
-        }
+        ]
       }
     ]
   }

modules/mesh-delivery-builder/buildrun/asks.go

@@ -1,316 +0,0 @@
-package buildrun
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/nats-io/nats.go"
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// **An asker puts an ask on its build seat's stream and waits for its step** (novox/hq ADR 0525 §1, §6; issue 1887 A4,
-// A5). It chooses no node: whichever build node pulls the ask writes `<node>.<ask id>` in its build module's steps state,
-// and the asker reads the first such key that is not running. The builder and the checker share it.
-
-// AskPublisher puts an encoded ask on subject, de-duplicated by its id.
-type AskPublisher interface {
-	PublishAsk(ctx context.Context, subject, id string, data []byte) error
-}
-
-// AskWaiter watches an ask's steps: every value a key `*.<ask id>` of the build module's steps state takes, running or
-// ended, on the channel it answers, until ctx ends. A watch, not a poll.
-type AskWaiter interface {
-	WatchAsk(ctx context.Context, module, askID string) (<-chan delivery.Step, error)
-}
-
-// Asker puts asks and waits for their steps.
-type Asker struct {
-	Publisher AskPublisher
-	Waiter    AskWaiter
-	// Bound is how long a running step (a build node took the ask, its key written running) may stand still, with no new phase,
-	// before the asker stops waiting; a step that keeps moving is waited for up to 3 Bounds from its start (issue 1930); zero waits as long as ctx. An ask waiting in its stream is not bounded: the stream's backlog is no fault
-	// (ADR 0525 §6, §9), and the bound starts again when another node takes the ask.
-	Bound time.Duration
-}
-
-// Put puts a on its stream: the seat's accept subject of its language and kind.
-func (k Asker) Put(ctx context.Context, a delivery.StepAsk) error {
-	raw, err := delivery.EncodeStepAsk(a)
-	if err != nil {
-		return err
-	}
-	subject, err := delivery.AskSubject(a.Language, a.Kind)
-	if err != nil {
-		return err
-	}
-	if err := k.Publisher.PublishAsk(ctx, subject, a.ID, raw); err != nil {
-		return fmt.Errorf("putting the %s ask %s: %w", a.Kind, a.ID, err)
-	}
-	return nil
-}
-
-// Wait waits for the step of an ask already put (a builder that started again takes over its own asks with it, never
-// putting them twice) and answers it when it ended, whatever its state. The bound runs from the step's start on the node
-// that took the ask, read from its running key, so an ask that waits in the stream for a free slot waits as long as ctx.
-func (k Asker) Wait(ctx context.Context, a delivery.StepAsk) (delivery.Step, error) {
-	module, err := delivery.BuildModuleOf(a.Language)
-	if err != nil {
-		return delivery.Step{}, err
-	}
-	watch, cancel := context.WithCancel(ctx)
-	defer cancel()
-	steps, err := k.Waiter.WatchAsk(watch, module, a.ID)
-	if err != nil {
-		return delivery.Step{}, err
-	}
-	var bound, outerCap <-chan time.Time
-	var timer, capTimer *time.Timer
-	defer func() {
-		if timer != nil {
-			timer.Stop()
-		}
-		if capTimer != nil {
-			capTimer.Stop()
-		}
-	}()
-	running, since, phase, phaseAt := "", time.Time{}, "", time.Time{}
-	standStill := func() error {
-		if phase == "" {
-			return fmt.Errorf("the ask %s's step on %s did not end within %s of its start: it stood still, saying no phase", a.ID, running, k.Bound)
-		}
-		return fmt.Errorf("the ask %s's step on %s did not end within %s: it stood still in %q since %s",
-			a.ID, running, k.Bound, phase, phaseAt.UTC().Format(time.RFC3339))
-	}
-	for {
-		select {
-		case <-ctx.Done():
-			return delivery.Step{}, ctx.Err()
-		case <-bound:
-			return delivery.Step{}, standStill()
-		case <-outerCap:
-			return delivery.Step{}, fmt.Errorf("the ask %s's step on %s did not end within %s of its start: it kept moving (last phase %q at %s) but never ended",
-				a.ID, running, 3*k.Bound, phase, phaseAt.UTC().Format(time.RFC3339))
-		case step, ok := <-steps:
-			if !ok {
-				return delivery.Step{}, errors.New("the watch of the ask's step ended")
-			}
-			if seen := stepSeenOf(ctx); seen != nil {
-				seen(step)
-			}
-			if step.State != delivery.StepRunning {
-				return step, nil
-			}
-			if k.Bound <= 0 {
-				continue
-			}
-			newRun := step.Node != running || !step.Started.Equal(since)
-			if !newRun && step.Phase == phase && step.PhaseAt.Equal(phaseAt) {
-				continue
-			}
-			// A node took the ask, or took it again after its run stopped (another node, or the same node's build module
-			// replaced mid-run: a new start), or its step entered a phase. The bound is on standing still: it runs from the
-			// step's last movement (its phase's start, else its start), so a step that keeps moving is waited for, up to
-			// three bounds from its start (issue 1930).
-			running, since, phase, phaseAt = step.Node, step.Started, step.Phase, step.PhaseAt
-			last := step.Started
-			if step.PhaseAt.After(last) {
-				last = step.PhaseAt
-			}
-			left := k.Bound
-			if !last.IsZero() {
-				left = time.Until(last.Add(k.Bound))
-			}
-			if timer != nil {
-				timer.Stop()
-			}
-			timer = time.NewTimer(max(left, 0))
-			bound = timer.C
-			if newRun {
-				if capTimer != nil {
-					capTimer.Stop()
-				}
-				outer := 3 * k.Bound
-				if !step.Started.IsZero() {
-					outer = time.Until(step.Started.Add(3 * k.Bound))
-				}
-				capTimer = time.NewTimer(max(outer, 0))
-				outerCap = capTimer.C
-			}
-		}
-	}
-}
-
-type stepSeenKey struct{}
-
-// WithStepSeen is ctx carrying seen, which Asker.Wait hands every value the ask's step key takes while it waits: the node
-// that took it, each phase it says while running (delivery.Step.Phase), and its end. A try names its asks' progress so
-// (issue 1890). seen runs in the waiting goroutine and must not block.
-func WithStepSeen(ctx context.Context, seen func(delivery.Step)) context.Context {
-	return context.WithValue(ctx, stepSeenKey{}, seen)
-}
-
-func stepSeenOf(ctx context.Context) func(delivery.Step) {
-	seen, _ := ctx.Value(stepSeenKey{}).(func(delivery.Step))
-	return seen
-}
-
-// Ask puts a and waits for its step; a step that did not pass is an error naming its node, its state and its reason.
-func (k Asker) Ask(ctx context.Context, a delivery.StepAsk) (delivery.Step, error) {
-	if err := k.Put(ctx, a); err != nil {
-		return delivery.Step{}, err
-	}
-	return k.Passed(k.Wait(ctx, a))
-}
-
-// Passed is step when it passed, else an error naming where it ended and why.
-func (k Asker) Passed(step delivery.Step, err error) (delivery.Step, error) {
-	if err != nil {
-		return step, err
-	}
-	if step.State != delivery.StepPassed {
-		return step, fmt.Errorf("the ask %s on %s %s: %s", step.ID, step.Node, step.State, step.Reason)
-	}
-	return step, nil
-}
-
-// JetStreamAsks is the bus side of an Asker: a JetStream publish de-duplicated by the ask's id (Nats-Msg-Id), and a watch
-// of `*.<ask id>` in the build module's steps bucket.
-type JetStreamAsks struct {
-	JS jetstream.JetStream
-}
-
-// PublishAsk is AskPublisher's.
-func (s JetStreamAsks) PublishAsk(ctx context.Context, subject, id string, data []byte) error {
-	msg := &nats.Msg{Subject: subject, Data: data, Header: nats.Header{}}
-	msg.Header.Set(jetstream.MsgIDHeader, id)
-	_, err := s.JS.PublishMsg(ctx, msg)
-	return err
-}
-
-// WatchAsk is AskWaiter's: the watch hands over what the keys hold now, so a step that ended before it began is read at
-// once, and every change after.
-func (s JetStreamAsks) WatchAsk(ctx context.Context, module, askID string) (<-chan delivery.Step, error) {
-	pattern, err := delivery.AskStepWatch(askID)
-	if err != nil {
-		return nil, err
-	}
-	kv, err := s.JS.KeyValue(ctx, delivery.StepsBucket(module))
-	if err != nil {
-		return nil, fmt.Errorf("the bucket %s: %w", delivery.StepsBucket(module), err)
-	}
-	w, err := kv.Watch(ctx, pattern)
-	if err != nil {
-		return nil, err
-	}
-	out := make(chan delivery.Step)
-	go func() {
-		defer close(out)
-		defer w.Stop()
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			case e, ok := <-w.Updates():
-				if !ok {
-					return
-				}
-				if e == nil || e.Operation() != jetstream.KeyValuePut {
-					continue
-				}
-				step, err := delivery.DecodeStep(e.Value())
-				if err != nil {
-					continue // not a step (a node's pause key never matches an ask id; anything else is not this ask's)
-				}
-				select {
-				case out <- step:
-				case <-ctx.Done():
-					return
-				}
-			}
-		}
-	}()
-	return out, nil
-}
-
-// FakeAsks is a test double of the bus for an asker's tests: each ask put is kept and, when Answer is set, its step is
-// written at once with what Answer says a build node wrote (running or ended). Write writes a step later. Safe for
-// concurrent use.
-type FakeAsks struct {
-	Answer func(a delivery.StepAsk) delivery.Step
-
-	mu       sync.Mutex
-	asks     []delivery.StepAsk
-	steps    map[string][]delivery.Step
-	watchers map[string][]chan delivery.Step
-}
-
-// PublishAsk is AskPublisher's.
-func (f *FakeAsks) PublishAsk(_ context.Context, _, id string, data []byte) error {
-	a, err := delivery.DecodeStepAsk(data)
-	if err != nil {
-		return err
-	}
-	f.mu.Lock()
-	f.asks = append(f.asks, a)
-	f.mu.Unlock()
-	if f.Answer != nil {
-		f.Write(f.Answer(a))
-	}
-	return nil
-}
-
-// Write writes an ask's step, as a build node does.
-func (f *FakeAsks) Write(step delivery.Step) {
-	f.mu.Lock()
-	if f.steps == nil {
-		f.steps, f.watchers = map[string][]delivery.Step{}, map[string][]chan delivery.Step{}
-	}
-	f.steps[step.ID] = append(f.steps[step.ID], step)
-	ws := append([]chan delivery.Step(nil), f.watchers[step.ID]...)
-	f.mu.Unlock()
-	for _, w := range ws {
-		w <- step
-	}
-}
-
-// End is Write: kept for the tests that end a step.
-func (f *FakeAsks) End(step delivery.Step) { f.Write(step) }
-
-// WatchAsk is AskWaiter's: what was written so far, then every write.
-func (f *FakeAsks) WatchAsk(ctx context.Context, _ string, askID string) (<-chan delivery.Step, error) {
-	out := make(chan delivery.Step, 64)
-	f.mu.Lock()
-	if f.steps == nil {
-		f.steps, f.watchers = map[string][]delivery.Step{}, map[string][]chan delivery.Step{}
-	}
-	for _, s := range f.steps[askID] {
-		out <- s
-	}
-	f.watchers[askID] = append(f.watchers[askID], out)
-	f.mu.Unlock()
-	go func() {
-		<-ctx.Done()
-		f.mu.Lock()
-		ws := f.watchers[askID]
-		for i, w := range ws {
-			if w == out {
-				f.watchers[askID] = append(ws[:i], ws[i+1:]...)
-				break
-			}
-		}
-		f.mu.Unlock()
-	}()
-	return out, nil
-}
-
-// Asks are the asks put so far.
-func (f *FakeAsks) Asks() []delivery.StepAsk {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	return append([]delivery.StepAsk(nil), f.asks...)
-}

modules/mesh-delivery-builder/buildrun/asks_integration_test.go

@@ -1,61 +0,0 @@
-//go:build integration
-
-package buildrun
-
-import (
-	"context"
-	"encoding/json"
-	"testing"
-	"time"
-
-	"github.com/nats-io/nats.go"
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-	"git.novox.be/novox/mesh-sdk/go/testbus"
-)
-
-// 1887/A4a, 1887/AC3 on the real bus: an ask put twice under one id is one message, and the asker reads the step a node
-// wrote under `<node>.<ask id>`.
-func TestAnAskIsPutOnceAndItsStepIsRead(t *testing.T) {
-	nc, err := nats.Connect(testbus.URL(t))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer nc.Close()
-	js, _ := jetstream.New(nc)
-	ctx := context.Background()
-	if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: "SEAT_NODE_BUILD_GO", Subjects: []string{"mesh.seat.node-build-go.accept.>"},
-		Retention: jetstream.WorkQueuePolicy}); err != nil {
-		t.Fatal(err)
-	}
-	kv, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: delivery.StepsBucket("mesh-build-go")})
-	if err != nil {
-		t.Fatal(err)
-	}
-	bus := JetStreamAsks{JS: js}
-	k := Asker{Publisher: bus, Waiter: bus, Bound: 5 * time.Second}
-	a := goAsk("mvl0frv18d1960")
-	for i := 0; i < 2; i++ {
-		if err := k.Put(ctx, a); err != nil {
-			t.Fatal(err)
-		}
-	}
-	s, _ := js.Stream(ctx, "SEAT_NODE_BUILD_GO")
-	if info, _ := s.Info(ctx); info.State.Msgs != 1 {
-		t.Fatalf("%d messages for one ask put twice", info.State.Msgs)
-	}
-	go func() {
-		time.Sleep(100 * time.Millisecond)
-		key, _ := delivery.AskStepKey("ace", a.ID)
-		running, _ := delivery.EncodeStep(delivery.Step{ID: a.ID, Tool: "delivery ask", Node: "ace", State: delivery.StepRunning, Started: time.Now()})
-		_, _ = kv.Put(ctx, key, running)
-		passed, _ := delivery.EncodeStep(delivery.Step{ID: a.ID, Tool: "delivery ask", Node: "ace", State: delivery.StepPassed, Started: time.Now(),
-			Result: json.RawMessage(`{"artifacts":[]}`)})
-		_, _ = kv.Put(ctx, key, passed)
-	}()
-	step, err := k.Passed(k.Wait(ctx, a))
-	if err != nil || step.Node != "ace" {
-		t.Fatalf("step %+v, %v", step, err)
-	}
-}

modules/mesh-delivery-builder/buildrun/asks_test.go

@@ -1,234 +0,0 @@
-package buildrun
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-	"git.novox.be/novox/mesh-sdk/go/health"
-)
-
-func goAsk(id string) delivery.StepAsk {
-	return delivery.StepAsk{ID: id, Kind: delivery.AskDelivery, Language: delivery.AskGo, Asker: "mesh-delivery-builder", At: time.Now(),
-		Build: &delivery.BuildJob{Module: "m", Path: ".", Fetch: map[string]any{"repository": "novox/x", "commit": strings.Repeat("a", 40)},
-			Artifacts: []delivery.AskArtifact{{Artifact: "program"}}}}
-}
-
-// 1887/A4a: an asker puts the ask once and answers the step a build node wrote for it, naming the node; one that did not
-// pass is an error naming the node and why; a wait of an ask already put puts nothing.
-func TestAnAskerPutsOnceAndReadsTheStep(t *testing.T) {
-	f := &FakeAsks{Answer: func(a delivery.StepAsk) delivery.Step {
-		return delivery.Step{ID: a.ID, Node: "ace", State: delivery.StepPassed, Result: []byte(`{"artifacts":[]}`)}
-	}}
-	k := Asker{Publisher: f, Waiter: f}
-	var seen []delivery.Step // issue 1890: a waiter that asks to see each value of the step sees it
-	step, err := k.Ask(WithStepSeen(context.Background(), func(s delivery.Step) { seen = append(seen, s) }), goAsk("mvl0frv18d1957"))
-	if err != nil || step.Node != "ace" || len(f.Asks()) != 1 || len(seen) != 1 || seen[0].Node != "ace" {
-		t.Fatalf("step %+v, %v, asks %d, seen %+v", step, err, len(f.Asks()), seen)
-	}
-	f.Answer = func(a delivery.StepAsk) delivery.Step {
-		return delivery.Step{ID: a.ID, Node: "shanks", State: delivery.StepRefused, Reason: "go 1.27 installed"}
-	}
-	if _, err := k.Ask(context.Background(), goAsk("mvl0frv18d1958")); err == nil || !strings.Contains(err.Error(), "shanks refused: go 1.27 installed") {
-		t.Fatalf("a refused step: %v", err)
-	}
-	// review round 2 item 1: an ask that waits in its stream for a free slot is not bounded; once a node writes its step
-	// running, the step is bounded from its start, and the error names the node.
-	g := &FakeAsks{}
-	k = Asker{Publisher: g, Waiter: g, Bound: 20 * time.Millisecond}
-	waiting, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
-	defer cancel()
-	if _, err := k.Wait(waiting, goAsk("mvl0frv18d1959")); err != context.DeadlineExceeded {
-		t.Fatalf("an ask no node took: %v, want it still waiting when ctx ended", err)
-	}
-	g.Write(delivery.Step{ID: "mvl0frv18d1961", Node: "ace", State: delivery.StepRunning, Started: time.Now()})
-	if _, err := k.Wait(context.Background(), goAsk("mvl0frv18d1961")); err == nil || !strings.Contains(err.Error(), "on ace did not end within") {
-		t.Fatalf("a step that never ends: %v", err)
-	}
-	if len(g.Asks()) != 0 {
-		t.Fatal("a wait put an ask")
-	}
-	// Issue 1930: the bound is on a step that stands still, not on its age. A step past one bound from its start that entered a
-	// new phase inside the bound is waited for until it ends; one that stood a whole bound in a phase fails at once, naming
-	// the phase; one three bounds from its start ends, said as kept moving. The steps' own times stand for the clock, so the
-	// bound is an hour no loaded machine reaches and no case waits on a pause (the check of 2026-11-02 22:35 tripped one
-	// of 60 ms).
-	k = Asker{Publisher: g, Waiter: g, Bound: time.Hour}
-	now := time.Now()
-	g.Write(delivery.Step{ID: "mvl0frv18d1980", Node: "ace", State: delivery.StepRunning, Started: now.Add(-90 * time.Minute), Phase: "pb", PhaseAt: now})
-	g.Write(delivery.Step{ID: "mvl0frv18d1980", Node: "ace", State: delivery.StepPassed})
-	if step, err := k.Wait(context.Background(), goAsk("mvl0frv18d1980")); err != nil || step.State != delivery.StepPassed {
-		t.Fatalf("a step that kept moving past its bound: %+v, %v", step, err)
-	}
-	g.Write(delivery.Step{ID: "mvl0frv18d1981", Node: "ace", State: delivery.StepRunning, Started: now.Add(-time.Hour), Phase: "integration: tests", PhaseAt: now.Add(-time.Hour)})
-	if _, err := k.Wait(context.Background(), goAsk("mvl0frv18d1981")); err == nil || !strings.Contains(err.Error(), `stood still in "integration: tests"`) {
-		t.Fatalf("a step that stood still in a phase: %v", err)
-	}
-	g.Write(delivery.Step{ID: "mvl0frv18d1982", Node: "ace", State: delivery.StepRunning, Started: now.Add(-3 * time.Hour), Phase: "qz", PhaseAt: now})
-	if _, err := k.Wait(context.Background(), goAsk("mvl0frv18d1982")); err == nil || !strings.Contains(err.Error(), "kept moving") {
-		t.Fatalf("a step that never stops moving: %v", err)
-	}
-	// Issue 734: an ask the build seat gave up on (DEAD_LETTERS keeps its copy with the ask's id) ends its wait as failed
-	// with the words, though a node had taken it; under NotTakenBound one no node takes ends at the bound; a step written
-	// first is answered as the node wrote it.
-	dead := &DeadLetters{}
-	lw := LostAskWaiter{Inner: g, Dead: dead}
-	k = Asker{Publisher: g, Waiter: lw, Bound: time.Minute}
-	g.Write(delivery.Step{ID: "mvl0frv18d1970", Node: "ace", State: delivery.StepRunning, Started: time.Now()})
-	given, ok := GivenUpOf(map[string][]string{"Mesh-Dead-Msg-Id": {"mvl0frv18d1970"}, "Mesh-Dead-Deliveries": {"5"},
-		"Mesh-Dead-Stream": {"SEAT_NODE_BUILD_GO"}, "Mesh-Dead-Gave-Up": {"2026-10-26T12:26:40Z"}})
-	if !ok {
-		t.Fatal("a dead letter's headers were not read")
-	}
-	go dead.Heard(given)
-	step, err = k.Wait(context.Background(), goAsk("mvl0frv18d1970"))
-	if err != nil || step.State != delivery.StepFailed || !IsLost(step) ||
-		!strings.Contains(step.Reason, LostWords+" after 5 deliveries at 2026-10-26T12:26:40Z") {
-		t.Fatalf("a given-up ask: %+v, %v", step, err)
-	}
-	if _, err := k.Passed(step, nil); err == nil || !strings.Contains(err.Error(), "on "+LostNode+" failed: "+LostWords) {
-		t.Fatalf("a given-up ask's error: %v", err)
-	}
-	step, err = k.Wait(NotTakenBound(context.Background(), 20*time.Millisecond), goAsk("mvl0frv18d1971"))
-	if err != nil || !IsNotTaken(step) || IsLost(step) {
-		t.Fatalf("an ask no node took: %+v, %v", step, err)
-	}
-	g.Write(delivery.Step{ID: "mvl0frv18d1972", Node: "g14", State: delivery.StepPassed})
-	if step, err = k.Wait(NotTakenBound(context.Background(), time.Minute), goAsk("mvl0frv18d1972")); err != nil || step.Node != "g14" {
-		t.Fatalf("a step written: %+v, %v", step, err)
-	}
-	// Review round 1 of issue 734: a hearing the bus refuses at start is deaf and says so, never holds the start up, and
-	// tries again on the next ask waited for; heard, it says so and hands the given-up asks on.
-	fol := &refusingFollower{refuse: 1}
-	var mu sync.Mutex
-	var told []Hearing
-	hearing := NewDeadLetterHearing(context.Background(), fol, []string{delivery.AskGo}, dead, nil,
-		func(h Hearing) { mu.Lock(); told = append(told, h); mu.Unlock() })
-	hearing.Wait()
-	if why := hearing.Deaf(); !strings.Contains(why, "SEAT_NODE_BUILD_GO: permissions violation") {
-		t.Fatalf("a refused hearing says %q", why)
-	}
-	k = Asker{Publisher: g, Waiter: LostAskWaiter{Inner: g, Dead: dead, Hearing: hearing}, Bound: time.Minute}
-	g.Write(delivery.Step{ID: "mvl0frv18d1973", Node: "g14", State: delivery.StepPassed})
-	if _, err := k.Wait(context.Background(), goAsk("mvl0frv18d1973")); err != nil {
-		t.Fatal(err)
-	}
-	hearing.Wait()
-	mu.Lock()
-	if hearing.Deaf() != "" || len(told) != 2 || told[0].Heard || !told[1].Heard || fol.calls() != 2 {
-		t.Fatalf("after an ask: deaf %q, told %+v, followed %d times", hearing.Deaf(), told, fol.calls())
-	}
-	mu.Unlock()
-	fol.heard(GivenUp{AskID: "mvl0frv18d1974", Deliveries: 5})
-	step, err = k.Wait(context.Background(), goAsk("mvl0frv18d1974"))
-	if err != nil || !IsLost(step) {
-		t.Fatalf("an ask heard given up after the hearing came back: %+v, %v", step, err)
-	}
-	// The lost check of 2026-10-28: a step whose own watch went deaf is read at the next nudge (a step of its build module
-	// ended) and answered; a nudge of another build module reads nothing; a watch that closes is opened again.
-	d := &FakeAsks{}
-	heard := &HeardEnds{Inner: deafWatch{}, Read: d}
-	k = Asker{Publisher: d, Waiter: heard, Bound: time.Minute}
-	d.Write(delivery.Step{ID: "mvl0frv18d1980", Node: "shanks", State: delivery.StepPassed})
-	got := make(chan delivery.Step, 1)
-	go func() { s, _ := k.Wait(context.Background(), goAsk("mvl0frv18d1980")); got <- s }()
-	for heard.Waiting() == 0 {
-		time.Sleep(time.Millisecond)
-	}
-	heard.Nudge(NodeBuildModule)
-	select {
-	case s := <-got:
-		t.Fatalf("a nudge of another build module answered %+v", s)
-	case <-time.After(20 * time.Millisecond):
-	}
-	heard.Nudge(GoBuildModule)
-	if s := <-got; s.State != delivery.StepPassed || s.Node != "shanks" {
-		t.Fatalf("a step its watch never handed over: %+v", s)
-	}
-	closing := &HeardEnds{Inner: &closingWatch{inner: d}, Read: d}
-	if s, err := (Asker{Publisher: d, Waiter: closing}).Wait(context.Background(), goAsk("mvl0frv18d1980")); err != nil || s.State != delivery.StepPassed {
-		t.Fatalf("a watch that closed once: %+v, %v", s, err)
-	}
-	for _, row := range []struct {
-		h    *Hearing
-		want string
-	}{{nil, health.StateUnhealthy}, {&told[0], health.StateUnhealthy}, {&told[1], health.StateHealthy}} {
-		var raw []byte
-		if row.h != nil {
-			raw, _ = json.Marshal(row.h)
-		}
-		if a := HearingHealth(raw); a.State != row.want || a.Why == "" {
-			t.Errorf("health of %+v = %+v, want %s", row.h, a, row.want)
-		}
-	}
-}
-
-// Review (issue 734 path): an ask taken again by the same node (its build module replaced mid-run) is bounded from the
-// new run's start, not the first run's. The steps' own times stand for the clock: the first run started now, the second a
-// whole bound ago, so the wait ends at once on the second run's bound where the first run's would wait an hour; no case
-// waits on a pause a loaded machine can outlast (the check of 2026-11-02 22:35 tripped one of 60 ms). The context's
-// bound is reached only by a wait that kept the first run's start.
-func TestARedeliveryToTheSameNodeRestartsTheBound(t *testing.T) {
-	f := &FakeAsks{}
-	k := Asker{Publisher: f, Waiter: f, Bound: time.Hour}
-	const id = "mvl0frv18d1962"
-	now := time.Now()
-	f.Write(delivery.Step{ID: id, Node: "ace", State: delivery.StepRunning, Started: now})
-	f.Write(delivery.Step{ID: id, Node: "ace", State: delivery.StepRunning, Started: now.Add(-time.Hour)})
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-	if _, err := k.Wait(ctx, goAsk(id)); err == nil || !strings.Contains(err.Error(), "on ace did not end within 1h0m0s of its start") {
-		t.Fatalf("a redelivered run a bound old: %v, want its own bound to end the wait", err)
-	}
-}
-
-// refusingFollower refuses the first `refuse` follows, as the bus does before the asker's grant is composed.
-type refusingFollower struct {
-	mu     sync.Mutex
-	refuse int
-	n      int
-	hand   func(GivenUp)
-}
-
-func (f *refusingFollower) Follow(_ context.Context, _ string, _ time.Time, heard func(GivenUp)) (func(), error) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	f.n++
-	if f.n <= f.refuse {
-		return nil, errors.New("permissions violation")
-	}
-	f.hand = heard
-	return func() {}, nil
-}
-
-func (f *refusingFollower) calls() int { f.mu.Lock(); defer f.mu.Unlock(); return f.n }
-
-func (f *refusingFollower) heard(g GivenUp) { f.mu.Lock(); h := f.hand; f.mu.Unlock(); h(g) }
-
-// deafWatch is a watch of an ask's step that stays open and hears nothing.
-type deafWatch struct{}
-
-func (deafWatch) WatchAsk(context.Context, string, string) (<-chan delivery.Step, error) {
-	return make(chan delivery.Step), nil
-}
-
-// closingWatch closes its first watch at once, and hands the later ones to inner.
-type closingWatch struct {
-	inner  AskWaiter
-	closed bool
-}
-
-func (c *closingWatch) WatchAsk(ctx context.Context, module, askID string) (<-chan delivery.Step, error) {
-	if !c.closed {
-		c.closed = true
-		ch := make(chan delivery.Step)
-		close(ch)
-		return ch, nil
-	}
-	return c.inner.WatchAsk(ctx, module, askID)
-}

modules/mesh-delivery-builder/buildrun/choose.go

@@ -1,88 +0,0 @@
-package buildrun
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// ChooseNodes picks up to want build nodes for a language (ADR 0478 clause 3): the nodes whose toolchains key reports the
-// version the nodes agree on, the ones with room under their build capacity first (places), then the fewest lanes the
-// part has running or chosen there, a tie broken by the node's name. A place is reserved on each node chosen, in the
-// same step as the choice, so builds choosing at once do not choose the same full node while another has room; the
-// caller takes the place (Places.Acquire) or gives it up (Places.Cancel). A node at its capacity is still chosen when
-// the others are too (fewer than want have room): its lane waits for a place. A node qualifies only when qualifies is true
-// of it (online and its build module healthy; nil means every node does). It answers the toolchain all the reporting nodes
-// agree on, qualifying or not, as the indexer computes it. When nothing is reported, or the nodes report different
-// versions (so the indexer agreed none), it fails naming the language and why; when no reporting node qualifies it fails
-// naming the nodes. A node whose build module refuses on its toolchain refuses the step, and the build fails naming it.
-func ChooseNodes(language string, entries []delivery.NodeToolchain, places *Places, qualifies func(node string) bool, want int) ([]string, delivery.Toolchain2, error) {
-	tc, none := delivery.AgreedToolchain(entries)
-	if none != "" {
-		return nil, delivery.Toolchain2{}, fmt.Errorf("no %s build node qualifies: %s", language, none)
-	}
-	nodes, err := choose(language, entries, places, qualifies, want)
-	return nodes, tc, err
-}
-
-// ChooseAnyNodes is ChooseNodes for artifacts that need no toolchain, such as an archive (ADR 0478 clause 1): the
-// build module's nodes agree on nothing, so any node of the build module that qualifies is chosen, by capacity and load only.
-func ChooseAnyNodes(language string, entries []delivery.NodeToolchain, places *Places, qualifies func(node string) bool, want int) ([]string, error) {
-	return choose(language, entries, places, qualifies, want)
-}
-
-func choose(language string, entries []delivery.NodeToolchain, places *Places, qualifies func(node string) bool, want int) ([]string, error) {
-	if places == nil {
-		places = &Places{}
-	}
-	nodes := make([]string, 0, len(entries))
-	var reporting []string
-	seen := map[string]bool{}
-	for _, e := range entries {
-		if seen[e.Node] {
-			continue
-		}
-		seen[e.Node] = true
-		reporting = append(reporting, e.Node)
-		if places.CapacityOf(e.Node) > 0 && (qualifies == nil || qualifies(e.Node)) { // a capacity of 0 keeps the part off a node
-			nodes = append(nodes, e.Node)
-		}
-	}
-	if len(nodes) == 0 {
-		sort.Strings(reporting)
-		return nil, fmt.Errorf("no %s build node qualifies: %s report the toolchain, and none is online with a healthy build module and a build capacity", language, strings.Join(reporting, ", "))
-	}
-	return places.choose(nodes, want), nil
-}
-
-// DigestsDifferPrefix opens the error of a build whose nodes built an artifact to different digests (ADR 0478 clause 4):
-// such a key is not built again as a new revision, since the same source on the same toolchains gave two answers and
-// building again settles nothing; it waits for another fingerprint.
-const DigestsDifferPrefix = "digests differ:"
-
-// Agree is the one digest every node built an artifact to (ADR 0478 clause 4), or an error naming each node and its
-// digest when they differ. One node's digest agrees with itself.
-func Agree(artifact string, byNode map[string]string) (string, error) {
-	nodes := make([]string, 0, len(byNode))
-	for n := range byNode {
-		nodes = append(nodes, n)
-	}
-	sort.Strings(nodes)
-	var first string
-	for i, n := range nodes {
-		if i == 0 {
-			first = byNode[n]
-			continue
-		}
-		if byNode[n] != first {
-			msg := fmt.Sprintf("%s the nodes built %s to different digests:", DigestsDifferPrefix, artifact)
-			for _, n := range nodes {
-				msg += fmt.Sprintf(" %s %s;", n, byNode[n])
-			}
-			return "", fmt.Errorf("%s", msg[:len(msg)-1])
-		}
-	}
-	return first, nil
-}

modules/mesh-delivery-builder/buildrun/choose_test.go

@@ -1,109 +0,0 @@
-package buildrun
-
-import (
-	"strings"
-	"testing"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-const digest = "sha256:2222222222222222222222222222222222222222222222222222222222222222"
-
-func hex64(c byte) string { return strings.Repeat(string(c), 64) }
-
-func tcs(language, version string, nodes ...string) []delivery.NodeToolchain {
-	var out []delivery.NodeToolchain
-	for _, n := range nodes {
-		out = append(out, delivery.NodeToolchain{Node: n, Toolchain: delivery.Toolchain{Language: language, Version: version, Recipe: "1"}})
-	}
-	return out
-}
-
-func chooseTakesTheAgreedNodesWithFewestRunningStepsTiesByName(t *testing.T) { // 1607/AC4, ADR 0478 clause 3
-	entries := tcs("go", "go1.27.1", "novox", "ace", "g14", "shanks")
-	nodes, tc, err := ChooseNodes("go", entries, placesRunning(map[string]int{"novox": 3, "ace": 1, "g14": 1, "shanks": 0}), nil, 2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(nodes) != 2 || nodes[0] != "shanks" || nodes[1] != "ace" {
-		t.Errorf("nodes = %v, want [shanks ace]: fewest steps first, a tie by name", nodes)
-	}
-	if tc.Version != "go1.27.1" || tc.Recipe != "1" || tc.Language != "go" {
-		t.Errorf("toolchain = %+v", tc)
-	}
-}
-
-func chooseWithOneNodeAnswersOneNode(t *testing.T) { // 1607/AC4
-	nodes, _, err := ChooseNodes("go", tcs("go", "go1.27.1", "novox"), nil, nil, 2)
-	if err != nil || len(nodes) != 1 || nodes[0] != "novox" {
-		t.Errorf("nodes = %v, err %v, want [novox]", nodes, err)
-	}
-}
-
-func chooseFailsNamingTheLanguageAndTheVersionsWhenNoNodeQualifies(t *testing.T) { // 1607/AC4
-	_, _, err := ChooseNodes("typescript", nil, nil, nil, 2)
-	if err == nil || !strings.Contains(err.Error(), "typescript") || !strings.Contains(err.Error(), delivery.ToolchainNoReport) {
-		t.Errorf("no report: error = %v, want it to name typescript and %q", err, delivery.ToolchainNoReport)
-	}
-	entries := append(tcs("go", "go1.27.1", "novox"), tcs("go", "go1.26.0", "ace")...)
-	_, _, err = ChooseNodes("go", entries, nil, nil, 2)
-	if err == nil || !strings.Contains(err.Error(), "go1.27.1") || !strings.Contains(err.Error(), "go1.26.0") || !strings.Contains(err.Error(), "go") {
-		t.Errorf("disagreeing nodes: error = %v, want both versions named", err)
-	}
-}
-
-func agreeNeedsEqualDigestsAndNamesBothNodesWhenTheyDiffer(t *testing.T) { // 1607/AC4, ADR 0478 clause 4
-	d, err := Agree("tool", map[string]string{"ace": digest, "novox": digest})
-	if err != nil || d != digest {
-		t.Errorf("Agree = %q, %v, want %q", d, err, digest)
-	}
-	_, err = Agree("tool", map[string]string{"ace": digest, "novox": "sha256:" + hex64('9')})
-	if err == nil || !strings.Contains(err.Error(), "ace") || !strings.Contains(err.Error(), "novox") || !strings.Contains(err.Error(), digest) || !strings.Contains(err.Error(), hex64('9')) || !strings.Contains(err.Error(), "tool") {
-		t.Errorf("differing digests: error = %v, want the artifact, both nodes and both digests", err)
-	}
-	if d, err := Agree("tool", map[string]string{"ace": digest}); err != nil || d != digest {
-		t.Errorf("one node: %q, %v", d, err)
-	}
-}
-
-func chooseSkipsNodesThatAreNotOnlineAndFailsNamingThemWhenNoneIs(t *testing.T) { // 1607 review 3, ADR 0478 clause 3
-	entries := tcs("go", "go1.27.1", "ace", "g14", "novox")
-	online := func(n string) bool { return n != "g14" } // a sleeping laptop
-	nodes, tc, err := ChooseNodes("go", entries, placesRunning(map[string]int{"novox": 5}), online, 2)
-	if err != nil || len(nodes) != 2 || nodes[0] != "ace" || nodes[1] != "novox" || tc.Version != "go1.27.1" {
-		t.Errorf("nodes = %v, toolchain %+v, err %v, want [ace novox] with g14 left out although it runs nothing", nodes, tc, err)
-	}
-	_, tc, err = ChooseNodes("go", entries, nil, func(string) bool { return false }, 2)
-	if err == nil || !strings.Contains(err.Error(), "online") || !strings.Contains(err.Error(), "g14") || !strings.Contains(err.Error(), "go") {
-		t.Errorf("none online: error = %v, want it to name the nodes that report and that none is online", err)
-	}
-	if tc.Version != "go1.27.1" {
-		t.Errorf("none online: the agreed toolchain %+v is still answered", tc)
-	}
-}
-
-// placesRunning is Places with these steps counted as running, for a test of the choice.
-func placesRunning(running map[string]int) *Places {
-	return &Places{running: running, changed: make(chan struct{})}
-}
-
-func choosePrefersNodesBelowTheirCapacity(t *testing.T) { // round 3
-	entries := tcs("go", "go1.27.1", "ace", "novox", "shanks")
-	// shanks has capacity 3 with 2 running: room; ace has the default 1 with 1 running: none; novox has none running.
-	p := placesRunning(map[string]int{"shanks": 2, "ace": 1})
-	p.Capacity = map[string]int{"shanks": 3}
-	nodes, _, err := ChooseNodes("go", entries, p, nil, 2)
-	if err != nil || len(nodes) != 2 || nodes[0] != "novox" || nodes[1] != "shanks" {
-		t.Errorf("nodes = %v, err %v, want [novox shanks]: the nodes with room, ace at capacity left out", nodes, err)
-	}
-}
-
-// The choice of the nodes a step runs on and the agreement of their answers, one table of cases (the test budget).
-func TestChoosingTheNodesOfAStep(t *testing.T) {
-	t.Run("choose takes the agreed nodes with fewest running steps ties by name", chooseTakesTheAgreedNodesWithFewestRunningStepsTiesByName)
-	t.Run("choose with one node answers one node", chooseWithOneNodeAnswersOneNode)
-	t.Run("choose fails naming the language and the versions when no node qualifies", chooseFailsNamingTheLanguageAndTheVersionsWhenNoNodeQualifies)
-	t.Run("agree needs equal digests and names both nodes when they differ", agreeNeedsEqualDigestsAndNamesBothNodesWhenTheyDiffer)
-	t.Run("choose skips nodes that are not online and fails naming them when none is", chooseSkipsNodesThatAreNotOnlineAndFailsNamingThemWhenNoneIs)
-	t.Run("choose prefers nodes below their capacity", choosePrefersNodesBelowTheirCapacity)
-}

modules/mesh-delivery-builder/buildrun/doc.go

@@ -1,5 +0,0 @@
-// Package buildrun holds the parts every module that runs steps on the build modules shares: the caller, the steps
-// watch and the runner of a long step (ADR 0469), the sets of presence, toolchains and healthy build modules, the
-// places a node offers by capacity, and the choice of build nodes (ADR 0478). The builder and the checker of the
-// delivery use them; they moved here from the builder's own package so neither keeps a copy (issue 1671, ADR 0484).
-package buildrun

modules/mesh-delivery-builder/buildrun/go.mod

@@ -1,23 +0,0 @@
-module git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun
-
-go 1.26.0
-
-require (
-	git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261104174359-05b3e2e1b94f
-	github.com/nats-io/nats.go v1.54.0
-)
-
-require (
-	git.novox.be/novox/mesh-contracts/go v0.0.0-20261104174344-ae5266e77639 // indirect
-	github.com/antithesishq/antithesis-sdk-go v0.8.0-default-no-op // indirect
-	github.com/google/go-tpm v0.9.8 // indirect
-	github.com/klauspost/compress v1.20.1 // indirect
-	github.com/minio/highwayhash v1.0.4 // indirect
-	github.com/nats-io/jwt/v2 v2.8.2 // indirect
-	github.com/nats-io/nats-server/v2 v2.11.17 // indirect
-	github.com/nats-io/nkeys v0.4.16 // indirect
-	github.com/nats-io/nuid v1.0.1 // indirect
-	golang.org/x/crypto v0.57.0 // indirect
-	golang.org/x/sys v0.48.0 // indirect
-	golang.org/x/time v0.16.0 // indirect
-)

modules/mesh-delivery-builder/buildrun/go.sum

@@ -1,29 +0,0 @@
-git.novox.be/novox/mesh-contracts/go v0.0.0-20261104174344-ae5266e77639 h1:Zt7CfWt2S2W/fVgWNyW2u2+xwz051LXvGxVTNIyfhdM=
-git.novox.be/novox/mesh-contracts/go v0.0.0-20261104174344-ae5266e77639/go.mod h1:0dD1XEJBJ0G5UYDQxSZI84nuujb6m3tOpJl4C8rQVvg=
-git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261104174359-05b3e2e1b94f h1:jDsfDMd48MXY9Zershc3eRxnhmx2sSpUfQkLq5jAIds=
-git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261104174359-05b3e2e1b94f/go.mod h1:08OomDXdwVN8/87nyDtv5R3rH/6LoP8SFFXz30bTYCM=
-github.com/antithesishq/antithesis-sdk-go v0.8.0-default-no-op h1:1BOWQJweNyvZMlpAHXGLiZQn9S+QXGcz3xh94lC0w6E=
-github.com/antithesishq/antithesis-sdk-go v0.8.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.1 h1:T7kKElXUMXrUJ2E9QhQhxFtcK5rPyLdsGZvdbLMPdiQ=
-github.com/klauspost/compress v1.20.1/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.2 h1:XXRgB60MSTnqsRwejQurVDs/hcv2dkt+86GjI+I/bMc=
-github.com/nats-io/jwt/v2 v2.8.2/go.mod h1:Ag/56sq9OblL4JgdYufDd16Egb17Kr/8WwwuO/forVc=
-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=
-github.com/nats-io/nkeys v0.4.16/go.mod h1:llLgWoI0o4z/Q57q2R1kHfmocyhGV6VG/U18Glg1Afs=
-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.16.0 h1:vMb6ptszcQMkcwiRTAuNNU50gom6++Q/6gY2hDM6VDE=
-golang.org/x/time v0.16.0/go.mod h1:rVKOqvZeKvrDKTQiAHJ7wmwP0RzleSphoEA9RcdLA0s=

modules/mesh-delivery-builder/buildrun/have.go

@@ -1,56 +0,0 @@
-package buildrun
-
-import (
-	"sync"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// HaveSet holds what each node's node-engine says of each module on it (node-engine_have, key `<node>.<module>`): the
-// builder reads it to know whether a node's build module is running and healthy, since a build module whose installed
-// toolchain is not the one its recipe builds with is unhealthy (mesh-build-go build_go_health) and its steps would
-// refuse (ADR 0478 clause 3). A module the node-engine has written no key of is not healthy. Safe for use from the watch
-// and from a build at once.
-type HaveSet struct {
-	mu      sync.Mutex
-	healthy map[string]bool // by `<node>.<module>`
-}
-
-// Put takes a change of the have bucket in and answers whether a module's healthy state changed. A node's own key
-// (`<node>.node`) and a value that is not a have are left out.
-func (s *HaveSet) Put(key string, value []byte, deleted bool) bool {
-	node, module, isNode, err := delivery.ParseHaveKey(key)
-	if err != nil || isNode {
-		return false
-	}
-	ok := false
-	if !deleted {
-		h, err := delivery.DecodeHave(value)
-		if err != nil {
-			return false
-		}
-		ok = h.Phase == delivery.PhaseRunning && h.Health == delivery.HealthOK
-	}
-	k := node + "." + module
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if s.healthy[k] == ok {
-		return false
-	}
-	if s.healthy == nil {
-		s.healthy = map[string]bool{}
-	}
-	if ok {
-		s.healthy[k] = true
-	} else {
-		delete(s.healthy, k)
-	}
-	return true
-}
-
-// Healthy is whether the module on the node was last seen running and healthy.
-func (s *HaveSet) Healthy(node, module string) bool {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	return s.healthy[node+"."+module]
-}

modules/mesh-delivery-builder/buildrun/heardends.go

@@ -1,236 +0,0 @@
-package buildrun
-
-import (
-	"context"
-	"fmt"
-	"sync"
-
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// **A step's end is never only its own watch's to hear** (the lost check of 2026-10-28: mesh-catalog #553's verdict
-// stayed running after its step mvsgthyjed5786 had passed on shanks at 19:09:31Z; the watch of that one key, opened at
-// 18:46:05Z, heard neither the step's start nor its end and never closed, while a watch opened at 18:58:48Z heard its own
-// step end). HeardEnds stands between the asker (Asker) and the watch of each ask's step key: when it is
-// nudged, every ask it waits on reads its step keys now (a read, not the watch) and hands what it reads to its wait, so a
-// step that ended is judged even when its own watch went deaf. A watch that closes under a wait is opened again, at most
-// reopenTries times. It is nudged on an event (Nudge): any step of the same build module ending (one watch of each steps
-// state, HearEnds), a reconnect to the bus, and whatever else the asker hears (the checker: checker_ask_again).
-// It holds no timer. Every asker of the build seats waits through it (the checker and the builder, HearEnds).
-
-// StepReader reads, now, every step a build module's steps state holds for an ask: its keys `*.<ask id>`.
-type StepReader interface {
-	AskSteps(ctx context.Context, module, askID string) ([]delivery.Step, error)
-}
-
-// reopenTries is how often a wait opens its ask's watch again after it closed, before the wait ends failed.
-const reopenTries = 3
-
-// HeardEnds is an AskWaiter over Inner that also reads an ask's steps when nudged. Safe for concurrent use.
-type HeardEnds struct {
-	Inner AskWaiter
-	Read  StepReader
-	Logf  func(format string, args ...any)
-
-	mu      sync.Mutex
-	waiting map[string]*waitedAsk // by ask id
-}
-
-type waitedAsk struct {
-	module string
-	nudge  chan struct{}
-}
-
-func (h *HeardEnds) logf(format string, args ...any) {
-	if h.Logf != nil {
-		h.Logf(format, args...)
-	}
-}
-
-// WatchAsk is AskWaiter's: what Inner's watch hands, and, at each nudge, what the ask's keys hold now.
-func (h *HeardEnds) WatchAsk(ctx context.Context, module, askID string) (<-chan delivery.Step, error) {
-	in, err := h.Inner.WatchAsk(ctx, module, askID)
-	if err != nil {
-		return nil, err
-	}
-	w := &waitedAsk{module: module, nudge: make(chan struct{}, 1)}
-	h.mu.Lock()
-	if h.waiting == nil {
-		h.waiting = map[string]*waitedAsk{}
-	}
-	h.waiting[askID] = w
-	h.mu.Unlock()
-	out := make(chan delivery.Step)
-	go func() {
-		defer close(out)
-		defer func() {
-			h.mu.Lock()
-			if h.waiting[askID] == w {
-				delete(h.waiting, askID)
-			}
-			h.mu.Unlock()
-		}()
-		send := func(s delivery.Step) bool {
-			select {
-			case out <- s:
-				return true
-			case <-ctx.Done():
-				return false
-			}
-		}
-		reopened := 0
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			case s, ok := <-in:
-				if !ok {
-					if ctx.Err() != nil || reopened >= reopenTries {
-						h.logf("the watch of the ask %s's step on %s closed %d times; its wait ends", askID, module, reopened+1)
-						return
-					}
-					reopened++
-					if in, err = h.Inner.WatchAsk(ctx, module, askID); err != nil {
-						h.logf("the watch of the ask %s's step on %s closed and cannot be opened again, so its wait ends: %v", askID, module, err)
-						return
-					}
-					h.logf("the watch of the ask %s's step on %s closed; opened again (%d of %d)", askID, module, reopened, reopenTries)
-					continue
-				}
-				if !send(s) {
-					return
-				}
-			case <-w.nudge:
-				if h.Read == nil {
-					continue
-				}
-				steps, err := h.Read.AskSteps(ctx, module, askID)
-				if err != nil {
-					h.logf("the steps of the ask %s on %s cannot be read: %v", askID, module, err)
-					continue
-				}
-				for _, s := range steps {
-					if s.State != delivery.StepRunning {
-						h.logf("the ask %s's step on %s ended %s, read at a nudge: its watch had not handed it over", askID, s.Node, s.State)
-					}
-					if !send(s) {
-						return
-					}
-				}
-			}
-		}
-	}()
-	return out, nil
-}
-
-// Nudge has every ask waited on of module read its steps now; module "" nudges every ask.
-func (h *HeardEnds) Nudge(module string) {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-	for _, w := range h.waiting {
-		if module == "" || w.module == module {
-			select {
-			case w.nudge <- struct{}{}:
-			default: // a nudge is pending already
-			}
-		}
-	}
-}
-
-// Waiting is how many asks are waited on now.
-func (h *HeardEnds) Waiting() int {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-	return len(h.waiting)
-}
-
-// AskSteps is StepReader's: the keys `*.<ask id>` of the build module's steps state, read now.
-func (s JetStreamAsks) AskSteps(ctx context.Context, module, askID string) ([]delivery.Step, error) {
-	pattern, err := delivery.AskStepWatch(askID)
-	if err != nil {
-		return nil, err
-	}
-	kv, err := s.JS.KeyValue(ctx, delivery.StepsBucket(module))
-	if err != nil {
-		return nil, fmt.Errorf("the bucket %s: %w", delivery.StepsBucket(module), err)
-	}
-	lister, err := kv.ListKeysFiltered(ctx, pattern)
-	if err != nil {
-		return nil, err
-	}
-	var out []delivery.Step
-	for key := range lister.Keys() {
-		e, err := kv.Get(ctx, key)
-		if err != nil {
-			continue // deleted between the list and the read
-		}
-		if step, err := delivery.DecodeStep(e.Value()); err == nil {
-			out = append(out, step)
-		}
-	}
-	return out, nil
-}
-
-// HearEnds is the HeardEnds every asker of the build seats waits through: over inner (the asks' own watches, or a
-// LostAskWaiter's inner), reading with asks, and nudged at each step end of each of modules (one watch of each steps state,
-// updates only; one that closes is opened again, and said and left after reopenTries closes in a row that heard nothing). The asker nudges it at a reconnect too (Nudge("")).
-func HearEnds(ctx context.Context, asks JetStreamAsks, inner AskWaiter, modules []string, logf func(string, ...any)) *HeardEnds {
-	if logf == nil {
-		logf = func(string, ...any) {}
-	}
-	h := &HeardEnds{Inner: inner, Read: asks, Logf: logf}
-	for _, module := range modules {
-		kv, err := asks.JS.KeyValue(ctx, delivery.StepsBucket(module))
-		if err != nil {
-			logf("the steps of %s cannot be read (%v): an ask whose own watch goes deaf is read only at a reconnect", module, err)
-			continue
-		}
-		go h.follow(ctx, kv, module)
-	}
-	return h
-}
-
-func (h *HeardEnds) follow(ctx context.Context, kv jetstream.KeyValue, module string) {
-	silent := 0 // closes in a row having heard nothing
-	for ctx.Err() == nil {
-		w, err := kv.WatchAll(ctx, jetstream.UpdatesOnly())
-		if err != nil {
-			h.logf("the steps of %s cannot be watched, so an ask whose own watch goes deaf is read only at a reconnect: %v", module, err)
-			return
-		}
-		heard := false
-		for e := range w.Updates() {
-			if e == nil || e.Operation() != jetstream.KeyValuePut {
-				continue
-			}
-			heard = true
-			if step, err := delivery.DecodeStep(e.Value()); err == nil && step.State != delivery.StepRunning {
-				h.Nudge(module)
-			}
-		}
-		_ = w.Stop()
-		if ctx.Err() != nil {
-			return
-		}
-		h.Nudge(module) // a step may have ended while the watch was closing
-		if heard {
-			silent = 0
-		} else if silent++; silent >= reopenTries {
-			h.logf("the watch of the steps of %s closed %d times in a row having heard nothing, so it is left: an ask whose own watch goes deaf is read only at a reconnect", module, silent)
-			return
-		}
-		h.logf("the watch of the steps of %s closed; opened again", module)
-	}
-}
-
-// AskSteps is StepReader's: the last step written for the ask, if any.
-func (f *FakeAsks) AskSteps(_ context.Context, _ string, askID string) ([]delivery.Step, error) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	if s := f.steps[askID]; len(s) > 0 {
-		return []delivery.Step{s[len(s)-1]}, nil
-	}
-	return nil, nil
-}

modules/mesh-delivery-builder/buildrun/lostask.go

@@ -1,503 +0,0 @@
-package buildrun
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-	"git.novox.be/novox/mesh-sdk/go/health"
-	"git.novox.be/novox/mesh-sdk/go/process"
-)
-
-// **An ask the build seat gave up on ends its step** (novox/hq issue 734). A build seat's worker offers an ask
-// delivery.AskMaxDeliver times; one handed out that often without an answer (a bus reload that drops every hand-out, a node
-// that dies taking it each time) is given up by the server, and the controller keeps a copy of it in DEAD_LETTERS under
-// mesh.events.dead.<seat stream>.<worker>, with the ask's message id (its ask id), how often it was handed out and when it
-// was given up. No build node writes a step for it, so an asker that waits for the step waits for ever: a try stays
-// running and holds a try place, a check's verdict stays running and its pull request waits.
-//
-// An asker of the build seats (the checker, the builder) hears those copies (DeadLetterHearing: an ordered consumer on
-// DEAD_LETTERS filtered to the build seats' streams, granted to a user of a seat pulled by kind, buscompose
-// DeadLetterReads) into DeadLetters, and LostAskWaiter ends the waiting step at once as failed on the node LostNode, its
-// reason saying LostWords; the asker decides what follows (the checker ends a try as error and asks a check again, the
-// builder asks its part of a build again).
-//
-// Belt and braces, where the asker says so in the context (NotTakenBound; the checker's tries): an ask no build node took
-// within a bound ends the same way, saying NotTakenWords. An ask waits in the stream as long as the backlog is otherwise
-// (ADR 0525 §9): a backlog is no fault.
-
-// LostNode is the node a step ended for a lost ask names: no build node wrote it.
-const LostNode = "bus"
-
-// The words of a step ended for its ask.
-const (
-	LostWords     = "its ask was given up by the build seat"
-	NotTakenWords = "no build node took its ask"
-)
-
-// The headers the controller keeps a given-up message's copy with in DEAD_LETTERS (mesh-controller internal/link
-// deadletters.go): the original message id (an ask's is its ask id), how often it was handed out, when it was given up.
-const (
-	DeadHeaderMsgID      = "Mesh-Dead-Msg-Id"
-	DeadHeaderDeliveries = "Mesh-Dead-Deliveries"
-	DeadHeaderGaveUp     = "Mesh-Dead-Gave-Up"
-	DeadHeaderStream     = "Mesh-Dead-Stream"
-)
-
-// DeadLettersStream is the stream the controller keeps given-up messages in, and DeadLetterFilter the subjects of one seat
-// stream's copies there (buscompose DeadLetterSubject).
-const DeadLettersStream = "DEAD_LETTERS"
-
-// DeadLetterFilter is the subjects DEAD_LETTERS keeps a seat stream's given-up messages under.
-func DeadLetterFilter(stream string) string { return "mesh.events.dead." + stream + ".>" }
-
-// SeatStream is the stream of a build seat's language (buscompose seatStreamName of node-build-<language>).
-func SeatStream(language string) string { return "SEAT_NODE_BUILD_" + strings.ToUpper(language) }
-
-// GivenUp is one ask a build seat gave up on, as DEAD_LETTERS keeps it.
-type GivenUp struct {
-	AskID      string
-	Stream     string
-	Deliveries int
-	At         time.Time
-}
-
-// GivenUpOf reads a DEAD_LETTERS copy's headers; false when it names no message id.
-func GivenUpOf(header map[string][]string) (GivenUp, bool) {
-	get := func(k string) string {
-		if v := header[k]; len(v) > 0 {
-			return strings.TrimSpace(v[0])
-		}
-		return ""
-	}
-	g := GivenUp{AskID: get(DeadHeaderMsgID), Stream: get(DeadHeaderStream)}
-	if g.AskID == "" {
-		return GivenUp{}, false
-	}
-	g.Deliveries, _ = strconv.Atoi(get(DeadHeaderDeliveries))
-	g.At, _ = time.Parse(time.RFC3339Nano, get(DeadHeaderGaveUp))
-	return g, true
-}
-
-// Words are what a step ended for the given-up ask says.
-func (g GivenUp) Words() string {
-	at := "at an unknown time"
-	if !g.At.IsZero() {
-		at = "at " + g.At.UTC().Format(time.RFC3339)
-	}
-	return fmt.Sprintf("%s after %d deliveries %s (kept in %s); ask again", LostWords, g.Deliveries, at, DeadLettersStream)
-}
-
-// keptGivenUp is how many given-up asks DeadLetters remembers for a waiter that starts after the copy was heard.
-const keptGivenUp = 1024
-
-// DeadLetters holds the given-up asks heard, and hands each to the waiter of its ask. Safe for concurrent use.
-type DeadLetters struct {
-	mu       sync.Mutex
-	heard    map[string]GivenUp
-	order    []string
-	watchers map[string][]chan GivenUp
-}
-
-// Heard takes one given-up ask in.
-func (d *DeadLetters) Heard(g GivenUp) {
-	d.mu.Lock()
-	if d.heard == nil {
-		d.heard, d.watchers = map[string]GivenUp{}, map[string][]chan GivenUp{}
-	}
-	if _, ok := d.heard[g.AskID]; !ok {
-		d.order = append(d.order, g.AskID)
-		if len(d.order) > keptGivenUp {
-			delete(d.heard, d.order[0])
-			d.order = d.order[1:]
-		}
-	}
-	d.heard[g.AskID] = g
-	ws := d.watchers[g.AskID]
-	delete(d.watchers, g.AskID)
-	d.mu.Unlock()
-	for _, w := range ws {
-		w <- g // buffered, one each
-	}
-}
-
-// watch answers a channel that gets the ask's given-up copy once (at once when it was heard already), and its cancel.
-func (d *DeadLetters) watch(askID string) (<-chan GivenUp, func()) {
-	ch := make(chan GivenUp, 1)
-	d.mu.Lock()
-	defer d.mu.Unlock()
-	if d.heard == nil {
-		d.heard, d.watchers = map[string]GivenUp{}, map[string][]chan GivenUp{}
-	}
-	if g, ok := d.heard[askID]; ok {
-		ch <- g
-		return ch, func() {}
-	}
-	d.watchers[askID] = append(d.watchers[askID], ch)
-	return ch, func() {
-		d.mu.Lock()
-		defer d.mu.Unlock()
-		ws := d.watchers[askID]
-		for i, w := range ws {
-			if w == ch {
-				d.watchers[askID] = append(ws[:i], ws[i+1:]...)
-				break
-			}
-		}
-		if len(d.watchers[askID]) == 0 {
-			delete(d.watchers, askID)
-		}
-	}
-}
-
-type notTakenKey struct{}
-
-// NotTakenBound says, in ctx, that an ask no build node took within bound ends its step (a try's, never a check's).
-func NotTakenBound(ctx context.Context, bound time.Duration) context.Context {
-	return context.WithValue(ctx, notTakenKey{}, bound)
-}
-
-func notTakenBoundOf(ctx context.Context) time.Duration {
-	d, _ := ctx.Value(notTakenKey{}).(time.Duration)
-	return d
-}
-
-// LostAskWaiter is an AskWaiter that ends an ask's step when the build seat gave the ask up (DeadLetters), or, under
-// NotTakenBound, when no build node took it within the bound: it hands the asker a failed step whose reason says why, on
-// the node "bus". Every step the build module writes is handed on as it is.
-type LostAskWaiter struct {
-	Inner AskWaiter
-	Dead  *DeadLetters
-	// Hearing, when set, is asked to hear DEAD_LETTERS again each time an ask is waited for while it cannot: an ask put is
-	// the event that makes hearing matter.
-	Hearing interface {
-		Deaf() string
-		Again()
-	}
-	Now func() time.Time
-}
-
-func (w LostAskWaiter) now() time.Time {
-	if w.Now != nil {
-		return w.Now()
-	}
-	return time.Now()
-}
-
-// WatchAsk is AskWaiter's.
-func (w LostAskWaiter) WatchAsk(ctx context.Context, module, askID string) (<-chan delivery.Step, error) {
-	if w.Hearing != nil && w.Hearing.Deaf() != "" {
-		w.Hearing.Again()
-	}
-	inner, err := w.Inner.WatchAsk(ctx, module, askID)
-	if err != nil {
-		return nil, err
-	}
-	var dead <-chan GivenUp
-	cancel := func() {}
-	if w.Dead != nil {
-		dead, cancel = w.Dead.watch(askID)
-	}
-	// The not-taken bound is a context's (ADR 0437 §8: no timer), ended when a node takes the ask.
-	var notTaken <-chan struct{}
-	bound := notTakenBoundOf(ctx)
-	stopBound := func() {}
-	if bound > 0 {
-		var nt context.Context
-		nt, stopBound = context.WithTimeout(context.Background(), bound)
-		notTaken = nt.Done()
-	}
-	out := make(chan delivery.Step)
-	go func() {
-		defer close(out)
-		defer cancel()
-		defer func() { stopBound() }()
-		send := func(s delivery.Step) bool {
-			select {
-			case out <- s:
-				return true
-			case <-ctx.Done():
-				return false
-			}
-		}
-		ended := func(reason string) delivery.Step {
-			at := w.now().UTC()
-			return delivery.Step{ID: askID, Node: LostNode, State: delivery.StepFailed, Reason: reason, Ended: at}
-		}
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			case s, ok := <-inner:
-				if !ok {
-					return
-				}
-				if notTaken != nil {
-					stopBound() // a node took it: its step is bounded by the asker from its start
-					notTaken = nil
-				}
-				if !send(s) {
-					return
-				}
-			case g := <-dead:
-				dead = nil
-				send(ended(g.Words()))
-				return
-			case <-notTaken:
-				send(ended(fmt.Sprintf("%s within %s of its put; it was lost or waits behind a backlog; ask again", NotTakenWords, bound)))
-				return
-			}
-		}
-	}()
-	return out, nil
-}
-
-// IsLost says whether a step was ended by LostAskWaiter because the build seat gave its ask up (LostWords).
-func IsLost(s delivery.Step) bool { return s.Node == LostNode && strings.Contains(s.Reason, LostWords) }
-
-// IsNotTaken says whether a step was ended by LostAskWaiter because no build node took its ask within the bound.
-func IsNotTaken(s delivery.Step) bool {
-	return s.Node == LostNode && strings.Contains(s.Reason, NotTakenWords)
-}
-
-// **The asker hears DEAD_LETTERS, tries again when it cannot, and says whether it hears** (issue 734). The read is
-// granted with the asker's seat traffic (buscompose DeadLetterReads); an asker started before its grant was composed is
-// refused, and an asker that only tried once would stay deaf until it starts again, silently. DeadLetterHearing tries in
-// the background, never holding the start up, and again on an event (Again): the asker's reconnect to the bus, and every
-// ask waited for while it is deaf (LostAskWaiter.Hearing); no timer. Each change of whether it hears is said (Said), so
-// the module's health tool says it: a deaf asker is not healthy.
-
-// Hearing is what a DeadLetterHearing says: whether it hears every build seat stream it follows, and why not.
-type Hearing struct {
-	Heard   bool      `json:"heard"`
-	Streams []string  `json:"streams"`
-	Why     string    `json:"why,omitempty"`
-	At      time.Time `json:"at"`
-}
-
-// HearingKey is the key a module keeps its Hearing under, in its own state (the checker's and the builder's hearing).
-const HearingKey = "dead-letters"
-
-// DeadLetterFollower starts following one seat stream's copies in DEAD_LETTERS from since, handing each given-up ask to
-// heard; it answers the stop, or why it cannot.
-type DeadLetterFollower interface {
-	Follow(ctx context.Context, stream string, since time.Time, heard func(GivenUp)) (func(), error)
-}
-
-// JetStreamDeadLetters is the bus side of a DeadLetterFollower: an ordered consumer on DEAD_LETTERS filtered to the
-// stream's copies, which resumes where it was after a reconnect and, reset before it heard any, starts at since again.
-type JetStreamDeadLetters struct{ JS jetstream.JetStream }
-
-// Follow is DeadLetterFollower's.
-func (j JetStreamDeadLetters) Follow(ctx context.Context, stream string, since time.Time, heard func(GivenUp)) (func(), error) {
-	cons, err := j.JS.OrderedConsumer(ctx, DeadLettersStream, jetstream.OrderedConsumerConfig{
-		FilterSubjects: []string{DeadLetterFilter(stream)}, DeliverPolicy: jetstream.DeliverByStartTimePolicy, OptStartTime: &since})
-	if err != nil {
-		return nil, err
-	}
-	cc, err := cons.Consume(func(m jetstream.Msg) {
-		if g, ok := GivenUpOf(m.Headers()); ok {
-			heard(g)
-		}
-	})
-	if err != nil {
-		return nil, err
-	}
-	return cc.Stop, nil
-}
-
-// DeadLetterHearing follows the build seats' given-up asks into Dead. Make it with NewDeadLetterHearing.
-type DeadLetterHearing struct {
-	follower DeadLetterFollower
-	streams  []string
-	dead     *DeadLetters
-	logf     func(string, ...any)
-	said     func(Hearing)
-	ctx      context.Context
-	since    time.Time
-
-	mu     sync.Mutex
-	stops  map[string]func()
-	why    map[string]string
-	trying bool
-	again  bool
-	told   *Hearing
-	wg     sync.WaitGroup
-}
-
-// NewDeadLetterHearing starts hearing the given-up asks of each language's build seat stream, in the background. said
-// is told each change of whether it hears (nil tells nothing); ctx ends it.
-func NewDeadLetterHearing(ctx context.Context, follower DeadLetterFollower, languages []string, dead *DeadLetters,
-	logf func(string, ...any), said func(Hearing)) *DeadLetterHearing {
-	h := &DeadLetterHearing{follower: follower, dead: dead, logf: logf, said: said, ctx: ctx, since: time.Now(),
-		stops: map[string]func(){}, why: map[string]string{}}
-	for _, l := range languages {
-		s := SeatStream(l)
-		h.streams = append(h.streams, s)
-		h.why[s] = "not tried yet"
-	}
-	if h.logf == nil {
-		h.logf = func(string, ...any) {}
-	}
-	h.Again()
-	return h
-}
-
-// Deaf says why a stream is not heard, or "" when every one is.
-func (h *DeadLetterHearing) Deaf() string {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-	return h.deafLocked()
-}
-
-func (h *DeadLetterHearing) deafLocked() string {
-	var out []string
-	for _, s := range h.streams {
-		if why, deaf := h.why[s]; deaf {
-			out = append(out, s+": "+why)
-		}
-	}
-	if len(out) == 0 {
-		return ""
-	}
-	return DeadLettersStream + " is not heard, so an ask a build seat gives up on is waited for until its bound: " +
-		strings.Join(out, "; ")
-}
-
-// Again tries, in the background, every stream not heard yet; a call while it tries makes it try once more after.
-func (h *DeadLetterHearing) Again() {
-	h.mu.Lock()
-	if h.trying {
-		h.again = true
-		h.mu.Unlock()
-		return
-	}
-	h.trying = true
-	h.mu.Unlock()
-	h.wg.Add(1)
-	go func() {
-		defer h.wg.Done()
-		for {
-			h.try()
-			h.mu.Lock()
-			if !h.again || h.ctx.Err() != nil {
-				h.trying = false
-				h.mu.Unlock()
-				return
-			}
-			h.again = false
-			h.mu.Unlock()
-		}
-	}()
-}
-
-// Wait returns when no try runs.
-func (h *DeadLetterHearing) Wait() { h.wg.Wait() }
-
-// Stop ends every stream's following.
-func (h *DeadLetterHearing) Stop() {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-	for s, stop := range h.stops {
-		stop()
-		delete(h.stops, s)
-	}
-}
-
-func (h *DeadLetterHearing) try() {
-	for _, s := range h.streams {
-		h.mu.Lock()
-		_, deaf := h.why[s]
-		h.mu.Unlock()
-		if !deaf || h.ctx.Err() != nil {
-			continue
-		}
-		stream := s
-		stop, err := h.follower.Follow(h.ctx, stream, h.since, func(g GivenUp) {
-			h.logf("the ask %s on %s was given up after %d deliveries at %s: the wait for its step ends", g.AskID, g.Stream,
-				g.Deliveries, g.At.Format(time.RFC3339))
-			h.dead.Heard(g)
-		})
-		h.mu.Lock()
-		if err != nil {
-			h.why[stream] = err.Error()
-			h.logf("the asks %s gives up on are not heard (%s of %s); tried again at the next reconnect or ask: %v",
-				stream, DeadLetterFilter(stream), DeadLettersStream, err)
-		} else {
-			delete(h.why, stream)
-			h.stops[stream] = stop
-			h.logf("the asks %s gives up on are heard from %s", stream, DeadLettersStream)
-		}
-		h.mu.Unlock()
-	}
-	h.tell()
-}
-
-// tell says the hearing when it changed.
-func (h *DeadLetterHearing) tell() {
-	h.mu.Lock()
-	why := h.deafLocked()
-	now := Hearing{Heard: why == "", Streams: append([]string(nil), h.streams...), Why: why, At: time.Now().UTC()}
-	same := h.told != nil && h.told.Heard == now.Heard && h.told.Why == now.Why
-	if !same {
-		h.told = &now
-	}
-	h.mu.Unlock()
-	if !same && h.said != nil {
-		h.said(now)
-	}
-}
-
-// HearingState is the name of the state an asker keeps its Hearing in (`<module>_hearing`, key HearingKey), which its
-// health tool reads.
-const HearingState = "hearing"
-
-// HearingKeeper is where a Hearing is kept: a jetstream.KeyValue, or a process.AwaitedBucket for a state that may not be
-// on the bus at the part's start (issue 1790), which keeps the latest until it appears and answers process.ErrNotYet.
-type HearingKeeper interface {
-	Put(ctx context.Context, key string, value []byte) (uint64, error)
-}
-
-// SayHearing is a DeadLetterHearing's said that keeps each Hearing in kv under HearingKey; nil kv keeps nothing and
-// says so once. A write kv keeps for later (process.ErrNotYet) is not an error: the awaited bucket said it waits.
-func SayHearing(ctx context.Context, kv HearingKeeper, logf func(string, ...any)) func(Hearing) {
-	if kv == nil {
-		if logf != nil {
-			logf("whether %s is heard is not kept: the state %s is not there, so the health tool cannot say it", DeadLettersStream, HearingState)
-		}
-		return nil
-	}
-	return func(h Hearing) {
-		data, err := json.Marshal(h)
-		if err == nil {
-			_, err = kv.Put(ctx, HearingKey, data)
-		}
-		if err != nil && !errors.Is(err, process.ErrNotYet) && logf != nil {
-			logf("whether %s is heard could not be kept: %v", DeadLettersStream, err)
-		}
-	}
-}
-
-// HearingHealth is the health answer of an asker's kept Hearing (raw, empty when none is kept): healthy while it hears
-// DEAD_LETTERS, unhealthy saying why while it does not or has not said.
-func HearingHealth(raw []byte) health.Answer {
-	if len(raw) == 0 {
-		return health.Unhealthy("it has not said whether it hears " + DeadLettersStream + " (issue 734): it is starting, or its state " + HearingState + " is not there")
-	}
-	var h Hearing
-	if err := json.Unmarshal(raw, &h); err != nil {
-		return health.Unhealthy("what it keeps of hearing " + DeadLettersStream + " is not a hearing: " + err.Error())
-	}
-	if !h.Heard {
-		return health.Unhealthy(h.Why + " (since " + h.At.Format(time.RFC3339) + "; tried again at its next reconnect or ask)")
-	}
-	return health.Healthy("it hears " + DeadLettersStream + " for " + strings.Join(h.Streams, ", "))
-}

modules/mesh-delivery-builder/buildrun/modules.go

@@ -1,7 +0,0 @@
-package buildrun
-
-// The build modules the mesh runs, by the language each builds (ADR 0469).
-const (
-	GoBuildModule   = "mesh-build-go"
-	NodeBuildModule = "mesh-build-node"
-)

modules/mesh-delivery-builder/buildrun/places.go

@@ -1,145 +0,0 @@
-package buildrun
-
-import (
-	"context"
-	"fmt"
-	"sort"
-	"sync"
-)
-
-// DefaultCapacity is the build capacity of a node that has no setting: one build step at a time.
-const DefaultCapacity = 1
-
-// Places counts the build steps a part runs on each node and holds a lane back while its node is at its
-// capacity (the operator's decision of 2026-10-21; ADR 0478 clause 3). A lane is the fetch and the builds of one build
-// module on one node, run one step at a time, so a lane holds one place while it runs. A node is chosen for a lane by
-// reserving a place on it at the moment of the choice (ChooseNodes), so that builds choosing at once see each other's
-// choices and none waits on a full node while another has room. A lane waits for its place by watching the ends of the
-// other lanes, not by a timer: ending a lane wakes the waiting ones.
-type Places struct {
-	// Capacity is the number of steps at once by node; a node not in it has DefaultCapacity.
-	Capacity map[string]int
-
-	mu       sync.Mutex
-	running  map[string]int // lanes holding a place
-	reserved map[string]int // lanes chosen for the node that do not hold a place yet
-	changed  chan struct{}  // closed, and replaced, each time a lane ends
-}
-
-// CapacityOf is how many steps the part runs on the node at once: DefaultCapacity for a node the setting does not
-// name, and 0 for one it names so, where the part never builds.
-func (p *Places) CapacityOf(node string) int {
-	if n, ok := p.Capacity[node]; ok && n >= 0 {
-		return n
-	}
-	return DefaultCapacity
-}
-
-// Running is the steps in flight now, by node.
-func (p *Places) Running() map[string]int {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	out := make(map[string]int, len(p.running))
-	for n, c := range p.running {
-		if c > 0 {
-			out[n] = c
-		}
-	}
-	return out
-}
-
-// Reserved is the lanes chosen for a node that hold no place yet, by node.
-func (p *Places) Reserved() map[string]int {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	out := make(map[string]int, len(p.reserved))
-	for n, c := range p.reserved {
-		if c > 0 {
-			out[n] = c
-		}
-	}
-	return out
-}
-
-func (p *Places) init() {
-	if p.running == nil {
-		p.running = map[string]int{}
-	}
-	if p.reserved == nil {
-		p.reserved = map[string]int{}
-	}
-	if p.changed == nil {
-		p.changed = make(chan struct{})
-	}
-}
-
-// Acquire takes a place on the node, waiting while the node is at its capacity, and answers the function that gives it
-// back. A place reserved for the node by a choice is the one taken. It returns an error when ctx ends first, and then
-// gives up the reservation too.
-func (p *Places) Acquire(ctx context.Context, node string) (release func(), err error) {
-	for {
-		p.mu.Lock()
-		p.init()
-		if p.running[node] < p.CapacityOf(node) {
-			p.running[node]++
-			if p.reserved[node] > 0 {
-				p.reserved[node]--
-			}
-			p.mu.Unlock()
-			var once sync.Once
-			return func() {
-				once.Do(func() {
-					p.mu.Lock()
-					p.running[node]--
-					close(p.changed)
-					p.changed = make(chan struct{})
-					p.mu.Unlock()
-				})
-			}, nil
-		}
-		wait := p.changed
-		p.mu.Unlock()
-		select {
-		case <-wait:
-		case <-ctx.Done():
-			p.Cancel(node)
-			return nil, fmt.Errorf("waiting for a place on %s: %w", node, ctx.Err())
-		}
-	}
-}
-
-// Cancel gives up a place reserved for the node that will not be taken.
-func (p *Places) Cancel(node string) {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	p.init()
-	if p.reserved[node] > 0 {
-		p.reserved[node]--
-	}
-}
-
-// choose orders the nodes (those with room first, counting the lanes running and the lanes reserved, then the fewest of
-// them, then by name), keeps the first want and reserves a place on each, all at once.
-func (p *Places) choose(nodes []string, want int) []string {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	p.init()
-	load := func(n string) int { return p.running[n] + p.reserved[n] }
-	sort.SliceStable(nodes, func(i, j int) bool {
-		ri, rj := load(nodes[i]) < p.CapacityOf(nodes[i]), load(nodes[j]) < p.CapacityOf(nodes[j])
-		if ri != rj {
-			return ri
-		}
-		if load(nodes[i]) != load(nodes[j]) {
-			return load(nodes[i]) < load(nodes[j])
-		}
-		return nodes[i] < nodes[j]
-	})
-	if len(nodes) > want {
-		nodes = nodes[:want]
-	}
-	for _, n := range nodes {
-		p.reserved[n]++
-	}
-	return nodes
-}

modules/mesh-delivery-builder/buildrun/places_test.go

@@ -1,104 +0,0 @@
-package buildrun
-
-import (
-	"context"
-	"strings"
-	"testing"
-	"time"
-)
-
-func acquireAsync(p *Places, node string) chan func() {
-	got := make(chan func(), 1)
-	go func() {
-		release, err := p.Acquire(context.Background(), node)
-		if err != nil {
-			close(got)
-			return
-		}
-		got <- release
-	}()
-	return got
-}
-
-func TestThreeStepsOnANodeOfCapacityTwoRunTwoAtOnceAndTheThirdStartsWhenOneEnds(t *testing.T) { // round 3
-	p := &Places{Capacity: map[string]int{"ace": 2}}
-	a, b := acquireAsync(p, "ace"), acquireAsync(p, "ace")
-	ra, rb := <-a, <-b
-	third := acquireAsync(p, "ace")
-	select {
-	case <-third:
-		t.Fatal("a third step started on a node of capacity 2 with two running")
-	case <-time.After(10 * time.Millisecond):
-	}
-	if p.Running()["ace"] != 2 {
-		t.Errorf("running = %v, want 2 on ace", p.Running())
-	}
-	ra()
-	select {
-	case r := <-third:
-		r()
-	case <-time.After(2 * time.Second):
-		t.Fatal("the third step did not start when one ended")
-	}
-	rb()
-}
-
-func TestANodeWithNoSettingRunsOneStepAtATime(t *testing.T) { // round 3
-	p := &Places{Capacity: map[string]int{"shanks": 3}}
-	first := <-acquireAsync(p, "g14")
-	second := acquireAsync(p, "g14")
-	select {
-	case <-second:
-		t.Fatal("two steps on a node without a setting")
-	case <-time.After(10 * time.Millisecond):
-	}
-	first()
-	r := <-second
-	r()
-	if p.CapacityOf("g14") != 1 || p.CapacityOf("shanks") != 3 {
-		t.Errorf("capacities = %d, %d", p.CapacityOf("g14"), p.CapacityOf("shanks"))
-	}
-}
-
-func TestAWaitingStepStopsWhenItsContextEnds(t *testing.T) { // round 3
-	p := &Places{}
-	r := <-acquireAsync(p, "ace")
-	defer r()
-	ctx, cancel := context.WithCancel(context.Background())
-	done := make(chan error, 1)
-	go func() { _, err := p.Acquire(ctx, "ace"); done <- err }()
-	cancel()
-	select {
-	case err := <-done:
-		if err == nil {
-			t.Error("Acquire returned no error for a cancelled wait")
-		}
-	case <-time.After(2 * time.Second):
-		t.Fatal("a cancelled wait did not return")
-	}
-}
-
-// The operator's decision of 2026-10-21 13:40: the builder builds on shanks and ace only; a capacity of 0 keeps it off a node.
-func TestACapacityOfZeroKeepsThePartOffTheNodeAndANodeNotNamedKeepsOne(t *testing.T) { // issue 1661
-	p := &Places{Capacity: map[string]int{"shanks": 3, "ace": 2, "g14": 0, "novox": 0}}
-	if p.CapacityOf("g14") != 0 || p.CapacityOf("novox") != 0 || p.CapacityOf("ace") != 2 || p.CapacityOf("other") != DefaultCapacity {
-		t.Errorf("capacities = %d %d %d %d, want 0 0 2 and the default for a node not named", p.CapacityOf("g14"), p.CapacityOf("novox"), p.CapacityOf("ace"), p.CapacityOf("other"))
-	}
-	entries := tcs("go", "go1.27.1", "ace", "g14", "novox", "shanks", "other")
-	for i := 0; i < 6; i++ {
-		nodes, _, err := ChooseNodes("go", entries, p, nil, 2)
-		if err != nil {
-			t.Fatal(err)
-		}
-		for _, n := range nodes {
-			if n == "g14" || n == "novox" {
-				t.Fatalf("choice %d: %v includes a node of capacity 0", i, nodes)
-			}
-		}
-	}
-	// Only nodes of capacity 0 report: nothing qualifies, and the build says why.
-	_, _, err := ChooseNodes("go", tcs("go", "go1.27.1", "g14", "novox"), p, nil, 2)
-	if err == nil || !strings.Contains(err.Error(), "capacity") {
-		t.Errorf("only capacity-0 nodes: error = %v, want it to name the capacity", err)
-	}
-}

modules/mesh-delivery-builder/buildrun/presence.go

@@ -1,53 +0,0 @@
-package buildrun
-
-import (
-	"sync"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// PresenceSet holds which nodes are online, as the watchman writes it (mesh-delivery-watchman_presence, key `<node>`, the
-// node-engine's connection): a node asleep or off the bus is offline and its build module cannot answer. A node the
-// watchman has no key of is not online. Safe for use from the watch and from a build at once.
-type PresenceSet struct {
-	mu     sync.Mutex
-	online map[string]bool
-}
-
-// Put takes a change of the presence bucket in and answers whether a node's online state changed. A part's key and a
-// value that is not a presence are left out.
-func (s *PresenceSet) Put(key string, value []byte, deleted bool) bool {
-	node, part, _, err := delivery.ParsePresenceKey(key)
-	if err != nil || part != "" {
-		return false
-	}
-	on := false
-	if !deleted {
-		p, err := delivery.DecodePresence(value)
-		if err != nil {
-			return false
-		}
-		on = p.Online
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if s.online[node] == on {
-		return false
-	}
-	if s.online == nil {
-		s.online = map[string]bool{}
-	}
-	if on {
-		s.online[node] = true
-	} else {
-		delete(s.online, node)
-	}
-	return true
-}
-
-// Online is whether the watchman last saw the node online.
-func (s *PresenceSet) Online(node string) bool {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	return s.online[node]
-}

modules/mesh-delivery-builder/buildrun/presence_test.go

@@ -1,43 +0,0 @@
-package buildrun
-
-import (
-	"testing"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-func presenceValue(t *testing.T, online bool) []byte {
-	t.Helper()
-	b, err := delivery.EncodePresence(delivery.Presence{Online: online})
-	if err != nil {
-		t.Fatal(err)
-	}
-	return b
-}
-
-func TestPresenceSetKnowsOnlyNodesTheWatchmanSawOnline(t *testing.T) { // 1607 review 3
-	var s PresenceSet
-	if s.Online("ace") {
-		t.Error("a node the watchman never wrote is online")
-	}
-	if !s.Put("ace", presenceValue(t, true), false) || !s.Online("ace") {
-		t.Error("ace online was not taken in")
-	}
-	if s.Put("ace", presenceValue(t, true), false) {
-		t.Error("the same presence again counted as a change")
-	}
-	if !s.Put("ace", presenceValue(t, false), false) || s.Online("ace") {
-		t.Error("ace going offline was not taken in")
-	}
-	s.Put("g14", presenceValue(t, true), false)
-	if !s.Put("g14", nil, true) || s.Online("g14") {
-		t.Error("a deleted key is still online")
-	}
-	// A part's instance (part.<part>.<instance>) is not a node.
-	if s.Put("part.mesh-delivery-builder.novox", presenceValue(t, true), false) || s.Online("part") {
-		t.Error("a part's key was taken for a node")
-	}
-	if s.Put("novox", []byte("junk"), false) {
-		t.Error("junk counted")
-	}
-}

modules/mesh-delivery-builder/buildrun/standing.go

@@ -1,248 +0,0 @@
-package buildrun
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"maps"
-	"slices"
-	"sort"
-	"sync"
-	"time"
-
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-	"git.novox.be/novox/mesh-sdk/go/process"
-)
-
-// A build module writes <node>.<language> of its toolchains state on every node it runs on, and nothing deletes the key
-// when the module leaves a node: no part writes another module's state, and the module is gone. A report of a node the
-// build module no longer runs on is therefore no builder's (issue 1940: mesh-build-node taken off ace on 2026-10-23 left
-// ace.typescript at v26.12.0, and every Node fingerprint said "builders disagree").
-//
-// ToolchainGate stands between the toolchains buckets and what takes their entries in (the indexer's PutToolchain, a
-// ToolchainSet): an entry is passed on only while the placement (the seat mesh-placement's state `placement`, held by
-// the assigner, delivery.PlacementBucket, read by delivery.Placed; ADR 0567, ADR 0549 §3) places its build module on
-// its node, and only once it was written since that placement; it is passed on as deleted otherwise, said once, and
-// passed on when its node writes it again. A report written before the placement is one an earlier run of the module
-// left (issue 1940, 2026-10-25 20:56: mesh-build-node put on ace again brought ace.typescript v26.12.0 of 2026-10-23
-// back into the agreement before the module ran there). Until the placement is settled, and while no node's placement
-// is held (before the assigner's adopt writes the first one, or where the state cannot be read), every entry is passed
-// on. Builders that run and report different versions still disagree: that refusal is the guard of novox/hq ADR 0465,
-// and it stays.
-//
-// This replaces the copies of the gate the indexer, the builder and the checker each kept over the controller's
-// assignments (issue 1940's subtask, issue 774: those go with the controller's lease, ADR 0549 §6).
-type ToolchainGate struct {
-	mu      sync.Mutex
-	modules map[string]bool                                           // the build modules whose toolchains pass the gate
-	forward func(module, key string, value []byte, deleted bool) bool // answers whether it changed what it holds
-	logf    func(format string, a ...any)
-	placed  *delivery.Placed
-	known   bool                         // the placement is settled
-	raw     map[string]map[string][]byte // module -> toolchains key -> value, as the bucket holds it
-	left    map[string]string            // <module>/<key> -> why it was said left out, so each reason is said once
-	// OnPlaced is told, outside the gate's lock, once the placement's history is read and after each revision of it
-	// FollowPlacement hears from then on (the counted nodes, Nodes, may have changed). Nil tells nobody.
-	OnPlaced func()
-}
-
-// NewToolchainGate is a gate over the toolchains of modules, passing what stands on to forward and saying with logf what
-// it leaves out.
-func NewToolchainGate(modules []string, forward func(module, key string, value []byte, deleted bool) bool, logf func(string, ...any)) *ToolchainGate {
-	g := &ToolchainGate{modules: map[string]bool{}, forward: forward, logf: logf, placed: delivery.NewPlaced(),
-		raw: map[string]map[string][]byte{}, left: map[string]string{}}
-	for _, m := range modules {
-		g.modules[m] = true
-	}
-	return g
-}
-
-// Toolchain takes one change of a build module's toolchains bucket in and answers whether what it passed on changed.
-func (g *ToolchainGate) Toolchain(module, key string, value []byte, deleted bool) bool {
-	g.mu.Lock()
-	defer g.mu.Unlock()
-	if g.raw[module] == nil {
-		g.raw[module] = map[string][]byte{}
-	}
-	if deleted {
-		delete(g.raw[module], key)
-	} else {
-		g.raw[module][key] = value
-	}
-	return g.pass(module, key)
-}
-
-// Placement takes one revision of the seat mesh-placement's placement in (at is when the bus wrote it) and answers whether what it
-// passed on changed. A value that does not read is said, and places nothing on its node.
-func (g *ToolchainGate) Placement(key string, value []byte, deleted bool, at time.Time) bool {
-	g.mu.Lock()
-	defer g.mu.Unlock()
-	was := g.placed.Seeded()
-	node, changed, err := g.placed.Put(key, value, deleted, at)
-	if err != nil {
-		g.logf("%s: %v (issue 1940)", delivery.PlacementBucket, err)
-	}
-	if !g.known {
-		return false
-	}
-	if was != g.placed.Seeded() {
-		// The first placement came, or the last went: every report's standing changed.
-		return g.all()
-	}
-	return g.again(node, changed)
-}
-
-// Nodes are the nodes the placement places any module on, sorted: the nodes the mesh counts (a node leaves the count
-// when the placement no longer names it; ADR 0624 §1). None until the placement is read.
-func (g *ToolchainGate) Nodes() []string {
-	var out []string
-	for node, modules := range g.placed.ByNode() {
-		if len(modules) > 0 {
-			out = append(out, node)
-		}
-	}
-	sort.Strings(out)
-	return out
-}
-
-// Settled says the placement's history is read: from now on only the reports of placed nodes pass, once a node's
-// placement is held. It answers whether what it passed on changed.
-func (g *ToolchainGate) Settled() bool {
-	g.mu.Lock()
-	defer g.mu.Unlock()
-	g.known = true
-	return g.all()
-}
-
-// all passes on every report again. The caller holds mu.
-func (g *ToolchainGate) all() bool {
-	changed := false
-	for _, module := range slices.Sorted(maps.Keys(g.raw)) {
-		for _, k := range slices.Sorted(maps.Keys(g.raw[module])) {
-			changed = g.pass(module, k) || changed
-		}
-	}
-	return changed
-}
-
-// again passes on every report of node by a build module among modules. The caller holds mu.
-func (g *ToolchainGate) again(node string, modules []string) bool {
-	changed := false
-	for _, module := range modules {
-		if !g.modules[module] {
-			continue
-		}
-		for _, k := range slices.Sorted(maps.Keys(g.raw[module])) {
-			if n, _, err := delivery.ParseToolchainKey(k); err == nil && n == node {
-				changed = g.pass(module, k) || changed
-			}
-		}
-	}
-	return changed
-}
-
-// pass hands one key on as it stands: its value when its node is placed and wrote it since (or the placement is not
-// known), deleted otherwise. The caller holds mu.
-func (g *ToolchainGate) pass(module, key string) bool {
-	value, held := g.raw[module][key]
-	if !held {
-		return g.forward(module, key, nil, true)
-	}
-	node, _, err := delivery.ParseToolchainKey(key)
-	why := ""
-	if err == nil && g.known && g.placed.Seeded() {
-		why = g.leftOut(module, node, value)
-	}
-	if why == "" {
-		delete(g.left, module+"/"+key)
-		return g.forward(module, key, value, false)
-	}
-	if g.left[module+"/"+key] != why {
-		g.left[module+"/"+key] = why
-		g.logf("%s.%s is left out of the agreed toolchain: %s (issue 1940)", delivery.ToolchainsBucket(module), key, why)
-	}
-	return g.forward(module, key, nil, true)
-}
-
-// leftOut is why a node's report is no builder's, or empty when it counts: the catalogue does not place the module on its
-// node, or the report was written before it did. A value that is no toolchain is passed on for its reader to refuse.
-// The caller holds mu.
-func (g *ToolchainGate) leftOut(module, node string, value []byte) string {
-	since, placed := g.placed.Since(node, module)
-	if !placed {
-		return fmt.Sprintf("the catalogue does not place %s on %s, so it is no builder", module, node)
-	}
-	tc, err := delivery.DecodeToolchain(value)
-	if err == nil && tc.At.Before(since) {
-		return fmt.Sprintf("it was written at %s, before %s was placed on %s at %s: it counts once %s writes it again",
-			tc.At.UTC().Format(time.RFC3339), module, node, since.UTC().Format(time.RFC3339), node)
-	}
-	return ""
-}
-
-// FollowPlacement reads the seat mesh-placement's placement with its history into gate, says it settled, and follows it; changed
-// is told whenever what the gate passes on changed. Where the state cannot be read or watched (not there, or this part
-// may not read it) it says so and the gate passes every report on: not fatal, since an indexer, builder or checker that
-// stops for it stops every delivery (issue 1945). An error of the watch after that ends on the channel.
-func FollowPlacement(ctx context.Context, js process.BucketOpener, gate *ToolchainGate, changed func(context.Context), logf func(string, ...any)) (<-chan error, error) {
-	errs := make(chan error, 1)
-	kv, err := js.KeyValue(ctx, delivery.PlacementBucket)
-	if err != nil {
-		logf("the state %s cannot be read, so every node's toolchain report counts, a build node's the catalogue does not place too (issue 1940): %v", delivery.PlacementBucket, err)
-		return errs, nil
-	}
-	w, err := kv.WatchAll(ctx, jetstream.IncludeHistory())
-	if err != nil {
-		logf("the state %s cannot be watched, so every node's toolchain report counts, a build node's the catalogue does not place too (issue 1940): %v", delivery.PlacementBucket, err)
-		return errs, nil
-	}
-	put := func(e jetstream.KeyValueEntry) bool {
-		return gate.Placement(e.Key(), e.Value(), e.Operation() != jetstream.KeyValuePut, e.Created())
-	}
-	for settled := false; !settled; {
-		select {
-		case <-ctx.Done():
-			_ = w.Stop()
-			return errs, ctx.Err()
-		case e, ok := <-w.Updates():
-			if !ok {
-				return errs, errors.New("the watch of " + delivery.PlacementBucket + " ended before it settled")
-			}
-			if e == nil {
-				settled = true
-				continue
-			}
-			put(e)
-		}
-	}
-	if gate.Settled() {
-		changed(ctx)
-	}
-	if gate.OnPlaced != nil {
-		gate.OnPlaced()
-	}
-	go func() {
-		defer func() { _ = w.Stop() }()
-		for {
-			select {
-			case <-ctx.Done():
-				errs <- ctx.Err()
-				return
-			case e, ok := <-w.Updates():
-				if !ok {
-					errs <- errors.New("the watch of " + delivery.PlacementBucket + " ended")
-					return
-				}
-				if e != nil && put(e) {
-					changed(ctx)
-				}
-				if e != nil && gate.OnPlaced != nil {
-					gate.OnPlaced()
-				}
-			}
-		}
-	}()
-	return errs, nil
-}

modules/mesh-delivery-builder/buildrun/standing_test.go

@@ -1,263 +0,0 @@
-package buildrun
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"log"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-func gateReport(t *testing.T, node, version string, at time.Time) (string, []byte) {
-	t.Helper()
-	key, err := delivery.ToolchainKey(node, "typescript")
-	if err != nil {
-		t.Fatal(err)
-	}
-	value, err := delivery.EncodeToolchain(delivery.Toolchain{Language: "typescript", Version: version, Recipe: "f59571cf4be75adf", At: at})
-	if err != nil {
-		t.Fatal(err)
-	}
-	return key, value
-}
-
-// placing is a value of the state `placement` placing modules on node.
-func placing(t *testing.T, node string, modules ...string) (string, []byte) {
-	t.Helper()
-	p := delivery.Placement{Node: node}
-	for _, m := range modules {
-		p.Modules = append(p.Modules, delivery.PlacedModule{Module: m})
-	}
-	values, err := delivery.PlacementValues(p)
-	if err != nil {
-		t.Fatal(err)
-	}
-	key, _ := delivery.PlacementNodeKey(node)
-	return key, values[key]
-}
-
-// placingLegacy is placing in the form before, `placement.<node>` (research 072 row 37).
-func placingLegacy(t *testing.T, node string, modules ...string) (string, []byte) {
-	t.Helper()
-	p := delivery.Placement{Node: node}
-	for _, m := range modules {
-		p.Modules = append(p.Modules, delivery.PlacedModule{Module: m})
-	}
-	key, _ := delivery.LegacyPlacementKey(node)
-	value, err := delivery.EncodePlacement(p)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return key, value
-}
-
-func agreedOf(set *ToolchainSet) (string, string) {
-	tc, none := delivery.AgreedToolchain(set.Entries("typescript"))
-	return tc.Version, none
-}
-
-// Issue 1940, the gate over the catalogue's placement (issue 774, ADR 0549 §3): a build node's report counts only while
-// the placement places its build module on its node, and only once written since; before the placement is settled, and
-// while no node's placement is held, every report counts. The live cases: mesh-build-node taken off ace left
-// ace.typescript at v26.12.0 against v26.12.1 on the three others; put on ace again, its report of 2026-10-23 06:29 came
-// back before the module ran there.
-func TestToolchainGate(t *testing.T) {
-	old := time.Date(2026, 10, 23, 6, 29, 18, 0, time.UTC)     // ace's report from its earlier run
-	placed := time.Date(2026, 10, 25, 19, 56, 45, 0, time.UTC) // mesh-build-node placed on ace again
-	three := []string{"g14", "novox", "shanks"}
-	start := func(t *testing.T, seeded bool) (*ToolchainGate, *ToolchainSet, *[]string) {
-		set := &ToolchainSet{}
-		said := &[]string{}
-		gate := NewToolchainGate([]string{GoBuildModule, NodeBuildModule}, set.Put, func(f string, a ...any) { *said = append(*said, fmt.Sprintf(f, a...)) })
-		for _, node := range three {
-			if seeded {
-				key, value := placing(t, node, NodeBuildModule)
-				gate.Placement(key, value, false, old.Add(-time.Hour))
-			}
-			key, value := gateReport(t, node, "v26.12.1", placed.Add(time.Minute))
-			gate.Toolchain(NodeBuildModule, key, value, false)
-		}
-		return gate, set, said
-	}
-
-	t.Run("not placed on ace: its report is no builder's", func(t *testing.T) {
-		gate, set, said := start(t, true)
-		key, value := gateReport(t, "ace", "v26.12.0", old)
-		gate.Toolchain(NodeBuildModule, key, value, false)
-		if a := delivery.ToolchainAgreement(set.Entries("typescript")); len(a.SittingOut) != 1 || a.SittingOut[0].Node != "ace" { // ADR 0584: the majority is agreed, ace's report counts as the one that sits out
-			t.Fatalf("before the placement is settled every report counts; got %+v", a)
-		}
-		k, v := placing(t, "ace", GoBuildModule) // another build module on ace: no matter
-		gate.Placement(k, v, false, old)
-		if !gate.Settled() {
-			t.Fatal("settling left ace's report out, so what was passed on changed")
-		}
-		if v, none := agreedOf(set); v != "v26.12.1" || none != "" {
-			t.Fatalf("the placed nodes agree on v26.12.1; got %q, %q", v, none)
-		}
-		if len(*said) != 1 || !strings.Contains((*said)[0], "does not place mesh-build-node on ace") {
-			t.Fatalf("ace's report is said left out once; said %q", *said)
-		}
-		if gate.Toolchain(NodeBuildModule, key, value, false) {
-			t.Fatal("a report of a node not placed changed what was passed on")
-		}
-		// Placed on ace with a report written since: it counts, and the builders really disagree.
-		k, v = placing(t, "ace", GoBuildModule, NodeBuildModule)
-		gate.Placement(k, v, false, old.Add(-time.Minute))
-		if a := delivery.ToolchainAgreement(set.Entries("typescript")); a.Toolchain.Version != "v26.12.1" || len(a.SittingOut) != 1 || a.SittingOut[0].Version != "v26.12.0" {
-			t.Fatalf("builders that run different versions: the majority is agreed and ace sits out; got %+v", a)
-		}
-		// Taken off ace again (its key deleted): its report goes again.
-		if !gate.Placement(k, nil, true, placed) {
-			t.Fatal("taking ace's placement away passed nothing on")
-		}
-		if v, none := agreedOf(set); v != "v26.12.1" || none != "" {
-			t.Fatalf("got %q, %q", v, none)
-		}
-		// A report deleted from the bucket goes whether its node is placed or not.
-		key, _ = gateReport(t, "g14", "v26.12.1", placed)
-		if !gate.Toolchain(NodeBuildModule, key, nil, true) || len(set.Entries("typescript")) != 2 {
-			t.Fatalf("deleting g14's report: %d entries left, want novox and shanks", len(set.Entries("typescript")))
-		}
-	})
-
-	for _, c := range []struct {
-		name   string
-		at     time.Time // when ace wrote its report
-		counts bool
-	}{
-		{"a report left before the placement", old, false},
-		{"a report written since the placement", placed.Add(30 * time.Second), true},
-	} {
-		t.Run(c.name, func(t *testing.T) {
-			gate, set, said := start(t, true)
-			k, v := placing(t, "ace") // ace's key, first heard placing nothing
-			gate.Placement(k, v, false, old.Add(-time.Hour))
-			gate.Settled()
-			k, v = placing(t, "ace", NodeBuildModule)
-			if gate.Placement(k, v, false, placed) {
-				t.Fatal("a placement with no report passed something on")
-			}
-			key, value := gateReport(t, "ace", "v26.12.0", c.at)
-			if got := gate.Toolchain(NodeBuildModule, key, value, false); got != c.counts {
-				t.Fatalf("ace's report passed on: %v, want %v", got, c.counts)
-			}
-			// ace's placement written again with another module beside: its standing does not move, nothing is said again.
-			k, v = placing(t, "ace", GoBuildModule, NodeBuildModule)
-			if gate.Placement(k, v, false, placed.Add(time.Minute)) {
-				t.Fatal("the same placement of mesh-build-node changed what was passed on")
-			}
-			if c.counts {
-				return
-			}
-			if v, none := agreedOf(set); v != "v26.12.1" || none != "" {
-				t.Fatalf("ace's left report is no builder's; got %q, %q", v, none)
-			}
-			if len(*said) != 1 || !strings.Contains((*said)[0], "before mesh-build-node was placed on ace at 2026-10-25T19:56:45Z") {
-				t.Fatalf("said %q, want once why ace's report is left out", *said)
-			}
-			key, value = gateReport(t, "ace", "v26.12.1", placed.Add(time.Minute))
-			if !gate.Toolchain(NodeBuildModule, key, value, false) || len(set.Entries("typescript")) != 4 {
-				t.Fatal("ace's new report was not passed on")
-			}
-		})
-	}
-
-	t.Run("no placement held: every report counts", func(t *testing.T) {
-		gate, set, _ := start(t, false)
-		key, value := gateReport(t, "ace", "v26.12.0", old)
-		gate.Toolchain(NodeBuildModule, key, value, false)
-		gate.Settled()
-		if n := len(set.Entries("typescript")); n != 4 {
-			t.Fatalf("before the first placement file every report counts; got %d", n)
-		}
-		k, v := placing(t, "g14", NodeBuildModule)
-		if !gate.Placement(k, v, false, old.Add(-time.Hour)) || len(set.Entries("typescript")) != 1 {
-			t.Fatalf("the first placement leaves every node it does not place out; got %d", len(set.Entries("typescript")))
-		}
-		if !gate.Placement(k, nil, true, placed) || len(set.Entries("typescript")) != 4 {
-			t.Fatal("the last placement gone: every report counts again")
-		}
-	})
-
-	t.Run("the history: a module in the first revision heard of a key stands since before it", func(t *testing.T) {
-		p := delivery.NewPlaced()
-		// ace in the form before, then converted: its module stands since before, the legacy key read no more.
-		k, v := placingLegacy(t, "ace", NodeBuildModule)
-		p.Put(k, v, false, old)
-		k, v = placing(t, "ace", NodeBuildModule)
-		if _, changed, err := p.Put(k, v, false, placed); len(changed) != 0 || err != nil {
-			t.Errorf("the conversion of ace's key changed %v, %v", changed, err)
-		}
-		if _, changed, _ := p.Put("ace."+NodeBuildModule, []byte("{}"), false, placed); len(changed) != 0 {
-			t.Errorf("a module key says which modules stand: %v", changed)
-		}
-		if k, v := placingLegacy(t, "ace"); true {
-			if _, changed, _ := p.Put(k, v, false, placed); len(changed) != 0 {
-				t.Errorf("the legacy key is read after the node key: %v", changed)
-			}
-		}
-		k2, v2 := placing(t, "g14")
-		p.Put(k2, v2, false, old)
-		k2, v2 = placing(t, "g14", NodeBuildModule)
-		if _, changed, _ := p.Put(k2, v2, false, placed); strings.Join(changed, ",") != NodeBuildModule {
-			t.Errorf("a module placed says changed %v", changed)
-		}
-		if _, _, err := p.Put("placement.novox", []byte("not json"), false, old); err == nil {
-			t.Error("a value that does not read was not said")
-		}
-		if s, ok := p.Since("ace", NodeBuildModule); !ok || !s.IsZero() {
-			t.Errorf("ace's module stands since %v, %v; want the zero time", s, ok)
-		}
-		if s, ok := p.Since("g14", NodeBuildModule); !ok || !s.Equal(placed) {
-			t.Errorf("g14's module stands since %v, %v; want the revision that placed it", s, ok)
-		}
-		if got := p.PlacedNodes(NodeBuildModule); strings.Join(got, ",") != "ace,g14" || len(p.ByNode()) != 2 || !p.Seeded() {
-			t.Errorf("PlacedNodes = %v, ByNode = %v", got, p.ByNode())
-		}
-	})
-
-	t.Run("a placement the bus refuses is said, and the part goes on", func(t *testing.T) {
-		var logs bytes.Buffer
-		logger := log.New(&logs, "", 0)
-		refused := errors.New("nats: permissions violation for publish to $JS.API.CONSUMER.CREATE.KV_mesh-delivery-assigner_placement")
-		gate, _, _ := start(t, false)
-		for _, bus := range []refusingBus{{err: refused}, {refuseOpen: true, err: refused}} {
-			if _, err := FollowPlacement(context.Background(), bus, gate, func(context.Context) {}, logger.Printf); err != nil {
-				t.Errorf("a refused placement stopped the start: %v", err)
-			}
-		}
-		if !strings.Contains(logs.String(), "cannot be watched") || !strings.Contains(logs.String(), "cannot be read") {
-			t.Errorf("the refusals were not said: %q", logs.String())
-		}
-	})
-}
-
-// refusingBus is a bus that refuses: every open (refuseOpen), or every watch of a bucket it opens, with err.
-type refusingBus struct {
-	refuseOpen bool
-	err        error
-}
-
-func (r refusingBus) KeyValue(context.Context, string) (jetstream.KeyValue, error) {
-	if r.refuseOpen {
-		return nil, r.err
-	}
-	return refusedWatch{err: r.err}, nil
-}
-
-type refusedWatch struct {
-	jetstream.KeyValue
-	err error
-}
-
-func (r refusedWatch) WatchAll(context.Context, ...jetstream.WatchOpt) (jetstream.KeyWatcher, error) {
-	return nil, r.err
-}

modules/mesh-delivery-builder/buildrun/steps.go

@@ -1,67 +0,0 @@
-package buildrun
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"time"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// Caller calls a tool of a module on one named machine (mesh-sdk process.Conn.CallOn; ADR 0469 clause 3).
-type Caller interface {
-	CallOn(node, key string, body any) (json.RawMessage, error)
-}
-
-// Steps waits for the end of a build module's long step: the value of its key `<node>.<id>` in the module's steps state
-// (ADR 0469 clause 2) once its state is not running. It is a watch of that key, not a poll; it returns when the step
-// ends or ctx does.
-type Steps interface {
-	Wait(ctx context.Context, module, key string) (delivery.Step, error)
-}
-
-// Runner runs a build module's long steps: the call answers at once with the step's key, and the result is read from that
-// key when the step ends (ADR 0469 clause 2).
-type Runner struct {
-	Caller Caller
-	Steps  Steps
-	// Bound is how long a step may run before the builder stops waiting for it.
-	Bound time.Duration
-}
-
-// Run calls tool of the build module on node with args, waits for the step's end and answers its result. A step that
-// failed or was refused is an error naming the node, the state and the reason.
-func (r Runner) Run(ctx context.Context, module, node, tool string, args map[string]any) (json.RawMessage, error) {
-	raw, err := r.Caller.CallOn(node, module+"."+tool, args)
-	if err != nil {
-		return nil, fmt.Errorf("%s on %s: %w", tool, node, err)
-	}
-	var answer struct {
-		Step  string `json:"step"`
-		Key   string `json:"key"`
-		State string `json:"state"`
-	}
-	if err := json.Unmarshal(raw, &answer); err != nil {
-		return nil, fmt.Errorf("%s on %s answered what is not a step: %w", tool, node, err)
-	}
-	if answer.Key == "" {
-		return nil, fmt.Errorf("%s on %s answered no step key: %s", tool, node, raw)
-	}
-	if n, _, err := delivery.ParseStepKey(answer.Key); err != nil || n != node {
-		return nil, fmt.Errorf("%s on %s answered the step key %q, which is not a key of that node", tool, node, answer.Key)
-	}
-	wait, cancel := context.WithTimeoutCause(ctx, r.Bound, fmt.Errorf("the step %s did not end within %s", answer.Key, r.Bound))
-	defer cancel()
-	step, err := r.Steps.Wait(wait, module, answer.Key)
-	if err != nil {
-		if cause := context.Cause(wait); cause != nil && ctx.Err() == nil {
-			err = cause
-		}
-		return nil, fmt.Errorf("%s on %s: %w", tool, node, err)
-	}
-	if step.State != delivery.StepPassed {
-		return nil, fmt.Errorf("%s on %s: the step %s %s: %s", tool, node, answer.Key, step.State, step.Reason)
-	}
-	return step.Result, nil
-}

modules/mesh-delivery-builder/buildrun/steps_test.go

@@ -1,125 +0,0 @@
-package buildrun
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-type call struct {
-	node, key string
-	body      any
-}
-
-// fakeCaller answers a long tool as the build modules do: at once, with the step and its key.
-type fakeCaller struct {
-	calls  []call
-	answer string
-	err    error
-}
-
-func (f *fakeCaller) CallOn(node, key string, body any) (json.RawMessage, error) {
-	f.calls = append(f.calls, call{node, key, body})
-	if f.err != nil {
-		return nil, f.err
-	}
-	return json.RawMessage(f.answer), nil
-}
-
-// fakeSteps holds the steps values by `<module>/<key>`; Wait on a key it does not hold blocks until the context ends.
-type fakeSteps struct {
-	mu    sync.Mutex
-	steps map[string]delivery.Step
-	// during, when set, is called as a wait starts and the function it answers as the wait ends.
-	during func(key string) func()
-}
-
-func (f *fakeSteps) Wait(ctx context.Context, module, key string) (delivery.Step, error) {
-	f.mu.Lock()
-	s, ok := f.steps[module+"/"+key]
-	during := f.during
-	f.mu.Unlock()
-	if ok {
-		if during != nil {
-			defer during(key)()
-		}
-		return s, nil
-	}
-	<-ctx.Done()
-	return delivery.Step{}, context.Cause(ctx)
-}
-
-func stepAt(node, id, state, reason string, result string) delivery.Step {
-	s := delivery.Step{ID: id, Tool: "build_go_fetch", Node: node, State: state, Reason: reason}
-	if result != "" {
-		s.Result = json.RawMessage(result)
-	}
-	return s
-}
-
-func runCallsTheToolOnTheNodeAndReadsTheStepsKey(t *testing.T) { // 1607/AC5
-	caller := &fakeCaller{answer: `{"step":"abc1","key":"ace.abc1","state":"running"}`}
-	steps := &fakeSteps{steps: map[string]delivery.Step{"mesh-build-go/ace.abc1": stepAt("ace", "abc1", delivery.StepPassed, "", `{"workspace":"w1","commit":"c"}`)}}
-	res, err := Runner{Caller: caller, Steps: steps, Bound: time.Second}.Run(context.Background(), "mesh-build-go", "ace", "build_go_fetch", map[string]any{"repository": "novox/r", "commit": "c"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(caller.calls) != 1 || caller.calls[0].node != "ace" || caller.calls[0].key != "mesh-build-go.build_go_fetch" {
-		t.Errorf("calls = %+v, want one on ace for mesh-build-go.build_go_fetch", caller.calls)
-	}
-	var fr struct{ Workspace string }
-	if err := json.Unmarshal(res, &fr); err != nil || fr.Workspace != "w1" {
-		t.Errorf("result = %s (%v), want the step's result", res, err)
-	}
-}
-
-func runFailsOnAFailedOrRefusedStepNamingItsReason(t *testing.T) { // 1607/AC5
-	for _, state := range []string{delivery.StepFailed, delivery.StepRefused} {
-		caller := &fakeCaller{answer: `{"step":"abc1","key":"ace.abc1","state":"running"}`}
-		steps := &fakeSteps{steps: map[string]delivery.Step{"mesh-build-go/ace.abc1": stepAt("ace", "abc1", state, "go is go1.26.0, the recipe builds with go1.27.1", "")}}
-		_, err := Runner{Caller: caller, Steps: steps, Bound: time.Second}.Run(context.Background(), "mesh-build-go", "ace", "build_go_build", nil)
-		if err == nil || !strings.Contains(err.Error(), "go1.27.1") || !strings.Contains(err.Error(), state) || !strings.Contains(err.Error(), "ace") {
-			t.Errorf("%s: error = %v, want the node, the state and the reason", state, err)
-		}
-	}
-}
-
-func runStopsWaitingAtTheBound(t *testing.T) { // 1607/AC5
-	caller := &fakeCaller{answer: `{"step":"abc1","key":"ace.abc1","state":"running"}`}
-	_, err := Runner{Caller: caller, Steps: &fakeSteps{}, Bound: 20 * time.Millisecond}.Run(context.Background(), "mesh-build-go", "ace", "build_go_build", nil)
-	if err == nil || !strings.Contains(err.Error(), "ace.abc1") || !strings.Contains(err.Error(), "did not end") {
-		t.Errorf("error = %v, want the step key and that it did not end within its bound", err)
-	}
-}
-
-func runRefusesAnAnswerWithNoKeyAndAKeyOfAnotherNode(t *testing.T) { // 1607/AC5
-	for _, answer := range []string{`{"state":"running"}`, `{"step":"abc1","key":"novox.abc1","state":"running"}`, `not json`} {
-		_, err := Runner{Caller: &fakeCaller{answer: answer}, Steps: &fakeSteps{}, Bound: time.Second}.Run(context.Background(), "mesh-build-go", "ace", "build_go_fetch", nil)
-		if err == nil {
-			t.Errorf("answer %s: no error", answer)
-		}
-	}
-}
-
-func runReturnsTheCallsOwnError(t *testing.T) { // 1607/AC5
-	boom := errors.New("no responders")
-	_, err := Runner{Caller: &fakeCaller{err: boom}, Steps: &fakeSteps{}, Bound: time.Second}.Run(context.Background(), "mesh-build-go", "ace", "build_go_fetch", nil)
-	if !errors.Is(err, boom) || !strings.Contains(err.Error(), "ace") {
-		t.Errorf("error = %v, want the call's error naming the node", err)
-	}
-}
-
-// A step run on its node and read from its steps key, one table of cases (the test budget).
-func TestRunningAStepOnANode(t *testing.T) {
-	t.Run("run calls the tool on the node and reads the steps key", runCallsTheToolOnTheNodeAndReadsTheStepsKey)
-	t.Run("run fails on a failed or refused step naming its reason", runFailsOnAFailedOrRefusedStepNamingItsReason)
-	t.Run("run stops waiting at the bound", runStopsWaitingAtTheBound)
-	t.Run("run refuses an answer with no key and a key of another node", runRefusesAnAnswerWithNoKeyAndAKeyOfAnotherNode)
-	t.Run("run returns the calls own error", runReturnsTheCallsOwnError)
-}

modules/mesh-delivery-builder/buildrun/toolchains.go

@@ -1,64 +0,0 @@
-package buildrun
-
-import (
-	"sync"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// LanguageOf is the language each build module's toolchains state holds (the indexer's ToolchainModules, reversed).
-var LanguageOf = map[string]string{GoBuildModule: "go", NodeBuildModule: "typescript"}
-
-// ToolchainSet holds what the build modules' toolchains buckets hold: each node's entry of a language, as the watches
-// put them in. Safe for use from the watches and from a build at once.
-type ToolchainSet struct {
-	mu sync.Mutex
-	by map[string]map[string]delivery.Toolchain // language -> node -> entry
-}
-
-// Put takes a change of a build module's toolchains bucket in: a put of a node's entry (key <node>.<language>) or its
-// delete. It answers whether the language's entries changed (a node's version or recipe, or a node appearing or going).
-// A key or a value that is not an entry of the module's language is left out.
-func (s *ToolchainSet) Put(module, key string, value []byte, deleted bool) bool {
-	language, ok := LanguageOf[module]
-	if !ok {
-		return false
-	}
-	node, keyLanguage, err := delivery.ParseToolchainKey(key)
-	if err != nil || keyLanguage != language {
-		return false
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if deleted {
-		if _, had := s.by[language][node]; !had {
-			return false
-		}
-		delete(s.by[language], node)
-		return true
-	}
-	tc, err := delivery.DecodeToolchain(value)
-	if err != nil || tc.Language != language {
-		return false
-	}
-	if s.by == nil {
-		s.by = map[string]map[string]delivery.Toolchain{}
-	}
-	if s.by[language] == nil {
-		s.by[language] = map[string]delivery.Toolchain{}
-	}
-	cur, had := s.by[language][node]
-	s.by[language][node] = tc
-	return !had || cur.Version != tc.Version || cur.Recipe != tc.Recipe
-}
-
-// Entries are the nodes' entries of a language, in no particular order.
-func (s *ToolchainSet) Entries(language string) []delivery.NodeToolchain {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	var out []delivery.NodeToolchain
-	for node, tc := range s.by[language] {
-		out = append(out, delivery.NodeToolchain{Node: node, Toolchain: tc})
-	}
-	return out
-}

modules/mesh-delivery-builder/buildrun/toolchains_test.go

@@ -1,49 +0,0 @@
-package buildrun
-
-import (
-	"testing"
-	"time"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-func tcValue(t *testing.T, language, version string) []byte {
-	t.Helper()
-	b, err := delivery.EncodeToolchain(delivery.Toolchain{Language: language, Version: version, Recipe: "1", At: time.Now()})
-	if err != nil {
-		t.Fatal(err)
-	}
-	return b
-}
-
-func TestToolchainSetKeepsEachNodesEntryByLanguageAndSaysWhenOneChanged(t *testing.T) { // 1607/AC6
-	var s ToolchainSet
-	if !s.Put(GoBuildModule, "novox.go", tcValue(t, "go", "go1.27.1"), false) {
-		t.Error("a first entry did not count as a change")
-	}
-	if s.Put(GoBuildModule, "novox.go", tcValue(t, "go", "go1.27.1"), false) {
-		t.Error("the same entry again counted as a change")
-	}
-	s.Put(GoBuildModule, "ace.go", tcValue(t, "go", "go1.27.1"), false)
-	s.Put(NodeBuildModule, "ace.typescript", tcValue(t, "typescript", "tsc5"), false)
-	if got := s.Entries("go"); len(got) != 2 {
-		t.Errorf("go entries = %+v, want two", got)
-	}
-	if got := s.Entries("typescript"); len(got) != 1 || got[0].Node != "ace" || got[0].Version != "tsc5" {
-		t.Errorf("typescript entries = %+v", got)
-	}
-	if !s.Put(GoBuildModule, "ace.go", nil, true) || len(s.Entries("go")) != 1 {
-		t.Error("a delete did not remove the node's entry")
-	}
-	// What is not a toolchain of the module's language is left out.
-	s = ToolchainSet{}
-	if s.Put(GoBuildModule, "novox.typescript", tcValue(t, "typescript", "x"), false) {
-		t.Error("a typescript toolchain in the go build module's bucket counted")
-	}
-	if s.Put(GoBuildModule, "novox.go", []byte("not json"), false) || s.Put("other-module", "novox.go", tcValue(t, "go", "x"), false) {
-		t.Error("garbage or an unknown module counted")
-	}
-	if len(s.Entries("go")) != 0 {
-		t.Error("an entry was kept")
-	}
-}

modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/main.go

@@ -14,119 +14,21 @@ import (
 	"sync"
 	"time"
 
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
 	stdio "git.novox.be/novox/mesh-sdk/go"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
-	"git.novox.be/novox/mesh-sdk/go/handacts"
-	"git.novox.be/novox/mesh-sdk/go/views"
-
-	"git.novox.be/novox/mesh-delivery/sdk/enginereads"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 
 	"mesh-delivery-builder/internal/build"
-	"mesh-delivery-builder/internal/versions"
 )
 
-// EngineReadsTool lists, asks again and drops what each counted node's engine reads, as the builder keeps it.
-const EngineReadsTool = "builder_engine_reads"
-
 // queueAsker writes a queues value and waits for the builder's answer to it.
 type queueAsker func(key string, value []byte) (json.RawMessage, error)
 
 // Tools are the builder's tools: stuck reads, askAgain writes the reasks value, queue writes a queues value and waits for
 // the builder's read, buildAgain writes a reasks value of mode build and waits for the builder's answer.
-// tags writes a tag-asks value and waits for the builder's answer; ta reads tag-asks.
-func Tools(r build.StuckReader, askAgain func(key string, value []byte) error, queue, buildAgain queueAsker, since build.LogSince, now func() time.Time, vs versions.Reader,
-	tags queueAsker, ta, fw, of versions.Reader) []stdio.Tool {
+func Tools(r build.StuckReader, askAgain func(key string, value []byte) error, queue, buildAgain queueAsker, since build.LogSince, now func() time.Time) []stdio.Tool {
 	str := func(args map[string]any, k string) string { s, _ := args[k].(string); return strings.TrimSpace(s) }
-	// handAct writes a reasks value of a versions hand act and answers the builder's answer, or its refusal as an error.
-	handAct := func(key string, value []byte, err error) (any, error) {
-		if err != nil {
-			return nil, err
-		}
-		raw, err := buildAgain(key, value)
-		if err != nil {
-			return nil, err
-		}
-		a, err := build.DecodeReAsk(raw)
-		if err != nil {
-			return nil, err
-		}
-		if a.Refused {
-			return nil, errors.New(a.Answer)
-		}
-		return map[string]any{"key": key, "name": a.Name, "do": a.Do, "version": a.Version, "answer": a.Answer}, nil
-	}
-	tagAct := func(key string, value []byte, err error) (any, error) {
-		if err != nil {
-			return nil, err
-		}
-		raw, err := tags(key, value)
-		if err != nil {
-			return nil, err
-		}
-		return versions.DecodeTagAsk(raw)
-	}
-	nameFP := map[string]any{"type": "object", "required": []string{"name", "fp", "why"}, "properties": map[string]any{
-		"name": map[string]any{"type": "string", "description": "the numbered name, <module>/<artifact>, as builder_versions lists it"},
-		"fp":   map[string]any{"type": "string", "description": "the fingerprint, src2:<hex>"},
-		"why":  map[string]any{"type": "string", "description": "why, in plain words"}}}
-	branch := func(head bool) map[string]any {
-		req := []string{"repository", "branch", "why"}
-		props := map[string]any{
-			"repository": map[string]any{"type": "string", "description": "<owner>/<name>"},
-			"branch":     map[string]any{"type": "string", "description": "the branch; its cleaned name is the tag"},
-			"why":        map[string]any{"type": "string", "description": "why, in plain words"}}
-		if head {
-			req = append(req, "head")
-			props["head"] = map[string]any{"type": "string", "description": "the commit the tagged version is built from"}
-		}
-		return map[string]any{"type": "object", "required": req, "properties": props}
-	}
 	return []stdio.Tool{
-		{Name: versions.PublishAgainTool, Description: versions.PublishAgainDescription, Input: nameFP,
-			Run: func(args map[string]any) (any, error) {
-				return handAct(build.NewPublishAgain(str(args, "name"), str(args, "fp"), str(args, "why"), stdio.CallerOf(args), now()))
-			}},
-		{Name: versions.FloorAgainTool, Description: versions.FloorAgainDescription,
-			Input: map[string]any{"type": "object", "required": []string{"name", "why"}, "properties": map[string]any{
-				"name": map[string]any{"type": "string", "description": "the numbered name, <module>/<artifact>"},
-				"why":  map[string]any{"type": "string", "description": "why, in plain words"}}},
-			Run: func(args map[string]any) (any, error) {
-				return handAct(build.NewFloorAgain(str(args, "name"), str(args, "why"), stdio.CallerOf(args), now()))
-			}},
-		{Name: versions.TagTool, Description: versions.TagDescription, Input: branch(true),
-			Run: func(args map[string]any) (any, error) {
-				return tagAct(versions.NewTagAsk(str(args, "repository"), str(args, "branch"), str(args, "head"), str(args, "why"), stdio.CallerOf(args), now()))
-			}},
-		{Name: versions.UntagTool, Description: versions.UntagDescription, Input: branch(false),
-			Run: func(args map[string]any) (any, error) {
-				return tagAct(versions.NewUntag(str(args, "repository"), str(args, "branch"), str(args, "why"), stdio.CallerOf(args), now()))
-			}},
-		{Name: versions.TagAsksTool, Description: versions.TagAsksDescription,
-			Input: map[string]any{"type": "object", "properties": map[string]any{
-				"repository": map[string]any{"type": "string", "description": "only this repository's asks, <owner>/<name>"}}},
-			Run: func(args map[string]any) (any, error) { return versions.AnswerTagAsks(ta, str(args, "repository")) }},
-		{Name: versions.OldFormTool, Description: versions.OldFormDescription,
-			Input: map[string]any{"type": "object", "properties": map[string]any{
-				"drop": map[string]any{"type": "string", "description": "a retired node to drop from the count by hand"},
-				"why":  map[string]any{"type": "string", "description": "with drop: why, in plain words"}}},
-			Run: func(args map[string]any) (any, error) {
-				if node := str(args, "drop"); node != "" {
-					return handAct(build.NewOldFormDrop(node, str(args, "why"), stdio.CallerOf(args), now()))
-				}
-				return versions.AnswerOldForm(of)
-			}},
-		{Name: versions.FloorWaitsTool, Description: versions.FloorWaitsDescription,
-			Input: map[string]any{"type": "object", "properties": map[string]any{}},
-			Run:   func(map[string]any) (any, error) { return versions.AnswerFloorWaits(fw) }},
-		{Name: versions.VersionsTool, Description: versions.VersionsDescription,
-			Input: map[string]any{"type": "object", "required": []string{"name"}, "properties": map[string]any{
-				"name":    map[string]any{"type": "string", "description": "the package, image, bundle or archive name"},
-				"version": map[string]any{"type": "string", "description": "one version, to ask whether it is recorded"},
-				"digest":  map[string]any{"type": "string", "description": "with version: the digest the holder received"}}},
-			Run: func(args map[string]any) (any, error) {
-				return versions.AnswerVersions(context.Background(), vs, str(args, "name"), str(args, "version"), str(args, "digest"))
-			}},
 		{Name: build.StuckTool,
 			Description: "Every build key that waits (building or queued), oldest first: its module, fingerprint, step words and since when, and each ask it " +
 				"waits on by language with its id, when it was put, its asking (1 for the first; the builder asks an ask again when it can no longer be " +
@@ -196,7 +98,7 @@ func Tools(r build.StuckReader, askAgain func(key string, value []byte) error, q
 			Description: "Every build that ended since a time, oldest first, from the builder's log build-log (kept 30 days): per build its module, " +
 				"fingerprint, source revision, repository, directory, commit and ref, the build node, when it ended, its outcome (done, failed or " +
 				"queued), the manifest built, the bases it was built against and each artifact made with its digest and reference. more says the " +
-				"log held more than one answer carries: ask again from the last build's time. What the operator's command nox builds reads. Read-only.",
+				"log held more than one answer carries: ask again from the last build's time. What mesh-catalog registers a build from. Read-only.",
 			Input: map[string]any{"type": "object", "required": []string{"since"}, "properties": map[string]any{
 				"since": map[string]any{"type": "string", "description": "RFC 3339 time; the builds that ended at or after it"}}},
 			Run: func(args map[string]any) (any, error) {
@@ -362,65 +264,7 @@ func main() {
 		a, err := build.DecodeReAsk(v)
 		return err == nil && !a.Answered.IsZero()
 	})
-	vs := stdio.State(versions.State)
-	vr := versions.Reader{Keys: vs.Keys, Get: func(key string) (json.RawMessage, bool, error) {
-		e, err := vs.Get(key)
-		if err != nil || e == nil {
-			return nil, false, err
-		}
-		return e.Value, true, nil
-	}}
-	ts := stdio.State(versions.TagAsksState)
-	tags := askKept(ts, versions.TagAsksState, versions.TagAsksBucket, "the ask", 25*time.Second, func(v []byte) bool {
-		a, err := versions.DecodeTagAsk(v)
-		return err == nil && !a.Answered.IsZero()
-	})
-	tr := versions.Reader{Keys: ts.Keys, Get: func(key string) (json.RawMessage, bool, error) {
-		e, err := ts.Get(key)
-		if err != nil || e == nil {
-			return nil, false, err
-		}
-		return e.Value, true, nil
-	}}
-	fs := stdio.State(versions.FloorWaitsState)
-	fr := versions.Reader{Keys: fs.Keys, Get: func(key string) (json.RawMessage, bool, error) {
-		e, err := fs.Get(key)
-		if err != nil || e == nil {
-			return nil, false, err
-		}
-		return e.Value, true, nil
-	}}
-	ofs := stdio.State(versions.OldFormState)
-	ofr := versions.Reader{Keys: ofs.Keys, Get: func(key string) (json.RawMessage, bool, error) {
-		e, err := ofs.Get(key)
-		if err != nil || e == nil {
-			return nil, false, err
-		}
-		return e.Value, true, nil
-	}}
-	bs := stdio.State(versions.BoundsState)
-	br := versions.Reader{Keys: bs.Keys, Get: func(key string) (json.RawMessage, bool, error) {
-		e, err := bs.Get(key)
-		if err != nil || e == nil {
-			return nil, false, err
-		}
-		return e.Value, true, nil
-	}}
-	tools := Tools(r, put, askQueue(stdio.State(build.QueuesState), 25*time.Second), buildAgain, stdio.Log(delivery.BuilderLog).Since, time.Now, vr, tags, tr, fr, ofr)
-	// The builder's expiring keys (state bounds): what each bounds and when it ends.
-	tools = append(tools, stdio.Tool{Name: versions.BoundsTool, Description: versions.BoundsDescription,
-		Input: map[string]any{"type": "object", "properties": map[string]any{}},
-		Run: func(map[string]any) (any, error) {
-			rows, err := versions.AnswerBounds(br, time.Now())
-			return map[string]any{"bounds": rows}, err
-		}})
-	// What each counted node's engine reads, as the builder keeps it (ADR 0618 §2, ADR 0624 §1): listed, one node asked
-	// again, or one node's key dropped.
-	tools = append(tools, enginereads.Tool(EngineReadsTool, "the builder", enginereads.KeptState(stdio.State("engine-reads")), true, time.Now))
-	// builder_first_views and builder_first_view_again: where the builder's first views of the indexer's and the assigner's
-	// states stand, and asking one again by hand (ADR 0615, DLV-M1).
-	tools = append(tools, views.StatusTools(delivery.BuilderModule, "builder_first_views", "builder_first_view_again", stdio.State(views.StatusState), handacts.Recorder{Ask: stdio.Ask}, time.Now)...)
-	if err := stdio.Serve("", tools); err != nil {
+	if err := stdio.Serve("", Tools(r, put, askQueue(stdio.State(build.QueuesState), 25*time.Second), buildAgain, stdio.Log(delivery.BuilderLog).Since, time.Now)); err != nil {
 		fmt.Fprintf(os.Stderr, "[mesh-delivery-builder-tools] %v\n", err)
 		os.Exit(1)
 	}

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/branchend.go

@@ -1,174 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"strings"
-	"time"
-
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-	"git.novox.be/novox/mesh-sdk/go/health"
-
-	"mesh-delivery-builder/internal/build"
-	"mesh-delivery-builder/internal/versions"
-)
-
-// forgeStream is the forge bridge's stream `forge` as the bus names it, where the builder's durable consumer hears a
-// branch's end (design 51 *Tagged versions*).
-const forgeStream = "FORGE"
-
-// forgeBranchDeleted is the forge bridge's kind for a branch's end (delivery.ForgeBranchDeleted in the group's mesh-sdk).
-const forgeBranchDeleted = "branch-deleted"
-
-// checkerAsksStream is the checker's family `asks` as the bus names it, and tagWantedSubject its event tag-wanted
-// (design 51 *Tagged versions*, DLV-C3): on the checker's own stream, so its subject is mesh.stream.<module>.event.*.
-const (
-	checkerAsksStream = "ASKS"
-	tagWantedSubject  = "mesh.stream." + delivery.CheckerModule + ".event.tag-wanted"
-)
-
-// forgeEnd is the part of a forge message the builder reads.
-type forgeEnd struct {
-	Kind       string `json:"kind"`
-	Repository string `json:"repository"`
-	Branch     string `json:"branch"`
-	Action     string `json:"action"`
-}
-
-// ended says whether the message ends a branch: merged, a pull closed, or branch-deleted.
-func (f forgeEnd) ended() bool {
-	switch f.Kind {
-	case delivery.ForgeMerged, forgeBranchDeleted:
-		return f.Branch != ""
-	case delivery.ForgePull:
-		return f.Action == delivery.PullClosed && f.Branch != ""
-	}
-	return false
-}
-
-// branchEnds hears the forge bridge's stream: every message wakes a floor whose bridge_tags was silent, and a branch's
-// end removes its tagged versions, acknowledged only once all are removed.
-type branchEnds struct {
-	acts     versions.Acts
-	findings *findings
-	tagAsks  func() jetstream.KeyValue
-	wake     func(ctx context.Context)
-	logf     func(string, ...any)
-	now      func() time.Time
-}
-
-func (h *branchEnds) heard(ctx context.Context, m jetstream.Msg) {
-	if h.wake != nil {
-		h.wake(ctx)
-	}
-	var f forgeEnd
-	if err := json.Unmarshal(m.Data(), &f); err != nil || !f.ended() {
-		h.ack(m)
-		return
-	}
-	end, err := h.acts.BranchEnded(ctx, f.Repository, f.Branch)
-	if err != nil {
-		h.logf("the end of %s %s: the versions cannot be read, heard again: %v", f.Repository, f.Branch, err)
-		h.again(m)
-		return
-	}
-	id := f.Repository + "/" + f.Branch
-	if end.Done {
-		h.findings.clear(ctx, versions.RemovalNotDone, health.ScopeModule, id)
-		if kv := h.tagAsks(); kv != nil {
-			if err := kv.Delete(ctx, versions.TagAskKey(f.Repository, f.Branch)); err != nil && !errors.Is(err, jetstream.ErrKeyNotFound) {
-				h.logf("the tag ask of %s %s stays in %s: %v", f.Repository, f.Branch, versions.TagAsksState, err)
-			}
-		}
-		h.ack(m)
-		return
-	}
-	since := h.now()
-	if md, err := m.Metadata(); err == nil {
-		since = md.Timestamp
-	}
-	if h.now().Sub(since) >= versions.RemovalFindingAfter {
-		h.findings.raise(ctx, finding{kind: versions.RemovalNotDone, scope: health.ScopeModule, id: id,
-			summary:     end.Finding(f.Repository, f.Branch, since),
-			headline:    "A branch's tagged versions are not removed",
-			explanation: "The branch ended, and the registry seats did not say removed for every version tagged for it within 15 minutes.",
-			resolved:    "Every seat said removed.",
-			needs:       "Look at the seats named: " + strings.Join(end.Seats(), ", ")})
-	}
-	h.logf("the end of %s %s: remove asked of %d tagged versions, heard again in a minute", f.Repository, f.Branch, len(end.Left))
-	h.again(m)
-}
-
-func (h *branchEnds) ack(m jetstream.Msg) {
-	if err := m.Ack(); err != nil {
-		h.logf("acknowledging %s: %v", m.Subject(), err)
-	}
-}
-
-// again leaves the message for the bus to give again in a minute: the retry is the bus's redelivery, not a timer here.
-func (h *branchEnds) again(m jetstream.Msg) {
-	if err := m.NakWithDelay(versions.RemoveAgainAfter); err != nil {
-		h.logf("leaving %s for the bus to give again: %v", m.Subject(), err)
-	}
-}
-
-// tagWanted takes the checker's tag-wanted in: written to tag-asks as builder_tag writes it, answered by its watch.
-func tagWanted(ctx context.Context, kv jetstream.KeyValue, m jetstream.Msg, by string, now time.Time, logf func(string, ...any)) {
-	if m.Subject() != tagWantedSubject {
-		_ = m.Ack() // the family's other events (the verdicts) are not the builder's
-		return
-	}
-	var t versions.TagWanted
-	err := json.Unmarshal(m.Data(), &t)
-	var key string
-	var value []byte
-	if err == nil {
-		key, value, err = versions.TagWantedAsk(t, by, now)
-	}
-	if err != nil {
-		logf("%s holds what is no tag-wanted, left: %v", m.Subject(), err)
-		_ = m.Ack()
-		return
-	}
-	if kv == nil {
-		logf("tag-wanted of %s %s is heard again: %s is not on the bus yet", t.Repository, t.Branch, versions.TagAsksState)
-		_ = m.NakWithDelay(versions.RemoveAgainAfter)
-		return
-	}
-	if _, err := kv.Put(ctx, key, value); err != nil {
-		logf("tag-wanted of %s %s is heard again: %v", t.Repository, t.Branch, err)
-		_ = m.Nak()
-		return
-	}
-	_ = m.Ack()
-}
-
-// tagsVia is build.Builder.Tags over the state tag-asks: the asks of the repository, read when a check's build is
-// looked at; none while the state is not bound.
-func tagsVia(kv func() jetstream.KeyValue, logf func(string, ...any)) build.TagOf {
-	return func(ctx context.Context, repository, head string) (string, bool) {
-		store := kv()
-		if store == nil {
-			return "", false
-		}
-		lister, err := store.ListKeysFiltered(ctx, versions.EscapeToken(repository)+".>")
-		if err != nil {
-			logf("the tag asks of %s cannot be read, so its check builds no tagged version: %v", repository, err)
-			return "", false
-		}
-		var asks []versions.TagAsk
-		for key := range lister.Keys() {
-			e, err := store.Get(ctx, key)
-			if err != nil {
-				continue
-			}
-			if t, err := versions.DecodeTagAsk(e.Value()); err == nil {
-				asks = append(asks, t)
-			}
-		}
-		return versions.TagFor(asks, repository, head)
-	}
-}

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/findings.go

@@ -1,174 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"time"
-
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-	"git.novox.be/novox/mesh-sdk/go/health"
-	"git.novox.be/novox/mesh-sdk/go/process"
-
-	"git.novox.be/novox/mesh-delivery/sdk/heard"
-
-	"mesh-delivery-builder/internal/versions"
-)
-
-// findingsBucket is the builder's findings (novox/hq ADR 0564 §2): what it sees wrong now, written at its raise and
-// deleted at its clear, which the condition keeper raises and clears.
-var findingsBucket = health.FindingsBucket(delivery.BuilderModule)
-
-// findings writes the builder's findings into its state, once bound; until then each is said in the log only.
-type findings struct {
-	kv   *process.AwaitedBucket
-	logf func(string, ...any)
-	now  func() time.Time
-	// store stands in for kv in a test.
-	store findingStore
-}
-
-// findingStore is the part of the findings bucket written.
-type findingStore interface {
-	Get(ctx context.Context, key string) (jetstream.KeyValueEntry, error)
-	Put(ctx context.Context, key string, value []byte) (uint64, error)
-	Delete(ctx context.Context, key string, opts ...jetstream.KVDeleteOpt) error
-}
-
-// finding is one of the builder's findings: its kind, what it is about, and its words.
-type finding struct {
-	kind, scope, id                                 string
-	summary, headline, explanation, resolved, needs string
-	severity                                        health.Severity
-}
-
-func (f *findings) bucket() findingStore {
-	switch {
-	case f == nil:
-		return nil
-	case f.store != nil:
-		return f.store
-	case f.kv == nil:
-		return nil
-	}
-	if kv := f.kv.KV(); kv != nil {
-		return kv
-	}
-	return nil
-}
-
-// BuildFailed is the finding of a failed trunk build (DLV-B7, design 25), about its module.
-const BuildFailed = "build-failed"
-
-// buildEnded raises the module's build-failed for a trunk build that failed and clears it at a later done one; a
-// candidate's build (its ref named) is the check's to say.
-func (f *findings) buildEnded(ctx context.Context, e delivery.BuildLogEntry) {
-	if e.Event != delivery.BuildEndedEvent || e.Ref != "" {
-		return
-	}
-	switch e.Outcome {
-	case delivery.BuildFailed:
-		f.raise(ctx, finding{kind: BuildFailed, scope: health.ScopeModule, id: e.Module,
-			summary:     "the trunk build of " + e.Module + " at " + e.FP + " (commit " + e.Commit + ") failed",
-			headline:    "A module's trunk build failed",
-			explanation: "The builder built " + e.Module + " from the trunk and the build failed, so its new version is not delivered.",
-			resolved:    "A later trunk build of " + e.Module + " is done.",
-			needs:       "builder_builds_since shows the build; builder_build_again builds it again."})
-	case delivery.BuildDone:
-		f.clear(ctx, BuildFailed, health.ScopeModule, e.Module)
-	}
-}
-
-// raise writes fd; it is written again only when its words changed, so the keeper's condition moves only then.
-func (f *findings) raise(ctx context.Context, fd finding) {
-	key := health.FindingKey(fd.scope, fd.id, fd.kind)
-	kv := f.bucket()
-	if kv == nil {
-		f.logf("finding %s (not written, %s is not on the bus yet): %s", key, findingsBucket, fd.summary)
-		return
-	}
-	if e, err := kv.Get(ctx, key); err == nil {
-		if old, err := health.DecodeFinding(e.Value()); err == nil && old.Summary == fd.summary {
-			return
-		}
-	}
-	at := f.now().UTC()
-	sev := fd.severity
-	if sev == "" {
-		sev = health.Warning
-	}
-	value, err := health.EncodeFinding(health.Finding{Key: key, Kind: fd.kind, Subject: health.Subject{Scope: fd.scope, ID: fd.id},
-		Severity: sev, Summary: fd.summary, Headline: fd.headline, Explanation: fd.explanation, Resolved: fd.resolved, Needs: fd.needs,
-		Evidence: []health.Evidence{{At: at, Said: fd.summary}}, Source: "builder." + fd.kind, Observer: delivery.BuilderModule, At: at})
-	if err == nil {
-		_, err = kv.Put(ctx, key, value)
-	}
-	if err != nil {
-		f.logf("the finding %s cannot be written: %v", key, err)
-	}
-}
-
-// clear deletes the finding of kind about scope and id; one not there is nothing to clear.
-func (f *findings) clear(ctx context.Context, kind, scope, id string) {
-	kv := f.bucket()
-	if kv == nil {
-		return
-	}
-	key := health.FindingKey(scope, id, kind)
-	if _, err := kv.Get(ctx, key); errors.Is(err, jetstream.ErrKeyNotFound) {
-		return
-	}
-	if err := kv.Delete(ctx, key); err != nil && !errors.Is(err, jetstream.ErrKeyNotFound) {
-		f.logf("the finding %s cannot be cleared: %v", key, err)
-	}
-}
-
-// notHeard is the writer of the builder's finding of a family it does not hear (heard.Writer, ADR 0615 §5): written into
-// its findings once bound, said in the log until then.
-func (f *findings) notHeard(ctx context.Context) heard.Writer {
-	on := func(do func(findingStore)) {
-		switch {
-		case f.store != nil:
-			do(f.store)
-		case f.kv != nil:
-			f.kv.Ready(func(kv jetstream.KeyValue) { do(kv) })
-		}
-	}
-	return heard.Writer{Observer: delivery.BuilderModule, Logf: f.logf, Now: f.now,
-		Put: func(key string, value []byte) error {
-			on(func(kv findingStore) {
-				if _, err := kv.Put(ctx, key, value); err != nil {
-					f.logf("the finding %s cannot be written: %v", key, err)
-				}
-			})
-			return nil
-		},
-		Delete: func(key string) error {
-			on(func(kv findingStore) {
-				if _, err := kv.Get(ctx, key); err != nil {
-					return // none stands
-				}
-				if err := kv.Delete(ctx, key); err != nil {
-					f.logf("the finding %s cannot be cleared: %v", key, err)
-				}
-			})
-			return nil
-		}}
-}
-
-// floorSaid is the floor finding (design 51 *Health and conditions*: a floor source silent): raised for a name waiting on
-// its floor, about that name, cleared once all three sources answered.
-func (f *findings) floorSaid(ctx context.Context) func(versions.FloorWait, bool) {
-	return func(w versions.FloorWait, raised bool) {
-		if !raised {
-			f.clear(ctx, versions.FloorSilent, health.ScopeModule, w.Name)
-			return
-		}
-		f.raise(ctx, finding{kind: versions.FloorSilent, scope: health.ScopeModule, id: w.Name, summary: w.Finding(),
-			headline:    "A version's floor is not known",
-			explanation: "The builder numbers a name only once its registry seat, the forge bridge's tags and the indexer's requirements all answered; one of them did not.",
-			resolved:    "All three answered.",
-			needs:       "builder_floor_waits names the silent source; builder_floor_again asks again by hand."})
-	}
-}

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/integration_test.go

@@ -9,10 +9,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"maps"
+	"io"
 	"os"
 	"path/filepath"
-	"slices"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -23,20 +22,12 @@ import (
 	"github.com/nats-io/nats.go"
 	"github.com/nats-io/nats.go/jetstream"
 
-	// The build runner the build modules pull and run asks with: mesh-build-go's own package (novox/hq ADR 0593 §1),
-	// another repository's, by its published version, so the builder is tested against the real pulling code.
-	runner "git.novox.be/novox/mesh-catalog/modules/mesh-build-go/buildstep"
-	"git.novox.be/novox/mesh-contracts/go/seats/gopackageregistry"
-	"git.novox.be/novox/mesh-contracts/go/seats/ociartifactregistry"
 	"git.novox.be/novox/mesh-sdk/go/buildstep"
 	"git.novox.be/novox/mesh-sdk/go/buscompose"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
-	"git.novox.be/novox/mesh-sdk/go/health"
 	"git.novox.be/novox/mesh-sdk/go/process"
-	"git.novox.be/novox/mesh-sdk/go/views/viewstest"
 
 	"mesh-delivery-builder/internal/build"
-	"mesh-delivery-builder/internal/versions"
 )
 
 // busConf is the shape of the composed accounts file (mesh-controller internal/broker): one account with JetStream, the
@@ -62,7 +53,7 @@ const (
 )
 
 // fakeBuildModules are the build modules on the nodes as the real ones run since R4g (ADR 0525; issue 1887 A4): each pulls
-// its build seat's asks on its nodes (runner.Puller over the seat's workers) and runs an ask's job with step bodies that
+// its build seat's asks on its nodes (buildstep.Puller over the seat's workers) and runs an ask's job with step bodies that
 // answer as the real tools do, ending the step on <node>.<ask id> of its steps bucket.
 type fakeBuildModules struct {
 	js        jetstream.JetStream
@@ -77,17 +68,14 @@ type fakeBuildModules struct {
 	// closed, while set, keeps every node's capacity at 0: no ask is pulled until open is called (a test of the asks
 	// waiting in their streams).
 	closed  atomic.Bool
-	pullers []*runner.Puller
-	// hang, while it holds a channel, keeps every build step running until the channel is closed: a step that never ends,
-	// so the builder's step bound runs out (design 51's round-2 case).
-	hang atomic.Pointer[chan struct{}]
+	pullers []*buildstep.Puller
 }
 
 // open lets the nodes pull again and wakes their pullers.
 func (f *fakeBuildModules) open() {
 	f.closed.Store(false)
 	f.mu.Lock()
-	ps := append([]*runner.Puller(nil), f.pullers...)
+	ps := append([]*buildstep.Puller(nil), f.pullers...)
 	f.mu.Unlock()
 	for _, p := range ps {
 		p.Wake()
@@ -119,12 +107,6 @@ func (f *fakeBuildModules) step(module, name string, args map[string]any) (any,
 		f.builds = append(f.builds, args)
 	}
 	f.mu.Unlock()
-	if h := f.hang.Load(); h != nil && name == "build" {
-		select {
-		case <-*h:
-		case <-f.ctx.Done():
-		}
-	}
 	switch {
 	case name == "fetch":
 		merge := ""
@@ -157,26 +139,26 @@ func (f *fakeBuildModules) serve(t *testing.T, module string, nodes ...string) {
 		t.Fatal(err)
 	}
 	language := strings.TrimPrefix(module, "mesh-build-")
-	if err := runner.DeclareAskWorkers(f.ctx, f.js, language, 30*time.Second); err != nil {
+	if err := buildstep.DeclareAskWorkers(f.ctx, f.js, language, 30*time.Second); err != nil {
 		t.Fatal(err)
 	}
 	put := func(key string, value any) (uint64, error) {
 		raw, _ := value.(json.RawMessage)
 		return kv.Put(f.ctx, key, raw)
 	}
-	call := func(name string) runner.StepFunc {
+	call := func(name string) buildstep.StepFunc {
 		return func(ctx context.Context, args map[string]any) (any, error) { return f.step(module, name, args) }
 	}
-	steps := runner.AskSteps{Fetch: call("fetch"), Build: call("build"), Copy: call("copy")}
+	steps := buildstep.AskSteps{Fetch: call("fetch"), Build: call("build"), Copy: call("copy")}
 	for _, node := range nodes {
-		p := &runner.Puller{Source: &runner.JetStreamAsks{JS: f.js, Language: language}, Language: language, Node: node, Put: put,
+		p := &buildstep.Puller{Source: &buildstep.JetStreamAsks{JS: f.js, Language: language}, Language: language, Node: node, Put: put,
 			Capacity: func() int {
 				if f.closed.Load() {
 					return 0
 				}
 				return 2
 			}, PullWait: 200 * time.Millisecond,
-			Run: func(ctx context.Context, a delivery.StepAsk) (any, error) { return runner.RunAsk(ctx, steps, a) }}
+			Run: func(ctx context.Context, a delivery.StepAsk) (any, error) { return buildstep.RunAsk(ctx, steps, a) }}
 		f.mu.Lock()
 		f.pullers = append(f.pullers, p)
 		f.mu.Unlock()
@@ -210,11 +192,7 @@ type bed struct {
 	builds     jetstream.KeyValue
 	tools      map[string]jetstream.KeyValue
 	instances  jetstream.KeyValue
-	tagAsks    jetstream.KeyValue
-	tagBounds  jetstream.KeyValue
-	packages   jetstream.KeyValue // the indexer's packages, served by its read tool and views family
-	out        *saidLog           // the builder's process log, every instance's
-	stop       func()             // stops the builder started last
+	stop       func() // stops the builder started last
 	fake       *fakeBuildModules
 	srvURL     string
 	dir        string
@@ -289,23 +267,8 @@ func startBedWith(t *testing.T, closed bool) *bed {
 	b.candidates = mk(delivery.CandidatesBucket, delivery.CandidatesHistory)
 	b.source = mk(delivery.SourceBucket, delivery.SourceHistory)
 	mk(delivery.ManifestsBucket, delivery.ManifestsHistory)
-	// The indexer and the assigner as the owners of the states the builder follows: their read tools and views families
-	// (ADR 0615, DLV-M1); n1 and n2 each have their durable consumer.
-	readers := []string{"n1_" + delivery.BuilderModule, "n2_" + delivery.BuilderModule}
-	for _, st := range []string{modulesState, manifestsState, candidatesState} {
-		viewstest.Serve(t, ctx, js, ctl, delivery.IndexerModule, st, delivery.IndexerModule+".indexer_read_"+st, indexerViews, readers...)
-	}
-	b.packages = viewstest.Serve(t, ctx, js, ctl, delivery.IndexerModule, delivery.PackagesState, delivery.IndexerModule+".indexer_read_packages", indexerViews, readers...)
-	viewstest.Serve(t, ctx, js, ctl, delivery.AssignerModule, delivery.PlacementState, delivery.AssignerModule+".assigner_read_placement", assignerViews, readers...)
 	b.builds = mk(delivery.BuilderBuildsBucket, delivery.BuilderBuildsHistory)
 	b.instances = mk(instancesBucket, 1)
-	// The tag asks and their bounds (design 51 *Tagged versions*): the bounds declared key-ttl, so an ended bound leaves the
-	// bus's marker a watch hears.
-	b.tagAsks = mk(versions.TagAsksBucket, 1)
-	if b.tagBounds, err = js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: versions.TagAskBoundsBucket, History: 1, LimitMarkerTTL: time.Minute}); err != nil {
-		t.Fatal(err)
-	}
-	b.out = &saidLog{}
 	// The builder's module log, as the runtime raises it (ADR 0297): its stream on the log's subjects.
 	logStream := buscompose.LogStreamName(delivery.BuilderModule, delivery.BuilderLog)
 	if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: logStream, Subjects: []string{buscompose.LogSubject(delivery.BuilderModule, delivery.BuilderLog) + ".>"},
@@ -365,24 +328,15 @@ func (b *bed) report(t *testing.T, module, node, language, version, recipe strin
 
 // module writes modules.<name> as the indexer does for a module with a new-form fingerprint, and its manifest by digest.
 func (b *bed) module(t *testing.T, name, fixture, path string) string {
-	return b.moduleWith(t, name, fixture, path, bothToolchains)
+	return b.moduleWith(t, name, fixture, path, map[string]delivery.ToolchainUsed{"go": {Version: "go1.27.1", Recipe: "1"}, "typescript": {Version: "tsc5", Recipe: "1"}})
 }
 
-// bothToolchains are the toolchains the bed's nodes report, as a module's fingerprint names them.
-var bothToolchains = map[string]delivery.ToolchainUsed{"go": {Version: "go1.27.1", Recipe: "1"}, "typescript": {Version: "tsc5", Recipe: "1"}}
-
 // moduleWith is module with the toolchains its fingerprint was computed with.
 func (b *bed) moduleWith(t *testing.T, name, fixture, path string, toolchains map[string]delivery.ToolchainUsed) string {
 	return b.moduleCommit(t, name, fixture, path, toolchains, commit)
 }
 
 func (b *bed) moduleCommit(t *testing.T, name, fixture, path string, toolchains map[string]delivery.ToolchainUsed, at string) string {
-	t.Helper()
-	return b.moduleFP(t, name, fixture, path, toolchains, at, fp, 0)
-}
-
-// moduleFP is moduleCommit with the new-form fingerprint fp2 and the source revision src of its merge (0: none).
-func (b *bed) moduleFP(t *testing.T, name, fixture, path string, toolchains map[string]delivery.ToolchainUsed, at, fp2 string, src uint64) string {
 	t.Helper()
 	raw, err := os.ReadFile(filepath.Join("testdata", fixture))
 	if err != nil {
@@ -400,8 +354,8 @@ func (b *bed) moduleFP(t *testing.T, name, fixture, path string, toolchains map[
 	if _, err := manifests.Put(b.ctx, digest, mv); err != nil {
 		t.Fatal(err)
 	}
-	data, err := delivery.EncodeModule(delivery.Module{Repository: "novox/mesh-catalog", Commit: at, FP: "src1:" + strings.Repeat("f", 64), FP2: fp2,
-		Manifest: digest, Path: path, Toolchains: toolchains, Src: src})
+	data, err := delivery.EncodeModule(delivery.Module{Repository: "novox/mesh-catalog", Commit: at, FP: "src1:" + strings.Repeat("f", 64), FP2: fp,
+		Manifest: digest, Path: path, Toolchains: toolchains})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -432,58 +386,16 @@ func (b *bed) start(t *testing.T, node string, env map[string]string) {
 	}
 	runCtx, stop := context.WithCancel(b.ctx)
 	done := make(chan error, 1)
-	go func() { done <- run(runCtx, func(k string) string { return e[k] }, b.out) }()
+	go func() { done <- run(runCtx, func(k string) string { return e[k] }, io.Discard) }()
 	var once sync.Once
 	b.stop = func() { once.Do(func() { stop(); <-done }) }
 	t.Cleanup(b.stop)
 }
 
-// saidLog is the builder's process log as its instances write it.
-type saidLog struct {
-	mu  sync.Mutex
-	buf strings.Builder
-}
-
-func (l *saidLog) Write(p []byte) (int, error) {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	return l.buf.Write(p)
-}
-
-// awaitSaid reads the process log until it holds want, within 20 s, and answers the line.
-func (b *bed) awaitSaid(t *testing.T, want string) string {
-	t.Helper()
-	deadline := time.Now().Add(20 * time.Second)
-	for {
-		b.out.mu.Lock()
-		all := b.out.buf.String()
-		b.out.mu.Unlock()
-		for _, line := range strings.Split(all, "\n") {
-			if strings.Contains(line, want) {
-				return line
-			}
-		}
-		if time.Now().After(deadline) {
-			t.Fatalf("the builder never said %q; it said:\n%s", want, all)
-		}
-		select {
-		case <-b.ctx.Done():
-			t.Fatal(b.ctx.Err())
-		case <-time.After(50 * time.Millisecond):
-		}
-	}
-}
-
 // await reads the build key until pred holds of it, within 20 s.
 func (b *bed) await(t *testing.T, module string, pred func(delivery.BuilderBuild) bool) delivery.BuilderBuild {
 	t.Helper()
-	return b.awaitFP(t, module, fp, pred)
-}
-
-// awaitFP is await of the build key of fingerprint at.
-func (b *bed) awaitFP(t *testing.T, module, at string, pred func(delivery.BuilderBuild) bool) delivery.BuilderBuild {
-	t.Helper()
-	key, err := delivery.BuilderBuildKey(module, at)
+	key, err := delivery.BuilderBuildKey(module, fp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -510,31 +422,9 @@ func isState(state string) func(delivery.BuilderBuild) bool {
 // the digests of both bundles, both build modules' toolchains, after a fetch and a build on one node (ADR 0478 clause 4).
 func TestBuilderMakesADoneKeyWithTheDigests(t *testing.T) { // 1607/AC7
 	b := startBed(t)
-	// DLV-B10 (design 51, round 2): the builder's versions, findings and the floor's three sources are on the bus; the seat
-	// answers 0.1.4, so netcheck's bundles are numbered from 0.1.5. Two merges close together, the first replaced before
-	// its claim: the second is numbered at once, and the first never.
-	reg := b.registry(t, "n1", "0.1.4")
-	const netcheck = "catalogue-a67f0196-netcheck.module.json"
-	first := "src2:" + strings.Repeat("1", 64)
-	b.moduleFP(t, "netcheck", netcheck, "modules/netcheck", bothToolchains, commit, first, 1)
-	digest := b.moduleFP(t, "netcheck", netcheck, "modules/netcheck", bothToolchains, commit, fp, 2)
-	// DLV-B6: a tag ask kept and never numbered (no check builds its head) is narrated once its bound ends on the bus, with
-	// what it waits on, and its bound is written again; no timer runs in the builder.
-	key, ask, err := versions.NewTagAsk("novox/mesh-sdk", "feat/x", "abc", "a group member's check", "me@shanks", time.Now())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := b.tagAsks.Put(b.ctx, key, ask); err != nil {
-		t.Fatal(err)
-	}
-	b.start(t, "n1", map[string]string{"MESH_BUILDER_TAG_ASK_BOUND": "1s", "MESH_BUILDER_STEP_BOUND": "1s"})
+	digest := b.module(t, "netcheck", "catalogue-a67f0196-netcheck.module.json", "modules/netcheck")
+	b.start(t, "n1", nil)
 	v := b.await(t, "netcheck", isState(delivery.BuildDone))
-	for _, a := range []string{"tools-go", "tools-typescript"} {
-		es := reg.of(t, "netcheck/"+a)
-		if len(es) != 1 || es[0].Version != "0.1.5" || es[0].Fingerprint != fp || es[0].State != versions.Numbered || es[0].Digest != digestOf(a) {
-			t.Errorf("versions of netcheck/%s = %+v, want the second merge numbered 0.1.5 at once with its digest, the first never", a, es)
-		}
-	}
 	if v.By != "n1.mesh-delivery-builder" || v.Manifest != digest || len(v.Artifacts) != 2 {
 		t.Fatalf("build = %+v", v)
 	}
@@ -546,21 +436,9 @@ func TestBuilderMakesADoneKeyWithTheDigests(t *testing.T) { // 1607/AC7
 	if v.Toolchains["go"].Version != "go1.27.1" || v.Toolchains["typescript"].Version != "tsc5" {
 		t.Errorf("toolchains = %+v", v.Toolchains)
 	}
-	// ADR 0618 §1: the done key names the reference forms it is written in.
-	if len(v.Needs) != 1 || v.Needs[0] != "form:artifact-store" {
-		t.Errorf("needs = %v, want the first form", v.Needs)
-	}
 	// 1955/L7 (ADR 0571 §1): the build's start and end are in the module log build-log under the module's key, read as a
 	// reader with the log's read reads them, the end naming the manifest and what was made.
-	// DLV-B10: between them the build log holds the build's narrations (build.said), each version numbered, and why.
-	var ended []delivery.BuildLogEntry
-	for _, e := range b.logged(t, "netcheck") {
-		if e.Event != delivery.BuildSaidEvent {
-			ended = append(ended, e)
-		} else if e.Why != versions.SaidNumbered || !strings.Contains(e.Line, "numbered 0.1.5") || e.FP != fp {
-			t.Errorf("said = %+v, want netcheck's versions numbered", e)
-		}
-	}
+	ended := b.logged(t, "netcheck")
 	if len(ended) != 2 || ended[0].Event != delivery.BuildStartedEvent || ended[1].Event != delivery.BuildEndedEvent ||
 		ended[1].Manifest != digest || len(ended[1].Made) != 2 || ended[1].Node != "n1" {
 		t.Errorf("logged = %+v, want the start and the end of netcheck's build", ended)
@@ -570,168 +448,38 @@ func TestBuilderMakesADoneKeyWithTheDigests(t *testing.T) { // 1607/AC7
 			t.Errorf("%s called %d times, want %d (on one node, ADR 0478 clause 4)", tool, got, want)
 		}
 	}
-	said := b.awaitSaid(t, "the tag ask of novox/mesh-sdk feat/x at abc (feat-x) is not answered after")
-	if !strings.Contains(said, "the check's build of abc is not claimed yet") {
-		t.Errorf("the narration = %q, want what the ask waits on", said)
+}
+
+// TestTwoBuilderInstancesStartingTogetherEndWithOneDoneKey: two builders on two nodes start together on one module key of an
+// archive only (no toolchain named, as the indexer writes it); the second takes over the key the first holds building
+// (ADR 0478 clause 6), and the key ends done, written once.
+func TestTwoBuilderInstancesStartingTogetherEndWithOneDoneKey(t *testing.T) { // 1607/AC7
+	b := startBed(t)
+	b.archive(t, "ca-trust", "modules/ca-trust", commit)
+	b.start(t, "n1", nil)
+	b.start(t, "n2", nil)
+	v := b.await(t, "ca-trust", isState(delivery.BuildDone))
+	if len(v.Artifacts) != 1 || v.Artifacts[0].Kind != "archive" || v.Artifacts[0].Digest != digestOf("files") {
+		t.Fatalf("build = %+v, want the archive's digest", v)
 	}
-	// And in the build log, under the builder's own key (the ruling of 13:17: build.said).
-	if !slices.ContainsFunc(b.logged(t, delivery.BuilderModule), func(e delivery.BuildLogEntry) bool {
-		return e.Event == delivery.BuildSaidEvent && e.Why == versions.SaidUnanswered && e.FP == key && e.Commit == "abc" &&
-			strings.Contains(e.Line, "the check's build of abc is not claimed yet")
-	}) {
-		t.Errorf("the build log of %s = %+v, want the unanswered tag ask said", delivery.BuilderModule, b.logged(t, delivery.BuilderModule))
+	if n := b.fake.count("mesh-build-go.build_go_build"); n < 1 { // each instance that built, on one node
+		t.Errorf("build_go_build was called %d times, want one for each instance that built", n)
 	}
-	if e, err := b.tagAsks.Get(b.ctx, key); err != nil {
-		t.Fatal(err)
-	} else if a, _ := versions.DecodeTagAsk(e.Value()); a.Answered.IsZero() || !a.Unanswered() {
-		t.Errorf("the tag ask = %+v, want kept and answered, no version yet", a)
-	}
-	for deadline := time.Now().Add(10 * time.Second); ; time.Sleep(50 * time.Millisecond) {
-		if _, err := b.tagBounds.Get(b.ctx, key); err == nil {
-			break
-		} else if time.Now().After(deadline) {
-			t.Fatalf("the bound is not written again after its narration: %v", err)
-		}
-	}
-	// Design 32, ADR 0615 §1: a package's name the indexer writes later reaches the builder by its packages' views family
-	// (never their bucket), and looks at the module again; the done bundles are kept, not numbered twice.
-	if _, err := b.packages.Put(b.ctx, "netcheck.0.1", []byte(`{"v":1,"name":"netcheck","package":"netcheck/lib","series":"0.1"}`)); err != nil {
-		t.Fatal(err)
-	}
-	b.awaitSaid(t, "names a package of netcheck")
-	if got := reg.numberedOf("netcheck/tools-go"); len(got) != 1 || got[0] != "0.1.5" {
-		t.Errorf("version.numbered of netcheck/tools-go = %v, want 0.1.5 once", got)
-	}
-	// DLV-B10: builder_publish_again after a published takes a new number, and says it numbered.
-	for _, a := range []string{"tools-go", "tools-typescript"} {
-		reg.published(t, "netcheck/"+a, "0.1.5", digestOf(a))
-	}
-	reg.awaitOf(t, "netcheck/tools-go", func(es []versions.Entry) bool { return len(es) == 1 && es[0].State == versions.Published })
-	key, again, err := build.NewPublishAgain("netcheck/tools-go", fp, "the holder lost it", "me@shanks", time.Now())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if a := reg.answered(t, key, again); a.Refused || a.Do != versions.AgainRenumber || a.Version != "0.1.6" {
-		t.Errorf("builder_publish_again = %+v, want a new number, 0.1.6", a)
-	}
-	// Running-testing note (review round 1): two claims never get one number on the bus's own compare-and-set, as
-	// the builder's state versions keeps them: eight claims of one name at once, eight versions.
-	store := versions.Versions{Store: awaitedVersions{process.AwaitBucket(b.ctx, b.js, nil, versions.Bucket, "", t.Logf)}}
-	numbers := make(chan string, 8)
-	var claims sync.WaitGroup
-	for i := range 8 {
-		claims.Go(func() {
-			d, _, err := store.Number(b.ctx, versions.Claim{Name: "netcheck/race", Kind: versions.KindBundle, Fingerprint: fmt.Sprintf("f%d", i)})
-			if err != nil {
-				t.Error(err)
-			}
-			numbers <- d.Version
-		})
-	}
-	claims.Wait()
-	close(numbers)
-	got := map[string]bool{}
-	for v := range numbers {
-		got[v] = true
-	}
-	if len(got) != 8 {
-		t.Errorf("eight claims of one name at once were numbered %v, want eight versions", slices.Sorted(maps.Keys(got)))
-	}
-	if got := reg.numberedOf("netcheck/tools-go"); len(got) != 2 || got[1] != "0.1.6" {
-		t.Errorf("version.numbered of netcheck/tools-go = %v, want 0.1.6 said after 0.1.5", got)
-	}
-	// DLV-B10: a build module's bound running out fails the trunk build, which is the builder's finding build-failed; the
-	// fingerprint built again keeps its number, said with why, and its done build clears the finding.
-	release := make(chan struct{})
-	b.fake.hang.Store(&release)
-	third := "src2:" + strings.Repeat("4", 64)
-	b.moduleFP(t, "netcheck", netcheck, "modules/netcheck", bothToolchains, commit, third, 3)
-	if f := b.awaitFP(t, "netcheck", third, isState(delivery.BuildFailed)); !strings.Contains(f.Error, "did not end within") {
-		t.Errorf("the failed build = %+v, want its bound run out", f)
-	}
-	failed := health.FindingKey(health.ScopeModule, "netcheck", BuildFailed)
-	reg.awaitFinding(t, failed, true)
-	b.fake.hang.Store(nil)
-	close(release)
-	b.moduleFP(t, "netcheck", netcheck, "modules/netcheck", bothToolchains, commit, third, 3) // the indexer writes it again
-	b.awaitFP(t, "netcheck", third, isState(delivery.BuildDone))
-	b.awaitSaid(t, "kept: fingerprint "+third+" is numbered under it")
-	if !slices.ContainsFunc(b.logged(t, "netcheck"), func(e delivery.BuildLogEntry) bool {
-		return e.Event == delivery.BuildSaidEvent && e.Why == versions.SaidKept && e.FP == third && strings.Contains(e.Line, "kept: fingerprint "+third)
-	}) {
-		t.Errorf("the build log of netcheck says no version kept at %s", third)
-	}
-	reg.awaitFinding(t, failed, false)
-	// DLV-B4: the seats' refused and removed, heard on the builder's durable consumer, move a numbered version: a retention
-	// removal turns the entry removed with its reason, a refusal refused with the holder's reason and the bytes it refused.
-	reg.outcome(t, ociartifactregistry.SubjectRemoved, versions.Outcome{Name: "netcheck/tools-typescript", Version: "0.1.5", Kind: "bundle", Holder: "distribution", Reason: "retention"})
-	reg.outcome(t, ociartifactregistry.SubjectRefused, versions.Outcome{Name: "netcheck/tools-go", Version: "0.1.6", Digest: digestOf("other"), Kind: "bundle", Holder: "distribution", Reason: "the cap"})
-	reg.awaitOf(t, "netcheck/tools-typescript", func(es []versions.Entry) bool {
-		return slices.ContainsFunc(es, func(e versions.Entry) bool {
-			return e.Version == "0.1.5" && e.State == versions.Removed && e.Reason == "retention"
-		})
-	})
-	reg.awaitOf(t, "netcheck/tools-go", func(es []versions.Entry) bool {
-		return slices.ContainsFunc(es, func(e versions.Entry) bool {
-			return e.Version == "0.1.6" && e.State == versions.Refused && e.Reason == "the cap" && e.RefusedDigest == digestOf("other")
-		})
-	})
-	// DLV-B6: a branch's end (the forge bridge's merged) asks the seat to remove each version tagged for it, the reason
-	// tag-gone, and the seat's removed turns it removed.
-	tagged := versions.Entry{Name: "mesh-sdk/go", Kind: versions.KindPackage, Series: "0.1", Version: "0.1.15-feat-x.1", Tag: "feat-x", Module: "mesh-sdk",
-		Fingerprint: "src2:" + strings.Repeat("5", 64), Repository: "novox/mesh-sdk", Seat: gopackageregistry.Seat, State: versions.Published, At: time.Now().UTC()}
-	raw, _ := json.Marshal(tagged)
-	if _, err := reg.versions.Put(b.ctx, versions.Key(tagged.Name, tagged.Version), raw); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := b.js.Publish(b.ctx, process.ModuleStreamSubject(delivery.ForgeBridgeModule, "forge"),
-		[]byte(`{"kind":"`+delivery.ForgeMerged+`","repository":"novox/mesh-sdk","branch":"feat/x"}`)); err != nil {
-		t.Fatal(err)
-	}
-	for deadline := time.Now().Add(20 * time.Second); ; time.Sleep(50 * time.Millisecond) {
-		reg.mu.Lock()
-		asked := slices.ContainsFunc(reg.removes, func(a map[string]any) bool {
-			return a["name"] == tagged.Name && a["version"] == tagged.Version && a["reason"] == "tag-gone"
-		})
-		reg.mu.Unlock()
-		if asked {
-			break
-		}
-		if time.Now().After(deadline) {
-			t.Fatalf("the seat's remove of %s@%s was not asked at the branch's end: %v", tagged.Name, tagged.Version, reg.removes)
-		}
-	}
-	reg.outcome(t, gopackageregistry.SubjectRemoved, versions.Outcome{Name: tagged.Name, Version: tagged.Version, Kind: versions.KindPackage, Holder: "gitea", Reason: "tag-gone"})
-	reg.awaitOf(t, tagged.Name, func(es []versions.Entry) bool { return len(es) == 1 && es[0].State == versions.Removed })
 }
 
 // TestAnArchiveOnlyModuleAndARootModuleAreBuilt: the indexer gives an archive no language, so modules.ca-trust has no
 // toolchains; the builder builds it on the build module's nodes all the same (review round 4). A module whose path is "."
-// is given to the build tools as it is (1615/AC4). Two builders on two nodes start together on the archive's key: the
-// second takes over the key the first holds building (ADR 0478 clause 6), and the key ends done, written once (1607/AC7).
-// One table: three tests were merged, to pay for the enrolment's and to bring mesh-delivery's count down (DLV-B8).
+// is given to the build tools as it is (1615/AC4). One table: the two tests were merged to pay for the enrolment's.
 func TestAnArchiveOnlyModuleAndARootModuleAreBuilt(t *testing.T) {
-	for _, c := range []struct {
-		name, path string
-		two        bool
-	}{{"no toolchain", "modules/ca-trust", false}, {"root", delivery.RootPath, false}, {"two instances together", "modules/ca-trust", true}} {
+	for _, c := range []struct{ name, path string }{{"no toolchain", "modules/ca-trust"}, {"root", delivery.RootPath}} {
 		t.Run(c.name, func(t *testing.T) {
 			b := startBed(t)
 			b.archive(t, "ca-trust", c.path, commit)
 			b.start(t, "n1", nil)
-			if c.two {
-				b.start(t, "n2", nil)
-			}
 			v := b.await(t, "ca-trust", isState(delivery.BuildDone))
 			if c.name == "no toolchain" && (len(v.Toolchains) != 0 || len(v.Artifacts) != 1 || strings.HasPrefix(v.Step, "one node (")) {
 				t.Errorf("build = %+v, want done naming no toolchain", v)
 			}
-			if c.two && (len(v.Artifacts) != 1 || v.Artifacts[0].Kind != "archive" || v.Artifacts[0].Digest != digestOf("files")) {
-				t.Errorf("build = %+v, want the archive's digest", v)
-			}
-			if n := b.fake.count("mesh-build-go.build_go_build"); c.two && n < 1 { // each instance that built, on one node
-				t.Errorf("build_go_build was called %d times, want one for each instance that built", n)
-			}
 		})
 	}
 }
@@ -1040,12 +788,7 @@ func TestTheBuilderAsksTheBuildSeatsAndCallsNoNode(t *testing.T) {
 	}
 	defer sub.Close()
 	var calls atomic.Int64
-	// A build module's tool, never the owners' read tools the builder's first views ask (DLV-M1).
-	s, err := sub.Subscribe("mesh.mod.*.call.>", func(m *nats.Msg) {
-		if strings.HasPrefix(m.Subject, "mesh.mod.mesh-build-") {
-			calls.Add(1)
-		}
-	})
+	s, err := sub.Subscribe("mesh.mod.*.call.>", func(*nats.Msg) { calls.Add(1) })
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1164,184 +907,3 @@ func TestARestartedBuilderPutsNoSecondAsk(t *testing.T) {
 		t.Errorf("done = %+v", done)
 	}
 }
-
-// registry is the part of the bed design 51's builder cases need: the builder's states versions, findings, floor-waits and
-// reasks, EVENTS with the seat oci-artifact-registry's outcomes and the builder's durable consumer of it, the builder's
-// own events kept, and the floor's three sources served on the bus as their holders answer through the tool runner
-// ({result}): the seat's versions, the forge bridge's bridge_tags and the indexer's indexer_requirements.
-type registry struct {
-	b                          *bed
-	versions, findings, reasks jetstream.KeyValue
-	mu                         sync.Mutex
-	numbered                   []delivery.VersionNumbered
-	removes                    []map[string]any
-}
-
-func (b *bed) registry(t *testing.T, node string, seatVersions ...string) *registry {
-	t.Helper()
-	r := &registry{b: b}
-	mk := func(name string) jetstream.KeyValue {
-		kv, err := b.js.CreateKeyValue(b.ctx, jetstream.KeyValueConfig{Bucket: name, History: 1})
-		if err != nil {
-			t.Fatal(err)
-		}
-		return kv
-	}
-	r.versions, r.findings, r.reasks = mk(versions.Bucket), mk(findingsBucket), mk(build.ReAsksBucket)
-	mk(versions.FloorWaitsBucket)
-	// EVENTS with two seats' outcomes, and the forge bridge's stream (a branch's end): each with the builder's durable consumer.
-	for stream, subjects := range map[string][]string{
-		eventsStream: {delivery.ArtifactsGoneSubject, ociartifactregistry.SubjectPublished, ociartifactregistry.SubjectRefused, ociartifactregistry.SubjectRemoved,
-			gopackageregistry.SubjectPublished, gopackageregistry.SubjectRefused, gopackageregistry.SubjectRemoved},
-		forgeStream: {process.ModuleStreamSubject(delivery.ForgeBridgeModule, ">")},
-	} {
-		if _, err := b.js.CreateStream(b.ctx, jetstream.StreamConfig{Name: stream, Subjects: subjects}); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := b.js.CreateOrUpdateConsumer(b.ctx, stream, jetstream.ConsumerConfig{Durable: node + "_" + delivery.BuilderModule,
-			AckPolicy: jetstream.AckExplicitPolicy}); err != nil {
-			t.Fatal(err)
-		}
-	}
-	// The Go seat's remove, as its holder answers it; each call is kept.
-	rm, err := b.js.Conn().Subscribe("mesh.seat."+gopackageregistry.Seat+".call.remove.>", func(m *nats.Msg) {
-		var args map[string]any
-		_ = json.Unmarshal(m.Data, &args)
-		r.mu.Lock()
-		r.removes = append(r.removes, args)
-		r.mu.Unlock()
-		_ = m.Respond([]byte(`{"result":{},"node":"ctl"}`))
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _ = rm.Unsubscribe() })
-	own := "mesh.mod." + delivery.BuilderModule + ".event.>"
-	if _, err := b.js.CreateStream(b.ctx, jetstream.StreamConfig{Name: "BUILDER_EVENTS", Subjects: []string{own}}); err != nil {
-		t.Fatal(err)
-	}
-	nc := b.js.Conn()
-	// As a build module hears it: on the contract's subject, read by the contract's decoder (BG2's late publish).
-	sub, err := nc.Subscribe(delivery.VersionNumberedSubject, func(m *nats.Msg) {
-		if nb, err := delivery.DecodeVersionNumbered(m.Data); err == nil {
-			r.mu.Lock()
-			r.numbered = append(r.numbered, nb)
-			r.mu.Unlock()
-		}
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _ = sub.Unsubscribe() })
-	var listed []map[string]string
-	for _, v := range seatVersions {
-		listed = append(listed, map[string]string{"version": v})
-	}
-	for subject, answer := range map[string]any{
-		"mesh.seat." + ociartifactregistry.Seat + ".call.versions.>":          map[string]any{"versions": listed},
-		"mesh.mod.mesh-delivery-forge-bridge.call.bridge_tags.>":              map[string]any{"tags": []string{}},
-		"mesh.mod." + delivery.IndexerModule + ".call.indexer_requirements.>": map[string]any{"requirements": []string{}},
-	} {
-		reply, _ := json.Marshal(map[string]any{"result": answer, "node": "ctl"})
-		s, err := nc.Subscribe(subject, func(m *nats.Msg) { _ = m.Respond(reply) })
-		if err != nil {
-			t.Fatal(err)
-		}
-		t.Cleanup(func() { _ = s.Unsubscribe() })
-	}
-	return r
-}
-
-// of is every entry versions holds of name.
-func (r *registry) of(t *testing.T, name string) []versions.Entry {
-	t.Helper()
-	l, err := r.versions.ListKeysFiltered(r.b.ctx, versions.NameFilter(name))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer func() { _ = l.Stop() }()
-	var out []versions.Entry
-	for k := range l.Keys() {
-		e, err := r.versions.Get(r.b.ctx, k)
-		if err != nil {
-			t.Fatal(err)
-		}
-		var v versions.Entry
-		if err := json.Unmarshal(e.Value(), &v); err != nil {
-			t.Fatal(err)
-		}
-		out = append(out, v)
-	}
-	return out
-}
-
-// awaitOf reads name's entries until pred holds of them, within 20 s.
-func (r *registry) awaitOf(t *testing.T, name string, pred func([]versions.Entry) bool) []versions.Entry {
-	t.Helper()
-	var es []versions.Entry
-	for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) {
-		if es = r.of(t, name); pred(es) {
-			return es
-		}
-	}
-	t.Fatalf("versions of %s = %+v within 20 s", name, es)
-	return es
-}
-
-// published says the artifact seat's published for name@version, as its holder does.
-func (r *registry) published(t *testing.T, name, version, digest string) {
-	t.Helper()
-	r.outcome(t, ociartifactregistry.SubjectPublished, versions.Outcome{Name: name, Version: version, Digest: digest, Kind: "bundle", Holder: "distribution"})
-}
-
-// outcome says a seat's outcome on subject, as its holder does.
-func (r *registry) outcome(t *testing.T, subject string, o versions.Outcome) {
-	t.Helper()
-	data, _ := json.Marshal(o)
-	msg := nats.NewMsg(subject)
-	msg.Header.Set("x-event-id", subject+"-"+o.Name+"-"+o.Version)
-	msg.Data = data
-	if _, err := r.b.js.PublishMsg(r.b.ctx, msg); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// answered writes a reasks value and reads it until the builder answered it, within 20 s.
-func (r *registry) answered(t *testing.T, key string, value []byte) build.ReAsk {
-	t.Helper()
-	if _, err := r.reasks.Put(r.b.ctx, key, value); err != nil {
-		t.Fatal(err)
-	}
-	var a build.ReAsk
-	for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) {
-		if e, err := r.reasks.Get(r.b.ctx, key); err == nil && json.Unmarshal(e.Value(), &a) == nil && !a.Answered.IsZero() {
-			return a
-		}
-	}
-	t.Fatalf("reasks.%s = %+v, not answered within 20 s", key, a)
-	return a
-}
-
-// awaitFinding reads the builder's finding key until it is there (raised) or gone, within 20 s.
-func (r *registry) awaitFinding(t *testing.T, key string, raised bool) {
-	t.Helper()
-	for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) {
-		if _, err := r.findings.Get(r.b.ctx, key); (err == nil) == raised {
-			return
-		}
-	}
-	t.Fatalf("the finding %s raised = %v within 20 s, want %v", key, !raised, raised)
-}
-
-// numberedOf are the version.numbered the builder said for name, in order.
-func (r *registry) numberedOf(name string) []string {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	var out []string
-	for _, nb := range r.numbered {
-		if nb.Name == name {
-			out = append(out, nb.Version)
-		}
-	}
-	return out
-}

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go

@@ -5,7 +5,6 @@
 package main
 
 import (
-	"cmp"
 	"context"
 	"fmt"
 	"io"
@@ -19,18 +18,15 @@ import (
 	"syscall"
 	"time"
 
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
-	"git.novox.be/novox/mesh-delivery/sdk/forms"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 
 	"github.com/nats-io/nats.go"
 	"github.com/nats-io/nats.go/jetstream"
 
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 	"git.novox.be/novox/mesh-sdk/go/process"
-	"git.novox.be/novox/mesh-sdk/go/views"
 
 	"mesh-delivery-builder/internal/build"
-	"mesh-delivery-builder/internal/versions"
 )
 
 const (
@@ -65,53 +61,22 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
 	if err != nil {
 		return err
 	}
-	// The indexer's modules, manifests, candidates and packages and the assigner's placement are their owners' states, read by the
-	// first view of their read tools and then their views families, never their buckets (ADR 0615 §1, DLV-M1). An owner that
-	// is down never holds the start: each is read on a goroutine once its first view is answered, and until then the
-	// unanswered first view is the builder's finding.
-	calls, err := process.Connect(cred, nats.Name(cred.Node+"."+cred.Module+".calls"), nats.RetryOnFailedConnect(true))
+	modules, err := process.EssentialBucket(ctx, js, "builder", delivery.ModulesBucket, "know any fingerprint to build")
 	if err != nil {
 		return err
 	}
-	defer calls.Close()
-	reader := &views.ProcessReader{Module: delivery.BuilderModule, Call: calls.Call, Logf: logger.Printf}
-	findingsKV := process.AwaitBucket(ctx, js, conn, findingsBucket, "the builder's findings, a first view unanswered past its bound among them, are said in its log only", logger.Printf)
-	reader.Findings = findingsKV.KV
-	modules, err := reader.Follow(delivery.IndexerModule, modulesState, delivery.IndexerModule+".indexer_read_modules", indexerViews)
-	if err != nil {
-		return err
-	}
-	manifests, err := reader.Follow(delivery.IndexerModule, manifestsState, delivery.IndexerModule+".indexer_read_manifests", indexerViews)
-	if err != nil {
-		return err
-	}
-	// The candidates' fingerprints are built too (issue 1684).
-	candidates, err := reader.Follow(delivery.IndexerModule, candidatesState, delivery.IndexerModule+".indexer_read_candidates", indexerViews)
-	if err != nil {
-		return err
-	}
-	// The indexer's packages, whose names a package is numbered under (design 32).
-	packages, err := reader.Follow(delivery.IndexerModule, delivery.PackagesState, delivery.IndexerModule+".indexer_read_packages", indexerViews)
-	if err != nil {
-		return err
-	}
-	placement, err := reader.Follow(delivery.AssignerModule, delivery.PlacementState, delivery.AssignerModule+".assigner_read_placement", assignerViews)
+	manifests, err := process.EssentialBucket(ctx, js, "builder", delivery.ManifestsBucket, "read what a module builds")
 	if err != nil {
 		return err
 	}
+	// The candidates' fingerprints are built too (issue 1684): a builder that cannot read them builds the trunk's.
+	candidates := process.OptionalBucket(ctx, js, delivery.CandidatesBucket, "no candidate's fingerprint is built until the builder starts again; the trunk's are", logger.Printf)
 	bound := defaultStepBound
 	if v := strings.TrimSpace(getenv("MESH_BUILDER_STEP_BOUND")); v != "" {
 		if bound, err = time.ParseDuration(v); err != nil {
 			return fmt.Errorf("MESH_BUILDER_STEP_BOUND: %w", err)
 		}
 	}
-	// An unanswered tag ask is narrated every TagAskBound (design 51: five minutes); a test gives a shorter one.
-	tagAskBound := versions.TagAskBound
-	if v := strings.TrimSpace(getenv("MESH_BUILDER_TAG_ASK_BOUND")); v != "" {
-		if tagAskBound, err = time.ParseDuration(v); err != nil {
-			return fmt.Errorf("MESH_BUILDER_TAG_ASK_BOUND: %w", err)
-		}
-	}
 	tools := &buildrun.ToolchainSet{}
 	// Each build module's part of a build is an ask on its build seat's stream, pulled by a build node with a free slot
 	// (novox/hq ADR 0525): the builder chooses no node, so it reads neither presence nor have and holds no capacity.
@@ -138,31 +103,12 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
 	heard := buildrun.HearEnds(ctx, asks, asks, buildModules, logger.Printf)
 	conn.SetReconnectHandler(func(*nats.Conn) { hearing.Again(); heard.Nudge("") })
 	// The builder asks the controller, as its own account, whether the artifact store still holds a done key's blobs
-	// (the seat verb held, novox/hq issue 1937) before it leaves the key done, on its calls connection.
-	// The builder numbers each trunk build at its claim (novox/hq design 51 *The versions*): its state versions, bound once
-	// the bus holds it; the floor's three sources asked as its own account; each new number said as version.numbered.
-	versionsKV := process.AwaitBucket(ctx, js, conn, versions.Bucket, "no trunk build is numbered: each is built unnumbered and published by its digest", logger.Printf)
-	found := &findings{kv: findingsKV, logf: logger.Printf, now: time.Now}
-	floorWaits := &versions.FloorWaits{Logf: logger.Printf, Said: found.floorSaid(context.WithoutCancel(ctx))}
-	// The names waiting on their floor are kept in the state floor-waits (DLV-B4): a restarted builder takes them in, so
-	// their silent sources' events still wake them; until the state is bound they are kept here only.
-	process.AwaitBucket(ctx, js, conn, versions.FloorWaitsBucket, "the names waiting on their floor are kept in memory only, and builder_floor_waits shows none", logger.Printf).
-		Ready(func(kv jetstream.KeyValue) {
-			floorWaits.Keep(kvKeeper{ctx: ctx, kv: kv}, heldFloorWaits(ctx, kv, logger.Printf))
-		})
-	// A package is numbered under its name in its ecosystem, read from the indexer's packages state (design 32).
-	numberer := &versions.Numberer{Versions: versions.Versions{Store: awaitedVersions{versionsKV}}, Floor: floorVia(calls.Call), Waits: floorWaits,
-		Names: versions.NamesIn(indexerPackages{packages}),
-		Said: func(nb delivery.VersionNumbered) {
-			if err := emitNumbered(context.WithoutCancel(ctx), js, cred, nb); err != nil {
-				logger.Printf("%v", err)
-			}
-		}}
-	// A publish that ends badly is a finding (design 51 *Health and conditions*): a holder's refused, a version no holder
-	// answered within its bound (a key of the state bounds with its own time to live), a seat's outcome that does not read.
-	pubBoundsKV := process.AwaitBucket(ctx, js, conn, versions.BoundsBucket, "a publish no holder answers, and a node holding the old form seven days, are not raised", logger.Printf)
-	pubs := &publishes{bounds: pubBoundsKV.KV, versions: numberer.Versions, findings: found, bound: versions.PublishBound, logf: logger.Printf}
-	numberer.Publishing = pubs.arm
+	// (the seat verb held, novox/hq issue 1937) before it leaves the key done.
+	calls, err := process.Connect(cred, nats.Name(cred.Node+"."+cred.Module+".calls"), nats.RetryOnFailedConnect(true))
+	if err != nil {
+		return err
+	}
+	defer calls.Close()
 	b := &build.Builder{
 		Claimer: build.Claimer{Store: kvStore{builds}, By: cred.Node + "." + cred.Module},
 		Asks:    buildrun.Asker{Publisher: asks, Waiter: buildrun.LostAskWaiter{Inner: heard, Dead: dead, Hearing: hearing}, Bound: bound},
@@ -176,52 +122,20 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
 		Stored:     storedVia(calls.Call),
 		Node:       cred.Node,
 	}
-	tagAsksKV := process.AwaitBucket(ctx, js, conn, versions.TagAsksBucket, "builder_tag and builder_untag are not answered", logger.Printf)
-	// A check's build of a head a kept tag ask names numbers its packages tagged (design 51 *Tagged versions*), and the ask
-	// is marked numbered with its versions.
-	b.Tags = tagsVia(tagAsksKV.KV, logger.Printf)
-	b.Numbers = build.VersionNumbers{N: numberer, TagNumbered: tagNumbered(tagAsksKV.KV, logger.Printf, time.Now)}
-	// An ask not answered within five minutes is narrated with what it waits on: its bound's end on the bus says when.
-	boundsKV := process.AwaitBucket(ctx, js, conn, versions.TagAskBoundsBucket, "an unanswered tag ask is not narrated", logger.Printf)
-	bounds := &tagBounds{asks: tagAsksKV.KV, bounds: boundsKV.KV, bound: tagAskBound, waits: floorWaits.Waiting, logf: logger.Printf, now: time.Now,
-		log: func(e delivery.BuildLogEntry) { b.Log(e) }}
-	// A state bound later numbers the builds looked at without it.
-	versionsKV.Ready(func(jetstream.KeyValue) { b.Reconsider(ctx) })
-	// The versions' hand acts (builder_publish_again, builder_floor_again) come through reasks, as builder_build_again.
-	acts := versions.Acts{Numberer: numberer, Done: doneVia(b), Reconsider: b.Reconsider, Remove: removeVia(calls.Call),
-		BuildAgain: func(ctx context.Context, module, fp, why, by string) (string, bool) {
-			r := b.BuildAgain(ctx, module, fp, why, by, buildAgainBound)
-			if r.Refused != "" {
-				return r.Refused, true
-			}
-			if r.Failed != "" {
-				return "built again, and it failed before its asks were put: " + r.Failed, false
-			}
-			return fmt.Sprintf("built again as revision %d", r.Revision), false
-		}}
 	// A candidate's preview is merged onto the trunk head the indexer previewed it onto: source.main at the candidate's base
 	// revision (the gate's source state). The source's revisions are watched with their history (a direct get of one revision
 	// is not what a read grants): a revision heard after the candidate that names it builds that candidate then. Where it
 	// cannot be read the trunk's keys are built and the candidates wait (issue 1945).
-	errs := make(chan error, 10)
-	trunks := &trunkSource{ctx: ctx, js: js, heads: &sourceHeads{}, moved: func(ctx context.Context) {
-		// A source revision heard is the forge's merge: it wakes a floor whose bridge_tags was silent (design 51 *The floor*).
-		(&floorWake{b: b, waits: floorWaits, logf: logger.Printf}).wake(ctx, versions.WakeForge, "", "")
-		b.TrunkMoved(ctx)
-	}, errs: errs, logf: logger.Printf}
+	errs := make(chan error, 6)
+	trunks := &trunkSource{ctx: ctx, js: js, heads: &sourceHeads{}, moved: b.TrunkMoved, errs: errs, logf: logger.Printf}
 	trunks.start()
 	b.Trunk = trunks.head
 	// The builder's log (ADR 0571 §1): each build's start and end in its module log `build-log`, read by the view, the
-	// indexer and the assigner through their reads, and by the operator's command nox builds through the tool builder_builds_since.
+	// indexer and the assigner through their reads, and by mesh-catalog through the tool builder_builds_since.
 	b.Log = func(e delivery.BuildLogEntry) {
-		if e.Node == "" { // a narration of no one build (a tag ask, the old form's window) is this instance's
-			e.Node = cred.Node
-		}
 		if err := appendLog(context.WithoutCancel(ctx), js, cred, e); err != nil {
 			logger.Printf("%v", err)
 		}
-		// A failed trunk build is the builder's finding build-failed, cleared by a later done one (DLV-B7).
-		found.buildEnded(context.WithoutCancel(ctx), e)
 	}
 	b.Said = func(e build.AskedAgain) {
 		if err := emitAskedAgain(context.WithoutCancel(ctx), js, cred, e); err != nil {
@@ -251,219 +165,42 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
 	// placement is settled first, so the toolchains settle through the gate already knowing it.
 	gate := buildrun.NewToolchainGate([]string{buildrun.GoBuildModule, buildrun.NodeBuildModule}, tools.Put, logger.Printf)
 	watch.put = gate.Toolchain
-	// What each counted node's engine reads (ADR 0618 §2, ADR 0624 §1): asked through the node-engine seat's verb as the
-	// builder's own account, for every node the placement names, and kept in the state engine-reads once it is bound.
-	reads := newEngineReads(calls.CallOn, gate, logger.Printf)
-	// The old reference form's window over them (DLV-B9), kept in the state old-form once it is bound; builder_old_form
-	// reads it and drops a retired node by hand.
-	reads.ctx = context.WithoutCancel(ctx)
-	reads.window = &oldForm{forms: forms.Current, findings: found, logf: logger.Printf, now: time.Now, log: func(e delivery.BuildLogEntry) { b.Log(e) },
-		bounds: pubBoundsKV.KV,
-		said: func(body versions.OldFormClosedBody) {
-			if err := emitEvent(context.WithoutCancel(ctx), js, cred, versions.OldFormClosedEvent, "old-form-closed-"+body.At.Format(time.RFC3339Nano), body); err != nil {
-				logger.Printf("saying %s: %v", versions.OldFormClosedEvent, err)
-			}
-		}}
-	acts.DropOldForm = func(ctx context.Context, node, by, why string, at time.Time) (string, error) {
-		answer, err := reads.window.drop(ctx, node, by, why, at)
-		if err == nil {
-			reads.stepWindow()
-		}
-		return answer, err
+	placementErrs, err := buildrun.FollowPlacement(ctx, js, gate, b.NodesChanged, logger.Printf)
+	if err != nil {
+		return err
 	}
-	process.AwaitBucket(ctx, js, conn, versions.OldFormBucket, "the old form's window is kept in memory only, and builder_old_form shows none", logger.Printf).
-		Ready(func(kv jetstream.KeyValue) {
-			reads.window.bind(context.WithoutCancel(ctx), kv)
-			reads.stepWindow()
-		})
-	gate.OnPlaced = reads.placed
-	b.Forms = reads.built
-	// Until the placement's first view is answered the gate passes every report on, as before the placement is settled.
-	placementErrs := make(chan error, 1)
-	go func() {
-		select {
-		case <-ctx.Done():
-			return
-		case <-placement.Follower().Ready():
-		}
-		pe, err := buildrun.FollowPlacement(ctx, reader, gate, b.NodesChanged, logger.Printf)
-		if err != nil {
-			placementErrs <- err
-			return
-		}
-		placementErrs <- <-pe
-	}()
 	if err := watch.start(); err != nil {
 		return err
 	}
 	// A build module says each time it wrote its toolchains key: its stream, and the builder's durable consumer on it, are
 	// made by the controller. Where the stream is not there yet the builder says so and is started again with the build
 	// module.
-	// Each consumer that is not there yet is the finding family-not-heard naming its stream until it binds at a later
-	// start (heard.Writer; ADR 0615 §5); one there that cannot be heard stops the builder, as before.
-	notHeard := found.notHeard(ctx)
-	var stopped error
-	hear := func(stream, consequence string, each func(jetstream.Msg)) {
-		_ = notHeard.Bind(stream, consequence, func() error {
-			cons, err := cred.EventConsumer(ctx, js, stream)
-			if err != nil {
-				return fmt.Errorf("the consumer %s_%s on %s does not exist yet: %w", cred.Node, cred.Module, stream, err)
-			}
-			cc, err := process.HearEvents(cons, each, logger.Printf)
-			if err != nil {
-				stopped = cmp.Or(stopped, err)
-				return err
-			}
-			go func() { <-ctx.Done(); cc.Stop() }()
-			return nil
-		})
-	}
 	for _, module := range []string{buildrun.GoBuildModule, buildrun.NodeBuildModule} {
-		hear(toolchainStreams[module], module+"'s toolchain reports are not heard until the builder starts again", func(m jetstream.Msg) { watch.Reported(m) })
+		stream := toolchainStreams[module]
+		cons, err := cred.EventConsumer(ctx, js, stream)
+		if err != nil {
+			logger.Printf("the consumer %s_%s on %s does not exist yet, so %s's reports are not heard until the builder starts again: %v", cred.Node, cred.Module, stream, module, err)
+			continue
+		}
+		cc, err := process.HearEvents(cons, func(m jetstream.Msg) { watch.Reported(m) }, logger.Printf)
+		if err != nil {
+			return err
+		}
+		defer cc.Stop()
 	}
 	// The seat mesh-artifact-sweep says artifacts-gone when it found a key's blob gone (issue 1937, ADR 0571 §2): the
 	// builder's durable consumer on EVENTS, made by the grants part from the manifest's consumes. Where it is not there yet the builder says
 	// so; it still asks held at its start and at every module value.
-	// The same consumer carries what wakes a floor (design 51 *The floor*): the indexer's manifest-accepted and the
-	// condition keeper's condition-cleared.
-	floor := floorWake{b: b, waits: floorWaits, logf: logger.Printf}
-	// And the four registry seats' published, refused and removed (DLV-B4), which move a numbered version.
-	seats := seatHearer{n: numberer, b: b, logf: logger.Printf, pub: pubs}
-	hear(eventsStream, delivery.ArtifactsGoneEvent+", what wakes a floor, the registry seats' words and manifest-reads-changed are not heard until the builder starts again", func(m jetstream.Msg) {
-		if reads.heard(m, logger.Printf) || floor.heard(ctx, m) || seats.heard(ctx, m) { // reads: the node-engine seat's manifest-reads-changed (ADR 0618 §4)
-			return
-		}
-		heardGone(ctx, b, m, logger.Printf)
-	})
-	if stopped != nil {
-		return stopped
-	}
-	reader.Start(ctx, js, cred, process.AwaitBucket(ctx, js, conn, firstViewsBucket, "builder_first_views reads nothing and builder_first_view_again is not heard", logger.Printf))
-	// The modules, once their first views and the manifests' are answered: what a module builds is read from the manifests.
-	go func() { errs <- buildFromModules(ctx, b, modules, manifests, candidates) }()
-	// A package's name heard in the indexer's packages looks at its module again, so a done build is numbered then.
-	go func() { errs <- followPackages(ctx, packages, b, logger.Printf) }()
-	// A person asks a key's build again with builder_ask_again, which writes the reasks state (issue 1945): watched, as
-	// every other input. The builder asks again by itself without it.
-	// A state not on the bus yet at this start is watched once it appears (issue 1790).
-	process.AwaitBucket(ctx, js, conn, build.ReAsksBucket, "builder_ask_again is not heard; an ask that can no longer be answered is still asked again by itself", logger.Printf).Ready(func(kv jetstream.KeyValue) {
-		eachReAsk := func(e jetstream.KeyValueEntry) { reAsked(ctx, b, acts, kv, e, logger.Printf) }
-		if rw, err := settle(ctx, kv, eachReAsk); err != nil {
-			process.NotWatched(logger.Printf, build.ReAsksBucket, err, "builder_ask_again is not heard until the builder starts again")
-		} else {
-			go func() { errs <- follow(ctx, rw, eachReAsk) }()
-		}
-	})
-	// A tag ask or a branch's removal by hand (builder_tag, builder_untag) is written to tag-asks and answered there
-	// (design 51 *Tagged versions*); the checker's tag-wanted and the branch's end join it on their consumers (DLV-B6).
-	tagAsksKV.Ready(func(kv jetstream.KeyValue) {
-		each := func(e jetstream.KeyValueEntry) {
-			tagAsked(ctx, acts, kv, e, logger.Printf)
-			if !opOf(e) {
-				bounds.disarm(ctx, e.Key())
-			} else if t, err := versions.DecodeTagAsk(e.Value()); err == nil {
-				bounds.asked(ctx, e.Key(), t)
-			}
-		}
-		if tw, err := settle(ctx, kv, each); err != nil {
-			process.NotWatched(logger.Printf, versions.TagAsksBucket, err, "builder_tag and builder_untag are not answered until the builder starts again")
-		} else {
-			go func() { errs <- follow(ctx, tw, each) }()
-		}
-	})
-	pubBoundsKV.Ready(func(kv jetstream.KeyValue) {
-		each := func(e jetstream.KeyValueEntry) {
-			if versions.IsOldFormBound(e.Key()) {
-				if e.Operation() == jetstream.KeyValuePurge {
-					reads.stepWindow() // a node's seven days ended: the step raises old-form-held now
-				}
-				return
-			}
-			pubs.ended(ctx, e)
-		}
-		watchBounds(ctx, kv, each, found.notHeard(ctx), errs, logger.Printf)
-	})
-	boundsKV.Ready(func(kv jetstream.KeyValue) {
-		each := func(e jetstream.KeyValueEntry) { bounds.ended(ctx, e) }
-		if bw, err := settle(ctx, kv, each); err != nil {
-			process.NotWatched(logger.Printf, versions.TagAskBoundsBucket, err, "an unanswered tag ask is not narrated until the builder starts again")
-		} else {
-			go func() { errs <- follow(ctx, bw, each) }()
-		}
-	})
-	// A person reads a build seat's stream with builder_seat_queue, which writes the queues state (issue 1945 note 62): the
-	// builder alone may read the stream, so it answers there.
-	process.AwaitBucket(ctx, js, conn, build.QueuesBucket, "builder_seat_queue is not answered", logger.Printf).Ready(func(kv jetstream.KeyValue) {
-		eachRead := func(e jetstream.KeyValueEntry) { queueRead(ctx, heldOnTheBus{js}, kv, e, logger.Printf) }
-		if qw, err := settle(ctx, kv, eachRead); err != nil {
-			process.NotWatched(logger.Printf, build.QueuesBucket, err, "builder_seat_queue is not answered until the builder starts again")
-		} else {
-			go func() { errs <- follow(ctx, qw, eachRead) }()
-		}
-	})
-	// A branch's end removes its tagged versions (design 51 *Tagged versions*, DLV-B6): the forge bridge's merged, a pull's
-	// closed or branch-deleted on the builder's durable consumer of its stream; each forge message also wakes a floor whose
-	// bridge_tags was silent. The checker's tag-wanted is kept in tag-asks. A consumer not there yet is said.
-	ends := &branchEnds{acts: acts, findings: found, tagAsks: tagAsksKV.KV, logf: logger.Printf, now: time.Now,
-		wake: func(ctx context.Context) {
-			(&floorWake{b: b, waits: floorWaits, logf: logger.Printf}).wake(ctx, versions.WakeForge, "", "")
-		}}
-	for _, c := range []struct {
-		stream, what string
-		hear         func(jetstream.Msg)
-	}{
-		{forgeStream, "a branch's end", func(m jetstream.Msg) { ends.heard(ctx, m) }},
-		{checkerAsksStream, "the checker's tag-wanted", func(m jetstream.Msg) {
-			tagWanted(ctx, tagAsksKV.KV(), m, delivery.CheckerModule, time.Now(), logger.Printf)
-		}},
-	} {
-		hear(c.stream, c.what+" is not heard until the builder starts again", c.hear)
-	}
-	if stopped != nil {
-		return stopped
-	}
-	// The state engine-reads, new with ADR 0618 (issue 1790's kind): until it is on the bus each statement is kept in memory
-	// only, and builder_engine_reads answers nothing.
-	process.AwaitBucket(ctx, js, conn, engineReadsBucket, "what each node's engine reads is kept in memory only", logger.Printf).Ready(func(kv jetstream.KeyValue) {
-		reads.bind(ctx, kv, errs, logger.Printf)
-	})
-	logger.Printf("started on %s", cred.Node)
-	select {
-	case <-ctx.Done():
-		b.Wait()
-		return nil
-	case err := <-errs:
-		return err
-	case err := <-placementErrs:
-		return err
-	case err := <-watch.errs:
-		return err
-	}
-}
-
-// The builder's own state of its first views (views.StatusState); its findings (findingsBucket) are where the condition
-// keeper raises a first view unanswered past its bound (ADR 0615 §6).
-var firstViewsBucket = delivery.BuilderModule + "_" + views.StatusState
-
-// The indexer's states the builder follows (delivery.ModulesBucket, ManifestsBucket, CandidatesBucket), and the owners'
-// views families as their manifests' `streams` name them.
-const (
-	indexerViews    = "indexer-views"
-	assignerViews   = "assigner-views"
-	modulesState    = "modules"
-	manifestsState  = "manifests"
-	candidatesState = "candidates"
-)
-
-// buildFromModules builds from the indexer's modules and candidates once the first views of the modules, the manifests and
-// the candidates are answered (never at the start: an indexer that is down holds no other part of it), and follows them.
-func buildFromModules(ctx context.Context, b *build.Builder, modules, manifests, candidates *views.Picture) error {
-	for _, p := range []*views.Picture{modules, manifests, candidates} {
-		select {
-		case <-ctx.Done():
-			return nil
-		case <-p.Follower().Ready():
+	switch cons, err := cred.EventConsumer(ctx, js, eventsStream); {
+	case err != nil:
+		logger.Printf("the consumer %s_%s on %s does not exist yet, so %s is not heard until the builder starts again: %v",
+			cred.Node, cred.Module, eventsStream, delivery.ArtifactsGoneEvent, err)
+	default:
+		cc, err := process.HearEvents(cons, func(m jetstream.Msg) { heardGone(ctx, b, m, logger.Printf) }, logger.Printf)
+		if err != nil {
+			return err
 		}
+		defer cc.Stop()
 	}
 	each := func(e jetstream.KeyValueEntry) {
 		if opOf(e) {
@@ -488,12 +225,48 @@ func buildFromModules(ctx context.Context, b *build.Builder, modules, manifests,
 			b.ForgetCandidate(e.Key())
 		}
 	}
-	cw, err := settle(ctx, candidates, eachCandidate)
-	if err != nil {
+	if candidates != nil {
+		cw, err := settle(ctx, candidates, eachCandidate)
+		if err != nil {
+			process.NotWatched(logger.Printf, delivery.CandidatesBucket, err, "no candidate's fingerprint is built until the builder starts again")
+		} else {
+			go func() { errs <- follow(ctx, cw, eachCandidate) }()
+		}
+	}
+	// A person asks a key's build again with builder_ask_again, which writes the reasks state (issue 1945): watched, as
+	// every other input. The builder asks again by itself without it.
+	// A state not on the bus yet at this start is watched once it appears (issue 1790).
+	process.AwaitBucket(ctx, js, conn, build.ReAsksBucket, "builder_ask_again is not heard; an ask that can no longer be answered is still asked again by itself", logger.Printf).Ready(func(kv jetstream.KeyValue) {
+		eachReAsk := func(e jetstream.KeyValueEntry) { reAsked(ctx, b, kv, e, logger.Printf) }
+		if rw, err := settle(ctx, kv, eachReAsk); err != nil {
+			process.NotWatched(logger.Printf, build.ReAsksBucket, err, "builder_ask_again is not heard until the builder starts again")
+		} else {
+			go func() { errs <- follow(ctx, rw, eachReAsk) }()
+		}
+	})
+	// A person reads a build seat's stream with builder_seat_queue, which writes the queues state (issue 1945 note 62): the
+	// builder alone may read the stream, so it answers there.
+	process.AwaitBucket(ctx, js, conn, build.QueuesBucket, "builder_seat_queue is not answered", logger.Printf).Ready(func(kv jetstream.KeyValue) {
+		eachRead := func(e jetstream.KeyValueEntry) { queueRead(ctx, heldOnTheBus{js}, kv, e, logger.Printf) }
+		if qw, err := settle(ctx, kv, eachRead); err != nil {
+			process.NotWatched(logger.Printf, build.QueuesBucket, err, "builder_seat_queue is not answered until the builder starts again")
+		} else {
+			go func() { errs <- follow(ctx, qw, eachRead) }()
+		}
+	})
+	logger.Printf("started on %s", cred.Node)
+	go func() { errs <- follow(ctx, w, each) }()
+	select {
+	case <-ctx.Done():
+		b.Wait()
+		return nil
+	case err := <-errs:
+		return err
+	case err := <-placementErrs:
+		return err
+	case err := <-watch.errs:
 		return err
 	}
-	go func() { _ = follow(ctx, cw, eachCandidate) }()
-	return follow(ctx, w, each)
 }
 
 // sourceHeads are the trunk heads of each revision of the gate's source.main the watch delivered, the newest

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/oldform.go

@@ -1,187 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"slices"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-	"git.novox.be/novox/mesh-sdk/go/health"
-
-	"git.novox.be/novox/mesh-delivery/sdk/forms"
-
-	"mesh-delivery-builder/internal/versions"
-)
-
-// oldForm keeps the old reference form's window (design 51 *Every build keeps the old reference form*, DLV-B9) in the
-// state old-form: stepped on every change of what the counted nodes state, of the placement, on a hand drop and at each
-// build key written, never on a timer. A node holding it seven days is the finding old-form-held; its close is said once
-// as version.old-form-closed and in the builder's log.
-type oldForm struct {
-	forms    forms.ArtifactForms
-	findings *findings
-	// said emits version.old-form-closed.
-	said func(versions.OldFormClosedBody)
-	// log writes the close into the builder's build log (build.said); nil writes none.
-	log  func(delivery.BuildLogEntry)
-	logf func(string, ...any)
-	now  func() time.Time
-
-	// bounds is the builder's state bounds: each node holding the window has a key there whose time to live ends at its
-	// seven days, so old-form-held is raised then, not at the next change (review round 1); nil keeps none.
-	bounds func() jetstream.KeyValue
-
-	mu sync.Mutex
-	w  versions.OldFormWindow
-	kv jetstream.KeyValue
-	// overdue are the nodes the finding is raised for now.
-	overdue []string
-}
-
-// bind takes the kept window in, so a restarted builder keeps each node's since and the nodes dropped by hand, and keeps
-// every later step in kv.
-func (o *oldForm) bind(ctx context.Context, kv jetstream.KeyValue) {
-	e, err := kv.Get(ctx, versions.OldFormKey)
-	o.mu.Lock()
-	defer o.mu.Unlock()
-	switch {
-	case errors.Is(err, jetstream.ErrKeyNotFound):
-	case err != nil:
-		o.logf("%s.%s cannot be read, so the window starts again: %v", versions.OldFormState, versions.OldFormKey, err)
-	default:
-		w, err := versions.DecodeOldFormWindow(e.Value())
-		if err != nil {
-			o.logf("%v; the window starts again", err)
-			break
-		}
-		// Taken in under what was stepped before the state was bound: the kept since and drops are the older truth.
-		for n, s := range o.w.Since {
-			if _, ok := w.Since[n]; !ok && w.Open && slices.Contains(w.Holding, n) {
-				w.Since[n] = s
-			}
-		}
-		for _, d := range o.w.Dropped {
-			w, _ = w.Drop(d.Node, d.By, d.Why, d.At)
-		}
-		o.w = w
-	}
-	o.kv = kv
-	o.keep(ctx)
-}
-
-// dropped is the nodes dropped by hand.
-func (o *oldForm) dropped() map[string]bool {
-	o.mu.Lock()
-	defer o.mu.Unlock()
-	return o.w.DroppedSet()
-}
-
-// step moves the window to what counted states.
-// named is every node the read named (the placement's nodes before any is dropped), counted the statements of those
-// still counted: a read naming no node judges nothing (delivery.StepWindow), so it never closes the window.
-func (o *oldForm) step(ctx context.Context, named []string, counted map[string][]string) {
-	o.mu.Lock()
-	defer o.mu.Unlock()
-	before := o.w
-	next, closed, overdue := o.w.Step(named, versions.Holding(o.forms, counted, o.w.DroppedSet()), o.now())
-	o.w = next
-	if !slices.Equal(before.Holding, next.Holding) || before.Open != next.Open || closed {
-		o.keep(ctx)
-	}
-	for _, n := range o.overdue {
-		if !slices.Contains(overdue, n) {
-			o.findings.clear(ctx, versions.OldFormHeld, health.ScopeMachine, n)
-		}
-	}
-	for _, n := range overdue {
-		o.findings.raise(ctx, finding{kind: versions.OldFormHeld, scope: health.ScopeMachine, id: n,
-			summary: fmt.Sprintf("the node-engine of %s has read only an older reference form since %s, so every build key still carries it",
-				n, next.Since[n].Format(time.RFC3339)),
-			headline:    "A node holds the old reference form",
-			explanation: "The builder writes an older reference form into every build key while a counted node's engine reads none of the newest (ADR 0624 §1); this node has held it seven days.",
-			resolved:    "The node's engine states the newest form, the node leaves the placement, or it is dropped as retired.",
-			needs:       "builder_old_form shows the window; a retired node is dropped there by hand; builder_engine_reads asks the node again."})
-	}
-	o.overdue = overdue
-	o.keepBounds(ctx, before, next, overdue)
-	if closed {
-		body := next.Closing()
-		line := fmt.Sprintf("the old reference form's window closed at %s: no counted node-engine reads only an older form (last held by %s; dropped by hand: %d); new build keys leave it out",
-			body.At.Format(time.RFC3339), strings.Join(body.LastHolding, ", "), len(body.Dropped))
-		o.logf("%s", line)
-		// In the build log too (design 51 *The node-engine's own build*), under the builder's own key, the window's key
-		// standing for the fingerprint: the close is no one build's.
-		if o.log != nil {
-			o.log(delivery.BuildLogEntry{Event: delivery.BuildSaidEvent, Module: delivery.BuilderModule, FP: versions.OldFormKey,
-				At: body.At.UTC(), Line: line, Why: versions.SaidOldFormClosed})
-		}
-		if o.said != nil {
-			o.said(body)
-		}
-	}
-}
-
-// keepBounds writes a bound for each node holding the window and not yet overdue, ending at its seven days, and deletes
-// the bound of each node that no longer holds it. A standing bound keeps its time (a Create). Called with mu held.
-func (o *oldForm) keepBounds(ctx context.Context, before, next versions.OldFormWindow, overdue []string) {
-	if o.bounds == nil {
-		return
-	}
-	kv := o.bounds()
-	if kv == nil {
-		return
-	}
-	for _, n := range before.Holding {
-		if !slices.Contains(next.Holding, n) {
-			if err := kv.Delete(ctx, versions.OldFormBoundKey(n)); err != nil && !errors.Is(err, jetstream.ErrKeyNotFound) {
-				o.logf("the old form's bound of %s is not deleted: %v", n, err)
-			}
-		}
-	}
-	for _, n := range next.Holding {
-		left := next.Since[n].Add(versions.FindingAfter).Sub(o.now())
-		if slices.Contains(overdue, n) || left <= 0 {
-			continue
-		}
-		if left < time.Second {
-			left = time.Second // the bus's least time to live
-		}
-		if _, err := kv.Create(ctx, versions.OldFormBoundKey(n), versions.EncodeBound("the seven days "+n+" holds the old form's window", o.now().Add(left)), jetstream.KeyTTL(left)); err != nil && !errors.Is(err, jetstream.ErrKeyExists) {
-			o.logf("the old form's bound of %s is not written, so its seven days are seen at the next change only: %v", n, err)
-		}
-	}
-}
-
-// drop is builder_old_form's drop: the node leaves the count, the window is stepped by the caller.
-func (o *oldForm) drop(ctx context.Context, node, by, why string, at time.Time) (string, error) {
-	o.mu.Lock()
-	defer o.mu.Unlock()
-	w, err := o.w.Drop(node, by, why, at)
-	if err != nil {
-		return "", err
-	}
-	o.w = w
-	o.keep(ctx)
-	return node + " dropped from the old form's count by hand; the window is stepped now", nil
-}
-
-// keep writes the window, once the state is bound; until then it is kept here only. Called with mu held.
-func (o *oldForm) keep(ctx context.Context) {
-	if o.kv == nil {
-		return
-	}
-	raw, err := json.Marshal(o.w)
-	if err == nil {
-		_, err = o.kv.Put(ctx, versions.OldFormKey, raw)
-	}
-	if err != nil {
-		o.logf("%s.%s cannot be written: %v", versions.OldFormState, versions.OldFormKey, err)
-	}
-}

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/publishbounds.go

@@ -1,129 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-sdk/go/health"
-	"git.novox.be/novox/mesh-sdk/go/process"
-
-	"git.novox.be/novox/mesh-delivery/sdk/heard"
-
-	"mesh-delivery-builder/internal/versions"
-)
-
-// publishes raises and clears the builder's findings of a publish that ended badly (versions/publish.go): a holder's
-// refused, a version unanswered past its bound, kept as a key of the state bounds with its own time to live, and a seat's
-// outcome that does not read.
-type publishes struct {
-	bounds   func() jetstream.KeyValue
-	versions versions.Versions
-	findings *findings
-	bound    time.Duration
-	logf     func(string, ...any)
-}
-
-// arm writes the version's bound when none stands, so a standing bound keeps its time. A bound that cannot be written
-// would never end, so the version is publish-unanswered at once (review round 2): the finding says why.
-func (p *publishes) arm(ctx context.Context, e versions.Entry) {
-	kv := p.bounds()
-	var err error
-	if kv == nil {
-		err = fmt.Errorf("%s is not on the bus yet", versions.BoundsBucket)
-	} else if _, err = kv.Create(ctx, versions.PublishBoundKey(e.Name, e.Version), versions.EncodeBound("the publish of "+e.Name+"@"+e.Version+" to "+e.Seat, time.Now().Add(p.bound)), jetstream.KeyTTL(p.bound)); errors.Is(err, jetstream.ErrKeyExists) {
-		err = nil
-	}
-	if err == nil {
-		return
-	}
-	p.logf("the publish bound of %s@%s is not written, so it is raised unanswered now: %v", e.Name, e.Version, err)
-	p.unanswered(ctx, e, fmt.Sprintf("its bound could not be written (%v), so the builder cannot wait on the holder's word", err))
-}
-
-// unanswered raises publish-unanswered about e's name, saying why.
-func (p *publishes) unanswered(ctx context.Context, v versions.Entry, why string) {
-	p.findings.raise(ctx, finding{kind: versions.PublishUnanswered, scope: health.ScopeModule, id: v.Name,
-		summary:     fmt.Sprintf("%s said neither published nor refused of %s@%s: %s", v.Seat, v.Name, v.Version, why),
-		headline:    "A registry seat did not answer a publish",
-		explanation: "The builder built and numbered " + v.Name + " " + v.Version + " and asked " + v.Seat + " to publish it; no word of its holder is known, so the build says done while the version may not be in the registry.",
-		resolved:    "That version is published, or a later version of " + v.Name + " is.",
-		needs:       "a look at the holder of " + v.Seat + " (its health and log); builder_publish_again asks the publish again."})
-}
-
-// heard is told each holder's word the numberer took in: published clears the name's findings, refused raises
-// publish-refused with the holder's reason, and either ends the version's bound.
-func (p *publishes) heard(ctx context.Context, seat, event string, o versions.Outcome) {
-	if o.Version != "" {
-		if kv := p.bounds(); kv != nil {
-			if err := kv.Delete(ctx, versions.PublishBoundKey(o.Name, o.Version)); err != nil && !errors.Is(err, jetstream.ErrKeyNotFound) {
-				p.logf("the publish bound of %s@%s is not ended: %v", o.Name, o.Version, err)
-			}
-		}
-	}
-	switch event {
-	case versions.HeardPublished:
-		p.findings.clear(ctx, versions.PublishRefused, health.ScopeModule, o.Name)
-		p.findings.clear(ctx, versions.PublishUnanswered, health.ScopeModule, o.Name)
-	case versions.HeardRefused:
-		reason := o.Reason
-		if reason == "" {
-			reason = "it gave no reason"
-		}
-		p.findings.raise(ctx, finding{kind: versions.PublishRefused, scope: health.ScopeModule, id: o.Name,
-			summary:     fmt.Sprintf("%s refused to publish %s@%s (digest %s): %s", seat, o.Name, o.Version, o.Digest, reason),
-			headline:    "A registry seat refused a publish",
-			explanation: "The builder built and numbered " + o.Name + " " + o.Version + ", and the holder of " + seat + " refused to store it, so that version is not in the registry.",
-			resolved:    "That version is published, or a later version of " + o.Name + " is.",
-			needs:       "builder_versions shows the version and why; builder_publish_again publishes it again once the cause is mended."})
-	}
-}
-
-// unread raises seat-outcome-unread about seat: what it said on subject is no outcome. read clears it.
-func (p *publishes) unread(ctx context.Context, seat, subject string, why error) {
-	p.findings.raise(ctx, finding{kind: versions.SeatOutcomeUnread, scope: health.ScopeModule, id: seat,
-		summary:     fmt.Sprintf("%s said on %s what is no outcome of a publish: %v", seat, subject, why),
-		headline:    "A registry seat said what the builder cannot read",
-		explanation: "The builder hears each registry seat's published, refused and removed to move a numbered version; this one does not read, so the version it was about does not move.",
-		resolved:    "The next outcome of " + seat + " reads.",
-		needs:       "a look at the seat's holder: the outcome's body is its contract's (mesh-contracts)."})
-}
-
-func (p *publishes) read(ctx context.Context, seat string) {
-	p.findings.clear(ctx, versions.SeatOutcomeUnread, health.ScopeModule, seat)
-}
-
-// ended is told each change of the state bounds: a bound whose time ended (the bus's marker) on a version still numbered
-// raises publish-unanswered.
-func (p *publishes) ended(ctx context.Context, e jetstream.KeyValueEntry) {
-	key, ok := versions.PublishBoundOf(e.Key())
-	if e.Operation() != jetstream.KeyValuePurge || !ok {
-		return
-	}
-	raw, _, found, err := p.versions.Store.Get(ctx, key)
-	if err != nil || !found {
-		return
-	}
-	v, err := versions.Decode(raw)
-	if err != nil || v.State != versions.Numbered {
-		return
-	}
-	p.unanswered(ctx, v, fmt.Sprintf("nothing within %s of its build", p.bound))
-}
-
-// watchBounds watches the state bounds, handing each change to each: a watch that cannot start loses every bound's end,
-// so it is the finding family-not-heard naming the state until a later start watches it (review round 2).
-func watchBounds(ctx context.Context, kv jetstream.KeyValue, each func(jetstream.KeyValueEntry), w heard.Writer, errs chan<- error, logf func(string, ...any)) {
-	const consequence = "a publish no holder answers, and a node holding the old form seven days, are not raised until the builder starts again"
-	pw, err := settle(ctx, kv, each)
-	if err != nil {
-		process.NotWatched(logf, versions.BoundsBucket, err, consequence)
-		w.NotHeard(versions.BoundsState, consequence, err)
-		return
-	}
-	w.Heard(versions.BoundsState)
-	go func() { errs <- follow(ctx, pw, each) }()
-}

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reads.go

@@ -1,151 +0,0 @@
-package main
-
-import (
-	"context"
-	"slices"
-	"sync"
-
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-	"git.novox.be/novox/mesh-sdk/go/process"
-
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
-	"git.novox.be/novox/mesh-delivery/sdk/enginereads"
-)
-
-// EngineReadsState is the builder's state of what each counted node's engine states it reads (novox/hq ADR 0618 §2, ADR
-// 0624 §1): one key `<node>`, written from the node-engine seat's verb manifest-reads at the builder's start, on the
-// seat's event manifest-reads-changed for that node, and when a person asks again (builder_engine_reads); a node that
-// is away keeps its last statement, and its key is removed when the placement no longer names the node. A counted node
-// with no key reads as stating the baseline: its first forms. No node's record is read in its place.
-const EngineReadsState = "engine-reads"
-
-// engineReadsBucket is that state's bucket.
-const engineReadsBucket = delivery.BuilderModule + "_" + EngineReadsState
-
-// engineReads keeps the statements and the counted nodes for the builder's forms (build.Builder.Forms).
-type engineReads struct {
-	keeper  *enginereads.Keeper
-	gate    *buildrun.ToolchainGate
-	mu      sync.Mutex
-	counted []string
-	// window is the old reference form's window over these statements (DLV-B9); nil keeps none.
-	window *oldForm
-	ctx    context.Context
-}
-
-// newEngineReads asks through call (process.Conn.CallOn) and keeps each answer in the state once it is bound.
-func newEngineReads(call enginereads.Caller, gate *buildrun.ToolchainGate, logf func(string, ...any)) *engineReads {
-	r := &engineReads{gate: gate, keeper: &enginereads.Keeper{Call: call, Logf: logf}}
-	r.keeper.Changed = r.stepWindow
-	return r
-}
-
-// stepWindow moves the old form's window to what the counted nodes state now (design 51 *Every build keeps the old
-// reference form*): on a statement's change, the placement's and a hand drop, and at each build key written.
-func (r *engineReads) stepWindow() {
-	if r.window == nil {
-		return
-	}
-	ctx := r.ctx
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	_, counted := r.forms()
-	r.window.step(ctx, r.named(), counted)
-}
-
-// named are the nodes the placement names, none dropped: what the window's step judges a read by.
-func (r *engineReads) named() []string {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	return slices.Clone(r.counted)
-}
-
-// bind keeps the statements in kv and hears it: every node's last statement at the start, a person's ask again and drop
-// later. Bound once the state is on the bus (process.AwaitBucket).
-func (r *engineReads) bind(ctx context.Context, kv jetstream.KeyValue, errs chan<- error, logf func(string, ...any)) {
-	r.keeper.Put = func(node string, v []byte) error { _, err := kv.Put(ctx, node, v); return err }
-	r.keeper.Delete = func(node string) error { return kv.Delete(ctx, node) }
-	each := func(e jetstream.KeyValueEntry) {
-		r.keeper.Heard(e.Key(), e.Value(), e.Operation() != jetstream.KeyValuePut)
-	}
-	w, err := settle(ctx, kv, each)
-	if err != nil {
-		process.NotWatched(logf, engineReadsBucket, err, "builder_engine_reads is not answered until the builder starts again")
-		return
-	}
-	go func() { errs <- follow(ctx, w, each) }()
-	// Every counted node asked again, so what was asked before the state was bound is kept in it too.
-	r.mu.Lock()
-	nodes := slices.Clone(r.counted)
-	r.mu.Unlock()
-	for _, node := range nodes {
-		r.keeper.AskNode(node, "the state engine-reads is bound")
-	}
-}
-
-// placed takes the placement in: a node it names newly is asked, one it no longer names is forgotten, key and all. The
-// first call asks every counted node (the builder's start).
-func (r *engineReads) placed() {
-	nodes := r.gate.Nodes()
-	r.mu.Lock()
-	before, first := r.counted, r.counted == nil
-	r.counted = nodes
-	r.mu.Unlock()
-	for _, node := range nodes {
-		if first || !slices.Contains(before, node) {
-			r.keeper.AskNode(node, "counted: the placement names it")
-		}
-	}
-	for _, node := range before {
-		if !slices.Contains(nodes, node) {
-			r.keeper.Forget(node)
-		}
-	}
-	r.stepWindow()
-}
-
-// heard takes an event of the builder's consumer on EVENTS: manifest-reads-changed asks its node again, and answers true.
-func (r *engineReads) heard(m jetstream.Msg, logf func(string, ...any)) bool {
-	node, ours, err := enginereads.NodeOf(m.Subject(), m.Data())
-	if !ours {
-		return false
-	}
-	if ackErr := m.Ack(); ackErr != nil {
-		logf("acknowledging %s: %v", m.Subject(), ackErr)
-	}
-	if err != nil {
-		logf("%s holds what is not %s, and %s is asked again all the same: %v", m.Subject(), enginereads.Event, node, err)
-	}
-	r.keeper.AskNode(node, enginereads.Event)
-	return true
-}
-
-// forms is the counted nodes' statements, and those of the nodes whose engine answered; a retired node dropped by hand
-// (builder_old_form) counts no more.
-func (r *engineReads) forms() (present, counted map[string][]string) {
-	r.mu.Lock()
-	nodes := slices.Clone(r.counted)
-	r.mu.Unlock()
-	if r.window != nil {
-		dropped := r.window.dropped()
-		nodes = slices.DeleteFunc(nodes, func(n string) bool { return dropped[n] })
-	}
-	return r.keeper.Present(nodes), r.keeper.Reads(nodes)
-}
-
-// built is build.Builder.Forms: forms, and the window stepped with them, so a node's seven days are seen at the next
-// build key at the latest.
-func (r *engineReads) built() (present, counted map[string][]string) {
-	present, counted = r.forms()
-	if r.window != nil {
-		ctx := r.ctx
-		if ctx == nil {
-			ctx = context.Background()
-		}
-		r.window.step(ctx, r.named(), counted)
-	}
-	return present, counted
-}

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reasks.go

@@ -15,7 +15,6 @@ import (
 	"github.com/nats-io/nats.go/jetstream"
 
 	"mesh-delivery-builder/internal/build"
-	"mesh-delivery-builder/internal/versions"
 )
 
 // askAgainer is the part of the builder a reasks value asks through.
@@ -32,7 +31,7 @@ const buildAgainBound = 15 * time.Second
 // reAsked answers one value of the reasks state (the tool builder_ask_again, issue 1945): a value not yet answered asks the
 // key's waiting lanes again and is written back, by compare-and-set at its revision, with what the builder did. A value
 // answered already (this builder's own write) or deleted is left.
-func reAsked(ctx context.Context, b askAgainer, acts versions.Acts, kv jetstream.KeyValue, e jetstream.KeyValueEntry, logf func(string, ...any)) {
+func reAsked(ctx context.Context, b askAgainer, kv jetstream.KeyValue, e jetstream.KeyValueEntry, logf func(string, ...any)) {
 	if e.Operation() != jetstream.KeyValuePut {
 		return
 	}
@@ -53,11 +52,6 @@ func reAsked(ctx context.Context, b askAgainer, acts versions.Acts, kv jetstream
 		announcedAgain(ctx, b, kv, e, r, logf)
 		return
 	}
-	if r.Mode == build.ModePublishAgain || r.Mode == build.ModeFloorAgain || r.Mode == build.ModeOldFormDrop {
-		// A version's hand act (design 51 *Tools of the builder*) may build again, so it is answered beside the watch.
-		go versionActed(ctx, acts, kv, e, r, logf)
-		return
-	}
 	asked := b.AskAgain(e.Key(), r.Why)
 	if len(asked) == 0 {
 		r.Answer = "no ask of this key waits in this builder now (it is not building, or its build has not reached its ask yet): nothing was asked; builder_stuck shows where it stands"
@@ -78,7 +72,21 @@ func reAsked(ctx context.Context, b askAgainer, acts versions.Acts, kv jetstream
 // emitAskedAgain says the builder's event build.asked-again (issue 1945): mesh.mod.<module>.event.build.asked-again,
 // with the SDK's envelope headers and the new ask's id as the bus's dedup id.
 func emitAskedAgain(ctx context.Context, js jetstream.JetStream, cred process.Account, e build.AskedAgain) error {
-	if err := emitEvent(ctx, js, cred, build.AskedAgainEvent, "asked-again-"+e.New, e); err != nil {
+	data, err := json.Marshal(e)
+	if err != nil {
+		return err
+	}
+	msg := nats.NewMsg(cred.EventSubject(build.AskedAgainEvent))
+	id := "asked-again-" + e.New
+	msg.Header.Set("x-event-id", id)
+	msg.Header.Set("x-source", cred.Module)
+	msg.Header.Set("x-node", cred.Node)
+	msg.Header.Set("x-time", time.Now().UTC().Format(time.RFC3339Nano))
+	msg.Header.Set("content-type", "application/json")
+	msg.Data = data
+	pub, cancel := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel()
+	if _, err := js.PublishMsg(pub, msg, jetstream.WithMsgID(id)); err != nil {
 		return fmt.Errorf("saying %s for %s: %w", build.AskedAgainEvent, e.Key, err)
 	}
 	return nil
@@ -155,33 +163,3 @@ func appendLog(ctx context.Context, js jetstream.JetStream, cred process.Account
 	}
 	return nil
 }
-
-// versionActed answers a reasks value of builder_publish_again, builder_floor_again or builder_old_form's drop, a hand act said in the log.
-func versionActed(ctx context.Context, acts versions.Acts, kv jetstream.KeyValue, e jetstream.KeyValueEntry, r build.ReAsk, logf func(string, ...any)) {
-	var err error
-	if r.Mode == build.ModePublishAgain {
-		var ag versions.Again
-		ag, r.Answer, err = acts.PublishAgain(ctx, r.Name, r.FP, r.Why, r.By, r.At)
-		r.Do, r.Version = ag.Do, ag.Entry.Version
-	} else if r.Mode == build.ModeOldFormDrop {
-		if acts.DropOldForm == nil {
-			err = errors.New("this builder keeps no old-form window")
-		} else {
-			r.Answer, err = acts.DropOldForm(ctx, r.Name, r.By, r.Why, r.At)
-		}
-	} else {
-		r.Answer, err = acts.FloorAgain(ctx, r.Name)
-	}
-	if err != nil {
-		r.Answer, r.Refused = err.Error(), true
-	}
-	r.Answered = time.Now().UTC()
-	logf("%s: %s of %s by %s (%s): %s", e.Key(), r.Mode, r.Name, r.By, r.Why, r.Answer)
-	data, err := json.Marshal(r)
-	if err != nil {
-		return
-	}
-	if _, err := kv.Update(ctx, e.Key(), data, e.Revision()); err != nil && !errors.Is(err, jetstream.ErrKeyExists) && !errors.Is(err, jetstream.ErrKeyRevisionMismatch) {
-		logf("%s.%s: the answer could not be written: %v", build.ReAsksState, e.Key(), err)
-	}
-}

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/refused_test.go

@@ -3,31 +3,17 @@ package main
 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"errors"
 	"log"
-	"maps"
-	"slices"
 	"strings"
 	"testing"
-	"time"
 
-	"git.novox.be/novox/mesh-sdk/go/health"
-
-	"git.novox.be/novox/mesh-delivery/sdk/heard"
 	"git.novox.be/novox/mesh-sdk/go/process"
 
-	"github.com/nats-io/nats.go"
 	"github.com/nats-io/nats.go/jetstream"
 
-	"git.novox.be/novox/mesh-contracts/go/seats/nodeengine"
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
-	"git.novox.be/novox/mesh-delivery/sdk/enginereads"
-	"git.novox.be/novox/mesh-delivery/sdk/forms"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
-
-	"mesh-delivery-builder/internal/build"
-	"mesh-delivery-builder/internal/versions"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 )
 
 // 1945 (a part exits at start for a bucket it works without): a bus that refuses every toolchains bucket leaves the
@@ -35,9 +21,6 @@ import (
 // its grant. The gate over the seat's placement, and its refusal, are mesh-sdk's (buildrun.ToolchainGate,
 // issue 774).
 func TestARefusedBucketIsSaidAndThePartGoesOn(t *testing.T) {
-	t.Run("a floor's wake is heard on the events consumer (design 51 The floor)", aFloorsWakeIsHeard)
-	t.Run("a failed trunk build is a finding until a later done one (DLV-B7)", aFailedTrunkBuildIsAFinding)
-	t.Run("a branch's end is acknowledged once its tagged versions are removed (design 51 Tagged versions)", aBranchsEndIsHeard)
 	set := &buildrun.ToolchainSet{}
 	var logs bytes.Buffer
 	logger := log.New(&logs, "", 0)
@@ -62,100 +45,6 @@ func TestARefusedBucketIsSaidAndThePartGoesOn(t *testing.T) {
 	if src.opened {
 		t.Error("a refused source counts as opened, so it is never opened again")
 	}
-	t.Run("ADR 0624: the counted nodes' engine reads", theCountedNodesEngineReads)
-}
-
-// theCountedNodesEngineReads: the builder asks the node-engine seat's verb of every node the placement names; a node away
-// and never asked has no statement and reads as the baseline's first forms, with no node record read in its place; an
-// away node keeps its last statement; a node the placement no longer names leaves the count, its key removed; and
-// builder_engine_reads drops one node's key.
-func theCountedNodesEngineReads(t *testing.T) {
-	gate := buildrun.NewToolchainGate(nil, func(string, string, []byte, bool) bool { return false }, t.Logf)
-	place := func(nodes ...string) {
-		for _, node := range []string{"n1", "n2"} {
-			pl := delivery.Placement{Node: node}
-			if slices.Contains(nodes, node) {
-				pl.Modules = []delivery.PlacedModule{{Module: "web"}}
-			}
-			values, err := delivery.PlacementValues(pl)
-			if err != nil {
-				t.Fatal(err)
-			}
-			for key, raw := range values {
-				gate.Placement(key, raw, false, time.Now())
-			}
-			if !slices.Contains(nodes, node) {
-				key, _ := delivery.PlacementModuleKey(node, "web")
-				gate.Placement(key, nil, true, time.Now())
-			}
-		}
-	}
-	away := map[string]bool{"n2": true}
-	asked := map[string]int{}
-	r := newEngineReads(func(node, key string, _ any) (json.RawMessage, error) {
-		asked[node]++
-		if away[node] {
-			return nil, nats.ErrNoResponders
-		}
-		return json.Marshal(nodeengine.ManifestReadsAnswer{V: 1, Node: node, ManifestReads: []string{"form:new"}, StatedAt: time.Now().Format(time.RFC3339Nano)})
-	}, gate, t.Logf)
-	r.keeper.Sync = true
-	kept := map[string][]byte{}
-	r.keeper.Put = func(node string, v []byte) error { kept[node] = v; return nil }
-	r.keeper.Delete = func(node string) error { delete(kept, node); return nil }
-	place("n1", "n2")
-	r.placed()
-	present, counted := r.forms()
-	if !slices.Equal(present["n1"], []string{"form:new"}) || len(present) != 1 || len(counted) != 2 || counted["n2"] != nil {
-		t.Errorf("away and never asked: present %v, counted %v", present, counted)
-	}
-	if s := r.keeper.Statements()["n2"]; s.From != enginereads.FromNone || s.Answered || asked["n2"] != 1 {
-		t.Errorf("n2, away and never asked, is %+v (asked %d)", s, asked["n2"])
-	}
-	// n2 back, stating {word:module}, then away again: it keeps that statement.
-	away["n2"] = false
-	r.keeper.Heard("n2", mustStatement(t, enginereads.Statement{Node: "n2", From: enginereads.FromVerb, Answered: true,
-		AskAgain: &enginereads.Again{By: "n1.ada", Why: "back"}}), false)
-	away["n2"] = true
-	r.keeper.AskNode("n2", "its event")
-	if _, counted = r.forms(); !slices.Equal(counted["n2"], []string{"form:new"}) || r.keeper.Statements()["n2"].Answered {
-		t.Errorf("away again, n2 reads %v (%+v)", counted["n2"], r.keeper.Statements()["n2"])
-	}
-	// n2 retired: it leaves the placement, and its key goes.
-	place("n1")
-	r.placed()
-	if _, counted = r.forms(); len(counted) != 1 || kept["n2"] != nil {
-		t.Errorf("retired n2: counted %v, its key %s", counted, kept["n2"])
-	}
-	// builder_engine_reads drops one key.
-	st := &memReads{v: map[string][]byte{"n1": kept["n1"]}}
-	tool := enginereads.Tool("builder_engine_reads", "the builder", st, true, time.Now)
-	if _, err := tool.Run(map[string]any{"node": "n1", "drop": "true", "why": "a test"}); err != nil || st.v["n1"] != nil {
-		t.Errorf("drop: %v, the key %s", err, st.v["n1"])
-	}
-}
-
-func mustStatement(t *testing.T, s enginereads.Statement) []byte {
-	t.Helper()
-	raw, err := enginereads.Encode(s)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return raw
-}
-
-// memReads is the builder's state of engine reads in memory, as the tool reads it.
-type memReads struct{ v map[string][]byte }
-
-func (m *memReads) Keys() ([]string, error) { return slices.Collect(maps.Keys(m.v)), nil }
-func (m *memReads) Get(key string) ([]byte, uint64, bool, error) {
-	v, ok := m.v[key]
-	return v, 1, ok, nil
-}
-func (m *memReads) Put(key string, value []byte) (uint64, error) { m.v[key] = value; return 2, nil }
-func (m *memReads) Delete(key string) error                      { delete(m.v, key); return nil }
-func (m *memReads) Await(string, uint64, func([]byte) bool, time.Duration) ([]byte, error) {
-	return nil, errors.New("no part answers here")
 }
 
 // refusingBus is a bus that refuses: every open (refuseOpen), or every watch of a bucket it opens, with err.
@@ -182,347 +71,3 @@ func (r refusedWatch) WatchAll(context.Context, ...jetstream.WatchOpt) (jetstrea
 func (r refusedWatch) Watch(context.Context, string, ...jetstream.WatchOpt) (jetstream.KeyWatcher, error) {
 	return nil, r.err
 }
-
-// wakeMsg is a message of the builder's events consumer: its subject and body, acknowledged.
-type wakeMsg struct {
-	jetstream.Msg
-	subject string
-	data    []byte
-	acked   bool
-	naked   bool
-	delayed time.Duration
-}
-
-func (m *wakeMsg) Subject() string { return m.subject }
-func (m *wakeMsg) Data() []byte    { return m.data }
-func (m *wakeMsg) Ack() error      { m.acked = true; return nil }
-func (m *wakeMsg) Nak() error      { m.naked = true; return nil }
-func (m *wakeMsg) NakWithDelay(d time.Duration) error {
-	m.delayed = d
-	return nil
-}
-func (m *wakeMsg) Metadata() (*jetstream.MsgMetadata, error) {
-	return nil, errors.New("no metadata")
-}
-func (m *wakeMsg) Headers() nats.Header {
-	return nil
-}
-
-func aFloorsWakeIsHeard(t *testing.T) {
-	var logs bytes.Buffer
-	waits := &versions.FloorWaits{}
-	waits.Wait("m/lib", versions.SeatGoPackages, "", versions.Floor{Silent: []string{versions.SourceRequirements}}, nil, time.Unix(0, 0))
-	waits.Wait("m/img", versions.SeatImages, "", versions.Floor{Silent: []string{versions.SourceTags}}, nil, time.Unix(0, 0))
-	f := &floorWake{b: &build.Builder{}, waits: waits, logf: log.New(&logs, "", 0).Printf}
-	accepted := &wakeMsg{subject: manifestAcceptedSubject}
-	if !f.heard(context.Background(), accepted) || !accepted.acked || !strings.Contains(logs.String(), "the floor of m/lib is asked again: manifest-accepted") {
-		t.Fatalf("manifest-accepted: acked %v, log %q", accepted.acked, logs.String())
-	}
-	logs.Reset()
-	cleared := &wakeMsg{subject: conditionClearedSubject, data: []byte(`{"subject":{"scope":"probe","id":"ace/mesh-delivery-forge-bridge"}}`)}
-	if !f.heard(context.Background(), cleared) || !strings.Contains(logs.String(), "the floor of m/img is asked again: condition-cleared") {
-		t.Fatalf("condition-cleared: log %q", logs.String())
-	}
-	if f.heard(context.Background(), &wakeMsg{subject: delivery.ArtifactsGoneSubject}) {
-		t.Fatal("artifacts-gone was taken as a floor's wake")
-	}
-	// DLV-B4: a registry seat's outcome on the same consumer moves a version; a published wakes a name whose seat was
-	// silent; one the state cannot take is left for the bus to give again.
-	logs.Reset()
-	waits.Wait("m/pkg", versions.SeatGoPackages, "", versions.Floor{Silent: []string{versions.SourceSeat}}, nil, time.Unix(0, 0))
-	h := &seatHearer{n: &versions.Numberer{Versions: versions.Versions{Store: noVersions{}}, Waits: waits}, b: &build.Builder{}, logf: log.New(&logs, "", 0).Printf}
-	byDigest := &wakeMsg{subject: "mesh.seat.go-package-registry.event.published", data: []byte(`{"name":"m/other","digest":"sha256:aa","kind":"package","holder":"gitea"}`)}
-	if !h.heard(context.Background(), byDigest) || !byDigest.acked || !strings.Contains(logs.String(), "the floor of m/pkg is asked again: go-package-registry said published") {
-		t.Fatalf("published: acked %v, log %q", byDigest.acked, logs.String())
-	}
-	refused := &wakeMsg{subject: "mesh.seat.oci-artifact-registry.event.refused", data: []byte(`{"name":"m/program","version":"0.1.3","digest":"sha256:bb","reason":"bytes differ"}`)}
-	if !h.heard(context.Background(), refused) || refused.acked || !refused.naked {
-		t.Fatalf("a refusal the state cannot take: acked %v, naked %v, log %q", refused.acked, refused.naked, logs.String())
-	}
-	if h.heard(context.Background(), &wakeMsg{subject: manifestAcceptedSubject}) {
-		t.Fatal("manifest-accepted was taken as a seat's outcome")
-	}
-}
-
-// noVersions is a state versions that holds nothing.
-type noVersions struct{}
-
-func (noVersions) Get(context.Context, string) ([]byte, uint64, bool, error) {
-	return nil, 0, false, nil
-}
-func (noVersions) Create(context.Context, string, []byte) (uint64, error) {
-	return 0, errors.New("read only")
-}
-func (noVersions) Update(context.Context, string, []byte, uint64) (uint64, error) {
-	return 0, errors.New("read only")
-}
-func (noVersions) KeysOf(context.Context, string) ([]string, error) { return nil, nil }
-
-func aBranchsEndIsHeard(t *testing.T) {
-	for _, c := range []struct {
-		f    forgeEnd
-		want bool
-	}{
-		{forgeEnd{Kind: delivery.ForgeMerged, Repository: "o/r", Branch: "feat/x"}, true},
-		{forgeEnd{Kind: forgeBranchDeleted, Repository: "o/r", Branch: "feat/x"}, true},
-		{forgeEnd{Kind: delivery.ForgePull, Repository: "o/r", Branch: "feat/x", Action: delivery.PullClosed}, true},
-		{forgeEnd{Kind: delivery.ForgePull, Repository: "o/r", Branch: "feat/x", Action: delivery.PullOpened}, false},
-		{forgeEnd{Kind: delivery.ForgeMerged, Repository: "o/r"}, false},
-	} {
-		if got := c.f.ended(); got != c.want {
-			t.Errorf("%+v ended = %v, want %v", c.f, got, c.want)
-		}
-	}
-	var logs bytes.Buffer
-	woken := 0
-	h := &branchEnds{acts: versions.Acts{Numberer: &versions.Numberer{Versions: versions.Versions{Store: noVersions{}}}}, findings: &findings{logf: t.Logf},
-		tagAsks: func() jetstream.KeyValue { return nil }, wake: func(context.Context) { woken++ }, logf: log.New(&logs, "", 0).Printf, now: time.Now}
-	open := &wakeMsg{subject: "mesh.mod.mesh-delivery-forge-bridge.event.forge.o.r.pull", data: []byte(`{"kind":"pull","repository":"o/r","branch":"feat/x","action":"opened"}`)}
-	h.heard(context.Background(), open)
-	merged := &wakeMsg{subject: "mesh.mod.mesh-delivery-forge-bridge.event.forge.o.r.merged", data: []byte(`{"kind":"merged","repository":"o/r","branch":"feat/x"}`)}
-	h.heard(context.Background(), merged)
-	if !open.acked || !merged.acked || woken != 2 {
-		t.Errorf("an open pull acked %v, a merge with nothing tagged acked %v, floors woken %d times", open.acked, merged.acked, woken)
-	}
-	// The checker's family holds its verdicts beside tag-wanted: a verdict is acknowledged and not kept; a tag-wanted with
-	// tag-asks not bound is heard again.
-	verdict := &wakeMsg{subject: "mesh.stream.mesh-delivery-checker.event.verdict", data: []byte(`{"repository":"o/r"}`)}
-	wanted := &wakeMsg{subject: tagWantedSubject, data: []byte(`{"repository":"o/r","branch":"feat/x","head":"abc","tag":"feat-x"}`)}
-	for _, m := range []*wakeMsg{verdict, wanted} {
-		tagWanted(context.Background(), nil, m, delivery.CheckerModule, time.Now(), t.Logf)
-	}
-	if !verdict.acked || verdict.delayed != 0 || wanted.acked || wanted.delayed != versions.RemoveAgainAfter || !strings.HasPrefix(tagWantedSubject, "mesh.stream.") {
-		t.Errorf("a verdict acked %v (delayed %v), a tag-wanted acked %v (delayed %v)", verdict.acked, verdict.delayed, wanted.acked, wanted.delayed)
-	}
-	unreadable := &wakeMsg{subject: merged.subject, data: merged.data}
-	h.acts.Numberer.Versions.Store = failingVersions{}
-	h.heard(context.Background(), unreadable)
-	if unreadable.acked || unreadable.delayed != versions.RemoveAgainAfter {
-		t.Errorf("a branch's end the versions cannot answer: acked %v, given again after %v", unreadable.acked, unreadable.delayed)
-	}
-}
-
-// failingVersions is a state versions that cannot be read.
-type failingVersions struct{ noVersions }
-
-func (failingVersions) KeysOf(context.Context, string) ([]string, error) {
-	return nil, errors.New("down")
-}
-
-func aFailedTrunkBuildIsAFinding(t *testing.T) {
-	st := &memFindings{vals: map[string][]byte{}}
-	f := &findings{store: st, logf: t.Logf, now: func() time.Time { return time.Unix(0, 0) }}
-	ended := func(outcome, ref string) delivery.BuildLogEntry {
-		return delivery.BuildLogEntry{Event: delivery.BuildEndedEvent, Module: "m", FP: "f1", Commit: "c", Ref: ref, Outcome: outcome}
-	}
-	key := health.FindingKey(health.ScopeModule, "m", BuildFailed)
-	f.buildEnded(context.Background(), ended(delivery.BuildFailed, "refs/pull/3/head"))
-	if len(st.vals) != 0 {
-		t.Fatalf("a candidate's failed build is a finding: %v", st.vals)
-	}
-	f.buildEnded(context.Background(), ended(delivery.BuildFailed, ""))
-	got, err := health.DecodeFinding(st.vals[key])
-	if err != nil || got.Observer != delivery.BuilderModule || !strings.Contains(got.Summary, "trunk build of m at f1") {
-		t.Fatalf("the finding = %+v, %v", got, err)
-	}
-	f.buildEnded(context.Background(), ended(delivery.BuildDone, ""))
-	if _, ok := st.vals[key]; ok {
-		t.Error("a later done trunk build leaves build-failed")
-	}
-	// The floor finding: raised while a name waits on its floor, cleared once it is known.
-	fw := &versions.FloorWaits{Said: f.floorSaid(context.Background())}
-	fw.Wait("m/lib", versions.SeatGoPackages, "", versions.Floor{Silent: []string{versions.SourceTags}}, nil, time.Unix(0, 0))
-	floorKey := health.FindingKey(health.ScopeModule, "m/lib", versions.FloorSilent)
-	if got, err := health.DecodeFinding(st.vals[floorKey]); err != nil || !strings.Contains(got.Summary, "bridge_tags did not answer") {
-		t.Fatalf("the floor finding = %+v, %v", got, err)
-	}
-	fw.Answered("m/lib")
-	if _, ok := st.vals[floorKey]; ok {
-		t.Error("a known floor leaves floor-silent")
-	}
-	// Design 51 *Health and conditions* (review round 1): a holder's refused is publish-refused with its reason, a version
-	// no holder answered within its bound publish-unanswered, a seat's outcome that does not read seat-outcome-unread;
-	// a later published of the name clears the first two, the seat's next outcome that reads the third.
-	vs := versions.Versions{Store: memVersions{}}
-	for _, v := range []string{"0.1.3", "0.1.4"} {
-		raw, err := versions.Encode(versions.Entry{Name: "m/program", Kind: versions.KindBundle, Series: "0.1", Version: v, Seat: "oci-artifact-registry", State: versions.Numbered})
-		if err != nil {
-			t.Fatal(err)
-		}
-		vs.Store.(memVersions)[versions.Key("m/program", v)] = raw
-	}
-	pubs := &publishes{bounds: func() jetstream.KeyValue { return nil }, versions: vs, findings: f, bound: versions.PublishBound, logf: t.Logf}
-	h := &seatHearer{n: &versions.Numberer{Versions: vs}, b: &build.Builder{}, logf: t.Logf, pub: pubs}
-	refusedKey := health.FindingKey(health.ScopeModule, "m/program", versions.PublishRefused)
-	refused := &wakeMsg{subject: "mesh.seat.oci-artifact-registry.event.refused", data: []byte(`{"name":"m/program","version":"0.1.3","digest":"sha256:bb","reason":"bytes differ"}`)}
-	if !h.heard(context.Background(), refused) || !refused.acked {
-		t.Fatalf("a refusal: acked %v", refused.acked)
-	}
-	if got, err := health.DecodeFinding(st.vals[refusedKey]); err != nil || !strings.Contains(got.Summary, "refused to publish m/program@0.1.3") || !strings.Contains(got.Summary, "bytes differ") {
-		t.Fatalf("a holder's refused: the finding = %+v, %v", got, err)
-	}
-	pubs.ended(context.Background(), purged{key: versions.PublishBoundKey("m/program", "0.1.4")})
-	unansweredKey := health.FindingKey(health.ScopeModule, "m/program", versions.PublishUnanswered)
-	if got, err := health.DecodeFinding(st.vals[unansweredKey]); err != nil || !strings.Contains(got.Summary, "neither published nor refused of m/program@0.1.4") {
-		t.Fatalf("a bound ended unanswered: the finding = %+v, %v", got, err)
-	}
-	// Review round 2: a bound that cannot be written is publish-unanswered at once; a watch of bounds that cannot start
-	// is family-not-heard naming the state.
-	delete(st.vals, unansweredKey)
-	pubs.arm(context.Background(), versions.Entry{Name: "m/program", Version: "0.1.4", Seat: "oci-artifact-registry"})
-	if got, err := health.DecodeFinding(st.vals[unansweredKey]); err != nil || !strings.Contains(got.Summary, "its bound could not be written") {
-		t.Fatalf("a bound not written: the finding = %+v, %v", got, err)
-	}
-	watchBounds(context.Background(), refusedWatch{err: errors.New("permissions violation")}, func(jetstream.KeyValueEntry) {}, f.notHeard(context.Background()), nil, t.Logf)
-	if got, err := health.DecodeFinding(st.vals[heard.Key(delivery.BuilderModule, versions.BoundsState)]); err != nil || !strings.Contains(got.Summary, "permissions violation") {
-		t.Fatalf("bounds not watched: the finding = %+v, %v", got, err)
-	}
-	delete(st.vals, heard.Key(delivery.BuilderModule, versions.BoundsState))
-	malformed := &wakeMsg{subject: "mesh.seat.oci-artifact-registry.event.published", data: []byte(`{"version":"0.1.4"}`)}
-	unreadKey := health.FindingKey(health.ScopeModule, "oci-artifact-registry", versions.SeatOutcomeUnread)
-	if !h.heard(context.Background(), malformed) || !malformed.acked || st.vals[unreadKey] == nil {
-		t.Fatalf("an outcome that does not read: acked %v, findings %v", malformed.acked, st.vals)
-	}
-	published := &wakeMsg{subject: "mesh.seat.oci-artifact-registry.event.published", data: []byte(`{"name":"m/program","version":"0.1.4","digest":"sha256:cc"}`)}
-	if !h.heard(context.Background(), published) || st.vals[refusedKey] != nil || st.vals[unansweredKey] != nil || st.vals[unreadKey] != nil {
-		t.Fatalf("a later published leaves the findings: %v", st.vals)
-	}
-	// ADR 0615 §5 (review round 1): a consumer not there yet is family-not-heard naming its stream, cleared when it binds.
-	notHeard := f.notHeard(context.Background())
-	unheardKey := heard.Key(delivery.BuilderModule, "FORGE")
-	_ = notHeard.Bind("FORGE", "a branch's end is not heard", func() error { return errors.New("consumer not found") })
-	if got, err := health.DecodeFinding(st.vals[unheardKey]); err != nil || got.Kind != heard.Kind || !strings.Contains(got.Summary, "does not hear FORGE") {
-		t.Fatalf("a consumer not there: the finding = %+v, %v", got, err)
-	}
-	_ = notHeard.Bind("FORGE", "a branch's end is not heard", func() error { return nil })
-	if _, ok := st.vals[unheardKey]; ok {
-		t.Error("a consumer bound leaves family-not-heard")
-	}
-	// DLV-B9, the old form's window: one counted node reading only the first form holds it; seven days on it is
-	// old-form-held about that node; the node stating the newest form closes it, said once, the finding cleared; a
-	// retired node dropped by hand leaves the count.
-	now := time.Unix(0, 0)
-	fs := forms.ArtifactForms{{Name: "registry", First: true, Kinds: []string{"image"}}, {Name: "oci", Kinds: []string{"image"}}}
-	var closings []versions.OldFormClosedBody
-	var logged []delivery.BuildLogEntry
-	marks := &memBounds{keys: map[string]bool{}}
-	window := &oldForm{forms: fs, findings: f, logf: t.Logf, now: func() time.Time { return now }, bounds: func() jetstream.KeyValue { return marks },
-		said: func(b versions.OldFormClosedBody) { closings = append(closings, b) },
-		log:  func(e delivery.BuildLogEntry) { logged = append(logged, e) }}
-	reads := &engineReads{keeper: &enginereads.Keeper{}, window: window, counted: []string{"a", "b"}}
-	newest := []string{forms.FormNeed("oci")}
-	counted := map[string][]string{"a": newest, "b": nil}
-	window.step(context.Background(), []string{"a", "b"}, counted)
-	heldKey := health.FindingKey(health.ScopeMachine, "b", versions.OldFormHeld)
-	if !window.w.Open || !slices.Equal(window.w.Holding, []string{"b"}) || st.vals[heldKey] != nil {
-		t.Fatalf("one node lacking the newest form: %+v", window.w)
-	}
-	// Review round 1: the node holding it has a bound in the state bounds ending at its seven days, so old-form-held is
-	// raised then, not at the next change.
-	if !marks.keys[versions.OldFormBoundKey("b")] || marks.keys[versions.OldFormBoundKey("a")] {
-		t.Fatalf("the old form's bounds = %v, want b's alone", marks.keys)
-	}
-	// Security-upgrade F3 (review round 1): an empty node_haves read, naming no node, leaves the window open.
-	window.step(context.Background(), nil, map[string][]string{})
-	if !window.w.Open || !slices.Equal(window.w.Holding, []string{"b"}) || len(closings) != 0 {
-		t.Fatalf("an empty read closed the window: %+v, closings %+v", window.w, closings)
-	}
-	now = now.Add(versions.FindingAfter)
-	window.step(context.Background(), []string{"a", "b"}, counted)
-	if got, err := health.DecodeFinding(st.vals[heldKey]); err != nil || !strings.Contains(got.Summary, "the node-engine of b") {
-		t.Fatalf("seven days held: the finding = %+v, %v", got, err)
-	}
-	counted["b"] = newest
-	window.step(context.Background(), []string{"a", "b"}, counted)
-	window.step(context.Background(), []string{"a", "b"}, counted)
-	if marks.keys[versions.OldFormBoundKey("b")] {
-		t.Error("a node no longer holding the window keeps its bound")
-	}
-	if window.w.Open || len(closings) != 1 || !slices.Equal(closings[0].LastHolding, []string{"b"}) || st.vals[heldKey] != nil {
-		t.Errorf("the node back with the newest form: %+v, closings %+v, finding left %v", window.w, closings, st.vals[heldKey] != nil)
-	}
-	if len(logged) != 1 || logged[0].Event != delivery.BuildSaidEvent || logged[0].Why != versions.SaidOldFormClosed ||
-		!strings.Contains(logged[0].Line, "last held by b") {
-		t.Errorf("the build log = %+v, want the close said once (build.said)", logged)
-	} else if _, err := delivery.EncodeBuildLogEntry(logged[0]); err != nil {
-		t.Errorf("the close is no entry the build log takes: %v", err)
-	}
-	if _, err := window.drop(context.Background(), "b", "op@shanks", "retired", now); err != nil {
-		t.Fatal(err)
-	}
-	if _, c := reads.forms(); len(c) != 1 || c["b"] != nil {
-		t.Errorf("a node dropped by hand is still counted: %v", c)
-	}
-}
-
-// memVersions is a state versions in memory.
-type memVersions map[string][]byte
-
-func (m memVersions) Get(_ context.Context, key string) ([]byte, uint64, bool, error) {
-	v, ok := m[key]
-	return v, 1, ok, nil
-}
-func (m memVersions) Create(_ context.Context, key string, v []byte) (uint64, error) {
-	m[key] = v
-	return 1, nil
-}
-func (m memVersions) Update(_ context.Context, key string, v []byte, _ uint64) (uint64, error) {
-	m[key] = v
-	return 2, nil
-}
-func (m memVersions) KeysOf(context.Context, string) ([]string, error) {
-	return slices.Collect(maps.Keys(m)), nil
-}
-
-// memBounds is the state bounds in memory: which keys stand.
-type memBounds struct {
-	jetstream.KeyValue
-	keys map[string]bool
-}
-
-func (m *memBounds) Create(_ context.Context, key string, _ []byte, _ ...jetstream.KVCreateOpt) (uint64, error) {
-	if m.keys[key] {
-		return 0, jetstream.ErrKeyExists
-	}
-	m.keys[key] = true
-	return 1, nil
-}
-func (m *memBounds) Delete(_ context.Context, key string, _ ...jetstream.KVDeleteOpt) error {
-	delete(m.keys, key)
-	return nil
-}
-
-// purged is the bus's marker of a key whose time to live ended.
-type purged struct {
-	jetstream.KeyValueEntry
-	key string
-}
-
-func (p purged) Key() string                     { return p.key }
-func (p purged) Operation() jetstream.KeyValueOp { return jetstream.KeyValuePurge }
-
-// memFindings is a findings bucket in memory.
-type memFindings struct{ vals map[string][]byte }
-
-type memEntry struct {
-	jetstream.KeyValueEntry
-	v []byte
-}
-
-func (e memEntry) Value() []byte { return e.v }
-
-func (m *memFindings) Get(_ context.Context, key string) (jetstream.KeyValueEntry, error) {
-	v, ok := m.vals[key]
-	if !ok {
-		return nil, jetstream.ErrKeyNotFound
-	}
-	return memEntry{v: v}, nil
-}
-func (m *memFindings) Put(_ context.Context, key string, v []byte) (uint64, error) {
-	m.vals[key] = v
-	return 1, nil
-}
-func (m *memFindings) Delete(_ context.Context, key string, _ ...jetstream.KVDeleteOpt) error {
-	delete(m.vals, key)
-	return nil
-}

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/seats.go

@@ -1,148 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"strings"
-
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-contracts/go/seats/containerimageregistry"
-	"git.novox.be/novox/mesh-contracts/go/seats/gopackageregistry"
-	"git.novox.be/novox/mesh-contracts/go/seats/npmpackageregistry"
-	"git.novox.be/novox/mesh-contracts/go/seats/ociartifactregistry"
-
-	"mesh-delivery-builder/internal/build"
-	"mesh-delivery-builder/internal/versions"
-)
-
-// seatEvent is one registry seat's event the builder hears: the seat and the event's name.
-type seatEvent struct{ seat, event string }
-
-// seatEvents are the four registry seats' published, refused, removed and kept, by subject (design 51 *How a publish ends*,
-// DLV-B4): each a seat event `<seat>.<event>` on the shared events stream, heard on the builder's durable consumer of
-// it through the manifest's consumes. The subjects are the seats' contracts' (mesh-contracts).
-var seatEvents = map[string]seatEvent{
-	containerimageregistry.SubjectPublished: {containerimageregistry.Seat, containerimageregistry.EventPublished},
-	containerimageregistry.SubjectRefused:   {containerimageregistry.Seat, containerimageregistry.EventRefused},
-	containerimageregistry.SubjectRemoved:   {containerimageregistry.Seat, containerimageregistry.EventRemoved},
-	containerimageregistry.SubjectKept:      {containerimageregistry.Seat, containerimageregistry.EventKept},
-	ociartifactregistry.SubjectPublished:    {ociartifactregistry.Seat, ociartifactregistry.EventPublished},
-	ociartifactregistry.SubjectRefused:      {ociartifactregistry.Seat, ociartifactregistry.EventRefused},
-	ociartifactregistry.SubjectRemoved:      {ociartifactregistry.Seat, ociartifactregistry.EventRemoved},
-	ociartifactregistry.SubjectKept:         {ociartifactregistry.Seat, ociartifactregistry.EventKept},
-	gopackageregistry.SubjectPublished:      {gopackageregistry.Seat, gopackageregistry.EventPublished},
-	gopackageregistry.SubjectRefused:        {gopackageregistry.Seat, gopackageregistry.EventRefused},
-	gopackageregistry.SubjectRemoved:        {gopackageregistry.Seat, gopackageregistry.EventRemoved},
-	gopackageregistry.SubjectKept:           {gopackageregistry.Seat, gopackageregistry.EventKept},
-	npmpackageregistry.SubjectPublished:     {npmpackageregistry.Seat, npmpackageregistry.EventPublished},
-	npmpackageregistry.SubjectRefused:       {npmpackageregistry.Seat, npmpackageregistry.EventRefused},
-	npmpackageregistry.SubjectRemoved:       {npmpackageregistry.Seat, npmpackageregistry.EventRemoved},
-	npmpackageregistry.SubjectKept:          {npmpackageregistry.Seat, npmpackageregistry.EventKept},
-}
-
-// seatHearer takes the registry seats' outcomes in: each moves a numbered version (versions.Numberer.Heard), and a
-// `published` that wakes a name waiting on its floor looks at every module again.
-type seatHearer struct {
-	n    *versions.Numberer
-	b    *build.Builder
-	logf func(string, ...any)
-	// pub raises and clears the findings of a publish that ended badly; nil raises none.
-	pub *publishes
-}
-
-// heard takes a message of the events consumer in when it is a registry seat's outcome, and answers whether it was.
-// One the state could not take is left unacknowledged (Nak), so the bus gives it again; one that is no outcome is said
-// and dropped.
-func (h *seatHearer) heard(ctx context.Context, m jetstream.Msg) bool {
-	se, ok := seatEvents[m.Subject()]
-	if !ok {
-		return false
-	}
-	var o versions.Outcome
-	if err := json.Unmarshal(m.Data(), &o); err != nil || o.Name == "" {
-		if err == nil {
-			err = errors.New("it names no name")
-		}
-		h.logf("%s holds what is no outcome of %s, left: %v", m.Subject(), se.seat, err)
-		if h.pub != nil {
-			h.pub.unread(ctx, se.seat, m.Subject(), err)
-		}
-		h.ack(m)
-		return true
-	}
-	if h.pub != nil {
-		h.pub.read(ctx, se.seat)
-	}
-	id := ""
-	if m.Headers() != nil {
-		id = m.Headers().Get("x-event-id")
-	}
-	wake, err := h.n.Heard(ctx, se.seat, se.event, id, o)
-	if err != nil {
-		h.logf("%v; heard again", err)
-		if nakErr := m.Nak(); nakErr != nil {
-			h.logf("leaving %s for the bus to give again: %v", m.Subject(), nakErr)
-		}
-		return true
-	}
-	if h.pub != nil {
-		h.pub.heard(ctx, se.seat, se.event, o)
-	}
-	h.ack(m)
-	if len(wake) > 0 {
-		h.logf("the floor of %s is asked again: %s said %s", strings.Join(wake, ", "), se.seat, se.event)
-		h.b.Reconsider(ctx)
-	}
-	return true
-}
-
-func (h *seatHearer) ack(m jetstream.Msg) {
-	if err := m.Ack(); err != nil {
-		h.logf("acknowledging %s: %v", m.Subject(), err)
-	}
-}
-
-// kvKeeper is the state floor-waits as versions.FloorKeeper.
-type kvKeeper struct {
-	ctx context.Context
-	kv  jetstream.KeyValue
-}
-
-func (k kvKeeper) Put(key string, value []byte) error {
-	_, err := k.kv.Put(k.ctx, key, value)
-	return err
-}
-
-func (k kvKeeper) Delete(key string) error {
-	err := k.kv.Delete(k.ctx, key)
-	if errors.Is(err, jetstream.ErrKeyNotFound) {
-		return nil
-	}
-	return err
-}
-
-// heldFloorWaits are the waits floor-waits holds at the builder's start; a value that is no wait is said and left.
-func heldFloorWaits(ctx context.Context, kv jetstream.KeyValue, logf func(string, ...any)) []versions.FloorWait {
-	l, err := kv.ListKeys(ctx)
-	if err != nil {
-		logf("%s cannot be listed, so a restart's waits are asked at their next claim: %v", versions.FloorWaitsState, err)
-		return nil
-	}
-	defer func() { _ = l.Stop() }()
-	var out []versions.FloorWait
-	for k := range l.Keys() {
-		e, err := kv.Get(ctx, k)
-		if err != nil {
-			continue
-		}
-		w, err := versions.DecodeFloorWait(e.Value())
-		if err != nil {
-			logf("%s.%s holds what is no floor wait, left: %v", versions.FloorWaitsState, k, err)
-			continue
-		}
-		out = append(out, w)
-	}
-	return out
-}

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/tagbounds.go

@@ -1,132 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"time"
-
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-
-	"mesh-delivery-builder/internal/versions"
-)
-
-// tagBounds narrates a tag ask the builder has not answered within five minutes, with what it waits on (design 51
-// *Tagged versions*): each unanswered ask has a key in the state tag-ask-bounds written with its own time to live, and
-// the bus's marker of its end, heard on the watch, is what narrates it and writes the bound again. No timer.
-type tagBounds struct {
-	asks   func() jetstream.KeyValue
-	bounds func() jetstream.KeyValue
-	waits  func() []versions.FloorWait
-	logf   func(string, ...any)
-	// log writes a narration into the builder's build log (build.said); nil writes none.
-	log   func(delivery.BuildLogEntry)
-	now   func() time.Time
-	bound time.Duration
-}
-
-// arm writes key's bound when none stands: a Create, so a standing bound keeps its time and a restart arms each
-// unanswered ask whose bound ended while the builder was away.
-func (tb *tagBounds) arm(ctx context.Context, key string) {
-	kv := tb.bounds()
-	if kv == nil {
-		return
-	}
-	if _, err := kv.Create(ctx, key, []byte(`{}`), jetstream.KeyTTL(tb.bound)); err != nil && !errors.Is(err, jetstream.ErrKeyExists) {
-		tb.logf("the bound of the tag ask %s is not written, so it is not narrated past five minutes: %v", key, err)
-	}
-}
-
-// disarm removes key's bound: the ask was answered or ended.
-func (tb *tagBounds) disarm(ctx context.Context, key string) {
-	if kv := tb.bounds(); kv != nil {
-		_ = kv.Delete(ctx, key)
-	}
-}
-
-// asked is told each value of tag-asks: an unanswered ask is armed, any other disarmed.
-func (tb *tagBounds) asked(ctx context.Context, key string, t versions.TagAsk) {
-	if t.Unanswered() {
-		tb.arm(ctx, key)
-		return
-	}
-	tb.disarm(ctx, key)
-}
-
-// ended is told each change of tag-ask-bounds: a bound whose time ended (the bus's marker, a purge on the watch) on an
-// ask still unanswered narrates it and arms it again.
-func (tb *tagBounds) ended(ctx context.Context, e jetstream.KeyValueEntry) {
-	if e.Operation() != jetstream.KeyValuePurge {
-		return
-	}
-	kv := tb.asks()
-	if kv == nil {
-		return
-	}
-	got, err := kv.Get(ctx, e.Key())
-	if err != nil {
-		return // the ask ended with its branch
-	}
-	t, err := versions.DecodeTagAsk(got.Value())
-	if err != nil || !t.Unanswered() {
-		return
-	}
-	var waits []versions.FloorWait
-	if tb.waits != nil {
-		waits = tb.waits()
-	}
-	line := versions.NarrateUnanswered(t, waits, tb.now())
-	tb.logf("%s", line)
-	// In the build log too (design 51 *Tagged versions*): under the builder's own key, no build being claimed yet, the
-	// ask's key standing for the fingerprint.
-	if tb.log != nil {
-		tb.log(delivery.BuildLogEntry{Event: delivery.BuildSaidEvent, Module: delivery.BuilderModule, FP: e.Key(), Commit: t.Head,
-			At: tb.now().UTC(), Line: line, Why: versions.SaidUnanswered})
-	}
-	tb.arm(ctx, e.Key())
-}
-
-// tagNumbered marks the tag ask of a check's build's head numbered with its versions in tag-asks, by compare-and-set.
-func tagNumbered(kv func() jetstream.KeyValue, logf func(string, ...any), now func() time.Time) func(context.Context, versions.BuildClaim, versions.Numbering) {
-	return func(ctx context.Context, c versions.BuildClaim, got versions.Numbering) {
-		store := kv()
-		if store == nil {
-			return
-		}
-		lister, err := store.ListKeysFiltered(ctx, versions.EscapeToken(c.Repository)+".>")
-		if err != nil {
-			logf("the tag ask of %s at %s is not marked numbered: %v", c.Repository, c.Head, err)
-			return
-		}
-		for key := range lister.Keys() {
-			for range 3 {
-				e, err := store.Get(ctx, key)
-				if err != nil {
-					break
-				}
-				t, err := versions.DecodeTagAsk(e.Value())
-				if err != nil {
-					break
-				}
-				t, changed := t.WithNumbered(c.Module, c.Head, got.Versions, got.Names, now())
-				if !changed {
-					break
-				}
-				data, err := json.Marshal(t)
-				if err != nil {
-					break
-				}
-				if _, err = store.Update(ctx, key, data, e.Revision()); err == nil {
-					logf("%s: tag ask of %s %s: %s", key, t.Repository, t.Branch, t.Answer)
-					break
-				}
-				if !errors.Is(err, jetstream.ErrKeyExists) && !errors.Is(err, jetstream.ErrKeyRevisionMismatch) {
-					logf("the tag ask %s is not marked numbered: %v", key, err)
-					break
-				}
-			}
-		}
-	}
-}

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/toolchains.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 	"sync"
 
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 	"git.novox.be/novox/mesh-sdk/go/process"
 
 	"github.com/nats-io/nats.go/jetstream"

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/versions.go

@@ -1,352 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/nats-io/nats.go"
-	"github.com/nats-io/nats.go/jetstream"
-
-	"git.novox.be/novox/mesh-contracts/go/seats/ociartifactregistry"
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-	"git.novox.be/novox/mesh-sdk/go/health"
-	"git.novox.be/novox/mesh-sdk/go/process"
-
-	"mesh-delivery-builder/internal/build"
-	"mesh-delivery-builder/internal/versions"
-)
-
-// The floor's two module tools (novox/hq design 51 *The floor*); the seat's is `seat:<registry>.versions`.
-const (
-	bridgeTagsTool   = "mesh-delivery-forge-bridge.bridge_tags"
-	requirementsTool = "mesh-delivery-indexer.indexer_requirements"
-)
-
-// awaitedVersions is the state versions as versions.Store: bound once the bus holds it (the grants part makes it, issue
-// 1790); until then every use is an error, so a trunk build is built unnumbered and said (build.Builder.number).
-type awaitedVersions struct{ b *process.AwaitedBucket }
-
-var errVersionsMissing = errors.New("the state " + versions.Bucket + " is not on the bus yet")
-
-func (s awaitedVersions) kv() (jetstream.KeyValue, error) {
-	if kv := s.b.KV(); kv != nil {
-		return kv, nil
-	}
-	return nil, errVersionsMissing
-}
-
-func (s awaitedVersions) Get(ctx context.Context, key string) ([]byte, uint64, bool, error) {
-	kv, err := s.kv()
-	if err != nil {
-		return nil, 0, false, err
-	}
-	e, err := kv.Get(ctx, key)
-	if errors.Is(err, jetstream.ErrKeyNotFound) {
-		return nil, 0, false, nil
-	}
-	if err != nil {
-		return nil, 0, false, err
-	}
-	return e.Value(), e.Revision(), true, nil
-}
-
-// indexerPackages is the indexer's packages state as the builder reads a package's name in its ecosystem from it (design
-// 32): the picture of its read tool's first view and its views family (ADR 0615 §1), never its bucket. Until the first
-// view is answered a package is built unnumbered and said (versions.Numberer.Names), and numbered once its name is heard
-// (followPackages).
-type indexerPackages struct{ kv jetstream.KeyValue }
-
-func (s indexerPackages) Keys(ctx context.Context) ([]string, error) {
-	keys, err := s.kv.Keys(ctx)
-	if errors.Is(err, jetstream.ErrNoKeysFound) {
-		return nil, nil
-	}
-	return keys, err
-}
-
-func (s indexerPackages) Get(ctx context.Context, key string) ([]byte, bool, error) {
-	e, err := s.kv.Get(ctx, key)
-	if errors.Is(err, jetstream.ErrKeyNotFound) || errors.Is(err, jetstream.ErrKeyDeleted) {
-		return nil, false, nil
-	}
-	if err != nil {
-		return nil, false, err
-	}
-	return e.Value(), true, nil
-}
-
-// followPackages watches the picture of the indexer's packages state: each series key heard that names a package's name
-// (versions.NamedModule), its first view's included, looks at its module again (build.Builder.PackageNamed), so a done
-// build that left the package unnumbered is numbered then with its digests. Woken by the views family, never a timer; a
-// key heard again naming the name and module it named (the indexer writes a series at each publish) looks at nothing.
-func followPackages(ctx context.Context, kv jetstream.KeyValue, b *build.Builder, logf func(string, ...any)) error {
-	w, err := kv.WatchAll(ctx)
-	if err != nil {
-		return err
-	}
-	heard := map[string]string{}
-	return follow(ctx, w, func(e jetstream.KeyValueEntry) {
-		if e.Operation() != jetstream.KeyValuePut {
-			delete(heard, e.Key())
-			return
-		}
-		module, name, named := versions.NamedModule(e.Key(), e.Value())
-		if named && heard[e.Key()] != module+" "+name {
-			heard[e.Key()] = module + " " + name
-			logf("%s.%s names a package of %s: its build is looked at again", delivery.PackagesBucket, e.Key(), module)
-			b.PackageNamed(ctx, module)
-		}
-	})
-}
-
-func versionsConflict(err error) error {
-	if errors.Is(err, jetstream.ErrKeyExists) || errors.Is(err, jetstream.ErrKeyRevisionMismatch) {
-		return versions.ErrConflict
-	}
-	return err
-}
-
-func (s awaitedVersions) Create(ctx context.Context, key string, value []byte) (uint64, error) {
-	kv, err := s.kv()
-	if err != nil {
-		return 0, err
-	}
-	rev, err := kv.Create(ctx, key, value)
-	return rev, versionsConflict(err)
-}
-
-func (s awaitedVersions) Update(ctx context.Context, key string, value []byte, revision uint64) (uint64, error) {
-	kv, err := s.kv()
-	if err != nil {
-		return 0, err
-	}
-	rev, err := kv.Update(ctx, key, value, revision)
-	return rev, versionsConflict(err)
-}
-
-func (s awaitedVersions) KeysOf(ctx context.Context, filter string) ([]string, error) {
-	kv, err := s.kv()
-	if err != nil {
-		return nil, err
-	}
-	l, err := kv.ListKeysFiltered(ctx, filter)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = l.Stop() }()
-	var out []string
-	for k := range l.Keys() {
-		out = append(out, k)
-	}
-	return out, nil
-}
-
-// floorVia is the floor's three sources as calls of the builder's own account (design 51 *The floor*): the seat's verb
-// versions, the forge bridge's bridge_tags and the indexer's indexer_requirements. A call that fails is that source
-// silent.
-func floorVia(call toolCaller) versions.FloorSources {
-	return versions.FloorSources{
-		Seat: func(_ context.Context, seat, name string) ([]string, error) {
-			raw, err := call("seat:"+seat+".versions", map[string]any{"name": name})
-			if err != nil {
-				return nil, err
-			}
-			var a struct {
-				Versions []struct {
-					Version string `json:"version"`
-				} `json:"versions"`
-			}
-			if err := json.Unmarshal(raw, &a); err != nil {
-				return nil, fmt.Errorf("%s's versions answered what is no list of versions: %w", seat, err)
-			}
-			var out []string
-			for _, v := range a.Versions {
-				if v.Version != "" {
-					out = append(out, v.Version)
-				}
-			}
-			return out, nil
-		},
-		Tags: func(_ context.Context, repository, prefix string) ([]string, error) {
-			raw, err := call(bridgeTagsTool, map[string]any{"repository": repository, "prefix": prefix})
-			if err != nil {
-				return nil, err
-			}
-			var a struct {
-				Tags []string `json:"tags"`
-			}
-			if err := json.Unmarshal(raw, &a); err != nil {
-				return nil, fmt.Errorf("bridge_tags answered what is no list of tags: %w", err)
-			}
-			return a.Tags, nil
-		},
-		Requirements: func(_ context.Context, name string) ([]string, error) {
-			raw, err := call(requirementsTool, map[string]any{"package": name})
-			if err != nil {
-				return nil, err
-			}
-			var a struct {
-				Requirements []string `json:"requirements"`
-			}
-			if err := json.Unmarshal(raw, &a); err != nil {
-				return nil, fmt.Errorf("indexer_requirements answered what is no list of versions: %w", err)
-			}
-			return a.Requirements, nil
-		},
-	}
-}
-
-// emitNumbered says the builder's event version.numbered (design 51 *Events of the builder*), on its own family apart
-// from its builds' ends; the name and version are the bus's dedup id.
-func emitNumbered(ctx context.Context, js jetstream.JetStream, cred process.Account, b delivery.VersionNumbered) error {
-	id := "numbered-" + versions.Key(b.Name, b.Version)
-	if b.Again != "" {
-		id += "-again-" + b.Again
-	}
-	if err := emitEvent(ctx, js, cred, delivery.VersionNumberedEvent, id, b); err != nil {
-		return fmt.Errorf("saying %s for %s@%s: %w", delivery.VersionNumberedEvent, b.Name, b.Version, err)
-	}
-	return nil
-}
-
-// emitEvent says one of the builder's events, mesh.mod.<module>.event.<event>, with the SDK's envelope headers and id as
-// the bus's dedup id.
-func emitEvent(ctx context.Context, js jetstream.JetStream, cred process.Account, event, id string, body any) error {
-	data, err := json.Marshal(body)
-	if err != nil {
-		return err
-	}
-	msg := nats.NewMsg(cred.EventSubject(event))
-	msg.Header.Set("x-event-id", id)
-	msg.Header.Set("x-source", cred.Module)
-	msg.Header.Set("x-node", cred.Node)
-	msg.Header.Set("x-time", time.Now().UTC().Format(time.RFC3339Nano))
-	msg.Header.Set("content-type", "application/json")
-	msg.Data = data
-	pub, cancel := context.WithTimeout(ctx, 10*time.Second)
-	defer cancel()
-	_, err = js.PublishMsg(pub, msg, jetstream.WithMsgID(id))
-	return err
-}
-
-// The events on the builder's consumer of EVENTS that wake a floor (design 51 *The floor*, DLV-B3b).
-var (
-	manifestAcceptedSubject = "mesh.mod." + delivery.IndexerModule + ".event." + delivery.ManifestAcceptedEvent
-	conditionClearedSubject = "mesh.mod." + health.KeeperModule + ".event." + health.EventCleared
-)
-
-// floorWake asks the floor of the names an event wakes again, by looking at every module again: a trunk build is
-// numbered before its claim (build.Builder.number).
-type floorWake struct {
-	b     *build.Builder
-	waits *versions.FloorWaits
-	logf  func(string, ...any)
-}
-
-// heard takes a message of the consumer in when it is one that wakes a floor, acknowledged, and answers whether it was.
-func (f *floorWake) heard(ctx context.Context, m jetstream.Msg) bool {
-	switch m.Subject() {
-	case manifestAcceptedSubject:
-		f.ack(m)
-		f.wake(ctx, versions.WakeAccepted, "", "")
-	case conditionClearedSubject:
-		f.ack(m)
-		var e health.Event
-		if err := json.Unmarshal(m.Data(), &e); err != nil {
-			f.logf("%s holds what is no condition, left: %v", m.Subject(), err)
-			return true
-		}
-		for _, module := range conditionModules(e.Subject.ID) {
-			f.wake(ctx, versions.WakeCleared, "", module)
-		}
-	default:
-		return false
-	}
-	return true
-}
-
-func (f *floorWake) ack(m jetstream.Msg) {
-	if err := m.Ack(); err != nil {
-		f.logf("acknowledging %s: %v", m.Subject(), err)
-	}
-}
-
-// wake looks at every module again when the event wakes a name, and says which.
-func (f *floorWake) wake(ctx context.Context, kind, seat, module string) {
-	names := f.waits.Wake(kind, seat, module, "")
-	if len(names) == 0 {
-		return
-	}
-	f.logf("the floor of %s is asked again: %s", strings.Join(names, ", "), kind)
-	f.b.Reconsider(ctx)
-}
-
-// conditionModules are the tokens of a condition's subject id (`<node>/<module>`, `<module>.<check>`): a module named
-// among them is the one whose condition cleared.
-func conditionModules(id string) []string {
-	return strings.FieldsFunc(id, func(r rune) bool { return r == '/' || r == '.' || r == ':' })
-}
-
-// doneVia says whether a build key is done, read from the builder's own builds state: the build's file is held.
-func doneVia(b *build.Builder) func(ctx context.Context, module, fp string) (bool, error) {
-	return func(ctx context.Context, module, fp string) (bool, error) {
-		key, err := delivery.BuilderBuildKey(module, fp)
-		if err != nil {
-			return false, err
-		}
-		raw, _, found, err := b.Claimer.Store.Get(ctx, key)
-		if err != nil || !found {
-			return false, err
-		}
-		cur, err := delivery.DecodeBuilderBuild(raw)
-		if err != nil {
-			return false, err
-		}
-		return cur.State == delivery.BuildDone, nil
-	}
-}
-
-// removeVia calls a registry seat's remove for one tagged version, as the builder's own account (design 51 *Tagged
-// versions*): the reason tag-gone; the seat says removed on its events, or answers kept when another tag names the
-// digest (the registry part's RemoveAnswer: kept, reason, tags), which ends the remove.
-func removeVia(call toolCaller) func(ctx context.Context, seat string, e versions.Entry) (versions.RemoveOutcome, error) {
-	return func(_ context.Context, seat string, e versions.Entry) (versions.RemoveOutcome, error) {
-		raw, err := call("seat:"+seat+".remove", map[string]any{"name": e.Name, "version": e.Version, "tag": e.Tag, "reason": "tag-gone"})
-		if err != nil {
-			return versions.RemoveOutcome{}, err
-		}
-		var a ociartifactregistry.RemoveAnswer // the four registry seats share the part's answer
-		if len(raw) > 0 && json.Unmarshal(raw, &a) != nil {
-			return versions.RemoveOutcome{}, fmt.Errorf("%s's remove answered what is no answer of it: %s", seat, raw)
-		}
-		return versions.RemoveOutcome{Kept: a.Kept, Reason: a.Reason, Tags: a.Tags}, nil
-	}
-}
-
-// tagAsked answers an unanswered value of tag-asks by compare-and-set at its revision, said in the log.
-func tagAsked(ctx context.Context, acts versions.Acts, kv jetstream.KeyValue, e jetstream.KeyValueEntry, logf func(string, ...any)) {
-	if e.Operation() != jetstream.KeyValuePut {
-		return
-	}
-	t, err := versions.DecodeTagAsk(e.Value())
-	if err != nil {
-		logf("%s.%s holds what is not a tag ask, left: %v", versions.TagAsksState, e.Key(), err)
-		return
-	}
-	if !t.Answered.IsZero() {
-		return
-	}
-	t = acts.TagAsked(ctx, t, time.Now())
-	logf("%s: %s of %s %s by %s (%s): %s", e.Key(), map[bool]string{true: "untag", false: "tag ask"}[t.Untag], t.Repository, t.Branch, t.By, t.Why, t.Answer)
-	data, err := json.Marshal(t)
-	if err != nil {
-		return
-	}
-	if _, err := kv.Update(ctx, e.Key(), data, e.Revision()); err != nil && !errors.Is(err, jetstream.ErrKeyExists) && !errors.Is(err, jetstream.ErrKeyRevisionMismatch) {
-		logf("%s.%s: the answer could not be written: %v", versions.TagAsksState, e.Key(), err)
-	}
-}

modules/mesh-delivery-builder/go.mod

@@ -3,44 +3,20 @@ module mesh-delivery-builder
 go 1.26.0
 
 require (
-	git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261104174359-05b3e2e1b94f
+	git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261102112556-abf5eace7791
 	github.com/nats-io/nats-server/v2 v2.11.17
 	github.com/nats-io/nats.go v1.54.0
 )
 
-require git.novox.be/novox/mesh-catalog/modules/mesh-build-go/buildstep v0.0.0-20261104174638-125929dbc459
-
 require (
-	git.novox.be/novox/mesh-contracts/go v0.0.0-20261104174344-ae5266e77639 // indirect
-	git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun v0.0.0-00010101000000-000000000000
-	github.com/antithesishq/antithesis-sdk-go v0.8.0-default-no-op // indirect
+	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.1 // 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.2 // 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/crypto v0.57.0 // indirect
 	golang.org/x/sys v0.48.0 // indirect
-	golang.org/x/time v0.16.0 // indirect
+	golang.org/x/time v0.15.0 // indirect
 )
-
-replace git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun => ./buildrun
-
-require (
-	git.novox.be/novox/mesh-contracts/go/seats/containerimageregistry v0.0.0-20261104174344-ae5266e77639
-	git.novox.be/novox/mesh-contracts/go/seats/gopackageregistry v0.0.0-20261104174344-ae5266e77639
-	git.novox.be/novox/mesh-contracts/go/seats/nodeengine v0.0.0-20261104174344-ae5266e77639
-	git.novox.be/novox/mesh-contracts/go/seats/npmpackageregistry v0.0.0-20261104174344-ae5266e77639
-	git.novox.be/novox/mesh-contracts/go/seats/ociartifactregistry v0.0.0-20261104174344-ae5266e77639
-	git.novox.be/novox/mesh-delivery/sdk v0.0.0-00010101000000-000000000000
-)
-
-require (
-	git.novox.be/novox/mesh-contracts/go/clients/containerimageregistryclient v0.0.0-20261104174344-ae5266e77639 // indirect
-	git.novox.be/novox/mesh-contracts/go/clients/gopackageregistryclient v0.0.0-20261104174344-ae5266e77639 // indirect
-	git.novox.be/novox/mesh-contracts/go/clients/npmpackageregistryclient v0.0.0-20261104174344-ae5266e77639 // indirect
-	git.novox.be/novox/mesh-contracts/go/clients/ociartifactregistryclient v0.0.0-20261104174344-ae5266e77639 // indirect
-)
-
-replace git.novox.be/novox/mesh-delivery/sdk => ../../sdk

modules/mesh-delivery-builder/go.sum

@@ -1,37 +1,15 @@
-git.novox.be/novox/mesh-catalog/modules/mesh-build-go/buildstep v0.0.0-20261104174638-125929dbc459 h1:DA4SFG/gKyG+aPJbfUpAUad2VeITIiKjJ6qOPmDhSA8=
-git.novox.be/novox/mesh-catalog/modules/mesh-build-go/buildstep v0.0.0-20261104174638-125929dbc459/go.mod h1:zR1HsAKZVbQsBIY5wPyrqI2WHInK268tITzGl2oqHro=
-git.novox.be/novox/mesh-contracts/go v0.0.0-20261104174344-ae5266e77639 h1:Zt7CfWt2S2W/fVgWNyW2u2+xwz051LXvGxVTNIyfhdM=
-git.novox.be/novox/mesh-contracts/go v0.0.0-20261104174344-ae5266e77639/go.mod h1:0dD1XEJBJ0G5UYDQxSZI84nuujb6m3tOpJl4C8rQVvg=
-git.novox.be/novox/mesh-contracts/go/clients/containerimageregistryclient v0.0.0-20261104174344-ae5266e77639 h1:I6uVDO9E+i3D9/n6KQ2RWYRs3kXYCqueiKXynifQo8w=
-git.novox.be/novox/mesh-contracts/go/clients/containerimageregistryclient v0.0.0-20261104174344-ae5266e77639/go.mod h1:ER2NVrd81uJo1lN0YCGA7OBxL910IHRgWYtxpsnHGF0=
-git.novox.be/novox/mesh-contracts/go/clients/gopackageregistryclient v0.0.0-20261104174344-ae5266e77639 h1:Rs5jOa7EWlpKuaH6+ExyGLN9k9UUi8N7upP9Ac3k+GY=
-git.novox.be/novox/mesh-contracts/go/clients/gopackageregistryclient v0.0.0-20261104174344-ae5266e77639/go.mod h1:fNfjFkP1+suYb12HJkapQe5W3cF98JsTcLBI/syoLHc=
-git.novox.be/novox/mesh-contracts/go/clients/npmpackageregistryclient v0.0.0-20261104174344-ae5266e77639 h1:VG+sZltyBIKrd9cwFJyKkInz04SxWBxUlJWfAuo6774=
-git.novox.be/novox/mesh-contracts/go/clients/npmpackageregistryclient v0.0.0-20261104174344-ae5266e77639/go.mod h1:Nq7glLZSZ8zOLTh1pXDnKZi+MxsMRyHw/bZODC3mvrY=
-git.novox.be/novox/mesh-contracts/go/clients/ociartifactregistryclient v0.0.0-20261104174344-ae5266e77639 h1:ROS9UG/Dg0NpsaDuEmDFV9CsIC1R92sOm3QauF7IvL0=
-git.novox.be/novox/mesh-contracts/go/clients/ociartifactregistryclient v0.0.0-20261104174344-ae5266e77639/go.mod h1:/Pke1v2VnSFcR8ic+fo/kNCg3JFYK6ILTal72Ca9520=
-git.novox.be/novox/mesh-contracts/go/seats/containerimageregistry v0.0.0-20261104174344-ae5266e77639 h1:5HeZzk6tKzcSwVivD3IcIvQ/2WIvysZvNvNKyq/oIBA=
-git.novox.be/novox/mesh-contracts/go/seats/containerimageregistry v0.0.0-20261104174344-ae5266e77639/go.mod h1:pPxwhTMb3hIk7UUrBicJnGQCqfTEoBGJvNFspEK2U18=
-git.novox.be/novox/mesh-contracts/go/seats/gopackageregistry v0.0.0-20261104174344-ae5266e77639 h1:oAXU1t8A1rGIr82JPBaNYSGLicXqhWglKaEAtPmrD0c=
-git.novox.be/novox/mesh-contracts/go/seats/gopackageregistry v0.0.0-20261104174344-ae5266e77639/go.mod h1:Y5kgBh0hBbL/hgc+abCF9Vbhov+vCsB0ckpRzUw1D+0=
-git.novox.be/novox/mesh-contracts/go/seats/nodeengine v0.0.0-20261104174344-ae5266e77639 h1:YQ6eJvc+RYUVIVf+oX+R4TC1dYL8TLLMZ0/JPDU1tp4=
-git.novox.be/novox/mesh-contracts/go/seats/nodeengine v0.0.0-20261104174344-ae5266e77639/go.mod h1:TB20TsQuOd5aer+cXL6PbaYyg2RvgL1R4MzD61Oks3A=
-git.novox.be/novox/mesh-contracts/go/seats/npmpackageregistry v0.0.0-20261104174344-ae5266e77639 h1:ILh7uctNwgx/89qHoR/H2kz5TpWeKEeIH0O2pDPE7Iw=
-git.novox.be/novox/mesh-contracts/go/seats/npmpackageregistry v0.0.0-20261104174344-ae5266e77639/go.mod h1:JRtTjIjMTkzn59IN4vCYei9ZwJGFnN1Puwame4V/sD0=
-git.novox.be/novox/mesh-contracts/go/seats/ociartifactregistry v0.0.0-20261104174344-ae5266e77639 h1:+bkN8op2yrAlBYrOB+hYnIoIZkbjXsNmc/4//uMnL4E=
-git.novox.be/novox/mesh-contracts/go/seats/ociartifactregistry v0.0.0-20261104174344-ae5266e77639/go.mod h1:ooQa2CiP8JOvhP0bdQvwurV5wskRE7Cm68ecURBbCwU=
-git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261104174359-05b3e2e1b94f h1:jDsfDMd48MXY9Zershc3eRxnhmx2sSpUfQkLq5jAIds=
-git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261104174359-05b3e2e1b94f/go.mod h1:08OomDXdwVN8/87nyDtv5R3rH/6LoP8SFFXz30bTYCM=
-github.com/antithesishq/antithesis-sdk-go v0.8.0-default-no-op h1:1BOWQJweNyvZMlpAHXGLiZQn9S+QXGcz3xh94lC0w6E=
-github.com/antithesishq/antithesis-sdk-go v0.8.0-default-no-op/go.mod h1:FQyySiasQQM8735Ddel3MRojmy4dA1IqCeyJ5jmPMbI=
+git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261102112556-abf5eace7791 h1:7SYIDPMxbPBr8dMB6k9fYsgVt4ZyWVL41q4LMFsfAvs=
+git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261102112556-abf5eace7791/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.1 h1:T7kKElXUMXrUJ2E9QhQhxFtcK5rPyLdsGZvdbLMPdiQ=
-github.com/klauspost/compress v1.20.1/go.mod h1:LUdAzn7YLVvxLpc7y3V1m40wESHTgc1422pwwBSKYuI=
+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.2 h1:XXRgB60MSTnqsRwejQurVDs/hcv2dkt+86GjI+I/bMc=
-github.com/nats-io/jwt/v2 v2.8.2/go.mod h1:Ag/56sq9OblL4JgdYufDd16Egb17Kr/8WwwuO/forVc=
+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=
@@ -45,5 +23,5 @@ golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZ
 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.16.0 h1:vMb6ptszcQMkcwiRTAuNNU50gom6++Q/6gY2hDM6VDE=
-golang.org/x/time v0.16.0/go.mod h1:rVKOqvZeKvrDKTQiAHJ7wmwP0RzleSphoEA9RcdLA0s=
+golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
+golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=

modules/mesh-delivery-builder/internal/build/askagain.go

@@ -11,9 +11,9 @@ import (
 	"strings"
 	"time"
 
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
 	"git.novox.be/novox/mesh-sdk/go/buildstep"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 )
 
 // **An ask that can no longer be answered is asked again** (novox/hq issue 1945). A build seat's stream gives an ask up
@@ -318,7 +318,7 @@ func (b *Builder) answer(ctx context.Context, l *lane, ask delivery.StepAsk, ask
 			// Not an asking: a node that sits out would use them all while it idles and pulls the ask again at once.
 			// Bounded by time from the first decline, then failed loudly naming the nodes and their reasons (as the
 			// checker's decline loop is, issue 890).
-			now := b.now()
+			now := time.Now()
 			if firstDecline.IsZero() {
 				firstDecline = now
 			}

modules/mesh-delivery-builder/internal/build/askfake_test.go

@@ -1,94 +0,0 @@
-package build
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"maps"
-	"strings"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// The build runner a build node runs an ask with is mesh-build-go's (novox/hq ADR 0593 §1), another repository's,
-// which the builder does not import. These tests run an ask as the builder needs it run: fetch once at the job's
-// fetch arguments with its package versions, build or copy each artifact, answer each one's digest and reference. They
-// test the builder, not the runner.
-
-// stepFunc is one step of a build module, as its tool answers it.
-type stepFunc func(ctx context.Context, args map[string]any) (any, error)
-
-// askSteps are a build module's steps an ask is run with.
-type askSteps struct{ Fetch, Build, Copy stepFunc }
-
-// runAsk runs a build ask with steps and answers its delivery.BuildAnswer, or the error that fails the step.
-func runAsk(ctx context.Context, steps askSteps, ask delivery.StepAsk) (any, error) {
-	if ask.Build == nil {
-		return nil, fmt.Errorf("the ask %s holds no build job", ask.ID)
-	}
-	job := *ask.Build
-	fetch := job.Fetch
-	if len(ask.Packages) > 0 && fetch != nil {
-		fetch = maps.Clone(fetch)
-		fetch["packages"] = maps.Clone(ask.Packages)
-	}
-	answer := delivery.BuildAnswer{}
-	workspace := ""
-	for _, a := range job.Artifacts {
-		var out any
-		var err error
-		if a.From != "" {
-			if steps.Copy == nil {
-				return nil, fmt.Errorf("this build module copies no artifact (%s)", a.Artifact)
-			}
-			out, err = steps.Copy(ctx, map[string]any{"module": job.Module, "artifact": a.Artifact, "from": a.From})
-		} else {
-			if workspace == "" {
-				raw, err := asRaw(steps.Fetch(ctx, fetch))
-				if err != nil {
-					return nil, err
-				}
-				var f struct {
-					Workspace string   `json:"workspace"`
-					Merge     string   `json:"merge"`
-					Conflicts []string `json:"conflicts"`
-				}
-				if err := json.Unmarshal(raw, &f); err != nil || f.Workspace == "" {
-					return nil, fmt.Errorf("the fetch answered no workspace: %s", raw)
-				}
-				if _, candidate := fetch["base"]; candidate && (len(f.Conflicts) > 0 || f.Merge == "") {
-					return nil, fmt.Errorf("the head does not merge into the trunk: %s", strings.Join(f.Conflicts, ", "))
-				}
-				workspace = f.Workspace
-			}
-			args := map[string]any{"workspace": workspace, "module": job.Path, "artifact": a.Artifact}
-			if job.Publish {
-				args["publish"] = true
-			}
-			out, err = steps.Build(ctx, args)
-		}
-		raw, err := asRaw(out, err)
-		if err != nil {
-			return nil, fmt.Errorf("%s: %w", a.Artifact, err)
-		}
-		var built struct {
-			Digest    string `json:"digest"`
-			Reference string `json:"reference"`
-		}
-		if err := json.Unmarshal(raw, &built); err != nil || built.Digest == "" {
-			return nil, fmt.Errorf("the build of %s answered no digest: %s", a.Artifact, raw)
-		}
-		answer.Artifacts = append(answer.Artifacts, delivery.AskBuilt{Artifact: a.Artifact, Digest: built.Digest, Reference: built.Reference})
-	}
-	return answer, nil
-}
-
-func asRaw(v any, err error) (json.RawMessage, error) {
-	if err != nil {
-		return nil, err
-	}
-	if r, ok := v.(json.RawMessage); ok {
-		return r, nil
-	}
-	return json.Marshal(v)
-}

modules/mesh-delivery-builder/internal/build/buildagain.go

@@ -7,8 +7,8 @@ import (
 	"strings"
 	"time"
 
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 )
 
 // **A failed key is built again by hand** (novox/hq issue 1126 note 72; ADR 0429 clause 18: "a fingerprint is built again

modules/mesh-delivery-builder/internal/build/candidates.go

@@ -5,8 +5,8 @@ import (
 	"fmt"
 	"sort"
 
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 )
 
 // How a candidate's fingerprint is built (novox/hq ADR 0484 clause 3, issue 1684): the indexer writes, for each module a

modules/mesh-delivery-builder/internal/build/claim.go

@@ -8,9 +8,9 @@ import (
 	"sort"
 	"strings"
 
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 )
 
 // ErrConflict is what a Store answers when a Create finds the key or an Update finds another revision than the one given.

modules/mesh-delivery-builder/internal/build/claim_test.go

@@ -114,11 +114,12 @@ func TestClaimCreatesTheKeyBuildingAndASecondBuilderGetsNothing(t *testing.T) {
 	if second, err := b.Claim(context.Background(), "m", fp1, hex64('a'), ClaimOptions{}); err != nil || second != nil {
 		t.Errorf("second builder's claim = %v, %v, want none: the same source is never built twice", second, err)
 	}
+}
 
-	// A claim losing the create race gets nothing (merged into this test for the test budget, design 51).
-	st = newMem()
+func TestClaimLosingTheCreateRaceGetsNothing(t *testing.T) { // 1607/AC3
+	st := newMem()
 	st.before = func() { seed(t, st, delivery.BuilderBuild{State: delivery.BuildBuilding, By: "novox.b"}) }
-	got, err = Claimer{Store: st, By: "novox.a"}.Claim(context.Background(), "m", fp1, "", ClaimOptions{})
+	got, err := Claimer{Store: st, By: "novox.a"}.Claim(context.Background(), "m", fp1, "", ClaimOptions{})
 	if err != nil || got != nil {
 		t.Errorf("claim = %v, %v, want none: the create failed because the key exists", got, err)
 	}
@@ -196,11 +197,12 @@ func TestFinishMovesTheKeyByCompareAndSetAndWritesOnlyADifferentValue(t *testing
 	if st.writes != writes {
 		t.Errorf("the same value was written again (%d writes, was %d)", st.writes, writes)
 	}
+}
 
-	// Finish after the key changed is a conflict, not an overwrite (merged into this test for the test budget).
-	st = newMem()
-	c = Claimer{Store: st, By: "novox.a"}
-	got, _ = c.Claim(context.Background(), "m", fp1, "", ClaimOptions{})
+func TestFinishAfterTheKeyChangedIsAConflictNotAnOverwrite(t *testing.T) { // 1607/AC3
+	st := newMem()
+	c := Claimer{Store: st, By: "novox.a"}
+	got, _ := c.Claim(context.Background(), "m", fp1, "", ClaimOptions{})
 	st.put(got.Key, []byte(`{"v":1,"state":"failed","error":"someone else"}`))
 	err := c.Finish(context.Background(), got, delivery.BuilderBuild{State: delivery.BuildFailed, Error: "mine"})
 	if !errors.Is(err, ErrConflict) {

modules/mesh-delivery-builder/internal/build/fixtures_test.go

@@ -29,7 +29,7 @@ func captured(t *testing.T, name string) json.RawMessage {
 	return step.Result
 }
 
-// The captured image steps, run as a pulled ask runs them (runAsk), answer what the builder reads: the trunk's
+// The captured image steps, run as a pulled ask runs them (buildstep.RunAsk), answer what the builder reads: the trunk's
 // build its digest and reference, a candidate's its digest and no reference (issue 1887 A4a).
 func TestCapturedImageStepsDecodeWithTheBuildersOwnTypes(t *testing.T) { // review r2, mesh-catalog 2; ADR 0487 clause 1
 	for _, tc := range []struct {
@@ -37,7 +37,7 @@ func TestCapturedImageStepsDecodeWithTheBuildersOwnTypes(t *testing.T) { // revi
 		publish bool
 		ref     bool
 	}{{"build-trunk.json", true, true}, {"build-candidate.json", false, false}} {
-		steps := askSteps{
+		steps := buildstep.AskSteps{
 			Fetch: func(context.Context, map[string]any) (any, error) {
 				return json.RawMessage(captured(t, "fetch.json")), nil
 			},
@@ -47,7 +47,7 @@ func TestCapturedImageStepsDecodeWithTheBuildersOwnTypes(t *testing.T) { // revi
 			At: time.Now(), Build: &delivery.BuildJob{Module: "m", Path: "modules/m", Publish: tc.publish,
 				Fetch:     map[string]any{"repository": "novox/mesh-catalog", "commit": strings.Repeat("a", 40)},
 				Artifacts: []delivery.AskArtifact{{Artifact: "server"}}}}
-		out, err := runAsk(context.Background(), steps, ask)
+		out, err := buildstep.RunAsk(context.Background(), steps, ask)
 		if err != nil {
 			t.Fatalf("%s: %v", tc.build, err)
 		}

modules/mesh-delivery-builder/internal/build/imports_test.go

@@ -1,78 +0,0 @@
-package build
-
-import (
-	"encoding/json"
-	"strings"
-	"sync"
-	"testing"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// ADR 0593 §2 (F3): the imports a Go build module answers at a build's end reach the done key and the log's end entry,
-// where the indexer keeps them on the module.
-func importsABuildAnswersReachTheDoneKeyAndTheLog(t *testing.T) {
-	r := newRig(t, goBundle)
-	imports := []string{"git.novox.be/novox/mesh-sdk/go", "git.novox.be/novox/mesh-sdk/go/announce"}
-	r.asks.Answer = func(a delivery.StepAsk) delivery.Step {
-		step := r.answer(a)
-		var answer map[string]any
-		if err := json.Unmarshal(step.Result, &answer); err == nil && a.Language == "go" {
-			answer["imports"] = imports
-			step.Result, _ = json.Marshal(answer)
-		}
-		return step
-	}
-	var logged []delivery.BuildLogEntry
-	var mu sync.Mutex
-	r.b.Node, r.b.Log = "novox", func(e delivery.BuildLogEntry) { mu.Lock(); logged = append(logged, e); mu.Unlock() }
-	v := r.consider(t, "modules/m")
-	if v.State != delivery.BuildDone || strings.Join(v.Imports, ",") != strings.Join(imports, ",") {
-		t.Fatalf("done key %+v, want the imports", v)
-	}
-	if len(logged) != 2 || strings.Join(logged[1].Imports, ",") != strings.Join(imports, ",") || len(logged[0].Imports) != 0 {
-		t.Fatalf("log %+v, want the imports on the end alone", logged)
-	}
-}
-
-// Design 26 (the lead's ruling on A2i's finding 2): the out-of-step files a contracts module's build module answers, in a
-// failed step's result too, reach the log's end entry, sorted and each once, where the indexer raises its finding; a
-// build that answers none names none.
-func outOfStepFilesABuildAnswersReachTheLog(t *testing.T) {
-	for _, row := range []struct {
-		name  string
-		fail  bool
-		files []string
-		want  string
-	}{
-		{"a passed build naming files", false, []string{"go/b.go", "go/a.go", "go/b.go"}, "go/a.go,go/b.go"},
-		{"a failed build naming files", true, []string{"ts/x.ts"}, "ts/x.ts"},
-		{"a build naming none", false, nil, ""},
-	} {
-		t.Run(row.name, func(t *testing.T) {
-			r := newRig(t, goBundle)
-			r.asks.Answer = func(a delivery.StepAsk) delivery.Step {
-				step := r.answer(a)
-				answer := map[string]any{}
-				_ = json.Unmarshal(step.Result, &answer)
-				if row.files != nil {
-					answer["out-of-step"] = row.files
-				}
-				step.Result, _ = json.Marshal(answer)
-				if row.fail {
-					step.State, step.Reason = delivery.StepFailed, "the generated files are out of step"
-				}
-				return step
-			}
-			var logged []delivery.BuildLogEntry
-			var mu sync.Mutex
-			r.b.Node, r.b.Log = "novox", func(e delivery.BuildLogEntry) { mu.Lock(); logged = append(logged, e); mu.Unlock() }
-			r.consider(t, "modules/m")
-			mu.Lock()
-			defer mu.Unlock()
-			if len(logged) != 2 || strings.Join(logged[1].OutOfStep, ",") != row.want || len(logged[0].OutOfStep) != 0 {
-				t.Fatalf("log %+v, want the end naming %q", logged, row.want)
-			}
-		})
-	}
-}

modules/mesh-delivery-builder/internal/build/numbers.go

@@ -1,140 +0,0 @@
-package build
-
-import (
-	"context"
-	"fmt"
-	"strconv"
-	"time"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-
-	"mesh-delivery-builder/internal/versions"
-)
-
-// Numbers numbers a trunk build at its claim (novox/hq design 51 *The versions*, ADR 0606, ADR 0617 §1) and records the
-// digests it was built with. Nil numbers nothing.
-type Numbers interface {
-	// tag is a check's build's tag (TagOf), empty for a trunk build; done the digests of its key when it is done already
-	// (versions.BuildClaim.Done), nil otherwise.
-	Number(ctx context.Context, module string, m delivery.Module, plan Plan, tag string, done map[string]string) (versions.Numbering, error)
-	Built(ctx context.Context, module string, m delivery.Module, plan Plan, got versions.Numbering, made []delivery.BuiltArtifact) error
-}
-
-// VersionNumbers is Numbers over the builder's state versions.
-type VersionNumbers struct {
-	N *versions.Numberer
-	// TagNumbered is told the versions a check's build of a tag ask's head was numbered (the ask is then marked numbered
-	// in tag-asks, design 51 *Tagged versions*); nil tells nobody.
-	TagNumbered func(ctx context.Context, c versions.BuildClaim, got versions.Numbering)
-}
-
-// ClaimOf is the claim a module value's trunk build is numbered by: a package per source revision (Src), the rest per
-// fingerprint, in merge order (Src).
-func ClaimOf(module string, m delivery.Module, plan Plan) versions.BuildClaim {
-	c := versions.BuildClaim{Module: module, Path: m.Path, Repository: delivery.RepositoryName(m.Repository), Fingerprint: m.FP2,
-		Commit: m.Commit, Merge: m.Src}
-	if m.Src != 0 {
-		c.Revision = strconv.FormatUint(m.Src, 10)
-	}
-	for _, t := range plan.Tasks {
-		c.Artifacts = append(c.Artifacts, versions.ClaimArtifact{Artifact: t.Artifact, Kind: t.Kind, Language: t.Language})
-	}
-	return c
-}
-
-func (v VersionNumbers) Number(ctx context.Context, module string, m delivery.Module, plan Plan, tag string, done map[string]string) (versions.Numbering, error) {
-	c := ClaimOf(module, m, plan)
-	c.Done = done
-	if tag != "" {
-		// A check's build of a head a tag ask names: its packages tagged, below the next version (design 51 *Tagged versions*).
-		c.Tag, c.Head, c.Revision, c.Merge = tag, m.Commit, "", 0
-	}
-	got, err := v.N.Number(ctx, c)
-	if err == nil && tag != "" && len(got.Versions) > 0 && v.TagNumbered != nil {
-		v.TagNumbered(ctx, c, got)
-	}
-	return got, err
-}
-
-func (v VersionNumbers) Built(ctx context.Context, module string, m delivery.Module, plan Plan, got versions.Numbering, made []delivery.BuiltArtifact) error {
-	digests := map[string]string{}
-	for _, a := range made {
-		digests[a.Name] = a.Digest
-	}
-	return v.N.Built(ctx, ClaimOf(module, m, plan), got, digests)
-}
-
-// TagOf answers the cleaned tag a kept tag ask names for a repository's head (the builder's state tag-asks, design 51
-// *Tagged versions*): a check's build of that head numbers its packages tagged at its claim.
-type TagOf func(ctx context.Context, repository, head string) (tag string, ok bool)
-
-// number numbers a build before its claim, a trunk build's artifacts or a check's build's packages under its tag: false
-// when it waits for its floor (a package, design 51 *The floor*), and then nothing is claimed; the floor's wake looks at
-// the module again.
-func (b *Builder) number(ctx context.Context, module string, m delivery.Module, plan Plan, tag string) (versions.Numbering, bool) {
-	if b.Numbers == nil {
-		return versions.Numbering{}, true
-	}
-	var done map[string]string
-	if tag == "" {
-		done = b.doneDigests(ctx, module, m.FP2)
-	}
-	got, err := b.Numbers.Number(ctx, module, m, plan, tag, done)
-	for _, s := range got.Said {
-		b.logf("%s at %s: %s", module, m.FP2, s.Line)
-		// And in the build log (design 51 *The versions*: it says a version was kept, and why), between the build's start and end.
-		// A look at a key already done builds nothing and has no start or end: a version kept there says nothing new, and is
-		// not logged (each later look, a first view answered or a name heard, would add one).
-		if b.Log != nil && !(done != nil && s.Why == versions.SaidKept) {
-			b.Log(delivery.BuildLogEntry{Event: delivery.BuildSaidEvent, Module: module, FP: m.FP2, Commit: m.Commit, Node: b.Node,
-				At: time.Now().UTC(), Line: s.Line, Why: s.Why})
-		}
-	}
-	if err != nil {
-		// Said, and built as before: an unnumbered build is published by its digest (ADR 0617 §1), numbered at its next look.
-		b.logf("%s at %s: %v", module, m.FP2, fmt.Errorf("not numbered, the versions cannot be used: %w", err))
-		return versions.Numbering{}, true
-	}
-	if got.Wait != "" {
-		b.logf("%s at %s is not built yet: %s", module, m.FP2, got.Wait)
-		return got, false
-	}
-	return got, true
-}
-
-// doneDigests are the digests of a trunk build's key by artifact when the key is done, nil otherwise or when it cannot be
-// read: a look at a done build numbers what it left unnumbered with them (versions.BuildClaim.Done).
-func (b *Builder) doneDigests(ctx context.Context, module, fp string) map[string]string {
-	key, err := delivery.BuilderBuildKey(module, fp)
-	if err != nil || b.Claimer.Store == nil {
-		return nil
-	}
-	raw, _, found, err := b.Claimer.Store.Get(ctx, key)
-	if err != nil || !found {
-		return nil
-	}
-	cur, err := delivery.DecodeBuilderBuild(raw)
-	if err != nil || cur.State != delivery.BuildDone {
-		return nil
-	}
-	out := map[string]string{}
-	for _, a := range cur.Artifacts {
-		if a.Digest != "" {
-			out[a.Name] = a.Digest
-		}
-	}
-	return out
-}
-
-// PackageNamed looks at a module again when the indexer's packages state names a name for one of its packages
-// (versions.NamedModule): a done trunk build that left the package unnumbered, its name not known at its claim, is
-// numbered then with the done build's digests, and version.numbered says them for its build module's late publish.
-func (b *Builder) PackageNamed(ctx context.Context, module string) {
-	b.init()
-	b.mu.Lock()
-	m, ok := b.known[module]
-	b.mu.Unlock()
-	if ok {
-		b.consider(ctx, module, m)
-	}
-}

modules/mesh-delivery-builder/internal/build/plan.go

@@ -8,9 +8,9 @@ import (
 	"sort"
 	"strings"
 
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 )
 
 // ImageBuildModule is the build module that builds an image artifact (novox/hq ADR 0487): buildah, rootless, on the nodes that

modules/mesh-delivery-builder/internal/build/plan_test.go

@@ -3,12 +3,11 @@ package build
 import (
 	"errors"
 
+	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 	"strings"
 	"testing"
 
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 )
 

modules/mesh-delivery-builder/internal/build/r4e_test.go

@@ -305,9 +305,10 @@ func TestTheFetchOfAModuleNamingItsPathsCarriesItsDirectoryAndThosePaths(t *test
 	r := newRig(t, tsPackage)
 	r.bm.packages["lib"] = "@novox/mesh-sdk@0.1.15"
 	paths := map[string]string{"src": hex40('1'), "package.json": hex40('2')}
-	// The named tree the indexer computes from those paths (its own, ADR 0593 §2), given as data: the builder reads it,
-	// never computes it.
-	const tree = delivery.NamedTreePrefix + "5b5e0f3b6f3c1f2a9d8e7c6b5a4938271605f4e3d2c1b0a9f8e7d6c5b4a39281"
+	tree, err := delivery.NamedTree(manifestD, paths)
+	if err != nil {
+		t.Fatal(err)
+	}
 	data, err := delivery.EncodeModule(delivery.Module{Repository: "novox/mesh-sdk", Commit: "7a74cee83f88e6585a5511c3cc53bdf0f5303d20", FP2: fp1, Manifest: manifestD, Path: ".",
 		Toolchains: agreedToolchains, Inputs2: &delivery.KeptInputs2{Tree: tree, Paths: paths}})
 	if err != nil {

modules/mesh-delivery-builder/internal/build/round4_test.go

@@ -2,10 +2,9 @@ package build
 
 import (
 	"context"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 	"testing"
 
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
-
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 )

modules/mesh-delivery-builder/internal/build/run.go

@@ -6,20 +6,16 @@ import (
 	"errors"
 	"fmt"
 	"maps"
-	"slices"
 	"sort"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
 
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
-	"git.novox.be/novox/mesh-delivery/sdk/forms"
 	"git.novox.be/novox/mesh-sdk/go/buildstep"
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
-
-	"mesh-delivery-builder/internal/versions"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 )
 
 // ToolchainEntries are the nodes' toolchain entries of a language (buildrun.ToolchainSet).
@@ -78,20 +74,9 @@ type Builder struct {
 	Said func(AskedAgain)
 	// Log is told each build's start and end, the entries of the builder's log (novox/hq ADR 0571 §1). Nil tells nobody.
 	Log func(delivery.BuildLogEntry)
-	// Now is the builder's clock: of the log, and of the decline bound (DeclineBound runs from the first decline); nil is
-	// time.Now. Node is the node the builder runs on, which asked the build.
+	// Now is the clock of the log; nil is time.Now. Node is the node the builder runs on, which asked the build.
 	Now  func() time.Time
 	Node string
-	// Numbers numbers each trunk build at its claim and records what it was built with (design 51 *The versions*); nil
-	// numbers nothing.
-	Numbers Numbers
-	// Tags answers a check's build's tag from the kept tag asks; nil numbers no check's build.
-	Tags TagOf
-	// Forms answers what each node's engine states it reads (ADR 0618 §2, ADR 0624 §1): present, the nodes whose engine
-	// answered when last asked, and counted, every node the placement names, present or away, a node with no statement
-	// stating nothing (the baseline's first forms). A done key names each artifact in the forms these keep, the oldest in
-	// its single reference, and its needs. Nil: no node states anything, and the first forms are kept.
-	Forms func() (present, counted map[string][]string)
 
 	once     sync.Once
 	sem      chan struct{}
@@ -103,10 +88,8 @@ type Builder struct {
 	plans    map[string]planned            // by manifest digest
 	cands    map[string]delivery.Candidate // by candidates key (candidates.go)
 	via      map[string]via                // by build key: a candidate's fetch (candidates.go)
-	// outOfStep are, by build key, the out-of-step files a build's lanes answered, until its end entry takes them.
-	outOfStep map[string][]string
-	trunkFP   map[string]bool // by build key: a trunk module value carries this fingerprint
-	tried     map[string]bool // by build key: looked at since this process started
+	trunkFP  map[string]bool               // by build key: a trunk module value carries this fingerprint
+	tried    map[string]bool               // by build key: looked at since this process started
 	// published are the package versions `<name>@<version>` a done key of this bucket names as a package's reference: a key
 	// waiting for one is built once it is here (ADR 0500 clause 6).
 	published map[string]bool
@@ -445,17 +428,6 @@ func (b *Builder) try(ctx context.Context, module string, m delivery.Module) {
 	first := !b.tried[key]
 	b.tried[key] = true
 	b.mu.Unlock()
-	var numbering versions.Numbering
-	tag := ""
-	if !trunk && b.Tags != nil && b.refOf(module, m.FP2) != "" {
-		tag, _ = b.Tags(ctx, delivery.RepositoryName(m.Repository), m.Commit)
-	}
-	if (trunk || tag != "") && planErr == nil && !nothing {
-		var goOn bool
-		if numbering, goOn = b.number(ctx, module, m, plan, tag); !goOn {
-			return
-		}
-	}
 	cl, err := b.Claimer.Claim(ctx, module, m.FP2, m.Manifest, ClaimOptions{TakeOver: first, ImageBuilder: imageSeat, Trunk: trunk, Published: b.isPublished,
 		Stored: b.storedOnce(key)})
 	if err != nil {
@@ -516,14 +488,7 @@ func (b *Builder) try(ctx context.Context, module string, m delivery.Module) {
 		b.logf("%s: the build could not be written: %v", cl.Key, err)
 		return
 	}
-	ended := LogEnded(module, m, b.refOf(module, m.FP2), b.Node, b.now(), result)
-	ended.OutOfStep = b.takeOutOfStep(key) // the generated files the build module's compare found out of step (design 26)
-	b.logBuild(ended)
-	if result.State == delivery.BuildDone && b.Numbers != nil && len(numbering.Versions) > 0 {
-		if err := b.Numbers.Built(ctx, module, m, plan, numbering, result.Artifacts); err != nil {
-			b.logf("%s: %v", cl.Key, err)
-		}
-	}
+	b.logBuild(LogEnded(module, m, b.refOf(module, m.FP2), b.Node, b.now(), result))
 	if result.State == delivery.BuildFailed {
 		b.logf("%s: failed: %s", cl.Key, result.Error)
 	}
@@ -568,8 +533,6 @@ type lane struct {
 	toolchain    *delivery.ToolchainUsed
 	digests      map[string]string // artifact -> digest
 	references   map[string]string // artifact -> the reference an image was pushed to (a trunk build only)
-	imports      []string          // the mesh packages the lane's programs import, as its build module answered them
-	outOfStep    []string          // the generated files its build module's compare found out of step, passed or failed
 	err          error
 }
 
@@ -625,9 +588,6 @@ func (b *Builder) build(ctx context.Context, module string, m delivery.Module, p
 		go func() { defer wg.Done(); b.runLane(ctx, l, repository, m, module, asked) }()
 	}
 	wg.Wait()
-	if key, err := delivery.BuilderBuildKey(module, m.FP2); err == nil {
-		b.keepOutOfStep(key, lanes)
-	}
 	var errs []string
 	for _, l := range lanes {
 		if l.err != nil {
@@ -643,10 +603,6 @@ func (b *Builder) build(ctx context.Context, module string, m delivery.Module, p
 		return failed("%s", keyError(errs))
 	}
 	var artifacts []delivery.BuiltArtifact
-	var present, counted map[string][]string
-	if b.Forms != nil {
-		present, counted = b.Forms()
-	}
 	keptModule := map[string]bool{}
 	for _, bm := range kept {
 		keptModule[bm] = true
@@ -675,7 +631,6 @@ func (b *Builder) build(ctx context.Context, module string, m delivery.Module, p
 			return failed("%s", err)
 		}
 		built := delivery.BuiltArtifact{Name: t.Artifact, Kind: t.Kind, Digest: d}
-		var answered []string
 		for _, l := range lanes {
 			if l.module != t.Module {
 				continue
@@ -687,11 +642,10 @@ func (b *Builder) build(ctx context.Context, module string, m delivery.Module, p
 				return failed("%s%s on %s: the build answered no reference, so its push to the artifact store was not answered", delivery.NotStored, t.Artifact, l.node)
 			}
 			if r != "" {
-				answered = append(answered, r)
+				built.Reference = r
 			}
 		}
-		// The forms a counted node's engine reads are kept, the oldest in the single reference (ADR 0624 §1, §3).
-		artifacts = append(artifacts, forms.Current.Choose(built, answered, present, counted))
+		artifacts = append(artifacts, built)
 	}
 	var steps []string
 	for _, l := range lanes {
@@ -712,8 +666,7 @@ func (b *Builder) build(ctx context.Context, module string, m delivery.Module, p
 	if len(used) == 0 {
 		used = nil
 	}
-	done := delivery.BuilderBuild{State: delivery.BuildDone, By: b.Claimer.By, Manifest: m.Manifest, Step: step, Artifacts: artifacts, Toolchains: used,
-		Imports: importsOf(lanes), Needs: forms.Current.Needs(artifacts)} // the forms it is written in (ADR 0618 §1)
+	done := delivery.BuilderBuild{State: delivery.BuildDone, By: b.Claimer.By, Manifest: m.Manifest, Step: step, Artifacts: artifacts, Toolchains: used}
 	if _, err := delivery.EncodeBuilderBuild(done); err != nil {
 		// A reference the build module answered that does not name the artifact and its digest is no reference.
 		return failed("%s%v", delivery.NotStored, err)
@@ -808,7 +761,7 @@ func (n *askNotes) note(ctx context.Context, language, id, step string) error {
 	n.mu.Lock()
 	defer n.mu.Unlock()
 	v := n.cl.Build
-	v.State, v.By, v.Step, v.Error, v.Artifacts, v.Needs = delivery.BuildBuilding, n.b.Claimer.By, step, "", nil, nil
+	v.State, v.By, v.Step, v.Error, v.Artifacts = delivery.BuildBuilding, n.b.Claimer.By, step, "", nil
 	v.Asks = maps.Clone(v.Asks)
 	if v.Asks == nil {
 		v.Asks = map[string]string{}
@@ -904,12 +857,6 @@ func (b *Builder) runLane(ctx context.Context, l *lane, repository string, m del
 		return
 	}
 	l.node = step.Node
-	// The build module's compare of a contracts module's generated files (design 26, CAT-BG5/BN2) answers the files out
-	// of step as delivery.BuildAnswer.OutOfStep, in a failed step's result too: read before the step's state is.
-	var compared delivery.BuildAnswer
-	if len(step.Result) > 0 && json.Unmarshal(step.Result, &compared) == nil {
-		l.outOfStep = compared.OutOfStep
-	}
 	if step.State != delivery.StepPassed {
 		l.err = fmt.Errorf("%s on %s: the ask %s %s: %s", l.module, step.Node, ask.ID, step.State, step.Reason)
 		return
@@ -919,7 +866,6 @@ func (b *Builder) runLane(ctx context.Context, l *lane, repository string, m del
 		l.err = fmt.Errorf("the ask of %s on %s answered what is not a build: %s", l.module, step.Node, step.Result)
 		return
 	}
-	l.imports = answer.Imports
 	built := map[string]delivery.AskBuilt{}
 	for _, a := range answer.Artifacts {
 		built[a.Artifact] = a
@@ -993,7 +939,7 @@ func LogStarted(module string, m delivery.Module, ref, by string, at time.Time)
 }
 
 // LogEnded is the log's entry of that build ending: the outcome (done, failed or queued), the manifest built, the bases it
-// was built against and each artifact made, as the done key has them: what the operator's command nox builds shows of a build.
+// was built against and each artifact made, as the done key has them: what mesh-catalog registers a build from.
 func LogEnded(module string, m delivery.Module, ref, by string, at time.Time, result delivery.BuilderBuild) delivery.BuildLogEntry {
 	e := LogStarted(module, m, ref, by, at)
 	e.Event, e.Outcome, e.Manifest = delivery.BuildEndedEvent, result.State, m.Manifest
@@ -1004,56 +950,9 @@ func LogEnded(module string, m delivery.Module, ref, by string, at time.Time, re
 		e.Against = append([]string(nil), m.Inputs2.Bases...)
 	}
 	e.Made = append([]delivery.BuiltArtifact(nil), result.Artifacts...)
-	e.Imports = append([]string(nil), result.Imports...) // the indexer keeps them on the module (novox/hq ADR 0593 §2)
 	return e
 }
 
-// keepOutOfStep holds, by build key, the out-of-step files the lanes' build modules answered, sorted and each once, until
-// the build's end entry takes them (takeOutOfStep); a build with none holds nothing.
-func (b *Builder) keepOutOfStep(key string, lanes []*lane) {
-	seen := map[string]bool{}
-	for _, l := range lanes {
-		for _, f := range l.outOfStep {
-			seen[f] = true
-		}
-	}
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	if len(seen) == 0 {
-		delete(b.outOfStep, key)
-		return
-	}
-	if b.outOfStep == nil {
-		b.outOfStep = map[string][]string{}
-	}
-	b.outOfStep[key] = slices.Sorted(maps.Keys(seen))
-}
-
-// takeOutOfStep answers the out-of-step files held for a build key and forgets them.
-func (b *Builder) takeOutOfStep(key string) []string {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	files := b.outOfStep[key]
-	delete(b.outOfStep, key)
-	return files
-}
-
-// importsOf are the mesh packages the lanes' programs import, as their build modules answered them (novox/hq ADR 0593
-// §2): sorted and each once; nil when none answered any. A lane kept from a prior build answered none, so a build that
-// kept one reports only what it built.
-func importsOf(lanes []*lane) []string {
-	seen := map[string]bool{}
-	for _, l := range lanes {
-		for _, p := range l.imports {
-			seen[p] = true
-		}
-	}
-	if len(seen) == 0 {
-		return nil
-	}
-	return slices.Sorted(maps.Keys(seen))
-}
-
 // SittingOutWords says, per node that is not on the agreed toolchain of a language, that it sits out and which version
 // it has against the agreed one: "ace sits out: typescript 26.12.1, agreed 26.13.0" (novox/hq ADR 0584 clause 2).
 func SittingOutWords(language string, a delivery.Agreement) []string {

modules/mesh-delivery-builder/internal/build/run_test.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
-	"slices"
 	"strconv"
 	"strings"
 	"sync"
@@ -14,13 +13,11 @@ import (
 	"testing"
 	"time"
 
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
-	"git.novox.be/novox/mesh-delivery/sdk/forms"
 	stdio "git.novox.be/novox/mesh-sdk/go"
+	"git.novox.be/novox/mesh-sdk/go/buildstep"
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
-
-	"mesh-delivery-builder/internal/versions"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 )
 
 // buildModules simulates the two build modules on the nodes: a long tool answers a step and key at once and writes the
@@ -143,7 +140,7 @@ type rig struct {
 // toolPrefix is the start of each build module's tool names, as the fake build modules answer them.
 var toolPrefix = map[string]string{buildrun.GoBuildModule: "build_go_", buildrun.NodeBuildModule: "build_node_", ImageBuildModule: "build_image_"}
 
-// answer runs an ask as the build module that pulls it does (runAsk), with the fake build modules' tools on the
+// answer runs an ask as the build module that pulls it does (buildstep.RunAsk), with the fake build modules' tools on the
 // rig's pulling node, and answers the step that node writes.
 func (r *rig) answer(a delivery.StepAsk) delivery.Step {
 	node := r.puller
@@ -152,7 +149,7 @@ func (r *rig) answer(a delivery.StepAsk) delivery.Step {
 	}
 	module, _ := delivery.BuildModuleOf(a.Language)
 	runner := buildrun.Runner{Caller: r.bm, Steps: r.bm.steps, Bound: time.Second}
-	tool := func(name string) stepFunc {
+	tool := func(name string) buildstep.StepFunc {
 		return func(ctx context.Context, args map[string]any) (any, error) {
 			raw, err := runner.Run(ctx, module, node, toolPrefix[module]+name, args)
 			if err != nil {
@@ -161,8 +158,8 @@ func (r *rig) answer(a delivery.StepAsk) delivery.Step {
 			return raw, nil
 		}
 	}
-	steps := askSteps{Fetch: tool("fetch"), Build: tool("build"), Copy: tool("copy")}
-	out, err := runAsk(context.Background(), steps, a)
+	steps := buildstep.AskSteps{Fetch: tool("fetch"), Build: tool("build"), Copy: tool("copy")}
+	out, err := buildstep.RunAsk(context.Background(), steps, a)
 	step := delivery.Step{ID: a.ID, Tool: a.Kind + " ask", Node: node, State: delivery.StepPassed}
 	if err != nil {
 		step.State, step.Reason = delivery.StepFailed, err.Error()
@@ -225,9 +222,6 @@ var (
 )
 
 func TestABundleAndAnArchiveAreBuiltOnOneNodeAndDone(t *testing.T) { // 1607/AC7, ADR 0478 clauses 1, 4
-	t.Run("the imports a build answers reach the done key and the log", importsABuildAnswersReachTheDoneKeyAndTheLog)
-	t.Run("the out-of-step files a build answers reach the log", outOfStepFilesABuildAnswersReachTheLog)
-	t.Run("ADR 0624: a done key keeps each form a counted node reads", aDoneKeyKeepsEachFormACountedNodeReads)
 	r := newRig(t, goBundle, archiveA, tsBundle)
 	// ADR 0584: a third node agrees with novox and ace's typescript is the odd one; the build is done and its step says ace sits out.
 	r.tools.Put(buildrun.NodeBuildModule, "g14.typescript", tcValue(t, "typescript", "tsc5"), false)
@@ -284,11 +278,6 @@ func TestABundleAndAnArchiveAreBuiltOnOneNodeAndDone(t *testing.T) { // 1607/AC7
 	if v.Artifacts[0].Kind != "archive" || v.Artifacts[1].Kind != "bundle" {
 		t.Errorf("kinds = %+v", v.Artifacts)
 	}
-	// ADR 0618 §1: the done key names the forms its references are written in, here the first form alone, and keeps no list
-	// beside the single reference while no counted node needs another form.
-	if !slices.Equal(v.Needs, []string{"form:artifact-store"}) || v.Artifacts[0].References != nil {
-		t.Errorf("needs = %v, references = %v", v.Needs, v.Artifacts[0].References)
-	}
 	if got := v.Toolchains["go"]; got.Version != "go1.27.1" || got.Recipe != "1" {
 		t.Errorf("toolchains = %+v, want go and typescript named", v.Toolchains)
 	}
@@ -329,7 +318,7 @@ func TestATrunkFingerprintIsOneAskOnTheDeliveryStream(t *testing.T) {
 	}
 	r.b.Module(context.Background(), "m", data)
 	var asks []delivery.StepAsk
-	for deadline := time.Now().Add(10 * time.Second); len(asks) == 0; time.Sleep(time.Millisecond) {
+	for deadline := time.Now().Add(2 * time.Second); len(asks) == 0; time.Sleep(time.Millisecond) {
 		if time.Now().After(deadline) {
 			t.Fatal("no ask was put")
 		}
@@ -429,19 +418,8 @@ func TestACandidatesImageCallCarriesNoPublishAndItsKeyNoReference(t *testing.T)
 	r := newRig(t, imageArt)
 	r.puller = "ace"
 	trunkModule(t, r)
-	// DLV-B6: a check's build of a head a kept tag ask names is numbered under that tag at its claim.
-	nums := &fakeNumbers{}
-	var tagAsked []string
-	r.b.Numbers = nums
-	r.b.Tags = func(_ context.Context, repository, head string) (string, bool) {
-		tagAsked = append(tagAsked, repository+"@"+head)
-		return "feat-x", head == headX
-	}
 	r.b.Candidate(context.Background(), "feat%2Fx", candidateValue(t, "feat/x", 7, headX))
 	r.b.Wait()
-	if !slices.Equal(nums.tags, []string{"feat-x"}) || len(tagAsked) != 1 || !strings.HasSuffix(tagAsked[0], "@"+headX) {
-		t.Errorf("the check's build numbered with tags %v (asked %v), want feat-x for its head", nums.tags, tagAsked)
-	}
 	v := valueOf(t, r.st, r.key)
 	if v.State != delivery.BuildDone || len(v.Artifacts) != 1 || v.Artifacts[0].Reference != "" {
 		t.Fatalf("build = %+v, want done with no reference", v)
@@ -455,69 +433,14 @@ func TestACandidatesImageCallCarriesNoPublishAndItsKeyNoReference(t *testing.T)
 	}
 }
 
-func TestATrunkImageCallCarriesPublish(t *testing.T) { // 1705b; design 51 *The versions*: numbered at the claim
+func TestATrunkImageCallCarriesPublish(t *testing.T) { // 1705b
 	r := newRig(t, imageArt)
 	r.puller = "ace"
-	nums := &fakeNumbers{wait: "m/img: the package waits for its floor"}
-	r.b.Numbers = nums
-	r.b.Module(context.Background(), "m", moduleValue(t, "modules/m"))
-	r.b.Wait()
-	if _, ok := r.st.vals[r.key]; ok || nums.numbered != 1 {
-		t.Fatalf("a build waiting for its floor was claimed (numbered %d times)", nums.numbered)
-	}
-	nums.wait, nums.versions = "", map[string]string{"img": "0.1.4"}
 	r.consider(t, "modules/m")
 	calls := r.bm.callsOf("build_image_build")
 	if len(calls) != 1 || calls[0].body.(map[string]any)["publish"] != true {
 		t.Errorf("calls = %+v, want publish true", calls)
 	}
-	if nums.built["img"] != digest {
-		t.Errorf("the built digest recorded = %v, want %s for img", nums.built, digest)
-	}
-	if nums.done != nil {
-		t.Errorf("a build still to make was numbered with done digests %v", nums.done)
-	}
-	// The indexer's packages state names a package of the module (PackageNamed): the done build is looked at again and
-	// numbered with its key's digests, so version.numbered carries them for the late publish; nothing is built again.
-	looks := nums.numbered
-	r.b.PackageNamed(context.Background(), "m")
-	r.b.Wait()
-	if nums.numbered != looks+1 || nums.done["img"] != digest || len(r.bm.callsOf("build_image_build")) != 1 {
-		t.Errorf("a named package's done build: numbered %d more times with %v, %d image builds; want once with img %s and no build",
-			nums.numbered-looks, nums.done, len(r.bm.callsOf("build_image_build")), digest)
-	}
-	r.b.PackageNamed(context.Background(), "other")
-	r.b.Wait()
-	if nums.numbered != looks+1 {
-		t.Errorf("a module the builder does not know was looked at")
-	}
-}
-
-// fakeNumbers is Numbers that answers what it is set to and keeps the digests a done build recorded.
-type fakeNumbers struct {
-	wait     string
-	versions map[string]string
-	numbered int
-	built    map[string]string
-	tags     []string
-	done     map[string]string // the done key's digests the last look numbered with
-}
-
-func (f *fakeNumbers) Number(_ context.Context, _ string, _ delivery.Module, _ Plan, tag string, done map[string]string) (versions.Numbering, error) {
-	f.tags = append(f.tags, tag)
-	f.done = done
-	f.numbered++
-	return versions.Numbering{Wait: f.wait, Versions: f.versions}, nil
-}
-
-func (f *fakeNumbers) Built(_ context.Context, _ string, _ delivery.Module, _ Plan, got versions.Numbering, made []delivery.BuiltArtifact) error {
-	f.built = map[string]string{}
-	for _, a := range made {
-		if got.Versions[a.Name] != "" {
-			f.built[a.Name] = a.Digest
-		}
-	}
-	return nil
 }
 
 func TestAnUnpinnedUpstreamFailsNotPinnedAndIsNeverBuiltAgain(t *testing.T) { // B3, ADR 0498 clause 4
@@ -642,7 +565,6 @@ func TestAKeyIsBuiltOnlyWithTheToolchainItsFingerprintNamesAndNothingIsWrittenOt
 	r.b.Module(context.Background(), "m", moduleValueWith(t, "modules/m", old))
 	r.b.Wait()
 	if len(r.st.vals) != 0 || len(r.bm.calls) != 0 {
-		t.Run("a recipe that moves builds the module again under its new fingerprint", aRecipeThatMovesBuildsTheModuleAgainUnderItsNewFingerprint)
 		t.Errorf("keys %v and %d calls for a fingerprint of go1.26.0 while the nodes agree on go1.27.1, want neither", r.st.vals, len(r.bm.calls))
 	}
 	// A recipe that differs is a different toolchain too, and a value that names none (written before) is not built.
@@ -667,45 +589,6 @@ func TestAKeyIsBuiltOnlyWithTheToolchainItsFingerprintNamesAndNothingIsWrittenOt
 	}
 }
 
-// ADR 0603 §3 (D9): a source revision changing the Go build module's recipe and a Go module builds the module at once with
-// the recipe the nodes run and again, a second key under the new fingerprint, once the agreement moves to the new recipe;
-// the first key is neither rebuilt nor waited on.
-func aRecipeThatMovesBuildsTheModuleAgainUnderItsNewFingerprint(t *testing.T) {
-	r := newRig(t, goBundle)
-	r.consider(t, "modules/m")
-	calls := len(r.bm.calls)
-	fp2 := "src2:" + hex64('2')
-	for _, n := range []string{"ace", "novox"} {
-		b, err := delivery.EncodeToolchain(delivery.Toolchain{Language: "go", Version: "go1.27.1", Recipe: "2", At: time.Now()})
-		if err != nil {
-			t.Fatal(err)
-		}
-		r.tools.Put(buildrun.GoBuildModule, n+".go", b, false)
-	}
-	r.b.Reconsider(context.Background())
-	r.b.Wait()
-	if len(r.bm.calls) != calls {
-		t.Errorf("%d calls, was %d: the first fingerprint was built again for the new recipe", len(r.bm.calls), calls)
-	}
-	data, err := delivery.EncodeModule(delivery.Module{Repository: "novox/mesh-catalog", Commit: "7a74cee83f88e6585a5511c3cc53bdf0f5303d20", FP: "src1:" + hex64('f'), FP2: fp2,
-		Manifest: mdigest('a'), Path: "modules/m", Toolchains: map[string]delivery.ToolchainUsed{"go": {Version: "go1.27.1", Recipe: "2"}}})
-	if err != nil {
-		t.Fatal(err)
-	}
-	r.b.Module(context.Background(), "m", data)
-	r.b.Wait()
-	second, err := delivery.BuilderBuildKey("m", fp2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if v := valueOf(t, r.st, second); v.State != delivery.BuildDone || v.Toolchains["go"].Recipe != "2" {
-		t.Errorf("second build = %+v, want done with recipe 2", v)
-	}
-	if v := valueOf(t, r.st, r.key); v.State != delivery.BuildDone {
-		t.Errorf("first build = %+v, want it left done", v)
-	}
-}
-
 func TestNodesTheyDisagreeOnLeaveTheKeyUnwritten(t *testing.T) { // 1615/AC4
 	r := newRig(t, goBundle)
 	r.tools.Put(buildrun.GoBuildModule, "ace.go", tcValue(t, "go", "go1.26.0"), false)
@@ -822,7 +705,7 @@ func (g *goneAsks) asked() int {
 // waitForAsks waits until n asks were put.
 func waitForAsks(t *testing.T, r *rig, n int) []delivery.StepAsk {
 	t.Helper()
-	for deadline := time.Now().Add(10 * time.Second); len(r.asks.Asks()) < n; time.Sleep(time.Millisecond) {
+	for deadline := time.Now().Add(2 * time.Second); len(r.asks.Asks()) < n; time.Sleep(time.Millisecond) {
 		if time.Now().After(deadline) {
 			t.Fatalf("%d asks put, want %d", len(r.asks.Asks()), n)
 		}
@@ -842,13 +725,7 @@ func TestABuildAskWaitingInItsStreamIsNotBounded(t *testing.T) {
 		r.b.Gone, r.b.CheckAfter = gone, 5*time.Millisecond
 		r.b.Module(context.Background(), "m", moduleValue(t, "modules/m"))
 		waitForAsks(t, r, 1)
-		// Five check bounds passed (five reads of whether it can be answered), so the ask waited past the step bound: an event
-		// to wait on, where a pause of 100 ms said nothing on a loaded machine.
-		for deadline := time.Now().Add(10 * time.Second); gone.asked() < 5; time.Sleep(time.Millisecond) {
-			if time.Now().After(deadline) {
-				t.Fatalf("whether the ask can still be answered was read %d times within 10 s, want 5", gone.asked())
-			}
-		}
+		time.Sleep(100 * time.Millisecond)
 		if v := valueOf(t, r.st, r.key); v.State != delivery.BuildBuilding {
 			t.Fatalf("the key = %+v while its ask waits, want building", v)
 		}
@@ -864,16 +741,11 @@ func TestABuildAskWaitingInItsStreamIsNotBounded(t *testing.T) {
 	t.Run("declined by a node off the agreed toolchain: put again, no asking used, the bound ends it loudly", func(t *testing.T) { // ADR 0584 clause 2
 		r := newRig(t, goBundle)
 		r.asks.Answer = nil
-		// The builder's clock steps a second at each read, so the bound of a minute ends the declines after many asks however
-		// slow the machine (a bound of 150 ms of wall clock let a loaded one put fewer than DefaultAskings).
-		var clock atomic.Int64
-		start := time.Now()
-		r.b.Now = func() time.Time { return start.Add(time.Duration(clock.Add(1)) * time.Second) }
-		r.b.DeclinePause, r.b.DeclineBound = -1, time.Minute
+		r.b.DeclinePause, r.b.DeclineBound = -1, 150*time.Millisecond
 		r.b.Module(context.Background(), "m", moduleValue(t, "modules/m"))
 		declined, _ := json.Marshal(delivery.StepDeclined{Declined: true, Lacks: []string{"the agreed toolchain go1.27.1 (recipe 1)"}})
 		waitForAsks(t, r, 1)
-		for ended, deadline := 0, time.Now().Add(20*time.Second); valueOf(t, r.st, r.key).State == delivery.BuildBuilding && time.Now().Before(deadline); time.Sleep(5 * time.Millisecond) {
+		for ended, deadline := 0, time.Now().Add(5*time.Second); valueOf(t, r.st, r.key).State == delivery.BuildBuilding && time.Now().Before(deadline); time.Sleep(5 * time.Millisecond) {
 			if asks := r.asks.Asks(); len(asks) > ended { // each ask put again is declined in its turn
 				r.asks.End(delivery.Step{ID: asks[ended].ID, Node: "ace", State: delivery.StepRefused, Reason: "this node builds with go1.26.0", Result: declined})
 				ended++
@@ -1054,7 +926,7 @@ func TestABuildAskWaitingInItsStreamIsNotBounded(t *testing.T) {
 			}
 			if c.byHand {
 				waitForAsks(t, r, 1)
-				for deadline := time.Now().Add(10 * time.Second); len(r.b.AskAgain(r.key, "stuck since 19:06")) == 0; time.Sleep(time.Millisecond) {
+				for deadline := time.Now().Add(2 * time.Second); len(r.b.AskAgain(r.key, "stuck since 19:06")) == 0; time.Sleep(time.Millisecond) {
 					if time.Now().After(deadline) {
 						t.Fatal("no lane of the key waits")
 					}
@@ -1062,7 +934,7 @@ func TestABuildAskWaitingInItsStreamIsNotBounded(t *testing.T) {
 			}
 			if c.deaf {
 				r.asks.End(r.answer(waitForAsks(t, r, 1)[0]))
-				for deadline := time.Now().Add(10 * time.Second); heard.Waiting() == 0; time.Sleep(time.Millisecond) {
+				for deadline := time.Now().Add(2 * time.Second); heard.Waiting() == 0; time.Sleep(time.Millisecond) {
 					if time.Now().After(deadline) {
 						t.Fatal("no ask is waited on")
 					}
@@ -1311,117 +1183,3 @@ type silentWatch struct{}
 func (silentWatch) WatchAsk(context.Context, string, string) (<-chan delivery.Step, error) {
 	return make(chan delivery.Step), nil
 }
-
-// aDoneKeyKeepsEachFormACountedNodeReads holds the builder's rows of ADR 0624's check: every build keeps each form a
-// counted node's engine reads, present or away, a node stating nothing reading the baseline's first form; the oldest kept
-// form is the single reference; a retired node leaves the count. old is the first form, new a fixture second form read
-// only by an engine stating form:new.
-func aDoneKeyKeepsEachFormACountedNodeReads(t *testing.T) {
-	fs := forms.ArtifactForms{
-		{Name: "old", First: true, Kinds: []string{"bundle"}, Is: func(r string) bool { return strings.HasPrefix(r, "artifact-store://") }},
-		{Name: "new", Kinds: []string{"bundle"}, Is: func(r string) bool { return strings.HasPrefix(r, "10.0.0.1:5000/") }},
-	}
-	both, nothing, onlyNew := []string{"form:new", "word:module"}, []string(nil), []string{"form:new"}
-	oldRef, newRef := "artifact-store://m/code/blobs/"+digest, "10.0.0.1:5000/m/code@"+digest
-	for _, row := range []struct {
-		name             string
-		present, counted map[string][]string
-		kept             []string
-		reference        string
-		references       []string
-	}{
-		{"A present {old,new}, B away {old}: both forms, the old in the single reference",
-			map[string][]string{"a": both}, map[string][]string{"a": both, "b": {"word:module"}}, []string{"old", "new"}, oldRef, []string{oldRef, newRef}},
-		{"A present {new}, B away stating nothing: the baseline's form stays",
-			map[string][]string{"a": onlyNew}, map[string][]string{"a": onlyNew, "b": nothing}, []string{"old", "new"}, oldRef, []string{oldRef, newRef}},
-		{"A present {old,new}, B away and never asked (no key): the baseline's form stays",
-			map[string][]string{"a": both}, map[string][]string{"a": both, "b": nil}, []string{"old", "new"}, oldRef, []string{oldRef, newRef}},
-		{"B retired: the new form only", map[string][]string{"a": both}, map[string][]string{"a": both}, []string{"new"}, newRef, nil},
-		{"B present stating nothing: the new form is not written",
-			map[string][]string{"a": both, "b": nothing}, map[string][]string{"a": both, "b": nothing}, []string{"old"}, oldRef, nil},
-		{"no node present: the first form", nil, map[string][]string{"a": both}, []string{"old"}, oldRef, nil},
-	} {
-		if got := fs.Kept("bundle", row.present, row.counted); !slices.Equal(got, row.kept) {
-			t.Errorf("%s: kept %v, want %v", row.name, got, row.kept)
-		}
-		a := fs.Choose(delivery.BuiltArtifact{Name: "code", Kind: "bundle", Digest: digest}, []string{newRef, oldRef}, row.present, row.counted)
-		if a.Reference != row.reference || !slices.Equal(a.References, row.references) {
-			t.Errorf("%s: %q %v, want %q %v", row.name, a.Reference, a.References, row.reference, row.references)
-		}
-		// An engine that predates the list reads the single reference, in a form every counted node reads (ADR 0624 §3).
-		if form, _ := fs.FormOf("bundle", a.Reference); form != row.kept[0] {
-			t.Errorf("%s: the single reference is in %q, want the oldest kept %q", row.name, form, row.kept[0])
-		}
-	}
-	// An answered reference no kept form names still names where the artifact is (ADR 0498 clause 1).
-	if a := fs.Choose(delivery.BuiltArtifact{Name: "code", Kind: "bundle", Digest: digest}, []string{oldRef}, map[string][]string{"a": both},
-		map[string][]string{"a": both}); a.Reference != oldRef {
-		t.Errorf("a lone answered reference was dropped: %+v", a)
-	}
-	withBoth := []delivery.BuiltArtifact{{Name: "code", Kind: "bundle", Digest: digest, Reference: oldRef, References: []string{oldRef, newRef}}}
-	if got := fs.Needs(withBoth); !slices.Equal(got, []string{"form:new", "form:old"}) {
-		t.Errorf("needs %v", got)
-	}
-	// The builder's own forms (forms.Current): a bundle a build step answers in the registry seat's form (mesh-build-go's
-	// oci-artifact-registry/<module>/<artifact>@<digest>) keeps the artifact-store form it derives for each counted node
-	// whose engine does not state form:seat-reference, that one in the single reference (ADR 0624 §1, §3).
-	seat := []string{forms.FormNeed(forms.FormSeatReference), "word:module"}
-	// Each kind the seat form names (a bundle through oci-artifact-registry, an image and an upstream copy through
-	// container-image-registry, the copy under the holder's own upstream/<host>/<path>), with the artifact-store form it derives.
-	for _, k := range []struct{ kind, seatRef, storeRef string }{
-		{"bundle", "oci-artifact-registry/m/code@" + digest, "artifact-store://m/code/blobs/" + digest},
-		{"image", "container-image-registry/m/code@" + digest, "artifact-store://m/code@" + digest},
-		{"upstream", "container-image-registry/upstream/quay.io:443/org/app@" + digest, "artifact-store://upstream/quay.io:443/org/app@" + digest},
-	} {
-		seatRef, storeRef := k.seatRef, k.storeRef
-		for _, row := range []struct {
-			name             string
-			present, counted map[string][]string
-			reference        string
-			references       []string
-			needs            []string
-		}{
-			{"seat form answered, B away stating nothing: the derived store form stays, in the single reference",
-				map[string][]string{"a": seat}, map[string][]string{"a": seat, "b": nil}, storeRef, []string{storeRef, seatRef},
-				[]string{"form:artifact-store", "form:seat-reference"}},
-			{"seat form answered, every counted engine reads it: the seat form only",
-				map[string][]string{"a": seat}, map[string][]string{"a": seat, "b": seat}, seatRef, nil, []string{"form:seat-reference"}},
-			{"seat form answered, a present engine stating nothing: the store form only",
-				map[string][]string{"a": seat, "b": nil}, map[string][]string{"a": seat, "b": nil}, storeRef, nil, []string{"form:artifact-store"}},
-			{"seat form answered, no node present: the store form", nil, map[string][]string{"a": seat}, storeRef, nil, []string{"form:artifact-store"}},
-		} {
-			a := forms.Current.Choose(delivery.BuiltArtifact{Name: "code", Kind: k.kind, Digest: digest}, []string{seatRef}, row.present, row.counted)
-			if a.Reference != row.reference || !slices.Equal(a.References, row.references) {
-				t.Errorf("%s %s: %q %v, want %q %v", k.kind, row.name, a.Reference, a.References, row.reference, row.references)
-			}
-			needs := forms.Current.Needs([]delivery.BuiltArtifact{a})
-			if !slices.Equal(needs, row.needs) {
-				t.Errorf("%s %s: needs %v, want %v", k.kind, row.name, needs, row.needs)
-			}
-			for node, stated := range row.counted {
-				if forms.Current.Held(needs, stated) {
-					t.Errorf("%s %s: the want of %s is held", k.kind, row.name, node)
-				}
-			}
-			if _, err := delivery.EncodeBuilderBuild(delivery.BuilderBuild{State: delivery.BuildDone, Manifest: strings.TrimPrefix(digest, "sha256:"), Artifacts: []delivery.BuiltArtifact{a}, Needs: needs}); err != nil {
-				t.Errorf("%s %s: %v", k.kind, row.name, err)
-			}
-		}
-	}
-	// What the assigner holds a want by (ADR 0624 §2), from the same forms.
-	for _, row := range []struct {
-		name   string
-		needs  []string
-		stated []string
-		held   bool
-	}{
-		{"a node stating {old}, a build carrying {old,new}: moves", []string{"form:new", "form:old"}, []string{"word:module"}, false},
-		{"a node stating nothing, a build carrying the baseline's form: moves", []string{"form:old"}, nil, false},
-		{"a build carrying {new} only, the node stating {old}: held", []string{"form:new"}, []string{"word:module"}, true},
-		{"a build naming no form: moves", nil, nil, false},
-	} {
-		if got := fs.Held(row.needs, row.stated); got != row.held {
-			t.Errorf("%s: held %v", row.name, got)
-		}
-	}
-}

modules/mesh-delivery-builder/internal/build/stuck.go

@@ -1,8 +1,6 @@
 package build
 
 import (
-	"mesh-delivery-builder/internal/versions"
-
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -13,8 +11,8 @@ import (
 	"sync/atomic"
 	"time"
 
-	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
+	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
 )
 
 // The builder's tools (novox/hq issue 1945; the instruction "tools are how a module is spoken to"): builder_stuck reads
@@ -56,67 +54,6 @@ type ReAsk struct {
 	Failed   string            `json:"failed,omitempty"`
 	Revision uint64            `json:"revision,omitempty"`
 	Asks     map[string]string `json:"asks,omitempty"`
-	// Name is the numbered name (`<module>/<artifact>`) of a ModePublishAgain or ModeFloorAgain value; Do and Version the
-	// builder's answer: what it did (versions.Again*) and the version published.
-	Name    string `json:"name,omitempty"`
-	Do      string `json:"do,omitempty"`
-	Version string `json:"version,omitempty"`
-}
-
-// ModePublishAgain is the Mode of a reasks value of builder_publish_again (design 51 *Tools of the builder*).
-const ModePublishAgain = "publish-again"
-
-// ModeFloorAgain is the Mode of a reasks value of builder_floor_again (design 51 *The floor*).
-const ModeFloorAgain = "floor-again"
-
-// NewPublishAgain is the value builder_publish_again writes for a name's fingerprint: the key of the name's module and
-// fingerprint, and the value.
-func NewPublishAgain(name, fp, why, by string, at time.Time) (string, []byte, error) {
-	module, artifact, ok := strings.Cut(strings.TrimSpace(name), "/")
-	if !ok || module == "" || artifact == "" {
-		return "", nil, fmt.Errorf("name %q is not a numbered name, <module>/<artifact>, as builder_versions lists it", name)
-	}
-	key, err := delivery.BuilderBuildKey(module, fp)
-	if err != nil {
-		return "", nil, err
-	}
-	if strings.TrimSpace(why) == "" {
-		return "", nil, errors.New("say why it is published again (why)")
-	}
-	data, err := json.Marshal(ReAsk{V: 1, Why: strings.TrimSpace(why), By: by, At: at.UTC(), Mode: ModePublishAgain, Module: module, FP: fp, Name: strings.TrimSpace(name)})
-	return key, data, err
-}
-
-// NewFloorAgain is the value builder_floor_again writes for a name: the key `floor.<name escaped>`, never a build key,
-// and the value.
-func NewFloorAgain(name, why, by string, at time.Time) (string, []byte, error) {
-	name = strings.TrimSpace(name)
-	if module, artifact, ok := strings.Cut(name, "/"); !ok || module == "" || artifact == "" {
-		return "", nil, fmt.Errorf("name %q is not a numbered name, <module>/<artifact>, as builder_versions lists it", name)
-	}
-	if strings.TrimSpace(why) == "" {
-		return "", nil, errors.New("say why the floor is asked again (why)")
-	}
-	data, err := json.Marshal(ReAsk{V: 1, Why: strings.TrimSpace(why), By: by, At: at.UTC(), Mode: ModeFloorAgain, Name: name})
-	return "floor." + versions.EscapeToken(name), data, err
-}
-
-// ModeOldFormDrop is the Mode of a reasks value of builder_old_form's drop (design 51 *Every build keeps the old
-// reference form*): a retired node dropped from the count by hand; Name is the node.
-const ModeOldFormDrop = "old-form-drop"
-
-// NewOldFormDrop is the value builder_old_form writes to drop a retired node: the key `old-form.<node>`, never a build
-// key, and the value.
-func NewOldFormDrop(node, why, by string, at time.Time) (string, []byte, error) {
-	node = strings.TrimSpace(node)
-	if node == "" || strings.ContainsAny(node, ". *>") {
-		return "", nil, fmt.Errorf("node %q is not a node's name", node)
-	}
-	if strings.TrimSpace(why) == "" {
-		return "", nil, errors.New("say why the node leaves the count (why)")
-	}
-	data, err := json.Marshal(ReAsk{V: 1, Why: strings.TrimSpace(why), By: by, At: at.UTC(), Mode: ModeOldFormDrop, Name: node})
-	return "old-form." + node, data, err
 }
 
 // ModeBuild is the Mode of a reasks value that asks the key to be built again, not its waiting asks to be asked again.

modules/mesh-delivery-builder/internal/versions/again.go

@@ -1,351 +0,0 @@
-package versions
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"sort"
-	"strings"
-	"time"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// What builder_publish_again does with one fingerprint of a name (design 51 *Tools of the builder*), after a holder failed.
-const (
-	// AgainPublish says version.numbered again for the recorded version: the build module publishes the held digest.
-	AgainPublish = "publish"
-	// AgainBuild builds the fingerprint again under the same number: the build's file is gone and no published was said
-	// for the number, so the new digest replaces the recorded one (Numberer.Built).
-	AgainBuild = "build"
-	// AgainRenumber takes a new number: a published was said for the number, so other bytes never go under it.
-	AgainRenumber = "renumber"
-)
-
-// Again is what builder_publish_again does, with the entry it acts on and why.
-type Again struct {
-	Do    string `json:"do"`
-	Entry Entry  `json:"entry"`
-	Why   string `json:"why"`
-}
-
-// PublishAgain decides builder_publish_again for fingerprint among a name's entries; built says whether the builder still
-// holds the build's file (its done key). It refuses a fingerprint not numbered, and a version refused for other bytes
-// than the ones recorded under it.
-func PublishAgain(entries []Entry, fingerprint string, built bool) (Again, error) {
-	fingerprint = strings.TrimSpace(fingerprint)
-	if fingerprint == "" {
-		return Again{}, errors.New("fp is required: the fingerprint whose version is published again")
-	}
-	for _, e := range latestFirst(entries) {
-		if e.Tag != "" || e.Fingerprint != fingerprint {
-			continue
-		}
-		switch {
-		case e.State == Refused && e.RefusedDigest != "" && e.Digest != "" && e.RefusedDigest != e.Digest:
-			return Again{}, fmt.Errorf("%s@%s was refused for other bytes (%s, recorded %s): it is not published again; a new build takes a new number",
-				e.Name, e.Version, e.RefusedDigest, e.Digest)
-		case e.State == Published || e.State == Removed:
-			return Again{Do: AgainRenumber, Entry: e, Why: fmt.Sprintf("%s@%s was %s, so the fingerprint takes a new number", e.Name, e.Version, e.State)}, nil
-		case !built:
-			return Again{Do: AgainBuild, Entry: e, Why: fmt.Sprintf("the build's file is gone and no published was said for %s@%s: built again under the same number", e.Name, e.Version)}, nil
-		}
-		return Again{Do: AgainPublish, Entry: e, Why: fmt.Sprintf("%s@%s (%s) is said numbered again, so its build module publishes the held digest", e.Name, e.Version, e.State)}, nil
-	}
-	return Again{}, fmt.Errorf("fingerprint %s is not numbered for this name: builder_versions lists what is", fingerprint)
-}
-
-// The builder's state of tag asks (design 51 *Tagged versions*): one key per repository and branch, removed when the
-// branch is merged or deleted or its pull request closed.
-const (
-	TagAsksState  = "tag-asks"
-	TagAsksBucket = "mesh-delivery-builder_tag-asks"
-)
-
-// The states of a tag ask.
-const (
-	TagAsked    = "asked"
-	TagNumbered = "numbered"
-	TagRemoving = "removing"
-	TagRemoved  = "removed"
-)
-
-// TagAsk is one value of tag-asks: an ask of a tagged version for a branch's head, from the checker's tag-wanted or by
-// hand (builder_tag), or by hand the removal of the branch's tagged versions (builder_untag, Untag).
-type TagAsk struct {
-	V          int       `json:"v"`
-	Repository string    `json:"repository"`
-	Branch     string    `json:"branch"`
-	Head       string    `json:"head,omitempty"`
-	Tag        string    `json:"tag"`
-	By         string    `json:"by,omitempty"`
-	Why        string    `json:"why,omitempty"`
-	At         time.Time `json:"at"`
-	Untag      bool      `json:"untag,omitempty"`
-	// State, Versions (name to version), Left (what a removal still waits on, name@version to its seat) and Answer are
-	// the builder's.
-	State    string            `json:"state,omitempty"`
-	Versions map[string]string `json:"versions,omitempty"`
-	Left     map[string]string `json:"left,omitempty"`
-	Answer   string            `json:"answer,omitempty"`
-	Answered time.Time         `json:"answered,omitzero"`
-}
-
-// TagAskKey is the key of a repository's branch in tag-asks.
-func TagAskKey(repository, branch string) string {
-	return EscapeToken(repository) + "." + EscapeToken(branch)
-}
-
-// NewTagAsk is the value builder_tag writes: its key and the value. The tag is the branch's, cleaned (CleanTag).
-func NewTagAsk(repository, branch, head, why, by string, at time.Time) (string, []byte, error) {
-	return newTagAsk(repository, branch, head, why, by, at, false)
-}
-
-// NewUntag is the value builder_untag writes: its key and the value.
-func NewUntag(repository, branch, why, by string, at time.Time) (string, []byte, error) {
-	return newTagAsk(repository, branch, "", why, by, at, true)
-}
-
-func newTagAsk(repository, branch, head, why, by string, at time.Time, untag bool) (string, []byte, error) {
-	repository, branch, head, why = strings.TrimSpace(repository), strings.TrimSpace(branch), strings.TrimSpace(head), strings.TrimSpace(why)
-	switch {
-	case repository == "" || !strings.Contains(repository, "/"):
-		return "", nil, errors.New("repository is required: <owner>/<name>")
-	case branch == "":
-		return "", nil, errors.New("branch is required")
-	case !untag && head == "":
-		return "", nil, errors.New("head is required: the commit the tagged version is built from")
-	case why == "":
-		return "", nil, errors.New("say why (why): a hand act is recorded")
-	}
-	data, err := json.Marshal(TagAsk{V: 1, Repository: repository, Branch: branch, Head: head, Tag: CleanTag(branch), By: by, Why: why,
-		At: at.UTC(), Untag: untag, State: TagAsked})
-	return TagAskKey(repository, branch), data, err
-}
-
-// DecodeTagAsk reads a tag-asks value.
-func DecodeTagAsk(data []byte) (TagAsk, error) {
-	var a TagAsk
-	if err := json.Unmarshal(data, &a); err != nil {
-		return a, err
-	}
-	if a.V != 1 {
-		return a, fmt.Errorf("a tag-asks value of version %d, not 1", a.V)
-	}
-	return a, nil
-}
-
-// TagAsksAnswer is what builder_tag_asks answers: the open asks, oldest first.
-type TagAsksAnswer struct {
-	Asks []TagAsk `json:"asks"`
-}
-
-// AnswerTagAsks is builder_tag_asks over the state read, only repository's when it is given.
-func AnswerTagAsks(r Reader, repository string) (TagAsksAnswer, error) {
-	keys, err := r.Keys()
-	if err != nil {
-		return TagAsksAnswer{}, fmt.Errorf("%s cannot be listed: %w", TagAsksState, err)
-	}
-	out := TagAsksAnswer{Asks: []TagAsk{}}
-	for _, k := range keys {
-		raw, ok, err := r.Get(k)
-		if err != nil {
-			return TagAsksAnswer{}, fmt.Errorf("%s.%s: %w", TagAsksState, k, err)
-		}
-		if !ok {
-			continue
-		}
-		a, err := DecodeTagAsk(raw)
-		if err != nil {
-			return TagAsksAnswer{}, fmt.Errorf("%s.%s holds what is not a tag ask: %w", TagAsksState, k, err)
-		}
-		if repository == "" || a.Repository == repository {
-			out.Asks = append(out.Asks, a)
-		}
-	}
-	sort.Slice(out.Asks, func(i, j int) bool { return out.Asks[i].At.Before(out.Asks[j].At) })
-	return out, nil
-}
-
-// Untagged are repository's tagged versions of tag that are not removed (a group's branch spans repositories, each
-// ending apart): what a branch's end, or builder_untag, removes through
-// each one's seat (design 51 *Tagged versions*). A version with no tag is never among them.
-func Untagged(entries []Entry, repository, tag string) []Entry {
-	tag = CleanTag(tag)
-	var out []Entry
-	for _, e := range entries {
-		if e.Tag != "" && e.Repository == repository && CleanTag(e.Tag) == tag && e.State != Removed && e.State != Kept {
-			out = append(out, e)
-		}
-	}
-	return InOrder(out)
-}
-
-// The tools' descriptions.
-const (
-	PublishAgainDescription = "Publish one fingerprint's version again after its holder failed (design 51): with the build's file held, the " +
-		"builder says version.numbered again and the build module publishes the held digest; with the file gone, it builds the fingerprint " +
-		"again under the same number, the new digest replacing the recorded one, since no published was said for it; after a published (or " +
-		"a removal) it takes a new number. It refuses a fingerprint not numbered and a version the holder refused for other bytes. A hand " +
-		"act, recorded with its caller and why in the builder's log."
-	FloorAgainDescription = "Ask the floor of one name again now, by hand (design 51 *The floor*): the seat's versions, the forge bridge's " +
-		"bridge_tags and the indexer's indexer_requirements, as the builder asks them by itself when a silent source says something. " +
-		"Answers which sources were silent and whether the floor is now known. A name the builder's versions already hold needs no floor: " +
-		"refused, saying so. A hand act."
-	TagDescription = "Ask a tagged version for a branch's head by hand, as the checker's tag-wanted asks it (design 51 *Tagged versions*): " +
-		"the builder keeps the ask in its state tag-asks until the branch is merged or deleted, or its pull request closed, and numbers " +
-		"each package the head builds below the next trunk version (0.1.15-<tag>.2). A hand act."
-	TagAsksDescription = "The open tag asks of the builder's state tag-asks, oldest first: repository, branch, head, tag, who asked and why, " +
-		"its state (asked, numbered, removing, removed), the versions numbered for it and, while its tagged versions are removed, the " +
-		"seats that have not yet said removed. With repository, that repository's only. Read-only."
-	UntagDescription = "Remove a branch's tagged versions by hand, as its merge, its pull request's close or its deletion does (design 51 " +
-		"*Tagged versions*): the builder calls each seat's remove with the reason tag-gone and marks each version removed once its seat says " +
-		"removed. Answers the versions it removes and the seats still waited on. A version with no tag is never removed. A hand act."
-)
-
-// Acts are the builder's hand acts on its versions, answered by its program (the tools bundle writes them to reasks).
-type Acts struct {
-	Numberer *Numberer
-	// Done says whether the build key of module and fingerprint is done: the build's file is held.
-	Done func(ctx context.Context, module, fp string) (bool, error)
-	// BuildAgain builds a failed key again (builder_build_again's path): its answer, or why it refused.
-	BuildAgain func(ctx context.Context, module, fp, why, by string) (answer string, refused bool)
-	// Reconsider looks at every module again, so a claim asks a name's floor.
-	Reconsider func(ctx context.Context)
-	// Remove calls a seat's verb remove for one tagged version, reason tag-gone: what it answered, kept or asked.
-	Remove func(ctx context.Context, seat string, e Entry) (RemoveOutcome, error)
-	// DropOldForm drops a retired node from the old form's count by hand (builder_old_form): its answer, or why not.
-	DropOldForm func(ctx context.Context, node, by, why string, at time.Time) (string, error)
-}
-
-// TagAsked answers one unanswered value of tag-asks. An untag calls remove on each of the branch's tagged versions'
-// seats and leaves each in Left until its seat says removed (Heard, on the seat's events); a call that fails stays in
-// Left with its error, asked again by the branch's end. A tag ask is kept: its versions are numbered when the head's
-// packages are claimed for the group's check.
-func (a Acts) TagAsked(ctx context.Context, t TagAsk, now time.Time) TagAsk {
-	t.Answered = now.UTC()
-	if !t.Untag {
-		t.State = TagAsked
-		t.Answer = "kept: each package the head builds is numbered " + "<next>-" + t.Tag + ".<n> when its build is claimed for the check"
-		return t
-	}
-	all, err := a.Numberer.Versions.All(ctx)
-	if err != nil {
-		t.Answer = "nothing removed: " + err.Error()
-		return t
-	}
-	t.Left, t.Versions = map[string]string{}, map[string]string{}
-	for _, e := range Untagged(all, t.Repository, t.Tag) {
-		t.Versions[e.Name] = e.Version
-		at := e.Name + "@" + e.Version
-		t.Left[at] = e.Seat
-		if left, ok := a.removeOne(ctx, e); ok {
-			delete(t.Left, at)
-		} else if left != "" {
-			t.Left[at] = left
-		}
-	}
-	if len(t.Left) == 0 {
-		t.State, t.Left, t.Answer = TagRemoved, nil, "the branch holds no tagged version: nothing to remove"
-		return t
-	}
-	t.State = TagRemoving
-	t.Answer = fmt.Sprintf("remove asked of %d tagged versions; each is marked removed when its seat says removed", len(t.Left))
-	return t
-}
-
-// removeOne asks e's seat to remove it: done when the seat kept it whole (recorded Kept, no retry); otherwise left, with
-// the error of a call that failed.
-func (a Acts) removeOne(ctx context.Context, e Entry) (left string, done bool) {
-	got, err := a.Remove(ctx, e.Seat, e)
-	if err != nil {
-		return e.Seat + ": " + err.Error(), false
-	}
-	if !got.Kept {
-		return "", false
-	}
-	if err := a.Numberer.keep(ctx, e, got.Reason, got.Tags); err != nil {
-		return e.Seat + ": kept, and not recorded so: " + err.Error(), false
-	}
-	return "", true
-}
-
-// PublishAgain is builder_publish_again of name's fingerprint: what it did, the version, and its answer; an error refuses.
-func (a Acts) PublishAgain(ctx context.Context, name, fp, why, by string, at time.Time) (Again, string, error) {
-	module, _, _ := strings.Cut(name, "/")
-	entries, err := a.Numberer.Versions.Of(ctx, name)
-	if err != nil {
-		return Again{}, "", err
-	}
-	done, err := a.Done(ctx, module, fp)
-	if err != nil {
-		return Again{}, "", fmt.Errorf("the build key of %s at %s cannot be read: %w", module, fp, err)
-	}
-	ag, err := PublishAgain(entries, fp, done)
-	if err != nil {
-		return Again{}, "", err
-	}
-	e := ag.Entry
-	if ag.Do == AgainRenumber {
-		_, ne, err := a.Numberer.Versions.Number(ctx, Claim{Name: e.Name, Kind: e.Kind, Series: e.Series, Module: e.Module, Fingerprint: e.Fingerprint,
-			Commit: e.Commit, Revision: e.Revision, Seat: e.Seat, Merge: e.Merge, Fresh: true})
-		if err != nil {
-			return Again{}, "", err
-		}
-		ag.Entry = ne
-	}
-	answer := ag.Why
-	if ag.Do == AgainBuild || (ag.Do == AgainRenumber && !done) {
-		said, refused := a.BuildAgain(ctx, module, fp, why, by)
-		if refused {
-			return Again{}, "", fmt.Errorf("%s; and the build again was refused: %s", ag.Why, said)
-		}
-		answer += "; " + said
-	}
-	if ag.Do == AgainPublish || (ag.Do == AgainRenumber && done) {
-		if a.Numberer.Said != nil {
-			b := NumberedOf(ag.Entry, "")
-			b.Again = at.UTC().Format(time.RFC3339Nano)
-			a.Numberer.Said(b)
-		}
-		answer += "; " + delivery.VersionNumberedEvent + " said for " + ag.Entry.Version
-	}
-	return ag, answer, nil
-}
-
-// FloorAgain is builder_floor_again of name: the floor counts only for a name the versions hold nothing of.
-func (a Acts) FloorAgain(ctx context.Context, name string) (string, error) {
-	entries, err := a.Numberer.Versions.Of(ctx, name)
-	if err != nil {
-		return "", err
-	}
-	if len(entries) > 0 {
-		return "", fmt.Errorf("%s holds %d versions: its floor counts only for its first number, so nothing is asked", name, len(entries))
-	}
-	answer := name + " waits on no floor in this builder: the floor is asked at its next claim"
-	if a.Numberer.Waits != nil {
-		for _, w := range a.Numberer.Waits.Waiting() {
-			if w.Name == name {
-				answer = fmt.Sprintf("the floor of %s is asked again (%s were silent)", name, strings.Join(w.Silent, ", "))
-			}
-		}
-		a.Numberer.Waits.Wake(WakeByHand, "", "", name)
-	}
-	a.Reconsider(ctx)
-	return answer + "; builder_versions shows its version once numbered", nil
-}
-
-// TagFor is the cleaned tag a kept tag ask names for repository's head: the ask a check's build of that head is
-// numbered under (design 51 *Tagged versions*). An untag, or an ask whose branch ended, names none.
-func TagFor(asks []TagAsk, repository, head string) (string, bool) {
-	for _, t := range asks {
-		if t.Untag || t.State == TagRemoving || t.State == TagRemoved || t.Head == "" {
-			continue
-		}
-		if t.Repository == repository && t.Head == head {
-			return t.Tag, t.Tag != ""
-		}
-	}
-	return "", false
-}

modules/mesh-delivery-builder/internal/versions/branchend.go

@@ -1,92 +0,0 @@
-package versions
-
-import (
-	"context"
-	"fmt"
-	"sort"
-	"strings"
-	"time"
-)
-
-// A branch's end removes its tagged versions (design 51 *Tagged versions*, DLV-B6): on the forge bridge's `merged`, a
-// pull's `closed` or `branch-deleted`, heard on the builder's durable consumer of the stream `forge`, the builder calls
-// each seat's `remove` and acknowledges the message only once every seat said `removed` (Heard marks the entry); until
-// then the bus gives it again each minute (RemoveAgainAfter) and, past RemovalFindingAfter, the builder's finding names
-// the seats still owing.
-const (
-	RemoveAgainAfter    = time.Minute
-	RemovalFindingAfter = 15 * time.Minute
-	// RemovalNotDone is the finding's kind.
-	RemovalNotDone = "tag-removal-not-done"
-)
-
-// BranchEnd is what one hearing of a branch's end did: the versions still not removed (name@version to its seat, with
-// the error of a remove that failed), and whether all are gone so the message is acknowledged.
-type BranchEnd struct {
-	Left map[string]string
-	Done bool
-}
-
-// Seats are the seats still owing a removal, sorted, each once.
-func (b BranchEnd) Seats() []string {
-	seen := map[string]bool{}
-	var out []string
-	for _, s := range b.Left {
-		seat, _, _ := strings.Cut(s, ":")
-		if !seen[seat] {
-			seen[seat] = true
-			out = append(out, seat)
-		}
-	}
-	sort.Strings(out)
-	return out
-}
-
-// Finding is the removal finding's words: what is left, since when.
-func (b BranchEnd) Finding(repository, branch string, since time.Time) string {
-	var at []string
-	for v, s := range b.Left {
-		at = append(at, v+" on "+s)
-	}
-	sort.Strings(at)
-	return fmt.Sprintf("the tagged versions of %s %s are not all removed since its end at %s: %s; the builder asks remove again each minute",
-		repository, branch, since.UTC().Format(time.RFC3339), strings.Join(at, ", "))
-}
-
-// BranchEnded removes repository's tagged versions of branch: every one not yet removed is asked of its seat again.
-// A store that cannot be read is the error: nothing is acknowledged then.
-func (a Acts) BranchEnded(ctx context.Context, repository, branch string) (BranchEnd, error) {
-	all, err := a.Numberer.Versions.All(ctx)
-	if err != nil {
-		return BranchEnd{}, err
-	}
-	left := map[string]string{}
-	for _, e := range Untagged(all, repository, branch) {
-		at := e.Name + "@" + e.Version
-		left[at] = e.Seat
-		if a.Remove == nil {
-			continue
-		}
-		// A seat that kept it whole (another tag names its digest) ends it here: recorded kept, never asked again.
-		if l, done := a.removeOne(ctx, e); done {
-			delete(left, at)
-		} else if l != "" {
-			left[at] = l
-		}
-	}
-	return BranchEnd{Left: left, Done: len(left) == 0}, nil
-}
-
-// TagWanted is the body of the checker's `tag-wanted` (design 51 *Tagged versions*): a group member's head to number
-// tagged versions for.
-type TagWanted struct {
-	Repository string `json:"repository"`
-	Branch     string `json:"branch"`
-	Head       string `json:"head"`
-	Tag        string `json:"tag,omitempty"`
-}
-
-// TagWantedAsk is the tag-asks value a tag-wanted becomes, as builder_tag writes it by hand: by the checker.
-func TagWantedAsk(t TagWanted, by string, at time.Time) (string, []byte, error) {
-	return NewTagAsk(t.Repository, t.Branch, t.Head, "the checker's tag-wanted for a group member's check", by, at)
-}

modules/mesh-delivery-builder/internal/versions/claim.go

@@ -1,263 +0,0 @@
-package versions
-
-import (
-	"context"
-	"fmt"
-	"sort"
-	"strings"
-	"time"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// The registry seats a version is published to (design 51 *The seats*), by what is published.
-const (
-	SeatImages     = "container-image-registry"
-	SeatArtifacts  = "oci-artifact-registry"
-	SeatGoPackages = "go-package-registry"
-	SeatNPM        = "npm-package-registry"
-)
-
-// SeatOf is the registry seat an artifact of kind in language is published to, and the kind the builder numbers it as;
-// ok is false for what is not numbered (an upstream copy is mirrored by its pinned digest, design 51 *Publishing*).
-func SeatOf(kind, language string) (seat, numberedAs string, ok bool) {
-	switch kind {
-	case KindImage:
-		return SeatImages, KindImage, true
-	case KindBundle, KindArchive:
-		return SeatArtifacts, kind, true
-	case KindPackage:
-		switch language {
-		case "go":
-			return SeatGoPackages, KindPackage, true
-		case "typescript", "javascript", "node":
-			return SeatNPM, KindPackage, true
-		}
-	}
-	return "", "", false
-}
-
-// NameOf is the name a module's image, bundle or archive is numbered under: `<module>/<artifact>`, the name the seat
-// answers it by (ADR 0605 §9's `<registry>/<module>/<artifact>@…`). A package is numbered under its name in its own
-// ecosystem instead (Numberer.Names).
-func NameOf(module, artifact string) string { return module + "/" + artifact }
-
-// PackageNames answers a package's name in its own ecosystem (design 32: a Go package's module path, an npm package's
-// package.json name) for the module and artifact it is built from, as the indexer's packages state holds it; known is
-// false when the state names none for it. An error is a state that cannot be read.
-type PackageNames func(ctx context.Context, module, artifact string) (name string, known bool, err error)
-
-// TagPrefix is the git tag prefix of a package in the module's directory path: `go/v` for mesh-sdk's `go`, `v` at the
-// root (design 51: the builder tags each Go version `go/v0.1.<n>`).
-func TagPrefix(path string) string {
-	path = strings.Trim(path, "/")
-	if path == "" || path == "." {
-		return "v"
-	}
-	return path + "/v"
-}
-
-// ClaimArtifact is one artifact of a trunk build to number.
-type ClaimArtifact struct {
-	Artifact, Kind, Language string
-}
-
-// BuildClaim is a trunk build at its claim: what Numberer.Number numbers.
-type BuildClaim struct {
-	Module, Path, Repository, Fingerprint, Commit, Series string
-	// Revision is the source revision of the merge (a package is numbered per revision); Merge its sequence, for order.
-	Revision  string
-	Merge     uint64
-	Artifacts []ClaimArtifact
-	// Tag numbers a check's build of a head a tag ask names (design 51 *Tagged versions*): its packages only, each a
-	// tagged version kept with Repository for its branch's end; Head is the head, said in numbered. Empty for a trunk build.
-	Tag, Head string
-	// Done are the digests of the build's done key, by artifact, when the claim is a look at a build already done: what it
-	// left unnumbered (a package whose name was not known yet, a floor that was silent) is numbered with them, so
-	// version.numbered carries the digest its build module publishes late. Nil for a build still to make.
-	Done map[string]string
-}
-
-// Numbering is what the claim got.
-type Numbering struct {
-	// Versions are each artifact's version, by artifact; an artifact built unnumbered (its floor not known) has none.
-	Versions map[string]string
-	// Unnumbered are the artifacts built and published by digest, numbered once their floor answers (ADR 0617 §1).
-	Unnumbered []string
-	// Wait is why the build waits: a package whose floor is not known (design 51 *The floor*). Nothing is claimed.
-	Wait string
-	// Said are the builder's narrations of each decision, for its process log and its build log (build.said).
-	Said []Narration
-	// Names are the names each numbered artifact was numbered under, by artifact (NameOf, or a package's name in its
-	// ecosystem).
-	Names map[string]string
-}
-
-// NameOf is the name artifact of module was numbered under in this numbering.
-func (g Numbering) NameOf(module, artifact string) string {
-	if name := g.Names[artifact]; name != "" {
-		return name
-	}
-	return NameOf(module, artifact)
-}
-
-// Narration is one line the builder says in its build log (design 51: the build log says a version was kept, and
-// why), and what it narrates.
-type Narration struct{ Line, Why string }
-
-// What a narration of the build log narrates (the build.said entry's why).
-const (
-	SaidNumbered      = "numbered"
-	SaidKept          = "kept"
-	SaidWaiting       = "waiting"
-	SaidUnnumbered    = "unnumbered"
-	SaidUnanswered    = "tag ask unanswered"
-	SaidOldFormClosed = "old-form-closed"
-)
-
-// narrationOf is a decision's narration.
-func narrationOf(name string, d Decision) Narration {
-	why := SaidNumbered
-	switch {
-	case d.Keep:
-		why = SaidKept
-	case d.Wait:
-		why = SaidWaiting
-	case d.Unnumbered:
-		why = SaidUnnumbered
-	}
-	return Narration{Line: name + ": " + d.Why, Why: why}
-}
-
-// Numberer numbers trunk builds at their claim (design 51 *The versions*, DLV-B2, B3): it asks a name's floor only
-// when versions holds nothing for it, records a silent floor as a wait (FloorWaits, woken by its source's event), and
-// says each new number (Said, the event version.numbered).
-type Numberer struct {
-	Versions Versions
-	Floor    FloorSources
-	Waits    *FloorWaits
-	// Holder is the module holding a seat, whose health condition's clear wakes a silent seat source; nil names none.
-	Holder func(seat string) string
-	// Said is told each version newly numbered; nil tells nobody.
-	Said func(delivery.VersionNumbered)
-	// Names answers a package's name in its ecosystem; nil numbers a package as NameOf names it.
-	Names PackageNames
-	// Publishing is told each version Built recorded that is still numbered, its holder's word not heard yet: the
-	// builder arms its publish bound (publish.go); nil arms none.
-	Publishing func(ctx context.Context, e Entry)
-	Now        func() time.Time
-}
-
-// Number numbers every numbered artifact of c. An error is a store that cannot be read or written: the claim is then
-// built as before, unnumbered, and said.
-func (n *Numberer) Number(ctx context.Context, c BuildClaim) (Numbering, error) {
-	out := Numbering{Versions: map[string]string{}, Names: map[string]string{}}
-	arts := append([]ClaimArtifact(nil), c.Artifacts...)
-	sort.Slice(arts, func(i, j int) bool { return arts[i].Artifact < arts[j].Artifact })
-	for _, a := range arts {
-		seat, kind, ok := SeatOf(a.Kind, a.Language)
-		if !ok || (c.Tag != "" && kind != KindPackage) {
-			continue
-		}
-		name := NameOf(c.Module, a.Artifact)
-		if kind == KindPackage && n.Names != nil {
-			// A package is numbered, asked for its floor and published under its name in its ecosystem (design 32), the
-			// name the holder's builder_versions question and the seat's versions name it by.
-			named, known, err := n.Names(ctx, c.Module, a.Artifact)
-			if err != nil || !known {
-				why := "the indexer's packages state names no name of it in its ecosystem yet (it writes one at the module's next trunk merge)"
-				if err != nil {
-					why = "the indexer's packages state cannot be read: " + err.Error()
-				}
-				out.Unnumbered = append(out.Unnumbered, a.Artifact)
-				out.Said = append(out.Said, Narration{Line: name + ": built unnumbered: " + why, Why: SaidUnnumbered})
-				continue
-			}
-			name = named
-		}
-		out.Names[a.Artifact] = name
-		entries, err := n.Versions.Of(ctx, name)
-		if err != nil {
-			return out, err
-		}
-		var floor Floor
-		var why map[string]string
-		if len(entries) == 0 {
-			floor, why = n.askFloor(ctx, seat, name, c)
-		}
-		d, e, err := n.Versions.Number(ctx, Claim{Name: name, Kind: kind, Series: c.Series, Module: c.Module, Fingerprint: c.Fingerprint,
-			Commit: c.Commit, Revision: c.Revision, Digest: c.Done[a.Artifact], Seat: seat, Merge: c.Merge, Floor: floor, Tag: c.Tag, Repository: c.Repository})
-		if err != nil {
-			return out, err
-		}
-		out.Said = append(out.Said, narrationOf(name, d))
-		switch {
-		case d.Wait:
-			n.wait(name, seat, floor, why)
-			out.Wait = name + ": " + d.Why
-			return out, nil
-		case d.Unnumbered:
-			n.wait(name, seat, floor, why)
-			out.Unnumbered = append(out.Unnumbered, a.Artifact)
-			continue
-		}
-		if n.Waits != nil {
-			n.Waits.Answered(name)
-		}
-		out.Versions[a.Artifact] = d.Version
-		if !d.Keep && n.Said != nil {
-			n.Said(NumberedOf(e, c.Head))
-		}
-	}
-	return out, nil
-}
-
-func (n *Numberer) askFloor(ctx context.Context, seat, name string, c BuildClaim) (Floor, map[string]string) {
-	return n.Floor.Ask(ctx, FloorOf{Seat: seat, Name: name, Repository: c.Repository, Prefix: TagPrefix(c.Path)})
-}
-
-func (n *Numberer) wait(name, seat string, f Floor, why map[string]string) {
-	if n.Waits == nil {
-		return
-	}
-	holder := ""
-	if n.Holder != nil {
-		holder = n.Holder(seat)
-	}
-	now := time.Now()
-	if n.Now != nil {
-		now = n.Now()
-	}
-	n.Waits.Wait(name, seat, holder, f, why, now)
-}
-
-// Built records the digest each numbered artifact was built with, on an entry that holds none yet or was never published: what the holder's
-// builder_versions question compares (ADR 0605 §4).
-func (n *Numberer) Built(ctx context.Context, c BuildClaim, got Numbering, digests map[string]string) error {
-	var errs []string
-	for artifact, version := range got.Versions {
-		d := digests[artifact]
-		if d == "" {
-			continue
-		}
-		e, err := n.Versions.Mark(ctx, got.NameOf(c.Module, artifact), version, func(e *Entry) {
-			// The new digest replaces the recorded one only while no published was said for the number (design 51
-			// *Tools of the builder*): a rebuild of a gone file under the same number.
-			if e.Digest == "" || e.State == Numbered || e.State == Refused {
-				e.Digest = d
-			}
-		})
-		if err != nil {
-			errs = append(errs, err.Error())
-			continue
-		}
-		if e.State == Numbered && n.Publishing != nil {
-			n.Publishing(ctx, e)
-		}
-	}
-	if len(errs) > 0 {
-		sort.Strings(errs)
-		return fmt.Errorf("the built digests could not be recorded: %s", strings.Join(errs, "; "))
-	}
-	return nil
-}

modules/mesh-delivery-builder/internal/versions/floor.go

@@ -1,319 +0,0 @@
-package versions
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"slices"
-	"sort"
-	"strings"
-	"sync"
-	"time"
-)
-
-// FloorSources are the three sources of a name's floor (design 51 *The floor*): each a tool call that answers the
-// versions it knows of a name, or an error when it does not answer.
-type FloorSources struct {
-	// Seat is `seat:<registry>.versions` of the registry seat the name is published to.
-	Seat func(ctx context.Context, seat, name string) ([]string, error)
-	// Tags is the forge bridge's bridge_tags: the git tags of the repository the name is built from, under prefix.
-	Tags func(ctx context.Context, repository, prefix string) ([]string, error)
-	// Requirements is the indexer's indexer_requirements: the highest pseudo-versions consumers require.
-	Requirements func(ctx context.Context, name string) ([]string, error)
-}
-
-// FloorOf names what a floor is asked for: the name on its seat, and the repository and tag prefix of its git tags.
-type FloorOf struct{ Seat, Name, Repository, Prefix string }
-
-// Ask asks the three sources of a name; a source that errs, or is not wired, is named in Silent with its error in why.
-func (s FloorSources) Ask(ctx context.Context, of FloorOf) (Floor, map[string]string) {
-	seat, name := of.Seat, of.Name
-	var f Floor
-	why := map[string]string{}
-	ask := func(source string, call func() ([]string, error), into *[]string) {
-		if call == nil {
-			f.Silent, why[source] = append(f.Silent, source), "not asked: the builder has no path to it"
-			return
-		}
-		got, err := call()
-		if err != nil {
-			f.Silent, why[source] = append(f.Silent, source), err.Error()
-			return
-		}
-		*into = got
-	}
-	var seatCall, tagsCall, reqCall func() ([]string, error)
-	if s.Seat != nil {
-		seatCall = func() ([]string, error) { return s.Seat(ctx, seat, name) }
-	}
-	if s.Tags != nil {
-		tagsCall = func() ([]string, error) { return s.Tags(ctx, of.Repository, of.Prefix) }
-	}
-	if s.Requirements != nil {
-		reqCall = func() ([]string, error) { return s.Requirements(ctx, name) }
-	}
-	ask(SourceSeat, seatCall, &f.Seat)
-	ask(SourceTags, tagsCall, &f.Tags)
-	ask(SourceRequirements, reqCall, &f.Requirements)
-	return f, why
-}
-
-// What wakes a name waiting on its floor, never a timer (design 51, DLV-B3b): the source that was silent saying
-// something, or its module's health condition clearing.
-const (
-	// WakePublished is the holder's `published` on the builder's durable consumer of `<seat>.events`.
-	WakePublished = "published"
-	// WakeForge is the forge bridge's next message on its stream `forge`.
-	WakeForge = "forge"
-	// WakeAccepted is the indexer's next `manifest-accepted`.
-	WakeAccepted = "manifest-accepted"
-	// WakeCleared is the condition keeper's clear of a silent module's health condition on `mesh-conditions`.
-	WakeCleared = "condition-cleared"
-	// WakeByHand is builder_floor_again, a hand act.
-	WakeByHand = "by hand"
-)
-
-// sourceOfWake is the floor source each event says something of; a clear names the source by its module.
-var sourceOfWake = map[string]string{WakePublished: SourceSeat, WakeForge: SourceTags, WakeAccepted: SourceRequirements}
-
-// ModuleOfSource is the module whose health condition's clear wakes a silent source.
-var ModuleOfSource = map[string]string{
-	SourceTags:         "mesh-delivery-forge-bridge",
-	SourceRequirements: "mesh-delivery-indexer",
-}
-
-// FloorWait is one name waiting on its floor: the sources still silent and why, since when; the finding the builder
-// writes names them, cleared once all three answer.
-type FloorWait struct {
-	Name   string            `json:"name"`
-	Seat   string            `json:"seat"`
-	Silent []string          `json:"silent"`
-	Why    map[string]string `json:"why,omitempty"`
-	Since  time.Time         `json:"since"`
-	// Holder is the module holding the name's seat: its condition's clear wakes the seat source.
-	Holder string `json:"holder,omitempty"`
-}
-
-// Finding is the floor finding's words.
-func (w FloorWait) Finding() string {
-	var parts []string
-	for _, s := range w.Silent {
-		p := s
-		if why := w.Why[s]; why != "" {
-			p += " (" + why + ")"
-		}
-		parts = append(parts, p)
-	}
-	return fmt.Sprintf("the floor of %s is not known since %s: %s did not answer; nothing of it is numbered until all three answer",
-		w.Name, w.Since.UTC().Format(time.RFC3339), strings.Join(parts, ", "))
-}
-
-// The builder's state floor-waits (DLV-B4): each name waiting on its floor, keyed by its escaped name, so a restarted
-// builder still knows which names its silent sources' events wake; builder_floor_waits reads it.
-const (
-	FloorWaitsState  = "floor-waits"
-	FloorWaitsBucket = "mesh-delivery-builder_floor-waits"
-	FloorWaitsTool   = "builder_floor_waits"
-)
-
-// FloorWaitKey is a wait's key in floor-waits.
-func FloorWaitKey(name string) string { return EscapeToken(name) }
-
-// FloorKeeper keeps the waits on the bus: Put a wait's value, Delete its key.
-type FloorKeeper interface {
-	Put(key string, value []byte) error
-	Delete(key string) error
-}
-
-// FloorWaits are the names waiting on their floor. Wake answers which names to ask again for an event, Answered drops
-// a name once all three answered; the builder's finding for each is the wait's Finding. Once Kept, every change is
-// written to the state floor-waits as well.
-type FloorWaits struct {
-	mu     sync.Mutex
-	waits  map[string]FloorWait
-	keeper FloorKeeper
-	// Logf says a wait that could not be kept; nil says nothing.
-	Logf func(string, ...any)
-	// Said is told each wait recorded (raised) and each answered (not raised): the builder's finding floor-silent.
-	Said func(w FloorWait, raised bool)
-}
-
-// FloorSilent is the kind of the floor finding.
-const FloorSilent = "floor-silent"
-
-// Keep binds the state: the waits it holds that are not known here are taken in (a restarted builder's), every wait
-// known here is written to it, and every change from now on is.
-func (fw *FloorWaits) Keep(k FloorKeeper, held []FloorWait) {
-	fw.mu.Lock()
-	if fw.waits == nil {
-		fw.waits = map[string]FloorWait{}
-	}
-	for _, w := range held {
-		if _, had := fw.waits[w.Name]; !had && w.Name != "" {
-			fw.waits[w.Name] = w
-		}
-	}
-	fw.keeper = k
-	all := make([]FloorWait, 0, len(fw.waits))
-	for _, w := range fw.waits {
-		all = append(all, w)
-	}
-	fw.mu.Unlock()
-	for _, w := range all {
-		fw.put(k, w)
-	}
-}
-
-func (fw *FloorWaits) put(k FloorKeeper, w FloorWait) {
-	if k == nil {
-		return
-	}
-	data, err := json.Marshal(w)
-	if err == nil {
-		err = k.Put(FloorWaitKey(w.Name), data)
-	}
-	if err != nil && fw.Logf != nil {
-		fw.Logf("the floor wait of %s is not kept in %s (a restart forgets it until its next claim): %v", w.Name, FloorWaitsState, err)
-	}
-}
-
-// DecodeFloorWait reads one value of floor-waits.
-func DecodeFloorWait(raw []byte) (FloorWait, error) {
-	var w FloorWait
-	if err := json.Unmarshal(raw, &w); err != nil {
-		return FloorWait{}, err
-	}
-	if w.Name == "" {
-		return FloorWait{}, errors.New("a floor wait names no name")
-	}
-	return w, nil
-}
-
-// Wait records that name's floor is not known.
-func (fw *FloorWaits) Wait(name, seat, holder string, f Floor, why map[string]string, now time.Time) FloorWait {
-	fw.mu.Lock()
-	if fw.waits == nil {
-		fw.waits = map[string]FloorWait{}
-	}
-	w, had := fw.waits[name]
-	if !had {
-		w.Since = now
-	}
-	w.Name, w.Seat, w.Holder, w.Silent, w.Why = name, seat, holder, slices.Clone(f.Silent), why
-	fw.waits[name] = w
-	k := fw.keeper
-	fw.mu.Unlock()
-	fw.put(k, w)
-	if fw.Said != nil {
-		fw.Said(w, true)
-	}
-	return w
-}
-
-// Answered drops name: its floor is known. It says whether the name waited, so its finding is cleared.
-func (fw *FloorWaits) Answered(name string) bool {
-	fw.mu.Lock()
-	w, had := fw.waits[name]
-	delete(fw.waits, name)
-	k := fw.keeper
-	fw.mu.Unlock()
-	if had && fw.Said != nil {
-		fw.Said(w, false)
-	}
-	if had && k != nil {
-		if err := k.Delete(FloorWaitKey(name)); err != nil && fw.Logf != nil {
-			fw.Logf("the floor wait of %s is not cleared from %s: %v", name, FloorWaitsState, err)
-		}
-	}
-	return had
-}
-
-// FloorWaitsAnswer is what builder_floor_waits answers: every name waiting on its floor, oldest first, with its finding.
-type FloorWaitsAnswer struct {
-	Waits []FloorWaitRead `json:"waits"`
-}
-
-// FloorWaitRead is one wait as builder_floor_waits shows it.
-type FloorWaitRead struct {
-	FloorWait
-	Finding string `json:"finding"`
-}
-
-// AnswerFloorWaits is builder_floor_waits, read from the state floor-waits.
-func AnswerFloorWaits(r Reader) (FloorWaitsAnswer, error) {
-	keys, err := r.Keys()
-	if err != nil {
-		return FloorWaitsAnswer{}, err
-	}
-	out := FloorWaitsAnswer{Waits: []FloorWaitRead{}}
-	for _, k := range keys {
-		raw, ok, err := r.Get(k)
-		if err != nil {
-			return FloorWaitsAnswer{}, err
-		}
-		if !ok {
-			continue
-		}
-		w, err := DecodeFloorWait(raw)
-		if err != nil {
-			return FloorWaitsAnswer{}, fmt.Errorf("%s.%s: %w", FloorWaitsState, k, err)
-		}
-		out.Waits = append(out.Waits, FloorWaitRead{FloorWait: w, Finding: w.Finding()})
-	}
-	sort.Slice(out.Waits, func(i, j int) bool {
-		if !out.Waits[i].Since.Equal(out.Waits[j].Since) {
-			return out.Waits[i].Since.Before(out.Waits[j].Since)
-		}
-		return out.Waits[i].Name < out.Waits[j].Name
-	})
-	return out, nil
-}
-
-// FloorWaitsDescription is builder_floor_waits' description.
-const FloorWaitsDescription = "The names waiting on their floor (the builder's state floor-waits, design 51 *The floor*), oldest first: " +
-	"each name, its registry seat, the sources still silent and why, since when, and the finding the builder says for it. " +
-	"Nothing of a waiting name is numbered until all three sources answer; builder_floor_again asks one again by hand. Read-only."
-
-// Wake answers the names to ask their floor again on an event: kind one of the Wake constants; seat the seat a
-// `published` came on; module the module whose condition cleared. A name is woken only when the event says something
-// of a source it waits on; WakeByHand with a name wakes that name alone.
-func (fw *FloorWaits) Wake(kind, seat, module, name string) []string {
-	fw.mu.Lock()
-	defer fw.mu.Unlock()
-	var out []string
-	for n, w := range fw.waits {
-		switch kind {
-		case WakeByHand:
-			if n == name {
-				out = append(out, n)
-			}
-		case WakeCleared:
-			for _, s := range w.Silent {
-				if ModuleOfSource[s] == module || (s == SourceSeat && w.Holder != "" && w.Holder == module) {
-					out = append(out, n)
-					break
-				}
-			}
-		default:
-			src := sourceOfWake[kind]
-			if slices.Contains(w.Silent, src) && (kind != WakePublished || seat == "" || seat == w.Seat) {
-				out = append(out, n)
-			}
-		}
-	}
-	sort.Strings(out)
-	return out
-}
-
-// Waiting is every wait, by name.
-func (fw *FloorWaits) Waiting() []FloorWait {
-	fw.mu.Lock()
-	defer fw.mu.Unlock()
-	out := make([]FloorWait, 0, len(fw.waits))
-	for _, w := range fw.waits {
-		out = append(out, w)
-	}
-	sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
-	return out
-}

modules/mesh-delivery-builder/internal/versions/heard.go

@@ -1,95 +0,0 @@
-package versions
-
-import (
-	"context"
-	"fmt"
-)
-
-// The registry seats' events the builder hears on its durable consumer of each `<seat>.events` (design 51 *How a
-// publish ends*, DLV-B4).
-const (
-	HeardPublished = "published"
-	HeardRefused   = "refused"
-	HeardRemoved   = "removed"
-	HeardKept      = "kept"
-)
-
-// Outcome is the body of a registry seat's published, refused and removed (mesh-contracts parts/registry Outcome), the
-// fields the builder reads.
-type Outcome struct {
-	Name    string `json:"name"`
-	Version string `json:"version,omitempty"`
-	Digest  string `json:"digest"`
-	Kind    string `json:"kind"`
-	Holder  string `json:"holder"`
-	Reason  string `json:"reason,omitempty"`
-	// Tags are, on kept, the other tags still naming its digest.
-	Tags []string `json:"tags,omitempty"`
-}
-
-// RemoveOutcome is what a seat's remove answered: kept whole (another tag names its digest), with why and those tags; or
-// asked, the seat saying removed on its events.
-type RemoveOutcome struct {
-	Kept   bool
-	Reason string
-	Tags   []string
-}
-
-// keep marks a tagged version kept by its seat, so it is asked no more.
-func (n *Numberer) keep(ctx context.Context, e Entry, reason string, tags []string) error {
-	if reason == "" {
-		reason = "shared-digest"
-	}
-	_, err := n.Versions.Mark(ctx, e.Name, e.Version, func(x *Entry) {
-		x.State, x.Reason, x.KeptWith = Kept, reason, append([]string(nil), tags...)
-	})
-	return err
-}
-
-// Heard takes one seat event in: a numbered version's entry turns published (with its digest when it held none),
-// refused with the holder's reason, removed with its reason and the event's id, or kept (another tag names its digest)
-// with the other tags; a by-digest publish (no version)
-// marks nothing. It answers the names waiting on their floor that the event wakes: a `published` says the seat
-// answers (design 51 *The floor*).
-func (n *Numberer) Heard(ctx context.Context, seat, event, id string, o Outcome) ([]string, error) {
-	var wake []string
-	if event == HeardPublished && n.Waits != nil {
-		wake = n.Waits.Wake(WakePublished, seat, "", "")
-	}
-	if o.Version == "" {
-		return wake, nil
-	}
-	var change func(*Entry)
-	switch event {
-	case HeardPublished:
-		change = func(e *Entry) {
-			e.State, e.Reason = Published, ""
-			if e.Digest == "" {
-				e.Digest = o.Digest
-			}
-		}
-	case HeardRefused:
-		change = func(e *Entry) {
-			if e.State != Published {
-				e.State, e.Reason, e.RefusedDigest = Refused, o.Reason, o.Digest
-			}
-		}
-	case HeardRemoved:
-		change = func(e *Entry) { e.State, e.Reason, e.RemovedBy = Removed, o.Reason, id }
-	case HeardKept:
-		change = func(e *Entry) {
-			if e.State != Removed {
-				e.State, e.Reason, e.KeptWith = Kept, o.Reason, append([]string(nil), o.Tags...)
-				if e.Reason == "" {
-					e.Reason = "shared-digest"
-				}
-			}
-		}
-	default:
-		return wake, fmt.Errorf("%s says %q, which the builder does not hear", seat, event)
-	}
-	if _, err := n.Versions.Mark(ctx, o.Name, o.Version, change); err != nil {
-		return wake, fmt.Errorf("%s's %s of %s@%s: %w", seat, event, o.Name, o.Version, err)
-	}
-	return wake, nil
-}

modules/mesh-delivery-builder/internal/versions/names.go

@@ -1,66 +0,0 @@
-package versions
-
-import (
-	"context"
-	"sort"
-	"strings"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// PackagesState is the indexer's packages state as the builder reads it (its manifest's reads grant): its keys, and one
-// key's value (found false when it holds none).
-type PackagesState interface {
-	Keys(ctx context.Context) ([]string, error)
-	Get(ctx context.Context, key string) (value []byte, found bool, err error)
-}
-
-// NamesIn are a package's names in its ecosystem as the indexer's packages state holds them (design 32): the name of the
-// series key that names module and artifact as what it is built from. A series key is named `<name>.<series>`; a key
-// with no dot is a mesh Go module's published packages, not a series. A value that does not decode is passed over.
-func NamesIn(s PackagesState) PackageNames {
-	return func(ctx context.Context, module, artifact string) (string, bool, error) {
-		keys, err := s.Keys(ctx)
-		if err != nil {
-			return "", false, err
-		}
-		sort.Strings(keys)
-		built := NameOf(module, artifact)
-		for _, key := range keys {
-			if !delivery.IsSeriesPackageKey(key) {
-				continue
-			}
-			value, found, err := s.Get(ctx, key)
-			if err != nil {
-				return "", false, err
-			}
-			if !found {
-				continue
-			}
-			v, err := delivery.DecodeSeriesPackage(value) // the indexer's value of a series key (mesh-sdk's contract, J4)
-			if err != nil || v.Package != built {
-				continue
-			}
-			return v.Name, true, nil
-		}
-		return "", false, nil
-	}
-}
-
-// NamedModule is the module a value of the indexer's packages state names a package's name for (design 32), and that
-// name: a series key whose value names a name and the <module>/<artifact> it is built from. The builder looks at that module again when
-// the value is heard, so a done build that left the package unnumbered (its name not known at its claim) is numbered then.
-func NamedModule(key string, value []byte) (module, name string, ok bool) {
-	if !delivery.IsSeriesPackageKey(key) {
-		return "", "", false
-	}
-	v, err := delivery.DecodeSeriesPackage(value)
-	if err != nil || v.Name == "" {
-		return "", "", false
-	}
-	module, artifact, cut := strings.Cut(v.Package, "/")
-	if !cut || module == "" || artifact == "" {
-		return "", "", false
-	}
-	return module, v.Name, true
-}

modules/mesh-delivery-builder/internal/versions/oldform.go

@@ -1,157 +0,0 @@
-package versions
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"slices"
-	"sort"
-	"strings"
-	"time"
-
-	"git.novox.be/novox/mesh-delivery/sdk/forms"
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// The old reference form's window (design 51 *Every build keeps the old reference form*, ADR 0624 §1, ADR 0618 §2-§4,
-// DLV-B9). Which forms a build key keeps is mesh-delivery's sdk/forms (Kept, Choose), the counted nodes' statements the
-// builder's state engine-reads; this is only the window over them: open while a counted node-engine, present or away,
-// reads of some artifact kind none of the newest form the builder knows for it, so an older form stays in new build keys
-// for it; closed, said once with `old-form-closed` and a log line, when none does. It moves on what moves a statement
-// (the node-engine seat's verb `manifest-reads` and its event `manifest-reads-changed`), the placement, a hand drop and
-// each build key written; never on a timer.
-
-// OldFormState is the builder's state of the window: one key, OldFormKey, an OldFormWindow. builder_old_form reads it.
-const (
-	OldFormState = "old-form"
-	OldFormKey   = "window"
-)
-
-// OldFormBucket is that state's bucket.
-const OldFormBucket = delivery.BuilderModule + "_" + OldFormState
-
-// OldFormHeld is the finding of a node holding the window open for FindingAfter, about that node, cleared when the
-// window closes or the node no longer holds it.
-const OldFormHeld = "old-form-held"
-
-// Holding are the counted nodes, those dropped by hand left out, whose engine reads, of some artifact kind fs knows, not
-// the newest form of that kind: the nodes for which an older form stays in new build keys (forms.ArtifactForms.Kept). A
-// node stating nothing reads the first forms (fs.Reads), sorted.
-func Holding(fs forms.ArtifactForms, counted map[string][]string, dropped map[string]bool) []string {
-	newest := map[string]string{} // kind -> newest form
-	var kinds []string
-	for _, f := range fs {
-		for _, k := range f.Kinds {
-			if _, ok := newest[k]; !ok {
-				kinds = append(kinds, k)
-			}
-			newest[k] = f.Name
-		}
-	}
-	var out []string
-	for node, stated := range counted {
-		if dropped[node] {
-			continue
-		}
-		for _, k := range kinds {
-			if !fs.Reads(stated, newest[k]) {
-				out = append(out, node)
-				break
-			}
-		}
-	}
-	sort.Strings(out)
-	return out
-}
-
-// OldFormWindow is the window's record: whether it is open, who holds it and since when (delivery.WindowHeld, the part
-// every window keeper shares), and the nodes dropped by hand; what builder_old_form answers and what `old-form-closed`
-// carries when it closes.
-type OldFormWindow struct {
-	delivery.WindowHeld
-	Dropped []Dropped `json:"dropped,omitempty"`
-}
-
-// Dropped is one retired node dropped from the count by hand (builder_old_form): a hand act with who and why.
-type Dropped struct {
-	Node string    `json:"node"`
-	By   string    `json:"by"`
-	Why  string    `json:"why"`
-	At   time.Time `json:"at"`
-}
-
-// OldFormClosedBody is the body of OldFormClosedEvent (design 51): when, the nodes that held it last and the nodes dropped
-// by hand.
-type OldFormClosedBody struct {
-	At          time.Time `json:"at"`
-	LastHolding []string  `json:"last_holding,omitempty"`
-	Dropped     []Dropped `json:"dropped,omitempty"`
-}
-
-// FindingAfter is how long a node holds the window open before it is the builder's finding naming the node.
-const FindingAfter = 7 * 24 * time.Hour
-
-// Step moves the window by mesh-sdk's one window rule (delivery.StepWindow): named is every counted node the read named,
-// those dropped by hand included, and holding those of them holding the window (Holding). A read naming no node (no
-// placement read yet, an empty node_haves) judges nothing, so it never closes the window. It answers the new window,
-// whether it closed in this step (so the builder says `old-form-closed` and its log line once), and the nodes holding it
-// past FindingAfter (the finding, cleared for every other node).
-func (w OldFormWindow) Step(named, holding []string, now time.Time) (next OldFormWindow, closed bool, overdue []string) {
-	held, closed, overdue := delivery.StepWindow(w.WindowHeld, named, holding, now, FindingAfter)
-	return OldFormWindow{WindowHeld: held, Dropped: w.Dropped}, closed, overdue
-}
-
-// Drop drops a retired node from the count by hand; dropping it again changes nothing.
-func (w OldFormWindow) Drop(node, by, why string, at time.Time) (OldFormWindow, error) {
-	node, why = strings.TrimSpace(node), strings.TrimSpace(why)
-	if node == "" || why == "" {
-		return w, errors.New("name the retired node (node) and say why it leaves the count (why)")
-	}
-	if w.DroppedSet()[node] {
-		return w, nil
-	}
-	w.Dropped = append(slices.Clone(w.Dropped), Dropped{Node: node, By: by, Why: why, At: at.UTC()})
-	return w, nil
-}
-
-// DroppedSet is the dropped nodes, as Holding takes them.
-func (w OldFormWindow) DroppedSet() map[string]bool {
-	out := map[string]bool{}
-	for _, d := range w.Dropped {
-		out[d.Node] = true
-	}
-	return out
-}
-
-// Closing is the event's body of a window that closed in a Step.
-func (w OldFormWindow) Closing() OldFormClosedBody {
-	return OldFormClosedBody{At: w.Closed, LastHolding: w.LastHolding, Dropped: w.Dropped}
-}
-
-// DecodeOldFormWindow reads the state's value; none is a closed window no node holds.
-func DecodeOldFormWindow(raw []byte) (OldFormWindow, error) {
-	var w OldFormWindow
-	if len(raw) == 0 {
-		return w, nil
-	}
-	if err := json.Unmarshal(raw, &w); err != nil {
-		return OldFormWindow{}, fmt.Errorf("the old-form window is not readable: %w", err)
-	}
-	return w, nil
-}
-
-// OldFormDescription is builder_old_form's description.
-const OldFormDescription = "The old reference form's window (design 51 *Every build keeps the old reference form*, ADR 0624): whether it is open, " +
-	"the counted nodes, present or away, whose node-engine reads an older reference form alone and since when (a node holding it seven days " +
-	"is the builder's finding " + OldFormHeld + "), when it last closed and who held it then, and the retired nodes dropped from the count by " +
-	"hand. With drop (a node) and why, drops that retired node from the count by hand, a hand act the builder answers; a node still placed " +
-	"leaves the count by itself only when the placement no longer names it. builder_engine_reads shows what each node's engine states."
-
-// AnswerOldForm is builder_old_form's read: the window as the state holds it.
-func AnswerOldForm(r Reader) (OldFormWindow, error) {
-	raw, ok, err := r.Get(OldFormKey)
-	if err != nil || !ok {
-		return OldFormWindow{}, err
-	}
-	return DecodeOldFormWindow(raw)
-}