A module is told the name it is served under (hq 122)

A module contributes a label; the mesh joins it with the node's domains and
the provider serves the result — and the module itself was never told.
Software that must know its own address (a login redirect, a canonical URL,
an issuer) had it written into the manifest as a literal: a domain in a
definition, wrong on every other machine (ADR 0112). Found converting
grafana's keycloak login for ace, where it forced GF_SERVER_ROOT_URL and
keycloak's issuer back into manifests.

The binding for a requirement a module contributes to now carries `name`
and `internal-name` (or `names` by local name for several contributions),
and `${bound:<requirement>:name}` / `:internal-name` (`:name-<local>`) fill
files from it. Both come from the one function the provider's received
file is composed by, so the proxy and the module cannot disagree about the
name. Absent when nothing was composed, so a file asking for a name on a
node with no public domain is refused, not rendered empty.

Also: `${bound:…}` could not name a requirement answered by a node-scoped
provider on the same machine — its binding file was written (from `here`)
but the placeholders only looked at the mesh's needs. Filled from the same
answer now.

Dockerfile

@@ -1,11 +1,5 @@
-# The Go it builds with, pinned here because genesis builds this file with no arguments (novox/hq
+ARG GO_BASE=golang:1.25-alpine
-# issue 223) — the Makefile passes the same digest. A tag older than go.mod asks for is how
+# The control plane's image.
-# `make image` broke once before (issue 146).
-ARG GO_BASE=golang@sha256:8ac98ca534ac3f51e1f420a1dd2c15e74c75cfa0f23f3ad27eb5d7236c349a0c
-# The control plane's image — for genesis and the lab only. The mesh runs the controller as a Go
-# bundle the host starts as a process (module.json; novox/hq issue 213), and builds no image of it.
-# Genesis builds this file and raises it as the container the process replaces on the first push
-# (mesh-host internal/bootstrap, novox/hq issue 223).
 #
 # novox/hq ADR 0006: this image is pinned by digest in the bundle the host carries, fetched on a
 # machine where no mesh exists yet, and run before there is anything to check it against. So it

Makefile

@@ -27,21 +27,17 @@ build:
 IMAGE ?= mesh-controller:$(VERSION)
 DEV_TAG ?= mesh-controller:development
 
-# The Go base the image is built on.
+# The base the module declares, read from the manifest rather than written here twice.
 #
 # **`make image` was broken and stayed broken**, because the Dockerfile's fallback base was a Go
 # older than go.mod asks for: every build died at `go mod download` with "go.mod requires go >=
 # 1.26.0", and the pipeline never saw it because the pipeline passes the declared base in. Anybody
 # building the image by hand hit it and had to find the digest themselves (novox/hq 04-ISSUES/146,
 # what it cost).
-#
+GO_BASE ?= $(shell python3 -c "import json;print(next(o['image'] for o in json.load(open('module.json'))['build']['on'] if o['arg']=='GO_BASE'))" 2>/dev/null)
-# **Pinned here since the manifest stopped building an image** (novox/hq issue 213): the mesh builds
-# the controller as a Go bundle with its own toolchain, and only `make image` — genesis and the lab —
-# still needs a Go base. The digest is the one the manifest declared until then.
-GO_BASE ?= golang@sha256:8ac98ca534ac3f51e1f420a1dd2c15e74c75cfa0f23f3ad27eb5d7236c349a0c
 
 image:
-	@test -n "$(GO_BASE)" || { echo "no GO_BASE; pass GO_BASE=<image>"; exit 1; }
+	@test -n "$(GO_BASE)" || { echo "module.json declares no GO_BASE; pass GO_BASE=<image> or fix the manifest"; exit 1; }
 	docker build --build-arg GO_BASE=$(GO_BASE) --build-arg VERSION=$(VERSION) -t $(IMAGE) -t $(DEV_TAG) .
 	@echo
 	@docker image inspect $(IMAGE) --format 'built {{.RepoTags}}  {{.Size}} bytes'
@@ -52,7 +48,7 @@ BUILDER_IMAGE ?= mesh-builder:$(VERSION)
 BUILDER_DEV_TAG ?= mesh-builder:development
 
 builder-image:
-	@test -n "$(GO_BASE)" || { echo "no GO_BASE; pass GO_BASE=<image>"; exit 1; }
+	@test -n "$(GO_BASE)" || { echo "module.json declares no GO_BASE; pass GO_BASE=<image> or fix the manifest"; exit 1; }
 	docker build --build-arg GO_BASE=$(GO_BASE) -f cmd/mesh-builder/Dockerfile -t $(BUILDER_IMAGE) -t $(BUILDER_DEV_TAG) .
 	@echo
 	@docker image inspect $(BUILDER_IMAGE) --format 'built {{.RepoTags}}  {{.Size}} bytes'
@@ -63,7 +59,7 @@ PROVISIONER_IMAGE ?= mesh-provision-postgres:$(VERSION)
 PROVISIONER_DEV_TAG ?= mesh-provision-postgres:development
 
 provisioner-image:
-	docker build --build-arg GO_BASE=$(GO_BASE) -f examples/postgres-provisioner/Dockerfile \
+	docker build -f examples/postgres-provisioner/Dockerfile \
 		-t $(PROVISIONER_IMAGE) -t $(PROVISIONER_DEV_TAG) .
 	@echo
 	@docker image inspect $(PROVISIONER_IMAGE) --format 'built {{.RepoTags}}  {{.Size}} bytes'
@@ -74,7 +70,7 @@ OBJECTSTORE_IMAGE ?= mesh-provision-objectstore:$(VERSION)
 OBJECTSTORE_DEV_TAG ?= mesh-provision-objectstore:development
 
 objectstore-image:
-	docker build --build-arg GO_BASE=$(GO_BASE) -f examples/objectstore-provisioner/Dockerfile \
+	docker build -f examples/objectstore-provisioner/Dockerfile \
 		-t $(OBJECTSTORE_IMAGE) -t $(OBJECTSTORE_DEV_TAG) .
 	@echo
 	@docker image inspect $(OBJECTSTORE_IMAGE) --format 'built {{.RepoTags}}  {{.Size}} bytes'
@@ -85,7 +81,7 @@ REDIS_PROVISIONER_IMAGE ?= mesh-provision-redis:$(VERSION)
 REDIS_PROVISIONER_DEV_TAG ?= mesh-provision-redis:development
 
 redis-provisioner-image:
-	docker build --build-arg GO_BASE=$(GO_BASE) -f examples/redis-provisioner/Dockerfile \
+	docker build -f examples/redis-provisioner/Dockerfile \
 		-t $(REDIS_PROVISIONER_IMAGE) -t $(REDIS_PROVISIONER_DEV_TAG) .
 	@echo
 	@docker image inspect $(REDIS_PROVISIONER_IMAGE) --format 'built {{.RepoTags}}  {{.Size}} bytes'
@@ -95,7 +91,7 @@ PROXY_IMAGE ?= mesh-route-proxy:$(VERSION)
 PROXY_DEV_TAG ?= mesh-route-proxy:development
 
 proxy-image:
-	docker build --build-arg GO_BASE=$(GO_BASE) -f examples/route-proxy/Dockerfile -t $(PROXY_IMAGE) -t $(PROXY_DEV_TAG) .
+	docker build -f examples/route-proxy/Dockerfile -t $(PROXY_IMAGE) -t $(PROXY_DEV_TAG) .
 	@echo
 	@docker image inspect $(PROXY_IMAGE) --format 'built {{.RepoTags}}  {{.Size}} bytes'
 

README.md

@@ -193,13 +193,6 @@ passes every check that only looks at the message.
 
 ## The image
 
-**The mesh no longer runs the controller from it** (novox/hq issue 213). The module declares a Go
-bundle, `controller`, which the host on the controller's machine unpacks and runs as the process
-`mesh-controller` under the account of the same name (ADR 0188 §1, §3). The image stays for what
-still runs a container of the controller: genesis, which raises the first controller from it and
-installs the module from its manifest (mesh-host `internal/bootstrap`), and the lab. Neither is the
-mesh's own build any more — `make image` builds it.
-
 `FROM scratch`, holding one statically linked binary and nothing else — no shell, no package
 manager, no libc, no CA certificates.
 

cmd/mesh-builder/main.go

@@ -137,12 +137,7 @@ func takeWorkFrom(credential Credential, on string) (link.BuildMachine, error) {
 	if err != nil {
 		return nil, err
 	}
-	// **The seat this machine serves is the one its credential claims** (novox/hq ADR 0190, the
+	return link.MachineOverNATS(js, on), nil
-	// handover): the mesh issues a build machine's credential naming the seat its module claims,
-	// and one binary serves the old role as `builder` and the new as `build-agent` from that alone.
-	seat := link.BuildSeatClaimed(credential.seatsClaimed())
-	fmt.Fprintf(os.Stderr, "taking build work as a holder of %s\n", seat)
-	return link.MachineOverNATSOn(js, on, seat), nil
 }
 
 // answer does one build and says what happened, whichever way it went.
@@ -153,34 +148,20 @@ func answer(ctx context.Context, publisher builder.Publisher, on, workspace stri
 	// it either finishes or fails is indistinguishable from one that never arrived — which cost a long
 	// diagnosis against a running mesh, chasing "the handler never fired" when the truth was only that
 	// the handler said nothing until the end.
-	fmt.Fprintf(os.Stderr, "a build request arrived for %s (%s)\n", request.Repository, request.ID)
+	fmt.Fprintf(os.Stderr, "a build request arrived for %s\n", request.Repository)
-
-	// **Everything a build says goes two ways**: to stderr, as always, and onto the bus as the
-	// role's own events under the build's id (novox/hq ADR 0157) — so whoever asked, and anybody
-	// watching, reads the same lines this container's log holds, live, and after the fact from the
-	// stream. Said first, before anything runs, so a build that hangs is one that visibly started.
-	say := func(step, message string) {
-		fmt.Fprintf(os.Stderr, "  [%s] %s\n", step, message)
-		work.Say(step, message)
-	}
-	builder.Said = say
-	defer func() { builder.Said = nil }()
-	if err := work.Began(ctx); err != nil {
-		fmt.Fprintf(os.Stderr, "cannot say a build started: %v\n", err)
-	}
 
 	result := link.BuildResult{
 		ID: request.ID, Repository: request.Repository, Path: request.Path,
-		Ref: request.Ref, On: on, Source: request.Source,
+		Ref: request.Ref, On: on,
 	}
-	what := "building " + request.Repository
+	fmt.Fprintf(os.Stderr, "building %s", request.Repository)
 	if request.Path != "" {
-		what += " at " + request.Path
+		fmt.Fprintf(os.Stderr, " at %s", request.Path)
 	}
 	if request.Ref != "" {
-		what += " on " + request.Ref
+		fmt.Fprintf(os.Stderr, " at %s", request.Ref)
 	}
-	say("build", what)
+	fmt.Fprintln(os.Stderr)
 
 	npmrc, err := packagesFrom()
 	var built builder.Result
@@ -190,13 +171,16 @@ func answer(ctx context.Context, publisher builder.Publisher, on, workspace stri
 		// after a clone that then fails at npm ci.
 		built, err = builder.Build(ctx, builder.Command, publisher,
 			request.Repository, request.Path, request.Ref, workspace, request.Held, npmrc,
-			forgeFrom(), say, request.Seats)
+			forgeFrom(),
+			func(step, message string) {
+				fmt.Fprintf(os.Stderr, "  [%s] %s\n", step, message)
+			})
 	}
 	if err != nil {
 		// A failure is a result. A build that fails and says nothing is indistinguishable from a
 		// builder that is not running, and those want completely different responses.
 		result.Failed = err.Error()
-		say("failed", err.Error())
+		fmt.Fprintf(os.Stderr, "  failed: %v\n", err)
 	} else {
 		manifest, marshalErr := json.Marshal(built.Manifest)
 		if marshalErr != nil {
@@ -213,7 +197,7 @@ func answer(ctx context.Context, publisher builder.Publisher, on, workspace stri
 			for _, r := range built.Read {
 				result.Read = append(result.Read, link.ReadRepository{Repository: r.Repository, Ref: r.Ref})
 			}
-			say("built", built.Manifest.Module+" from "+short(built.Commit))
+			fmt.Fprintf(os.Stderr, "  built %s from %s\n", built.Manifest.Module, short(built.Commit))
 		}
 	}
 
@@ -458,21 +442,6 @@ type Credential struct {
 	// as two fields and this machine joins them once, here, to dial.
 	User     string `json:"user,omitempty"`
 	Password string `json:"password,omitempty"`
-	// Claims are the seats the module this credential was issued for claims, as the mesh writes
-	// them beside the credential (novox/hq ADR 0159). The first is the build role this machine
-	// serves; a credential naming none is from before claims travelled in it.
-	Claims []struct {
-		Seat string `json:"seat"`
-	} `json:"claims,omitempty"`
-}
-
-// seatsClaimed is the seats the credential names, in order.
-func (c Credential) seatsClaimed() []string {
-	out := make([]string, 0, len(c.Claims))
-	for _, claim := range c.Claims {
-		out = append(out, claim.Seat)
-	}
-	return out
 }
 
 // onTheNewBus is whether a credential is for the bus being built: its address says so, and the

cmd/mesh-builder/seat_test.go

@@ -1,27 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/link"
-)
-
-// The seat a build machine serves comes from its credential (novox/hq ADR 0190 handover).
-func TestTheCredentialSaysWhichBuildRoleThisMachineServes(t *testing.T) {
-	var held Credential
-	if err := json.Unmarshal([]byte(`{"url":"nats://bus:4222","user":"anchor.builder","password":"x",
-		"claims":[{"seat":"mesh-build-machine","scope":"mesh","serves":[]}]}`), &held); err != nil {
-		t.Fatal(err)
-	}
-	if got := link.BuildSeatClaimed(held.seatsClaimed()); got != "mesh-build-machine" {
-		t.Errorf("the old builder's credential serves %q", got)
-	}
-	var bare Credential
-	if err := json.Unmarshal([]byte(`{"url":"nats://bus:4222","user":"anchor.build-agent","password":"x"}`), &bare); err != nil {
-		t.Fatal(err)
-	}
-	if got := link.BuildSeatClaimed(bare.seatsClaimed()); got != link.TheBuildMachine {
-		t.Errorf("a credential without claims serves %q, want %s", got, link.TheBuildMachine)
-	}
-}

cmd/mesh-controller/acts.go

@@ -3,7 +3,6 @@ package main
 import (
 	"context"
 	"fmt"
-	"github.com/novox/mesh-controller/internal/broker"
 	"sort"
 	"strings"
 
@@ -47,13 +46,6 @@ func assign(ctx context.Context, open *stores, node, module string) (string, err
 		return "", err
 	}
 	defer release()
-	// **Before the new assignment can unsettle a seat somebody holds only by being alone**
-	// (novox/hq 04-ISSUES/170): what the mesh derived so far is written down, and then the
-	// assignment resolves against a record rather than against a coincidence.
-	settled, err := recordDerivedHolders(ctx, open)
-	if err != nil {
-		return "", err
-	}
 	fresh, err := open.inventory.Assign(ctx, node, module)
 	if err != nil {
 		return "", err
@@ -65,16 +57,6 @@ func assign(ctx context.Context, open *stores, node, module string) (string, err
 			node, module), nil
 	}
 	said := fmt.Sprintf("%s is assigned %s", node, module)
-	for _, line := range settled {
-		said += "\n  " + line
-	}
-	// Its bus credential, in the same act (novox/hq issue 203): an assignment pushed before its
-	// credential exists delivers a process that cannot authenticate and crash-loops until somebody
-	// runs a second verb and a second push. Issued here when the module speaks on the bus and has
-	// no credential yet; kept when it has one, so re-assigning rotates nothing.
-	if line := issueOnAssign(ctx, open, node, module); line != "" {
-		said += "\n  " + line
-	}
 	plan, _, err := planFor(ctx, open, node)
 	if err != nil {
 		// Kept, and still refused. Both halves are the answer, and the rest of the mesh is still
@@ -160,33 +142,3 @@ func blockedElsewhere(ctx context.Context, open *stores, except string) string {
 	out.WriteString("\nThis may or may not be what just changed — it is what is true now.")
 	return out.String()
 }
-
-// issueOnAssign gives a newly assigned module its bus credential, the way `module issue` does, and
-// says what it did in one line. Nothing for a module that declares no broker secret; nothing for one
-// whose user is already minted (a credential is rotated on purpose, never by re-assigning); and when
-// the bus cannot be reached from here, the line names the verb and the push that would refuse the
-// module until it is run — never a silent placeholder (novox/hq issue 203).
-func issueOnAssign(ctx context.Context, open *stores, node, module string) string {
-	inv := open.inventory
-	shelf, err := inv.Catalogue(ctx)
-	if err != nil {
-		return ""
-	}
-	m, known := shelf[module]
-	if !known || mayIssue(m) != nil {
-		return ""
-	}
-	user := broker.Principal{Kind: broker.KindModule, Node: node, Module: module}.Username()
-	if _, minted, err := inv.BusUserHash(ctx, user); err != nil || minted {
-		return ""
-	}
-	busAddress, err := broker.BusAddress()
-	if err == nil {
-		err = issueOnTheNewBus(ctx, inv, m, node, busAddress)
-	}
-	if err != nil {
-		return fmt.Sprintf("its bus credential is not issued (%v): `module issue %s --node %s` first — "+
-			"`push %s` refuses to send %s until it is", err, module, node, node, module)
-	}
-	return fmt.Sprintf("its bus credential is issued and sealed to %s, and arrives with the push", node)
-}

cmd/mesh-controller/addresses_test.go

@@ -145,7 +145,7 @@ func TestTheRegistryTrustAndEveryImageFollowThePortTheNodeGaveTheStore(t *testin
 //
 // Composed from the control plane's own manifest against a real inventory: the store's module is
 // given 6852 on this node the way genesis or an operator gives it, and the control plane's
-// process is told so beside the sealed connection genesis wrote.
+// container is told so beside the sealed connection genesis wrote.
 func TestTheControlPlaneIsToldWhereTheNodePutTheStoreAndTheBroker(t *testing.T) {
 	open := aMesh(t)
 	ctx := t.Context()
@@ -157,8 +157,8 @@ func TestTheControlPlaneIsToldWhereTheNodePutTheStoreAndTheBroker(t *testing.T)
 	if err != nil {
 		t.Fatal(err)
 	}
-	control, err := withSeatPorts(m).Resolve([]catalogue.Built{{Name: "controller", Kind: catalogue.ArtifactBundle,
+	control, err := withSeatPorts(m).Resolve([]catalogue.Built{{Name: "server", Kind: catalogue.ArtifactImage,
-		Reference: "https://registry.example/mesh-controller/controller.tar.gz", Digest: aDigest}})
+		Reference: "registry.example/control@" + aDigest}})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -175,12 +175,6 @@ func TestTheControlPlaneIsToldWhereTheNodePutTheStoreAndTheBroker(t *testing.T)
 		Guards: []int{15672},
 		Resources: []map[string]any{{"id": "server", "type": "container", "name": "mesh-broker",
 			"ports": []any{"5671:5671", "5672:5672", "127.0.0.1:15672:15672"}, "image": "mq@" + aDigest}}})
-	// The control plane's own bus user is the installer's, seeded at genesis before the controller
-	// runs (SeedBusUser); without it a push now refuses the credential nobody issued (issue 203).
-	if err := open.inventory.SeedBusUser(ctx, inventory.BusUser{Username: "anchor.mesh-controller",
-		Kind: inventory.BusController, Node: "anchor", Module: "mesh-controller"}, "bootstrap"); err != nil {
-		t.Fatal(err)
-	}
 	if _, err := assign(ctx, open, "anchor", "mesh-controller"); err != nil {
 		t.Fatal(err)
 	}
@@ -200,12 +194,12 @@ func TestTheControlPlaneIsToldWhereTheNodePutTheStoreAndTheBroker(t *testing.T)
 
 	var env map[string]any
 	for _, r := range composed(t, open, "anchor").Resources {
-		if r["id"] == "mesh-controller.controller" {
+		if r["id"] == "mesh-controller.server" {
 			env, _ = r["env"].(map[string]any)
 		}
 	}
 	if env == nil {
-		t.Fatal("the control plane's process is not in its own node's declaration")
+		t.Fatal("the control plane's container is not in its own node's declaration")
 	}
 	for key, want := range map[string]string{
 		"MESH_STORE_INVENTORY_PORT": "6852",
@@ -238,7 +232,7 @@ func withSeatPorts(m catalogue.Manifest) catalogue.Manifest {
 	out := m
 	out.Resources = nil
 	for _, r := range m.Resources {
-		if r["type"] != "container" && r["type"] != "process" {
+		if r["type"] != "container" {
 			out.Resources = append(out.Resources, r)
 			continue
 		}

cmd/mesh-controller/adopting_test.go

@@ -91,26 +91,11 @@ func reportsReaching(t *testing.T, open *stores, reachable []link.Reach, held ..
 	if _, err := (link.Enrolment{Inventory: open.inventory}).Heard(ctx, link.Report{
 		Node: "anchor", Applied: []string{"hello-web.x"}, Declared: digestOf(body),
 		Firewall: "ufw", Held: held, Reachable: reachable,
-		// A machine says which of its links face outside on every apply (novox/hq ADR 0140), and a
-		// filter is not sent to one that has not. The anchor reports one, as a real host does; this
-		// fixture lacked it from 2026-09-28 and nothing ran the test (issue 177).
-		Outward: []string{"eth0"},
-		// And what filters it (ADR 0168): its front end, the runtime's own, and a chain a
-		// predecessor left in the runtime's user chain.
-		Filters: anchorFilters,
 	}); err != nil {
 		t.Fatal(err)
 	}
 }
 
-// anchorFilters is what the adopted anchor says filters it: ufw's chains, the runtime's, and a
-// predecessor's chain the mesh did not write.
-var anchorFilters = []link.Filter{
-	{Where: "table ip filter, chain ufw-reject-input", Owner: "found-firewall", Refuses: "reject"},
-	{Where: "table ip filter, chain DOCKER", Owner: "runtime", Refuses: `iifname != "docker0" oifname "docker0" drop`},
-	{Where: "table ip filter, chain DOCKER-USER", Owner: "other", Refuses: `iifname "eth0" tcp dport 6000 drop`},
-}
-
 var (
 	heldContainer = link.Held{ID: "hello-web.server", Module: "hello-web", Kind: "container",
 		Target: "hello-web", Since: time.Now()}
@@ -120,10 +105,10 @@ var (
 
 func TestTakingAModuleNotOnTheNodeIsRefused(t *testing.T) {
 	open, _ := anAdoptedAnchor(t)
-	if _, err := take(t.Context(), open, "anchor", "nftables", takeOptions{Yes: true}); !errors.Is(err, inventory.ErrNotAssigned) {
+	if _, err := take(t.Context(), open, "anchor", "nftables"); !errors.Is(err, inventory.ErrNotAssigned) {
 		t.Fatalf("taking an unassigned module gave %v", err)
 	}
-	if _, err := take(t.Context(), open, "laptop", "network", takeOptions{Yes: true}); !errors.Is(err, inventory.ErrNotAdopted) {
+	if _, err := take(t.Context(), open, "laptop", "network"); !errors.Is(err, inventory.ErrNotAdopted) {
 		t.Fatalf("taking on a converged node gave %v", err)
 	}
 }
@@ -154,24 +139,7 @@ func TestTheFlipIsRefusedWhileAFoundContainerIsHeld(t *testing.T) {
 func TestTakingNamesWhatItReplaces(t *testing.T) {
 	open, _ := anAdoptedAnchor(t)
 	reportsHolding(t, open, heldContainer, heldFile)
-	ctx := t.Context()
+	said, err := take(t.Context(), open, "anchor", "hello-web")
-	// The machine holds something for the module, so the take acts on the preview the operator
-	// saw and names its digest (novox/hq ADR 0163).
-	preview, err := take(ctx, open, "anchor", "hello-web", takeOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	saw := takeDigestIn(t, preview)
-	if !strings.Contains(preview, "nothing taken; `take anchor hello-web --yes "+saw+"`") {
-		t.Fatalf("the preview does not say how to act on it:\n%s", preview)
-	}
-	if taken, _ := open.inventory.Taken(ctx, "anchor"); len(taken) != 0 {
-		t.Fatal("the preview took something")
-	}
-	if _, err := take(ctx, open, "anchor", "hello-web", takeOptions{Yes: true}); err == nil || !strings.Contains(err.Error(), "name its digest") {
-		t.Fatalf("--yes without the digest was not refused: %v", err)
-	}
-	said, err := take(ctx, open, "anchor", "hello-web", takeOptions{Yes: true, Digest: saw})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -181,71 +149,10 @@ func TestTakingNamesWhatItReplaces(t *testing.T) {
 	}
 }
 
-// takeDigestIn is the digest a take's preview printed.
-func takeDigestIn(t *testing.T, preview string) string {
-	t.Helper()
-	for _, line := range strings.Split(preview, "\n") {
-		if fields := strings.Fields(line); len(fields) == 2 && fields[0] == "preview" {
-			return fields[1]
-		}
-	}
-	t.Fatalf("the preview printed no digest:\n%s", preview)
-	return ""
-}
-
-// A take acts on the preview the operator saw, and on an account of the machine that is still the
-// machine: a changed preview and a stale account refuse (novox/hq ADR 0163, rule 1).
-func TestATakeIsRefusedOnAChangedPreviewOrAStaleAccount(t *testing.T) {
-	open, _ := anAdoptedAnchor(t)
-	ctx := t.Context()
-	reportsHolding(t, open, heldContainer, heldFile)
-	preview, err := take(ctx, open, "anchor", "hello-web", takeOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	saw := takeDigestIn(t, preview)
-
-	// The machine reports again, and what it holds has changed: the found container now carries
-	// facts the preview never showed.
-	changed := heldContainer
-	changed.Facts = map[string]any{"image": "hello:2", "declared_image": "registry.example/hello"}
-	reportsHolding(t, open, changed, heldFile)
-	_, err = take(ctx, open, "anchor", "hello-web", takeOptions{Yes: true, Digest: saw})
-	if err == nil || !strings.Contains(err.Error(), "has changed since preview "+saw) {
-		t.Fatalf("a changed preview was acted on: %v", err)
-	}
-	if taken, _ := open.inventory.Taken(ctx, "anchor"); len(taken) != 0 {
-		t.Fatal("a refused take took something")
-	}
-
-	// And an account older than the flip allows.
-	preview, err = take(ctx, open, "anchor", "hello-web", takeOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	saw = takeDigestIn(t, preview)
-	saved := reportFreshFor
-	reportFreshFor = -time.Second
-	defer func() { reportFreshFor = saved }()
-	_, err = take(ctx, open, "anchor", "hello-web", takeOptions{Yes: true, Digest: saw})
-	if err == nil || !strings.Contains(err.Error(), "a take acts only on an account newer than") {
-		t.Fatalf("a stale account was acted on: %v", err)
-	}
-	reportFreshFor = saved
-	if _, err := take(ctx, open, "anchor", "hello-web", takeOptions{Yes: true, Digest: saw}); err != nil {
-		t.Fatal(err)
-	}
-	// A module the machine holds nothing for has nothing to compare: --yes alone suffices.
-	if _, err := take(ctx, open, "anchor", "notes", takeOptions{Yes: true}); err == nil {
-		// notes holds a file, so this one needs the digest too.
-		t.Fatal("notes holds a found file and was taken without a digest")
-	}
-}
-
 func TestConvergingPreviewsThenChangesAndAdoptingKeepsWhatWasTaken(t *testing.T) {
 	open, sent := anAdoptedAnchor(t)
 	ctx := t.Context()
-	if _, err := take(ctx, open, "anchor", "hello-web", takeOptions{Yes: true}); err != nil {
+	if _, err := take(ctx, open, "anchor", "hello-web"); err != nil {
 		t.Fatal(err)
 	}
 	reportsHolding(t, open, heldFile)
@@ -275,20 +182,6 @@ func TestConvergingPreviewsThenChangesAndAdoptingKeepsWhatWasTaken(t *testing.T)
 	if strings.Contains(preview, "15672") {
 		t.Errorf("a loopback listener is in the preview:\n%s", preview)
 	}
-	// What filters the machine now, and the fate of each (novox/hq ADR 0168): the predecessor's
-	// chain is named as not the mesh's and left, so the reader knows before the flip.
-	for _, want := range []string{
-		"table ip filter, chain DOCKER-USER",
-		"NOT THE MESH'S; left in force",
-		`iifname "eth0" tcp dport 6000 drop`,
-		"table ip filter, chain ufw-reject-input",
-		"the found firewall's; retired with it",
-		"the container runtime's own; left",
-	} {
-		if !strings.Contains(preview, want) {
-			t.Errorf("the preview does not say %q:\n%s", want, preview)
-		}
-	}
 	for _, line := range strings.Split(preview, "\n") {
 		if strings.Contains(line, "5000") && !strings.Contains(line, "WILL CLOSE") {
 			t.Errorf("an undeclared published port is not said to close: %s", line)
@@ -433,7 +326,7 @@ func digestIn(t *testing.T, preview string) string {
 func TestTheFlipActsOnlyOnThePreviewTheOperatorSaw(t *testing.T) {
 	open, sent := anAdoptedAnchor(t)
 	ctx := t.Context()
-	if _, err := take(ctx, open, "anchor", "hello-web", takeOptions{Yes: true}); err != nil {
+	if _, err := take(ctx, open, "anchor", "hello-web"); err != nil {
 		t.Fatal(err)
 	}
 	reportsHolding(t, open, heldFile)
@@ -499,7 +392,7 @@ func TestTheFlipActsOnlyOnThePreviewTheOperatorSaw(t *testing.T) {
 func TestTheFlipHoldsTheNodeWhileItSends(t *testing.T) {
 	open, _ := anAdoptedAnchor(t)
 	ctx := t.Context()
-	if _, err := take(ctx, open, "anchor", "hello-web", takeOptions{Yes: true}); err != nil {
+	if _, err := take(ctx, open, "anchor", "hello-web"); err != nil {
 		t.Fatal(err)
 	}
 	reportsHolding(t, open, heldFile)
@@ -544,7 +437,7 @@ func TestTheFlipHoldsTheNodeWhileItSends(t *testing.T) {
 func TestThePreviewNamesEveryHeldKind(t *testing.T) {
 	open, _ := anAdoptedAnchor(t)
 	ctx := t.Context()
-	if _, err := take(ctx, open, "anchor", "hello-web", takeOptions{Yes: true}); err != nil {
+	if _, err := take(ctx, open, "anchor", "hello-web"); err != nil {
 		t.Fatal(err)
 	}
 	since := time.Now()
@@ -587,7 +480,7 @@ func TestThePreviewNamesEveryHeldKind(t *testing.T) {
 func TestTheFlipIsRefusedOnAnAccountNamingNothingReachable(t *testing.T) {
 	open, sent := anAdoptedAnchor(t)
 	ctx := t.Context()
-	if _, err := take(ctx, open, "anchor", "hello-web", takeOptions{Yes: true}); err != nil {
+	if _, err := take(ctx, open, "anchor", "hello-web"); err != nil {
 		t.Fatal(err)
 	}
 	// Only a loopback listener: nothing off the machine, which is the same silence.
@@ -615,7 +508,7 @@ func TestTheFlipIsRefusedOnAnAccountNamingNothingReachable(t *testing.T) {
 func TestAssigningWaitsForWhateverIsConvergingTheNode(t *testing.T) {
 	open, _ := anAdoptedAnchor(t)
 	ctx := t.Context()
-	if _, err := take(ctx, open, "anchor", "hello-web", takeOptions{Yes: true}); err != nil {
+	if _, err := take(ctx, open, "anchor", "hello-web"); err != nil {
 		t.Fatal(err)
 	}
 	reportsHolding(t, open, heldFile)

cmd/mesh-controller/adoption.go

@@ -24,15 +24,6 @@ import (
 func showMode(ctx context.Context, inv *inventory.Inventory, node inventory.Node) error {
 	if !node.Adopted {
 		fmt.Printf("  mode              converged\n")
-		// A converged machine holds nothing, and can still run what nobody asked for
-		// (novox/hq ADR 0163): what it reports as strays is said whatever its mode.
-		if said, err := inv.AdoptionOf(ctx, node.Name); err == nil && len(said.Strays) > 0 {
-			showStrays(said.Strays)
-		}
-		// And what filters it, truthfully (novox/hq ADR 0168): the mesh alone, or not.
-		if filtering, err := inv.FilteringOf(ctx, node.Name); err == nil {
-			showFiltering(filtering, false)
-		}
 		return nil
 	}
 	fmt.Printf("  mode              adopted since %s\n",
@@ -71,81 +62,11 @@ func showMode(ctx context.Context, inv *inventory.Inventory, node inventory.Node
 		if h.Kept != "" {
 			fmt.Printf("  %-17s original kept at %s\n", "", h.Kept)
 		}
-		for _, f := range comparisonLines(h) {
-			fmt.Printf("  %-17s %s\n", "", f)
-		}
-	}
-	showStrays(said.Strays)
-	if filtering, err := inv.FilteringOf(ctx, node.Name); err == nil {
-		showFiltering(filtering, true)
 	}
 	fmt.Printf("  as of             %s\n", said.At.Local().Format(time.DateTime))
 	return nil
 }
 
-// showFiltering says what filters a machine, with owners (novox/hq ADR 0168), and for a converged
-// machine the state of the firewall it was found with. A machine that has not said is not said to
-// be filtered by anything.
-func showFiltering(f inventory.Filtering, adopted bool) {
-	if len(f.Filters) == 0 && f.FoundFirewall == nil {
-		return
-	}
-	if fw := f.FoundFirewall; fw != nil && !adopted {
-		switch {
-		case fw.Active:
-			fmt.Printf("  found firewall    %s is ACTIVE on this converged machine; the next apply retires it again\n", fw.Kind)
-		case fw.RetiredBy == "removed":
-			fmt.Printf("  found firewall    %s, removed: the mesh's filter is what filters this machine (novox/hq ADR 0180)\n", fw.Kind)
-		case fw.RetiredBy == inventory.FilterMesh || fw.RetiredBy == "mesh":
-			fmt.Printf("  found firewall    %s, retired by the mesh; its configuration stays on disk\n", fw.Kind)
-		case fw.RetiredBy != "":
-			fmt.Printf("  found firewall    %s, found inactive — not by the mesh\n", fw.Kind)
-		default:
-			fmt.Printf("  found firewall    %s, inactive\n", fw.Kind)
-		}
-	}
-	if len(f.Filters) == 0 {
-		return
-	}
-	if f.Alone() {
-		fmt.Printf("  filtered by       the mesh alone (%s)\n", filterSummary(f.Filters))
-		return
-	}
-	fmt.Printf("  filtered by       NOT the mesh alone: %d rule set(s) the mesh did not write refuse traffic here\n", len(f.Others()))
-	for _, x := range f.Filters {
-		if x.Owner == inventory.FilterOther || x.Owner == inventory.FilterFoundFirewall {
-			fmt.Printf("  %-17s %s — %s: %s\n", "", x.Where, x.Owner, x.Refuses)
-		}
-	}
-	fmt.Printf("  %-17s and its own: %s\n", "", filterSummary(f.Filters))
-}
-
-// filterSummary counts a machine's filters by owner: "mesh 2, runtime 3, ban 1".
-func filterSummary(filters []inventory.Filter) string {
-	counts := map[string]int{}
-	for _, x := range filters {
-		counts[x.Owner]++
-	}
-	var parts []string
-	for _, owner := range []string{inventory.FilterMesh, inventory.FilterRuntime, inventory.FilterBan, inventory.FilterFoundFirewall, inventory.FilterOther} {
-		if n := counts[owner]; n > 0 {
-			parts = append(parts, fmt.Sprintf("%s %d", owner, n))
-		}
-	}
-	return strings.Join(parts, ", ")
-}
-
-// showStrays says what a machine runs that the mesh neither wrote nor holds (ADR 0163).
-func showStrays(strays []inventory.Stray) {
-	if len(strays) == 0 {
-		return
-	}
-	fmt.Printf("  strays            %d container(s) the mesh neither wrote nor holds:\n", len(strays))
-	for _, s := range strays {
-		fmt.Printf("  %-17s %s (%s)\n", "", s.Name, s.Detail)
-	}
-}
-
 // showTunnel is the node show lines about the tunnel an adopted node found and carried (novox/hq
 // ADR 0105): what it presented at enrolment, and what it last said about taking it over.
 func showTunnel(ctx context.Context, inv *inventory.Inventory, name string) error {
@@ -215,28 +136,7 @@ const DefaultFilter = "nftables"
 // take is a module's cutover on an adopted node: the operator's act, done when that module's data
 // has moved. From the next push its resources converge there like any other, replacing what the
 // node found and holds for it.
-//
+func take(ctx context.Context, open *stores, node, module string) (string, error) {
-// **Previewed, and the preview is a comparison** (novox/hq ADR 0163): for every held thing the
-// module would replace, what runs beside what the module declares, and the difference; the
-// module's secrets on the machine and where each came from; its settings on the machine. Without
-// --yes the comparison is printed and nothing changes. `--yes <digest>` cuts over exactly what was
-// previewed, the way the flip is confirmed: the preview ends with a digest of what it said, and a
-// take naming an older one, or acting on an account of the machine older than the flip allows, is
-// refused. A module the machine holds nothing for has nothing to compare, and `--yes` suffices.
-// takeOptions is what a take was told about the differences it may pass (novox/hq ADR 0163).
-type takeOptions struct {
-	Yes bool
-	// Digest is the preview's, named with --yes; required whenever the machine holds something
-	// for the module.
-	Digest    string
-	Downgrade bool
-	Replace   map[string]bool
-	// Mint names the secrets the service shall take a new value for, although the mesh minted
-	// one and the service already has its own (rule 2).
-	Mint map[string]bool
-}
-
-func take(ctx context.Context, open *stores, node, module string, opts takeOptions) (string, error) {
 	inv := open.inventory
 	assigned, err := inv.Assigned(ctx, node)
 	if err != nil {
@@ -250,335 +150,25 @@ func take(ctx context.Context, open *stores, node, module string, opts takeOptio
 			}
 		}
 	}
-	// The comparison first (novox/hq ADR 0163): every held thing the module would replace, beside
-	// what the module declares, and the differences that refuse unless named.
-	c, err := comparisonFor(ctx, open, node, module)
-	if err != nil {
-		return "", err
-	}
-	preview, refusals, saw := comparisonOf(module, c, opts)
-	if len(refusals) > 0 {
-		return "", fmt.Errorf("taking %s on %s is refused:\n  %s\n%s", module, node,
-			strings.Join(refusals, "\n  "), preview)
-	}
-	holds := len(heldOf(c.reported, module)) > 0
-	if holds {
-		preview += "\n  preview " + saw
-	}
-	if !opts.Yes {
-		if !holds {
-			return preview + fmt.Sprintf("\nnothing taken; `take %s %s --yes` declares it as the mesh's own", node, module), nil
-		}
-		return preview + fmt.Sprintf("\nnothing taken; `take %s %s --yes %s` cuts it over as previewed", node, module, saw), nil
-	}
-	if holds {
-		// The take acts on the preview the operator saw, and on an account of the machine that
-		// is still the machine: the same two refusals the flip makes.
-		if age := time.Since(c.reported.At); age > reportFreshFor {
-			return preview, fmt.Errorf("%s last said what it holds %s ago, and a take acts only on "+
-				"an account newer than %s: run `push %s --wait 2m`, then preview again",
-				node, age.Round(time.Second), reportFreshFor, node)
-		}
-		if opts.Digest == "" {
-			return preview, fmt.Errorf("taking %s on %s acts on the preview you saw: name its digest, "+
-				"`take %s %s --yes %s`, once you have read it", module, node, node, module, saw)
-		}
-		if opts.Digest != saw {
-			return preview, fmt.Errorf("what taking %s on %s would replace has changed since preview %s "+
-				"(it is now %s): read the preview above, and run `take %s %s --yes %s` if it is "+
-				"what you want", module, node, opts.Digest, saw, node, module, saw)
-		}
-	}
 	if err := inv.Take(ctx, node, module); err != nil {
 		return "", err
 	}
 	said := fmt.Sprintf("%s is taken on %s", module, node)
-	if holds {
+	reported, err := inv.AdoptionOf(ctx, node)
-		said += "; the next push replaces what the node found and holds for it:\n" + preview
-	}
-	return said + fmt.Sprintf("\n  run `push %s` to cut it over", node), nil
-}
-
-// comparison is everything a take puts beside what the module declares: the machine's account of
-// what it holds and what is reachable on it, the module's secrets on the machine, its settings
-// there, and which found networks a setting keeps for each of its containers (by held id).
-type comparison struct {
-	reported inventory.Adoption
-	secrets  []inventory.SecretState
-	layers   []catalogue.Layer
-	keeps    map[string][]string
-	// settingsRefused is why the module's settings cannot compose with its definition, when
-	// they cannot — the module would be left out of the declaration (rule 6).
-	settingsRefused string
-}
-
-func comparisonFor(ctx context.Context, open *stores, node, module string) (comparison, error) {
-	inv := open.inventory
-	var c comparison
-	var err error
-	if c.reported, err = inv.AdoptionOf(ctx, node); err != nil {
-		return c, err
-	}
-	if c.secrets, err = inv.SecretsOf(ctx, node, module); err != nil {
-		return c, err
-	}
-	if c.layers, err = inv.SettingsFor(ctx, node, module); err != nil {
-		return c, err
-	}
-	shelf, err := inv.Catalogue(ctx)
 	if err != nil {
-		return c, err
+		return "", err
 	}
-	if m, known := shelf[module]; known && len(c.layers) > 0 {
+	var replaces []string
-		if err := catalogue.JudgeSettings(m, c.layers, true); err != nil {
-			c.settingsRefused = err.Error()
-		}
-		if kept, err := catalogue.KeptNetworks(m, c.layers, true); err == nil && len(kept) > 0 {
-			c.keeps = map[string][]string{}
-			for id, networks := range kept {
-				c.keeps[module+"."+id] = networks
-			}
-		}
-	}
-	return c, nil
-}
-
-// heldOf is what a node holds for one module.
-func heldOf(reported inventory.Adoption, module string) []inventory.Held {
-	var out []inventory.Held
 	for _, h := range reported.Held {
 		if h.Module == module {
-			out = append(out, h)
+			replaces = append(replaces, "  "+heldLine(h))
 		}
 	}
-	return out
+	if len(replaces) > 0 {
-}
+		said += "; the next push replaces what the node found and holds for it:\n" +
-
+			strings.Join(replaces, "\n")
-// comparisonOf is a take's preview: for every held thing of the module, what runs beside what the
-// module declares; its secrets and its settings on the machine; and the refusals the differences
-// earn unless the take named them (novox/hq ADR 0163): an image older than the one running, a
-// declared file that differs from the found one, a secret the mesh minted for a service whose data
-// was found. A narrowed port and a shared network are said and not refused. The digest is of what
-// the preview says, so anything in it changing changes the digest.
-func comparisonOf(module string, c comparison, opts takeOptions) (preview string, refusals []string, digest string) {
-	var b strings.Builder
-	held := heldOf(c.reported, module)
-	foundData := false
-	for _, h := range held {
-		if h.Kind == "container" || h.Kind == "directory" {
-			foundData = true
 	}
-		fmt.Fprintf(&b, "  %s", heldLine(h))
+	return said + fmt.Sprintf("\n  run `push %s` to cut it over", node), nil
-		if h.Kept != "" {
-			fmt.Fprintf(&b, ", original kept at %s", h.Kept)
-		}
-		b.WriteString("\n")
-		for _, line := range comparisonLinesWith(h, c.keeps[h.ID], c.reported) {
-			fmt.Fprintf(&b, "    %s\n", line)
-		}
-		f := factsOf(h)
-		if f.downgrade && !opts.Downgrade {
-			refusals = append(refusals, fmt.Sprintf("%s: the module's image (%s, made %s) is older than the one running (%s, made %s) — "+
-				"a service that migrated its data forward may not start on it; `--downgrade` to take it anyway",
-				h.Target, f.declaredImage, day(f.declaredCreated), f.image, day(f.imageCreated)))
-		}
-		if f.differs && !opts.Replace[h.Target] && !opts.Replace["*"] {
-			refusals = append(refusals, fmt.Sprintf("%s: the module's content differs from the file found; the lines above "+
-				"marked - are lost by taking it; `--replace %s` to replace it anyway, or declare the file partially",
-				h.Target, h.Target))
-		}
-	}
-	// The module's secrets on the machine (rule 2 and 3): a service whose data was found already
-	// has a value for each, so one the mesh minted and nobody accepted refuses unless --mint says
-	// the service shall take a new one.
-	for _, sec := range c.secrets {
-		name := sec.Name
-		if sec.Local != "" {
-			name += " (" + sec.Local + ")"
-		}
-		what := "own secret"
-		accept := fmt.Sprintf("`secret accept <node> %s %s`", module, sec.Name)
-		if !sec.Own() {
-			what = "secret from " + sec.Provider
-			accept = fmt.Sprintf("`secret accept <node> %s %s --provider %s`", module, sec.Name, sec.Provider)
-			if sec.Local != "" {
-				accept = strings.TrimSuffix(accept, "`") + " --local " + sec.Local + "`"
-			}
-		}
-		switch {
-		case sec.Origin == inventory.OriginAccepted:
-			fmt.Fprintf(&b, "  %s %s: accepted from a person, carried in as it is\n", what, name)
-		case opts.Mint[sec.Name]:
-			fmt.Fprintf(&b, "  %s %s: minted by the mesh; the service takes the new value, as --mint said\n", what, name)
-		case foundData:
-			fmt.Fprintf(&b, "  %s %s: MINTED by the mesh and not accepted — the running service already has one\n", what, name)
-			refusals = append(refusals, fmt.Sprintf("%s: the mesh minted a value and the service whose data was found "+
-				"already uses its own; %s carries the existing value in, or `--mint %s` says the service shall take "+
-				"the new one", name, accept, sec.Name))
-		default:
-			fmt.Fprintf(&b, "  %s %s: minted by the mesh\n", what, name)
-		}
-	}
-	// And its settings on this machine, composed against its definition (rule 1, rule 6).
-	for _, layer := range c.layers {
-		keys := make([]string, 0, len(layer.Values))
-		for k := range layer.Values {
-			keys = append(keys, k)
-		}
-		sort.Strings(keys)
-		fmt.Fprintf(&b, "  settings from %s: %s\n", layer.From, strings.Join(keys, ", "))
-	}
-	if c.settingsRefused != "" {
-		fmt.Fprintf(&b, "  SETTINGS DO NOT COMPOSE with the module's definition, so the push leaves it out: %s\n", c.settingsRefused)
-	}
-	preview = strings.TrimRight(b.String(), "\n")
-	sum := sha256.Sum256([]byte(preview))
-	return preview, refusals, hex.EncodeToString(sum[:])[:12]
-}
-
-// facts is a held thing's facts as the preview reads them.
-type facts struct {
-	image, imageCreated, declaredImage, declaredCreated string
-	downgrade, differs                                  bool
-	networks                                            map[string][]string
-	mounts, ports, declaredPorts, declaredVolumes       []string
-	difference                                          []string
-}
-
-func factsOf(h inventory.Held) facts {
-	var f facts
-	if h.Facts == nil {
-		return f
-	}
-	str := func(k string) string { s, _ := h.Facts[k].(string); return s }
-	list := func(k string) []string {
-		var out []string
-		if raw, ok := h.Facts[k].([]any); ok {
-			for _, x := range raw {
-				if s, ok := x.(string); ok {
-					out = append(out, s)
-				}
-			}
-		}
-		return out
-	}
-	f.image, f.imageCreated = str("image"), str("image_created")
-	f.declaredImage, f.declaredCreated = str("declared_image"), str("declared_image_created")
-	f.downgrade, _ = h.Facts["downgrade"].(bool)
-	f.differs, _ = h.Facts["differs"].(bool)
-	f.mounts, f.ports = list("mounts"), list("ports")
-	f.declaredPorts, f.declaredVolumes, f.difference = list("declared_ports"), list("declared_volumes"), list("difference")
-	if raw, ok := h.Facts["networks"].(map[string]any); ok {
-		f.networks = map[string][]string{}
-		for name, members := range raw {
-			var out []string
-			if ms, ok := members.([]any); ok {
-				for _, m := range ms {
-					if s, ok := m.(string); ok {
-						out = append(out, s)
-					}
-				}
-			}
-			f.networks[name] = out
-		}
-	}
-	return f
-}
-
-// comparisonLines says a held thing's facts the way a person weighs them.
-func comparisonLines(h inventory.Held) []string {
-	return comparisonLinesWith(h, nil, inventory.Adoption{})
-}
-
-// comparisonLinesWith is comparisonLines knowing which found networks this machine's setting keeps
-// for the container (rule 4) and what the machine reports reachable, so a published port's reach
-// is said beside the port (rule 1).
-func comparisonLinesWith(h inventory.Held, keeps []string, reported inventory.Adoption) []string {
-	f := factsOf(h)
-	var out []string
-	if f.image != "" || f.declaredImage != "" {
-		line := fmt.Sprintf("runs %s", orNone(f.image))
-		if f.imageCreated != "" {
-			line += " (made " + day(f.imageCreated) + ")"
-		}
-		line += "; the module declares " + orNone(f.declaredImage)
-		switch {
-		case f.declaredCreated != "":
-			line += " (made " + day(f.declaredCreated) + ")"
-		case f.declaredImage != "":
-			line += " (not on the machine yet, so its age is unknown)"
-		}
-		if f.downgrade {
-			line += " — DOWNGRADE"
-		}
-		out = append(out, line)
-	}
-	names := make([]string, 0, len(f.networks))
-	for n := range f.networks {
-		names = append(names, n)
-	}
-	sort.Strings(names)
-	for _, n := range names {
-		members := f.networks[n]
-		if len(members) == 0 {
-			continue
-		}
-		if slices.Contains(keeps, n) {
-			out = append(out, fmt.Sprintf("on the network %s with %s — kept by this machine's setting, so they still reach it by name once taken",
-				n, strings.Join(members, ", ")))
-			continue
-		}
-		out = append(out, fmt.Sprintf("on the network %s with %s, which may reach it by name and will not once it moves to the module's own network"+
-			" (`settings set %s --node <node>` with {%q: {<container>: [%q]}} keeps it)",
-			n, strings.Join(members, ", "), h.Module, catalogue.NetworksSetting, n))
-	}
-	for _, n := range keeps {
-		if _, found := f.networks[n]; !found {
-			out = append(out, fmt.Sprintf("keeps the network %s by this machine's setting, which the found container is not on", n))
-		}
-	}
-	if len(f.ports) > 0 || len(f.declaredPorts) > 0 {
-		out = append(out, fmt.Sprintf("publishes %s; the module declares %s",
-			orNone(strings.Join(f.ports, " ")), orNone(strings.Join(f.declaredPorts, " "))))
-		// How far each published port reaches now, as the machine reported it: the listener the
-		// runtime publishes for this container. The found firewall's and the guard's rules are
-		// not read; what they let through is said as what was reported reachable.
-		var reach []string
-		for _, r := range reported.Reachable {
-			if r.By == h.Target && r.Published {
-				reach = append(reach, fmt.Sprintf("%s:%d (%s, container port %d)", r.Address, r.Port, r.Protocol, r.ContainerPort))
-			}
-		}
-		switch {
-		case len(reach) > 0:
-			line := "reachable now at " + strings.Join(reach, ", ")
-			if reported.Firewall != "" && reported.Firewall != "none" {
-				line += ", behind the found firewall (" + reported.Firewall + "), whose rules are not read"
-			}
-			out = append(out, line)
-		case len(f.ports) > 0 && len(reported.Reachable) > 0:
-			out = append(out, "not reported reachable on the machine")
-		}
-	}
-	if len(f.mounts) > 0 || len(f.declaredVolumes) > 0 {
-		out = append(out, fmt.Sprintf("mounts %s; the module declares %s",
-			orNone(strings.Join(f.mounts, " ")), orNone(strings.Join(f.declaredVolumes, " "))))
-	}
-	if f.differs {
-		out = append(out, "the declared content differs from the file found (- lost, + new):")
-		for _, d := range f.difference {
-			out = append(out, "  "+d)
-		}
-	}
-	return out
-}
-
-// day is a timestamp as a person reads it in a preview: its date.
-func day(stamp string) string {
-	if len(stamp) >= 10 {
-		return stamp[:10]
-	}
-	return stamp
 }
 
 // reportFreshFor is how old a node's account of itself may be for the flip to act on it. A
@@ -720,11 +310,7 @@ func converge(ctx context.Context, open *stores, node string, yes bool, digest s
 	}
 	derived := derivedFilter{rules: rules, foundation: with.Foundation, mesh: with.Mesh,
 		outward: plan.PublicDomain != "", outwardLinks: with.OutwardLinks}
-	filtering, err := inv.FilteringOf(ctx, node)
+	preview, saw := previewOf(node, reported, derived, plan, taken, filter, runs[filter])
-	if err != nil {
-		return "", err
-	}
-	preview, saw := previewOf(node, reported, filtering, derived, plan, taken, filter, runs[filter])
 	preview += "\n\n  preview " + saw
 	if !yes {
 		return preview + fmt.Sprintf("\n\nNothing has changed. Run `converge %s --yes %s` to do "+
@@ -794,7 +380,7 @@ func converge(ctx context.Context, open *stores, node string, yes bool, digest s
 // previewOf is what converging a node will change, before it changes it, and a short digest of
 // what it said: every reachable thing and its fate, the modules the flip takes and the filter. The
 // digest is what the flip is asked to act on, so it changes whenever any of those would.
-func previewOf(node string, reported inventory.Adoption, filtering inventory.Filtering, derived derivedFilter,
+func previewOf(node string, reported inventory.Adoption, derived derivedFilter,
 	plan catalogue.Resolution, taken []string, filter string, filterAssigned bool) (string, string) {
 	var said []string
 	var b strings.Builder
@@ -886,30 +472,6 @@ func previewOf(node string, reported inventory.Adoption, filtering inventory.Fil
 		fmt.Fprintf(&b, "  the found firewall (%s) is disabled, never flushed: its configuration stays on disk\n", fw)
 	}
 	said = append(said, fmt.Sprintf("filter %s assigned=%t firewall=%s", filter, filterAssigned, fw))
-	// What filters the machine now, and the fate of each (novox/hq ADR 0168): the found firewall
-	// retired, the runtime's own and bans left, and what the mesh did not write left and named —
-	// so the reader knows before the flip that the machine will not be filtered by the mesh alone.
-	if len(filtering.Filters) > 0 {
-		b.WriteString("\n  what filters the machine now, and what the flip does to each:\n")
-		for _, x := range filtering.Filters {
-			fate := "left: " + x.Owner + "'s"
-			switch x.Owner {
-			case inventory.FilterMesh:
-				fate = "the mesh's guard; replaced by its filter"
-			case inventory.FilterFoundFirewall:
-				fate = "the found firewall's; retired with it"
-			case inventory.FilterRuntime:
-				fate = "the container runtime's own; left"
-			case inventory.FilterBan:
-				fate = "a ban list; left"
-			case inventory.FilterOther:
-				fate = "NOT THE MESH'S; left in force — the machine is not filtered by the mesh alone until you remove it"
-			}
-			fmt.Fprintf(&b, "    %-50s %s\n", x.Where, fate)
-			fmt.Fprintf(&b, "    %-50s   %s\n", "", x.Refuses)
-			said = append(said, "filter "+x.Owner+" "+x.Where)
-		}
-	}
 	// Sorted: the same account, reported in another order, is the same preview.
 	sort.Strings(said)
 	sum := sha256.Sum256([]byte(strings.Join(said, "\n")))
@@ -1034,39 +596,12 @@ func adopt(ctx context.Context, open *stores, node string) (string, error) {
 
 // takeCommand, convergeCommand and adoptCommand are the command line's adapters to the acts above.
 func takeCommand(ctx context.Context, args []string) error {
-	set := flag.NewFlagSet("take", flag.ContinueOnError)
+	if len(args) != 2 {
-	yes := set.Bool("yes", false, "cut over as previewed, naming the digest the preview printed after it; "+
+		return errors.New("take <node> <module>")
-		"without it the comparison is printed and nothing is taken")
-	downgrade := set.Bool("downgrade", false, "take it although the module's image is older than the one running")
-	var replace, mint stringList
-	set.Var(&replace, "replace", "a found file's path whose content the module may replace although it differs (repeatable; * for every one)")
-	set.Var(&mint, "mint", "a secret the service shall take the mesh's minted value for, although it already has its own (repeatable)")
-	positionals, err := parseAround(set, args)
-	if err != nil {
-		return err
 	}
-	if len(positionals) < 2 || len(positionals) > 3 || (len(positionals) == 3 && !*yes) {
+	return runAct(ctx, func(open *stores) (string, error) { return take(ctx, open, args[0], args[1]) })
-		return errors.New("take <node> <module> [--yes <digest>] [--downgrade] [--replace <path>]... [--mint <secret>]...")
-	}
-	opts := takeOptions{Yes: *yes, Downgrade: *downgrade, Replace: map[string]bool{}, Mint: map[string]bool{}}
-	if len(positionals) == 3 {
-		opts.Digest = positionals[2]
-	}
-	for _, r := range replace {
-		opts.Replace[r] = true
-	}
-	for _, m := range mint {
-		opts.Mint[m] = true
-	}
-	return runAct(ctx, func(open *stores) (string, error) { return take(ctx, open, positionals[0], positionals[1], opts) })
 }
 
-// stringList is a repeatable flag.
-type stringList []string
-
-func (l *stringList) String() string     { return strings.Join(*l, ",") }
-func (l *stringList) Set(v string) error { *l = append(*l, v); return nil }
-
 func convergeCommand(ctx context.Context, args []string) error {
 	set := flag.NewFlagSet("converge", flag.ContinueOnError)
 	yes := set.String("yes", "", "do it, naming the digest the preview printed; without it, only "+

cmd/mesh-controller/api.go

@@ -102,7 +102,7 @@ func commands(who Authenticator) http.Handler {
 	}))
 	// Adoption (novox/hq ADR 0100): the same acts as `take`, `converge` and `adopt`.
 	mux.HandleFunc("POST /take", acting(who, true, func(ctx context.Context, open *stores, in request) (string, error) {
-		return take(ctx, open, in.Node, in.Module, takeOptions{Yes: in.Yes, Digest: in.Digest})
+		return take(ctx, open, in.Node, in.Module)
 	}))
 	mux.HandleFunc("POST /converge", acting(who, false, func(ctx context.Context, open *stores, in request) (string, error) {
 		return converge(ctx, open, in.Node, in.Yes, in.Digest, in.Filter)
@@ -124,8 +124,8 @@ func commands(who Authenticator) http.Handler {
 type request struct {
 	Node   string `json:"node"`
 	Module string `json:"module"`
-	// Yes, Digest and Filter are converge's and take's: do it rather than preview it, the digest
+	// Yes, Digest and Filter are converge's: do it rather than preview it, the digest of the
-	// of the preview it acts on, and (converge) which module loads the mesh's filter.
+	// preview it acts on, and which module loads the mesh's filter.
 	Yes    bool   `json:"yes,omitempty"`
 	Digest string `json:"digest,omitempty"`
 	Filter string `json:"filter,omitempty"`

cmd/mesh-controller/build.go

@@ -10,8 +10,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/nats-io/nats.go"
-
 	"github.com/novox/mesh-controller/internal/broker"
 	"github.com/novox/mesh-controller/internal/catalogue"
 	"github.com/novox/mesh-controller/internal/inventory"
@@ -148,11 +146,6 @@ func buildFrom(result link.BuildResult) inventory.Build {
 		// rebuild the graph rather than a list of names.
 		Path: result.Path,
 	}
-	// When it was asked, which is what orders it against another build of the same module
-	// (novox/hq 04-ISSUES/219) — not when it was heard.
-	if asked, ok := link.BuildAskedAt(result.ID); ok {
-		kept.Asked = asked
-	}
 	for _, ref := range result.Against {
 		kept.Against = append(kept.Against, catalogue.Recorded(ref))
 	}
@@ -182,14 +175,10 @@ func buildFrom(result link.BuildResult) inventory.Build {
 func buildsCommand(ctx context.Context, args []string) error {
 	set := flag.NewFlagSet("builds", flag.ContinueOnError)
 	limit := set.Int("n", 20, "how many to show")
-	logOf := set.String("log", "", "a build's id: print what the build machine said, line by line")
 	positionals, err := parseAround(set, args)
 	if err != nil {
 		return err
 	}
-	if *logOf != "" {
-		return buildLog(ctx, *logOf)
-	}
 	module := ""
 	if len(positionals) == 1 {
 		module = positionals[0]
@@ -230,8 +219,8 @@ func buildsCommand(ctx context.Context, args []string) error {
 		if !b.Worked() {
 			outcome = "failed"
 		}
-		fmt.Printf("%-18s %-14s %-10s %s  %s\n",
+		fmt.Printf("%-18s %-14s %-10s %s\n",
-			what, outcome, b.On, b.At.Local().Format("2006-01-02 15:04"), b.ID)
+			what, outcome, b.On, b.At.Local().Format("2006-01-02 15:04"))
 		fmt.Printf("    %s", b.Repository)
 		if b.Ref != "" {
 			fmt.Printf(" at %s", b.Ref)
@@ -414,19 +403,16 @@ func buildOne(ctx context.Context, source buildSource, path, ref string, wait ti
 	// Correlated by something the control plane makes, not by the module's name: two builds of one
 	// module can be in flight, and the second answer is not the first one's.
 	request := link.BuildRequest{
-		ID:         link.NewBuildID(time.Now()),
+		ID:         fmt.Sprintf("%s-%d", "build", time.Now().UnixNano()),
 		Repository: repository,
 		Path:       path,
 		Ref:        ref,
 		Held:       heldBy(ctx),
-		Seats:      seatBases(ctx),
 	}
 	fmt.Printf("asked for %s", source)
 	if source.Seat != "" {
 		fmt.Printf(" (%s)", repository)
 	}
-	// The id is how a person follows this build while it runs: `builds --log <id>`.
-	fmt.Printf(" as %s", request.ID)
 	if path != "" {
 		fmt.Printf(" at %s", path)
 	}
@@ -435,134 +421,70 @@ func buildOne(ctx context.Context, source buildSource, path, ref string, wait ti
 	}
 	fmt.Println()
 
-	seat := buildSeatHeld(ctx)
+	ask, err := askOver(server)
-	ask, err := askOverOn(seat)
 	if err != nil {
 		return err
 	}
 	defer ask.Close()
-	fmt.Printf("  of %s\n", seat)
-
-	if wait == 0 {
-		// Asked and not waited for (novox/hq issue 176): the outcome is the role's event, and the
-		// controller takes it in — records the build, registers the module — whether or not anybody
-		// is still here. A tool call cannot hold a connection for the minutes a build takes; it
-		// follows the build by its id instead.
-		if err := ask.Ask(ctx, request); err != nil {
-			return err
-		}
-		fmt.Printf("asked, not waited for: `builds --log %s` follows it as it runs, and `builds` "+
-			"shows what came of it; the module is registered when the outcome comes\n", request.ID)
-		return nil
-	}
 
 	result, err := ask.Submit(ctx, request, wait)
 	if err != nil {
 		return err
 	}
 
+	// Kept before it is judged. A failed build that leaves no trace is indistinguishable from one
+	// nobody asked for, and the difference is the whole of whether somebody should be looking at
+	// something.
 	open, err := openStores(ctx)
 	if err != nil {
 		return err
 	}
 	defer open.Close()
-	manifest, kept, err := takeIn(ctx, open.inventory, result)
+	inv := open.inventory
-	if err != nil {
+	kept := buildFrom(result)
+	if err := inv.RecordBuild(ctx, kept); err != nil {
 		return err
 	}
+
+	if result.Failed != "" {
+		// The builder's own words. Wrapping them in something about the control plane would put
+		// two explanations between a person and a build log.
+		return fmt.Errorf("%s could not build %s:\n%s", result.On, result.Repository, result.Failed)
+	}
+
 	// Said as recorded: what each artifact is, not where this builder happened to push it.
 	for _, made := range kept.Made {
 		fmt.Printf("  %-12s %s %s\n", made.Name, made.Kind, made.Reference)
 	}
-	fmt.Printf("\n%s %s, built on %s from %s\n",
-		manifest.Module, manifest.Version, result.On, short(result.Commit))
-	saysWhenThePolicyActs(ctx, open.inventory, manifest.Module)
-	fmt.Printf("  run `assign <node> %s` to put it somewhere\n", manifest.Module)
-	return nil
-}
 
-// saysWhenThePolicyActs tells whoever built a module that its upgrade policy will send the
+	// Parsed with the same parser a hand-written manifest goes through. A second path would be a
-// result on at once (novox/hq issue 126, ADR 0163): a person choreographing a data move must
+	// second thing to disagree about what a manifest is. The manifest as recorded, so the catalogue
-// know which module will not wait for them.
+	// holds references by digest and path and every declaration composes the store's address in.
-func saysWhenThePolicyActs(ctx context.Context, inv *inventory.Inventory, module string) {
-	if u, err := inv.UpgradeOf(ctx, module); err == nil && u.RollOut {
-		how := "one machine at a time"
-		if u.Together {
-			how = "every machine at once"
-		}
-		fmt.Printf("  %s rolls out on build: the machines running it are sent this now, %s — "+
-			"`upgrade %s record` first if something must move before it does\n", module, how, module)
-	}
-}
-
-// takeIn is what the mesh does with a build's outcome, whoever hears it: the waiting command and
-// the daemon that follows the role's events both come here (novox/hq issue 176), so a build's
-// result reaches the catalogue whether or not the asker was still listening.
-//
-// Kept before it is judged. A failed build that leaves no trace is indistinguishable from one
-// nobody asked for, and the difference is the whole of whether somebody should be looking at
-// something. Then parsed with the same parser a hand-written manifest goes through — a second path
-// would be a second thing to disagree about what a manifest is — and registered with where it came
-// from: **for a source on a seat, as the path and the seat, never the URL just cloned** (ADR 0111),
-// which the request carried and the outcome echoes. A definition naming an installation is refused
-// here, where it would enter the catalogue; the build stays recorded and the refusal says which.
-//
-// Idempotent: the same outcome taken in twice registers the same module twice, which is one row
-// written with the same values.
-func takeIn(ctx context.Context, inv *inventory.Inventory, result link.BuildResult) (
-	catalogue.Manifest, inventory.Build, error) {
-	kept := buildFrom(result)
-	if err := inv.RecordBuild(ctx, kept); err != nil {
-		return catalogue.Manifest{}, kept, err
-	}
-	if result.Failed != "" {
-		// The builder's own words. Wrapping them in something about the control plane would put
-		// two explanations between a person and a build log.
-		return catalogue.Manifest{}, kept, fmt.Errorf("%s could not build %s:\n%s",
-			result.On, result.Repository, result.Failed)
-	}
 	manifest, err := catalogue.ParseManifest(kept.Manifest)
 	if err != nil {
-		return catalogue.Manifest{}, kept, fmt.Errorf("%s built %s and what came back is not a manifest: %w",
+		return fmt.Errorf("%s built %s and what came back is not a manifest: %w",
 			result.On, result.Repository, err)
 	}
+
+	// Recorded with where it came from, so "is this current?" is answerable without building it
+	// again (novox/hq ADR 0009). **For a source on a seat, as the path and the seat, never the URL
+	// just cloned** (ADR 0111): the URL is where the forge runs today, and recording it would put
+	// the forge's address back into every module built from it. The build log above keeps the URL,
+	// because that is what was cloned.
 	recorded := inventory.Source{
 		Repository: result.Repository, Path: result.Path, Ref: result.Ref,
 		BuiltFrom: result.Commit, Head: result.Commit,
-		// What it stood on, so registration can judge a built manifest's base (to-be 38 WP2.4).
-		Against: kept.Against,
-		// When it was asked, so an older request heard later does not replace a newer one
-		// (novox/hq 04-ISSUES/219).
-		Asked: kept.Asked,
 	}
-	if result.Source != nil && result.Source.Seat != "" {
+	if source.Seat != "" {
-		recorded.Repository, recorded.Seat = result.Source.Repository, result.Source.Seat
+		recorded.Repository, recorded.Seat = source.Repository, source.Seat
-	}
-	// **A build at a commit does not change the branch a module follows** (novox/hq 04-ISSUES/215):
-	// the commit is built and recorded as what it was built from, and the module keeps following
-	// what it followed before — the repository's default branch for one new to the catalogue.
-	if followedBranch(result.Ref) == "" && result.Ref != "" {
-		recorded.Ref = ""
-		if was, err := inv.SourceOf(ctx, manifest.Module); err == nil {
-			recorded.Ref = followedBranch(was.Ref)
-		}
-	}
-	if err := namesNoInstallation(manifest); err != nil {
-		return manifest, kept, fmt.Errorf("%s built %s (%s), and the mesh does not register it: %w",
-			result.On, result.Repository, short(result.Commit), err)
 	}
 	if err := inv.RegisterModule(ctx, manifest, recorded); err != nil {
-		if errors.Is(err, inventory.ErrSuperseded) {
+		return err
-			return manifest, kept, fmt.Errorf("%s built %s (%s), recorded and not registered: %w",
-				result.On, manifest.Module, short(result.Commit), err)
 	}
-		return manifest, kept, err
+	fmt.Printf("\n%s %s, built on %s from %s\n",
-	}
+		manifest.Module, manifest.Version, result.On, short(result.Commit))
-	// The keep set just moved, and new bytes just landed (novox/hq ADR 0189). Asked here rather
+	fmt.Printf("  run `assign <node> %s` to put it somewhere\n", manifest.Module)
-	// than on a timer of its own: this is the only moment either is true. Never fatal — the build
+	return nil
-	// worked and the module is registered.
-	collect(ctx, inv)
-	return manifest, kept, nil
 }
 
 // buildAndShow builds and prints the manifest without recording anything.
@@ -582,16 +504,16 @@ func buildAndShow(ctx context.Context, source buildSource, path, ref string, wai
 	}
 	defer server.Close()
 
-	ask, err := askOverOn(buildSeatHeld(ctx))
+	ask, err := askOver(server)
 	if err != nil {
 		return err
 	}
 	defer ask.Close()
 
 	result, err := ask.Submit(ctx, link.BuildRequest{
-		ID:         link.NewBuildID(time.Now()),
+		ID:         fmt.Sprintf("%s-%d", "build", time.Now().UnixNano()),
 		Repository: repository, Path: path, Ref: ref,
-		Held: heldBy(ctx), Seats: seatBases(ctx),
+		Held: heldBy(ctx),
 	}, wait)
 	if err != nil {
 		return err
@@ -625,8 +547,6 @@ type answers struct {
 	// pair that answers "has it caught up", which waiting alone cannot (the sent digest is
 	// recorded at send, not at apply).
 	reported []inventory.Reported
-	// plans is what the last merges produced and where each stands (novox/hq ADR 0162).
-	plans []inventory.Plan
 	// refused is why a machine cannot be worked out at all, by name. A different thing from every
 	// other answer here: those are about a machine that was told something, and this is about one
 	// that cannot be told anything — it never reaches waiting, because nothing was computed for it
@@ -636,10 +556,6 @@ type answers struct {
 	// a consequence of the refusals above: a node that does not resolve is not on the network, and
 	// a mesh whose hub is that node has no hub.
 	network string
-	// filtered is every converged machine that is not filtered by the mesh alone (novox/hq ADR
-	// 0168): what filters it beyond the mesh's own, the runtime's plumbing and bans, by name — a
-	// predecessor's chain, a found firewall in force again. Such a machine is not "all well".
-	filtered map[string]inventory.Filtering
 	// untaken is, per machine, each assigned module whose resources the machine is holding as it
 	// found them, and how many — a module that was assigned, sent, and is running none of what it
 	// declares because nothing has taken it (novox/hq ADR 0100, 04-ISSUES/125).
@@ -695,111 +611,10 @@ func heldBy(ctx context.Context) map[string]string {
 // **One place chooses**, as everywhere else the bus change went (novox/hq ADR 0116 step 5). On the bus
 // the mesh runs on today this needs the controller's own connection, so it is handed one; on the bus
 // being built it dials, because a build request is a one-shot and holds nothing else.
-func askOverOn(seat string) (link.Builders, error) {
+func askOver(_ *link.Server) (link.Builders, error) {
 	address, err := broker.BusAddress()
 	if err != nil {
 		return nil, err
 	}
-	return link.BuildsOverNATSOn(address, seat)
+	return link.BuildsOverNATS(address)
-}
-
-// buildSeatHeld is the build role to ask: the one some assigned module claims (novox/hq ADR 0190,
-// the handover). Read from the catalogue at ask time, because the answer changes exactly once, the
-// moment the first build-agent is assigned — and a controller that asked the new role before then
-// would queue work nothing takes, while the outcome that registers build-agent itself has to come
-// from the old builder. When the catalogue cannot be read the current role is asked, said aloud.
-func buildSeatHeld(ctx context.Context) string {
-	open, err := openStores(ctx)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "could not read what is assigned, so the build is asked of %s: %v\n",
-			link.TheBuildMachine, err)
-		return link.TheBuildMachine
-	}
-	defer open.Close()
-	entries, err := open.inventory.Catalogued(ctx)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "could not read the catalogue, so the build is asked of %s: %v\n",
-			link.TheBuildMachine, err)
-		return link.TheBuildMachine
-	}
-	return buildSeatAmong(entries)
-}
-
-// buildSeatAmong is the rule, over what the catalogue holds: the current build role when any
-// assigned module claims it; else the retired role while an assigned module still claims that; else
-// the current role, which is where every ask goes once the handover is done.
-func buildSeatAmong(entries []inventory.Entry) string {
-	heldBefore := false
-	for _, e := range entries {
-		if len(e.On) == 0 {
-			continue
-		}
-		if e.Manifest.ClaimsSeat(link.TheBuildMachine) {
-			return link.TheBuildMachine
-		}
-		if e.Manifest.ClaimsSeat(link.TheBuildMachineBefore) {
-			heldBefore = true
-		}
-	}
-	if heldBefore {
-		return link.TheBuildMachineBefore
-	}
-	return link.TheBuildMachine
-}
-
-// buildLog prints everything a build machine said about one build, read back from the bus.
-//
-// **From the stream, not from a record** (novox/hq ADR 0157). A build's lines are the role's own
-// events under the build's id, retained with every other event; the mesh keeps no second copy. Read
-// with a consumer of its own that is gone when this returns, so nothing accumulates in the server
-// for the reading, and filtered by subject, so one build's lines are all that travel.
-func buildLog(ctx context.Context, id string) error {
-	address, err := broker.BusAddress()
-	if err != nil {
-		return err
-	}
-	js, err := broker.Dial(address)
-	if err != nil {
-		return fmt.Errorf("cannot reach the bus to read a build's log: %w", err)
-	}
-	defer js.Close()
-
-	// Under whichever build role did it: a build asked of the retired role during the handover
-	// (ADR 0190) said its lines as that role's events, and a reader should not have to know which.
-	lines := link.BuildLogOf("*", id)
-	sub, err := js.Context().PullSubscribe(lines, "",
-		nats.BindStream(broker.EventsStream), nats.DeliverAll(), nats.AckNone())
-	if err != nil {
-		return fmt.Errorf("cannot read %s from the bus: %w", lines, err)
-	}
-	defer func() { _ = sub.Unsubscribe() }()
-
-	printed := 0
-	for {
-		batch, err := sub.Fetch(200, nats.MaxWait(2*time.Second))
-		if err != nil && !errors.Is(err, nats.ErrTimeout) && !errors.Is(err, context.DeadlineExceeded) {
-			return fmt.Errorf("reading a build's log: %w", err)
-		}
-		for _, msg := range batch {
-			var line link.BuildLine
-			if err := json.Unmarshal(msg.Data, &line); err != nil {
-				fmt.Printf("  ? %s\n", string(msg.Data))
-				continue
-			}
-			at := line.At
-			if t, err := time.Parse(time.RFC3339Nano, line.At); err == nil {
-				at = t.Local().Format("15:04:05")
-			}
-			fmt.Printf("%s %4d [%s] %s\n", at, line.Seq, line.Step, line.Message)
-			printed++
-		}
-		if len(batch) < 200 {
-			break
-		}
-	}
-	if printed == 0 {
-		fmt.Printf("nothing on the bus for build %s: no build by that id in the last week, or a build "+
-			"machine older than this that said nothing while building\n", id)
-	}
-	return nil
 }

cmd/mesh-controller/build_seat_test.go

@@ -1,43 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-	"github.com/novox/mesh-controller/internal/inventory"
-	"github.com/novox/mesh-controller/internal/link"
-)
-
-func claiming(module, seat string, on ...string) inventory.Entry {
-	return inventory.Entry{
-		Manifest: catalogue.Manifest{Module: module, Claims: []catalogue.Claim{{Name: seat}}},
-		On:       on,
-	}
-}
-
-// The controller asks the build role that has a holder (novox/hq ADR 0190 handover): the retired
-// one while only the builder is assigned, the current one from the first build-agent on, and the
-// current one when nothing holds either — where every ask goes once the handover is done.
-func TestTheControllerAsksTheBuildRoleThatHasAHolder(t *testing.T) {
-	onlyTheBuilder := []inventory.Entry{
-		claiming("builder", link.TheBuildMachineBefore, "anchor"),
-		claiming("build-agent", link.TheBuildMachine), // registered, assigned nowhere yet
-	}
-	if got := buildSeatAmong(onlyTheBuilder); got != link.TheBuildMachineBefore {
-		t.Errorf("with only the builder assigned, asked %q", got)
-	}
-	bothHeld := []inventory.Entry{
-		claiming("builder", link.TheBuildMachineBefore, "anchor"),
-		claiming("build-agent", link.TheBuildMachine, "home-server"),
-	}
-	if got := buildSeatAmong(bothHeld); got != link.TheBuildMachine {
-		t.Errorf("with a build-agent assigned anywhere, asked %q", got)
-	}
-	neither := []inventory.Entry{claiming("builder", link.TheBuildMachineBefore)}
-	if got := buildSeatAmong(neither); got != link.TheBuildMachine {
-		t.Errorf("with no holder of either, asked %q, want the current role", got)
-	}
-	if got := buildSeatAmong(nil); got != link.TheBuildMachine {
-		t.Errorf("an empty catalogue asks %q", got)
-	}
-}

cmd/mesh-controller/build_test.go

@@ -1,152 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"errors"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/novox/mesh-controller/internal/inventory"
-	"github.com/novox/mesh-controller/internal/link"
-)
-
-// A build's outcome is taken in the same way whoever hears it (novox/hq issue 176): recorded, and
-// the module registered with its source as the seat and path when the request said so — never the
-// URL. A definition naming an installation is recorded and not registered; a failure is recorded
-// and said.
-func TestABuildHeardIsRecordedAndRegistered(t *testing.T) {
-	open := aMesh(t)
-	ctx := t.Context()
-	manifest, _ := json.Marshal(map[string]any{"module": "shop", "version": "3"})
-	m, _, err := takeIn(ctx, open.inventory, link.BuildResult{
-		ID: "b-1", Repository: "http://forge.internal:20000/novox/shop.git", Path: "modules/shop",
-		Ref: "main", On: "anchor", Commit: "abcdef0123", Manifest: manifest,
-		Source: &link.SourceOnSeat{Seat: "git", Repository: "novox/shop"},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if m.Module != "shop" {
-		t.Fatalf("registered %q", m.Module)
-	}
-	shelf, err := open.inventory.Catalogue(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, held := shelf["shop"]; !held {
-		t.Fatal("the module a heard build produced is not in the catalogue")
-	}
-	src, err := open.inventory.SourceOf(ctx, "shop")
-	if err != nil || src.Seat != "git" || src.Repository != "novox/shop" || src.BuiltFrom != "abcdef0123" {
-		t.Fatalf("the source is the seat and the path, never the URL: %+v %v", src, err)
-	}
-	builds, err := open.inventory.Builds(ctx, "shop", 5)
-	if err != nil || len(builds) != 1 || builds[0].ID != "b-1" {
-		t.Fatalf("the build is not recorded once: %v %v", builds, err)
-	}
-
-	named, _ := json.Marshal(map[string]any{"module": "idp", "version": "1", "resources": []any{
-		map[string]any{"id": "server", "type": "container", "image": "x@sha256:aa",
-			"env": map[string]any{"KC_HOSTNAME": "https://login.mesh-one.be"}}}})
-	_, _, err = takeIn(ctx, open.inventory, link.BuildResult{
-		ID: "b-2", Repository: "/r", On: "anchor", Commit: "0123456789", Manifest: named})
-	if err == nil || !strings.Contains(err.Error(), "does not register it") {
-		t.Fatalf("a definition naming an installation was taken in: %v", err)
-	}
-	if shelf, _ := open.inventory.Catalogue(ctx); shelf["idp"].Module != "" {
-		t.Fatal("the refused module was registered anyway")
-	}
-	if builds, _ := open.inventory.Builds(ctx, "idp", 5); len(builds) != 1 {
-		t.Fatalf("the refused build was not recorded: %v", builds)
-	}
-
-	_, _, err = takeIn(ctx, open.inventory, link.BuildResult{ID: "b-3", Repository: "/r", On: "anchor", Failed: "no compiler"})
-	if err == nil || !strings.Contains(err.Error(), "no compiler") {
-		t.Fatalf("a failure is said in the builder's words: %v", err)
-	}
-}
-
-// novox/hq 04-ISSUES/215: a build asked at a commit is recorded as built from that commit, and the
-// module keeps following the branch it followed — a new one, the default branch.
-func TestABuildAtACommitKeepsTheBranchTheModuleFollows(t *testing.T) {
-	open := aMesh(t)
-	ctx := t.Context()
-	manifest, _ := json.Marshal(map[string]any{"module": "unifi", "version": "1"})
-	result := func(id, ref, commit string) link.BuildResult {
-		return link.BuildResult{ID: id, Repository: "http://forge.internal:20000/novox/mesh-catalog.git",
-			Path: "modules/unifi", Ref: ref, On: "anchor", Commit: commit, Manifest: manifest,
-			Source: &link.SourceOnSeat{Seat: "git", Repository: "novox/mesh-catalog"}}
-	}
-	if _, _, err := takeIn(ctx, open.inventory, result("b-1", "main", "1111111aaaa")); err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := takeIn(ctx, open.inventory, result("b-2", "9c97a8a", "9c97a8a1d2c3")); err != nil {
-		t.Fatal(err)
-	}
-	src, err := open.inventory.SourceOf(ctx, "unifi")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if src.Ref != "main" || src.BuiltFrom != "9c97a8a1d2c3" {
-		t.Errorf("after a build at a commit the module follows %q, built from %q; want main, 9c97a8a1d2c3", src.Ref, src.BuiltFrom)
-	}
-
-	// One new to the catalogue, first built at a commit, follows the default branch.
-	other, _ := json.Marshal(map[string]any{"module": "letta", "version": "1"})
-	r := result("b-3", "deadbeef", "deadbeefcafe")
-	r.Manifest, r.Path = other, "modules/letta"
-	if _, _, err := takeIn(ctx, open.inventory, r); err != nil {
-		t.Fatal(err)
-	}
-	if src, _ := open.inventory.SourceOf(ctx, "letta"); src.Ref != "" {
-		t.Errorf("a module first built at a commit follows %q, want the default branch", src.Ref)
-	}
-}
-
-// novox/hq 04-ISSUES/219: an older request heard after a newer one is recorded and not registered,
-// so a push sends what the newer request built.
-func TestAnOlderBuildHeardLaterDoesNotReplaceTheNewer(t *testing.T) {
-	open := aMesh(t)
-	ctx := t.Context()
-	older := time.Date(2026, 10, 3, 21, 33, 45, 0, time.UTC)
-	newer := time.Date(2026, 10, 3, 21, 51, 57, 0, time.UTC)
-	result := func(asked time.Time, image string) link.BuildResult {
-		manifest, _ := json.Marshal(map[string]any{"module": "postgres", "version": image})
-		return link.BuildResult{ID: link.NewBuildID(asked), Repository: "http://forge.internal:20000/novox/mesh-catalog.git",
-			Path: "modules/postgres", Ref: "main", On: "anchor", Commit: "efff5415", Manifest: manifest,
-			Source: &link.SourceOnSeat{Seat: "git", Repository: "novox/mesh-catalog"}}
-	}
-	if _, _, err := takeIn(ctx, open.inventory, result(newer, "4bcd5f73")); err != nil {
-		t.Fatal(err)
-	}
-	_, _, err := takeIn(ctx, open.inventory, result(older, "0ab07fa9"))
-	if !errors.Is(err, inventory.ErrSuperseded) {
-		t.Fatalf("the older request's outcome was taken in as current: %v", err)
-	}
-	shelf, err := open.inventory.Catalogue(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got := shelf["postgres"].Version; got != "4bcd5f73" {
-		t.Errorf("postgres is %q; want the newer request's 4bcd5f73", got)
-	}
-	if builds, _ := open.inventory.Builds(ctx, "postgres", 5); len(builds) != 2 {
-		t.Errorf("the late build was not recorded: %v", builds)
-	}
-}
-
-func TestABuildIDSaysWhenItWasAsked(t *testing.T) {
-	at := time.Date(2026, 10, 3, 21, 51, 57, 392539762, time.UTC)
-	if got, ok := link.BuildAskedAt(link.NewBuildID(at)); !ok || !got.Equal(at) {
-		t.Errorf("read back %v %v; want %v", got, ok, at)
-	}
-	if got, ok := link.BuildAskedAt("build-1791064317392539762"); !ok || got.Format(time.TimeOnly) != "21:51:57" {
-		t.Errorf("the incident's id reads as %v %v", got, ok)
-	}
-	for _, id := range []string{"b-1", "build-2", "build-", "build-x", ""} {
-		if _, ok := link.BuildAskedAt(id); ok {
-			t.Errorf("%q read as a request time", id)
-		}
-	}
-}

cmd/mesh-controller/check.go

@@ -1,147 +0,0 @@
-package main
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-)
-
-// moduleCheck judges manifests where they are written, with no mesh (novox/hq ADR 0037, issue 148).
-//
-// **The same functions registration runs, and nothing the command line adds** (ADR 0035): the strict
-// parse with every per-manifest problem, then the rules no single manifest can be judged against,
-// over exactly the manifests given. Somebody describing their own application in their own
-// repository runs this before pushing and finds out there, rather than when a running mesh refuses
-// the registration or, later, when a machine applies something that resolved and should not have.
-//
-// **What it cannot know without a store, it says.** The mesh's own seat set is the store's (ADR
-// 0122); this binary carries a compiled copy that the store overrides when loaded, so a claim on a
-// mesh seat is judged fully only at registration. A seat another module declares is unknown unless
-// that module's manifest is passed too. Both are printed as a note, not as a problem — a check that
-// refused what it could not see would teach people to ignore it.
-func moduleCheck(paths []string, out io.Writer) error {
-	if len(paths) == 0 {
-		return errors.New("module check <manifest.json>... — one file per module; pass every " +
-			"manifest of a repository together so the rules between them are checked too")
-	}
-	shelf := catalogue.Shelf{}
-	faulted := map[string]bool{}
-	failed := 0
-	for _, path := range paths {
-		raw, err := os.ReadFile(path)
-		if err != nil {
-			fmt.Fprintf(out, "%s: %v\n", path, err)
-			failed++
-			continue
-		}
-		m, err := catalogue.ParseManifest(raw)
-		if err != nil {
-			fmt.Fprintf(out, "%s: %v\n", path, err)
-			failed++
-			continue
-		}
-		if first, twice := shelf[m.Module]; twice {
-			_ = first
-			fmt.Fprintf(out, "%s: %s was already given; two manifests name one module\n", path, m.Module)
-			failed++
-			continue
-		}
-		// A definition names no installation (novox/hq ADR 0112, ADR 0155): judged here, in the
-		// catalogue-wide test, and at registration, which refuses in the same words.
-		if named := catalogue.InstallationProblems(m); len(named) > 0 {
-			for _, p := range named {
-				fmt.Fprintf(out, "%s: %s\n", path, p)
-			}
-			failed += len(named)
-			faulted[m.Module] = true
-		}
-		shelf[m.Module] = m
-	}
-
-	// Between the manifests: a seat declared twice, a use of a seat nothing declares, a claim on
-	// a seat that does not exist. Run only over what parsed, because a problem inside one manifest
-	// has already been said and would be said again here in a worse form.
-	problems := catalogue.CatalogueProblems(shelf)
-	sort.Strings(problems)
-	for _, p := range problems {
-		fmt.Fprintln(out, p)
-	}
-	failed += len(problems)
-
-	var names []string
-	for name := range shelf {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	for _, name := range names {
-		m := shelf[name]
-		if faulted[name] {
-			continue
-		}
-		fmt.Fprintf(out, "%s: ok", name)
-		if n := len(m.Tools); n > 0 {
-			fmt.Fprintf(out, ", %d tool(s)", n)
-		}
-		if len(m.Invokes) > 0 {
-			fmt.Fprintf(out, ", invokes %s", joinInvokes(m.Invokes))
-		}
-		// The state it keeps and reads (novox/hq ADR 0202), so a reviewer sees what lands on the bus.
-		if len(m.State) > 0 {
-			kept := make([]string, 0, len(m.State))
-			for _, s := range m.State {
-				kept = append(kept, s.Name)
-			}
-			fmt.Fprintf(out, ", keeps state %s", strings.Join(kept, ", "))
-		}
-		if len(m.Reads) > 0 {
-			fmt.Fprintf(out, ", reads %s", strings.Join(m.Reads, ", "))
-		}
-		fmt.Fprintln(out)
-	}
-	if failed > 0 {
-		return fmt.Errorf("%d problem(s) in %d manifest(s)", failed, len(paths))
-	}
-	fmt.Fprintf(out, "%d manifest(s) checked. Judged against the seats this binary carries; a claim on "+
-		"one of the mesh's own seats is judged fully at registration, and a seat declared by a "+
-		"module not given here reads as unknown\n", len(paths))
-	return nil
-}
-
-func joinInvokes(invokes []string) string {
-	if len(invokes) == 1 && invokes[0] == "*" {
-		return "every tool"
-	}
-	s := ""
-	for i, t := range invokes {
-		if i > 0 {
-			s += ", "
-		}
-		s += t
-	}
-	return s
-}
-
-// manifestsUnder lists every module.json below a directory, for `module check <dir>`.
-func manifestsUnder(dir string) ([]string, error) {
-	var found []string
-	err := filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		if d.IsDir() && (d.Name() == "node_modules" || d.Name() == ".git" || d.Name() == "dist") {
-			return filepath.SkipDir
-		}
-		if !d.IsDir() && d.Name() == "module.json" {
-			found = append(found, path)
-		}
-		return nil
-	})
-	sort.Strings(found)
-	return found, err
-}

cmd/mesh-controller/check_test.go

@@ -1,94 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-	"testing"
-)
-
-// The check anybody can run is the check registration runs (novox/hq issue 148, ADR 0037): a manifest
-// with a known fault is named, and one without passes, with no store opened.
-func TestModuleCheckNamesAFaultAndNeedsNoMesh(t *testing.T) {
-	dir := t.TempDir()
-	good := filepath.Join(dir, "good.json")
-	bad := filepath.Join(dir, "bad.json")
-	os.WriteFile(good, []byte(`{"module":"shop","version":"1","tools":["price"],"invokes":["mesh-catalog.catalog_modules"]}`), 0o600)
-	os.WriteFile(bad, []byte(`{"module":"till","version":"1","invokes":["shop"]}`), 0o600)
-
-	var out bytes.Buffer
-	if err := moduleCheck([]string{good}, &out); err != nil {
-		t.Fatalf("a sound manifest was refused: %v\n%s", err, out.String())
-	}
-	if !strings.Contains(out.String(), "shop: ok, 1 tool(s), invokes mesh-catalog.catalog_modules") {
-		t.Fatalf("the report does not say what it checked:\n%s", out.String())
-	}
-
-	out.Reset()
-	err := moduleCheck([]string{good, bad}, &out)
-	if err == nil {
-		t.Fatal("a manifest invoking a module and no tool passed")
-	}
-	if !strings.Contains(out.String(), `till invokes "shop", which does not name a tool`) {
-		t.Fatalf("the fault is not named in the manifest's words:\n%s", out.String())
-	}
-}
-
-// The rules between manifests run over what was given together: a seat two modules declare is
-// refused, which no single-manifest check can see.
-func TestModuleCheckJudgesBetweenTheManifestsGiven(t *testing.T) {
-	dir := t.TempDir()
-	a := filepath.Join(dir, "a.json")
-	b := filepath.Join(dir, "b.json")
-	os.WriteFile(a, []byte(`{"module":"a","version":"1","seats":[{"name":"printer","scope":"mesh"}]}`), 0o600)
-	os.WriteFile(b, []byte(`{"module":"b","version":"1","seats":[{"name":"printer","scope":"mesh"}]}`), 0o600)
-	var out bytes.Buffer
-	if err := moduleCheck([]string{a, b}, &out); err == nil {
-		t.Fatalf("two declarations of one seat passed:\n%s", out.String())
-	}
-	if !strings.Contains(out.String(), "a seat name means one protocol") {
-		t.Fatalf("the cross-manifest rule was not the one named:\n%s", out.String())
-	}
-}
-
-// The real catalogue passes the command, the way it passes the test that used to be the only check.
-func TestModuleCheckPassesTheCatalogue(t *testing.T) {
-	root := filepath.Join("..", "..", "..", "mesh-catalog", "modules")
-	if _, err := os.Stat(root); err != nil {
-		t.Skipf("catalogue sibling not present: %v", err)
-	}
-	paths, err := manifestsUnder(root)
-	if err != nil || len(paths) == 0 {
-		t.Fatalf("no manifests under %s: %v", root, err)
-	}
-	var out bytes.Buffer
-	if err := moduleCheck(paths, &out); err != nil {
-		t.Fatalf("the catalogue does not pass its own check: %v\n%s", err, out.String())
-	}
-}
-
-func TestRegistrationRefusesADefinitionNamingAnInstallation(t *testing.T) {
-	// novox/hq ADR 0155: the check moves to registration once the catalogue passes it. Both
-	// ways in — `module add` and a build's result — go through this, and a name declared on
-	// purpose passes with its reason.
-	named := catalogue.Manifest{Module: "idp", Resources: []map[string]any{
-		{"id": "server", "type": "container", "image": "x@sha256:aa",
-			"env": map[string]any{"KC_HOSTNAME": "https://login.mesh-one.be"}},
-	}}
-	err := namesNoInstallation(named)
-	if err == nil || !strings.Contains(err.Error(), "login.mesh-one.be") ||
-		!strings.Contains(err.Error(), catalogue.NamesOnPurpose) {
-		t.Fatalf("a definition naming an installation is refused with the name and the way out; got %v", err)
-	}
-	meant := catalogue.Manifest{Module: "site", Resources: []map[string]any{
-		{"id": "server", "type": "container", "image": "registry.mesh-one.be/org/site@sha256:cc",
-			catalogue.NamesOnPurpose: map[string]any{
-				"registry.mesh-one.be": "built outside the mesh until its repository is a build source here"}},
-	}}
-	if err := namesNoInstallation(meant); err != nil {
-		t.Fatalf("a name declared on purpose passes; got %v", err)
-	}
-}

cmd/mesh-controller/collect.go

@@ -1,108 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"time"
-
-	"github.com/novox/mesh-controller/internal/artifacts"
-	"github.com/novox/mesh-controller/internal/inventory"
-)
-
-// Letting the artifact store go of what the mesh no longer keeps (novox/hq ADR 0189, issue 108).
-//
-// **Run where the records change.** A build is the moment new bytes landed in the store and the
-// moment the keep set moved, so it is the moment to say what may go — and it needs no timer of
-// its own. Reclaiming the bytes is the store's own nightly step; this only decides.
-//
-// Never fatal to a build. The build succeeded, the module is registered, and a store that could
-// not be reached is a thing to say rather than a reason to undo any of that. The next build asks
-// again, and the references it could not collect are still uncollected, so nothing is lost by
-// having failed.
-
-// collect asks the store to let go of everything the mesh made and no longer keeps, and records
-// what it let go of. Says what it did and what it could not; returns nothing, because nothing
-// upstream should branch on it.
-func collect(ctx context.Context, inv *inventory.Inventory) {
-	references, err := inv.ToCollect(ctx)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "could not work out what the artifact store may let go of: %v\n", err)
-		return
-	}
-	if len(references) == 0 {
-		return
-	}
-	shelf, err := inv.Catalogue(ctx)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "could not read the catalogue to find the artifact store: %v\n", err)
-		return
-	}
-	// As the mesh reaches it from the network. Empty means the store is not on the network — on a
-	// mesh being raised it is not yet, and there the store holds one build of anything and has
-	// nothing to collect.
-	address, err := artifactStoreAddress(ctx, inv, shelf, "")
-	if err != nil || address == "" {
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "could not find the artifact store to collect from: %v\n", err)
-		}
-		return
-	}
-
-	// **Bounded, because this runs inside somebody's build.** The first sweep of a mesh that has
-	// never collected has the whole history to get through, and a person waiting on `build` should
-	// not pay for it. Two bounds, and what is left over is simply offered again next time —
-	// builds are frequent, and the point is that the store stops growing, not that it empties
-	// tonight.
-	within, stop := context.WithTimeout(ctx, sweepBudget)
-	defer stop()
-	store := artifacts.Store{Address: address}
-
-	var done []string
-	var left int
-	for i, reference := range references {
-		if i >= mostPerSweep || within.Err() != nil {
-			left = len(references) - i
-			break
-		}
-		err := store.LetGo(within, reference)
-		if err == nil || errors.Is(err, artifacts.Gone) {
-			// Gone is the outcome wanted, already true. Recorded so the next sweep does not ask
-			// again for ever.
-			done = append(done, reference)
-			continue
-		}
-		// **Stopped at the first refusal, not pushed through.** A store that refuses one refuses
-		// all of them — deletion disabled, the store down, the network gone — so going on would
-		// be a hundred identical failures and a hundred identical log lines in front of whoever
-		// was building something.
-		fmt.Fprintf(os.Stderr, "the artifact store kept %s, so nothing more was asked of it: %v\n",
-			reference, err)
-		left = len(references) - i
-		break
-	}
-
-	if len(done) > 0 {
-		// Recorded outside `within`: the deletions happened, and losing the record of them because
-		// the sweep ran out of budget would mean asking about them again for ever.
-		if err := inv.MarkCollected(ctx, done); err != nil {
-			fmt.Fprintf(os.Stderr, "the store let go of %d artifact(s) and the record of it did not keep: %v\n",
-				len(done), err)
-			return
-		}
-		fmt.Fprintf(os.Stderr, "the artifact store let go of %d artifact(s) the mesh no longer keeps\n",
-			len(done))
-	}
-	if left > 0 {
-		fmt.Fprintf(os.Stderr, "%d more to collect; the next build asks again\n", left)
-	}
-}
-
-// mostPerSweep is how many artifacts one sweep will ask about. Enough that a mesh building
-// several times a day converges within days of this landing; small enough that no single build
-// waits on the whole backlog.
-const mostPerSweep = 200
-
-// sweepBudget is the longest a sweep will keep a build waiting.
-const sweepBudget = 60 * time.Second

cmd/mesh-controller/credential_on_assign_test.go

@@ -1,90 +0,0 @@
-package main
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-	"github.com/novox/mesh-controller/internal/inventory"
-)
-
-// A fresh assignment is pushed before its credential exists (novox/hq issue 203): `assign` recorded
-// the module, `push` sealed a random own secret where the bus credential belongs, and the process
-// crash-looped until a person ran `module issue` and pushed again. Now assigning a module that speaks
-// on the bus issues its credential in the same act — or, when the bus cannot be reached from here,
-// says which verb to run — and a push never seals a placeholder in a credential's place.
-
-func aTalker() catalogue.Manifest {
-	return catalogue.Manifest{Module: "talker", Version: "1",
-		OwnSecrets: catalogue.OwnSecrets{"broker": {Path: "/var/lib/mesh/talker/broker"}},
-		Resources: []map[string]any{
-			{"id": "state", "type": "directory", "path": "/var/lib/mesh/talker", "mode": "0700"},
-		}}
-}
-
-func TestAssigningAModuleThatSpeaksOnTheBusNamesItsCredential(t *testing.T) {
-	open := aMesh(t)
-	ctx := t.Context()
-	register(t, open, aTalker())
-
-	// No bus is known to this process, so the credential cannot be issued here: the assignment
-	// stands and says exactly what must happen before a push — never silently.
-	said, err := assign(ctx, open, "laptop", "talker")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(said, "module issue talker --node laptop") {
-		t.Fatalf("an assignment whose credential could not be issued does not name the verb:\n%s", said)
-	}
-
-	// And the push refuses to send it, naming the same verb, rather than sealing a placeholder.
-	plan, settings, err := planFor(ctx, open, "laptop")
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, err = declarationFor(ctx, open, "laptop", plan, settings)
-	if err == nil {
-		t.Fatal("a push sealed a placeholder where talker's bus credential belongs")
-	}
-	if !strings.Contains(err.Error(), "module issue talker --node laptop") || !strings.Contains(err.Error(), "issue 203") {
-		t.Fatalf("the refusal does not say what to run: %v", err)
-	}
-
-	// Once the user is minted, the push goes on to the credential the mesh sealed, and re-assigning
-	// does not mint again: a credential rotates on purpose, never by habit.
-	if _, err := open.inventory.MintBusPassword(ctx, inventory.BusUser{
-		Username: "laptop.talker", Kind: inventory.BusModule, Node: "laptop", Module: "talker"}); err != nil {
-		t.Fatal(err)
-	}
-	hash, _, err := open.inventory.BusUserHash(ctx, "laptop.talker")
-	if err != nil {
-		t.Fatal(err)
-	}
-	said, err = assign(ctx, open, "laptop", "talker")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(said, "module issue") {
-		t.Fatalf("a module with a minted credential was told to issue one:\n%s", said)
-	}
-	again, _, err := open.inventory.BusUserHash(ctx, "laptop.talker")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if again != hash {
-		t.Fatal("re-assigning rotated the credential")
-	}
-}
-
-// A module that declares no broker secret is left alone: nothing to issue, nothing said.
-func TestAssigningAModuleThatDoesNotSpeakSaysNothingOfCredentials(t *testing.T) {
-	open := aMesh(t)
-	register(t, open, helloWeb())
-	said, err := assign(t.Context(), open, "laptop", "hello-web")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(said, "credential") {
-		t.Fatalf("a module without a broker secret was told about credentials:\n%s", said)
-	}
-}

cmd/mesh-controller/dependents_test.go

@@ -1,52 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-	"github.com/novox/mesh-controller/internal/inventory"
-)
-
-// A merge that rebuilds a base rebuilds what stands on it, through every layer, and nothing else
-// (novox/hq issue 186): the runtime image moving means every module built on it moves too, and a
-// module built on one of those moves as well.
-func TestAMergeOfABaseTakesWhatStandsOnItAlong(t *testing.T) {
-	entry := func(name string) inventory.Entry {
-		return inventory.Entry{Manifest: catalogue.Manifest{Module: name}}
-	}
-	entries := []inventory.Entry{entry("mesh-tools"), entry("shop"), entry("shop-plugin"), entry("postgres"), entry("unrelated")}
-	against := map[string][]string{
-		"shop":        {catalogue.ArtifactStoreScheme + "mesh-tools/runtime@sha256:a"},
-		"shop-plugin": {catalogue.ArtifactStoreScheme + "shop/runtime@sha256:b"},
-		"postgres":    {catalogue.ArtifactStoreScheme + "mesh-tools/runtime@sha256:a"},
-		"unrelated":   {catalogue.ArtifactStoreScheme + "alpine/base@sha256:c"},
-	}
-	got := dependentsOf([]inventory.Entry{entry("mesh-tools")}, entries, against)
-	var names []string
-	for _, e := range got {
-		names = append(names, e.Manifest.Module)
-	}
-	want := map[string]bool{"shop": true, "shop-plugin": true, "postgres": true}
-	if len(names) != len(want) {
-		t.Fatalf("rebuilt %v; wanted exactly the three that stand on the runtime, directly or through shop", names)
-	}
-	for _, n := range names {
-		if !want[n] {
-			t.Fatalf("%s was rebuilt and stands on nothing that moved (%v)", n, names)
-		}
-	}
-	// The dependents come in base order when the merge orders them: the runtime, then shop, then
-	// the plugin that stands on shop.
-	ordered := orderByBases(append([]inventory.Entry{entry("mesh-tools")}, got...), against)
-	pos := map[string]int{}
-	for i, e := range ordered {
-		pos[e.Manifest.Module] = i
-	}
-	if !(pos["mesh-tools"] < pos["shop"] && pos["shop"] < pos["shop-plugin"]) {
-		t.Fatalf("not in base order: %v", ordered)
-	}
-	// Nothing moved: nothing follows.
-	if more := dependentsOf(nil, entries, against); len(more) != 0 {
-		t.Fatalf("with nothing moved, %d module(s) were rebuilt", len(more))
-	}
-}

cmd/mesh-controller/foundation_scope_test.go

@@ -0,0 +1,33 @@
+package main
+
+// The broker opening belongs only on the node that listens on it (novox/hq: it leaked onto
+// every enrolled node's declaration, opening a from-anywhere hole for a port nothing there
+// serves). foundationPortsFor is the scope.
+
+import (
+	"testing"
+
+	"github.com/novox/mesh-controller/internal/catalogue"
+)
+
+func TestTheBrokerHostGetsTheFoundationOpening(t *testing.T) {
+	broker := catalogue.Manifest{Module: "lavinmq", Listens: []catalogue.Listening{
+		{Port: 5671, Protocol: "tcp", From: "mesh"},
+		{Port: 5672, Protocol: "tcp", From: "mesh"},
+	}}
+	got := foundationPortsFor(5671, []catalogue.Manifest{broker})
+	if len(got) != 1 || got[0] != 5671 {
+		t.Fatalf("the node that listens on the broker port keeps it; got %v", got)
+	}
+}
+
+func TestANodeThatOnlyDialsTheBrokerGetsNoOpening(t *testing.T) {
+	// ace's set: things that reach the broker as a client, none listening on 5671.
+	ace := []catalogue.Manifest{
+		{Module: "plex", Listens: []catalogue.Listening{{Port: 32400, Protocol: "tcp", From: "anywhere"}}},
+		{Module: "postgres", Listens: []catalogue.Listening{{Port: 5432, Protocol: "tcp", From: "mesh"}}},
+	}
+	if got := foundationPortsFor(5671, ace); got != nil {
+		t.Fatalf("a node that only dials out opens nothing for the broker; got %v", got)
+	}
+}

cmd/mesh-controller/holdings.go

@@ -1,92 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"sort"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-)
-
-// recordDerivedHolders writes down who holds each mesh-scoped seat that nobody was ever recorded
-// as holding.
-//
-// **A seat held by derivation is a seat held by accident of being alone** (novox/hq
-// 04-ISSUES/170). ADR 0131 lets a holder on record settle a seat, and lets any other assignment
-// whose module could hold it stand beside the holder, eligible and silent. But a seat nobody
-// ever handed over has no record, so its holder is whichever assignment happened to be the sole
-// claimant — and the day a second one is assigned, both claim, both are refused, and the first
-// one's whole machine stops resolving. That is what assigning a second postgres did to the
-// control plane's own store.
-//
-// So the mesh writes the derived answer down before it acts on an assignment: for every
-// mesh-scoped seat with exactly one resolved holder and nothing on record, that holder is
-// recorded as the standing one — the same record `seat <name> --to <node>/<module>` makes by
-// hand, made from what the mesh already resolved. A seat with two derived claimants is left
-// alone: that is the ambiguity a person settles, and recording either would be guessing.
-//
-// Node-scoped seats are untouched: a record is one holder per seat, and a node-scoped seat has
-// one holder per machine (ADR 0121), so there is nothing for a record to settle there.
-func recordDerivedHolders(ctx context.Context, open *stores) ([]string, error) {
-	inv := open.inventory
-	shelf, err := inv.Catalogue(ctx)
-	if err != nil {
-		return nil, err
-	}
-	// exclude nobody: every node's claims, resolved with the holdings on record.
-	world, err := theRestOfTheMesh(ctx, inv, shelf, "")
-	if err != nil {
-		return nil, err
-	}
-	recorded, err := inv.Holdings(ctx)
-	if err != nil {
-		return nil, err
-	}
-	// A record is a row against a seat the store knows. A seat it does not — a mesh whose seats
-	// were never seeded, a seat a module declares for itself — stays held by derivation, as it
-	// always was; a missing row is not a reason an assignment fails.
-	known, err := inv.Seats(ctx)
-	if err != nil {
-		return nil, err
-	}
-	recordable := map[string]bool{}
-	for _, s := range known {
-		recordable[s.Name] = true
-	}
-	onRecord := map[string]bool{}
-	for _, h := range recorded {
-		if s, ok := catalogue.SeatNamed(h.Claim); ok {
-			onRecord[s.Name] = true
-		}
-	}
-	holders := map[string][]catalogue.Held{}
-	for _, h := range world.Held {
-		if h.Scope != catalogue.ScopeMesh {
-			continue
-		}
-		s, ok := catalogue.SeatNamed(h.Claim)
-		if !ok || onRecord[s.Name] || !recordable[s.Name] {
-			continue
-		}
-		holders[s.Name] = append(holders[s.Name], h)
-	}
-	names := make([]string, 0, len(holders))
-	for name := range holders {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	var said []string
-	for _, name := range names {
-		if len(holders[name]) != 1 {
-			continue
-		}
-		h := holders[name][0]
-		if err := inv.HoldSeat(ctx, name, catalogue.ScopeMesh, h.Node, h.Module); err != nil {
-			return said, err
-		}
-		said = append(said, fmt.Sprintf(
-			"recorded %s on %s as the standing holder of %s, which it held only by being alone",
-			h.Module, h.Node, name))
-	}
-	return said, nil
-}

cmd/mesh-controller/holdings_test.go

@@ -1,110 +0,0 @@
-package main
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-)
-
-// A seat nobody ever handed over is held by whichever assignment happened to be alone — and the
-// day a second module able to hold it is assigned, both claimed, both were refused, and the first
-// one's machine stopped resolving (novox/hq 04-ISSUES/170). The mesh now writes the derived holder
-// down before it acts, so the second assignment stands beside the holder on record.
-
-func aSeatedStore() catalogue.Manifest {
-	return catalogue.Manifest{Module: "store", Version: "1",
-		Provides: []catalogue.Offer{{Name: "postgres-database", Scope: catalogue.ScopeMesh}},
-		Serves:   map[string]map[string]any{"postgres-database": {"port": 5432}},
-		Claims:   []catalogue.Claim{{Name: "mesh-store", Scope: catalogue.ScopeMesh}}}
-}
-
-func TestASecondEligibleHolderStandsBesideTheOneHeldByBeingAlone(t *testing.T) {
-	open := aMesh(t)
-	ctx := t.Context()
-	// Every deploy seeds the mesh's own seats; a record is a row against one of them.
-	if _, err := open.inventory.SeedSeats(ctx, catalogue.DefaultSeats()); err != nil {
-		t.Fatal(err)
-	}
-	register(t, open, aSeatedStore())
-
-	if _, err := assign(ctx, open, "anchor", "store"); err != nil {
-		t.Fatal(err)
-	}
-	said, err := assign(ctx, open, "laptop", "store")
-	if err != nil {
-		t.Fatalf("a second store, eligible for the seat, was refused:\n%s\n%v", said, err)
-	}
-	if strings.Contains(said, "cannot be worked out") {
-		t.Fatalf("assigning a second store unsettled the first one's machine:\n%s", said)
-	}
-	if !strings.Contains(said, "recorded store on anchor as the standing holder of mesh-store") {
-		t.Fatalf("the holder by derivation was not written down:\n%s", said)
-	}
-
-	holdings, err := open.inventory.Holdings(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var found bool
-	for _, h := range holdings {
-		if h.Claim == "mesh-store" {
-			found = true
-			if h.Node != "anchor" || h.Module != "store" {
-				t.Fatalf("mesh-store is recorded on %s/%s, not on the one that held it", h.Node, h.Module)
-			}
-		}
-	}
-	if !found {
-		t.Fatalf("mesh-store has no holder on record after assigning: %v", holdings)
-	}
-
-	// And the record decides from here: the anchor's plan holds the seat, the laptop's does not.
-	for node, holds := range map[string]bool{"anchor": true, "laptop": false} {
-		plan, _, err := planFor(ctx, open, node)
-		if err != nil {
-			t.Fatalf("%s no longer resolves: %v", node, err)
-		}
-		var claimed bool
-		for _, c := range plan.Claims {
-			if c.Claim == "mesh-store" {
-				claimed = true
-			}
-		}
-		if claimed != holds {
-			t.Fatalf("%s holds mesh-store: %v, want %v", node, claimed, holds)
-		}
-	}
-}
-
-func TestAHolderOnRecordIsNotRewrittenByDerivation(t *testing.T) {
-	open := aMesh(t)
-	ctx := t.Context()
-	if _, err := open.inventory.SeedSeats(ctx, catalogue.DefaultSeats()); err != nil {
-		t.Fatal(err)
-	}
-	register(t, open, aSeatedStore())
-	for _, node := range []string{"anchor", "laptop"} {
-		if _, err := assign(ctx, open, node, "store"); err != nil {
-			t.Fatal(err)
-		}
-	}
-	// A person hands the seat to the laptop. From here the record decides, and what the mesh
-	// derives must never write over it.
-	if err := open.inventory.HoldSeat(ctx, "mesh-store", catalogue.ScopeMesh, "laptop", "store"); err != nil {
-		t.Fatal(err)
-	}
-	said, err := recordDerivedHolders(ctx, open)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(said) != 0 {
-		t.Fatalf("a seat on record was written again from derivation: %v", said)
-	}
-	holdings, _ := open.inventory.Holdings(ctx)
-	for _, h := range holdings {
-		if h.Claim == "mesh-store" && h.Node != "laptop" {
-			t.Fatalf("the record moved to %s", h.Node)
-		}
-	}
-}

cmd/mesh-controller/issue_204_test.go

@@ -1,93 +0,0 @@
-package main
-
-import (
-	"context"
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/inventory"
-)
-
-// A declaration composed earlier is numbered lower than one composed later, whatever order the two
-// are sent in (novox/hq issue 204). The number used to be taken at send time, after composing, so a
-// declaration composed before an assignment changed and sent after a newer one carried the higher
-// number — and the machine, which refuses a lower number, took the older content as the mesh's
-// newest word. Taken before the composition reads anything, the order of numbers is the order of
-// compositions, and the host's refusal does what it is for.
-func TestADeclarationComposedEarlierIsNumberedLowerWhateverOrderItIsSent(t *testing.T) {
-	allot := numbered()
-	var composed []string
-	compose := func(stamp string) func(string) (sendable, error) {
-		return func(node string) (sendable, error) {
-			composed = append(composed, stamp)
-			return sendable{Resources: []map[string]any{{"id": node + "." + stamp}}}, nil
-		}
-	}
-	// Composed first — before an assignment changed — and sent last.
-	stale, _ := composeEach([]string{"anchor"}, allot, compose("before"))
-	// Composed after the change, sent first.
-	fresh, _ := composeEach([]string{"anchor"}, allot, compose("after"))
-
-	if stale[0].declared.Sequence != 1 || fresh[0].declared.Sequence != 2 {
-		t.Fatalf("the numbers do not follow the compositions: before=%d after=%d",
-			stale[0].declared.Sequence, fresh[0].declared.Sequence)
-	}
-	// Sent in the other order, the numbers do not change — so the machine that has applied the
-	// fresh one (2) refuses the stale one (1) when it arrives late.
-	if !(stale[0].declared.Sequence < fresh[0].declared.Sequence) {
-		t.Fatal("a declaration composed earlier must carry the lower number, however late it is sent")
-	}
-	if len(composed) != 2 || composed[0] != "before" {
-		t.Fatalf("compositions happened in an unexpected order: %v", composed)
-	}
-}
-
-// The number is taken before the first read of the composition, not after it: an allotter that
-// fails leaves nothing composed for that machine, and the others are still composed.
-func TestTheNumberIsTakenBeforeComposingAndItsFailureIsARefusal(t *testing.T) {
-	calls := 0
-	allot := func(node string) (int64, error) {
-		if node == "anchor" {
-			return 0, context.DeadlineExceeded
-		}
-		return 7, nil
-	}
-	sending, refusals := composeEach([]string{"anchor", "laptop"}, allot, func(node string) (sendable, error) {
-		calls++
-		if node == "anchor" {
-			t.Fatal("anchor was composed although its number could not be taken")
-		}
-		return sendable{}, nil
-	})
-	if calls != 1 || len(sending) != 1 || sending[0].node != "laptop" || sending[0].declared.Sequence != 7 {
-		t.Fatalf("laptop should be composed with its number and anchor refused: %v / %v", sending, refusals)
-	}
-	if len(refusals) != 1 {
-		t.Fatalf("anchor's failed number should be a refusal naming it: %v", refusals)
-	}
-}
-
-// What was sent is written down even when the sender's context is already cancelled (issue 204): a
-// controller replaced mid-send had told the machine and never recorded it, so status read "applied,
-// current" over a machine that had just been sent something else.
-func TestASendIsRecordedEvenWhenTheSenderIsBeingCancelled(t *testing.T) {
-	inv := inventory.ForTest(t)
-	ctx, cancel := context.WithCancel(t.Context())
-	if _, err := inv.AddNode(ctx, "anchor"); err != nil {
-		t.Fatal(err)
-	}
-	cancel() // the sender is going away: its context is cancelled between the send and the record
-	body := []byte(`{"declaration":1,"resources":[]}`)
-	digest, err := recordSent(ctx, inv, "anchor", body)
-	if err != nil {
-		// NodeByName on the cancelled context may itself refuse; the record must still be possible
-		// through the detached context, so look the node up again on a live one.
-		t.Fatalf("recording a send after cancellation failed: %v", err)
-	}
-	outstanding, err := inv.Outstanding(t.Context(), "anchor")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if outstanding != digest || digest != digestOf(body) {
-		t.Fatalf("the send was not recorded: outstanding %q, sent %q", outstanding, digest)
-	}
-}

cmd/mesh-controller/main.go

@@ -8,7 +8,6 @@ package main
 
 import (
 	"context"
-	"errors"
 	"flag"
 	"fmt"
 	"os"
@@ -73,8 +72,6 @@ func run() error {
 		return askCommand(ctx, args[1:])
 	case "builds":
 		return buildsCommand(ctx, args[1:])
-	case "plans":
-		return plansCommand(ctx, args[1:])
 	case "pin":
 		return pinCommand(ctx, args[1:], true)
 	case "unpin":
@@ -164,7 +161,6 @@ func usage() {
   overlay place <node> [flags]   say where a node is and how it is reached
   overlay show                   the private network, as the mesh computes it
   module add <file>              register a module from its manifest
-  module check <file|dir>...     judge manifests where they are written, with no mesh (exit 1 on any problem)
   module list                    what modules this mesh knows about
   module moved <name> <commit>   the source has a newer commit than the mesh built
   module forget <name>           remove one, unless a node runs it or the mesh holds things for it
@@ -175,14 +171,11 @@ func usage() {
   upgrade <name> record          ...record that they are behind, and send nothing
   status [--json]                what is wrong, what is quiet, and what is out of date
   seats [--json]                 every seat this mesh defines, what it delivers, and who holds it
-  seat rename <from> <to>        rename a seat; its former name still resolves (ADR 0122)
-  seat <name> --to <node>/<module>   hand a seat to that assignment as one act; never empty in between (ADR 0131)
   board [--listen ADDR]          the same three questions, as a page that holds nothing
   api --issuer URL [--listen A]  assign and unassign over http, for a surface that is not here
   assign <node> <module>         put a module on a node
   unassign <node> <module>       take it off
-  take <node> <module>           preview a module's cutover on an adopted node: what runs beside
+  take <node> <module>           cut a module over on an adopted node, once its data has moved
-                                 what it declares; --yes <digest> cuts it over as previewed
   converge <node> [--yes <digest>] [--filter nftables]   preview, then make, an adopted node converged
   adopt <node>                   return a converged node to adopted; what was taken stays taken
   settings set <module> <file>   what a module's config should say, for the whole mesh
@@ -207,8 +200,7 @@ func usage() {
   licence refresh <name>         mint a new access token and seal it to every holder
   rotate <provision> [--consumer <n>]  a new credential for every holder, both ends at once
   ask <module> <tool> [json]           call one of a module's tools over the broker, and print its answer
-  pin <node> <provision> <from-node> <module>
+  pin <node> <provision> <from>  which node this one gets a provision from
-                                 which provider this one gets a provision from: the module, and its node
   unpin <node> <provision>       put that question back
   plan <node> [--files|--json]     what that node would run, and why
   push [<node>] [--behind]       send a node everything it should be, or only those that need it
@@ -248,40 +240,6 @@ func parseAround(set *flag.FlagSet, args []string) ([]string, error) {
 	}
 }
 
-// Built is the daemon hearing a build's outcome on the bus — its own asking, an announcement's, or
-// a tool's that did not wait (novox/hq issue 176) — and taking it in: recorded, and the module
-// registered, the same as the waiting command does. Said either way, so the daemon's log tells what
-// became of a build nobody was watching.
 func (b builds) Built(ctx context.Context, result link.BuildResult) error {
-	manifest, _, err := takeIn(ctx, b.inv, result)
+	return b.inv.RecordBuild(ctx, buildFrom(result))
-	// When it was asked, so a plan takes as its outcome only a build asked for it or after it
-	// (novox/hq 04-ISSUES/219). Zero when the id does not say.
-	asked, _ := link.BuildAskedAt(result.ID)
-	switch {
-	case err != nil && result.Failed != "":
-		fmt.Printf("%s: %v\n", result.ID, err)
-		if result.Module != "" {
-			planBuilt(ctx, b.open, result.Module, result.Commit, result.Failed, asked)
-		} else {
-			planFailedBuild(ctx, b.open, result)
-		}
-		return nil
-	case errors.Is(err, inventory.ErrSuperseded):
-		// Not a failure: the module is already at what a later request built. A plan that asked
-		// before that later request is answered by it; one that asked after it ignores this.
-		fmt.Printf("%s: %v\n", result.ID, err)
-		planBuilt(ctx, b.open, manifest.Module, result.Commit, "", asked)
-		return nil
-	case err != nil:
-		fmt.Printf("%s: heard and recorded, and not registered: %v\n", result.ID, err)
-		if manifest.Module != "" {
-			planBuilt(ctx, b.open, manifest.Module, result.Commit, err.Error(), asked)
-		}
-		return nil
-	}
-	fmt.Printf("%s: %s %s registered, built on %s from %s\n",
-		result.ID, manifest.Module, manifest.Version, result.On, short(result.Commit))
-	saysWhenThePolicyActs(ctx, b.inv, manifest.Module)
-	planBuilt(ctx, b.open, manifest.Module, result.Commit, "", asked)
-	return nil
 }

cmd/mesh-controller/modules.go

@@ -54,24 +54,7 @@ var provided = providedModules()
 
 func moduleCommand(ctx context.Context, args []string) error {
 	if len(args) == 0 {
-		return errors.New("module add <file>, module check <file>..., module list, or module forget <name>")
+		return errors.New("module add <file>, module list, or module forget <name>")
-	}
-	// `check` needs no mesh, and must not: it is what somebody runs in their own repository before
-	// there is a mesh in reach (novox/hq issue 148). A directory expands to every manifest under it.
-	if args[0] == "check" {
-		var paths []string
-		for _, a := range args[1:] {
-			if info, err := os.Stat(a); err == nil && info.IsDir() {
-				under, err := manifestsUnder(a)
-				if err != nil {
-					return err
-				}
-				paths = append(paths, under...)
-				continue
-			}
-			paths = append(paths, a)
-		}
-		return moduleCheck(paths, os.Stdout)
 	}
 	open, err := openStores(ctx)
 	if err != nil {
@@ -113,9 +96,6 @@ func moduleCommand(ctx context.Context, args []string) error {
 		if err != nil {
 			return err
 		}
-		if err := namesNoInstallation(m); err != nil {
-			return err
-		}
 		if err := inv.RegisterModule(ctx, m, from); err != nil {
 			return err
 		}
@@ -147,40 +127,6 @@ func moduleCommand(ctx context.Context, args []string) error {
 		if err != nil {
 			return err
 		}
-		// **The same list, for something other than a person** (novox/hq ADR 0195): what each module
-		// is, where it runs, whether it is current, and what it says of itself.
-		if len(args) > 1 && args[1] == "--json" {
-			type listed struct {
-				Module   string `json:"module"`
-				Version  string `json:"version"`
-				Built    string `json:"built,omitempty"`
-				Head     string `json:"head,omitempty"`
-				Current  bool   `json:"current"`
-				Provided bool   `json:"provided,omitempty"`
-				// Tools says whether the module answers tools anywhere it runs: a list of its own,
-				// a bundle the runtime serves, or a seat's verbs it claims (novox/hq ADR 0197) —
-				// what the console checks the bus's answers against.
-				Tools        bool     `json:"tools"`
-				On           []string `json:"on"`
-				Provides     []string `json:"provides,omitempty"`
-				Requires     []string `json:"requires,omitempty"`
-				Claims       []string `json:"claims,omitempty"`
-				Capabilities []string `json:"capabilities,omitempty"`
-			}
-			out := make([]listed, 0, len(entries))
-			for _, e := range entries {
-				m := e.Manifest
-				l := listed{Module: m.Module, Version: m.Version, Built: e.Source.BuiltFrom, Head: e.Source.Head,
-					Current: e.Provided || e.Source.Repository == "" || e.Source.Current(), Provided: e.Provided,
-					On: append([]string{}, e.On...), Provides: m.Offers(), Requires: m.Requires,
-					Capabilities: m.Capabilities, Tools: declaresTools(m)}
-				for _, c := range m.Claims {
-					l.Claims = append(l.Claims, c.At()+"/"+c.Name)
-				}
-				out = append(out, l)
-			}
-			return printJSON(out)
-		}
 		if len(entries) == 0 {
 			fmt.Println("this mesh knows about no modules yet")
 			return nil
@@ -329,7 +275,7 @@ func moduleCommand(ctx context.Context, args []string) error {
 		return issueOnTheNewBus(ctx, inv, m, *forNode, busAddress)
 
 	default:
-		return fmt.Errorf("module has no %q; it has add, check, list, moved, forget and issue", args[0])
+		return fmt.Errorf("module has no %q; it has add, list, moved, forget and issue", args[0])
 	}
 }
 
@@ -386,14 +332,10 @@ func settingsCommand(ctx context.Context, args []string) error {
 	switch args[0] {
 	case "set":
 		if len(positionals) != 2 {
-			return errors.New("settings set <module> <settings.json | {…}> [--node <node>]")
+			return errors.New("settings set <module> <settings.json> [--node <node>]")
 		}
-		// A file, or the values themselves when they begin with `{` — which is how the mesh's own
+		raw, err := os.ReadFile(positionals[1])
-		// `settings` tool passes them, having no file to hand over (novox/hq issue 198).
+		if err != nil {
-		var raw []byte
-		if strings.HasPrefix(strings.TrimSpace(positionals[1]), "{") {
-			raw = []byte(positionals[1])
-		} else if raw, err = os.ReadFile(positionals[1]); err != nil {
 			return err
 		}
 		var values map[string]any
@@ -449,8 +391,8 @@ func describeOffers(offers []catalogue.Offer) string {
 // database should not change where an existing machine gets its data the day a second one
 // arrives.
 func pinCommand(ctx context.Context, args []string, setting bool) error {
-	if setting && len(args) != 4 {
+	if setting && len(args) != 3 {
-		return errors.New("pin <node> <provision> <from-node> <module>")
+		return errors.New("pin <node> <provision> <from-node>")
 	}
 	if !setting && len(args) != 2 {
 		return errors.New("unpin <node> <provision>")
@@ -469,12 +411,17 @@ func pinCommand(ctx context.Context, args []string, setting bool) error {
 		fmt.Printf("%s is no longer told where to get %s from\n", args[0], args[1])
 		return nil
 	}
-	// The provider's node may be this same machine: two modules beside the consumer can both
+	if args[0] == args[2] {
-	// answer a provision, and then the module is the whole question (novox/hq #258).
+		// Allowed by nothing here, and worth saying rather than resolving into a confusing
-	if err := inv.PinProvision(ctx, args[0], args[1], args[2], args[3]); err != nil {
+		// refusal later: a node providing something to itself is a node-scoped provision, and
+		// this field is for the other kind.
+		return fmt.Errorf("%s cannot get %s from itself; that would be a provision this machine "+
+			"provides, which does not need saying", args[0], args[1])
+	}
+	if err := inv.PinProvision(ctx, args[0], args[1], args[2]); err != nil {
 		return err
 	}
-	fmt.Printf("%s gets %s from %s/%s\n", args[0], args[1], args[2], args[3])
+	fmt.Printf("%s gets %s from %s\n", args[0], args[1], args[2])
 	fmt.Printf("  run `push %s` to send it\n", args[0])
 	return nil
 }
@@ -591,7 +538,7 @@ func issueOnTheNewBus(ctx context.Context, inv *inventory.Inventory, m catalogue
 
 	user := broker.Principal{Kind: broker.KindModule, Node: node, Module: m.Module}.Username()
 	password, err := inv.MintBusPassword(ctx, inventory.BusUser{
-		Username: user, Kind: busKindOf(m.Module), Node: node, Module: m.Module,
+		Username: user, Kind: inventory.BusModule, Node: node, Module: m.Module,
 	})
 	if err != nil {
 		return err
@@ -611,30 +558,12 @@ func issueOnTheNewBus(ctx context.Context, inv *inventory.Inventory, m catalogue
 	return issueWith(ctx, inv, m, node, busAddress, known, reachable, user, password)
 }
 
-// busKindOf is what a module's bus user is recorded as: the node's tool runtime where the module is
-// the runtime (novox/hq ADR 0175), a module otherwise. The username is the same either way — the
-// runtime is issued through this same path — and the kind is what a reader of the records sees.
-func busKindOf(module string) string {
-	if module == catalogue.RuntimeModule {
-		return inventory.BusNodeTools
-	}
-	return inventory.BusModule
-}
-
 // issueWith is the delivery half: the minted password sealed to the machine as the module's broker
 // secret, and the module's consumer created where the bus can be reached. Split from the minting
 // so the move can issue every module against a bus whose address it worked out itself
 // (`rollout mint`, design 28 task 5.2) rather than the one in this process's environment.
 func issueWith(ctx context.Context, inv *inventory.Inventory, m catalogue.Manifest,
 	node, busAddress string, known broker.Broker, reachable, user, password string) error {
-	// The seats this module claims, with the verbs each promises (novox/hq ADR 0159): the runtime
-	// serves a claimed seat's verbs with its tools of the same name, and the bus admits only the
-	// holder's subscription — so the runtime tries each claim and the grant decides. Written here
-	// because this file is the one thing the mesh writes that the runtime reads before it speaks.
-	claims, err := claimsFor(ctx, inv, m)
-	if err != nil {
-		return err
-	}
 	held, err := json.Marshal(struct {
 		URL         string `json:"url"`
 		Fingerprint string `json:"fingerprint,omitempty"`
@@ -642,10 +571,9 @@ func issueWith(ctx context.Context, inv *inventory.Inventory, m catalogue.Manife
 		Module      string `json:"module"`
 		User        string `json:"user"`
 		Password    string `json:"password"`
-		Claims      []seatClaimed `json:"claims,omitempty"`
 	}{
 		URL: "nats://" + reachable, Fingerprint: known.Fingerprint,
-		Node: node, Module: m.Module, User: user, Password: password, Claims: claims,
+		Node: node, Module: m.Module, User: user, Password: password,
 	})
 	if err != nil {
 		return err
@@ -717,73 +645,3 @@ func whereItComesFrom(repository, ref, commit, path string, self bool) (inventor
 	}
 	return from, nil
 }
-
-// namesNoInstallation is the mesh refusing a definition that names an installation, at the moment
-// it would enter the catalogue (novox/hq ADR 0112, ADR 0155). `module check` says the same thing
-// earlier, where the author is; this is the last moment the mesh can still say no, and a
-// definition that got past the check — written elsewhere, or checked by nobody — is refused here
-// in the same words. A name meant on purpose is declared with its reason and passes.
-func namesNoInstallation(m catalogue.Manifest) error {
-	named := catalogue.InstallationProblems(m)
-	if len(named) == 0 {
-		return nil
-	}
-	return fmt.Errorf("%s names an installation, and a definition names none — declare a name meant "+
-		"on purpose under %s with its reason, or take it out:\n  - %s",
-		m.Module, catalogue.NamesOnPurpose, strings.Join(named, "\n  - "))
-}
-
-// seatClaimed is one seat a module claims, as its runtime needs it: the name, the scope (a
-// node-scoped seat's verb carries the machine, design 33 §4) and the verbs the seat promises.
-type seatClaimed struct {
-	Seat   string   `json:"seat"`
-	Scope  string   `json:"scope"`
-	Serves []string `json:"serves,omitempty"`
-}
-
-// claimsFor joins a module's claims with the seats' protocols from the mesh's records.
-func claimsFor(ctx context.Context, inv *inventory.Inventory, m catalogue.Manifest) ([]seatClaimed, error) {
-	if len(m.Claims) == 0 {
-		return nil, nil
-	}
-	seats, err := inv.Seats(ctx)
-	if err != nil {
-		return nil, err
-	}
-	byName := map[string]catalogue.Seat{}
-	for _, s := range seats {
-		byName[s.Name] = s
-	}
-	var out []seatClaimed
-	for _, c := range m.Claims {
-		claimed := seatClaimed{Seat: c.Name, Scope: c.At()}
-		if s, known := byName[c.Name]; known {
-			claimed.Scope = s.Scope
-			// The verbs the runtime serves for the seat: the claim's own when it names them
-			// (ADR 0160), else every verb the seat promises, which its tools then answer.
-			claimed.Serves = c.ServesFor(catalogue.Manifest{Tools: catalogue.VerbNames(s.Serves)})
-		}
-		out = append(out, claimed)
-	}
-	return out, nil
-}
-
-// declaresTools is whether a module answers tools wherever it runs (novox/hq ADR 0197): it names
-// tools of its own, its build delivers a bundle the node's runtime serves, or it claims a seat
-// whose verbs it serves. A module with none is never expected to announce anything.
-func declaresTools(m catalogue.Manifest) bool {
-	if len(m.Tools) > 0 {
-		return true
-	}
-	for _, b := range m.Bundles {
-		if len(b.Loads) > 0 {
-			return true
-		}
-	}
-	for _, c := range m.Claims {
-		if len(c.Serves) > 0 {
-			return true
-		}
-	}
-	return false
-}

cmd/mesh-controller/modules_test.go

@@ -11,7 +11,7 @@ import (
 // A module that declares none is refused before the account exists, so the bus never carries an
 // account nothing reads (novox/hq 04-ISSUES/078).
 func TestAModuleWithNoBrokerSecretCannotBeIssued(t *testing.T) {
-	err := mayIssue(catalogue.Manifest{Module: "step-ca", OwnSecrets: catalogue.OwnSecrets{"password": {Path: "/run/password"}}})
+	err := mayIssue(catalogue.Manifest{Module: "step-ca", OwnSecrets: map[string]string{"password": "/run/password"}})
 	if err == nil {
 		t.Fatal("a module with no broker own secret was issued an account")
 	}
@@ -20,7 +20,7 @@ func TestAModuleWithNoBrokerSecretCannotBeIssued(t *testing.T) {
 			t.Errorf("the refusal does not say %q: %v", want, err)
 		}
 	}
-	if err := mayIssue(catalogue.Manifest{Module: "redis", OwnSecrets: catalogue.OwnSecrets{"broker": {Path: "/run/broker"}}}); err != nil {
+	if err := mayIssue(catalogue.Manifest{Module: "redis", OwnSecrets: map[string]string{"broker": "/run/broker"}}); err != nil {
 		t.Errorf("a module declaring its broker secret was refused: %v", err)
 	}
 }

cmd/mesh-controller/network.go

@@ -567,9 +567,6 @@ func onTheNetwork(ctx context.Context, inv *inventory.Inventory,
 			catalogue.Node{Name: p.Name, Site: p.Site, Capabilities: caps},
 			catalogue.World{Unchecked: true, Holdings: holdings})
 		if err != nil {
-			// Said, not skipped in silence: a machine dropped here loses its address, and every
-			// plan that names it fails in another module's words (novox/hq issue 188).
-			fmt.Fprintf(os.Stderr, "%s is not counted as on the network: it does not resolve: %v\n", p.Name, err)
 			continue
 		}
 		for _, m := range got.Modules {

cmd/mesh-controller/network_test.go

@@ -3,7 +3,6 @@ package main
 import (
 	"context"
 	"os"
-	"reflect"
 	"strings"
 	"testing"
 
@@ -266,12 +265,6 @@ func TestTheResolverIsToldEveryMachineOnTheNetworkAndToldAgainWhenOneLeaves(t *t
 	if _, err := assign(ctx, open, "anchor", "dnsmasq"); err != nil {
 		t.Fatal(err)
 	}
-	// Its bus credential, as assigning issues it where the bus is reachable (novox/hq issue 203):
-	// no bus is known to this test, so it is minted here, or composing refuses the placeholder.
-	if _, err := open.inventory.MintBusPassword(ctx, inventory.BusUser{
-		Username: "anchor.dnsmasq", Kind: inventory.BusModule, Node: "anchor", Module: "dnsmasq"}); err != nil {
-		t.Fatal(err)
-	}
 	zones := func() string {
 		t.Helper()
 		for _, r := range composed(t, open, "anchor").Resources {
@@ -310,28 +303,3 @@ func TestTheResolverIsToldEveryMachineOnTheNetworkAndToldAgainWhenOneLeaves(t *t
 		t.Fatalf("a machine that left the network is still a wildcard, or the one that stayed is not:\n%s", after)
 	}
 }
-
-// The roster is the machines and nothing else (novox/hq ADR 0191): each node's internal domain covers
-// every route on it, and a node's public domains are public DNS's. A routed name in `.Names` was a
-// private answer for a public name, handed by a resolver serving a LAN to a phone that could not use it.
-func TestTheRosterNamesOnlyTheMachines(t *testing.T) {
-	open := aMesh(t)
-	ctx := t.Context()
-	gens, err := generators(ctx, open)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, node := range []string{"anchor", "laptop"} {
-		plan, settings, err := planFor(ctx, open, node)
-		if err != nil {
-			t.Fatal(err)
-		}
-		with, _, err := renderingFor(ctx, open, node, plan, settings, gens, Reading)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !reflect.DeepEqual(with.Names, with.Machines) {
-			t.Fatalf("%s's roster names more than the machines:\n names    %v\n machines %v", node, with.Names, with.Machines)
-		}
-	}
-}

cmd/mesh-controller/nodes.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"flag"
 	"fmt"
@@ -45,21 +44,6 @@ func nodeCommand(ctx context.Context, args []string) error {
 		if err != nil {
 			return err
 		}
-		// **The same list, for something other than a person** — the console's discovery reads it
-		// (novox/hq ADR 0195), and a reader that parses a printed column breaks when it is reworded.
-		if len(args) > 1 && args[1] == "--json" {
-			type listed struct {
-				Name  string `json:"name"`
-				Heard string `json:"heard"`
-				Mode  string `json:"mode"`
-				ID    string `json:"id"`
-			}
-			out := make([]listed, 0, len(nodes))
-			for _, n := range nodes {
-				out = append(out, listed{Name: n.Name, Heard: heardFrom(n), Mode: modeOf(n), ID: n.ID})
-			}
-			return printJSON(out)
-		}
 		if len(nodes) == 0 {
 			// Said rather than printed as nothing: an empty list and a failed read must never
 			// look the same, and this command answering "none" is only honest because getting
@@ -516,13 +500,3 @@ func orNotReported(s string) string {
 	}
 	return s
 }
-
-// printJSON prints a value as indented JSON, the shape every `--json` answers in.
-func printJSON(v any) error {
-	body, err := json.MarshalIndent(v, "", "  ")
-	if err != nil {
-		return err
-	}
-	fmt.Println(string(body))
-	return nil
-}

cmd/mesh-controller/order_test.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"reflect"
 	"strings"
 	"testing"
 	"time"
@@ -192,7 +191,7 @@ func TestWhatAHandedOverModuleRecordsAboutItsSource(t *testing.T) {
 		t.Fatalf("the source records as %+v", from)
 	}
 	// A manifest with no provenance at all is legitimate: fixing something in a hurry.
-	if from, err := whereItComesFrom("", "", "", "", false); err != nil || !reflect.DeepEqual(from, inventory.Source{}) {
+	if from, err := whereItComesFrom("", "", "", "", false); err != nil || from != (inventory.Source{}) {
 		t.Fatalf("a manifest handed over with no provenance was refused: %+v, %v", from, err)
 	}
 	for _, c := range []struct {
@@ -211,27 +210,3 @@ func TestWhatAHandedOverModuleRecordsAboutItsSource(t *testing.T) {
 		}
 	}
 }
-
-// novox/hq 04-ISSUES/215: a module once built at a commit still follows its branch — a merge into it
-// matches the module, and a plan re-asks the branch, not the old commit.
-func TestAModuleBuiltAtACommitStillFollowsItsBranch(t *testing.T) {
-	m := link.SourceMoved{Owner: "novox", Repo: "mesh-catalog", Base: "main"}
-	pinned := inventory.Source{Repository: "novox/mesh-catalog", Seat: "git", Ref: "9c97a8a"}
-	if !sourceIs(pinned, m) {
-		t.Error("a module whose record names a commit is left out of a merge into its branch")
-	}
-	full := inventory.Source{Repository: "novox/mesh-catalog", Seat: "git", Ref: "9c97a8a1d2c3b4a5f60718293a4b5c6d7e8f9012"}
-	if !sourceIs(full, m) {
-		t.Error("a full commit hash is read as a branch")
-	}
-	if got := followedBranch("9c97a8a"); got != "" {
-		t.Errorf("a plan would re-ask the old commit %q", got)
-	}
-	if got := followedBranch("release"); got != "release" {
-		t.Errorf("a branch is not followed as named: %q", got)
-	}
-	// A module that follows another branch is still not this merge's.
-	if sourceIs(inventory.Source{Repository: "novox/mesh-catalog", Seat: "git", Ref: "release"}, m) {
-		t.Error("a module following another branch was matched")
-	}
-}

cmd/mesh-controller/plan.go

@@ -7,7 +7,6 @@ import (
 	"errors"
 	"flag"
 	"fmt"
-	"os"
 	"sort"
 	"strings"
 
@@ -16,6 +15,8 @@ import (
 	"github.com/novox/mesh-controller/internal/inventory"
 	"github.com/novox/mesh-controller/internal/licences"
 	"github.com/novox/mesh-controller/internal/overlay"
+	"net"
+	"strconv"
 )
 
 // working out what one machine should be.
@@ -162,14 +163,7 @@ func planFor(ctx context.Context, open *stores, nodeName string) (catalogue.Reso
 			}
 			continue
 		}
-		var secret inventory.Secret
+		secret, err := inv.SecretFor(ctx, n.Name, nodeName, n.For, n.From, n.Local)
-		var err error
-		if n.SharedOwn != "" {
-			// The provider's one credential, sealed to this consumer too (novox/hq ADR 0158).
-			secret, err = inv.SharedSecretFor(ctx, n.Name, nodeName, n.For, n.From, providerModuleOf(resolved, open, ctx, n), n.Local, n.SharedOwn)
-		} else {
-			secret, err = inv.SecretFor(ctx, n.Name, nodeName, n.For, n.From, n.Local)
-		}
 		if err != nil {
 			// Said rather than skipped. A machine that resolves cleanly and receives no
 			// credential is one that will fail to authenticate at some later, less obvious
@@ -184,12 +178,8 @@ func planFor(ctx context.Context, open *stores, nodeName string) (catalogue.Reso
 	// Settings for everything that resolved, including modules nobody assigned directly: a
 	// requirement pulled in by something else is still configurable, and finding out that it is
 	// not only when you try would be an arbitrary line nobody could predict.
-	//
-	// A setting that reaches nothing, or cannot compose with the definition it was stored for,
-	// no longer refuses the machine here: it is judged where it is stored, and a definition that
-	// moved under it costs that module its place in the declaration, said by name (novox/hq ADR
-	// 0163, rule 6 — see Compose).
 	settings := catalogue.SettingsBy{}
+	var stray []string
 	for _, m := range resolved.Modules {
 		layers, err := inv.SettingsFor(ctx, nodeName, m.Module)
 		if err != nil {
@@ -199,6 +189,18 @@ func planFor(ctx context.Context, open *stores, nodeName string) (catalogue.Reso
 			continue
 		}
 		settings[m.Module] = layers
+		stray = append(stray, catalogue.UnusedSettings(m, layers)...)
+	}
+	if len(stray) > 0 {
+		// Somebody set something that reaches no file. Said here rather than discovered by the
+		// machine not behaving differently, which is the slowest way there is.
+		//
+		// Marked like a set that will not compose, and for the same reason: it is a standing fact
+		// about this node's own configuration, not a question the mesh could not answer. A gatherer
+		// passes over it as it always did — one node's stray setting must not stop every other node
+		// being described (novox/hq 04-ISSUES/152).
+		return catalogue.Resolution{}, nil, notResolvable{fmt.Errorf(
+			"these settings reach nothing:\n  - %s", strings.Join(stray, "\n  - "))}
 	}
 	return resolved, settings, nil
 }
@@ -272,9 +274,8 @@ func theRestOfTheMesh(ctx context.Context, inv *inventory.Inventory,
 	for _, o := range others {
 		got, err := catalogue.Resolve(shelf, o.assigned, o.node, catalogue.World{Unchecked: true, Holdings: holdings})
 		if err != nil {
-			// Said, not skipped: a machine dropped here offers nothing and holds nothing as far
+			// Their set does not resolve for some other reason. Not this node's problem to
-			// as every other machine's plan can tell (novox/hq issue 188).
+			// report, and nothing of theirs is running, so it offers nothing.
-			fmt.Fprintf(os.Stderr, "%s is left out of the rest of the mesh: it does not resolve: %v\n", o.node.Name, err)
 			continue
 		}
 		firstHeld = append(firstHeld, got.Claims...)
@@ -305,22 +306,8 @@ func theRestOfTheMesh(ctx context.Context, inv *inventory.Inventory,
 	world := catalogue.World{Offered: offered, Held: firstHeld, Holdings: holdings}
 	var held []catalogue.Held
 	for _, o := range others {
-		// Each machine is resolved with its own pins, as its plan is: a machine that needs one to
+		got, err := catalogue.Resolve(shelf, o.assigned, o.node, world)
-		// settle two providers would otherwise be refused here and vanish from the mesh — every
-		// seat it holds unheld, every build that needs one refused (2026-10-01, the control node;
-		// novox/hq issue 188).
-		theirs := world
-		if pins, err := inv.PinsFor(ctx, o.node.Name); err == nil {
-			theirs.Pinned = pins
-		}
-		got, err := catalogue.Resolve(shelf, o.assigned, o.node, theirs)
 		if err != nil {
-			// Said only for the whole-mesh view. With one machine excluded, the others are
-			// resolved without its offers, and one that consumes them cannot resolve here by
-			// design — that is not the machine being dropped, it is the view being partial.
-			if exclude == "" {
-				fmt.Fprintf(os.Stderr, "%s is left out of the rest of the mesh: it does not resolve: %v\n", o.node.Name, err)
-			}
 			continue
 		}
 		held = append(held, got.Claims...)
@@ -394,33 +381,7 @@ func declarationWith(ctx context.Context, open *stores, node string,
 	if err != nil {
 		return sendable{}, err
 	}
-	return sendable{Resources: composed.Resources, Adoption: adoption,
+	return sendable{Resources: composed.Resources, Adoption: adoption}, nil
-		Received: composed.Received, Mesh: with.Mesh,
-		LeftOut: sortedKeysOf(composed.LeftOut), leftOutWhy: composed.LeftOut}, nil
-}
-
-// sortedKeysOf is a map's keys, sorted — so what a declaration says it left out does not move
-// for a reordering nobody made.
-func sortedKeysOf(m map[string]string) []string {
-	if len(m) == 0 {
-		return nil
-	}
-	out := make([]string, 0, len(m))
-	for k := range m {
-		out = append(out, k)
-	}
-	sort.Strings(out)
-	return out
-}
-
-// reportLeftOut says which of a machine's modules its declaration leaves out and why (novox/hq ADR
-// 0163, rule 6), one line each: the machine is told everything else, and is told it was left out.
-func reportLeftOut(node string, declared sendable) {
-	for _, m := range declared.LeftOut {
-		fmt.Printf("%s: %s left out — a setting stored for it cannot compose with its definition; "+
-			"what the machine holds for it is kept and its containers are untouched. %s\n",
-			node, m, declared.leftOutWhy[m])
-	}
 }
 
 // renderingFor is everything a node's declaration is composed with, and the node's record.
@@ -460,10 +421,7 @@ func renderingFor(ctx context.Context, open *stores, node string,
 	for _, m := range plan.Modules {
 		g, err := catalogue.GivenPorts(m, settings[m.Module])
 		if err != nil {
-			// A given port its definition no longer publishes: the module is left out of the
+			return catalogue.Rendering{}, inventory.Node{}, err
-			// declaration, by name, when it is composed (novox/hq ADR 0163, rule 6) — never the
-			// machine refused here for it.
-			continue
 		}
 		if g != nil {
 			given[m.Module] = g
@@ -533,23 +491,6 @@ func renderingFor(ctx context.Context, open *stores, node string,
 			var sealed string
 			var err error
 			if choosing == Allocating {
-				// **The broker credential is never invented here** (novox/hq issue 203). Every other
-				// own secret is the mesh's to make — a password nobody else knows — but this one
-				// is an account on the bus, minted by `module issue` and sealed by it; a push that
-				// made a random one would deliver a file the process cannot read and report the
-				// machine applied. Refused by name, with the verb.
-				if name == "broker" {
-					user := broker.Principal{Kind: broker.KindModule, Node: node, Module: m.Module}.Username()
-					if _, minted, err := inv.BusUserHash(ctx, user); err != nil {
-						return catalogue.Rendering{}, inventory.Node{}, err
-					} else if !minted {
-						return catalogue.Rendering{}, inventory.Node{}, fmt.Errorf(
-							"%s on %s has no bus credential: nothing was issued for %s, and a push "+
-								"would seal a placeholder its process cannot read (novox/hq issue 203). "+
-								"`module issue %s --node %s`, then push again",
-							m.Module, node, user, m.Module, node)
-					}
-				}
 				sealed, err = inv.SecretForModule(ctx, node, m.Module, name)
 			} else {
 				var held bool
@@ -645,24 +586,43 @@ func renderingFor(ctx context.Context, open *stores, node string,
 		}
 	}
 
-	// **The roster is the machines and nothing else** (novox/hq ADR 0191). Each node has one internal
+	// And every routed name → the node that serves it (novox/hq ADR 0066). Alongside the
-	// domain, `<node>.internal`, and every route on it is a name under that domain (ADR 0151), which
+	// `<node>.internal` names above, so a container — or an internal ACME validator — resolves a
-	// the resolver answers with one wildcard per machine — so no route needs a line of its own. A
+	// routed name to the proxy that serves it, mesh-wide. The mesh publishes the names it was told
-	// node's public domains are the operator's and public DNS answers them; the mesh gives no private
+	// to serve and knows nothing about what they mean.
-	// answer for any of them. The roster once carried every routed name, public ones included, and a
+	// Kept apart from the machines, because a fact about the machines must not be handed the names
-	// resolver that also serves a LAN handed a phone a tunnel address for the mail server.
+	// the mesh merely serves (novox/hq 04-ISSUES/111).
-	// `.Names` and `.Machines` stay two fields so a module's template keeps rendering (issue 111).
 	machines := make(map[string]string, len(names))
 	for name, at := range names {
 		machines[name] = at
 	}
+	routes, err := routeNamesInTheMesh(ctx, open)
+	if err != nil {
+		return catalogue.Rendering{}, inventory.Node{}, err
+	}
+	for name, at := range routes {
+		names[name] = at
+	}
 
-	// **The bus is never public** (novox/hq ADR 0169). It was a foundation port — widened from the
+	// The ports the mesh itself needs open, which no module declares. Read from the broker this
-	// broker's own `from: mesh` to from-anywhere on the broker's host, so a machine could enrol
+	// control plane was told about rather than written down twice: the address a node is handed in
-	// before it had an address on the private network. A machine joins through the tunnel now, and
+	// its token and the port its machine must accept on are the same fact.
-	// every link to the bus crosses it, so its reach is what the `nats` module declares: the mesh.
+	//
-	// Nothing the mesh itself needs is opened beyond what a module declares.
+	// **Only on the node that listens on it** (novox/hq issue: the broker opening leaked onto
+	// every node). The opening exists to WIDEN the broker's port to from-anywhere — a machine
+	// enrolling is not on the mesh yet, so the broker's own `from: mesh` listen would refuse its
+	// first dial. That widening belongs on the broker's host and nowhere else: a node that only
+	// dials out needs no incoming rule, and an opening for a port nothing here listens on is a
+	// from-anywhere hole for a dead port. So the foundation port is kept only when a module
+	// resolved onto THIS node actually listens on it.
 	var foundation []int
+	if b, err := broker.FromEnvironment(); err == nil {
+		if _, port, err := net.SplitHostPort(b.Address); err == nil {
+			if n, err := strconv.Atoi(port); err == nil {
+				foundation = foundationPortsFor(n, plan.Modules)
+			}
+		}
+	}
 
 	// And, for a module that keeps them, every operator-sealed secret in the mesh — the vault's
 	// copy, outside the store (novox/hq ADR 0085, amended). Read only; nothing here mints. The
@@ -734,6 +694,94 @@ func renderingFor(ctx context.Context, open *stores, node string,
 	}, record, nil
 }
 
+// routeNamesInTheMesh is every routed name and the address of the node that serves it (novox/hq
+// ADR 0066).
+//
+// **Mesh-wide, so any container resolves any routed name to its proxy** — including an internal
+// ACME validator, which cannot complete a challenge for a name it cannot reach. A routed name is
+// composed on the consumer's node (from its label and that node's public domain) and served by the
+// node answering the consumer's route requirement; this gathers both.
+//
+// It reads route names off resolutions rather than a table because there is no table: a route is a
+// contribution, computed from what each node runs. Name-agnostic — a contribution counts as a
+// routed name only because it carried a label the mesh composed, never because the mesh knows what
+// "route" means. A node that does not resolve is skipped, so one machine's broken set does not cost
+// the rest their names.
+//
+// **A node that could not be READ is a different matter and is raised.** Skipping one states, to
+// every machine at once, that its names do not exist — and since the roster is part of every
+// container's identity, that withdraws them and replaces every container (novox/hq 04-ISSUES/152,
+// 151). So every failure here says which machine and which read, because the alternative is a
+// mesh-wide refusal with nothing named in it.
+func routeNamesInTheMesh(ctx context.Context, open *stores) (map[string]string, error) {
+	inv := open.inventory
+	places, err := inv.Overlays(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("where the machines are cannot be read: %w", err)
+	}
+	address := map[string]string{}
+	for _, p := range places {
+		if strings.TrimSpace(p.Address) != "" {
+			address[p.Name] = p.Address
+		}
+	}
+
+	nodes, err := inv.Nodes(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("which machines the mesh has cannot be read: %w", err)
+	}
+
+	out := map[string]string{}
+	for _, n := range nodes {
+		plan, settings, err := planFor(ctx, open, n.Name)
+		switch {
+		case unresolvable(err):
+			// Their set does not compose, so they serve no names. Passed over, so one machine's
+			// broken set does not cost the rest theirs.
+			continue
+		case err != nil:
+			// The mesh could not be asked. Returning the roster without this machine's names would
+			// state that they do not exist — to every machine, and indistinguishably from the
+			// operator having withdrawn them (novox/hq 04-ISSUES/152).
+			return nil, fmt.Errorf("the names %s serves cannot be read: %w", n.Name, err)
+		}
+		for _, m := range plan.Modules {
+			for to := range m.Contributes {
+				values, asks, err := plan.ContributionsFrom(to, m.Module, settings)
+				if err != nil {
+					return nil, err
+				}
+				if !asks {
+					continue
+				}
+				// A routed name, and only that: a contribution the mesh composed a name for from a
+				// label it was given. A grant that happens to carry a `name` of its own — a database
+				// name — carries no label and is left alone.
+				if _, labelled := values["label"]; !labelled {
+					continue
+				}
+				name, _ := values["name"].(string)
+				if name == "" {
+					continue
+				}
+				// The node that serves it: whoever answers this consumer's route requirement, or
+				// this same node when the proxy is beside the consumer.
+				serving := n.Name
+				for _, need := range plan.Needs {
+					if need.Name == to && need.For == m.Module {
+						serving = need.From
+						break
+					}
+				}
+				if at := address[serving]; at != "" {
+					out[strings.ToLower(name)] = at
+				}
+			}
+		}
+	}
+	return out, nil
+}
+
 // certificateFor is what the mesh certifies about one machine's internal name.
 //
 // It reaches across two contexts and reads neither one's store from the other: `inventory` knows
@@ -946,20 +994,6 @@ func planCommand(ctx context.Context, args []string) error {
 		return nil
 	}
 
-	// Which modules a push would leave out, and why — said before the plan, since the plan is of
-	// what the machine would be told (novox/hq ADR 0163, rule 6). Judged, never composed: `plan`
-	// without --json allocates nothing.
-	if record, err := open.inventory.NodeByName(ctx, args[0]); err == nil {
-		left := plan.LeftOut(settings, record.Adopted)
-		reportLeftOut(args[0], sendable{LeftOut: sortedKeysOf(left), leftOutWhy: left})
-	}
-	// And a setting that reaches nothing — refused where it is stored, and said here for one
-	// stored before its definition moved from under it.
-	for _, m := range plan.Modules {
-		for _, stray := range catalogue.UnusedSettings(m, settings[m.Module]) {
-			fmt.Printf("%s: a setting reaches nothing — %s\n", args[0], stray)
-		}
-	}
 	fmt.Printf("%s would run:\n", args[0])
 	for _, m := range plan.Modules {
 		fmt.Printf("  %-20s %s\n", m.Module, plan.Because[m.Module])
@@ -1306,22 +1340,19 @@ func composeBusUsers(ctx context.Context, inv *inventory.Inventory,
 	return broker.ComposeAccounts(filled)
 }
 
-// providerModuleOf is which module answers a need on the providing node: the one in this node's
+// foundationPortsFor is the broker port, kept only when a module resolved onto this node listens
-// own set when the provider is here, else the one the catalogue says offers it.
+// on it (novox/hq issue: the broker opening leaked onto every node). The foundation opening
-func providerModuleOf(resolved catalogue.Resolution, open *stores, ctx context.Context, n catalogue.Needed) string {
+// exists to WIDEN the broker's `from: mesh` port to from-anywhere, because a machine enrolling is
-	for _, m := range resolved.Modules {
+// not on the mesh yet and its first dial would be refused. That widening belongs on the broker's
-		if _, shared := m.SharedCredentialOf(n.Name); shared {
+// host alone: a node that only dials out needs no incoming rule, and an opening for a port
-			return m.Module
+// nothing here listens on is a from-anywhere hole for a dead port.
+func foundationPortsFor(brokerPort int, modules []catalogue.Manifest) []int {
+	for _, m := range modules {
+		for _, l := range m.Listens {
+			if l.Port == brokerPort {
+				return []int{brokerPort}
 			}
 		}
-	shelf, err := open.inventory.Catalogue(ctx)
-	if err != nil {
-		return ""
 	}
-	for name, m := range shelf {
+	return nil
-		if _, shared := m.SharedCredentialOf(n.Name); shared {
-			return name
-		}
-	}
-	return ""
 }

cmd/mesh-controller/plans_one_at_a_time_test.go

@@ -1,47 +0,0 @@
-package main
-
-import (
-	"testing"
-	"time"
-
-	"github.com/novox/mesh-controller/internal/inventory"
-)
-
-// novox/hq issue 213: for the moment a machine hands its controller over, the container and the
-// process both run the plan timer on one store. Only the one holding the plans moves them; the other
-// leaves them alone, and moves them once they are let go.
-func TestAControllerLeavesThePlansToTheOneHoldingThem(t *testing.T) {
-	open := aMesh(t)
-	ctx := t.Context()
-	now := time.Now().UTC()
-	// Every tier done: the next step is the plan's last, and needs nothing but the store.
-	plan := inventory.Plan{ID: "plan-213", Repository: "r", Commit: "abc", Created: now, Updated: now,
-		State: inventory.PlanRolling, Tier: 1, Tiers: [][]string{{"app"}},
-		Modules: map[string]*inventory.PlanModule{"app": {State: "built"}}}
-	if err := open.inventory.SavePlan(ctx, plan); err != nil {
-		t.Fatal(err)
-	}
-
-	// The other controller: its own connections to the same store, holding the plans.
-	other, err := inventory.Open(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(other.Close)
-	release, err := other.HoldPlans(ctx, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(release) // before the close above: a pool waits for a connection still held
-
-	advancePlans(ctx, open)
-	if p, err := open.inventory.PlanByID(ctx, "plan-213"); err != nil || !p.Open() {
-		t.Fatalf("a controller moved a plan another held: %+v %v", p, err)
-	}
-
-	release()
-	advancePlans(ctx, open)
-	if p, err := open.inventory.PlanByID(ctx, "plan-213"); err != nil || p.State != inventory.PlanDone {
-		t.Fatalf("the plan did not move once it was let go: %+v %v", p, err)
-	}
-}

cmd/mesh-controller/push.go

@@ -4,11 +4,9 @@ import (
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
-	"encoding/json"
 	"errors"
 	"flag"
 	"fmt"
-	"log"
 	"os"
 	"sort"
 	"strings"
@@ -113,10 +111,7 @@ func serve(ctx context.Context) error {
 	// while everything else about it looks correct.
 	// And build results nobody was waiting for. A build triggered any other way than `build`
 	// would otherwise be reported into the void, which is the same as not reporting it.
-	server.Records(builds{inv, open})
+	server.Records(builds{inv})
-	// Open plans move on a timer as well as on outcomes (novox/hq ADR 0162): a tier waiting for
-	// machines to report moves when they have, and a plan left by a replaced controller resumes.
-	go planTicker(ctx, open)
 	// And what the catalogue decided a build meant. The builder's own result is already handled
 	// above; this is the other half — the control plane is the only one of the three that knows
 	// which machines run the thing, so it is the one that acts (novox/hq ADR 0072).
@@ -129,35 +124,6 @@ func serve(ctx context.Context) error {
 		return err
 	}
 
-	// And the mesh's own verbs, as the seat this control plane holds (novox/hq ADR 0154). Served
-	// from the store's row, so what the seat declares is what is answered.
-	handlers, behind, err := seatToolHandlers()
-	if err != nil {
-		return err
-	}
-	if len(behind) > 0 {
-		// Said once, loudly, and then served anyway (novox/hq ADR 0185): the mesh keeps answering
-		// while whatever put an older control plane here is undone.
-		fmt.Printf("this control plane is behind the %s row: it cannot run %s. "+
-			"Those answer the reason when called; everything else is served as usual\n",
-			catalogue.ControllerSeatName, strings.Join(behind, ", "))
-	}
-	bus, isNATS := server.Bus().(link.OverNATS)
-	if !isNATS {
-		return errors.New("the mesh's verbs are served over the bus, and this control plane is not on it")
-	}
-	stopServing, err := bus.ServeSeatTools(catalogue.ControllerSeatName, handlers, log.New(os.Stdout, "", log.LstdFlags))
-	if err != nil {
-		return err
-	}
-	defer stopServing()
-	// And says so on the bus (novox/hq ADR 0197): what it serves, as the NATS services protocol asks.
-	stopAnnouncing, err := bus.Announce(seatAnnouncement(handlers), log.New(os.Stdout, "", log.LstdFlags))
-	if err != nil {
-		return err
-	}
-	defer stopAnnouncing()
-
 	return server.Serve(ctx)
 }
 
@@ -211,12 +177,6 @@ func declare(ctx context.Context, args []string) error {
 	if err := link.Declare(ctx, server.Bus(), ident, node, raw, 15*time.Second); err != nil {
 		return err
 	}
-	// Written down like every other send (novox/hq issue 204): a declaration a person sent by hand
-	// is still what the machine was last told, and status must not read it as current for the one
-	// the mesh would compose.
-	if _, err := recordSent(ctx, inv, node, raw); err != nil {
-		return err
-	}
 	fmt.Printf("sent %s a signed declaration (%d bytes)\n", node, len(raw))
 	return nil
 }
@@ -360,7 +320,7 @@ func pushCommand(ctx context.Context, args []string) error {
 	if err != nil {
 		return err
 	}
-	sending, refusals := composeEach(asked, allotting(held, inv), func(node string) (sendable, error) {
+	sending, refusals := composeEach(asked, func(node string) (sendable, error) {
 		plan, settings, err := planFor(held, open, node)
 		if err != nil {
 			return sendable{}, err
@@ -372,18 +332,12 @@ func pushCommand(ctx context.Context, args []string) error {
 		// The private network is in here with everything else. It used to be composed separately
 		// and prepended, which meant every machine with an address was on it and no machine could
 		// be kept off. It is a module now, so it arrives the way a module does.
-		declared, err := declarationWith(held, open, node, plan, settings, gens, Allocating)
+		return declarationWith(held, open, node, plan, settings, gens, Allocating)
-		if err == nil {
-			reportLeftOut(node, declared)
-		}
-		return declared, err
 	})
 
 	sentDigest := map[string]string{}
 	defer release()
 	for _, s := range sending {
-		// The number is inside the signed bytes, so a replayed older declaration cannot borrow a
-		// newer one's (novox/hq 04-ISSUES/107); it was taken when the composition began (issue 204).
 		body, err := s.declared.Body()
 		if err != nil {
 			return err
@@ -393,20 +347,19 @@ func pushCommand(ctx context.Context, args []string) error {
 		}
 		// After it is away, not before. A digest recorded for something that failed to send would
 		// make the machine look current for a declaration it never received.
-		digest, err := recordSent(ctx, inv, s.node, body)
+		record, err := inv.NodeByName(ctx, s.node)
 		if err != nil {
 			return err
 		}
+		digest := digestOf(body)
+		if err := inv.RecordSent(ctx, record.ID, digest); err != nil {
+			return err
+		}
 		sentDigest[s.node] = digest
 		fmt.Printf("sent %s %d resource(s)\n", s.node, len(s.declared.Resources))
 	}
 	release()
 	fmt.Printf("\n%d node(s) told\n", len(sending))
-	// And each machine's memberships, as every other send does (ADR 0160): a push is the one most
-	// operators run, and on 2026-10-01 it was the one path that issued none.
-	if err := issueMemberships(ctx, open, server, sending); err != nil {
-		return err
-	}
 
 	// **A named push leaves the mesh consistent, not just the machine it named** (novox/hq
 	// issue 057, ADR 0083). Assigning a cross-node consumer mints a provision, and the PROVIDER's
@@ -469,18 +422,18 @@ func pushCommand(ctx context.Context, args []string) error {
 						return sendable{}, err
 					}
 					reportUnhostable(node, plan)
-					declared, err := declarationWith(held, open, node, plan, settings, gens, Allocating)
+					return declarationWith(held, open, node, plan, settings, gens, Allocating)
-					if err == nil {
-						reportLeftOut(node, declared)
-					}
-					return declared, err
 				},
 				func(s readyNode, body []byte) error {
 					if err := link.Declare(ctx, server.Bus(), ident, s.node, body,
 						15*time.Second); err != nil {
 						return err
 					}
-					if _, err := recordSent(ctx, inv, s.node, body); err != nil {
+					record, err := inv.NodeByName(ctx, s.node)
+					if err != nil {
+						return err
+					}
+					if err := inv.RecordSent(ctx, record.ID, digestOf(body)); err != nil {
 						return err
 					}
 					fmt.Printf("sent %s %d resource(s)\n", s.node, len(s.declared.Resources))
@@ -569,31 +522,17 @@ type readyNode struct {
 //
 // The all-or-nothing rule is kept where it means something — sendTo, which rotates a credential
 // across two machines that must agree — and dropped here, where it never did.
-func composeEach(names []string, allot func(node string) (int64, error),
+func composeEach(names []string,
 	compose func(node string) (sendable, error)) ([]readyNode, []string) {
 
 	var sending []readyNode
 	var refusals []string
 	for _, name := range names {
-		// **Numbered before it is composed, not before it is sent** (novox/hq issue 204). The
-		// number says where this declaration stands against every other the mesh composed for the
-		// machine, and the host refuses one lower than the last it applied. Taken at send time, as
-		// it was, a declaration composed a minute ago — before an assignment changed — went out with
-		// a number higher than one composed after the change and sent before it, and the machine
-		// took the older content as the newer word: on 2026-10-02 a runtime assigned and applied on
-		// two machines was undone two seconds later by exactly that. Taken here, before the first
-		// read, what was composed earlier is numbered lower whatever order the sends happen in.
-		seq, err := allot(name)
-		if err != nil {
-			refusals = append(refusals, fmt.Sprintf("%s:\n%v", name, err))
-			continue
-		}
 		declared, err := compose(name)
 		if err != nil {
 			refusals = append(refusals, fmt.Sprintf("%s:\n%v", name, err))
 			continue
 		}
-		declared.Sequence = seq
 		if len(declared.Resources) == 0 {
 			// Sent, not skipped (novox/hq issue 127). A node whose declaration composes to
 			// nothing may have HELD something before — the broker opening a placement gave it,
@@ -621,7 +560,7 @@ func sendRound(ctx context.Context, open *stores, names []string,
 		return nil, err
 	}
 	defer release()
-	sending, refused := composeEach(names, allotting(held, open.inventory), func(node string) (sendable, error) {
+	sending, refused := composeEach(names, func(node string) (sendable, error) {
 		return compose(held, node)
 	})
 	for _, s := range sending {
@@ -681,12 +620,6 @@ func sendTo(ctx context.Context, open *stores, names []string) error {
 	var sending []readyNode
 	var refusals []string
 	for _, name := range names {
-		// Numbered before composing, for the reason composeEach gives (novox/hq issue 204).
-		seq, err := allot(ctx, inv, name)
-		if err != nil {
-			refusals = append(refusals, fmt.Sprintf("%s:\n%v", name, err))
-			continue
-		}
 		plan, settings, err := planFor(ctx, open, name)
 		if err != nil {
 			refusals = append(refusals, fmt.Sprintf("%s:\n%v", name, err))
@@ -698,8 +631,6 @@ func sendTo(ctx context.Context, open *stores, names []string) error {
 			refusals = append(refusals, fmt.Sprintf("%s:\n%v", name, err))
 			continue
 		}
-		declared.Sequence = seq
-		reportLeftOut(name, declared)
 		sending = append(sending, readyNode{name, declared})
 	}
 	if len(refusals) > 0 {
@@ -721,73 +652,15 @@ func sendTo(ctx context.Context, open *stores, names []string) error {
 		if err := link.Declare(ctx, server.Bus(), ident, s.node, body, 15*time.Second); err != nil {
 			return err
 		}
-		if _, err := recordSent(ctx, inv, s.node, body); err != nil {
+		record, err := inv.NodeByName(ctx, s.node)
+		if err != nil {
+			return err
+		}
+		if err := inv.RecordSent(ctx, record.ID, digestOf(body)); err != nil {
 			return err
 		}
 		fmt.Printf("  sent %s %d resource(s)\n", s.node, len(s.declared.Resources))
 	}
-	// And every assignment on those machines its membership (novox/hq ADR 0160): composed from the
-	// same records the bus's accounts are, so what a runtime serves and what its account may are one
-	// composition. Issued after the declaration, because the runtime it is for arrives with it.
-	return issueMemberships(ctx, open, server, sending)
-}
-
-// issueMemberships publishes the membership of every module on the machines just sent.
-//
-// Each carries what its module receives and the private network's addresses, from the same
-// composition as the declaration it was sent (novox/hq ADR 0167): a provider reads what it is
-// given on the bus, and the file written beside it says the same thing.
-func issueMemberships(ctx context.Context, open *stores, server *link.Server, sent []readyNode) error {
-	records, err := open.inventory.BusRecords(ctx)
-	if err != nil {
-		return err
-	}
-	where := broker.PlacementsOf(records, records.Interchangeable)
-	bus, ok := server.Bus().(link.OverNATS)
-	if !ok {
-		return nil
-	}
-	// The declarations are sent and recorded by now; a membership that cannot be issued is said
-	// and does not unsay them. Every runtime without one serves the shape it derives (ADR 0160), so
-	// the push stands, the first failure is named once, and the next push tries again.
-	issued, failed := 0, 0
-	var first error
-	for _, s := range sent {
-		node := s.node
-		for _, d := range records.Assigned[node] {
-			membership := broker.MembershipFor(node, d, where)
-			membership.Mesh = s.declared.Mesh
-			for requirement, given := range s.declared.Received[d.Module] {
-				raw, err := json.Marshal(given)
-				if err != nil {
-					return err
-				}
-				if membership.Receives == nil {
-					membership.Receives = map[string]json.RawMessage{}
-				}
-				membership.Receives[requirement] = raw
-			}
-			body, err := json.Marshal(membership)
-			if err != nil {
-				return err
-			}
-			if err := bus.PublishMembership(ctx, node, d.Module, body); err != nil {
-				if first == nil {
-					first = err
-				}
-				failed++
-				continue
-			}
-			issued++
-		}
-	}
-	if issued > 0 {
-		fmt.Printf("  issued %d membership(s)\n", issued)
-	}
-	if failed > 0 {
-		fmt.Printf("  %d membership(s) could not be issued; the first: %v — the machines keep what "+
-			"they derive until the next push\n", failed, first)
-	}
 	return nil
 }
 
@@ -821,12 +694,6 @@ func wouldSend(ctx context.Context, open *stores,
 		if err != nil {
 			continue
 		}
-		// Composed with the number the machine was LAST sent, so this is byte for byte what it was
-		// sent when nothing else changed. A fresh number here would make every machine read as
-		// behind for ever (novox/hq 04-ISSUES/107).
-		if declared.Sequence, err = open.inventory.Sequence(ctx, n.ID); err != nil {
-			return nil, err
-		}
 		body, err := declared.Body()
 		if err != nil {
 			return nil, err
@@ -898,21 +765,6 @@ func raiseTheBus(ctx context.Context, inv *inventory.Inventory, address string)
 	if err := broker.RaiseSeats(js, inventory.MeshSeats(), holders); err != nil {
 		return err
 	}
-	// Every module's state (novox/hq ADR 0202), from the catalogue: a bucket exists from
-	// registration, so a module reading one may watch it before its owner runs anywhere. One that
-	// nothing declares any more is said and kept — what it holds is data.
-	buckets, err := inv.DeclaredBuckets(ctx)
-	if err != nil {
-		return err
-	}
-	undeclared, err := broker.RaiseBuckets(js, buckets)
-	if err != nil {
-		return err
-	}
-	if len(undeclared) > 0 {
-		fmt.Printf("the bus holds state nothing declares any more, kept because it is data: %s — "+
-			"removing it is a person's act\n", strings.Join(undeclared, ", "))
-	}
 	// And how every module hears what it consumes. Derived from the same records the user list is
 	// composed from, so a module the mesh grants a consumer's subjects has that consumer waiting.
 	// Done on every raise, not only when a credential is issued: every module moved onto this bus
@@ -936,8 +788,8 @@ func raiseTheBus(ctx context.Context, inv *inventory.Inventory, address string)
 		}
 		hearing++
 	}
-	fmt.Printf("the bus at %s has its streams, %d machine(s) can hear a declaration, %d module(s) "+
+	fmt.Printf("the bus at %s has its streams, %d machine(s) can hear a declaration, and %d module(s) "+
-		"can hear what they consume, and %d bucket(s) of state\n", broker.BareAddress(address), len(names), hearing, len(buckets))
+		"can hear what they consume\n", broker.BareAddress(address), len(names), hearing)
 	return nil
 }
 
@@ -975,40 +827,3 @@ func seatHolders(ctx context.Context, inv *inventory.Inventory) (map[string]brok
 	}
 	return out, nil
 }
-
-// number gives one send the next sequence for its node (novox/hq 04-ISSUES/107).
-// allotting is allot over one inventory, in the shape composeEach takes.
-func allotting(ctx context.Context, inv *inventory.Inventory) func(node string) (int64, error) {
-	return func(node string) (int64, error) { return allot(ctx, inv, node) }
-}
-
-// allot takes the next sequence for a machine — the number its next declaration carries.
-func allot(ctx context.Context, inv *inventory.Inventory, node string) (int64, error) {
-	record, err := inv.NodeByName(ctx, node)
-	if err != nil {
-		return 0, err
-	}
-	return inv.NextSequence(ctx, record.ID)
-}
-
-// recordSent writes down what a machine was just sent, and returns the digest.
-//
-// **On a context that outlives the caller's** (novox/hq issue 204). The record is written after the
-// declaration is away, so a send that failed is never recorded as current — and a controller being
-// replaced mid-send had its context cancelled between the two, so the machine was told and the mesh
-// never wrote it down: status read "applied, current" over a machine that had just been sent
-// something else. What was sent was sent; the record of it must not depend on the sender living
-// another second. Bounded, so a store that is away does not hold a dying process open for ever.
-func recordSent(ctx context.Context, inv *inventory.Inventory, node string, body []byte) (string, error) {
-	kept, cancel := context.WithTimeout(context.WithoutCancel(ctx), 10*time.Second)
-	defer cancel()
-	record, err := inv.NodeByName(kept, node)
-	if err != nil {
-		return "", err
-	}
-	digest := digestOf(body)
-	if err := inv.RecordSent(kept, record.ID, digest); err != nil {
-		return "", err
-	}
-	return digest, nil
-}

cmd/mesh-controller/push_test.go

@@ -17,7 +17,7 @@ import (
 // the wrong machine no longer refuses the whole node), applied one level up.
 func TestOneUnresolvableNodeStillLetsTheRestBeSent(t *testing.T) {
 	sending, refusals := composeEach(
-		[]string{"anchor", "home-server", "laptop"}, numbered(),
+		[]string{"anchor", "home-server", "laptop"},
 		func(node string) (sendable, error) {
 			if node == "anchor" {
 				return sendable{}, errors.New(`nothing provides "acme-ca", wanted by route-proxy`)
@@ -43,7 +43,7 @@ func TestOneUnresolvableNodeStillLetsTheRestBeSent(t *testing.T) {
 // (novox/hq issue 127): it may have held something before, and only sending the empty
 // declaration tells it to drop what the mesh owned. It is never a refusal.
 func TestAnEmptyDeclarationIsSentSoTheNodeDropsWhatItHeld(t *testing.T) {
-	sending, refusals := composeEach([]string{"spare"}, numbered(),
+	sending, refusals := composeEach([]string{"spare"},
 		func(string) (sendable, error) { return sendable{}, nil })
 	if len(sending) != 1 || len(refusals) != 0 {
 		t.Errorf("an empty declaration must be sent, not skipped or refused: %v / %v", sending, refusals)
@@ -74,9 +74,3 @@ func TestASkippedMachineIsStillAnError(t *testing.T) {
 		}
 	}
 }
-
-// numbered is an allotter for tests: one higher per call, as the inventory's is per machine.
-func numbered() func(string) (int64, error) {
-	var n int64
-	return func(string) (int64, error) { n++; return n, nil }
-}

cmd/mesh-controller/readable.go

@@ -3,7 +3,6 @@ package main
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/novox/mesh-controller/internal/inventory"
 	"sort"
 	"time"
 )
@@ -40,9 +39,6 @@ type meshStatus struct {
 	// whose is older is still working — and Waiting cannot tell those apart, because the sent
 	// digest is recorded at send, not at apply.
 	Reported []machineReported `json:"reported"`
-	// Plans is what the last merges produced and where each stands (novox/hq ADR 0162): the
-	// open ones first, each saying its tier, what it waits for, and whether it has waited too long.
-	Plans []planStatus `json:"plans"`
 	// Unresolved is every machine that cannot be worked out at all, with what the mesh said when
 	// it tried. **A machine here is in none of the lists above**: nothing was computed for it, so
 	// there is nothing to compare it against and nothing it can be behind — which is why a
@@ -67,21 +63,6 @@ type meshStatus struct {
 	// **A document without this said an outage was a well mesh.** Read from what each machine
 	// reported, so it is the machine's account and not the mesh's take-time listing.
 	Untaken []machineUntaken `json:"untaken,omitempty"`
-	// Filtered is every converged machine that is not filtered by the mesh alone (novox/hq ADR
-	// 0168), one entry per rule set the mesh did not write — the found firewall in force again,
-	// or a chain nobody speaks for. Absent when every converged machine is filtered by the mesh
-	// alone. A document without this called a machine well while a predecessor's chain refused
-	// what the mesh declared open.
-	Filtered []machineFiltered `json:"filtered,omitempty"`
-}
-
-// machineFiltered is one rule set on a converged machine that the mesh did not write and that
-// refuses traffic: where it is, whose the host reads it as, and what it refuses.
-type machineFiltered struct {
-	Node    string `json:"node"`
-	Where   string `json:"where"`
-	Owner   string `json:"owner"`
-	Refuses string `json:"refuses"`
 }
 
 // machineUntaken is one module a machine is holding rather than running, and how many resources of
@@ -171,7 +152,7 @@ func statusAsJSON(asked answers) ([]byte, error) {
 	out := meshStatus{Machines: len(nodes), Wrong: []machineDoing{},
 		Quiet: []machineQuiet{}, Behind: []moduleBehind{}, Waiting: []machineWaiting{},
 		Reported: []machineReported{}, Unresolved: []machineUnresolved{},
-		Network: asked.network, Adopted: adoptedNodes(nodes), Plans: planStatuses(asked.plans, time.Now())}
+		Network: asked.network, Adopted: adoptedNodes(nodes)}
 	// In a stated order, so two readings of an unchanged mesh are the same document.
 	untakenNodes := make([]string, 0, len(asked.untaken))
 	for name := range asked.untaken {
@@ -189,21 +170,6 @@ func statusAsJSON(asked answers) ([]byte, error) {
 				machineUntaken{Node: name, Module: m, Held: asked.untaken[name][m]})
 		}
 	}
-	filteredNodes := make([]string, 0, len(asked.filtered))
-	for name := range asked.filtered {
-		filteredNodes = append(filteredNodes, name)
-	}
-	sort.Strings(filteredNodes)
-	for _, name := range filteredNodes {
-		f := asked.filtered[name]
-		if fw := f.FoundFirewall; fw != nil && fw.Active {
-			out.Filtered = append(out.Filtered, machineFiltered{Node: name, Where: "the found firewall",
-				Owner: inventory.FilterFoundFirewall, Refuses: fw.Kind + " is in force again"})
-		}
-		for _, x := range f.Others() {
-			out.Filtered = append(out.Filtered, machineFiltered{Node: name, Where: x.Where, Owner: x.Owner, Refuses: x.Refuses})
-		}
-	}
 	for name := range asked.refused {
 		out.Unresolved = append(out.Unresolved, machineUnresolved{
 			Node: name, Problem: asked.refused[name]})

cmd/mesh-controller/readable_test.go

@@ -167,46 +167,3 @@ func TestAMachineFailingTheSameWayIsSaidToBeStuck(t *testing.T) {
 		t.Fatalf("one failure is not stuck: %v", once)
 	}
 }
-
-// A converged machine something other than the mesh filters is named, per rule set, and is not
-// well (novox/hq ADR 0168); one filtered by the mesh alone is not in the list.
-func TestAMachineNotFilteredByTheMeshAloneIsNamedAndNotWell(t *testing.T) {
-	alone := inventory.Filtering{Filters: []inventory.Filter{
-		{Where: "table inet mesh, chain input", Owner: inventory.FilterMesh, Refuses: "policy drop"},
-		{Where: "table ip filter, chain DOCKER", Owner: inventory.FilterRuntime, Refuses: "drop"},
-		{Where: "table ip filter, chain f2b-sshd", Owner: inventory.FilterBan, Refuses: "ip saddr 192.0.2.1 reject"},
-	}}
-	if !alone.Alone() {
-		t.Fatal("the mesh's own, the runtime's and a ban are not the mesh alone")
-	}
-	notAlone := inventory.Filtering{
-		Filters: append(alone.Filters, inventory.Filter{Where: "chain HAL-MESH-ONLY (iptables-legacy)",
-			Owner: inventory.FilterOther, Refuses: `-A HAL-MESH-ONLY -m comment --comment "not public" -j DROP`}),
-		FoundFirewall: &inventory.FoundFirewall{Kind: "ufw", Active: true},
-	}
-	asked := answers{nodes: []inventory.Node{{Name: "home-server"}, {Name: "laptop"}},
-		filtered: map[string]inventory.Filtering{"home-server": notAlone}}
-	if asked.well() {
-		t.Fatal("a machine not filtered by the mesh alone reads as well")
-	}
-	body, err := statusAsJSON(asked)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var parsed struct {
-		Filtered []map[string]string `json:"filtered"`
-	}
-	if err := json.Unmarshal(body, &parsed); err != nil {
-		t.Fatal(err)
-	}
-	if len(parsed.Filtered) != 2 {
-		t.Fatalf("filtered: %v", parsed.Filtered)
-	}
-	if parsed.Filtered[0]["node"] != "home-server" || parsed.Filtered[0]["owner"] != inventory.FilterFoundFirewall ||
-		parsed.Filtered[1]["where"] != "chain HAL-MESH-ONLY (iptables-legacy)" || parsed.Filtered[1]["owner"] != inventory.FilterOther {
-		t.Fatalf("filtered: %v", parsed.Filtered)
-	}
-	if body, _ := statusAsJSON(answers{nodes: asked.nodes}); strings.Contains(string(body), `"filtered"`) {
-		t.Fatal("a mesh filtered by itself alone carries a filtered list")
-	}
-}

cmd/mesh-controller/release_plan.go

@@ -1,875 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"flag"
-	"fmt"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/novox/mesh-controller/internal/inventory"
-	"github.com/novox/mesh-controller/internal/link"
-)
-
-// A merge produces a tiered plan the mesh keeps (novox/hq ADR 0162).
-//
-// The handler that hears the merge computes the plan from the catalogue's one dependency relation,
-// writes it to the store, asks the first tier and returns — the receive loop is never held by a
-// build. Every outcome taken in advances the plan it belongs to; a ticker advances what outcomes
-// alone cannot (a tier waiting for machines to report); a controller replaced mid-plan finds the
-// plan where it left it.
-
-// planWaitBound is how long a plan may wait on one thing before `status` names it red.
-const planWaitBound = 30 * time.Minute
-
-// tiersOf sorts a set of modules into tiers along the ordering edges among them: tier 0 depends
-// on nothing else in the set, tier 1 only on tier 0, and so on. An edge to a module outside the set says
-// nothing about the order inside it. A cycle — which the catalogue should never produce — puts
-// what remains in one last tier rather than losing it, and is said by the caller.
-func tiersOf(set []string, edges []inventory.Edge) [][]string {
-	in := map[string]bool{}
-	for _, m := range set {
-		in[m] = true
-	}
-	deps := map[string]map[string]bool{}
-	for _, m := range set {
-		deps[m] = map[string]bool{}
-	}
-	// The build seat's holders follow the controller that defines their worker (EdgeWorkerOf,
-	// novox/hq issue 206), so the built-by edge from that controller to such a holder yields: the
-	// controller is built by whichever build machine is running, as the runtime image always was.
-	worker := map[string]map[string]bool{}
-	for _, e := range edges {
-		if e.Kind == inventory.EdgeWorkerOf && in[e.From] && in[e.To] {
-			if worker[e.To] == nil {
-				worker[e.To] = map[string]bool{}
-			}
-			worker[e.To][e.From] = true
-		}
-	}
-	for _, e := range edges {
-		// A code dependency — B packages A's source — rebuilds B with A, in the same tier: B's
-		// build needs nothing of A's first. The other kinds order: stands-on and declared after
-		// the base is built, built-by after the build machine is built and running — except for
-		// what the build machine itself stands on, and for the controller whose worker the build
-		// machine binds. The runtime image is built by the builder and the builder is built on the
-		// runtime image; the image comes first, built by the builder that is running.
-		if !in[e.From] || !in[e.To] || e.From == e.To || e.Kind == inventory.EdgePackages {
-			continue
-		}
-		if e.Kind == inventory.EdgeBuiltBy && (isBaseOf(e.From, e.To, edges, in) || worker[e.From][e.To]) {
-			continue
-		}
-		deps[e.From][e.To] = true
-	}
-	placed := map[string]bool{}
-	var tiers [][]string
-	for len(placed) < len(set) {
-		var tier []string
-		for _, m := range set {
-			if placed[m] {
-				continue
-			}
-			free := true
-			for d := range deps[m] {
-				if !placed[d] {
-					free = false
-					break
-				}
-			}
-			if free {
-				tier = append(tier, m)
-			}
-		}
-		if len(tier) == 0 {
-			// A cycle: everything left, together, and the caller says so.
-			for _, m := range set {
-				if !placed[m] {
-					tier = append(tier, m)
-				}
-			}
-		}
-		sort.Strings(tier)
-		for _, m := range tier {
-			placed[m] = true
-		}
-		tiers = append(tiers, tier)
-	}
-	return tiers
-}
-
-// isBaseOf says whether `to` stands on `base`, directly or through other bases in the set, along
-// the build edges alone.
-func isBaseOf(base, to string, edges []inventory.Edge, in map[string]bool) bool {
-	seen := map[string]bool{}
-	var walk func(string) bool
-	walk = func(m string) bool {
-		if m == base {
-			return true
-		}
-		if seen[m] {
-			return false
-		}
-		seen[m] = true
-		for _, e := range edges {
-			if e.From == m && in[e.To] && (e.Kind == inventory.EdgeStandsOn || e.Kind == inventory.EdgeDeclared) && walk(e.To) {
-				return true
-			}
-		}
-		return false
-	}
-	return walk(to)
-}
-
-// reachableFrom is the moved modules plus everything that depends on them, through every layer:
-// what a merge rebuilds. Along the code and build edges only: a module *built by* the build machine
-// is not changed by a new build machine, so a built-by edge orders and gates a plan and never
-// widens it — the first plan of 2026-10-01 took the whole catalogue along for a controller change.
-func reachableFrom(moved []string, edges []inventory.Edge) []string {
-	in := map[string]bool{}
-	for _, m := range moved {
-		in[m] = true
-	}
-	for grew := true; grew; {
-		grew = false
-		for _, e := range edges {
-			// Built-by and worker-of order a plan; neither widens it. A new build machine changes
-			// nothing it builds, and a new controller changes nothing about the holder it orders —
-			// what packages the controller's source is already a code edge.
-			if e.Kind == inventory.EdgeBuiltBy || e.Kind == inventory.EdgeWorkerOf {
-				continue
-			}
-			if in[e.To] && !in[e.From] {
-				in[e.From] = true
-				grew = true
-			}
-		}
-	}
-	out := make([]string, 0, len(in))
-	for m := range in {
-		out = append(out, m)
-	}
-	sort.Strings(out)
-	return out
-}
-
-// hasCycle says whether the tiers' last tier holds modules that still depend on each other.
-func hasCycle(tiers [][]string, edges []inventory.Edge) bool {
-	if len(tiers) == 0 {
-		return false
-	}
-	last := map[string]bool{}
-	for _, m := range tiers[len(tiers)-1] {
-		last[m] = true
-	}
-	for _, e := range edges {
-		if last[e.From] && last[e.To] {
-			return true
-		}
-	}
-	return false
-}
-
-// planFor is the plan a merge produces: the moved modules and everything reachable from them,
-// tiered, with the merge it answers.
-func planOfMerge(m link.SourceMoved, moved []string, edges []inventory.Edge) inventory.Plan {
-	set := reachableFrom(moved, edges)
-	tiers := tiersOf(set, edges)
-	modules := map[string]*inventory.PlanModule{}
-	for _, name := range set {
-		modules[name] = &inventory.PlanModule{}
-	}
-	return inventory.Plan{
-		ID:         fmt.Sprintf("plan-%d", time.Now().UnixNano()),
-		Repository: m.Owner + "/" + m.Repo,
-		Commit:     m.Commit,
-		Created:    time.Now().UTC(),
-		State:      inventory.PlanBuilding,
-		Tiers:      tiers,
-		Modules:    modules,
-	}
-}
-
-// gates is what the next tier needs running from this one: a module of the tier that a later
-// tier is built by — the runtime dependency — and whose policy rolls it out, must be applied by
-// the machines running it before the next tier is asked. A base an image stands on need only be
-// built; a source another module packages need not even be that.
-func gates(p inventory.Plan, edges []inventory.Edge, rollsOut func(string) bool) []string {
-	if p.Tier >= len(p.Tiers) {
-		return nil
-	}
-	inTier := map[string]bool{}
-	all := map[string]bool{}
-	for _, tier := range p.Tiers {
-		for _, m := range tier {
-			all[m] = true
-		}
-	}
-	for _, m := range p.Tiers[p.Tier] {
-		inTier[m] = true
-	}
-	later := map[string]bool{}
-	for _, tier := range p.Tiers[p.Tier+1:] {
-		for _, m := range tier {
-			later[m] = true
-		}
-	}
-	seen := map[string]bool{}
-	var out []string
-	for _, e := range edges {
-		if later[e.From] && inTier[e.To] && e.Kind == inventory.EdgeBuiltBy && !seen[e.To] && rollsOut(e.To) &&
-			!isBaseOf(e.From, e.To, edges, all) {
-			seen[e.To] = true
-			out = append(out, e.To)
-		}
-	}
-	sort.Strings(out)
-	return out
-}
-
-// applied says whether every machine running the module has reported since the module was built.
-func applied(module string, builtAt time.Time, running []string, reports []inventory.Reported) (bool, []string) {
-	at := map[string]*time.Time{}
-	for _, r := range reports {
-		at[r.Node] = r.At
-	}
-	var waiting []string
-	for _, n := range running {
-		if t := at[n]; t == nil || t.Before(builtAt) {
-			waiting = append(waiting, n)
-		}
-	}
-	return len(waiting) == 0, waiting
-}
-
-// askTier asks the build machine for every module of the tier, and marks each asked. A module
-// the catalogue no longer holds, or whose ask could not be made, is a failure of the plan: a tier
-// half asked is a tier that will never complete.
-func askTier(ctx context.Context, inv *inventory.Inventory, p *inventory.Plan) error {
-	entries, err := inv.Catalogued(ctx)
-	if err != nil {
-		return err
-	}
-	byName := map[string]inventory.Entry{}
-	for _, e := range entries {
-		byName[e.Manifest.Module] = e
-	}
-	now := time.Now().UTC()
-	for _, name := range p.Tiers[p.Tier] {
-		state := p.Modules[name]
-		if state == nil {
-			state = &inventory.PlanModule{}
-			p.Modules[name] = state
-		}
-		e, known := byName[name]
-		if !known {
-			state.State = "failed"
-			state.Why = "no longer in the catalogue"
-			p.State = inventory.PlanFailed
-			p.Note = name + " is no longer in the catalogue"
-			continue
-		}
-		source := buildSource{Repository: e.Source.Repository, Seat: e.Source.Seat}
-		fmt.Printf("  tier %d: ", p.Tier)
-		// The branch it follows, never a commit a build once named (novox/hq 04-ISSUES/215).
-		if err := buildOne(ctx, source, e.Source.Path, followedBranch(e.Source.Ref), 0); err != nil {
-			state.State = "failed"
-			state.Why = err.Error()
-			p.State = inventory.PlanFailed
-			p.Note = fmt.Sprintf("%s could not be asked for: %v", name, err)
-			continue
-		}
-		state.State = "asked"
-		state.AskedAt = &now
-	}
-	return nil
-}
-
-// planBuilt marks a module built (or failed) in every open plan whose current tier holds it, and
-// advances what that completes. Called from the daemon's take-in of every outcome.
-//
-// **Only a build asked at or after the plan's ask is its outcome** (novox/hq 04-ISSUES/219). Two
-// plans a few minutes apart both ask for a module; the earlier plan's build, finishing late, is not
-// the later plan's answer — it stood on the bases from before the later plan's merge, and taking it
-// would send machines, and the next tier, what the later merge replaced. asked is zero when the
-// build's request time is not known, and such an outcome is taken as before.
-func planBuilt(ctx context.Context, open *stores, module, commit, failed string, asked time.Time) {
-	inv := open.inventory
-	// One controller works the plans at a time (novox/hq issue 213); an outcome waits its turn rather
-	// than write over what the holder is about to save. Not taken, it is still in the build records,
-	// which the holder settles the plan from (issue 214).
-	release, err := inv.HoldPlans(ctx, true)
-	if err != nil {
-		fmt.Printf("plans: %s's outcome is left to the build records: %v\n", module, err)
-		return
-	}
-	defer release()
-	plans, err := inv.OpenPlans(ctx)
-	if err != nil {
-		fmt.Printf("plans: cannot read them: %v\n", err)
-		return
-	}
-	now := time.Now().UTC()
-	for i := range plans {
-		p := &plans[i]
-		if p.Tier >= len(p.Tiers) {
-			continue
-		}
-		inTier := false
-		for _, m := range p.Tiers[p.Tier] {
-			if m == module {
-				inTier = true
-			}
-		}
-		if !inTier {
-			continue
-		}
-		state := p.Modules[module]
-		if state == nil {
-			state = &inventory.PlanModule{}
-			p.Modules[module] = state
-		}
-		if askedBefore(asked, state.AskedAt) {
-			continue
-		}
-		if failed != "" {
-			state.State = "failed"
-			state.Why = failed
-			p.State = inventory.PlanFailed
-			p.Note = fmt.Sprintf("%s failed to build in tier %d", module, p.Tier)
-		} else {
-			state.State = "built"
-			state.BuiltAt = &now
-			state.Commit = commit
-		}
-		if err := inv.SavePlan(ctx, *p); err != nil {
-			fmt.Printf("%s: cannot keep the plan: %v\n", p.ID, err)
-			continue
-		}
-		if p.State == inventory.PlanFailed {
-			fmt.Printf("%s: %s; the tiers after it are not asked\n", p.ID, p.Note)
-		}
-	}
-	advanceHeld(ctx, open)
-}
-
-// advancePlans moves every open plan as far as the facts allow: a tier whose modules are all built
-// and whose gates are applied gives way to the next; the last tier done is the plan done. Called
-// after every outcome and on a timer, so a plan waiting on a machine's report moves when it comes.
-//
-// **One controller at a time** (novox/hq issue 213). A plan is read, changed and saved whole; two
-// controllers — the old and the new while a machine hands its controller over — would each ask a
-// tier the other had just asked. Taken without waiting: whoever holds the plans is moving them.
-func advancePlans(ctx context.Context, open *stores) {
-	release, err := open.inventory.HoldPlans(ctx, false)
-	if err != nil {
-		if !errors.Is(err, inventory.ErrPlansBusy) {
-			fmt.Printf("plans: cannot hold them: %v\n", err)
-		}
-		return
-	}
-	defer release()
-	advanceHeld(ctx, open)
-}
-
-// advanceHeld is advancePlans for a caller already holding the plans.
-func advanceHeld(ctx context.Context, open *stores) {
-	inv := open.inventory
-	plans, err := inv.OpenPlans(ctx)
-	if err != nil {
-		fmt.Printf("plans: cannot read them: %v\n", err)
-		return
-	}
-	if len(plans) == 0 {
-		return
-	}
-	edges, err := inv.Dependencies(ctx)
-	if err != nil {
-		fmt.Printf("plans: cannot read the dependencies: %v\n", err)
-		return
-	}
-	rollsOut := func(module string) bool {
-		u, err := inv.UpgradeOf(ctx, module)
-		return err == nil && u.RollOut
-	}
-	for i := range plans {
-		p := &plans[i]
-		for p.Open() {
-			moved, err := advanceOnce(ctx, open, p, edges, rollsOut)
-			if err != nil {
-				fmt.Printf("%s: %v\n", p.ID, err)
-				break
-			}
-			if err := inv.SavePlan(ctx, *p); err != nil {
-				fmt.Printf("%s: cannot keep the plan: %v\n", p.ID, err)
-				break
-			}
-			if !moved {
-				break
-			}
-		}
-	}
-}
-
-// advanceOnce takes one step of one plan and says whether anything changed.
-func advanceOnce(ctx context.Context, open *stores, p *inventory.Plan,
-	edges []inventory.Edge, rollsOut func(string) bool) (bool, error) {
-	inv := open.inventory
-	if p.Tier >= len(p.Tiers) {
-		p.State = inventory.PlanDone
-		fmt.Printf("%s: done — %s at %s, %d tier(s)\n", p.ID, p.Repository, short(p.Commit), len(p.Tiers))
-		return true, nil
-	}
-	tier := p.Tiers[p.Tier]
-	// Not yet asked: ask.
-	unasked := 0
-	for _, m := range tier {
-		if s := p.Modules[m]; s == nil || s.State == "" {
-			unasked++
-		}
-	}
-	if unasked == len(tier) {
-		if err := askTier(ctx, inv, p); err != nil {
-			return false, err
-		}
-		return true, nil
-	}
-	// **Asked: settle from the build records first** (novox/hq 04-ISSUES/214). An outcome is taken
-	// in by whichever controller hears it, and a merge to the controller's own repository replaces
-	// the controller in its first tier: the build that produced the new one is recorded, and the
-	// plan never hears it. The record is the fact; a build recorded after the ask is that tier's
-	// outcome, whoever was listening.
-	recorded := map[string][]inventory.Build{}
-	for _, m := range tier {
-		if s := p.Modules[m]; s != nil && s.State == "asked" {
-			builds, err := inv.Builds(ctx, m, 5)
-			if err != nil {
-				return false, err
-			}
-			recorded[m] = builds
-		}
-	}
-	if settleFromRecords(p, tier, recorded) {
-		return true, nil
-	}
-	// Asked: wait for every build.
-	var latest time.Time
-	for _, m := range tier {
-		s := p.Modules[m]
-		if s == nil || s.State != "built" {
-			return false, nil
-		}
-		if s.BuiltAt != nil && s.BuiltAt.After(latest) {
-			latest = *s.BuiltAt
-		}
-	}
-	// Built: send every module of the tier whose policy rolls out, once, to the machines running
-	// it — whether or not its source commit moved. A dependent rebuilt because its base moved, or
-	// a module that packages another repository's source, keeps its commit; the catalogue announces
-	// no move for it and its machines would keep the old image until somebody pushed (novox/hq
-	// issue 189). A module whose policy records is built and left, as its policy says.
-	for _, m := range tier {
-		state := p.Modules[m]
-		if state == nil || state.SentAt != nil || !rollsOut(m) {
-			continue
-		}
-		running, err := inv.Running(ctx, m)
-		if err != nil {
-			return false, err
-		}
-		now := time.Now().UTC()
-		state.SentAt = &now
-		if len(running) == 0 {
-			continue
-		}
-		if err := sendTo(ctx, open, running); err != nil {
-			return false, fmt.Errorf("sending %s to %s after tier %d: %w", m, strings.Join(running, ", "), p.Tier, err)
-		}
-		fmt.Printf("%s: tier %d built; sent %s to %s\n", p.ID, p.Tier, m, strings.Join(running, ", "))
-		return true, nil
-	}
-	// And wait for what the next tier needs running.
-	needed := gates(*p, edges, rollsOut)
-	if len(needed) > 0 {
-		reports, err := inv.LastReports(ctx)
-		if err != nil {
-			return false, err
-		}
-		var waiting []string
-		for _, m := range needed {
-			running, err := inv.Running(ctx, m)
-			if err != nil {
-				return false, err
-			}
-			state := p.Modules[m]
-			if state == nil {
-				state = &inventory.PlanModule{}
-				p.Modules[m] = state
-			}
-			// The plan sends what it waits for. A rebuild from the same source commit is not a
-			// move the catalogue announces — the build machine rebuilt for a controller change
-			// is one — so the roll-out that opens this gate is the plan's to make, once, and
-			// the reports that open it are the ones after the send.
-			since := latest
-			if state.BuiltAt != nil {
-				since = *state.BuiltAt
-			}
-			if state.SentAt != nil && state.SentAt.After(since) {
-				since = *state.SentAt
-			}
-			if ok, on := applied(m, since, running, reports); !ok {
-				waiting = append(waiting, fmt.Sprintf("%s on %s", m, strings.Join(on, ", ")))
-			}
-		}
-		if len(waiting) > 0 {
-			note := "tier " + fmt.Sprint(p.Tier) + " built; waiting for " + strings.Join(waiting, "; ") + " to be applied"
-			changed := p.State != inventory.PlanRolling || p.Note != note
-			p.State = inventory.PlanRolling
-			p.Note = note
-			return changed, nil
-		}
-	}
-	p.Tier++
-	p.State = inventory.PlanBuilding
-	p.Note = ""
-	if p.Tier < len(p.Tiers) {
-		fmt.Printf("%s: tier %d done; asking tier %d: %s\n", p.ID, p.Tier-1, p.Tier, strings.Join(p.Tiers[p.Tier], ", "))
-	}
-	return true, nil
-}
-
-// planTicker advances open plans on a timer, for the steps outcomes alone cannot take.
-func planTicker(ctx context.Context, open *stores) {
-	advancePlans(ctx, open)
-	tick := time.NewTicker(30 * time.Second)
-	defer tick.Stop()
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-tick.C:
-			advancePlans(ctx, open)
-		}
-	}
-}
-
-// planLine is one plan as `status` says it.
-func planLine(p inventory.Plan, now time.Time) string {
-	where := fmt.Sprintf("tier %d of %d", min(p.Tier+1, len(p.Tiers)), len(p.Tiers))
-	switch p.State {
-	case inventory.PlanDone:
-		return fmt.Sprintf("%s %s done, %d tier(s)", p.Repository, short(p.Commit), len(p.Tiers))
-	case inventory.PlanFailed:
-		return fmt.Sprintf("%s %s FAILED at %s: %s", p.Repository, short(p.Commit), where, p.Note)
-	}
-	since := now.Sub(p.Updated).Round(time.Minute)
-	late := ""
-	if since > planWaitBound {
-		late = " — LATE"
-	}
-	what := "building"
-	if p.State == inventory.PlanRolling {
-		what = p.Note
-	}
-	return fmt.Sprintf("%s %s %s, %s for %s%s", p.Repository, short(p.Commit), where, what, since, late)
-}
-
-// planFailedBuild marks the module a failed build was for when the result names no module: by the
-// repository and path the plan's modules were asked at.
-func planFailedBuild(ctx context.Context, open *stores, result link.BuildResult) {
-	entries, err := open.inventory.Catalogued(ctx)
-	if err != nil {
-		return
-	}
-	for _, e := range entries {
-		if repositoryMatches(e.Source.Repository, result.Repository) && e.Source.Path == result.Path {
-			asked, _ := link.BuildAskedAt(result.ID)
-			planBuilt(ctx, open, e.Manifest.Module, result.Commit, result.Failed, asked)
-			return
-		}
-	}
-}
-
-func repositoryMatches(a, b string) bool {
-	trim := func(s string) string { return strings.ToLower(strings.TrimSuffix(s, ".git")) }
-	return trim(a) == trim(b) || strings.HasSuffix(trim(a), "/"+trim(b)) || strings.HasSuffix(trim(b), "/"+trim(a))
-}
-
-// planStatus is one plan as `status --json` says it.
-type planStatus struct {
-	ID         string    `json:"id"`
-	Repository string    `json:"repository"`
-	Commit     string    `json:"commit"`
-	State      string    `json:"state"`
-	Tier       int       `json:"tier"`
-	Tiers      int       `json:"tiers"`
-	Waiting    string    `json:"waiting,omitempty"`
-	Since      time.Time `json:"since"`
-	Late       bool      `json:"late"`
-}
-
-func planStatuses(plans []inventory.Plan, now time.Time) []planStatus {
-	out := make([]planStatus, 0, len(plans))
-	for _, p := range plans {
-		ps := planStatus{ID: p.ID, Repository: p.Repository, Commit: p.Commit, State: p.State,
-			Tier: p.Tier, Tiers: len(p.Tiers), Since: p.Updated}
-		if p.Open() {
-			ps.Waiting = p.Note
-			if ps.Waiting == "" {
-				ps.Waiting = "builds of tier " + fmt.Sprint(p.Tier)
-			}
-			ps.Late = now.Sub(p.Updated) > planWaitBound
-		}
-		out = append(out, ps)
-	}
-	return out
-}
-
-// openPlans is the open plans among the recent ones, and how many have waited past the bound.
-func openPlans(plans []inventory.Plan) ([]inventory.Plan, int) {
-	var open []inventory.Plan
-	late := 0
-	for _, p := range plans {
-		if p.Open() {
-			open = append(open, p)
-			if time.Since(p.Updated) > planWaitBound {
-				late++
-			}
-		}
-	}
-	return open, late
-}
-
-// plansCommand says what the last merges produced and where each stands; given an id, one plan
-// tier by tier with every module's state.
-func plansCommand(ctx context.Context, args []string) error {
-	set := flag.NewFlagSet("plans", flag.ContinueOnError)
-	limit := set.Int("n", 10, "how many to show")
-	whatIf := set.String("what-if", "", "owner/repository: the plan a merge there would produce, saving nothing — with --paths or --modules")
-	paths := set.String("paths", "", "the files the merge would change, comma-separated, from the repository's root")
-	modules := set.String("modules", "", "or the modules it would change, comma-separated")
-	positionals, err := parseAround(set, args)
-	if err != nil {
-		return err
-	}
-	open, err := openStores(ctx)
-	if err != nil {
-		return err
-	}
-	defer open.Close()
-	inv := open.inventory
-	now := time.Now()
-	if len(positionals) == 1 {
-		p, err := inv.PlanByID(ctx, positionals[0])
-		if err != nil {
-			return err
-		}
-		fmt.Printf("%s — %s\n", p.ID, planLine(p, now))
-		for i, tier := range p.Tiers {
-			marker := " "
-			if i == p.Tier && p.Open() {
-				marker = ">"
-			}
-			fmt.Printf("%s tier %d\n", marker, i)
-			for _, m := range tier {
-				s := p.Modules[m]
-				state := "not yet asked"
-				if s != nil && s.State != "" {
-					state = s.State
-					if s.Commit != "" {
-						state += " from " + short(s.Commit)
-					}
-					if s.Why != "" {
-						state += ": " + s.Why
-					}
-				}
-				fmt.Printf("    %-22s %s\n", m, state)
-			}
-		}
-		return nil
-	}
-	if *whatIf != "" {
-		return planWhatIf(ctx, inv, *whatIf, splitList(*paths), splitList(*modules))
-	}
-	if len(positionals) == 2 && positionals[0] == "stop" {
-		p, err := inv.PlanByID(ctx, positionals[1])
-		if err != nil {
-			return err
-		}
-		if !p.Open() {
-			return fmt.Errorf("%s is already %s", p.ID, p.State)
-		}
-		p.State = inventory.PlanFailed
-		p.Note = "stopped by hand at tier " + fmt.Sprint(p.Tier)
-		release, err := inv.HoldPlans(ctx, true)
-		if err != nil {
-			return err
-		}
-		defer release()
-		if p, err = inv.PlanByID(ctx, positionals[1]); err != nil {
-			return err
-		}
-		if !p.Open() {
-			return fmt.Errorf("%s is already %s", p.ID, p.State)
-		}
-		p.State = inventory.PlanFailed
-		p.Note = "stopped by hand at tier " + fmt.Sprint(p.Tier)
-		if err := inv.SavePlan(ctx, p); err != nil {
-			return err
-		}
-		fmt.Printf("%s stopped at tier %d of %d; what was asked still builds and registers, nothing further is asked\n",
-			p.ID, p.Tier, len(p.Tiers))
-		return nil
-	}
-	plans, err := inv.RecentPlans(ctx, *limit)
-	if err != nil {
-		return err
-	}
-	if len(plans) == 0 {
-		fmt.Println("no merge has produced a plan yet")
-		return nil
-	}
-	for _, p := range plans {
-		fmt.Printf("%-28s %s\n", p.ID, planLine(p, now))
-	}
-	return nil
-}
-
-// planWhatIf is the plan a merge would produce, computed the way the merge handler computes one
-// and saved nowhere: the modules the repository's changed files touch (or the modules named), what
-// packages their source, everything reachable from them, in tiers. For reading before merging.
-func planWhatIf(ctx context.Context, inv *inventory.Inventory, repository string, paths, modules []string) error {
-	owner, repo, found := strings.Cut(repository, "/")
-	if !found {
-		return fmt.Errorf("--what-if takes owner/repository, not %q", repository)
-	}
-	m := link.SourceMoved{Owner: owner, Repo: repo, Base: "main", Commit: "what-if", Paths: paths}
-	entries, err := inv.Catalogued(ctx)
-	if err != nil {
-		return err
-	}
-	read, err := inv.ReadRepositories(ctx)
-	if err != nil {
-		return err
-	}
-	var from, packaging []inventory.Entry
-	named := map[string]bool{}
-	for _, name := range modules {
-		named[name] = true
-	}
-	for _, e := range entries {
-		switch {
-		case named[e.Manifest.Module]:
-			from = append(from, e)
-		case len(named) == 0 && sourceIs(e.Source, m):
-			from = append(from, e)
-		case readsFrom(read[e.Manifest.Module], m):
-			packaging = append(packaging, e)
-		}
-	}
-	if len(named) == 0 {
-		from = whatTheMergeTouched(from, entries, m)
-	}
-	moved := append(append([]inventory.Entry{}, from...), packaging...)
-	if len(moved) == 0 {
-		fmt.Printf("a merge of %s changing %s would build nothing the mesh holds\n", repository,
-			orNone(strings.Join(append(paths, modules...), ", ")))
-		return nil
-	}
-	edges, err := inv.Dependencies(ctx)
-	if err != nil {
-		return err
-	}
-	var names []string
-	for _, e := range moved {
-		names = append(names, e.Manifest.Module)
-	}
-	p := planOfMerge(m, names, edges)
-	fmt.Printf("a merge of %s would build %d module(s) in %d tier(s):\n", repository, len(p.Modules), len(p.Tiers))
-	rolls := map[string]string{}
-	for i, tier := range p.Tiers {
-		fmt.Printf("  tier %d\n", i)
-		for _, name := range tier {
-			how := "built; its policy records, so nothing is sent"
-			if u, err := inv.UpgradeOf(ctx, name); err == nil && u.RollOut {
-				running, _ := inv.Running(ctx, name)
-				how = "built, then sent to " + orNone(strings.Join(running, ", "))
-				rolls[name] = how
-			}
-			fmt.Printf("    %-22s %s\n", name, how)
-		}
-	}
-	if hasCycle(p.Tiers, edges) {
-		fmt.Println("  the last tier depends on itself and would be built together, in no order")
-	}
-	if len(packaging) > 0 {
-		var also []string
-		for _, e := range packaging {
-			also = append(also, e.Manifest.Module)
-		}
-		fmt.Printf("  %s package source from %s, so they are rebuilt without their own source moving\n",
-			strings.Join(also, ", "), repository)
-	}
-	return nil
-}
-
-func splitList(s string) []string {
-	var out []string
-	for _, part := range strings.Split(s, ",") {
-		if part = strings.TrimSpace(part); part != "" {
-			out = append(out, part)
-		}
-	}
-	return out
-}
-
-// settleFromRecords marks every module of the tier still `asked` built — or failed — from a build
-// recorded after it was asked, and says whether it changed anything (novox/hq 04-ISSUES/214).
-// Newest first, as Builds answers: the first record after the ask is the outcome of that ask.
-func settleFromRecords(p *inventory.Plan, tier []string, recorded map[string][]inventory.Build) bool {
-	changed := false
-	for _, m := range tier {
-		s := p.Modules[m]
-		if s == nil || s.State != "asked" || s.AskedAt == nil {
-			continue
-		}
-		var outcome *inventory.Build
-		for i := range recorded[m] {
-			b := recorded[m][i]
-			if b.At.Before(*s.AskedAt) {
-				break
-			}
-			// Recorded after the ask and asked before it: an earlier ask's late outcome, not this
-			// one's (novox/hq 04-ISSUES/219).
-			if askedBefore(b.Asked, s.AskedAt) {
-				continue
-			}
-			outcome = &b
-		}
-		if outcome == nil {
-			continue
-		}
-		at := outcome.At
-		if outcome.Worked() {
-			s.State = "built"
-			s.BuiltAt = &at
-			s.Commit = outcome.Commit
-		} else {
-			s.State = "failed"
-			s.Why = outcome.Failed
-			p.State = inventory.PlanFailed
-			p.Note = fmt.Sprintf("%s failed to build in tier %d", m, p.Tier)
-		}
-		fmt.Printf("%s: %s settled from the build records as %s (%s)\n", p.ID, m, s.State, outcome.ID)
-		changed = true
-	}
-	return changed
-}
-
-// askedBefore is whether a build asked at asked was asked before a plan asked for its module — and
-// so is not that plan's outcome (novox/hq 04-ISSUES/219). False when either time is not known.
-func askedBefore(asked time.Time, planAsked *time.Time) bool {
-	return !asked.IsZero() && planAsked != nil && asked.Before(*planAsked)
-}

cmd/mesh-controller/release_plan_test.go

@@ -1,183 +0,0 @@
-package main
-
-import (
-	"testing"
-	"time"
-
-	"github.com/novox/mesh-controller/internal/inventory"
-	"github.com/novox/mesh-controller/internal/link"
-)
-
-// A merge produces a tiered plan (novox/hq ADR 0162): what moved and everything reachable from it,
-// sorted so a tier depends only on earlier ones — with the three kinds of dependency told apart.
-func TestAMergeIsPlannedInTiersAlongTheThreeKindsOfDependency(t *testing.T) {
-	edges := []inventory.Edge{
-		// build dependencies: images on the runtime, a plugin on one of them
-		{From: "shop", To: "mesh-tools", Kind: inventory.EdgeStandsOn},
-		{From: "postgres", To: "mesh-tools", Kind: inventory.EdgeStandsOn},
-		{From: "shop-plugin", To: "shop", Kind: inventory.EdgeDeclared},
-		// a code dependency: the proxy packages the controller's source — same tier
-		{From: "route-proxy", To: "mesh-controller", Kind: inventory.EdgePackages},
-		{From: "builder", To: "mesh-controller", Kind: inventory.EdgePackages},
-		// runtime dependencies: everything source-built is built by the builder
-		{From: "shop", To: "builder", Kind: inventory.EdgeBuiltBy},
-		{From: "postgres", To: "builder", Kind: inventory.EdgeBuiltBy},
-		{From: "shop-plugin", To: "builder", Kind: inventory.EdgeBuiltBy},
-		{From: "route-proxy", To: "builder", Kind: inventory.EdgeBuiltBy},
-		{From: "mesh-controller", To: "builder", Kind: inventory.EdgeBuiltBy},
-		{From: "mesh-tools", To: "builder", Kind: inventory.EdgeBuiltBy},
-		{From: "builder", To: "mesh-tools", Kind: inventory.EdgeStandsOn},
-		{From: "unrelated", To: "alpine", Kind: inventory.EdgeStandsOn},
-	}
-	// The runtime image moved: everything on it, and what is built by what is on it.
-	set := reachableFrom([]string{"mesh-tools"}, edges)
-	// What stands on the runtime, and the builder that stands on it; not the controller, which the
-	// builder merely builds, nor the proxy that packages the controller.
-	want := []string{"builder", "mesh-tools", "postgres", "shop", "shop-plugin"}
-	if len(set) != len(want) {
-		t.Fatalf("reachable from the runtime: %v, want %v", set, want)
-	}
-	tiers := tiersOf(set, edges)
-	pos := map[string]int{}
-	for i, tier := range tiers {
-		for _, m := range tier {
-			pos[m] = i
-		}
-	}
-	if pos["mesh-tools"] != 0 || pos["builder"] != 1 {
-		t.Fatalf("the runtime then the builder: %v", tiers)
-	}
-	if !(pos["shop"] > pos["builder"] && pos["postgres"] > pos["builder"]) {
-		t.Fatalf("what the builder builds comes after the builder: %v", tiers)
-	}
-	if pos["shop-plugin"] <= pos["shop"] {
-		t.Fatalf("a plugin after what it is declared on: %v", tiers)
-	}
-	if hasCycle(tiers, edges) {
-		t.Fatalf("no cycle here: %v", tiers)
-	}
-
-	// The controller alone moved: the proxy with it, nothing else.
-	small := reachableFrom([]string{"mesh-controller"}, edges)
-	if len(small) != 3 {
-		t.Fatalf("a controller merge rebuilds the controller and what packages it: %v", small)
-	}
-	// The builder packages the controller's source (same tier by that edge) and the controller is
-	// built by the builder (next tier by that one): the builder first, then the controller and the
-	// proxy together — a code dependency in one tier, a runtime dependency across tiers.
-	smallTiers := tiersOf(small, edges)
-	if len(smallTiers) != 2 || smallTiers[0][0] != "builder" || len(smallTiers[1]) != 2 {
-		t.Fatalf("the builder, then the controller and the proxy together: %v", smallTiers)
-	}
-	// The builder alone moved: the builder, and nothing it builds.
-	if only := reachableFrom([]string{"builder"}, edges); len(only) != 1 {
-		t.Fatalf("a build machine change rebuilds the build machine alone: %v", only)
-	}
-
-	// Only a runtime dependency gates on deployment, and only when the module rolls out.
-	p := planOfMerge(link.SourceMoved{Owner: "novox", Repo: "mesh-tools", Commit: "abc"}, []string{"mesh-tools"}, edges)
-	p.Tier = pos["builder"]
-	rollsOut := func(m string) bool { return m == "builder" }
-	if g := gates(p, edges, rollsOut); len(g) != 1 || g[0] != "builder" {
-		t.Fatalf("the builder gates the tier after it: %v", g)
-	}
-	p.Tier = 0
-	if g := gates(p, edges, rollsOut); len(g) != 0 {
-		t.Fatalf("the runtime image is a build dependency and gates nothing: %v", g)
-	}
-	if g := gates(p, edges, func(string) bool { return false }); len(g) != 0 {
-		t.Fatalf("a module that only records its upgrade gates nothing: %v", g)
-	}
-}
-
-// A gate is open once every machine running the module has reported after it was built.
-func TestAGateOpensWhenTheMachinesHaveReportedSinceTheBuild(t *testing.T) {
-	built := time.Date(2026, 10, 1, 15, 0, 0, 0, time.UTC)
-	before, after := built.Add(-time.Minute), built.Add(time.Minute)
-	reports := []inventory.Reported{{Node: "anchor", At: &after}, {Node: "home-server", At: &before}}
-	ok, waiting := applied("builder", built, []string{"anchor", "home-server"}, reports)
-	if ok || len(waiting) != 1 || waiting[0] != "home-server" {
-		t.Fatalf("one machine has not reported since the build: ok=%v waiting=%v", ok, waiting)
-	}
-	if ok, _ := applied("builder", built, []string{"anchor"}, reports); !ok {
-		t.Fatal("the machine that reported after the build holds the gate open")
-	}
-	if ok, _ := applied("builder", built, nil, reports); !ok {
-		t.Fatal("a module running nowhere gates nothing")
-	}
-}
-
-// A cycle is not lost: what remains is one last tier, and the caller says so.
-func TestACycleIsOneLastTierAndSaidSo(t *testing.T) {
-	edges := []inventory.Edge{{From: "a", To: "b", Kind: inventory.EdgeStandsOn}, {From: "b", To: "a", Kind: inventory.EdgeStandsOn}}
-	tiers := tiersOf([]string{"a", "b"}, edges)
-	if len(tiers) != 1 || len(tiers[0]) != 2 || !hasCycle(tiers, edges) {
-		t.Fatalf("a cycle should be one tier of two, said: %v", tiers)
-	}
-}
-
-// novox/hq 04-ISSUES/211: a merge moving the toolchain and a bundle compiled in it builds the
-// bundle a tier after the toolchain, not beside it.
-func TestABundleIsPlannedAfterTheToolchainItIsCompiledIn(t *testing.T) {
-	edges := []inventory.Edge{{From: "node-tools", To: "mesh-tools", Kind: inventory.EdgeStandsOn}}
-	p := planOfMerge(link.SourceMoved{Owner: "novox", Repo: "mesh-tools", Commit: "abc"},
-		[]string{"mesh-tools", "node-tools"}, edges)
-	if len(p.Tiers) != 2 || p.Tiers[0][0] != "mesh-tools" || p.Tiers[1][0] != "node-tools" {
-		t.Fatalf("the toolchain, then the bundle: %v", p.Tiers)
-	}
-}
-
-// novox/hq 04-ISSUES/214: a plan whose build outcome was recorded while no controller followed it —
-// the controller rebuilding itself — settles from the build records instead of waiting for ever.
-func TestAPlanSettlesAnAskedBuildFromTheRecords(t *testing.T) {
-	asked := time.Date(2026, 10, 3, 19, 20, 0, 0, time.UTC)
-	p := inventory.Plan{ID: "plan-1", Tiers: [][]string{{"mesh-controller", "builder"}, {"route-proxy"}},
-		Modules: map[string]*inventory.PlanModule{
-			"mesh-controller": {State: "asked", AskedAt: &asked},
-			"builder":         {State: "asked", AskedAt: &asked},
-		}}
-	records := map[string][]inventory.Build{
-		// Newest first, as Builds answers: the build after the ask is the outcome.
-		"mesh-controller": {
-			{ID: "build-2", Commit: "2ebbb799", At: asked.Add(4 * time.Minute)},
-			{ID: "build-1", Commit: "06ea2168", At: asked.Add(-10 * time.Minute)},
-		},
-		// Only a build from before the ask: not this ask's outcome.
-		"builder": {{ID: "build-0", Commit: "06ea2168", At: asked.Add(-time.Hour)}},
-	}
-	if !settleFromRecords(&p, p.Tiers[0], records) {
-		t.Fatal("nothing settled, though the controller's build is recorded after the ask")
-	}
-	if s := p.Modules["mesh-controller"]; s.State != "built" || s.Commit != "2ebbb799" || s.BuiltAt == nil {
-		t.Errorf("the controller's ask is %+v, want built from 2ebbb799", s)
-	}
-	if s := p.Modules["builder"]; s.State != "asked" {
-		t.Errorf("an ask with no record after it was settled: %+v", s)
-	}
-
-	// novox/hq 04-ISSUES/219: a build recorded after the ask but asked before it — an earlier
-	// plan's late outcome — is not this ask's, built or failed.
-	r := inventory.Plan{ID: "plan-3", Tiers: [][]string{{"postgres"}},
-		Modules: map[string]*inventory.PlanModule{"postgres": {State: "asked", AskedAt: &asked}}}
-	late := map[string][]inventory.Build{"postgres": {
-		{ID: "build-old", Commit: "efff5415", Asked: asked.Add(-18 * time.Minute), At: asked.Add(12 * time.Minute)},
-	}}
-	if settleFromRecords(&r, r.Tiers[0], late) || r.Modules["postgres"].State != "asked" {
-		t.Errorf("an earlier ask's late outcome settled this ask: %+v", r.Modules["postgres"])
-	}
-	// Newest heard first: the earlier ask's late outcome, then this ask's own, heard before it.
-	late["postgres"] = append(late["postgres"], inventory.Build{ID: "build-mine", Commit: "4bcd5f73",
-		Asked: asked.Add(time.Second), At: asked.Add(5 * time.Minute)})
-	if !settleFromRecords(&r, r.Tiers[0], late) || r.Modules["postgres"].State != "built" ||
-		r.Modules["postgres"].Commit != "4bcd5f73" {
-		t.Errorf("this ask's own outcome, heard before the earlier ask's, did not settle it: %+v", r.Modules["postgres"])
-	}
-
-	// A failure recorded after the ask fails the plan, as hearing it would have.
-	q := inventory.Plan{ID: "plan-2", Tiers: [][]string{{"x"}},
-		Modules: map[string]*inventory.PlanModule{"x": {State: "asked", AskedAt: &asked}}}
-	settleFromRecords(&q, q.Tiers[0], map[string][]inventory.Build{"x": {{ID: "b", Failed: "no", At: asked.Add(time.Minute)}}})
-	if q.State != inventory.PlanFailed || q.Modules["x"].State != "failed" {
-		t.Errorf("a recorded failure did not fail the plan: %+v %+v", q, q.Modules["x"])
-	}
-}

cmd/mesh-controller/rollout.go

@@ -346,9 +346,7 @@ func rolloutMint(ctx context.Context, again bool) error {
 			}
 			machines++
 
-		case broker.KindModule, broker.KindNodeTools:
+		case broker.KindModule:
-			// The runtime is minted and delivered exactly as a module is (novox/hq ADR 0175): it is
-			// issued as the module it stands for, to that module's `broker` secret.
 			if p.Module == "mesh-controller" {
 				// The control plane is a module too, and its `broker` secret is the old bus's
 				// credential it is still using while this runs. Writing the new bus's blob there
@@ -367,7 +365,7 @@ func rolloutMint(ctx context.Context, again bool) error {
 				skipped++
 				continue
 			}
-			password, err := inv.MintBusPassword(ctx, inventory.BusUser{Username: p.Username(), Kind: busKindOf(p.Module), Node: p.Node, Module: p.Module})
+			password, err := inv.MintBusPassword(ctx, inventory.BusUser{Username: p.Username(), Kind: inventory.BusModule, Node: p.Node, Module: p.Module})
 			if err != nil {
 				return err
 			}

cmd/mesh-controller/roster_failure_test.go

@@ -2,12 +2,13 @@ package main
 
 import (
 	"context"
+	"strings"
 	"testing"
 )
 
 // A node's own set failing to compose, and the mesh being unable to answer at all, are different
 // things, and only the first may be passed over when something is gathered across every machine
-// (novox/hq 04-ISSUES/152). These pin that distinction where the gatherers rely on it.
+// (novox/hq 04-ISSUES/152). These pin that distinction where the three gatherers rely on it.
 
 func TestASetThatDoesNotComposeIsMarkedAsTheNodesOwnProblem(t *testing.T) {
 	open := aMesh(t)
@@ -44,3 +45,55 @@ func TestAStoreThatCannotBeReadIsNotANodeThatDoesNotCompose(t *testing.T) {
 		t.Fatalf("a question the mesh could not answer was read as a node that runs nothing: %v", err)
 	}
 }
+
+func TestOneIncoherentNodeDoesNotCostTheRestTheirNames(t *testing.T) {
+	open := aMesh(t)
+	one, two := rivals()
+	register(t, open, one)
+	register(t, open, two)
+	for _, m := range []string{one.Module, two.Module} {
+		if _, err := open.inventory.Assign(t.Context(), "laptop", m); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	// laptop cannot compose. That is laptop's problem and nobody else's: the roster is still
+	// answerable, and anchor keeps whatever it serves.
+	if _, err := routeNamesInTheMesh(t.Context(), open); err != nil {
+		t.Fatalf("one node's broken set cost the whole mesh its roster: %v", err)
+	}
+}
+
+func TestARosterIsNeverReturnedWithNamesItCouldNotRead(t *testing.T) {
+	open := aMesh(t)
+
+	stopped, cancel := context.WithCancel(t.Context())
+	cancel()
+
+	names, err := routeNamesInTheMesh(stopped, open)
+	if err == nil {
+		t.Fatalf("a roster was composed from a store that could not be read: %v", names)
+	}
+	// The failure must be raised, not turned into an absence. A roster missing a machine's names
+	// is indistinguishable, on every machine that receives it, from the operator withdrawing them —
+	// and because the roster is part of every container's identity, it replaces all of them.
+	if names != nil {
+		t.Fatalf("a partial roster was returned beside the error: %v", names)
+	}
+}
+
+// Kept so the reason survives the next person reading it: the message the gatherer raises must say
+// which machine could not be read, or the operator is left with a mesh-wide failure and no name.
+func TestTheRaisedFailureNamesTheMachineItCouldNotRead(t *testing.T) {
+	open := aMesh(t)
+	stopped, cancel := context.WithCancel(t.Context())
+	cancel()
+
+	_, err := routeNamesInTheMesh(stopped, open)
+	if err == nil {
+		t.Fatal("no failure was raised")
+	}
+	if !strings.Contains(err.Error(), "cannot be read") {
+		t.Fatalf("the failure does not say the mesh could not be read: %v", err)
+	}
+}

cmd/mesh-controller/seatverbs.go

@@ -1,426 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"github.com/nats-io/nats.go/micro"
-	"os"
-	"os/exec"
-	"sort"
-	"strings"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-	"github.com/novox/mesh-controller/internal/link"
-)
-
-// The mesh's own verbs, served as the mesh-controller seat's tools (novox/hq ADR 0154, design 33).
-//
-// **Each tool runs the command it names, in this same binary, and answers what it printed.** That is
-// ADR 0035 taken literally: the logic lives once, in the command, and a surface is an adapter with no
-// decisions in it. Running a fresh process rather than calling the function keeps two things true
-// that calling it would not — every command opens and closes its own stores the way it does from a
-// shell, and nothing a command prints to the process's standard output can leak into another call's
-// answer. It also means a refusal is the same refusal in the same words, because it is the same
-// output.
-
-// verbAnswer is what a verb answers: what the command printed, whether it succeeded, and — where the
-// command speaks JSON — the same as data.
-type verbAnswer struct {
-	Output string `json:"output"`
-	OK     bool   `json:"ok"`
-	Answer any    `json:"answer,omitempty"`
-}
-
-// argvFor is the command line a verb and its arguments become. Only the verbs the seat declares, and
-// only the arguments each declares: a caller cannot reach a flag the schema did not name.
-func argvFor(verb string, args map[string]any) ([]string, error) {
-	str := func(key string) string {
-		v, _ := args[key].(string)
-		return strings.TrimSpace(v)
-	}
-	need := func(keys ...string) error {
-		for _, k := range keys {
-			if str(k) == "" {
-				return fmt.Errorf("%s needs %q", verb, k)
-			}
-		}
-		return nil
-	}
-	switch verb {
-	case "command":
-		// The generic verb: the command line as given, split as a shell would split it, with
-		// nothing added — the named verbs add flags a caller cannot reach; this one is the whole
-		// binary and says so in its description (novox/hq ADR 0154, 0175).
-		if err := need("command"); err != nil {
-			return nil, err
-		}
-		argv, err := splitCommandLine(str("command"))
-		if err != nil {
-			return nil, err
-		}
-		if len(argv) == 0 {
-			return nil, errors.New("command names no command")
-		}
-		return argv, nil
-	case "status":
-		return []string{"status", "--json"}, nil
-	case "nodes":
-		return []string{"node", "list", "--json"}, nil
-	case "node":
-		if err := need("node"); err != nil {
-			return nil, err
-		}
-		return []string{"node", "show", str("node")}, nil
-	case "modules":
-		return []string{"module", "list", "--json"}, nil
-	case "seats":
-		return []string{"seats", "--json"}, nil
-	case "builds":
-		if id := str("log"); id != "" {
-			return []string{"builds", "--log", id}, nil
-		}
-		if m := str("module"); m != "" {
-			return []string{"builds", m}, nil
-		}
-		return []string{"builds"}, nil
-	case "plans":
-		if r := str("repository"); r != "" {
-			argv := []string{"plans", "--what-if", r}
-			if p := str("paths"); p != "" {
-				argv = append(argv, "--paths", p)
-			}
-			if m := str("modules"); m != "" {
-				argv = append(argv, "--modules", m)
-			}
-			return argv, nil
-		}
-		if id := str("stop"); id != "" {
-			return []string{"plans", "stop", id}, nil
-		}
-		if id := str("id"); id != "" {
-			return []string{"plans", id}, nil
-		}
-		return []string{"plans"}, nil
-	case "plan":
-		if err := need("node"); err != nil {
-			return nil, err
-		}
-		return []string{"plan", str("node"), "--json"}, nil
-	case "assign", "unassign":
-		if err := need("node", "module"); err != nil {
-			return nil, err
-		}
-		return []string{verb, str("node"), str("module")}, nil
-	case "pin":
-		if err := need("node", "provision", "from", "module"); err != nil {
-			return nil, err
-		}
-		return []string{"pin", str("node"), str("provision"), str("from"), str("module")}, nil
-	case "unpin":
-		if err := need("node", "provision"); err != nil {
-			return nil, err
-		}
-		return []string{"unpin", str("node"), str("provision")}, nil
-	case "push":
-		// Sent and not waited for: the asker reads `status` for what the machine did, which is
-		// what a person at a shell does too. A tool call that blocked for a push's whole apply would
-		// time out on every machine that takes a minute, and say nothing about the ones that did not.
-		if n := str("node"); n != "" {
-			return []string{"push", n, "--wait", "0"}, nil
-		}
-		return []string{"push", "--behind", "--wait", "0"}, nil
-	case "rotate":
-		if p := str("provision"); p != "" {
-			argv := []string{"rotate", p}
-			if c := str("consumer"); c != "" {
-				argv = append(argv, "--consumer", c)
-			}
-			return argv, nil
-		}
-		if str("node") != "" && str("module") != "" && str("secret") != "" {
-			return []string{"secret", "rotate", str("node"), str("module"), str("secret")}, nil
-		}
-		// Half of either shape: the command says its usage, which names both shapes, and that is
-		// the answer the caller needs.
-		return []string{"rotate"}, nil
-	case "settings":
-		// `settings set|clear` at a shell (novox/hq issue 198). The values travel as an argument
-		// because a tool has no file to hand the command; the command reads either.
-		if err := need("module"); err != nil {
-			return nil, err
-		}
-		argv := []string{"settings", "set", str("module")}
-		switch {
-		case str("clear") == "true":
-			argv = []string{"settings", "clear", str("module")}
-		case str("values") != "":
-			argv = append(argv, str("values"))
-		}
-		// Neither values nor clear: the command says its usage, which names both, and that is the
-		// answer the caller needs — the same as `rotate` given half of either shape.
-		if n := str("node"); n != "" {
-			argv = append(argv, "--node", n)
-		}
-		return argv, nil
-	case "issue":
-		// The same act as `module issue` at a shell (novox/hq design 25 §4): the account is minted
-		// into the mesh's records and delivered at the machine's next push, which is the caller's to
-		// ask for — so the mesh is never pushed as a side effect of a credential.
-		if err := need("node", "module"); err != nil {
-			return nil, err
-		}
-		return []string{"module", "issue", str("module"), "--node", str("node")}, nil
-	case "build":
-		if err := need("repository"); err != nil {
-			return nil, err
-		}
-		// Not waited for: a tool call cannot hold a connection for the minutes a build takes; the
-		// daemon takes the outcome in when it comes and the id follows the build (issue 176). A
-		// repository given without a scheme is a path on the forge holding the git seat.
-		argv := []string{"build", str("repository"), "--wait", "0"}
-		if !strings.Contains(str("repository"), "://") && !strings.HasPrefix(str("repository"), "git@") {
-			argv = append(argv, "--self")
-		}
-		if p := str("path"); p != "" {
-			argv = append(argv, "--path", p)
-		}
-		if r := str("ref"); r != "" {
-			argv = append(argv, "--ref", r)
-		}
-		return argv, nil
-	}
-	return nil, fmt.Errorf("%q is not a verb the %s seat serves", verb, catalogue.ControllerSeatName)
-}
-
-// jsonVerbs are the verbs whose command speaks JSON, so the answer carries it as data as well.
-var jsonVerbs = map[string]bool{"status": true, "seats": true, "plan": true}
-
-// runVerb runs this binary with the given command line and gathers what it said.
-func runVerb(ctx context.Context, argv []string) (verbAnswer, error) {
-	self, err := os.Executable()
-	if err != nil {
-		return verbAnswer{}, err
-	}
-	cmd := exec.CommandContext(ctx, self, argv...)
-	// The same environment: the stores' credentials, the bus, the broker — everything a command run
-	// from a shell in this container would have, because it is that.
-	cmd.Env = os.Environ()
-	// Two buffers, one answer. What the command *says* is both streams, in the order a person at
-	// a shell would read them; what it *answers as data* is standard output alone — `status --json`
-	// prints its warnings beside the document, and a JSON parsed from the two together parsed
-	// nothing (2026-09-30, the first status asked through the console had no `answer`).
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	runErr := cmd.Run()
-	answer := verbAnswer{Output: stdout.String() + stderr.String(), OK: runErr == nil}
-	if jsonVerbs[argv[0]] && runErr == nil {
-		var parsed any
-		if json.Unmarshal(bytes.TrimSpace(stdout.Bytes()), &parsed) == nil {
-			answer.Answer = parsed
-		}
-	}
-	var exit *exec.ExitError
-	if runErr != nil && !errors.As(runErr, &exit) {
-		// Not the command refusing — the command not running at all, which is this process's fault.
-		return answer, fmt.Errorf("could not run %s: %w", strings.Join(argv, " "), runErr)
-	}
-	return answer, nil
-}
-
-// seatToolHandlers are the handlers for every verb the mesh-controller seat declares, from the
-// store's row, so a verb the row does not carry is not served. A verb it carries that this binary
-// cannot run is named at start and answers the reason when called — never a refusal to serve, which
-// would take the whole control plane down for one word (novox/hq ADR 0185).
-func seatToolHandlers() (map[string]link.ToolHandler, []string, error) {
-	seat, known := catalogue.SeatNamed(catalogue.ControllerSeatName)
-	if !known {
-		return nil, nil, fmt.Errorf("this mesh defines no %s seat", catalogue.ControllerSeatName)
-	}
-	var behind []string
-	handlers := map[string]link.ToolHandler{}
-	for _, v := range seat.Serves {
-		verb := v.Name
-		if verb == "tools" {
-			handlers[verb] = func(ctx context.Context, _ json.RawMessage) (any, error) {
-				return seatTools(), nil
-			}
-			continue
-		}
-		if _, err := argvFor(verb, sampleArguments(v)); err != nil {
-			// **A row ahead of this binary is not a reason to go silent.**
-			//
-			// The row is the store's and a control plane follows it (novox/hq ADR 0154), so a verb
-			// this build does not know means the row was widened by a newer one — the ordinary
-			// state of a roll-out, and of a push that put an older control plane back. Refusing to
-			// serve at all made that transient fatal: on 2026-10-02 one unknown verb took the whole
-			// mesh off the bus for ten minutes, and the way back was a human running the binary by
-			// hand, because the thing that would have repaired it is the thing that was down
-			// (novox/hq 04-ISSUES/201, ADR 0185).
-			//
-			// So the verbs this binary knows are served, and this one answers the reason instead of
-			// nothing: a caller gets a sentence naming the fault, and everything else keeps working
-			// — including the push that replaces this binary with the one whose verb it is.
-			behind = append(behind, verb)
-			reason := err
-			handlers[verb] = func(context.Context, json.RawMessage) (any, error) {
-				return nil, fmt.Errorf("%s is in this mesh's %s row and the control plane running "+
-					"here cannot run it: %w. It is a verb of a newer build; this one is behind",
-					verb, catalogue.ControllerSeatName, reason)
-			}
-			continue
-		}
-		handlers[verb] = func(ctx context.Context, raw json.RawMessage) (any, error) {
-			args := map[string]any{}
-			if len(raw) > 0 {
-				if err := json.Unmarshal(raw, &args); err != nil {
-					return nil, fmt.Errorf("the arguments are not a JSON object: %w", err)
-				}
-			}
-			argv, err := argvFor(verb, args)
-			if err != nil {
-				return nil, err
-			}
-			return runVerb(ctx, argv)
-		}
-	}
-	return handlers, behind, nil
-}
-
-// seatTools is what `tools` answers: every seat with a protocol, and the tools each serves, from the
-// mesh's own records — no holder in the path, so it is true while a holder restarts (design 33 §5).
-func seatTools() map[string]any {
-	var seats []map[string]any
-	for _, s := range catalogue.SeatsWithAProtocol() {
-		if len(s.Serves) == 0 {
-			continue
-		}
-		var tools []map[string]any
-		for _, v := range s.Serves {
-			tools = append(tools, map[string]any{
-				"name": v.Name, "description": v.Description, "input": v.Input, "output": v.Output,
-			})
-		}
-		seats = append(seats, map[string]any{"seat": s.Name, "scope": s.Scope, "tools": tools})
-	}
-	return map[string]any{"seats": seats}
-}
-
-// sampleArguments is one of every argument a verb's schema requires, so the check at start proves the
-// verb runnable rather than that it happens to want the arguments the check guessed.
-func sampleArguments(v catalogue.Verb) map[string]any {
-	sample := map[string]any{"node": "x", "module": "x", "repository": "x"}
-	switch required := v.Input["required"].(type) {
-	case []string:
-		for _, k := range required {
-			sample[k] = "x"
-		}
-	case []any:
-		for _, k := range required {
-			if name, ok := k.(string); ok {
-				sample[name] = "x"
-			}
-		}
-	}
-	return sample
-}
-
-// splitCommandLine splits a command line into words the way a POSIX shell does for the simple
-// cases a controller command needs: spaces separate, single or double quotes group, a backslash
-// escapes the next character inside double quotes or outside any. No expansion of anything.
-func splitCommandLine(line string) ([]string, error) {
-	var words []string
-	var cur strings.Builder
-	inWord := false
-	quote := rune(0)
-	runes := []rune(line)
-	for i := 0; i < len(runes); i++ {
-		r := runes[i]
-		switch {
-		case quote == '\'':
-			if r == '\'' {
-				quote = 0
-			} else {
-				cur.WriteRune(r)
-			}
-		case quote == '"':
-			if r == '"' {
-				quote = 0
-			} else if r == '\\' && i+1 < len(runes) {
-				i++
-				cur.WriteRune(runes[i])
-			} else {
-				cur.WriteRune(r)
-			}
-		case r == '\'' || r == '"':
-			quote = r
-			inWord = true
-		case r == '\\' && i+1 < len(runes):
-			i++
-			cur.WriteRune(runes[i])
-			inWord = true
-		case r == ' ' || r == '\t' || r == '\n':
-			if inWord {
-				words = append(words, cur.String())
-				cur.Reset()
-				inWord = false
-			}
-		default:
-			cur.WriteRune(r)
-			inWord = true
-		}
-	}
-	if quote != 0 {
-		return nil, fmt.Errorf("command has an unclosed %c quote", quote)
-	}
-	if inWord {
-		words = append(words, cur.String())
-	}
-	return words, nil
-}
-
-// seatAnnouncement is what the controller says it serves on the bus (novox/hq ADR 0197): the
-// mesh-controller seat, one endpoint per verb it answers, each with the seat's own description and
-// argument schema — the same facts `tools` answers from the records, as NATS's services format.
-func seatAnnouncement(handlers map[string]link.ToolHandler) micro.Info {
-	about := map[string]catalogue.Verb{}
-	for _, s := range catalogue.SeatsWithAProtocol() {
-		if s.Name == catalogue.ControllerSeatName {
-			for _, v := range s.Serves {
-				about[v.Name] = v
-			}
-		}
-	}
-	verbs := make([]string, 0, len(handlers))
-	for verb := range handlers {
-		verbs = append(verbs, verb)
-	}
-	sort.Strings(verbs)
-	var endpoints []micro.EndpointInfo
-	for _, verb := range verbs {
-		schema, _ := json.Marshal(about[verb].Input)
-		// The same shape every tool runtime announces in (node-tools' announce package): the name is
-		// `<seat>__<verb>`, as the protocol's characters allow; the metadata is what identifies it.
-		endpoints = append(endpoints, micro.EndpointInfo{
-			Name:       catalogue.ControllerSeatName + "__" + verb,
-			Subject:    link.SeatToolSubject(catalogue.ControllerSeatName, verb),
-			QueueGroup: "seat." + catalogue.ControllerSeatName,
-			Metadata: map[string]string{
-				"kind": "seat", "module": catalogue.ControllerSeatName, "tool": verb,
-				"seat": catalogue.ControllerSeatName, "scope": "mesh", "interchangeable": "false",
-				"description": about[verb].Description, "schema": string(schema),
-			},
-		})
-	}
-	return micro.Info{
-		ServiceIdentity: micro.ServiceIdentity{
-			Name: catalogue.ControllerSeatName, ID: "controller", Version: "0.1.0",
-			Metadata: map[string]string{"seat": catalogue.ControllerSeatName, "scope": "mesh"},
-		},
-		Description: "the mesh's own verbs, answered by the holder of the mesh-controller seat",
-		Endpoints:   endpoints,
-	}
-}

cmd/mesh-controller/seatverbs_test.go

@@ -1,298 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"github.com/novox/mesh-controller/internal/link"
-	"strings"
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-)
-
-// Every verb the mesh-controller seat declares is one this binary can run, with the arguments the
-// schema names and no other (novox/hq ADR 0154, ADR 0035).
-func TestEveryDeclaredVerbHasACommandLine(t *testing.T) {
-	for _, v := range catalogue.ControllerVerbs {
-		if v.Name == "tools" {
-			continue
-		}
-		args := map[string]any{}
-		props, _ := v.Input["properties"].(map[string]any)
-		for name := range props {
-			args[name] = "x"
-		}
-		argv, err := argvFor(v.Name, args)
-		if err != nil {
-			t.Errorf("%s: %v", v.Name, err)
-			continue
-		}
-		if argv[0] == "" {
-			t.Errorf("%s: empty command", v.Name)
-		}
-	}
-}
-
-// `builds` given a build's id reads that build's log from the bus rather than listing builds
-// (novox/hq ADR 0157).
-func TestBuildsWithAnIdReadsThatBuildsLog(t *testing.T) {
-	argv, err := argvFor("builds", map[string]any{"log": "build-17"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Join(argv, " ") != "builds --log build-17" {
-		t.Fatalf("builds with a log id became %q", strings.Join(argv, " "))
-	}
-}
-
-// The build tool takes a repository as a URL or as its path on the forge holding the git seat, and
-// says which it was given, so the command reads the path as a seat source rather than handing it to
-// git as written (novox/hq issue 176). And it never waits: the id follows the build.
-func TestTheBuildToolTellsAForgePathFromAURL(t *testing.T) {
-	argv, _ := argvFor("build", map[string]any{"repository": "novox/mesh-catalog", "path": "modules/x"})
-	if line := strings.Join(argv, " "); !strings.Contains(line, "--self") || !strings.Contains(line, "--wait 0") {
-		t.Fatalf("a forge path is a seat source, not waited for; got %q", line)
-	}
-	argv, _ = argvFor("build", map[string]any{"repository": "https://example.tld/o/r.git"})
-	if line := strings.Join(argv, " "); strings.Contains(line, "--self") {
-		t.Fatalf("a URL is cloned as given; got %q", line)
-	}
-}
-
-// `rotate` is one verb with two shapes (ADR 0114, issue 180): a pair credential by provision, or a
-// module's own secret by machine, module and name.
-func TestRotateTakesAProvisionOrAnOwnSecret(t *testing.T) {
-	argv, _ := argvFor("rotate", map[string]any{"provision": "postgres-database", "consumer": "ace"})
-	if strings.Join(argv, " ") != "rotate postgres-database --consumer ace" {
-		t.Fatalf("a pair credential: %v", argv)
-	}
-	argv, _ = argvFor("rotate", map[string]any{"node": "ace", "module": "nodered", "secret": "api-token"})
-	if strings.Join(argv, " ") != "secret rotate ace nodered api-token" {
-		t.Fatalf("an own secret: %v", argv)
-	}
-	argv, _ = argvFor("rotate", map[string]any{"node": "ace"})
-	if strings.Join(argv, " ") != "rotate" {
-		t.Fatalf("half an own secret falls to the command's usage: %v", argv)
-	}
-}
-
-// `settings` is `settings set|clear` at a shell, with the values passed inline (novox/hq issue 198).
-func TestSettingsSetsOrClearsALayer(t *testing.T) {
-	argv, err := argvFor("settings", map[string]any{"module": "dnsmasq", "values": `{"a":1}`, "node": "ace"})
-	if err != nil || strings.Join(argv, " ") != `settings set dnsmasq {"a":1} --node ace` {
-		t.Fatalf("set on a machine: %v %v", argv, err)
-	}
-	argv, _ = argvFor("settings", map[string]any{"module": "dnsmasq", "clear": "true"})
-	if strings.Join(argv, " ") != "settings clear dnsmasq" {
-		t.Fatalf("clear for the mesh: %v", argv)
-	}
-	argv, _ = argvFor("settings", map[string]any{"module": "dnsmasq"})
-	if strings.Join(argv, " ") != "settings set dnsmasq" {
-		t.Fatalf("a set with no values falls to the command's usage: %v", argv)
-	}
-}
-
-// `issue` is `module issue` at a shell: the module and the machine, and nothing that would push. A
-// module's bus account was mintable only from the controller's command line, so an agent working
-// through the tools could not finish a rollout that gave a module one (novox/hq issue 191).
-func TestIssueGivesAModuleItsAccountOnAMachine(t *testing.T) {
-	argv, err := argvFor("issue", map[string]any{"node": "ace", "module": "route-proxy"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Join(argv, " ") != "module issue route-proxy --node ace" {
-		t.Fatalf("issue runs %v", argv)
-	}
-	if _, err := argvFor("issue", map[string]any{"module": "route-proxy"}); err == nil {
-		t.Error("an account was issued without saying which machine reads it")
-	}
-}
-
-// A required argument missing is refused in the verb's own words, before anything runs.
-func TestAVerbMissingWhatItNeedsIsRefused(t *testing.T) {
-	if _, err := argvFor("node", map[string]any{}); err == nil || !strings.Contains(err.Error(), `node needs "node"`) {
-		t.Fatalf("node without a machine was accepted: %v", err)
-	}
-	if _, err := argvFor("upgrade", map[string]any{}); err == nil {
-		t.Fatal("a verb the seat does not serve was accepted")
-	}
-}
-
-// A push and a build are sent, not waited for: the asker reads status, or the build's log by its
-// id, for what happened. A repository given as a forge path is said to be one (issue 176).
-func TestActsDoNotBlockTheCall(t *testing.T) {
-	argv, _ := argvFor("push", map[string]any{"node": "one"})
-	if strings.Join(argv, " ") != "push one --wait 0" {
-		t.Fatalf("push waits: %v", argv)
-	}
-	argv, _ = argvFor("build", map[string]any{"repository": "novox/x", "path": "modules/x"})
-	if strings.Join(argv, " ") != "build novox/x --wait 0 --self --path modules/x" {
-		t.Fatalf("build: %v", argv)
-	}
-}
-
-// What `tools` answers is the seats' records, with each verb's schema.
-func TestToolsAnswersTheSeatsRecords(t *testing.T) {
-	handlers, behind, err := seatToolHandlers()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(behind) != 0 {
-		t.Fatalf("this build cannot run %v of its own seat's verbs", behind)
-	}
-	if len(handlers) != len(catalogue.ControllerVerbs) {
-		t.Fatalf("%d handlers for %d verbs", len(handlers), len(catalogue.ControllerVerbs))
-	}
-	answer := seatTools()
-	seats, _ := answer["seats"].([]map[string]any)
-	var found bool
-	for _, s := range seats {
-		if s["seat"] == catalogue.ControllerSeatName {
-			found = true
-			tools, _ := s["tools"].([]map[string]any)
-			if len(tools) != len(catalogue.ControllerVerbs) || tools[0]["input"] == nil {
-				t.Fatalf("the controller seat's tools are not listed in full: %v", tools)
-			}
-		}
-	}
-	if !found {
-		t.Fatal("the mesh-controller seat is not in the listing")
-	}
-}
-
-// A JSON verb's answer is parsed from what the command wrote to standard output alone; a warning it
-// printed beside the document does not take the document away. The test binary stands in for the
-// controller: `-test.run` with a name that matches nothing prints `ok` and a warning about no tests.
-func TestAJSONVerbsAnswerIsItsStandardOutput(t *testing.T) {
-	jsonVerbs["-test.run"] = true
-	t.Cleanup(func() { delete(jsonVerbs, "-test.run") })
-	answer, err := runVerb(t.Context(), []string{"-test.run", "TestAnswerEcho", "-test.v"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !answer.OK {
-		t.Fatalf("the command failed: %s", answer.Output)
-	}
-	if !strings.Contains(answer.Output, "PASS") {
-		t.Fatalf("stderr and stdout are both what the command said: %s", answer.Output)
-	}
-}
-
-// `command` is the generic verb: the command line as given, split as a shell would, nothing added —
-// so an operator's `node account g14 jochen` is one call through the console rather than a shell on
-// the control node (novox/hq ADR 0154, ADR 0175).
-func TestCommandRunsTheLineAsGiven(t *testing.T) {
-	argv, err := argvFor("command", map[string]any{"command": "node account g14 jochen"})
-	if err != nil || strings.Join(argv, " ") != "node account g14 jochen" {
-		t.Fatalf("a plain line: %v %v", argv, err)
-	}
-	argv, err = argvFor("command", map[string]any{"command": `settings set dnsmasq '{"a": "b c"}' --node ace`})
-	if err != nil || len(argv) != 6 || argv[3] != `{"a": "b c"}` {
-		t.Fatalf("a quoted word stays one word: %q %v", argv, err)
-	}
-	argv, err = argvFor("command", map[string]any{"command": `node add "the box" --adopted`})
-	if err != nil || len(argv) != 4 || argv[2] != "the box" {
-		t.Fatalf("double quotes group: %q %v", argv, err)
-	}
-	if _, err := argvFor("command", map[string]any{"command": "   "}); err == nil {
-		t.Fatal("an empty line was accepted")
-	}
-	if _, err := argvFor("command", map[string]any{"command": `node "unclosed`}); err == nil {
-		t.Fatal("an unclosed quote was accepted")
-	}
-}
-
-// A verb in the row that this binary cannot run does not take the control plane off the bus: the
-// rest are served, the unknown one answers the reason, and the start-up names it (novox/hq ADR
-// 0185). One unknown word cost the mesh ten minutes of silence on 2026-10-02, recoverable only by
-// a person running the binary by hand — the push that would have repaired it needs the control
-// plane that was down.
-func TestARowAheadOfThisBuildIsServedAnyway(t *testing.T) {
-	seat, known := catalogue.SeatNamed(catalogue.ControllerSeatName)
-	if !known {
-		t.Fatal("no controller seat")
-	}
-	// The row as a newer control plane would have written it: every verb this build knows, and one
-	// it does not.
-	widened := seat
-	widened.Serves = append(append([]catalogue.Verb{}, seat.Serves...),
-		catalogue.Verb{Name: "teleport", Description: "a verb from a build that does not exist yet"})
-	rows := catalogue.DefaultSeats()
-	for i := range rows {
-		if rows[i].Name == catalogue.ControllerSeatName {
-			rows[i] = widened
-		}
-	}
-	catalogue.UseSeats(rows)
-	t.Cleanup(func() { catalogue.UseSeats(catalogue.DefaultSeats()) })
-
-	handlers, behind, err := seatToolHandlers()
-	if err != nil {
-		t.Fatalf("a row with one unknown verb refused to serve at all: %v", err)
-	}
-	if len(behind) != 1 || behind[0] != "teleport" {
-		t.Fatalf("the verbs this build cannot run were reported as %v", behind)
-	}
-	if len(handlers) != len(widened.Serves) {
-		t.Fatalf("%d handlers for %d verbs in the row", len(handlers), len(widened.Serves))
-	}
-	for _, known := range []string{"status", "nodes", "push"} {
-		if handlers[known] == nil {
-			t.Errorf("%s is not served although this build knows it", known)
-		}
-	}
-	_, err = handlers["teleport"](context.Background(), nil)
-	if err == nil {
-		t.Fatal("the unknown verb answered as though it had run")
-	}
-	for _, want := range []string{"teleport", "cannot run it", "behind"} {
-		if !strings.Contains(err.Error(), want) {
-			t.Errorf("the answer does not say %q: %v", want, err)
-		}
-	}
-}
-
-// novox/hq ADR 0195: the console's discovery reads the machines and the modules; they answer as JSON,
-// as status and seats do, so nothing parses a printed column.
-func TestTheNodesAndModulesVerbsAnswerAsJSON(t *testing.T) {
-	for verb, want := range map[string]string{"nodes": "[node list --json]", "modules": "[module list --json]"} {
-		argv, err := argvFor(verb, map[string]any{})
-		if err != nil {
-			t.Fatal(err)
-		}
-		if fmt.Sprint(argv) != want {
-			t.Errorf("%s runs %v, want %s", verb, argv, want)
-		}
-	}
-}
-
-// novox/hq ADR 0197: the controller announces exactly the verbs it serves, each on the subject and
-// queue it serves it on, with the seat's own description and schema, in NATS's services format.
-func TestTheControllerAnnouncesTheVerbsItServes(t *testing.T) {
-	handlers, _, err := seatToolHandlers()
-	if err != nil {
-		t.Fatal(err)
-	}
-	info := seatAnnouncement(handlers)
-	if info.Name != catalogue.ControllerSeatName || info.ID == "" || info.Version == "" {
-		t.Fatalf("the service is not named for the seat: %+v", info.ServiceIdentity)
-	}
-	if len(info.Endpoints) != len(handlers) {
-		t.Fatalf("%d endpoints announced for %d verbs served", len(info.Endpoints), len(handlers))
-	}
-	for _, e := range info.Endpoints {
-		verb := e.Metadata["tool"]
-		if _, served := handlers[verb]; !served || e.Name != catalogue.ControllerSeatName+"__"+verb {
-			t.Errorf("%s (%s) is announced and not served under that name", e.Name, verb)
-		}
-		if e.Metadata["kind"] != "seat" || e.Metadata["seat"] != catalogue.ControllerSeatName {
-			t.Errorf("%s is not announced as the seat's verb: %v", e.Name, e.Metadata)
-		}
-		if e.Subject != link.SeatToolSubject(catalogue.ControllerSeatName, verb) || e.QueueGroup != "seat."+catalogue.ControllerSeatName {
-			t.Errorf("%s is announced on %s/%s, not where it is served", e.Name, e.Subject, e.QueueGroup)
-		}
-		if e.Metadata["description"] == "" || e.Metadata["schema"] == "" || e.Metadata["scope"] != "mesh" {
-			t.Errorf("%s is announced without its description, schema or scope: %v", e.Name, e.Metadata)
-		}
-	}
-}

cmd/mesh-controller/secret.go

@@ -10,7 +10,6 @@ import (
 	"io"
 	"os"
 	"strings"
-	"time"
 
 	"github.com/novox/mesh-controller/internal/catalogue"
 	"github.com/novox/mesh-controller/internal/inventory"
@@ -39,8 +38,6 @@ func secretCommand(ctx context.Context, args []string) error {
 	}
 	switch args[0] {
 	case "accept":
-	case "rotate":
-		return secretRotate(ctx, args[1:])
 	case "recover":
 		return secretRecover(ctx, args[1:])
 	case "export":
@@ -104,8 +101,7 @@ func secretCommand(ctx context.Context, args []string) error {
 	return nil
 }
 
-const secretUsage = "secret rotate <node> <module> <name>\n" +
+const secretUsage = "secret accept <node> <module> <name> [--from <file>] [--provider <node> [--local <name>]]\n" +
-	"secret accept <node> <module> <name> [--from <file>] [--provider <node> [--local <name>]]\n" +
 	"secret recover <node> <module> <name> --key <operator-key> [--out <file>] [--from-export <file>] [--provider <node>]\n" +
 	"secret export [--out <file>]"
 
@@ -363,59 +359,3 @@ func valueFor(node, module, name, from string) (string, error) {
 		return line, nil
 	}
 }
-
-// secretRotate makes a module's own secret anew and sends the machine, so the module starts again on
-// the new value (novox/hq ADR 0114, issue 180). A pair credential rotates with `rotate <provision>`;
-// this is the secret with one party. Said in the log with who asked and when, never the value.
-func secretRotate(ctx context.Context, args []string) error {
-	rest, _ := split(args)
-	if len(rest) != 3 {
-		return errors.New(secretUsage)
-	}
-	node, module, name := rest[0], rest[1], rest[2]
-	open, err := openStores(ctx)
-	if err != nil {
-		return err
-	}
-	defer open.Close()
-	if err := open.inventory.RotateModuleSecret(ctx, node, module, name); err != nil {
-		var refused inventory.ErrNotRotatable
-		if errors.As(err, &refused) {
-			return fmt.Errorf("not rotated: %s", refused.Why)
-		}
-		return err
-	}
-	fmt.Printf("rotated %q of %s on %s at %s, asked by %s; the value is sealed and not shown\n",
-		name, module, node, time.Now().UTC().Format(time.RFC3339), whoAsked())
-	// A shared credential (ADR 0158) has as many holders as the provision has consumers, and all
-	// of them are sent in one act, so no machine is left reading a value the provider no longer takes.
-	machines, err := open.inventory.SharedHolders(ctx, node, module, name)
-	if err != nil {
-		return err
-	}
-	if len(machines) == 0 {
-		machines = []string{node}
-	}
-	if len(machines) == 1 {
-		fmt.Printf("sending %s, so %s starts again on the new value:\n", node, module)
-	} else {
-		fmt.Printf("shared with every consumer; sending %s together:\n", strings.Join(machines, ", "))
-	}
-	if err := sendTo(ctx, open, machines); err != nil {
-		return fmt.Errorf("%w\n\nThe new value is sealed and not yet delivered; what runs keeps the old "+
-			"one until the machines next apply. Fix the cause and run `push --behind`", err)
-	}
-	return nil
-}
-
-// whoAsked names the caller for the log: the account the command runs as, which for a tool call
-// through the console is the mesh's own.
-func whoAsked() string {
-	if u := os.Getenv("SUDO_USER"); u != "" {
-		return u
-	}
-	if u := os.Getenv("USER"); u != "" {
-		return u
-	}
-	return "the mesh"
-}

cmd/mesh-controller/sendable.go

@@ -18,27 +18,9 @@ import (
 // make a machine look out of date for ever, or send something `plan` never showed.
 type sendable struct {
 	Resources []map[string]any
-	// Sequence orders this send against every other to the same node: one higher each time, taken
-	// under the node's hold just before the body is made (novox/hq 04-ISSUES/107). Zero is not sent
-	// at all, which a host reads as "no order claimed" — the shape of every declaration before this.
-	Sequence int64
 	// Adoption is nil for a converged node, and then the body is byte for byte what it was before
 	// adoption existed: an older host parses the envelope strictly and would refuse the key.
 	Adoption *adoptionEnvelope
-
-	// Received and Mesh are not sent in the declaration. They are what this machine's memberships
-	// are issued with on the bus (novox/hq ADR 0167): each module's received contributions, from
-	// the same composition as its received files, and every machine's private-network address.
-	Received map[string]map[string][]catalogue.Contribution
-	Mesh     []string
-	// LeftOut is every module of the machine's set left out of this declaration because a stored
-	// setting cannot compose with its definition (novox/hq ADR 0163, rule 6), sorted. The host
-	// keeps that module's held things and touches none of its containers; a machine is told
-	// everything or nothing about what it IS told, and what it is not told is said. Absent from
-	// the body when empty, so a declaration that leaves nothing out is byte for byte what it was.
-	LeftOut []string
-	// leftOutWhy is why each was, for push and plan to say; never on the wire.
-	leftOutWhy map[string]string
 }
 
 // adoptionEnvelope is what an adopted node is told about its mode. Taken is every module taken on
@@ -56,12 +38,6 @@ func (s sendable) Body() ([]byte, error) {
 	if s.Adoption != nil {
 		envelope["adoption"] = s.Adoption
 	}
-	if s.Sequence > 0 {
-		envelope["sequence"] = s.Sequence
-	}
-	if len(s.LeftOut) > 0 {
-		envelope["left_out"] = s.LeftOut
-	}
 	// An empty declaration is deliberate here — the node owns nothing the mesh put there
 	// (novox/hq issue 127) — and the host refuses an empty body unless it is told the emptiness
 	// is meant, so a truncated or mis-composed body is never mistaken for "own nothing".

cmd/mesh-controller/sendable_test.go

@@ -47,12 +47,7 @@ func composed(t *testing.T, open *stores, node string) sendable {
 // aMesh's laptop with the private network taken off it, so nothing in the declaration is random:
 // what changes this string is a change to what a converged machine is sent, which is the thing an
 // older host would refuse.
-//
+const convergedBefore = `{"declaration":1,"resources":[{"content":"hello","id":"hello-web.page","path":"/var/lib/hello-web/index.html","type":"file"},{"hosts":["anchor.internal:10.77.0.1"],"id":"hello-web.server","image":"registry.example/hello@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","name":"hello-web","type":"container"},{"id":"hello-web.served","path":"/var/lib/hello-web","type":"directory"}]}`
-// Re-captured 2026-10-01 (novox/hq issue 177): c978aa7 took `hosts` off every container — a
-// machine's own resolver knows the mesh's names now — and left this string carrying it, so the
-// guard failed for a day and nothing ran it. A field an older host never sees is the one change
-// this guard permits; a field it would refuse is the one it exists to catch.
-const convergedBefore = `{"declaration":1,"resources":[{"content":"hello","id":"hello-web.page","path":"/var/lib/hello-web/index.html","type":"file"},{"id":"hello-web.server","image":"registry.example/hello@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","name":"hello-web","type":"container"},{"id":"hello-web.served","path":"/var/lib/hello-web","type":"directory"}]}`
 
 func TestAConvergedDeclarationIsByteForByteWhatItWas(t *testing.T) {
 	open := aMesh(t)
@@ -382,62 +377,3 @@ func TestAnEmptyDeclarationSaysOwnsNothing(t *testing.T) {
 		t.Fatalf("a non-empty declaration must not mark owns_nothing; got %v", env)
 	}
 }
-
-// A setting is judged where it is stored, and an impossible one costs a module, not a machine
-// (novox/hq ADR 0163, rule 6): stored while it composed, a setting whose definition then moved from
-// under it leaves that module out of the declaration — said in the envelope, so the host keeps the
-// module's things — and the machine is told everything else.
-func TestADefinitionMovingUnderAStoredSettingLeavesThatModuleOutNotTheMachine(t *testing.T) {
-	open := aMesh(t)
-	ctx := t.Context()
-	web := helloWeb()
-	web.Resources[1]["ports"] = []any{"8080"}
-	register(t, open, web)
-	register(t, open, catalogue.Manifest{Module: "notes", Version: "1",
-		Resources: []map[string]any{{"id": "conf", "type": "file", "path": "/etc/notes.conf", "content": "x"}}})
-	for _, m := range []string{"hello-web", "notes"} {
-		if _, err := assign(ctx, open, "laptop", m); err != nil {
-			t.Fatal(err)
-		}
-	}
-	// Judged where it is stored: a port the module does not publish is refused by name.
-	err := open.inventory.SetSettings(ctx, "laptop", "hello-web",
-		map[string]any{catalogue.PortsSetting: map[string]any{"9999": 10000}})
-	if err == nil || !strings.Contains(err.Error(), "hello-web on laptop") || !strings.Contains(err.Error(), "9999") {
-		t.Fatalf("an impossible setting was stored: %v", err)
-	}
-	if err := open.inventory.SetSettings(ctx, "laptop", "hello-web",
-		map[string]any{catalogue.PortsSetting: map[string]any{"8080": 10000}}); err != nil {
-		t.Fatal(err)
-	}
-	if declared := composed(t, open, "laptop"); len(declared.LeftOut) != 0 {
-		t.Fatalf("a setting that composes left a module out: %v", declared.LeftOut)
-	}
-
-	// The definition moves: the container publishes another port now.
-	web.Version = "2"
-	web.Resources[1]["ports"] = []any{"9090"}
-	register(t, open, web)
-	declared := composed(t, open, "laptop")
-	if len(declared.LeftOut) != 1 || declared.LeftOut[0] != "hello-web" {
-		t.Fatalf("hello-web is not left out: %v", declared.LeftOut)
-	}
-	if !strings.Contains(declared.leftOutWhy["hello-web"], "no container of its publishes 8080") {
-		t.Fatalf("why it was left out is not said: %v", declared.leftOutWhy)
-	}
-	if hasID(declared.Resources, "hello-web.server") || !hasID(declared.Resources, "notes.conf") {
-		t.Fatalf("the machine was not told everything else: %v", declared.Resources)
-	}
-	body, err := declared.Body()
-	if err != nil {
-		t.Fatal(err)
-	}
-	var env map[string]any
-	if err := json.Unmarshal(body, &env); err != nil {
-		t.Fatal(err)
-	}
-	left, _ := env["left_out"].([]any)
-	if len(left) != 1 || left[0] != "hello-web" {
-		t.Fatalf("the envelope does not say what was left out: %v", env)
-	}
-}

cmd/mesh-controller/sequence_test.go

@@ -1,77 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"testing"
-)
-
-// A declaration's only identity was the digest of its bytes; the controller already held a per-node
-// lock and recorded each send, so the order existed and was thrown away at the wire (novox/hq
-// 04-ISSUES/107).
-
-func TestASendCarriesItsNumberInsideTheSignedBytes(t *testing.T) {
-	body, err := sendable{Resources: []map[string]any{{"id": "x", "type": "file"}}, Sequence: 7}.Body()
-	if err != nil {
-		t.Fatal(err)
-	}
-	var env map[string]any
-	if err := json.Unmarshal(body, &env); err != nil {
-		t.Fatal(err)
-	}
-	if got, _ := env["sequence"].(float64); got != 7 {
-		t.Fatalf("the body carries sequence %v, wanted 7", env["sequence"])
-	}
-}
-
-func TestAnUnnumberedSendIsByteForByteWhatItWasBefore(t *testing.T) {
-	// Zero is not sent at all. A host reads absence as "no order claimed" — the shape of every
-	// declaration before this — so an older host, or the read-only comparison against a machine
-	// sent nothing since sends were numbered, sees exactly the bytes it always saw.
-	body, err := sendable{Resources: []map[string]any{{"id": "x", "type": "file"}}}.Body()
-	if err != nil {
-		t.Fatal(err)
-	}
-	var env map[string]any
-	if err := json.Unmarshal(body, &env); err != nil {
-		t.Fatal(err)
-	}
-	if _, present := env["sequence"]; present {
-		t.Fatalf("a send numbered zero put a sequence on the wire: %s", body)
-	}
-}
-
-func TestEachSendToANodeIsOneHigherAndReadable(t *testing.T) {
-	open := aMesh(t)
-	record, err := open.inventory.NodeByName(t.Context(), "anchor")
-	if err != nil {
-		t.Fatal(err)
-	}
-	// Sent nothing since numbering existed: what it would be sent is composed with zero, which is
-	// not on the wire, which is what it was actually sent.
-	if n, err := open.inventory.Sequence(t.Context(), record.ID); err != nil || n != 0 {
-		t.Fatalf("a fresh node reads sequence %d, %v", n, err)
-	}
-	first, err := open.inventory.NextSequence(t.Context(), record.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	second, err := open.inventory.NextSequence(t.Context(), record.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if first != 1 || second != 2 {
-		t.Fatalf("two sends were numbered %d and %d", first, second)
-	}
-	// And the read path sees the last one taken, so the comparison composes what was sent.
-	if n, err := open.inventory.Sequence(t.Context(), record.ID); err != nil || n != 2 {
-		t.Fatalf("after two sends the node reads sequence %d, %v", n, err)
-	}
-	// Another node counts on its own.
-	other, err := open.inventory.NodeByName(t.Context(), "laptop")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if n, err := open.inventory.NextSequence(t.Context(), other.ID); err != nil || n != 1 {
-		t.Fatalf("a second node's first send was numbered %d, %v", n, err)
-	}
-}

cmd/mesh-controller/source.go

@@ -82,16 +82,6 @@ func cloneFrom(ctx context.Context, source buildSource) (string, error) {
 // serves no scheme or port has nothing to compose from — a default port here would be the forge's
 // address guessed, which is the thing this exists to stop.
 func clonedFromSeat(world catalogue.World, seatName, repository string) (string, error) {
-	base, err := seatBase(world, seatName)
-	if err != nil {
-		return "", err
-	}
-	path := strings.TrimSuffix(strings.Trim(repository, "/"), ".git")
-	return fmt.Sprintf("%s/%s.git", base, path), nil
-}
-
-// seatBase is `scheme://host:port` of a seat's holder as the mesh reaches it, for cloning.
-func seatBase(world catalogue.World, seatName string) (string, error) {
 	seat, known := catalogue.SeatNamed(seatName)
 	if !known || seat.Delivers == "" {
 		return "", fmt.Errorf("%q is not a seat a repository can live on", seatName)
@@ -104,9 +94,9 @@ func seatBase(world catalogue.World, seatName string) (string, error) {
 		}
 	}
 	if holder == nil {
-		return "", fmt.Errorf("nobody holds the %s seat, so nothing can be cloned from this mesh's "+
+		return "", fmt.Errorf("nobody holds the %s seat, so %s cannot be cloned from this mesh's "+
 			"forge — assign a module that claims it, or build from the repository's URL without --self",
-			seat.Name)
+			seat.Name, repository)
 	}
 	var provider *catalogue.Provider
 	for i, p := range world.Offered[seat.Delivers] {
@@ -128,33 +118,8 @@ func seatBase(world catalogue.World, seatName string) (string, error) {
 		return "", fmt.Errorf("%s on %s holds the %s seat and does not serve a scheme and a port for %q",
 			holder.Module, holder.Node, seat.Name, seat.Delivers)
 	}
-	return fmt.Sprintf("%s://%s:%s", scheme, provider.At, port), nil
+	path := strings.TrimSuffix(strings.Trim(repository, "/"), ".git")
-}
+	return fmt.Sprintf("%s://%s:%s/%s.git", scheme, provider.At, port, path), nil
-
-// seatBases is the clone base of every seat a recipe's context may name, for a build request
-// (novox/hq ADR 0155). A seat nobody holds is left out rather than refused here: the build may not
-// name it at all, and if it does the builder refuses with the seat's name.
-func seatBases(ctx context.Context) map[string]string {
-	open, err := openStores(ctx)
-	if err != nil {
-		return nil
-	}
-	defer open.Close()
-	shelf, err := open.inventory.Catalogue(ctx)
-	if err != nil {
-		return nil
-	}
-	world, err := theRestOfTheMesh(ctx, open.inventory, shelf, "")
-	if err != nil {
-		return nil
-	}
-	bases := map[string]string{}
-	for _, seatName := range []string{gitSeat} {
-		if base, err := seatBase(world, seatName); err == nil {
-			bases[seatName] = base
-		}
-	}
-	return bases
 }
 
 // servedPort is a served port as text, however the manifest and the node's settings carried it.

cmd/mesh-controller/status.go

@@ -138,18 +138,6 @@ func printStatus(asked answers) error {
 			len(quiet), strings.Join(said, "\n  "))
 	}
 
-	if open, late := openPlans(asked.plans); len(open) > 0 {
-		fmt.Printf("%d plan(s) open", len(open))
-		if late > 0 {
-			fmt.Printf(", %d waiting past %s", late, planWaitBound)
-		}
-		fmt.Println(":")
-		for _, p := range open {
-			fmt.Printf("  %s\n", planLine(p, time.Now()))
-		}
-		fmt.Println()
-	}
-
 	if len(behind) > 0 {
 		var names []string
 		for m := range behind {
@@ -227,28 +215,6 @@ func printStatus(asked answers) error {
 			"  not readable from a commit; that needs a version the host reports as ordered\n\n")
 	}
 
-	if len(asked.filtered) > 0 {
-		// A converged machine is filtered by the mesh alone, and the mesh says truthfully which
-		// (novox/hq ADR 0168). One that is not — a predecessor's chain still refusing, a found
-		// firewall in force again — is said here, and is not well.
-		machines := make([]string, 0, len(asked.filtered))
-		for name := range asked.filtered {
-			machines = append(machines, name)
-		}
-		sort.Strings(machines)
-		fmt.Printf("%d converged machine(s) are not filtered by the mesh alone:\n", len(machines))
-		for _, name := range machines {
-			f := asked.filtered[name]
-			if fw := f.FoundFirewall; fw != nil && fw.Active {
-				fmt.Printf("  %-12s the found firewall (%s) is in force again; the next apply retires it\n", name, fw.Kind)
-			}
-			for _, x := range f.Others() {
-				fmt.Printf("  %-12s %s (%s): %s\n", name, x.Where, x.Owner, x.Refuses)
-			}
-		}
-		fmt.Printf("\n  the mesh wrote none of these and removes none; `node show <node>` lists every filter with its owner\n\n")
-	}
-
 	if len(asked.untaken) > 0 {
 		// **Before the adopted line, and it breaks "all well".** An adopted machine is a state
 		// somebody chose and can leave alone; a module assigned to one and never taken is work
@@ -323,10 +289,7 @@ func firstLine(s string) string {
 // A type of its own rather than a method on the enrolment, because they are unrelated things
 // arriving on one queue and an implementation of one should not have to say anything about the
 // other.
-type builds struct {
+type builds struct{ inv *inventory.Inventory }
-	inv  *inventory.Inventory
-	open *stores
-}
 
 // theThreeQuestions reads what anything answering "is the mesh alright" needs.
 //
@@ -379,17 +342,6 @@ func theThreeQuestions(ctx context.Context, open *stores) (answers, error) {
 	if err != nil {
 		return answers{}, err
 	}
-	// And which converged machines something other than the mesh filters (novox/hq ADR 0168), as
-	// each last reported — the account that was missing when a predecessor's chain refused what the
-	// mesh declared open for eleven hours (04-ISSUES/144, 145).
-	out.filtered, err = filteredMachines(ctx, inv, out.nodes)
-	if err != nil {
-		return answers{}, err
-	}
-	out.plans, err = inv.RecentPlans(ctx, 5)
-	if err != nil {
-		return answers{}, err
-	}
 
 	// And which machines are not running what the mesh would send them. The same question as a
 	// module being behind its source, one level down: that one says the catalogue is out of date,
@@ -435,30 +387,6 @@ func theThreeQuestions(ctx context.Context, open *stores) (answers, error) {
 //
 // A machine that reports no holds contributes nothing, so a converged mesh answers an empty map and
 // the caller prints nothing.
-// filteredMachines is every converged machine not filtered by the mesh alone, with what it last said
-// filters it (novox/hq ADR 0168). An adopted machine keeps its found firewall by design and is not
-// counted; a machine that has not said is not said to be filtered by anything.
-func filteredMachines(ctx context.Context, inv *inventory.Inventory, nodes []inventory.Node) (
-	map[string]inventory.Filtering, error) {
-	out := map[string]inventory.Filtering{}
-	for _, n := range nodes {
-		if n.Adopted {
-			continue
-		}
-		f, err := inv.FilteringOf(ctx, n.Name)
-		if err != nil {
-			return nil, fmt.Errorf("what filters %s cannot be read: %w", n.Name, err)
-		}
-		if len(f.Filters) == 0 && f.FoundFirewall == nil {
-			continue
-		}
-		if !f.Alone() {
-			out[n.Name] = f
-		}
-	}
-	return out, nil
-}
-
 func untakenModules(ctx context.Context, inv *inventory.Inventory, nodes []inventory.Node) (
 	map[string]map[string]int, error) {
 
@@ -495,8 +423,7 @@ func untakenModules(ctx context.Context, inv *inventory.Inventory, nodes []inven
 // read as success for the whole of the edge cut-over outage (novox/hq 04-ISSUES/125).
 func (a answers) well() bool {
 	return len(a.wrong) == 0 && len(a.quiet) == 0 && len(a.behind) == 0 &&
-		len(a.waiting) == 0 && len(a.refused) == 0 && a.network == "" && len(a.untaken) == 0 &&
+		len(a.waiting) == 0 && len(a.refused) == 0 && a.network == "" && len(a.untaken) == 0
-		len(a.filtered) == 0
 }
 
 // hostSplit is which machines report which host version, for every version more than one machine

cmd/mesh-controller/take_preview_test.go

@@ -1,143 +0,0 @@
-package main
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-	"github.com/novox/mesh-controller/internal/inventory"
-)
-
-// What the forge's take compares, as a machine would report it.
-func aForgeComparison() comparison {
-	return comparison{reported: inventory.Adoption{
-		Firewall: "ufw",
-		Held: []inventory.Held{
-			{ID: "forge.server", Module: "forge", Kind: "container", Target: "forge", Facts: map[string]any{
-				"image": "forge:1.27.3", "image_created": "2026-09-17T10:00:00Z",
-				"declared_image": "forge:1.22.6", "declared_image_created": "2026-08-20T10:00:00Z", "downgrade": true,
-				"networks": map[string]any{"predecessor_default": []any{"office", "db"}},
-				"ports":    []any{"3000/tcp>0.0.0.0:3000"}, "declared_ports": []any{"3000:3000"},
-			}},
-			{ID: "forge.config", Module: "forge", Kind: "file", Target: "/etc/forge/app.ini", Kept: "/var/lib/mesh/kept/app.ini",
-				Facts: map[string]any{"differs": true, "difference": []any{"- private scope: local", "+ upstream: public"}}},
-			{ID: "other.server", Module: "other", Kind: "container", Target: "other"},
-		},
-		Reachable: []inventory.Reach{
-			{Protocol: "tcp", Address: "0.0.0.0", Port: 3000, By: "forge", Published: true, ContainerPort: 3000},
-			{Protocol: "tcp", Address: "0.0.0.0", Port: 22, By: "sshd"},
-		},
-	}}
-}
-
-// A take is a comparison (novox/hq ADR 0163): the preview puts what runs beside what the module
-// declares, and an older image or a differing file refuses unless named.
-func TestATakePreviewsTheComparisonAndRefusesWhatIsNotNamed(t *testing.T) {
-	c := aForgeComparison()
-	preview, refusals, saw := comparisonOf("forge", c, takeOptions{})
-	for _, want := range []string{"runs forge:1.27.3 (made 2026-09-17)", "declares forge:1.22.6 (made 2026-08-20)", "DOWNGRADE",
-		"on the network predecessor_default with office, db", "will not once it moves to the module's own network",
-		"publishes 3000/tcp>0.0.0.0:3000; the module declares 3000:3000",
-		// How far the port reaches now, as the machine reported it (rule 1).
-		"reachable now at 0.0.0.0:3000 (tcp, container port 3000), behind the found firewall (ufw)",
-		"- private scope: local", "original kept at /var/lib/mesh/kept/app.ini"} {
-		if !strings.Contains(preview, want) {
-			t.Errorf("the preview lacks %q:\n%s", want, preview)
-		}
-	}
-	if strings.Contains(preview, "other") {
-		t.Errorf("another module's held things are in the preview:\n%s", preview)
-	}
-	if len(refusals) != 2 || !strings.Contains(refusals[0], "--downgrade") || !strings.Contains(refusals[1], "--replace /etc/forge/app.ini") {
-		t.Fatalf("the downgrade and the differing file refuse, each naming its override: %v", refusals)
-	}
-	if len(saw) != 12 {
-		t.Fatalf("the preview's digest is %q", saw)
-	}
-	// Named, they pass.
-	if _, refusals, _ := comparisonOf("forge", c, takeOptions{Downgrade: true, Replace: map[string]bool{"/etc/forge/app.ini": true}}); len(refusals) != 0 {
-		t.Fatalf("named differences still refused: %v", refusals)
-	}
-	if _, refusals, _ := comparisonOf("forge", c, takeOptions{Downgrade: true, Replace: map[string]bool{"*": true}}); len(refusals) != 0 {
-		t.Fatalf("replace * did not cover the file: %v", refusals)
-	}
-	// A held thing with no facts yet — a host older than this — refuses nothing and says what it can.
-	if preview, refusals, _ := comparisonOf("other", c, takeOptions{}); len(refusals) != 0 || !strings.Contains(preview, "container other") {
-		t.Fatalf("a factless hold: %q %v", preview, refusals)
-	}
-	// The digest is of what the preview says: a fact changing changes it.
-	c.reported.Held[0].Facts["image"] = "forge:1.27.4"
-	if _, _, again := comparisonOf("forge", c, takeOptions{}); again == saw {
-		t.Fatal("the found image changed and the digest did not")
-	}
-}
-
-// A secret the mesh minted for a service whose data was found refuses: the running service already
-// has a value (rule 2). Accepted, it is carried in; `--mint` says the service shall take the new one.
-func TestAMintedSecretForFoundDataRefusesUnlessAcceptedOrMinted(t *testing.T) {
-	c := aForgeComparison()
-	c.secrets = []inventory.SecretState{
-		{Name: "admin", Origin: inventory.OriginMade},
-		{Name: "postgres-database", Origin: inventory.OriginMade, Provider: "anchor"},
-		{Name: "broker", Origin: inventory.OriginAccepted},
-	}
-	preview, refusals, _ := comparisonOf("forge", c, takeOptions{Downgrade: true, Replace: map[string]bool{"*": true}})
-	for _, want := range []string{
-		"own secret admin: MINTED by the mesh and not accepted",
-		"secret from anchor postgres-database: MINTED by the mesh and not accepted",
-		"own secret broker: accepted from a person, carried in as it is",
-	} {
-		if !strings.Contains(preview, want) {
-			t.Errorf("the preview lacks %q:\n%s", want, preview)
-		}
-	}
-	if len(refusals) != 2 {
-		t.Fatalf("two minted secrets refuse: %v", refusals)
-	}
-	if !strings.Contains(refusals[0], "`secret accept <node> forge admin`") || !strings.Contains(refusals[0], "`--mint admin`") {
-		t.Errorf("the own secret's refusal names accepting it and minting it: %s", refusals[0])
-	}
-	if !strings.Contains(refusals[1], "`secret accept <node> forge postgres-database --provider anchor`") {
-		t.Errorf("the required secret's refusal names its provider: %s", refusals[1])
-	}
-	preview, refusals, _ = comparisonOf("forge", c, takeOptions{Downgrade: true, Replace: map[string]bool{"*": true},
-		Mint: map[string]bool{"admin": true, "postgres-database": true}})
-	if len(refusals) != 0 || !strings.Contains(preview, "admin: minted by the mesh; the service takes the new value, as --mint said") {
-		t.Fatalf("--mint did not pass the minted secrets: %v\n%s", refusals, preview)
-	}
-	// With no found data — only a file held — the service has no value of its own, and a minted
-	// secret is simply said.
-	c.reported.Held = c.reported.Held[1:2]
-	if _, refusals, _ := comparisonOf("forge", c, takeOptions{Replace: map[string]bool{"*": true}}); len(refusals) != 0 {
-		t.Fatalf("a minted secret refused with no data found: %v", refusals)
-	}
-}
-
-// A found network a per-machine setting keeps is named in the preview (rule 4), and the module's
-// settings are said with where each came from, composed or not (rules 1 and 6).
-func TestTheKeptNetworkAndTheSettingsAreInThePreview(t *testing.T) {
-	c := aForgeComparison()
-	c.keeps = map[string][]string{"forge.server": {"predecessor_default"}}
-	c.layers = []catalogue.Layer{
-		{From: catalogue.MeshWideLayer, Values: map[string]any{"site": "x"}},
-		{From: "anchor", Values: map[string]any{catalogue.NetworksSetting: map[string]any{"server": []any{"predecessor_default"}}}},
-	}
-	preview, _, _ := comparisonOf("forge", c, takeOptions{Downgrade: true, Replace: map[string]bool{"*": true}})
-	for _, want := range []string{
-		"on the network predecessor_default with office, db — kept by this machine's setting, so they still reach it by name once taken",
-		"settings from the mesh: site",
-		"settings from anchor: networks",
-	} {
-		if !strings.Contains(preview, want) {
-			t.Errorf("the preview lacks %q:\n%s", want, preview)
-		}
-	}
-	if strings.Contains(preview, "will not once it moves") {
-		t.Errorf("a kept network is still said to be lost:\n%s", preview)
-	}
-	c.settingsRefused = "forge: ports is a { port: machine-port } map"
-	preview, _, _ = comparisonOf("forge", c, takeOptions{Downgrade: true, Replace: map[string]bool{"*": true}})
-	if !strings.Contains(preview, "SETTINGS DO NOT COMPOSE with the module's definition, so the push leaves it out: forge: ports") {
-		t.Errorf("settings that cannot compose are not said:\n%s", preview)
-	}
-}

cmd/mesh-controller/upgrades.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"flag"
 	"fmt"
-	"regexp"
 	"strings"
 	"time"
 
@@ -284,14 +283,6 @@ func (f following) SourceMoved(ctx context.Context, m link.SourceMoved) error {
 	if isHistory(m.MergedAt, lastLookAt(entries, m)) {
 		packaging = nil
 	}
-	// Said, never silent (novox/hq 04-ISSUES/215): a module built from this repository that follows
-	// another branch is not part of this merge, and whoever is waiting for its change should read why.
-	for _, e := range entries {
-		if sameRepository(e.Source.Repository, m) && !sourceIs(e.Source, m) {
-			fmt.Printf("  %s is built from %s/%s and follows %s, not %s; this merge leaves it out\n",
-				e.Manifest.Module, m.Owner, m.Repo, e.Source.Ref, m.Base)
-		}
-	}
 	touched := whatTheMergeTouched(from, entries, m)
 	for _, e := range touched {
 		if err := inv.SourceMoved(ctx, e.Manifest.Module, m.Commit); err != nil {
@@ -304,38 +295,17 @@ func (f following) SourceMoved(ctx context.Context, m link.SourceMoved) error {
 			"built from\n", m.Owner, m.Repo, m.Base, m.Commit)
 		return nil
 	}
-	// A merge produces a plan the mesh keeps (novox/hq ADR 0162): what moved and everything that
+	against, err := inv.BuiltAgainst(ctx)
-	// depends on it, along the catalogue's one dependency relation, sorted into tiers. The plan is
-	// written before any build is asked; the first tier is asked; this returns. Outcomes advance it.
-	edges, err := inv.Dependencies(ctx)
 	if err != nil {
 		return notNow(err)
 	}
-	var movedNames []string
+	ordered := orderByBases(moved, against)
-	for _, e := range moved {
+	names := make([]string, 0, len(ordered))
-		movedNames = append(movedNames, e.Manifest.Module)
+	for _, e := range ordered {
+		names = append(names, e.Manifest.Module)
 	}
-	// Written and its first tier asked as one act on the plans (novox/hq issue 213): a timer on
+	fmt.Printf("%s/%s merged into %s (%.8s); building %s\n",
-	// another controller reading it between the two would ask the tier again.
+		m.Owner, m.Repo, m.Base, m.Commit, strings.Join(names, ", "))
-	release, err := inv.HoldPlans(ctx, true)
-	if err != nil {
-		return notNow(err)
-	}
-	defer release()
-	plan := planOfMerge(m, movedNames, edges)
-	if hasCycle(plan.Tiers, edges) {
-		fmt.Printf("  the last tier depends on itself: %s — built together, in no order\n",
-			strings.Join(plan.Tiers[len(plan.Tiers)-1], ", "))
-	}
-	if err := inv.SavePlan(ctx, plan); err != nil {
-		return notNow(err)
-	}
-	var tiers []string
-	for i, t := range plan.Tiers {
-		tiers = append(tiers, fmt.Sprintf("%d: %s", i, strings.Join(t, ", ")))
-	}
-	fmt.Printf("%s/%s merged into %s (%.8s); plan %s, %d module(s) in %d tier(s)\n  %s\n",
-		m.Owner, m.Repo, m.Base, m.Commit, plan.ID, len(plan.Modules), len(plan.Tiers), strings.Join(tiers, "\n  "))
 	if len(packaging) > 0 {
 		var also []string
 		for _, e := range packaging {
@@ -344,11 +314,22 @@ func (f following) SourceMoved(ctx context.Context, m link.SourceMoved) error {
 		fmt.Printf("  %s package source from it, so they are rebuilt and their own source record "+
 			"is left where it is\n", strings.Join(also, ", "))
 	}
-	if err := askTier(ctx, inv, &plan); err != nil {
+	var failed []string
-		return notNow(err)
+	for _, e := range ordered {
+		source := buildSource{Repository: e.Source.Repository, Seat: e.Source.Seat}
+		if err := buildOne(ctx, source, e.Source.Path, e.Source.Ref, 20*time.Minute); err != nil {
+			fmt.Printf("  %s: %v\n", e.Manifest.Module, err)
+			failed = append(failed, e.Manifest.Module)
+			// A base that failed is a reason to stop: what stands on it would be built against
+			// the old one, and report success (novox/hq 04-ISSUES/131).
+			if standsOn(ordered, e.Manifest.Module, against) {
+				fmt.Printf("  stopping: %s is a base of what was still to build\n", e.Manifest.Module)
+				break
 			}
-	if err := inv.SavePlan(ctx, plan); err != nil {
+		}
-		return notNow(err)
+	}
+	if len(failed) > 0 {
+		fmt.Printf("%d of %d not built: %s\n", len(failed), len(ordered), strings.Join(failed, ", "))
 	}
 	return nil
 }
@@ -361,24 +342,7 @@ func sourceIs(s inventory.Source, m link.SourceMoved) bool {
 	if !sameRepository(s.Repository, m) {
 		return false
 	}
-	ref := followedBranch(s.Ref)
+	return s.Ref == "" || s.Ref == m.Base
-	return ref == "" || ref == m.Base
-}
-
-// commitRef is a ref that names a commit rather than a branch: what `build --ref <commit>` asks for.
-var commitRef = regexp.MustCompile(`^[0-9a-f]{7,40}$`)
-
-// followedBranch is the branch a recorded ref means a module follows (novox/hq 04-ISSUES/215). **A
-// commit is never a branch to follow.** A build asked at a commit — to try one, or to pin it during a
-// fix — recorded that commit as the module's ref; every merge after it then failed to match the
-// module, its plan left it out without saying so, and every plan that rebuilt it asked for that same
-// old commit again. A commit recorded so is read as the repository's default branch, which is what
-// the module followed before it; a branch is followed as named.
-func followedBranch(ref string) string {
-	if commitRef.MatchString(strings.TrimSpace(ref)) {
-		return ""
-	}
-	return ref
 }
 
 // sameRepository is whether a recorded repository is the one a merge names, in either spelling it
@@ -558,37 +522,3 @@ func isHistory(mergedAt string, seen time.Time) bool {
 	}
 	return at.Before(seen)
 }
-
-// dependentsOf is every catalogued module that stands on one of the moved modules, directly or
-// through another dependent, and is not itself among them — in the catalogue's order, so the
-// answer is the same each time. A module standing on nothing that moved is left alone: a merge
-// rebuilds what it changed and what is built on top of that, not the catalogue.
-func dependentsOf(moved, entries []inventory.Entry, against map[string][]string) []inventory.Entry {
-	bases := map[string]bool{}
-	for _, e := range moved {
-		bases[e.Manifest.Module] = true
-	}
-	var out []inventory.Entry
-	taken := map[string]bool{}
-	for grew := true; grew; {
-		grew = false
-		for _, e := range entries {
-			name := e.Manifest.Module
-			if bases[name] || taken[name] {
-				continue
-			}
-			for base := range bases {
-				if standsOnModule(e, base, against) {
-					taken[name] = true
-					out = append(out, e)
-					grew = true
-					break
-				}
-			}
-		}
-		for _, e := range out {
-			bases[e.Manifest.Module] = true
-		}
-	}
-	return out
-}

cmd/mesh-controller/worker_order_test.go

@@ -1,45 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/inventory"
-)
-
-// The holder of the build seat follows the controller that defines its worker (novox/hq issue 206).
-// On 2026-10-03 a plan put the build machine in tier 0 and the controller in tier 1; the new build
-// machine could not bind the worker the old controller had defined, and nothing could build the
-// controller that would have redefined it. The built-by edge from the controller to its build
-// machine yields to that order: the controller is built by whichever build machine is running.
-func TestTheBuildSeatsHolderFollowsTheControllerThatDefinesItsWorker(t *testing.T) {
-	edges := []inventory.Edge{
-		{From: "build-agent", To: "mesh-controller", Kind: inventory.EdgePackages},
-		{From: "build-agent", To: "mesh-controller", Kind: inventory.EdgeWorkerOf},
-		{From: "mesh-controller", To: "build-agent", Kind: inventory.EdgeBuiltBy},
-		{From: "route-proxy", To: "mesh-controller", Kind: inventory.EdgePackages},
-		{From: "route-proxy", To: "build-agent", Kind: inventory.EdgeBuiltBy},
-	}
-	set := reachableFrom([]string{"mesh-controller"}, edges)
-	if len(set) != 3 {
-		t.Fatalf("the controller, what packages it, and nothing more: %v", set)
-	}
-	tiers := tiersOf(set, edges)
-	pos := map[string]int{}
-	for i, tier := range tiers {
-		for _, m := range tier {
-			pos[m] = i
-		}
-	}
-	if pos["mesh-controller"] != 0 {
-		t.Fatalf("the controller first, built by the build machine that is running: %v", tiers)
-	}
-	if pos["build-agent"] <= pos["mesh-controller"] {
-		t.Fatalf("the build machine after the controller that defines its worker: %v", tiers)
-	}
-	if pos["route-proxy"] <= pos["build-agent"] {
-		t.Fatalf("what the build machine builds comes after it: %v", tiers)
-	}
-	if hasCycle(tiers, edges) {
-		t.Fatalf("no cycle here: %v", tiers)
-	}
-}

examples/objectstore-provisioner/Dockerfile

@@ -10,10 +10,7 @@
 # The client is copied from the vendor's own image rather than installed from a distribution:
 # `apk add mc` on Alpine installs Midnight Commander, which is a different program with the same
 # name, and the failure would be a provisioner that starts cleanly and cannot do anything.
-# The Go it builds with is the one the manifest pins (build.on GO_BASE), passed by the Makefile and the
+FROM golang:1.25-alpine AS build
-# build machine alike; the default only serves a hand build, and matches go.mod.
-ARG GO_BASE=golang:1.26-alpine
-FROM ${GO_BASE} AS build
 WORKDIR /src
 COPY go.mod go.sum ./
 RUN go mod download

examples/postgres-provisioner/Dockerfile

@@ -3,10 +3,7 @@
 # Built here so a machine can be given it by the mesh rather than by somebody putting a binary on
 # it. Static and FROM scratch for the same reason the control plane's image is: it is fetched by
 # digest and run on a machine, and everything in it is something a person would have to audit.
-# The Go it builds with is the one the manifest pins (build.on GO_BASE), passed by the Makefile and the
+FROM golang:1.25-alpine AS build
-# build machine alike; the default only serves a hand build, and matches go.mod.
-ARG GO_BASE=golang:1.26-alpine
-FROM ${GO_BASE} AS build
 WORKDIR /src
 COPY go.mod go.sum ./
 RUN go mod download

examples/redis-provisioner/Dockerfile

@@ -2,10 +2,7 @@
 #
 # FROM scratch, like the postgres one and unlike the bucket one: it speaks the store's own wire
 # protocol directly and needs no client in the image.
-# The Go it builds with is the one the manifest pins (build.on GO_BASE), passed by the Makefile and the
+FROM golang:1.25-alpine AS build
-# build machine alike; the default only serves a hand build, and matches go.mod.
-ARG GO_BASE=golang:1.26-alpine
-FROM ${GO_BASE} AS build
 WORKDIR /src
 COPY go.mod go.sum ./
 RUN go mod download

examples/route-proxy/Dockerfile

@@ -2,10 +2,7 @@
 #
 # Static and FROM scratch like the control plane's image, and for the same reason: it is fetched
 # by digest and run on a machine, so everything in it is something a person would have to audit.
-# The Go it builds with is the one the manifest pins (build.on GO_BASE), passed by the Makefile and the
+FROM golang:1.25-alpine AS build
-# build machine alike; the default only serves a hand build, and matches go.mod.
-ARG GO_BASE=golang:1.26-alpine
-FROM ${GO_BASE} AS build
 WORKDIR /src
 COPY go.mod go.sum ./
 RUN go mod download

examples/route-proxy/bus.go

@@ -1,132 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"log"
-	"os"
-	"strings"
-	"sync/atomic"
-	"time"
-
-	"github.com/nats-io/nats.go"
-
-	"github.com/novox/mesh-controller/internal/broker"
-)
-
-// What the mesh issued this proxy, read on the bus (novox/hq ADR 0160, ADR 0167).
-//
-// **The proxy is told, not left to work it out.** Its membership carries the routes it is given —
-// the same contributions its file is written from — and every machine's address on the private
-// network, which is who may be served an internal name. Read once at connect and followed, so a
-// route added or a machine joining reaches a running proxy without a restart.
-
-// credential is the bus account the mesh delivered as this module's own secret named broker.
-type credential struct {
-	URL         string `json:"url"`
-	Fingerprint string `json:"fingerprint"`
-	Node        string `json:"node"`
-	Module      string `json:"module"`
-	User        string `json:"user"`
-	Password    string `json:"password"`
-}
-
-// followMembership connects with the credential in path and applies every membership the mesh
-// issues this proxy. It retries the first connection for as long as it takes: a proxy that started
-// before the bus keeps serving the file, and takes the bus when it answers.
-func followMembership(path string, held *table, fromBus *atomic.Bool) {
-	for {
-		err := followOnce(path, held, fromBus)
-		if err == nil {
-			return
-		}
-		log.Printf("cannot follow this proxy's membership, serving the file meanwhile: %v", err)
-		time.Sleep(30 * time.Second)
-	}
-}
-
-func followOnce(path string, held *table, fromBus *atomic.Bool) error {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return err
-	}
-	var cred credential
-	if err := json.Unmarshal(raw, &cred); err != nil {
-		return fmt.Errorf("the broker credential is not one: %w", err)
-	}
-	if cred.Node == "" || cred.Module == "" {
-		return fmt.Errorf("the broker credential names no node or module, so it has no membership")
-	}
-
-	opts := []nats.Option{
-		nats.Name(cred.Node + "." + cred.Module),
-		nats.UserInfo(cred.User, cred.Password),
-		// Its own inbox, and nothing wider: every principal is granted `_INBOX.<its user>.>` alone.
-		nats.CustomInboxPrefix("_INBOX." + cred.User),
-		// The bus being restarted is an upgrade, not a reason to stop following.
-		nats.MaxReconnects(-1),
-	}
-	if strings.TrimSpace(cred.Fingerprint) != "" {
-		opts = append(opts, nats.Secure(broker.PinnedToFingerprint(cred.Fingerprint)))
-	}
-	conn, err := nats.Connect(cred.URL, opts...)
-	if err != nil {
-		return fmt.Errorf("connecting to the bus at %s: %w", broker.BareAddress(cred.URL), err)
-	}
-
-	subject := broker.MembershipSubject(cred.Node, cred.Module)
-	apply := func(body []byte) {
-		var issued broker.Membership
-		if err := json.Unmarshal(body, &issued); err != nil {
-			log.Printf("a membership arrived that is not one: %v", err)
-			return
-		}
-		if took := applyMembership(issued, held); took && !fromBus.Swap(true) {
-			log.Printf("routes now come from this proxy's membership on %s", subject)
-		}
-	}
-
-	// Followed first, read second: an issue landing between the two is applied, not missed.
-	if _, err := conn.Subscribe(subject, func(m *nats.Msg) { apply(m.Data) }); err != nil {
-		conn.Close()
-		return fmt.Errorf("cannot follow %s: %w", subject, err)
-	}
-	// The subject-addressed direct get: the one request this account may make of the stream.
-	got, err := conn.Request("$JS.API.DIRECT.GET."+broker.AssignmentsStream+"."+subject, nil, 5*time.Second)
-	switch {
-	case err != nil:
-		log.Printf("cannot read the membership issued on %s yet (%v); following it", subject, err)
-	case got.Header.Get("Status") != "" || len(got.Data) == 0:
-		log.Printf("no membership issued on %s yet; serving the file until one is", subject)
-	default:
-		apply(got.Data)
-	}
-	return nil
-}
-
-// applyMembership serves what a membership says, and says whether it said anything about routes.
-//
-// A membership with no routes in it is one from a controller older than ADR 0167, and the file stays
-// the source rather than every route being withdrawn because a field was absent.
-func applyMembership(issued broker.Membership, held *table) bool {
-	raw, carries := issued.Receives["route"]
-	if !carries {
-		return false
-	}
-	var contributions []contribution
-	if err := json.Unmarshal(raw, &contributions); err != nil {
-		log.Printf("the routes in this proxy's membership are not contributions, keeping what is served: %v", err)
-		return false
-	}
-	inside, err := sourcesOf(issued.Mesh)
-	if err != nil {
-		log.Printf("the mesh in this proxy's membership is unreadable, keeping what is served: %v", err)
-		return false
-	}
-	routes, public := routesOf(contributions)
-	held.set(routes, public)
-	held.setInside(inside)
-	log.Printf("serving %d route(s) from the membership, internal names to %d machine(s): %s",
-		len(routes), len(inside), strings.Join(held.names(), ", "))
-	return true
-}

examples/route-proxy/forwarded_test.go

@@ -1,29 +0,0 @@
-package main
-
-import (
-	"crypto/tls"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"testing"
-)
-
-// A backend behind the proxy learns the client used TLS and which name it asked for, so the addresses
-// it writes into its own pages are the ones a client can use (2026-10-03: a forge's Go import tag
-// named an http clone URL, and Go refused the module path).
-func TestABackendIsToldTheRequestWasHTTPSAndForWhichName(t *testing.T) {
-	var proto, host, fwdHost, fwdFor string
-	backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		proto, host, fwdHost, fwdFor = r.Header.Get("X-Forwarded-Proto"), r.Host, r.Header.Get("X-Forwarded-Host"), r.Header.Get("X-Forwarded-For")
-	}))
-	defer backend.Close()
-	where, _ := url.Parse(backend.URL)
-	req := httptest.NewRequest(http.MethodGet, "https://git.example.org/novox/mesh-sdk/go?go-get=1", nil)
-	req.TLS = &tls.ConnectionState{}
-	req.Host = "git.example.org"
-	req.RemoteAddr = "192.0.2.7:51000"
-	towards(where).ServeHTTP(httptest.NewRecorder(), req)
-	if proto != "https" || fwdHost != "git.example.org" || host != "git.example.org" || fwdFor != "192.0.2.7" {
-		t.Errorf("the backend was told proto=%q host=%q forwarded-host=%q for=%q", proto, host, fwdHost, fwdFor)
-	}
-}

examples/route-proxy/main.go

@@ -54,14 +54,12 @@ import (
 	"net"
 	"net/http"
 	"net/http/httputil"
-	"net/netip"
 	"net/url"
 	"os"
 	"path/filepath"
 	"sort"
 	"strings"
 	"sync"
-	"sync/atomic"
 	"time"
 
 	"golang.org/x/crypto/acme"
@@ -198,63 +196,6 @@ type table struct {
 	// pass ACME's own validation (it has no public DNS to prove it against), so asking for it is
 	// not merely pointless but the failing order onlyWhatTheMeshSaid exists to prevent.
 	public map[string]bool
-	// inside is where a request must come from to be served a name that is only internal: every
-	// machine's address on the private network, as the mesh issued it in this proxy's membership
-	// (novox/hq ADR 0167). Empty until it is issued, and then only the machine itself is inside.
-	inside sources
-}
-
-// sources is who may be served an internal name: the private network's addresses as the mesh
-// issued them. The machine itself is always inside — anything on a machine may call anything on it
-// (novox/hq ADR 0144) — so loopback needs no entry.
-type sources []netip.Prefix
-
-// sourcesOf reads the addresses the mesh issued, each a single address or a range. One that does
-// not parse is an error, not an entry skipped: the proxy would otherwise serve internal names to
-// fewer machines than the mesh said, and say nothing.
-func sourcesOf(mesh []string) (sources, error) {
-	var out sources
-	for _, entry := range mesh {
-		entry = strings.TrimSpace(entry)
-		if prefix, err := netip.ParsePrefix(entry); err == nil {
-			out = append(out, prefix.Masked())
-			continue
-		}
-		addr, err := netip.ParseAddr(entry)
-		if err != nil {
-			return nil, fmt.Errorf("%q is not an address on the private network", entry)
-		}
-		addr = addr.Unmap()
-		out = append(out, netip.PrefixFrom(addr, addr.BitLen()))
-	}
-	return out, nil
-}
-
-// holds says whether a request from this remote address came from the mesh or the machine itself.
-//
-// **By source, which the mesh's guard deliberately is not** — it names interfaces, because a source
-// address can be claimed by whoever sends the packet. The proxy cannot see the interface a request
-// arrived on, and here the claim does not carry: a connection needs its replies, and replies to a
-// mesh address leave by the tunnel, never back to the claimant.
-func (s sources) holds(remote string) bool {
-	host := remote
-	if h, _, err := net.SplitHostPort(remote); err == nil {
-		host = h
-	}
-	addr, err := netip.ParseAddr(host)
-	if err != nil {
-		return false
-	}
-	addr = addr.Unmap()
-	if addr.IsLoopback() {
-		return true
-	}
-	for _, prefix := range s {
-		if prefix.Contains(addr) {
-			return true
-		}
-	}
-	return false
 }
 
 func (t *table) set(routes map[string][]rule, public map[string]bool) {
@@ -273,7 +214,7 @@ func (t *table) set(routes map[string][]rule, public map[string]bool) {
 				log.Printf("route %s points at %q, which is not a URL: %v", host, r.target, err)
 				continue
 			}
-			r.to = towards(where)
+			r.to = httputil.NewSingleHostReverseProxy(where)
 			if r.insecure {
 				r.to.Transport = &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
 			}
@@ -373,41 +314,6 @@ func bareHost(host string) string {
 	return strings.ToLower(host)
 }
 
-// hiddenFrom says whether this host must look unrouted to a request from this address: it is
-// only an internal name, and the request did not come from the private network.
-//
-// **The proxy is the only way in to a routed endpoint, so it is what makes `internal` true**
-// (novox/hq ADR 0138, issue 191). It answers public names on the same listeners, so a request from
-// anywhere can carry any Host header; a name being internal keeps nobody out unless this check does.
-// Answered exactly as a name that was never routed, so an outsider learns nothing from asking.
-func (t *table) hiddenFrom(host, remote string) bool {
-	if !t.eligibleForInternalACME(host) {
-		return false
-	}
-	t.mu.RLock()
-	defer t.mu.RUnlock()
-	return !t.inside.holds(remote)
-}
-
-// setInside replaces who the mesh is, as the membership said.
-func (t *table) setInside(inside sources) {
-	t.mu.Lock()
-	t.inside = inside
-	t.mu.Unlock()
-}
-
-// namesSeenFrom is what this proxy says it serves to a request from this address — every routed
-// name, less the internal-only ones when the request came from outside.
-func (t *table) namesSeenFrom(remote string) []string {
-	out := []string{}
-	for _, name := range t.names() {
-		if !t.hiddenFrom(name, remote) {
-			out = append(out, name)
-		}
-	}
-	return out
-}
-
 func (t *table) names() []string {
 	t.mu.RLock()
 	defer t.mu.RUnlock()
@@ -437,20 +343,7 @@ func run() error {
 	}
 
 	held := newTable()
-	// **The bus first, the file until it has spoken** (novox/hq ADR 0167). The membership carries
-	// the routes and who the mesh is; the file carries the routes alone, so while the proxy reads
-	// it an internal name is served to this machine and to nobody else — refused, never opened.
-	fromBus := &atomic.Bool{}
-	if credential := strings.TrimSpace(os.Getenv("MESH_BROKER_FILE")); credential != "" {
-		go followMembership(credential, held, fromBus)
-	} else {
-		log.Printf("MESH_BROKER_FILE is not set: routes come from %s alone, and a name that is only "+
-			"internal is served to this machine alone", path)
-	}
 	read := func() {
-		if fromBus.Load() {
-			return
-		}
 		routes, public, err := routesFrom(path)
 		if err != nil {
 			// Kept serving what it had. A file being rewritten is momentarily unreadable, and
@@ -529,7 +422,19 @@ func run() error {
 	}()
 
 	tlsConfig := publicManager.TLSConfig()
-	tlsConfig.GetCertificate = certificateFor(held, tlsConfig.GetCertificate, internalManager)
+	if internalManager != nil {
+		// Dispatched by which authority may certify this name at all — the same question
+		// eligibleForInternalACME already answers, asked once more at handshake time rather than
+		// only when an order is placed, since a cached certificate is served here on every request
+		// and never goes through HostPolicy again.
+		fromPublic, fromInternal := tlsConfig.GetCertificate, internalManager.TLSConfig().GetCertificate
+		tlsConfig.GetCertificate = func(hello *tls.ClientHelloInfo) (*tls.Certificate, error) {
+			if held.eligibleForInternalACME(hello.ServerName) {
+				return fromInternal(hello)
+			}
+			return fromPublic(hello)
+		}
+	}
 
 	server := &http.Server{
 		Addr:      secure,
@@ -687,33 +592,6 @@ func forThisAuthority(cache, directory string, root []byte) string {
 	return filepath.Join(cache, hex.EncodeToString(sum[:])[:16])
 }
 
-// certificateFor picks the certificate a handshake is answered with.
-//
-// Dispatched by which authority may certify this name at all — the same question
-// eligibleForInternalACME already answers, asked once more at handshake time rather than only when
-// an order is placed, since a cached certificate is served here on every request and never goes
-// through HostPolicy again. And refused, exactly as an unrouted name is, to a client outside the
-// private network asking for a name that is only internal: the certificate would name it.
-func certificateFor(held *table, fromPublic func(*tls.ClientHelloInfo) (*tls.Certificate, error),
-	internalManager *autocert.Manager) func(*tls.ClientHelloInfo) (*tls.Certificate, error) {
-	var fromInternal func(*tls.ClientHelloInfo) (*tls.Certificate, error)
-	if internalManager != nil {
-		fromInternal = internalManager.TLSConfig().GetCertificate
-	}
-	return func(hello *tls.ClientHelloInfo) (*tls.Certificate, error) {
-		if held.eligibleForInternalACME(hello.ServerName) {
-			if hello.Conn != nil && held.hiddenFrom(hello.ServerName, hello.Conn.RemoteAddr().String()) {
-				return nil, fmt.Errorf("no public route for %q in this mesh, so no certificate is asked for",
-					hello.ServerName)
-			}
-			if fromInternal != nil {
-				return fromInternal(hello)
-			}
-		}
-		return fromPublic(hello)
-	}
-}
-
 // newTable is an empty routing table.
 func newTable() *table {
 	return &table{to: map[string][]rule{}}
@@ -722,9 +600,8 @@ func newTable() *table {
 // handler is the proxy itself, separated so it can be driven by a test without a listener.
 func handler(held *table) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		hidden := held.hiddenFrom(r.Host, r.RemoteAddr)
 		matched, known := held.find(r.Host, r.URL.Path)
-		if hidden || !known {
+		if !known {
 			// **Named, not a bare 404.** A route that was withdrawn and a name that never existed
 			// are different things, and a proxy that says only "not found" makes an operator go
 			// and read the mesh to tell them apart. What it is serving is the answer to both.
@@ -732,20 +609,15 @@ func handler(held *table) http.Handler {
 			// And since a host may now be routed only on some paths, those are a third thing:
 			// saying "no route for this name" while listing that very name as served is a
 			// contradiction an operator would have to disbelieve the proxy to get past.
-			// **Said in the log as well as to the client.** A name this mesh does not serve, asked
-			// for from outside, is what a scanner does, and the machine's intrusion prevention reads
-			// this proxy's log for exactly that line (novox/hq ADR 0179): the address last, as the
-			// jail's filter expects it.
-			log.Printf("refused: no route for %q, asked from %s", r.Host, r.RemoteAddr)
 			w.Header().Set("Content-Type", "text/plain; charset=utf-8")
 			w.WriteHeader(http.StatusNotFound)
-			if !hidden && held.routed(r.Host) {
+			if held.routed(r.Host) {
 				fmt.Fprintf(w, "%s is served here, but no route covers %q.\n",
 					bareHost(r.Host), r.URL.Path)
 				return
 			}
 			fmt.Fprintf(w, "no route for %q in this mesh.\nserving: %s\n",
-				r.Host, strings.Join(held.namesSeenFrom(r.RemoteAddr), ", "))
+				r.Host, strings.Join(held.names(), ", "))
 			return
 		}
 
@@ -844,12 +716,6 @@ func boolByte(b bool) byte {
 // routesFrom reads what the mesh wrote and turns it into host → the rules for that host, and
 // which of those hosts is a public name — the second is `name`, ACME-eligible; a host reached
 // only through `internal-name` never appears there.
-//
-// **A route may carry either name, or both** (novox/hq ADR 0138). How far an endpoint reaches
-// decides which names the mesh composes, so an endpoint that reaches only the private network
-// arrives with an `internal-name` and no `name`. That is a whole route, not a malformed one: it is
-// served under its internal name and certified by the internal authority. Only a route with
-// neither name has nothing to be served under (novox/hq issue 191).
 func routesFrom(path string) (map[string][]rule, map[string]bool, error) {
 	raw, err := os.ReadFile(path)
 	if err != nil {
@@ -859,29 +725,17 @@ func routesFrom(path string) (map[string][]rule, map[string]bool, error) {
 	if err := json.Unmarshal(raw, &said); err != nil {
 		return nil, nil, err
 	}
-	routes, public := routesOf(said.Given)
-	return routes, public, nil
-}
 
-// routesOf turns what the mesh gave into host → the rules for that host, and which hosts are public
-// names — the same whether the contributions came in the file or in the membership.
-func routesOf(contributions []contribution) (map[string][]rule, map[string]bool) {
 	out := map[string][]rule{}
 	public := map[string]bool{}
-	for _, c := range contributions {
+	for _, c := range said.Given {
 		name, _ := c.Values["name"].(string)
-		name = strings.TrimSpace(name)
+		if name == "" {
-		internal, _ := c.Values["internal-name"].(string)
-		internal = strings.TrimSpace(internal)
-		if name == "" && internal == "" {
 			log.Printf("%s on %s asked for a route and named nothing; skipped", c.From, c.Node)
 			continue
 		}
-		// What the route is called in a log line: its public name when it has one.
+		host := strings.ToLower(name)
-		called := name
+		public[host] = true
-		if called == "" {
-			called = internal
-		}
 
 		made := rule{path: asPath(c.Values["path"])}
 		if p, ok := asWhole(c.Values["priority"]); ok {
@@ -898,7 +752,7 @@ func routesOf(contributions []contribution) (map[string][]rule, map[string]bool)
 			if looksLikeACredential(named) {
 				log.Printf("%s on %s declared route %q with a credential in the declaration rather "+
 					"than the name of a secret; the whole route is refused (novox/hq ADR 0108)",
-					c.From, c.Node, called)
+					c.From, c.Node, name)
 				continue
 			}
 			users, err := usersFrom(named)
@@ -916,7 +770,7 @@ func routesOf(contributions []contribution) (map[string][]rule, map[string]bool)
 			port, ok := asPort(c.Values["port"])
 			if !ok {
 				log.Printf("%s on %s asked for route %q and gave no usable port; skipped",
-					c.From, c.Node, called)
+					c.From, c.Node, name)
 				continue
 			}
 			// Where the mesh says that machine is. Empty means it is this one — a workload beside
@@ -937,7 +791,7 @@ func routesOf(contributions []contribution) (map[string][]rule, map[string]bool)
 			}
 			if scheme != "http" && scheme != "https" {
 				log.Printf("%s on %s asked for route %q with scheme %q, which is neither http "+
-					"nor https; skipped", c.From, c.Node, called, scheme)
+					"nor https; skipped", c.From, c.Node, name, scheme)
 				continue
 			}
 			made.insecure, _ = c.Values["insecure"].(bool)
@@ -948,7 +802,7 @@ func routesOf(contributions []contribution) (map[string][]rule, map[string]bool)
 				bytes, whole := asWhole(asked)
 				if !whole || bytes <= 0 {
 					log.Printf("%s on %s asked for route %q with a max-request-body of %v, which is "+
-						"not a whole positive number of bytes; skipped", c.From, c.Node, called, asked)
+						"not a whole positive number of bytes; skipped", c.From, c.Node, name, asked)
 					continue
 				}
 				made.maxRequestBody = int64(bytes)
@@ -956,24 +810,19 @@ func routesOf(contributions []contribution) (map[string][]rule, map[string]bool)
 			made.target = fmt.Sprintf("%s://%s:%d", scheme, at, port)
 		}
 
-		if name != "" {
-			host := strings.ToLower(name)
 		out[host] = append(out[host], made)
-			public[host] = true
-		}
 
-		// The internal-network name, the same rule under a second host — a predecessor proxy
+		// The internal-network alias, the same rule under a second host — a predecessor proxy
 		// answered both for one route, as a convenience (reaching a service over the VPN without a
 		// public TLS round trip), not as an access boundary; composing it here restores exactly
 		// that, nothing more. Absent whenever the node composed no internal name (novox/hq ADR
 		// 0056's internalDomain half) — the same "nothing to join a label to" case the public name
-		// already has. And the only name, when the endpoint reaches no further than the private
+		// already has.
-		// network.
+		if internal, _ := c.Values["internal-name"].(string); strings.TrimSpace(internal) != "" {
-		if internal != "" {
 			out[strings.ToLower(internal)] = append(out[strings.ToLower(internal)], made)
 		}
 	}
-	return out, public
+	return out, public, nil
 }
 
 // asWhole is any whole number the mesh wrote, whatever its magnitude.
@@ -1060,17 +909,3 @@ func asPort(v any) (int, bool) {
 	}
 	return 0, false
 }
-
-// towards proxies to one backend and tells it what the client asked: **X-Forwarded-Proto, -Host and
-// -For**, set from the request this proxy received. A backend that builds its own addresses — a forge
-// writing its clone URL into a page, a login redirect — otherwise sees the plain HTTP hop from this
-// proxy and writes `http://`, though every client reached it over TLS: Go refused the forge's module
-// path for exactly that on 2026-10-03, its import tag naming an http clone URL.
-// The standard library's NewSingleHostReverseProxy sets only X-Forwarded-For.
-func towards(where *url.URL) *httputil.ReverseProxy {
-	return &httputil.ReverseProxy{Rewrite: func(pr *httputil.ProxyRequest) {
-		pr.SetURL(where)
-		pr.Out.Host = pr.In.Host
-		pr.SetXForwarded()
-	}}
-}

examples/route-proxy/reach_test.go

@@ -1,206 +0,0 @@
-package main
-
-import (
-	"crypto/tls"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"strings"
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/broker"
-)
-
-// behind is a workload the proxy can send to, and a table routing one public name and one
-// internal-only name to it, with the mesh's machines as the membership would issue them.
-func behind(t *testing.T, mesh ...string) *table {
-	t.Helper()
-	workload := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		io.WriteString(w, "the workload")
-	}))
-	t.Cleanup(workload.Close)
-	at, _ := url.Parse(workload.URL)
-	host, port, _ := net.SplitHostPort(at.Host)
-
-	routes, public, err := routesFrom(write(t, fmt.Sprintf(`{"given":[
-	  {"from":"app","node":"anchor","at":%q,
-	   "values":{"name":"app.example","internal-name":"app.anchor.internal","port":%s}},
-	  {"from":"admin","node":"anchor","at":%q,
-	   "values":{"internal-name":"admin.anchor.internal","port":%s}}
-	]}`, host, port, host, port)))
-	if err != nil {
-		t.Fatal(err)
-	}
-	held := newTable()
-	inside, err := sourcesOf(mesh)
-	if err != nil {
-		t.Fatal(err)
-	}
-	held.setInside(inside)
-	held.set(routes, public)
-	return held
-}
-
-// askFrom is what the proxy answers a request for host coming from remote.
-func askFrom(held *table, host, remote string) (int, string) {
-	r := httptest.NewRequest(http.MethodGet, "http://"+host+"/", nil)
-	r.RemoteAddr = remote
-	w := httptest.NewRecorder()
-	handler(held).ServeHTTP(w, r)
-	return w.Code, w.Body.String()
-}
-
-// **An internal-only name is served to the private network and to nobody else** (novox/hq ADR
-// 0138, issue 191). The proxy answers public names on the same listeners, so without this a name
-// being internal kept nobody out: a request from the internet only had to carry it.
-func TestAnInternalOnlyNameIsServedOnlyInsideThePrivateNetwork(t *testing.T) {
-	held := behind(t, "10.10.0.1", "10.10.0.7")
-
-	if code, body := askFrom(held, "admin.anchor.internal", "10.10.0.7:51000"); code != http.StatusOK ||
-		body != "the workload" {
-		t.Errorf("a request from the private network was not served: %d %q", code, body)
-	}
-	if code, body := askFrom(held, "admin.anchor.internal", "127.0.0.1:51000"); code != http.StatusOK {
-		t.Errorf("a request from the machine itself was not served: %d %q", code, body)
-	}
-
-	code, body := askFrom(held, "admin.anchor.internal", "203.0.113.9:51000")
-	if code != http.StatusNotFound {
-		t.Fatalf("a request from outside the private network reached an internal-only name: %d %q",
-			code, body)
-	}
-	// Answered as a name never routed, and the list of what is served does not name it either —
-	// otherwise the refusal would tell an outsider exactly what to ask for from inside.
-	if strings.Contains(strings.SplitN(body, "\n", 2)[1], "admin.anchor.internal") {
-		t.Errorf("the refusal names the internal-only route to an outsider: %q", body)
-	}
-	if !strings.Contains(body, "app.example") {
-		t.Errorf("the refusal stopped listing the public names: %q", body)
-	}
-}
-
-// The internal name of a route that also has a public one is internal too: served inside, and to
-// an outsider only under the public name. Nothing is lost — the outsider has the public name — and a
-// name stays one thing whichever route it came from.
-func TestAnInternalAliasOfAPublicRouteIsServedInsideOnly(t *testing.T) {
-	held := behind(t, "10.10.0.1", "10.10.0.7")
-	if code, body := askFrom(held, "app.anchor.internal", "10.10.0.7:51000"); code != http.StatusOK {
-		t.Errorf("the internal alias stopped answering the private network: %d %q", code, body)
-	}
-	if code, _ := askFrom(held, "app.anchor.internal", "203.0.113.9:51000"); code != http.StatusNotFound {
-		t.Errorf("the internal alias was served to an outsider: %d", code)
-	}
-	if code, _ := askFrom(held, "app.example", "203.0.113.9:51000"); code != http.StatusOK {
-		t.Errorf("the public name was refused to an outsider: %d", code)
-	}
-}
-
-// Before a membership has said who the mesh is, only the machine itself is inside — refused to
-// everyone else, never served to everyone.
-func TestUntilTheMeshIsIssuedAnInternalOnlyNameIsServedToTheMachineAlone(t *testing.T) {
-	held := behind(t)
-	if code, _ := askFrom(held, "admin.anchor.internal", "10.10.0.7:51000"); code != http.StatusNotFound {
-		t.Errorf("an internal-only name was served with no private network said: %d", code)
-	}
-	if code, _ := askFrom(held, "admin.anchor.internal", "[::1]:51000"); code != http.StatusOK {
-		t.Errorf("an internal-only name was refused to the machine itself: %d", code)
-	}
-}
-
-type from struct {
-	net.Conn
-	remote net.Addr
-}
-
-func (c from) RemoteAddr() net.Addr { return c.remote }
-
-// The handshake refuses an internal-only name to an outsider too: the certificate would name it,
-// and serving it would answer the question the routing refuses to.
-func TestTheHandshakeRefusesAnInternalOnlyNameToAnOutsider(t *testing.T) {
-	held := behind(t, "10.10.0.1", "10.10.0.7")
-	served := &tls.Certificate{}
-	pick := certificateFor(held, func(*tls.ClientHelloInfo) (*tls.Certificate, error) { return served, nil }, nil)
-	hello := func(name, remote string) *tls.ClientHelloInfo {
-		addr, _ := net.ResolveTCPAddr("tcp", remote)
-		return &tls.ClientHelloInfo{ServerName: name, Conn: from{remote: addr}}
-	}
-
-	if _, err := pick(hello("admin.anchor.internal", "203.0.113.9:443")); err == nil {
-		t.Error("an outsider was handed a certificate for an internal-only name")
-	}
-	if got, err := pick(hello("admin.anchor.internal", "10.10.0.7:443")); err != nil || got != served {
-		t.Errorf("a client on the private network was refused: %v", err)
-	}
-	if got, err := pick(hello("app.example", "203.0.113.9:443")); err != nil || got != served {
-		t.Errorf("a public name was refused to an outsider: %v", err)
-	}
-}
-
-// The mesh is issued as machines' addresses; a range is read as well. One that does not parse is
-// refused rather than skipped, so a typo never quietly narrows or widens who is inside.
-func TestTheMeshIsReadAsAddressesAndRanges(t *testing.T) {
-	if _, err := sourcesOf([]string{"10.10.0.1", "not-an-address"}); err == nil {
-		t.Error("an entry that is not an address was accepted")
-	}
-	inside, err := sourcesOf([]string{"10.10.0.1", "fd00::1", "10.20.0.0/24"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	for remote, want := range map[string]bool{
-		"10.10.0.1:1":          true,
-		"[::ffff:10.10.0.1]:1": true,
-		"[fd00::1]:1":          true,
-		"10.20.0.200:1":        true,
-		"10.10.0.2:1":          false,
-		"192.168.1.10:1":       false,
-		"not-an-address":       false,
-	} {
-		if inside.holds(remote) != want {
-			t.Errorf("%s inside the mesh: got %v, want %v", remote, !want, want)
-		}
-	}
-}
-
-// What the mesh issues is what is served: the routes in the membership, internal names to the
-// machines it names (novox/hq ADR 0167).
-func TestAMembershipIsServedAsIssued(t *testing.T) {
-	held := newTable()
-	took := applyMembership(broker.Membership{
-		Receives: map[string]json.RawMessage{"route": json.RawMessage(`[
-		  {"from":"admin","node":"anchor","at":"anchor.internal",
-		   "values":{"internal-name":"admin.anchor.internal","port":8080}}]`)},
-		Mesh: []string{"10.10.0.7"},
-	}, held)
-	if !took {
-		t.Fatal("a membership carrying routes was not applied")
-	}
-	if code, _ := askFrom(held, "admin.anchor.internal", "10.10.0.7:1"); code == http.StatusNotFound {
-		t.Error("a machine the membership names was refused the internal-only route")
-	}
-	if code, _ := askFrom(held, "admin.anchor.internal", "10.10.0.9:1"); code != http.StatusNotFound {
-		t.Errorf("a machine the membership does not name was served the internal-only route: %d", code)
-	}
-}
-
-// A membership that says nothing about routes is one from a controller that does not issue them,
-// and changes nothing: the file stays the source rather than every route being withdrawn.
-func TestAMembershipWithoutRoutesLeavesTheFileServing(t *testing.T) {
-	held := behind(t, "10.10.0.7")
-	before := held.names()
-	if applyMembership(broker.Membership{Mesh: []string{"10.10.0.7"}}, held) {
-		t.Error("a membership without routes was taken as the source of routes")
-	}
-	if got := held.names(); strings.Join(got, ",") != strings.Join(before, ",") {
-		t.Errorf("a membership without routes changed what is served: %v, was %v", got, before)
-	}
-	if applyMembership(broker.Membership{
-		Receives: map[string]json.RawMessage{"route": json.RawMessage(`[]`)},
-		Mesh:     []string{"not-an-address"},
-	}, held) {
-		t.Error("a membership whose mesh cannot be read was applied")
-	}
-}

examples/route-proxy/routes_test.go

@@ -90,50 +90,6 @@ func TestARouteWithAnInternalNameIsReachableUnderBoth(t *testing.T) {
 	}
 }
 
-// A route whose endpoint reaches only the private network carries an internal name and no public
-// one (novox/hq ADR 0138), and is served under that name rather than skipped as naming nothing —
-// skipping it left every internal-only module unreachable by name (novox/hq issue 191).
-func TestARouteWithOnlyAnInternalNameIsServed(t *testing.T) {
-	routes, public, err := routesFrom(write(t, `{"given":[
-	  {"from":"app","node":"anchor","at":"anchor.internal",
-	   "values":{"internal-name":"App.Anchor.Internal","port":8443,"scheme":"https","insecure":true}}
-	]}`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if targetOf(routes, "app.anchor.internal") != "https://anchor.internal:8443" {
-		t.Fatalf("the internal-only route is not served: %v", routes)
-	}
-	if len(routes) != 1 {
-		t.Errorf("an internal-only route made hosts it never named: %v", routes)
-	}
-	if len(public) != 0 {
-		t.Errorf("an internal-only route made a name eligible for a public certificate: %v", public)
-	}
-
-	held := newTable()
-	held.set(routes, public)
-	if err := onlyInternalNamesTheMeshSaid(held)(context.Background(), "app.anchor.internal"); err != nil {
-		t.Errorf("the internal authority refused the internal-only route's name: %v", err)
-	}
-	if err := onlyWhatTheMeshSaid(held)(context.Background(), "app.anchor.internal"); err == nil {
-		t.Error("a public certificate was ordered for an internal-only name")
-	}
-}
-
-// A route with neither name has nothing to be served under, and is still skipped.
-func TestARouteWithNeitherNameIsSkipped(t *testing.T) {
-	routes, public, err := routesFrom(write(t, `{"given":[
-	  {"from":"app","node":"anchor","at":"anchor.internal","values":{"internal-name":"  ","port":8080}}
-	]}`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(routes) != 0 || len(public) != 0 {
-		t.Errorf("a route that named nothing was served: %v %v", routes, public)
-	}
-}
-
 // A route with no internal-name composed gets no second host — the ordinary case, unchanged.
 func TestARouteWithNoInternalNameGetsNoAlias(t *testing.T) {
 	routes, _, err := routesFrom(write(t, `{"given":[

internal/artifacts/store.go

@@ -1,99 +0,0 @@
-// Package artifacts speaks to the mesh's artifact store over its own door.
-//
-// Only what the mesh needs that nothing else does: letting go of something it put there
-// (novox/hq ADR 0189, issue 108). Pushing is the builder's, through the container runtime; reading
-// is every machine's, through its runtime. This is the one operation that belongs to the thing
-// holding the records, because it is the only one that is a decision rather than a transfer.
-package artifacts
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-)
-
-// Store is the artifact store at an address, as this machine reaches it.
-type Store struct {
-	// Address is `host:port` — the store as the caller reaches it now, composed and never
-	// recorded (novox/hq 04-ISSUES/102).
-	Address string
-	// HTTP is the client used; nil is a client with a modest timeout.
-	HTTP *http.Client
-}
-
-// Gone is the answer when the store does not hold it: the outcome wanted, already true.
-var Gone = fmt.Errorf("the store does not hold it")
-
-// LetGo asks the store to drop one artifact the mesh recorded making.
-//
-// Takes a reference as the mesh records it — `artifact-store://<module>/<artifact>@sha256:…` for
-// an image, `…/blobs/sha256:…` for an archive — because that is the identity every record uses,
-// and composes the address here at the moment of use.
-//
-// Returns Gone when the store answers that it does not have it. That is not a failure: the sweep
-// wants the artifact absent, and it is. It is distinguished from success only so a caller can say
-// which of the two happened.
-func (s Store) LetGo(ctx context.Context, reference string) error {
-	path, kept := catalogue.InArtifactStore(reference)
-	if !kept {
-		// Nothing the mesh put in its own store. Refused rather than attempted: composing a
-		// delete for a reference of unknown shape is how a sweep reaches something that is not
-		// the mesh's.
-		return fmt.Errorf("%s is not a reference into the mesh's artifact store", reference)
-	}
-	if s.Address == "" {
-		return fmt.Errorf("this mesh has no artifact store on its network to ask about %s", reference)
-	}
-	repository, kind, digest, err := split(path)
-	if err != nil {
-		return err
-	}
-	url := "http://" + s.Address + "/v2/" + repository + "/" + kind + "/" + digest
-
-	request, err := http.NewRequestWithContext(ctx, http.MethodDelete, url, nil)
-	if err != nil {
-		return err
-	}
-	client := s.HTTP
-	if client == nil {
-		client = &http.Client{Timeout: 30 * time.Second}
-	}
-	response, err := client.Do(request)
-	if err != nil {
-		return err
-	}
-	defer response.Body.Close()
-	switch response.StatusCode {
-	case http.StatusAccepted, http.StatusOK, http.StatusNoContent:
-		return nil
-	case http.StatusNotFound:
-		return Gone
-	case http.StatusMethodNotAllowed:
-		// The registry was started without deletion enabled. Said plainly, because the remedy is
-		// a setting on the store's module and not anything about this artifact.
-		return fmt.Errorf(
-			"the artifact store refuses deletion: its server was started without it enabled "+
-				"(REGISTRY_STORAGE_DELETE_ENABLED), so nothing can be collected until the store "+
-				"module is applied again (novox/hq ADR 0189). Asking about %s", reference)
-	default:
-		return fmt.Errorf("the artifact store answered %s for %s", response.Status, reference)
-	}
-}
-
-// split reads a recorded path into the repository, which endpoint names the thing, and the digest.
-//
-// Two shapes, which are the two the mesh records: `<repository>@sha256:<hex>` is a manifest, and
-// `<repository>/blobs/sha256:<hex>` is a blob.
-func split(path string) (repository, kind, digest string, err error) {
-	if before, after, ok := strings.Cut(path, "@sha256:"); ok {
-		return before, "manifests", "sha256:" + after, nil
-	}
-	if before, after, ok := strings.Cut(path, "/blobs/sha256:"); ok {
-		return before, "blobs", "sha256:" + after, nil
-	}
-	return "", "", "", fmt.Errorf("%q names nothing the store holds by digest", path)
-}

internal/artifacts/store_test.go

@@ -1,94 +0,0 @@
-package artifacts
-
-import (
-	"context"
-	"errors"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-)
-
-// Asking the store to let go of what the mesh no longer keeps (novox/hq ADR 0189, issue 108).
-//
-// A fake store records what it was asked to delete, so what is asserted is the mesh's decision
-// and the shape of the request — not the registry's behaviour, which is the registry's to test.
-
-func fakeStore(t *testing.T, answer int) (Store, *[]string) {
-	t.Helper()
-	var asked []string
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodDelete {
-			t.Errorf("the store was asked %s %s; collecting is a delete", r.Method, r.URL.Path)
-		}
-		asked = append(asked, r.URL.Path)
-		w.WriteHeader(answer)
-	}))
-	t.Cleanup(server.Close)
-	return Store{Address: strings.TrimPrefix(server.URL, "http://")}, &asked
-}
-
-func TestAnImageAndAnArchiveAreAskedForAtTheirOwnEndpoints(t *testing.T) {
-	// The two shapes the mesh records: a manifest by digest, and a blob by digest. They are
-	// different endpoints, and asking at the wrong one answers 404 — which this would then
-	// record as collected, leaving the bytes on disk for ever while the record says otherwise.
-	store, asked := fakeStore(t, http.StatusAccepted)
-	ctx := context.Background()
-
-	image := catalogue.ArtifactStoreScheme + "web/app@sha256:abc123"
-	archive := catalogue.ArtifactStoreScheme + "web/config/blobs/sha256:def456"
-	if err := store.LetGo(ctx, image); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.LetGo(ctx, archive); err != nil {
-		t.Fatal(err)
-	}
-	want := []string{"/v2/web/app/manifests/sha256:abc123", "/v2/web/config/blobs/sha256:def456"}
-	if len(*asked) != 2 || (*asked)[0] != want[0] || (*asked)[1] != want[1] {
-		t.Fatalf("the store was asked %v; want %v", *asked, want)
-	}
-}
-
-func TestAStoreThatDoesNotHaveItAnswersGone(t *testing.T) {
-	// The outcome wanted, already true. Told apart from success only so the sweep can say which
-	// happened; both are recorded, because retrying for ever is the thing to avoid.
-	store, _ := fakeStore(t, http.StatusNotFound)
-	err := store.LetGo(context.Background(), catalogue.ArtifactStoreScheme+"web/app@sha256:abc123")
-	if !errors.Is(err, Gone) {
-		t.Fatalf("a store that does not hold it answered %v, want Gone", err)
-	}
-}
-
-func TestAStoreWithDeletionOffSaysSoAndNamesTheRemedy(t *testing.T) {
-	// The registry answers 405 when it was started without deletion enabled. The remedy is a
-	// setting on the store's module, and saying "405" would send somebody to the wrong place.
-	store, _ := fakeStore(t, http.StatusMethodNotAllowed)
-	err := store.LetGo(context.Background(), catalogue.ArtifactStoreScheme+"web/app@sha256:abc123")
-	if err == nil {
-		t.Fatal("a store that refuses deletion was read as success")
-	}
-	if !strings.Contains(err.Error(), "REGISTRY_STORAGE_DELETE_ENABLED") {
-		t.Fatalf("the refusal does not name the remedy: %v", err)
-	}
-}
-
-func TestAReferenceThatIsNotTheMeshsOwnIsNeverAsked(t *testing.T) {
-	// The whole safety of the sweep is that it names only what the mesh recorded putting there.
-	// A reference of another shape — a vendor's image, a package version — is refused rather
-	// than composed into a delete somewhere that is not the mesh's store.
-	store, asked := fakeStore(t, http.StatusAccepted)
-	for _, reference := range []string{
-		"docker.io/library/registry@sha256:abc123",
-		"registry@sha256:abc123",
-		"1.4.2",
-	} {
-		if err := store.LetGo(context.Background(), reference); err == nil {
-			t.Errorf("%s was asked about; it is not a reference into the mesh's store", reference)
-		}
-	}
-	if len(*asked) != 0 {
-		t.Fatalf("the store was asked about %v", *asked)
-	}
-}

internal/broker/agreement_catalogue_test.go

@@ -67,7 +67,7 @@ func TestTheAgreementCheckCatchesASubscriptionThatMatchesNothing(t *testing.T) {
 	// An event published under a seat's name is real even though no module declares it as its own.
 	if bad := Disagreements(nil,
 		[]AConsumer{{Module: "watcher", Consumes: []string{"mesh-artifact-store.image.pushed"}}},
-		[]DeclaredSeat{{Name: "mesh-artifact-store", Emits: []string{"image.pushed"}}}); len(bad) != 0 {
+		[]DeclaredSeat{{Name: "the-artifact-store", Emits: []string{"image.pushed"}}}); len(bad) != 0 {
 		t.Fatalf("an event a seat emits was reported as matching nothing: %v", bad)
 	}
 }
@@ -234,13 +234,3 @@ func admitsSubject(pattern, subject []string) bool {
 	}
 	return len(pattern) == len(subject)
 }
-
-// The two packages name the runtime module separately — the broker's types stay free of the
-// catalogue's on purpose — so this is what holds them to one string. A rename that reached only one
-// side would compose a runtime principal for a module nobody assigns, silently, and leave the one
-// that is assigned with a module's own grants.
-func TestTheBrokerAndTheCatalogueAgreeOnTheRuntimeModule(t *testing.T) {
-	if RuntimeModule != catalogue.RuntimeModule {
-		t.Fatalf("the broker calls the runtime %q and the catalogue %q", RuntimeModule, catalogue.RuntimeModule)
-	}
-}

internal/broker/derived.go

@@ -40,13 +40,6 @@ type Consumer struct {
 	AckWaitSeconds int
 	// MaxDeliver before the message is dead-lettered; zero for the mesh's default.
 	MaxDeliver int
-	// MaxAckPending is how many deliveries the server lets stand unacknowledged at once; zero for
-	// the server's default, which is many. **One, for a consumer handled one at a time**
-	// (novox/hq issue 175): a handler that builds for minutes keeps its own message alive with a
-	// heartbeat, but everything handed over behind it times out unacknowledged and comes back —
-	// and a merge that came back rebuilt what it had just built, five times over on 2026-09-30.
-	// With one outstanding, the server holds the rest, and the heartbeat is keeping the message.
-	MaxAckPending int
 	Why        string
 }
 
@@ -144,18 +137,12 @@ func ConsumerFor(p Principal) (Consumer, bool) {
 	}, true
 }
 
-// HolderConsumerFor is the worker a seat's holders share on that seat's work queue.
+// HolderConsumerFor is the worker a seat's holder gets on that seat's work queue.
 //
-// **One worker for every holder, and each holder pulls one ask when it is idle** (novox/hq ADR
+// **A queue group even though the seat guarantees one holder.** The seat is *authority* — who may
-// 0190). The seat is *authority* — who may be the telegram sender — and the worker is *delivery*,
+// be the telegram sender — and the queue group is *delivery*. Tie delivery to the seat and the
-// kept separate so that relaxing one changes nothing about the other: a node-scoped seat has a
+// day somebody allows two holders for throughput, every message is processed twice with nothing
-// holder per machine, and all of them take from this one consumer, so the work is shared without
+// reporting it. Kept separate, relaxing one changes nothing about the other.
-// any holder knowing about the others. Pulled rather than pushed because a push consumer hands the
-// next ask to whichever subscriber the server picks, busy or not, and a pulled one is asked for by
-// a holder that has just become free. Which is also what ends the race issue 186 describes — asks
-// delivered behind the one being worked, expiring unacknowledged and dropped after the fifth
-// redelivery: nothing is delivered that nobody asked for. A long build keeps its own ask alive
-// (stillWorking); the ack wait is for a holder that died.
 func HolderConsumerFor(node, module string, seat DeclaredSeat) (Consumer, bool) {
 	if len(seat.Accepts) == 0 {
 		return Consumer{}, false
@@ -164,13 +151,11 @@ func HolderConsumerFor(node, module string, seat DeclaredSeat) (Consumer, bool)
 		Name:           "SEAT_" + upperSnake(seat.Name) + "_worker",
 		Stream:         seatStreamName(seat.Name),
 		Filters:        []string{"mesh.seat." + seat.Name + ".accept.>"},
+		Queue:          "holders",
 		AckWaitSeconds: 60,
 		MaxDeliver:     5,
-		// As many in flight as there are holders working, which pulling bounds by itself: a holder
+		Why: fmt.Sprintf("%s on %s holds %s; it acknowledges after the work is done, so a "+
-		// fetches one and fetches again only after it acknowledged. The server's default stands.
+			"crash mid-work redelivers rather than loses", module, node, seat.Name),
-		Why: fmt.Sprintf("%s on %s holds %s; every holder pulls one ask at a time from this worker "+
-			"and acknowledges after the work is done, so a crash mid-work redelivers rather than "+
-			"loses and an idle holder is the one that takes the next ask", module, node, seat.Name),
 	}, true
 }
 

internal/broker/derived_test.go

@@ -88,20 +88,15 @@ func TestAModuleThatConsumesNothingGetsNoConsumer(t *testing.T) {
 	}
 }
 
-// The seat is authority and the worker is delivery (novox/hq ADR 0190): one worker per seat, shared
+// The seat is authority and the queue group is delivery. Tie them together and the day somebody
-// by every holder and pulled from, so a second holder takes the next ask rather than a copy of the
+// allows two holders, every message is processed twice with nothing reporting it.
-// same one — which is what a queue group used to guard, and what pulling one durable gives outright.
+func TestAHoldersWorkerUsesAQueueGroupAnyway(t *testing.T) {
-func TestAHoldersWorkerIsOneSharedByItsHolders(t *testing.T) {
 	c, ok := HolderConsumerFor("one", "telegram", telegramSeat())
 	if !ok {
 		t.Fatal("the holder of a seat with inbound work got no worker")
 	}
-	two, _ := HolderConsumerFor("two", "telegram", telegramSeat())
+	if c.Queue == "" {
-	if c.Name != two.Name || c.Stream != two.Stream {
+		t.Fatal("the worker is not in a queue group, so a second holder would double-process")
-		t.Fatal("two holders got two workers, so each would process every ask")
-	}
-	if c.Push || c.Queue != "" {
-		t.Fatal("the worker is pushed, so the server would hand an ask to a busy holder")
 	}
 	if c.Stream != "SEAT_TELEGRAM_SENDER" {
 		t.Fatalf("the worker reads %q, not the seat's own stream", c.Stream)
@@ -158,24 +153,3 @@ func TestANodesDeclarationConsumerIsWhatItsOwnGrantAllows(t *testing.T) {
 	has(t, perms.Publish, "$JS.ACK.NODES."+c.Name+".>")
 	has(t, perms.Subscribe, c.Filters[0])
 }
-
-// Every holder of a seat shares one worker and pulls from it (novox/hq ADR 0190): no queue group
-// and no delivery subject, because a push consumer hands the next ask to whichever subscriber the
-// server picks, busy or not; and no cap of one in flight, because pulling bounds the asks in flight
-// by the holders that are free — which is what ended the race of issue 186, where asks delivered
-// behind the one being worked expired and were dropped.
-func TestAHoldersWorkerIsPulledByEveryHolder(t *testing.T) {
-	c, found := HolderConsumerFor("anchor", "build-agent", DeclaredSeat{Name: "node-build-agent", Accepts: []string{"build"}})
-	if !found {
-		t.Fatal("a seat that accepts work has no worker")
-	}
-	if c.Queue != "" || c.Push {
-		t.Fatalf("the worker is pushed (queue %q, push %v); a holder pulls when it is free", c.Queue, c.Push)
-	}
-	if c.MaxAckPending != 0 {
-		t.Fatalf("the worker caps asks in flight at %d; pulling bounds them by the holders working", c.MaxAckPending)
-	}
-	if c.Name != "SEAT_NODE_BUILD_AGENT_worker" || c.Stream != "SEAT_NODE_BUILD_AGENT" {
-		t.Fatalf("the worker is %s on %s; one per seat, shared by its holders", c.Name, c.Stream)
-	}
-}

internal/broker/invokes_test.go

@@ -1,106 +0,0 @@
-package broker
-
-import (
-	"strings"
-	"testing"
-)
-
-// A module that says it calls a tool may publish exactly that subject (novox/hq ADR 0152): the same
-// grant a person gets, derived the same way, so one list answers "what may this ask" for everybody.
-func TestAModuleMayAskOnlyTheToolsItInvokes(t *testing.T) {
-	perms, err := PermissionsFor(Principal{Kind: KindModule, Node: "desk", Module: "mesh-console",
-		Invokes: []string{"shop.price"}, PasswordHash: "x"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	has(t, perms.Publish, "mesh.mod.shop.tool.price")
-	hasNot(t, perms.Publish, "mesh.mod.shop.tool.refund")
-	hasNot(t, perms.Publish, "mesh.mod.*.tool.>")
-}
-
-// The console's grant: every tool, as one subject, and it reads as one.
-func TestAModuleInvokingEverythingMayAskAnyTool(t *testing.T) {
-	perms, err := PermissionsFor(Principal{Kind: KindModule, Node: "desk", Module: "mesh-console",
-		Invokes: []string{"*"}, PasswordHash: "x"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	has(t, perms.Publish, "mesh.mod.*.tool.>")
-}
-
-// **A grant to call widens nothing else.** A module that invokes may not publish an event it did not
-// declare, may not answer as another module, and subscribes nothing it did not consume — the
-// difference between the console and a person is that the console is on a machine, not that it may
-// do more.
-func TestInvokingGrantsNothingButTheCall(t *testing.T) {
-	perms, err := PermissionsFor(Principal{Kind: KindModule, Node: "desk", Module: "mesh-console",
-		Invokes: []string{"*"}, PasswordHash: "x"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, p := range perms.Publish {
-		if strings.Contains(p, ".event.") {
-			t.Errorf("a module that only invokes may publish %q, an event it never declared", p)
-		}
-		// A role's tools are tools (ADR 0132); a role's work queue and events are not.
-		if strings.HasPrefix(p, "mesh.seat.") && !strings.Contains(p, ".tool.") {
-			t.Errorf("a module that only invokes may publish %q, a seat it neither holds nor uses", p)
-		}
-	}
-	for _, s := range perms.Subscribe {
-		if strings.Contains(s, ".tool.") && !strings.HasPrefix(s, "mesh.mod.mesh-console.") {
-			t.Errorf("a module that invokes may subscribe %q, another module's tools", s)
-		}
-	}
-}
-
-// A module that declares no invokes calls nothing, which is every module but the console.
-func TestAModuleThatInvokesNothingCallsNothing(t *testing.T) {
-	perms, err := PermissionsFor(Principal{Kind: KindModule, Node: "one", Module: "shop",
-		Emits: []string{"order.placed"}, PasswordHash: "x"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, p := range perms.Publish {
-		if strings.Contains(p, ".tool.") {
-			t.Errorf("a module with no invokes may publish %q", p)
-		}
-	}
-}
-
-// The malformed entry is refused for a module as it is for a person, and in the same words.
-func TestAModulesToolGrantThatNamesNoToolIsRefused(t *testing.T) {
-	if _, err := PermissionsFor(Principal{Kind: KindModule, Node: "one", Module: "shop",
-		Invokes: []string{"telegram"}, PasswordHash: "x"}); err == nil {
-		t.Fatal("a grant naming a module but no tool was accepted")
-	}
-}
-
-// What a declaration says reaches the composed user, so a manifest's `invokes` is the grant.
-func TestADeclaredInvokeReachesTheComposedUser(t *testing.T) {
-	users, err := Users(Records{
-		Nodes:    []string{"desk"},
-		Assigned: map[string][]Declared{"desk": {{Module: "mesh-console", Invokes: []string{"*"}}}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	perms, err := PermissionsFor(users[len(users)-1])
-	if err != nil {
-		t.Fatal(err)
-	}
-	has(t, perms.Publish, "mesh.mod.*.tool.>")
-}
-
-// A module's tool is addressed two ways (novox/hq ADR 0159): to whichever instance answers, and to
-// the instance on one machine. A grant for the tool covers both and nothing wider.
-func TestInvokingAToolMayAddressTheMachineToo(t *testing.T) {
-	got, err := invokedSubjects([]string{"postgres.postgres_query"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	want := []string{"mesh.mod.postgres.tool.postgres_query", "mesh.mod.postgres.tool.postgres_query.*"}
-	if len(got) != 2 || got[0] != want[0] || got[1] != want[1] {
-		t.Fatalf("the grant is %v, want %v", got, want)
-	}
-}

internal/broker/jetstream.go

@@ -1,7 +1,6 @@
 package broker
 
 import (
-	"context"
 	"crypto/sha256"
 	"crypto/tls"
 	"crypto/x509"
@@ -13,7 +12,6 @@ import (
 	"time"
 
 	"github.com/nats-io/nats.go"
-	"github.com/nats-io/nats.go/jetstream"
 )
 
 // The JetStream side of the controller: the one place the mesh's streams and consumers are
@@ -146,7 +144,6 @@ func (j *JetStream) EnsureStream(s Stream) error {
 		MaxMsgsPerSubject: int64(s.MaxMsgsPerSubject),
 		Description:       s.Why,
 	}
-	want.AllowDirect = s.Direct
 	if s.Retention == RetentionLastPerSubject {
 		// Last-per-subject is a limits stream with one message kept per subject, not a
 		// retention policy of its own — the state shape, spelled the way the server spells it.
@@ -182,7 +179,6 @@ func (j *JetStream) EnsureConsumer(c Consumer) error {
 		AckPolicy:      nats.AckExplicitPolicy,
 		AckWait:        time.Duration(c.AckWaitSeconds) * time.Second,
 		MaxDeliver:     c.MaxDeliver,
-		MaxAckPending:  c.MaxAckPending,
 		DeliverGroup:   c.Queue,
 		DeliverSubject: "",
 		Description:    c.Why,
@@ -216,51 +212,6 @@ func (j *JetStream) EnsureConsumer(c Consumer) error {
 
 	switch have, err := j.js.ConsumerInfo(c.Stream, c.Name); {
 	case err == nil:
-		// **The controller owns the worker's shape, type included** (novox/hq issue 206). A holder
-		// built for a pull worker cannot bind a push one — `cannot pull subscribe to push based
-		// consumer` — and on 2026-10-03 the build machine rolled before the controller that would
-		// have redefined its worker, restarted on that for an hour, and nothing could build the
-		// controller that would have ended it. The server cannot change a consumer's type in place,
-		// so one of the wrong type is re-made: on a work queue nothing is lost, because what was
-		// acknowledged is gone from the stream and what was not is delivered again from the start.
-		// On any other stream a re-made consumer would replay what this one acknowledged (issue
-		// 156), so there it is said and left, and the person re-makes it knowing the cost.
-		if havePush, wantPush := have.Config.DeliverSubject != "", want.DeliverSubject != ""; havePush != wantPush {
-			shape := func(push bool) string {
-				if push {
-					return "push"
-				}
-				return "pull"
-			}
-			info, err := j.js.StreamInfo(c.Stream)
-			if err != nil {
-				return fmt.Errorf("asking about stream %s to re-make consumer %s: %w", c.Stream, c.Name, err)
-			}
-			if info.Config.Retention != nats.WorkQueuePolicy {
-				// **A stream that keeps its history is re-made from now on, never from the start.**
-				// Left for a hand, the hand re-makes it with the server's default — everything the
-				// stream holds — which on 2026-10-03 replayed every build ask since 1 October and
-				// re-registered nine modules from the past (novox/hq issue 207). What this consumer
-				// had not yet acknowledged is lost with it, and said: on a history stream that is
-				// the smaller cost, and the asks in flight are visible to whoever asked.
-				j.note("consumer %s on %s changes from %s to %s delivery on a stream that keeps its history: "+
-					"re-made to deliver from now on, so nothing this one acknowledged comes back (novox/hq issue "+
-					"207); %d ask(s) it had not acknowledged are not carried over and must be asked again",
-					c.Name, c.Stream, shape(havePush), shape(wantPush), have.NumPending+uint64(have.NumAckPending))
-				want.DeliverPolicy = nats.DeliverNewPolicy
-			} else {
-				j.note("consumer %s on %s changes from %s to %s delivery: re-made where it left off, nothing "+
-					"acknowledged comes back and nothing pending is lost (novox/hq issue 206); a holder bound to "+
-					"the old shape binds again", c.Name, c.Stream, shape(havePush), shape(wantPush))
-			}
-			if err := j.js.DeleteConsumer(c.Stream, c.Name); err != nil {
-				return fmt.Errorf("re-making consumer %s on %s as %s: %w", c.Name, c.Stream, shape(wantPush), err)
-			}
-			if _, err := j.js.AddConsumer(c.Stream, want); err != nil {
-				return fmt.Errorf("re-making consumer %s on %s as %s: %w", c.Name, c.Stream, shape(wantPush), err)
-			}
-			return nil
-		}
 		// Where an existing consumer starts is its history, not something an assertion may move:
 		// the server refuses a changed deliver policy outright. Carried across, so asserting twice
 		// is the no-op a restart depends on.
@@ -318,50 +269,3 @@ func retentionOf(r Retention) nats.RetentionPolicy {
 		return nats.LimitsPolicy
 	}
 }
-
-// EnsureBucket creates a module's bucket if it is absent and brings its options to match if it is
-// present (novox/hq ADR 0202).
-//
-// **An update, never a delete and recreate**, for the reason a stream is updated: recreating
-// discards what the bucket holds, and what a module's state holds is data. The mesh's caps are
-// asserted with the owner's options, so a bucket made by hand converges to them.
-func (j *JetStream) EnsureBucket(b Bucket) error {
-	history := b.History
-	if history == 0 {
-		history = 1
-	}
-	js, err := jetstream.New(j.conn)
-	if err != nil {
-		return err
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	if _, err := js.CreateOrUpdateKeyValue(ctx, jetstream.KeyValueConfig{
-		Bucket:       b.Bucket(),
-		Description:  b.Why(),
-		History:      uint8(history),
-		TTL:          time.Duration(b.TTLSeconds) * time.Second,
-		MaxValueSize: StateMaxValueBytes,
-		MaxBytes:     StateMaxBytes,
-		Storage:      jetstream.FileStorage,
-	}); err != nil {
-		return fmt.Errorf("asserting bucket %s: %w", b.Bucket(), err)
-	}
-	return nil
-}
-
-// BucketNames is every key-value bucket on the server, the mesh's and anybody else's.
-func (j *JetStream) BucketNames() ([]string, error) {
-	js, err := jetstream.New(j.conn)
-	if err != nil {
-		return nil, err
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	lister := js.KeyValueStoreNames(ctx)
-	var out []string
-	for name := range lister.Name() {
-		out = append(out, name)
-	}
-	return out, lister.Error()
-}

internal/broker/membership.go

@@ -1,149 +0,0 @@
-package broker
-
-import (
-	"encoding/json"
-	"sort"
-	"strings"
-)
-
-// What the mesh issues an assignment to serve and to reach (novox/hq ADR 0160).
-//
-// A module's code names its tools and its events; **where they land is the mesh's to decide**, and
-// it decided it twice — once in the runtime, once here, by one rule compiled into both. Now the
-// controller composes a membership for every module on every machine and publishes it to a subject
-// only that assignment reads; the runtime serves exactly what the membership says, and the account's
-// grant is the same composition read the other way. The shape issued today is the shape the mesh
-// already had, so nothing moves when a membership first arrives; only who decides it moves.
-
-// Membership is one assignment's subjects: what this instance of a module on this machine serves,
-// and what it may reach.
-type Membership struct {
-	Node   string `json:"node"`
-	Module string `json:"module"`
-	// Serves is every address a tool of this instance answers on. `{tool}` stands for the tool's
-	// own name, which the module knows and the mesh does not need to: the mesh issues the address,
-	// the runtime fills the name. An address with a queue is shared with the module's other
-	// instances, and the bus hands each call to one of them; an address without is this instance's.
-	Serves []Served `json:"serves"`
-	// Seats is every verb of a seat this instance holds, at the subject the seat's callers use.
-	Seats []SeatServed `json:"seats,omitempty"`
-	// Emits is where an event of this module lands; `{event}` stands for the event's name.
-	Emits string `json:"emits"`
-	// Reaches is each tool this module may call, `<module>.<tool>`, to the subjects that reach it:
-	// the first is whichever instance answers, when the mesh issued one; the rest name a machine.
-	Reaches map[string][]string `json:"reaches,omitempty"`
-	// Tools is where this instance answers what it serves — the runtime's one verb of its own.
-	Tools string `json:"tools"`
-	// Receives is what this assignment is given for each requirement it receives, by requirement:
-	// the contributions of every module that asked for it, as the catalogue composed them (novox/hq
-	// ADR 0167). The same list its received file is written from, so the two cannot disagree; a
-	// requirement nobody contributed to is an empty list, never absent. Kept as JSON because the
-	// catalogue owns the shape of a contribution and the bus only carries it.
-	Receives map[string]json.RawMessage `json:"receives,omitempty"`
-	// Mesh is every machine's address on the private network — what a rule saying "from the mesh"
-	// resolves to in the packet filter, issued here from the same list (novox/hq ADR 0167). A
-	// module that must tell the mesh from the world, the route proxy serving an internal name, reads
-	// it here rather than keeping a definition of its own.
-	Mesh []string `json:"mesh,omitempty"`
-	// State is every bucket this module's code may reach, by the name it uses for each, and whether
-	// it may write it (novox/hq ADR 0202): the runtime answers a bundle's state verbs from this list
-	// and refuses, with the reason, what is not on it — the bus enforces only the union over every
-	// module on the machine.
-	State []StateIssued `json:"state,omitempty"`
-}
-
-// Served is one address a tool is answered on.
-type Served struct {
-	Subject string `json:"subject"`
-	Queue   string `json:"queue,omitempty"`
-}
-
-// SeatServed is one verb of a held seat, where its callers ask.
-type SeatServed struct {
-	Seat    string `json:"seat"`
-	Verb    string `json:"verb"`
-	Subject string `json:"subject"`
-}
-
-// MembershipSubject is the one address a runtime derives for itself: where its own membership is
-// published, from the two names its credential carries. Everything else is in the membership.
-func MembershipSubject(node, module string) string {
-	return "mesh.assignment." + node + "." + module
-}
-
-// Placements is where every module runs, for deciding which instance answers for the module.
-type Placements struct {
-	// Nodes is each module's machines.
-	Nodes map[string][]string
-	// Interchangeable is each module whose definition says its instances are the same anywhere,
-	// so the module's plain subject is issued to all of them in one queue.
-	Interchangeable map[string]bool
-}
-
-// AnswersForTheModule says whether an instance of a module on one machine is issued the module's
-// plain subject: when it is the only instance, or when the definition says instances are
-// interchangeable. A stateful module on two machines gets only its machines' subjects, so a call
-// that names none reaches nothing rather than the wrong store.
-func (p Placements) AnswersForTheModule(module string) bool {
-	return len(p.Nodes[module]) <= 1 || p.Interchangeable[module]
-}
-
-// MembershipFor composes one assignment's membership from what it declared and where everything
-// runs. The subjects are the ones PermissionsFor grants, derived here once more only until the
-// grant itself is read from the membership — which is the next step, not this one.
-func MembershipFor(node string, d Declared, where Placements) Membership {
-	own := "mesh.mod." + d.Module
-	m := Membership{
-		Node: node, Module: d.Module,
-		Emits: own + ".event.{event}",
-		Tools: own + ".tool.tools",
-	}
-	// This machine's address always; the module's when this instance answers for the module.
-	m.Serves = append(m.Serves, Served{Subject: own + ".tool.{tool}." + node})
-	if where.AnswersForTheModule(d.Module) {
-		m.Serves = append(m.Serves, Served{Subject: own + ".tool.{tool}", Queue: "serve." + d.Module})
-	}
-	for _, s := range d.Holds {
-		for _, verb := range s.Serves {
-			m.Seats = append(m.Seats, SeatServed{Seat: s.Name, Verb: verb, Subject: seatToolSubject(s, verb, node)})
-		}
-	}
-	m.State = stateIssuedFor(d)
-	if len(d.Invokes) > 0 {
-		m.Reaches = map[string][]string{}
-		for _, t := range d.Invokes {
-			if t == "*" || strings.HasPrefix(t, "seat:") {
-				continue // every tool, or a role's: addressed by name, not resolved per instance
-			}
-			module, tool, ok := strings.Cut(t, ".")
-			if !ok {
-				continue
-			}
-			var reach []string
-			if where.AnswersForTheModule(module) {
-				reach = append(reach, "mesh.mod."+module+".tool."+tool)
-			}
-			nodes := append([]string{}, where.Nodes[module]...)
-			sort.Strings(nodes)
-			for _, n := range nodes {
-				reach = append(reach, "mesh.mod."+module+".tool."+tool+"."+n)
-			}
-			m.Reaches[t] = reach
-		}
-	}
-	return m
-}
-
-// PlacementsOf reads where everything runs from the records the bus's accounts are composed from.
-func PlacementsOf(r Records, interchangeable map[string]bool) Placements {
-	p := Placements{Nodes: map[string][]string{}, Interchangeable: interchangeable}
-	for node, declared := range r.Assigned {
-		for _, d := range declared {
-			p.Nodes[d.Module] = append(p.Nodes[d.Module], node)
-		}
-	}
-	for _, nodes := range p.Nodes {
-		sort.Strings(nodes)
-	}
-	return p
-}

internal/broker/membership_test.go

@@ -1,109 +0,0 @@
-package broker
-
-import (
-	"reflect"
-	"testing"
-)
-
-// The mesh issues an assignment's subjects (novox/hq ADR 0160): a module alone on one machine
-// answers for the module and for its machine; a stateful module on two machines answers only for
-// each machine; one that says its instances are interchangeable answers for the module everywhere;
-// a holder serves its seat's verbs; and what a module may reach is resolved the same way.
-func TestAMembershipIsIssuedFromWhereEverythingRuns(t *testing.T) {
-	records := Records{Assigned: map[string][]Declared{
-		"anchor": {
-			{Module: "postgres", Serves: []string{"query"}, Holds: []Seat{{Name: "mesh-store", Scope: "mesh", Serves: []string{"databases", "query"}}}},
-			{Module: "catalog", Invokes: []string{"postgres.query", "search.find"}},
-		},
-		"home-server": {
-			{Module: "postgres"},
-			{Module: "search"},
-			{Module: "dashboard", Invokes: []string{"postgres.query"}},
-		},
-		"laptop": {{Module: "search"}},
-	}, Interchangeable: map[string]bool{"search": true}}
-	where := PlacementsOf(records, records.Interchangeable)
-
-	pg := MembershipFor("anchor", records.Assigned["anchor"][0], where)
-	if !reflect.DeepEqual(pg.Serves, []Served{{Subject: "mesh.mod.postgres.tool.{tool}.anchor"}}) {
-		t.Fatalf("a stateful module on two machines answers only for its machine: %+v", pg.Serves)
-	}
-	if len(pg.Seats) != 2 || pg.Seats[0].Subject != "mesh.seat.mesh-store.tool.databases" {
-		t.Fatalf("the holder serves the seat's verbs at the seat's subjects: %+v", pg.Seats)
-	}
-	if pg.Emits != "mesh.mod.postgres.event.{event}" || pg.Tools != "mesh.mod.postgres.tool.tools" {
-		t.Fatalf("events and the tools verb: %+v", pg)
-	}
-
-	search := MembershipFor("laptop", records.Assigned["laptop"][0], where)
-	if !reflect.DeepEqual(search.Serves, []Served{
-		{Subject: "mesh.mod.search.tool.{tool}.laptop"},
-		{Subject: "mesh.mod.search.tool.{tool}", Queue: "serve.search"},
-	}) {
-		t.Fatalf("an interchangeable module answers for the module in the queue too: %+v", search.Serves)
-	}
-
-	dashboard := MembershipFor("home-server", records.Assigned["home-server"][2], where)
-	if !reflect.DeepEqual(dashboard.Serves, []Served{
-		{Subject: "mesh.mod.dashboard.tool.{tool}.home-server"},
-		{Subject: "mesh.mod.dashboard.tool.{tool}", Queue: "serve.dashboard"},
-	}) {
-		t.Fatalf("a module alone on one machine answers for the module: %+v", dashboard.Serves)
-	}
-	if !reflect.DeepEqual(dashboard.Reaches["postgres.query"],
-		[]string{"mesh.mod.postgres.tool.query.anchor", "mesh.mod.postgres.tool.query.home-server"}) {
-		t.Fatalf("reaching a stateful module names each machine and no plain subject: %v", dashboard.Reaches)
-	}
-	catalog := MembershipFor("anchor", records.Assigned["anchor"][1], where)
-	if !reflect.DeepEqual(catalog.Reaches["search.find"],
-		[]string{"mesh.mod.search.tool.find", "mesh.mod.search.tool.find.home-server", "mesh.mod.search.tool.find.laptop"}) {
-		t.Fatalf("reaching an interchangeable module offers the plain subject first: %v", catalog.Reaches)
-	}
-	if MembershipSubject("anchor", "postgres") != "mesh.assignment.anchor.postgres" {
-		t.Fatal("the one subject a runtime derives for itself")
-	}
-}
-
-func TestAnAccountMayReadItsOwnMembershipAndNoOthers(t *testing.T) {
-	perms, err := PermissionsFor(Principal{Kind: KindModule, Node: "anchor", Module: "postgres", PasswordHash: "x"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	has(t, perms.Subscribe, "mesh.assignment.anchor.postgres")
-	has(t, perms.Publish, "$JS.API.DIRECT.GET.ASSIGNMENTS.mesh.assignment.anchor.postgres")
-	hasNot(t, perms.Subscribe, "mesh.assignment.>")
-}
-
-// The runtime arriving on a machine changes nothing about what each module is issued (to-be 38 WP2):
-// the memberships are composed as before and the runtime reads several of them. What the machine's
-// user list gains is one runtime principal, and loses nothing but the runtime module's own.
-func TestTheRuntimeArrivingLeavesEveryMembershipAsItWas(t *testing.T) {
-	filter := Seat{Name: "node-packet-filter", Scope: "node", Serves: []string{"rules", "reload"}}
-	three := []Declared{
-		{Module: "nftables", Holds: []Seat{filter}, Serves: []string{"firewall_rules"}},
-		{Module: "zsh", Serves: []string{"execute"}},
-		{Module: "systemd", Serves: []string{"units"}},
-	}
-	before := Records{Nodes: []string{"anchor"}, Assigned: map[string][]Declared{"anchor": three}}
-	after := Records{Nodes: []string{"anchor"}, Assigned: map[string][]Declared{
-		"anchor": append(append([]Declared{}, three...), Declared{Module: RuntimeModule}),
-	}}
-	for _, d := range three {
-		was := MembershipFor("anchor", d, PlacementsOf(before, nil))
-		is := MembershipFor("anchor", d, PlacementsOf(after, nil))
-		if !reflect.DeepEqual(was, is) {
-			t.Errorf("%s's membership changed when the runtime arrived:\n%+v\n%+v", d.Module, was, is)
-		}
-	}
-	users, err := Users(after)
-	if err != nil {
-		t.Fatal(err)
-	}
-	kinds := map[Kind]int{}
-	for _, p := range users {
-		kinds[p.Kind]++
-	}
-	if kinds[KindNodeTools] != 1 || kinds[KindModule] != 3 || kinds[KindNode] != 1 || kinds[KindController] != 1 {
-		t.Errorf("the machine's users are %v; one runtime, the three modules, the host and the controller", kinds)
-	}
-}

internal/broker/nats.go

@@ -34,28 +34,12 @@ const (
 	// authority is a list of tools and nothing else — not control, not declarations, not builds,
 	// and no ability to answer anything, because a person asks.
 	KindPerson Kind = "person"
-	// KindNodeTools is a machine's tool runtime (novox/hq ADR 0175, to-be 38): one process per
-	// node, on the host side, serving every assigned module's tools and every held seat's verbs.
-	// Its authority is the union of what the modules it carries would each have had for their
-	// tools — and nothing of what they consume, because tools are what it runs, not reactions.
-	KindNodeTools Kind = "node-tools"
 )
 
-// RuntimeModule is the module that IS the node's tool runtime (novox/hq ADR 0175). Where it is
-// assigned, the mesh composes one runtime principal for the machine in place of that module's own,
-// and the per-module containers that served tools until then stop being the way tools reach a node.
-// Mirrored in the catalogue package, which the agreement test holds to the same string; one
-// constant, so a rename is one edit and the two packages cannot drift.
-const RuntimeModule = "node-tools"
-
 // Seat is a role on the bus as a principal relates to it: the subjects it accepts, and those it
 // emits (novox/hq ADR 0118, design 29 §5).
 type Seat struct {
 	Name     string
-	// Scope is where the seat has one holder. A node-scoped seat's tool carries the node in its
-	// subject, because one subject reaching six machines' holders is not an address
-	// (novox/hq ADR 0132, design 33 §4). Empty reads as mesh.
-	Scope    string
 	Accepts  []string
 	Emits    []string
 	Serves   []string
@@ -86,29 +70,14 @@ type Principal struct {
 	// a namespace no such module owns. Every service started and the graph stayed empty.
 	Watches []Seat
 
-	// Carries are the modules whose tools this principal serves, for a KindNodeTools principal
+	// Invokes are the tools a person may call, as `<module>.<tool>`; a single `*` is every tool,
-	// (novox/hq ADR 0175): every module assigned to its node, as each declares itself. Its
+	// for an administrator. Only meaningful for KindPerson.
-	// serving authority is the union of theirs — each module's own tool namespace and each held
-	// seat's verbs on this node — derived from the same declarations the modules' own principals
-	// are, so the runtime can serve nothing a module could not have served for itself.
-	Carries []Declared
-
-	// Invokes are the tools this principal may call, as `<module>.<tool>`; a single `*` is every
-	// tool. A person's whole authority (design 25 §7), and a module's only if its manifest says so
-	// (novox/hq ADR 0152) — the console's does, and nothing else's.
 	//
 	// **A list, not a role.** A person is not a module and holds no seat: nothing is addressed
 	// to them, nothing is delivered to them, and they have no durable consumer to acknowledge.
-	// What they have is permission to ask. A module that invokes gains exactly the same
+	// What they have is permission to ask.
-	// permission and nothing beside it.
 	Invokes []string
 
-	// State is the local names of the state this principal's module keeps, and Reads the state of
-	// others it reads as `<module>.<name>` (novox/hq ADR 0202): a bucket each, kept by the owner's
-	// instances and read by whoever declares it.
-	State []string
-	Reads []string
-
 	// PasswordHash is the bcrypt hash the mesh minted. The plaintext is sealed to the principal
 	// and never appears here: this file is written to a node's disk and read by a server, and a
 	// secret that can be read from a configuration file is a secret with a wider blast radius
@@ -116,13 +85,10 @@ type Principal struct {
 	PasswordHash string
 }
 
-// seatsTheControllerAsks are the roles the mesh's own flows submit work to. Named rather than
+// meshSeatsTheControllerUses are the roles the mesh's own flows submit work to. Named rather than
 // derived from the seat set: the controller is not a module and declares no `uses`, so its side of a
 // seat has to be stated, and a list is what makes "which roles does the mesh itself talk to" answerable.
-// Both build roles while the handover runs (novox/hq ADR 0190): the controller asks whichever has a
+var meshSeatsTheControllerUses = []string{"mesh-build-machine"}
-// holder, and the retired one has one until build-agent replaces the builder. The second entry
-// goes with the retired seat row.
-var seatsTheControllerAsks = []string{"node-build-agent", "mesh-build-machine"}
 
 // enrolmentPrefix is the space every enrolling node's user and inbox live under, so the one place the
 // controller may answer an enrolment is derived from the same constant the user is named from.
@@ -140,10 +106,7 @@ func (p Principal) Username() string {
 	switch p.Kind {
 	case KindPerson:
 		return "person." + p.Module
-	case KindModule, KindNodeTools:
+	case KindModule:
-		// The runtime is named exactly as the module it stands for would have been: the mesh
-		// issues its credential through the same path a module's takes (`module issue`), and
-		// that path knows the node and the module, not the kind.
 		return p.Node + "." + p.Module
 	case KindNode:
 		return "node." + p.Node
@@ -204,10 +167,8 @@ func PermissionsFor(p Principal) (Permissions, error) {
 	switch p.Kind {
 	case KindController:
 		// The controller owns the mesh's own traffic and the streams. It is the only writer of
-		// stream definitions (design 25 §3), so it alone reaches the JetStream API — and it alone
+		// stream definitions (design 25 §3), so it alone reaches the JetStream API.
-		// issues memberships (novox/hq ADR 0160), which it publishes into the assignments stream
+		pub = []string{"mesh.control.>", "mesh.node.>", "$JS.API.>"}
-		// after each push; refused by the server on 2026-10-01 until this line named them.
-		pub = []string{"mesh.control.>", "mesh.node.>", "mesh.assignment.>", "$JS.API.>"}
 		// **And where its consumers deliver.** A push consumer delivers on `_DELIVER.<its name>`,
 		// and a client bound to it subscribes exactly that; the server refused it for every
 		// principal the first time one bound a consumer (2026-09-28). Each kind below is granted
@@ -217,9 +178,7 @@ func PermissionsFor(p Principal) (Permissions, error) {
 		// Work the mesh's own flows submit to a role, and the outcomes they wait on (ADR 0121). A
 		// build is the one today: the controller asks, and reads the answer from the seat's event
 		// like the catalogue does — which is why no holder needs to publish into anybody's inbox.
-		// A node-scoped seat's work subject carries no node (novox/hq ADR 0190): the ask goes to
+		for _, seat := range meshSeatsTheControllerUses {
-		// the role, and whichever machine holding it is idle takes it.
-		for _, seat := range seatsTheControllerAsks {
 			pub = append(pub, "mesh.seat."+seat+".accept.>")
 		}
 		// **And what the mesh says it did** (novox/hq ADR 0134). The control plane states its own
@@ -236,15 +195,6 @@ func PermissionsFor(p Principal) (Permissions, error) {
 		// the new bus was refused the publish (2026-09-28).
 		pub = append(pub, "mesh.mod.*.tool.>")
 
-		// **And the mesh's own verbs, as the seat it holds** (novox/hq ADR 0132, ADR 0154):
-		// `status`, `push`, `assign` are the mesh-controller seat's tools, served by its holder. The
-		// whole verb namespace of its own seat rather than a list: the list is the seat's protocol,
-		// which this package mirrors rather than reads, and a verb the seat does not declare is a
-		// subject nothing publishes.
-		sub = append(sub, "mesh.seat."+ControllerSeat+".tool.>")
-		// And says so (novox/hq ADR 0197): it answers discovery for the seat it serves.
-		sub = append(sub, announcing(ControllerSeat)...)
-
 		// The two events it reacts to, and its ack subject on the stream they arrive from
 		// (streams.go). **Each named, not a pattern**: `mesh.mod.*.event.>` would make the
 		// controller a subscriber to every event in the mesh, and its permission list would stop
@@ -274,14 +224,18 @@ func PermissionsFor(p Principal) (Permissions, error) {
 	case KindPerson:
 		// Tools, and nothing else. Every subject a person may publish is a tool call; a person
 		// who could publish an event would be able to claim a module said something.
-		invoked, err := invokedSubjects(p.Invokes)
+		for _, t := range p.Invokes {
-		if err != nil {
+			if t == "*" {
-			return Permissions{}, err
+				pub = append(pub, "mesh.mod.*.tool.>")
+				continue
+			}
+			module, tool, ok := strings.Cut(t, ".")
+			if !ok {
+				return Permissions{}, fmt.Errorf(
+					"%q does not name a tool: a person invokes <module>.<tool>, or * for every one", t)
+			}
+			pub = append(pub, "mesh.mod."+module+".tool."+tool)
 		}
-		pub = append(pub, invoked...)
-		// And may ask what answers (novox/hq ADR 0197): a question every service answers about
-		// itself, its replies to the asker's own inbox.
-		pub = append(pub, discovering()...)
 
 	case KindEnrolment:
 		// A leaked token is useless for anything but enrolling: it cannot read a declaration, hear
@@ -338,29 +292,6 @@ func PermissionsFor(p Principal) (Permissions, error) {
 		// away — no other principal may subscribe this namespace, and a caller's authority is
 		// still granted per tool, by name, on the publish side.
 		sub = append(sub, own+".tool.>")
-		// It says what it serves (novox/hq ADR 0197): discovery for its own name and every seat it
-		// holds a verb of, answered by the runtime that serves them.
-		announced := []string{p.Module}
-		for _, s := range p.Holds {
-			if len(s.Serves) > 0 {
-				announced = append(announced, s.Name)
-			}
-		}
-		sub = append(sub, announcing(announced...)...)
-		// Its own membership (ADR 0160): the one subject a runtime derives for itself, read
-		// directly from the stream and followed live. Nothing else's.
-		sub = append(sub, MembershipSubject(p.Node, p.Module))
-		pub = append(pub, "$JS.API.DIRECT.GET."+AssignmentsStream+"."+MembershipSubject(p.Node, p.Module))
-
-		// 1b. The tools it calls, if its manifest says it calls any (novox/hq ADR 0152). The same
-		//     grant a person gets and derived the same way, so "what may this module ask" is
-		//     answered by the one list that answers it for everybody. Publish only: an answer
-		//     arrives on its own inbox, which every principal has below.
-		invoked, err := invokedSubjects(p.Invokes)
-		if err != nil {
-			return Permissions{}, err
-		}
-		pub = append(pub, invoked...)
 
 		// 2. What it consumes, by the emitter's own subject — an event is addressed to its
 		//    emitter, because the emitter's identity is the meaning (ADR 0118).
@@ -393,17 +324,13 @@ func PermissionsFor(p Principal) (Permissions, error) {
 
 		// 3. Seats it holds: full participation.
 		for _, s := range p.Holds {
-			// Taking work from the role's queue: the worker consumer every holder shares (asked
+			// Taking work from the role's queue: the worker consumer it binds (asked about,
-			// about, pulled from, acknowledged), on the seat's own stream (novox/hq ADR 0190). A
+			// delivered on, acknowledged), each on the seat's own stream. The first machine to
-			// holder pulls — asks the consumer for its next message, answered on its own inbox —
+			// take work over the new bus was refused the asking (2026-09-28).
-			// so what it needs is MSG.NEXT on that worker and nothing delivered to it. The first
-			// machine to take work over the new bus was refused the asking (2026-09-28).
 			worker := "SEAT_" + upperSnake(s.Name) + "_worker"
 			stream := seatStreamName(s.Name)
-			pub = append(pub,
+			sub = append(sub, "_DELIVER."+worker, "_DELIVER."+worker+".>")
-				"$JS.API.CONSUMER.INFO."+stream+"."+worker,
+			pub = append(pub, "$JS.API.CONSUMER.INFO."+stream+"."+worker, "$JS.ACK."+stream+"."+worker+".>")
-				"$JS.API.CONSUMER.MSG.NEXT."+stream+"."+worker,
-				"$JS.ACK."+stream+"."+worker+".>")
 			for _, a := range s.Accepts {
 				sub = append(sub, seatSubject(s, "accept", a))
 			}
@@ -411,7 +338,7 @@ func PermissionsFor(p Principal) (Permissions, error) {
 				pub = append(pub, seatSubject(s, "event", e))
 			}
 			for _, t := range s.Serves {
-				sub = append(sub, seatToolSubject(s, t, p.Node))
+				sub = append(sub, seatSubject(s, "tool", t))
 			}
 		}
 
@@ -423,89 +350,9 @@ func PermissionsFor(p Principal) (Permissions, error) {
 				pub = append(pub, seatSubject(s, "accept", a))
 			}
 			for _, t := range s.Serves {
-				pub = append(pub, seatToolSubject(s, t, "*"))
+				pub = append(pub, seatSubject(s, "tool", t))
 			}
 		}
-
-		// 5. Its state, and the state of others it reads (novox/hq ADR 0202): every one read and
-		//    watched, its own written too.
-		pub = append(pub, stateGrants(p.Module, p.State, p.Reads)...)
-
-	case KindNodeTools:
-		// **One process serves what every module on the machine would have served for itself**
-		// (novox/hq ADR 0175). Each carried module's whole tool namespace — the same grant that
-		// module's own principal has, for the same reason: the tools a module serves are what its
-		// code answers, and a list here would be a second copy of it. Each held seat's verbs on
-		// this node, as the holder's own principal would be granted them.
-		var serves []string
-		for _, d := range p.Carries {
-			if !safeSubject.MatchString(d.Module) {
-				return Permissions{}, fmt.Errorf(
-					"%q cannot be part of a subject: a permission is a subject pattern, and this would widen it", d.Module)
-			}
-			serves = append(serves, d.Module)
-			for _, s := range d.Holds {
-				serves = append(serves, s.Name)
-			}
-			own := "mesh.mod." + d.Module
-			sub = append(sub, own+".tool.>")
-			// A tool that emits an event is the module's code and emits under the module's name
-			// (ADR 0042); the runtime carrying that code may publish what the module declared it
-			// emits, and nothing it did not.
-			for _, e := range d.Emits {
-				pub = append(pub, own+".event."+e)
-			}
-			for _, s := range d.Holds {
-				for _, t := range s.Serves {
-					sub = append(sub, seatToolSubject(s, t, p.Node))
-				}
-			}
-		}
-		// Every assigned module's membership on this node (ADR 0160): one per module, read
-		// directly from the stream and followed live. This node's and no other's — the one token
-		// that varies is the module, so the pattern is the machine's own assignments.
-		sub = append(sub, "mesh.assignment."+p.Node+".*")
-		pub = append(pub, "$JS.API.DIRECT.GET."+AssignmentsStream+".mesh.assignment."+p.Node+".*")
-		// And every tool on the mesh (ADR 0175, decision 5): any node may call any tool on any
-		// node, as the console already could — the runtime is the console's serving mode.
-		invoked, err := invokedSubjects([]string{"*"})
-		if err != nil {
-			return Permissions{}, err
-		}
-		pub = append(pub, invoked...)
-		// It says what it serves and may ask what answers (novox/hq ADR 0197): the runtime answers
-		// discovery for each module and seat it carries, and the console it is asks the bus.
-		// One service per runtime process, named for the runtime: the bus lets a principal answer each
-		// request once, so the runtime announces everything it carries under its own name.
-		sub = append(sub, announcing(append([]string{RuntimeModule}, serves...)...)...)
-		pub = append(pub, discovering()...)
-		// **And it consumes for the modules it carries** (novox/hq ADR 0198, which changes ADR 0175's
-		// "it consumes nothing"): a module's long-running code is a bundle this runtime launches, and
-		// the runtime is its bus — it reads the module's own durable consumer and acknowledges what
-		// the module's code took. Exactly the grants the module's own principal has for that consumer,
-		// on its name and no other's: asking about it, pulling from it, acknowledging it. The
-		// consumer is still the controller's to make, from the module's own principal.
-		for _, d := range p.Carries {
-			own := Principal{Kind: KindModule, Node: p.Node, Module: d.Module, Emits: d.Emits,
-				Consumes: d.Consumes, Serves: d.Serves, Holds: d.Holds, Uses: d.Uses, Watches: d.Watches}
-			if _, consumes := ConsumerFor(own); !consumes {
-				continue
-			}
-			stream, durable := consumerStream(own), consumerDurable(own)
-			pub = append(pub,
-				"$JS.API.CONSUMER.INFO."+stream+"."+durable,
-				"$JS.API.CONSUMER.MSG.NEXT."+stream+"."+durable,
-				"$JS.ACK."+stream+"."+durable+".>")
-		}
-		// **And it keeps and reads state for the modules it carries** (novox/hq ADR 0202): the union
-		// of what each may do with a bucket — an owner's write, a reader's read. That one module's code
-		// does not write another's bucket through it is the runtime's to keep, from the membership
-		// each assignment is issued, as it keeps each module's events under that module's own name.
-		for _, d := range p.Carries {
-			pub = append(pub, stateGrants(d.Module, stateNames(d.State), d.Reads)...)
-		}
-		sub = unique(sub)
-		pub = unique(pub)
 	}
 
 	if p.Kind == KindPerson {
@@ -513,11 +360,6 @@ func PermissionsFor(p Principal) (Permissions, error) {
 		// consumer, because nothing is delivered to a person — they ask and are answered.
 		sub = append(sub, p.inbox())
 	}
-	if p.Kind == KindNodeTools {
-		// Its reply space, so the answers to what its tools call come back to it. No ack subject
-		// for the same reason a person has none: nothing is delivered to it.
-		sub = append(sub, p.inbox())
-	}
 
 	if p.Kind == KindModule || p.Kind == KindNode || p.Kind == KindController {
 		// Its own reply space, and nothing wider.
@@ -539,7 +381,7 @@ func PermissionsFor(p Principal) (Permissions, error) {
 		// A module answers what it was asked — a tool call reaches it on its own namespace, so the
 		// authority is bounded by having been asked — and so does the controller. A node and a
 		// person are never asked anything, and are granted nothing here.
-		AllowResponses: p.Kind == KindModule || p.Kind == KindController || p.Kind == KindNodeTools,
+		AllowResponses: p.Kind == KindModule || p.Kind == KindController,
 	}, nil
 }
 
@@ -558,18 +400,6 @@ func seatSubject(s Seat, kind, verb string) string {
 	return "mesh.seat." + s.Name + "." + kind + "." + verb
 }
 
-// seatToolSubject is where a role's tool is asked. Mesh-wide for a mesh-scoped seat; a node-scoped
-// seat carries the node it is asked of, because a flat subject would reach every machine's holder
-// and the queue group would silently pick a winner (novox/hq ADR 0132, design 33 §4). A holder
-// subscribes its own node's; a user publishes any node's (`*`) and names the machine in the subject.
-func seatToolSubject(s Seat, verb, node string) string {
-	base := seatSubject(s, "tool", verb)
-	if s.Scope == "node" && node != "" {
-		return base + "." + node
-	}
-	return base
-}
-
 // consumerStream and consumerDurable are the two halves of a consumer's identity, and they are
 // two functions because conflating them was a real bug.
 //
@@ -761,20 +591,6 @@ func ComposeAccounts(principals []Principal) (string, error) {
 	return b.String(), nil
 }
 
-// unique is a sorted list with each subject once. Two carried modules holding seats with the same
-// verb, or the runtime module itself carried beside the others, would otherwise write a grant twice
-// — harmless to the server, and noise in a file that is read as the mesh's authority model.
-func unique(values []string) []string {
-	sort.Strings(values)
-	out := values[:0]
-	for i, v := range values {
-		if i == 0 || v != values[i-1] {
-			out = append(out, v)
-		}
-	}
-	return out
-}
-
 func quoted(values []string) string {
 	if len(values) == 0 {
 		return ""
@@ -785,63 +601,3 @@ func quoted(values []string) string {
 	}
 	return strings.Join(out, ", ")
 }
-
-// invokedSubjects is the publish side of a grant to call tools: one subject per `<module>.<tool>`,
-// or the whole tool namespace for `*`. A person's authority and a module's `invokes` are both this
-// (novox/hq ADR 0152), so a malformed entry is refused in one place, before it could be widened into
-// something that happens to parse.
-func invokedSubjects(invokes []string) ([]string, error) {
-	var out []string
-	for _, t := range invokes {
-		if t == "*" {
-			// Every module's tools and every role's (novox/hq ADR 0132): a role's verb is a tool
-			// like any other, addressed to the seat instead of a module.
-			out = append(out, "mesh.mod.*.tool.>", "mesh.seat.*.tool.>")
-			continue
-		}
-		if rest, isSeat := strings.CutPrefix(t, "seat:"); isSeat {
-			// A role's tool, `seat:<seat>.<verb>`. Both address shapes, because the grant is
-			// written without knowing the seat's scope: a mesh seat's verb is flat and a node
-			// seat's carries the machine (design 33 §4).
-			seat, verb, ok := strings.Cut(rest, ".")
-			if !ok || seat == "" || verb == "" {
-				return nil, fmt.Errorf(
-					"%q does not name a role's tool: one invokes seat:<seat>.<verb>", t)
-			}
-			out = append(out, "mesh.seat."+seat+".tool."+verb, "mesh.seat."+seat+".tool."+verb+".*")
-			continue
-		}
-		module, tool, ok := strings.Cut(t, ".")
-		if !ok || module == "" || tool == "" {
-			return nil, fmt.Errorf(
-				"%q does not name a tool: one invokes <module>.<tool>, seat:<seat>.<verb>, or * for every one", t)
-		}
-		// Both ways a module's tool is addressed (novox/hq ADR 0159): to whichever instance
-		// answers, and to the instance on one machine, which is the same subject with the machine
-		// as its last token.
-		out = append(out, "mesh.mod."+module+".tool."+tool, "mesh.mod."+module+".tool."+tool+".*")
-	}
-	return out, nil
-}
-
-// announcing is what a principal that serves tools subscribes to answer the NATS services
-// protocol's discovery (novox/hq ADR 0197): the questions asked of every service, and those asked of
-// each name it serves — its own and no other's, so it cannot answer for a service it is not.
-func announcing(names ...string) []string {
-	out := []string{"$SRV.PING", "$SRV.INFO", "$SRV.STATS"}
-	for _, n := range names {
-		if !safeSubject.MatchString(n) {
-			continue
-		}
-		for _, verb := range []string{"PING", "INFO", "STATS"} {
-			out = append(out, "$SRV."+verb+"."+n, "$SRV."+verb+"."+n+".>")
-		}
-	}
-	return out
-}
-
-// discovering is what a principal publishes to ask what answers (novox/hq ADR 0197): the services
-// protocol's discovery requests, whose replies come to its own inbox.
-func discovering() []string {
-	return []string{"$SRV.PING", "$SRV.PING.>", "$SRV.INFO", "$SRV.INFO.>"}
-}

internal/broker/nats_test.go

@@ -71,18 +71,6 @@ func TestHoldingASeatIsTheMirrorOfUsingIt(t *testing.T) {
 	hasNot(t, perms.Publish, "mesh.seat.telegram-sender.accept.send")
 }
 
-// A build machine may say everything about a build as it happens (novox/hq ADR 0157): that it
-// started, and every line under the build's own id — the seat's `log.*` becomes a publish over
-// one token, so a reader follows one build by subject and the holder can name no other subject.
-func TestTheBuildMachineMaySayWhatItDoesUnderTheBuildsId(t *testing.T) {
-	seat := Seat{Name: "mesh-build-machine", Accepts: []string{"build"}, Emits: []string{"started", "built", "log.*"}}
-	perms, _ := PermissionsFor(Principal{Kind: KindModule, Node: "anchor", Module: "builder",
-		Holds: []Seat{seat}, PasswordHash: "x"})
-	has(t, perms.Publish, "mesh.seat.mesh-build-machine.event.started")
-	has(t, perms.Publish, "mesh.seat.mesh-build-machine.event.log.*")
-	hasNot(t, perms.Publish, "mesh.seat.mesh-build-machine.event.>")
-}
-
 // Without an ack permission a durable consumer never really consumes: every message it receives is
 // redelivered forever, refused by the permission list it already has (design 25 §4).
 func TestAModuleMayAckItsOwnDeliveriesAndNoOthers(t *testing.T) {
@@ -233,9 +221,7 @@ func TestAPersonReachesNothingButTools(t *testing.T) {
 	perms, _ := PermissionsFor(Principal{Kind: KindPerson, Module: "jo",
 		Invokes: []string{"*"}, PasswordHash: "x"})
 	for _, p := range perms.Publish {
-		// A tool call, or asking what answers (novox/hq ADR 0197) — a question every service
+		if !strings.Contains(p, ".tool.") {
-		// answers about itself, which claims nothing and controls nothing.
-		if !strings.Contains(p, ".tool.") && !strings.HasPrefix(p, "$SRV.") {
 			t.Errorf("a person may publish %q, which is not a tool call", p)
 		}
 	}
@@ -373,109 +359,3 @@ func TestAModulePullsItsOwnConsumerAndNoOthers(t *testing.T) {
 		}
 	}
 }
-
-// The runtime's authority is the union of what the modules it carries would have been granted for
-// their tools (novox/hq ADR 0175): every carried module's tool namespace, every held seat's verbs
-// on this node, every module's membership on this node, and a call to anything. Nothing it
-// consumes, because it reacts to nothing.
-func TestTheRuntimeServesTheUnionAndConsumesForItsModules(t *testing.T) {
-	filter := Seat{Name: "node-packet-filter", Scope: "node", Serves: []string{"rules", "reload"}}
-	p := Principal{Kind: KindNodeTools, Node: "anchor", Module: RuntimeModule, Carries: []Declared{
-		{Module: "nftables", Holds: []Seat{filter}, Serves: []string{"firewall_rules"}},
-		{Module: "zsh", Emits: []string{"shell.opened"}, Consumes: []string{"shop.order.placed"}},
-		{Module: RuntimeModule},
-	}}
-	perms, err := PermissionsFor(p)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, want := range []string{
-		"mesh.mod.nftables.tool.>", "mesh.mod.zsh.tool.>", "mesh.mod." + RuntimeModule + ".tool.>",
-		"mesh.seat.node-packet-filter.tool.rules.anchor", "mesh.seat.node-packet-filter.tool.reload.anchor",
-		"mesh.assignment.anchor.*",
-		"_INBOX.anchor." + RuntimeModule + ".>",
-	} {
-		if !contains(perms.Subscribe, want) {
-			t.Errorf("the runtime may not subscribe %s: %v", want, perms.Subscribe)
-		}
-	}
-	for _, want := range []string{
-		"mesh.mod.*.tool.>", "mesh.seat.*.tool.>",
-		"$JS.API.DIRECT.GET.ASSIGNMENTS.mesh.assignment.anchor.*",
-		"mesh.mod.zsh.event.shell.opened",
-	} {
-		if !contains(perms.Publish, want) {
-			t.Errorf("the runtime may not publish %s: %v", want, perms.Publish)
-		}
-	}
-	// It reads the consumer of every carried module that consumes — that module's, by its name, as
-	// the module's own principal could (novox/hq ADR 0198) — and of no module that consumes nothing.
-	for _, want := range []string{
-		"$JS.API.CONSUMER.INFO.EVENTS.anchor_zsh",
-		"$JS.API.CONSUMER.MSG.NEXT.EVENTS.anchor_zsh",
-		"$JS.ACK.EVENTS.anchor_zsh.>",
-	} {
-		if !contains(perms.Publish, want) {
-			t.Errorf("the runtime may not read zsh's consumer: %s missing from %v", want, perms.Publish)
-		}
-	}
-	for _, s := range perms.Publish {
-		if (strings.HasPrefix(s, "$JS.ACK.") || strings.Contains(s, "CONSUMER")) && !strings.Contains(s, "anchor_zsh") {
-			t.Errorf("the runtime was granted a consumer no carried module of it consumes on: %s", s)
-		}
-	}
-	// It pulls; nothing is pushed to it, and it subscribes no event subject directly.
-	for _, s := range perms.Subscribe {
-		if strings.Contains(s, ".event.") || strings.HasPrefix(s, "_DELIVER.") {
-			t.Errorf("the runtime was granted a delivery: %s", s)
-		}
-	}
-	if !perms.AllowResponses {
-		t.Error("the runtime answers what it is asked, and may not reply")
-	}
-	if _, needed := ConsumerFor(p); needed {
-		t.Error("a consumer would be made for the runtime itself; it reads its modules' consumers, never one of its own")
-	}
-	// Each subject once in each list: the file is read as the mesh's authority model. One subject may
-	// stand in both — the runtime answers discovery on `$SRV.INFO` and, as the console, asks it
-	// (novox/hq ADR 0197) — because subscribing and publishing are two different grants.
-	for _, list := range [][]string{perms.Subscribe, perms.Publish} {
-		seen := map[string]bool{}
-		for _, s := range list {
-			if seen[s] {
-				t.Errorf("%s is granted twice", s)
-			}
-			seen[s] = true
-		}
-	}
-}
-
-func contains(list []string, want string) bool {
-	for _, s := range list {
-		if s == want {
-			return true
-		}
-	}
-	return false
-}
-
-// A node-scoped seat's work is shared (novox/hq ADR 0190): its holder on any machine subscribes the
-// seat's one work subject, with no node in it, so holders on several machines read one queue. The
-// node token belongs to a seat's tools, which are asked of one machine (design 33 §4), not to its work.
-func TestANodeSeatsWorkSubjectCarriesNoNode(t *testing.T) {
-	seat := Seat{Name: "node-build-agent", Scope: "node", Accepts: []string{"build"}, Serves: []string{"status"}}
-	perms, err := PermissionsFor(Principal{Kind: KindModule, Node: "anchor", Module: "build-agent", Holds: []Seat{seat}})
-	if err != nil {
-		t.Fatal(err)
-	}
-	has(t, perms.Subscribe, "mesh.seat.node-build-agent.accept.build")
-	hasNot(t, perms.Subscribe, "mesh.seat.node-build-agent.accept.build.anchor")
-	// And its tools still carry the machine.
-	has(t, perms.Subscribe, "mesh.seat.node-build-agent.tool.status.anchor")
-	// The controller asks the role, not a machine.
-	controller, err := PermissionsFor(Principal{Kind: KindController})
-	if err != nil {
-		t.Fatal(err)
-	}
-	has(t, controller.Publish, "mesh.seat.node-build-agent.accept.>")
-}

internal/broker/seattools_test.go

@@ -1,57 +0,0 @@
-package broker
-
-import "testing"
-
-// A node-scoped seat's tool carries the node (novox/hq ADR 0132, design 33 §4): two nodes holding one
-// node-scoped seat derive two addresses, and a user of the seat may publish any node's.
-func TestTwoNodesHoldingOneNodeSeatDeriveTwoToolAddresses(t *testing.T) {
-	seat := Seat{Name: "node-dns-resolver", Scope: "node", Serves: []string{"lookup"}}
-	one, _ := PermissionsFor(Principal{Kind: KindModule, Node: "one", Module: "dnsmasq", Holds: []Seat{seat}, PasswordHash: "x"})
-	two, _ := PermissionsFor(Principal{Kind: KindModule, Node: "two", Module: "dnsmasq", Holds: []Seat{seat}, PasswordHash: "x"})
-	has(t, one.Subscribe, "mesh.seat.node-dns-resolver.tool.lookup.one")
-	has(t, two.Subscribe, "mesh.seat.node-dns-resolver.tool.lookup.two")
-	hasNot(t, one.Subscribe, "mesh.seat.node-dns-resolver.tool.lookup")
-	hasNot(t, one.Subscribe, "mesh.seat.node-dns-resolver.tool.lookup.two")
-
-	user, _ := PermissionsFor(Principal{Kind: KindModule, Node: "three", Module: "asker", Uses: []Seat{seat}, PasswordHash: "x"})
-	has(t, user.Publish, "mesh.seat.node-dns-resolver.tool.lookup.*")
-}
-
-// A mesh-scoped seat's tool stays flat: nothing about it changes.
-func TestAMeshSeatsToolIsAddressedToTheSeatAlone(t *testing.T) {
-	seat := Seat{Name: "git", Scope: "mesh", Serves: []string{"list_repos"}}
-	holder, _ := PermissionsFor(Principal{Kind: KindModule, Node: "one", Module: "gitea", Holds: []Seat{seat}, PasswordHash: "x"})
-	has(t, holder.Subscribe, "mesh.seat.git.tool.list_repos")
-	user, _ := PermissionsFor(Principal{Kind: KindModule, Node: "two", Module: "asker", Uses: []Seat{seat}, PasswordHash: "x"})
-	has(t, user.Publish, "mesh.seat.git.tool.list_repos")
-}
-
-// The controller serves its own seat's verbs and may answer them (novox/hq ADR 0154).
-func TestTheControllerServesItsSeatsToolsAndMayAnswer(t *testing.T) {
-	perms, err := PermissionsFor(Principal{Kind: KindController, PasswordHash: "x"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	has(t, perms.Subscribe, "mesh.seat.mesh-controller.tool.>")
-	if !perms.AllowResponses {
-		t.Fatal("the controller serves tools and may not answer one")
-	}
-}
-
-// A grant to every tool reaches a role's tools too, and a role's tool is granted by name.
-func TestAGrantReachesARolesTools(t *testing.T) {
-	all, _ := PermissionsFor(Principal{Kind: KindModule, Node: "desk", Module: "mesh-console", Invokes: []string{"*"}, PasswordHash: "x"})
-	has(t, all.Publish, "mesh.seat.*.tool.>")
-
-	one, err := PermissionsFor(Principal{Kind: KindPerson, Module: "jo", Invokes: []string{"seat:mesh-controller.status"}, PasswordHash: "x"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	has(t, one.Publish, "mesh.seat.mesh-controller.tool.status")
-	hasNot(t, one.Publish, "mesh.seat.mesh-controller.tool.push")
-	hasNot(t, one.Publish, "mesh.mod.*.tool.>")
-
-	if _, err := PermissionsFor(Principal{Kind: KindPerson, Module: "jo", Invokes: []string{"seat:mesh-controller"}, PasswordHash: "x"}); err == nil {
-		t.Fatal("a role grant naming no verb was accepted")
-	}
-}

internal/broker/state.go

@@ -1,169 +0,0 @@
-package broker
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-)
-
-// A module's state on the bus (novox/hq ADR 0202, design 32 §4, design 25 §3).
-//
-// A module names the state it keeps (`state`) and the state of others it reads (`reads`), and each
-// is a key-value bucket: the server's own last-per-subject stream with direct reads, delete markers
-// and watches, which is the state relationship the mesh already uses for declarations, opened to
-// modules. The controller creates every bucket from the catalogue — from registration, like a
-// seat's stream, so a reader may watch before the owner runs anywhere — and no module can.
-//
-// Pure, like everything else in this package that decides what the bus holds; jetstream.go is the
-// part that asks a server.
-
-// The mesh's caps on a bucket, the same for every module: a value is a piece of state, not a file,
-// and a bucket that grew without bound would be one module filling the bus's disk for everyone.
-const (
-	StateMaxValueBytes = 256 * 1024
-	StateMaxBytes      = 64 * 1024 * 1024
-)
-
-// A Bucket is one module's declared state as the bus holds it.
-type Bucket struct {
-	Module string
-	Name   string
-	// History is how many values a key keeps; zero is one.
-	History int
-	// TTLSeconds is how long a value lives; zero is until replaced or deleted.
-	TTLSeconds int
-}
-
-// BucketName is the bucket a module's state lives in: the module and the local name joined by an
-// underscore, which neither may contain, so two modules can never derive one bucket.
-func BucketName(module, name string) string { return module + "_" + name }
-
-// Bucket is this bucket's name on the bus.
-func (b Bucket) Bucket() string { return BucketName(b.Module, b.Name) }
-
-// Why is carried into the server's description of the bucket, so somebody reading the server's
-// own state finds whose it is and why it is kept.
-func (b Bucket) Why() string {
-	return fmt.Sprintf("%s's state %q (novox/hq ADR 0202): its current value per key, written by %s, "+
-		"read by whatever declares it reads it; kept when %s is unassigned, because it is data",
-		b.Module, b.Name, b.Module, b.Module)
-}
-
-// bucketOfRead is the bucket a read names, `<module>.<name>`, or false when it names none.
-func bucketOfRead(read string) (string, bool) {
-	at := strings.LastIndex(read, ".")
-	if at <= 0 || at == len(read)-1 {
-		return "", false
-	}
-	module, name := read[:at], read[at+1:]
-	if !safeSubject.MatchString(module) || !safeSubject.MatchString(name) {
-		return "", false
-	}
-	return BucketName(module, name), true
-}
-
-// stateGrants is what a principal publishes to reach the state its modules keep and read: for every
-// bucket, binding to it, reading a key directly, and an ordered consumer for listing and watching,
-// created and deleted on the bucket's own stream, with its flow control answered; for a bucket an
-// owner keeps, writing under the bucket's own subjects too.
-//
-// **Measured against a running server, 2026-10-04** (novox/hq research 024), and each one is there
-// because leaving it out failed: without STREAM.INFO nothing binds; without DIRECT.GET nothing is
-// read; without CONSUMER.CREATE no key is listed and nothing is watched; without CONSUMER.DELETE a
-// watch cannot be stopped and lingers on the server. A write outside these is refused by the server
-// — and reaches the writer as a timeout, not a refusal, which is why the runtime refuses first.
-func stateGrants(module string, keeps []string, reads []string) []string {
-	var out []string
-	read := func(bucket string) {
-		stream := "KV_" + bucket
-		out = append(out,
-			"$JS.API.STREAM.INFO."+stream,
-			"$JS.API.DIRECT.GET."+stream+".>",
-			"$JS.API.CONSUMER.CREATE."+stream+".>",
-			"$JS.API.CONSUMER.DELETE."+stream+".>",
-			"$JS.FC."+stream+".>")
-	}
-	for _, name := range keeps {
-		if !safeSubject.MatchString(name) {
-			continue
-		}
-		bucket := BucketName(module, name)
-		read(bucket)
-		out = append(out, "$KV."+bucket+".>")
-	}
-	for _, r := range reads {
-		if bucket, ok := bucketOfRead(r); ok {
-			read(bucket)
-		}
-	}
-	return out
-}
-
-// StateIssued is one bucket an assignment may reach, by the name its module uses for it: its own
-// state by the local name, another's as `<module>.<name>` (novox/hq ADR 0202).
-type StateIssued struct {
-	Name   string `json:"name"`
-	Bucket string `json:"bucket"`
-	Writes bool   `json:"writes,omitempty"`
-}
-
-// stateIssuedFor is every bucket a module's code may reach, as its membership lists them.
-func stateIssuedFor(d Declared) []StateIssued {
-	var out []StateIssued
-	for _, b := range d.State {
-		out = append(out, StateIssued{Name: b.Name, Bucket: BucketName(d.Module, b.Name), Writes: true})
-	}
-	for _, r := range d.Reads {
-		if bucket, ok := bucketOfRead(r); ok {
-			out = append(out, StateIssued{Name: r, Bucket: bucket})
-		}
-	}
-	return out
-}
-
-// stateNames is the local names of a module's own buckets.
-func stateNames(buckets []Bucket) []string {
-	out := make([]string, 0, len(buckets))
-	for _, b := range buckets {
-		out = append(out, b.Name)
-	}
-	return out
-}
-
-// A BucketAsserter is the part of a JetStream connection bucket assertion needs.
-type BucketAsserter interface {
-	// EnsureBucket creates the bucket if absent and brings its options to match if present, never
-	// discarding what it holds.
-	EnsureBucket(b Bucket) error
-	// BucketNames is every key-value bucket on the server.
-	BucketNames() ([]string, error)
-}
-
-// RaiseBuckets asserts every declared bucket and answers the buckets on the server that nothing
-// declares any more.
-//
-// **Those are reported, never removed** (novox/hq ADR 0202, ADR 0030): what a module stored is
-// data, and a manifest edited, a module renamed or a catalogue entry dropped is an ordinary day's
-// work that must not take data with it. Removing one is a person's act.
-func RaiseBuckets(a BucketAsserter, buckets []Bucket) (undeclared []string, err error) {
-	sorted := append([]Bucket(nil), buckets...)
-	sort.Slice(sorted, func(i, j int) bool { return sorted[i].Bucket() < sorted[j].Bucket() })
-	declared := map[string]bool{}
-	for _, b := range sorted {
-		if err := a.EnsureBucket(b); err != nil {
-			return nil, fmt.Errorf("asserting %s's state %q: %w", b.Module, b.Name, err)
-		}
-		declared[b.Bucket()] = true
-	}
-	names, err := a.BucketNames()
-	if err != nil {
-		return nil, fmt.Errorf("listing the bus's state: %w", err)
-	}
-	for _, n := range names {
-		if !declared[n] {
-			undeclared = append(undeclared, n)
-		}
-	}
-	sort.Strings(undeclared)
-	return undeclared, nil
-}

internal/broker/state_test.go

@@ -1,166 +0,0 @@
-package broker
-
-import (
-	"slices"
-	"strings"
-	"testing"
-
-	"github.com/nats-io/nats.go"
-)
-
-// The grants measured against a running server (novox/hq research 024): an owner reads and writes
-// its bucket, a reader only reads, and neither reaches any other bucket.
-func TestAnOwnerWritesItsStateAndAReaderOnlyReads(t *testing.T) {
-	owner, err := PermissionsFor(Principal{Kind: KindModule, Node: "one", Module: "claude-code",
-		State: []string{"servers"}, PasswordHash: "x"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, s := range []string{
-		"$KV.claude-code_servers.>",
-		"$JS.API.STREAM.INFO.KV_claude-code_servers",
-		"$JS.API.DIRECT.GET.KV_claude-code_servers.>",
-		"$JS.API.CONSUMER.CREATE.KV_claude-code_servers.>",
-		"$JS.API.CONSUMER.DELETE.KV_claude-code_servers.>",
-		"$JS.FC.KV_claude-code_servers.>",
-	} {
-		has(t, owner.Publish, s)
-	}
-	hasNot(t, owner.Publish, "$KV.>")
-	hasNot(t, owner.Publish, "$JS.API.>")
-
-	reader, err := PermissionsFor(Principal{Kind: KindModule, Node: "one", Module: "console",
-		Reads: []string{"claude-code.servers"}, PasswordHash: "x"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	has(t, reader.Publish, "$JS.API.DIRECT.GET.KV_claude-code_servers.>")
-	has(t, reader.Publish, "$JS.API.CONSUMER.CREATE.KV_claude-code_servers.>")
-	hasNot(t, reader.Publish, "$KV.claude-code_servers.>")
-	for _, s := range reader.Subscribe {
-		if s == "$KV.claude-code_servers.>" {
-			t.Fatalf("a reader subscribes the bucket's subjects directly: %v", reader.Subscribe)
-		}
-	}
-}
-
-// One runtime carries every module on its machine, so its grant is the union: the owner's write
-// where an owner is carried, a read where only a reader is.
-func TestTheRuntimeKeepsAndReadsStateForItsModules(t *testing.T) {
-	perms, err := PermissionsFor(Principal{Kind: KindNodeTools, Node: "one", Module: RuntimeModule,
-		Carries: []Declared{
-			{Module: "claude-code", State: []Bucket{{Module: "claude-code", Name: "servers"}},
-				Reads: []string{"licence-manager.bindings"}},
-			{Module: "audit"},
-		}, PasswordHash: "x"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	has(t, perms.Publish, "$KV.claude-code_servers.>")
-	has(t, perms.Publish, "$JS.API.DIRECT.GET.KV_licence-manager_bindings.>")
-	hasNot(t, perms.Publish, "$KV.licence-manager_bindings.>")
-}
-
-// A module with no state is granted nothing of any bucket — the composition of every module that
-// existed before this is unchanged.
-func TestAModuleWithNoStateReachesNoBucket(t *testing.T) {
-	perms, err := PermissionsFor(Principal{Kind: KindModule, Node: "one", Module: "billing",
-		Emits: []string{"order.placed"}, PasswordHash: "x"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, s := range perms.Publish {
-		if strings.HasPrefix(s, "$KV.") || strings.HasPrefix(s, "$JS.FC.") || strings.Contains(s, ".KV_") {
-			t.Fatalf("granted %q without declaring state", s)
-		}
-	}
-}
-
-// A read that names no bucket grants nothing rather than something that happens to parse.
-func TestAReadThatNamesNoBucketGrantsNothing(t *testing.T) {
-	if got := stateGrants("a", nil, []string{"nodot", "x.", ".y", "a.b>"}); len(got) != 0 {
-		t.Fatalf("granted %v for reads that name no bucket", got)
-	}
-}
-
-// The membership lists every bucket the module's code may reach, by the name the module uses for
-// it, and whether it may write it — the list the runtime refuses from.
-func TestAMembershipListsTheStateItsModuleMayReach(t *testing.T) {
-	m := MembershipFor("one", Declared{Module: "claude-code",
-		State: []Bucket{{Module: "claude-code", Name: "servers"}},
-		Reads: []string{"licence-manager.bindings"}}, Placements{})
-	want := []StateIssued{
-		{Name: "servers", Bucket: "claude-code_servers", Writes: true},
-		{Name: "licence-manager.bindings", Bucket: "licence-manager_bindings"},
-	}
-	if !slices.Equal(m.State, want) {
-		t.Fatalf("issued %+v, want %+v", m.State, want)
-	}
-	if none := MembershipFor("one", Declared{Module: "audit"}, Placements{}); none.State != nil {
-		t.Fatalf("a module with no state was issued %+v", none.State)
-	}
-}
-
-type buckets struct {
-	ensured []string
-	on      []string
-}
-
-func (b *buckets) EnsureBucket(x Bucket) error {
-	b.ensured = append(b.ensured, x.Bucket())
-	return nil
-}
-func (b *buckets) BucketNames() ([]string, error) { return b.on, nil }
-
-// Every declared bucket is asserted; one on the server that nothing declares is said, not removed.
-func TestRaisingStateReportsWhatNothingDeclares(t *testing.T) {
-	b := &buckets{on: []string{"claude-code_servers", "gone_old", "ours_by_hand"}}
-	undeclared, err := RaiseBuckets(b, []Bucket{{Module: "claude-code", Name: "servers"}, {Module: "a", Name: "b"}})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !slices.Equal(b.ensured, []string{"a_b", "claude-code_servers"}) {
-		t.Fatalf("asserted %v", b.ensured)
-	}
-	if !slices.Equal(undeclared, []string{"gone_old", "ours_by_hand"}) {
-		t.Fatalf("reported %v", undeclared)
-	}
-}
-
-// Against a real server: a bucket is created with the owner's options and the mesh's caps,
-// asserting it again changes nothing and keeps what it holds, and a changed option is brought to
-// match in place.
-func TestABucketIsAssertedInPlace(t *testing.T) {
-	js := aLiveBus(t)
-	b := Bucket{Module: "statetest", Name: "servers"}
-	if _, err := RaiseBuckets(js, []Bucket{b}); err != nil {
-		t.Fatalf("a real server refused a module's bucket: %v", err)
-	}
-	kv, err := js.Context().KeyValue(b.Bucket())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := kv.Put("all.one", []byte(`{"kept":true}`)); err != nil {
-		t.Fatal(err)
-	}
-	b.History = 3
-	if _, err := RaiseBuckets(js, []Bucket{b}); err != nil {
-		t.Fatalf("asserting the bucket again failed, so a restart would: %v", err)
-	}
-	got, err := kv.Get("all.one")
-	if err != nil || string(got.Value()) != `{"kept":true}` {
-		t.Fatalf("asserting again lost what the bucket held: %v %v", got, err)
-	}
-	status, err := kv.Status()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if status.History() != 3 {
-		t.Fatalf("history is %d, the owner declared 3", status.History())
-	}
-	if s, ok := status.(*nats.KeyValueBucketStatus); ok {
-		if c := s.StreamInfo().Config; c.MaxMsgSize != StateMaxValueBytes || c.MaxBytes != StateMaxBytes {
-			t.Fatalf("the mesh's caps are not on the bucket: value %d, bucket %d", c.MaxMsgSize, c.MaxBytes)
-		}
-	}
-}

internal/broker/streams.go

@@ -47,14 +47,8 @@ type Stream struct {
 	// Why is carried into the assertion so an operator reading the server's own state finds the
 	// reason there, rather than only in a repository they may not have.
 	Why string
-	// Direct lets a client read a subject's last message without a consumer, which is how a
-	// runtime reads its own membership with no JetStream API beyond one request (ADR 0160).
-	Direct bool
 }
 
-// AssignmentsStream holds every assignment's membership, the newest per subject.
-const AssignmentsStream = "ASSIGNMENTS"
-
 // MeshStreams is the foundation set, in the order a person reads it.
 //
 // **CONTROL names its subjects rather than taking `mesh.control.>`**, because heartbeats live
@@ -85,15 +79,7 @@ func MeshStreams() []Stream {
 				"n-1 by construction (issue 107)",
 		},
 		{
-			Name:      AssignmentsStream,
+			Name: "EVENTS",
-			Subjects:  []string{"mesh.assignment.*.*"},
-			Retention: RetentionLastPerSubject,
-			Direct:    true,
-			Why: "one membership per assignment, always the newest: what the mesh issued this module " +
-				"on this machine to serve and to reach (ADR 0160); read directly by the runtime it is for",
-		},
-		{
-			Name: EventsStream,
 			// A seat's own events ride here too: they are 1:many like any event, and the
 			// `event` token keeps them clear of both the seat's work queue (`accept`) and its
 			// tools (`tool`), which must not be persisted.
@@ -217,15 +203,10 @@ var ControllerFollows = []string{
 	// A build's outcome, which is the build-machine role's own event now (ADR 0121) rather than a
 	// message on the control branch. Same three audiences, one publish: whoever asked, this, and the
 	// catalogue.
-	seatEventSubject("node-build-agent", "built"),
+	seatEventSubject("mesh-build-machine", "built"),
 	// The forge's merges: what moved a source, so the mesh builds what that source produces
 	// without anybody telling it (novox/hq 04-ISSUES/131). Appended, because the index is a name.
 	moduleEventSubject("gitea", "pull.merged"),
-	// The retired build role's outcome too, while the handover runs (novox/hq ADR 0190): the one
-	// build machine keeps answering on its seat until build-agent replaces it, and the outcome that
-	// registers build-agent itself comes from there. Appended, for the same reason as above; goes
-	// with the retired seat row.
-	seatEventSubject("mesh-build-machine", "built"),
 }
 
 // moduleEventSubject is where one module's event lands. The same derivation PermissionsFor uses, so
@@ -239,9 +220,6 @@ func seatEventSubject(seat, verb string) string {
 	return "mesh.seat." + seat + ".event." + verb
 }
 
-// EventsStream holds every module's and every role's events, a build's log among them.
-const EventsStream = "EVENTS"
-
 // MeshConsumers is what the controller consumes, in the order a person reads it.
 //
 // **Unlimited redelivery on CONTROL, deliberately.** The store window's bound is the controller's,
@@ -266,13 +244,8 @@ func MeshConsumers() []Consumer {
 			Push:           true,
 			AckWaitSeconds: 30,
 			MaxDeliver:     5,
-			// One at a time (novox/hq issue 175): acting on a merge builds for minutes, and an
+			Why: "the two events the mesh's own controller reacts to; after max-deliver it " +
-			// announcement handed over behind it must wait on the server, not time out on the
+				"dead-letters, because an announcement it cannot act on will not become actionable",
-			// client and come back to be acted on again.
-			MaxAckPending: 1,
-			Why: "the two events the mesh's own controller reacts to, one at a time; after " +
-				"max-deliver it dead-letters, because an announcement it cannot act on will not " +
-				"become actionable",
 		},
 	}
 }

internal/broker/streams_test.go

@@ -126,7 +126,6 @@ func TestEachStreamCarriesTheRetentionItsShapeNeeds(t *testing.T) {
 		"CONTROL": RetentionWorkQueue,
 		"NODES":   RetentionLastPerSubject,
 		"EVENTS":  RetentionLimits,
-		"ASSIGNMENTS": RetentionLastPerSubject,
 	}
 	got := map[string]Retention{}
 	for _, s := range MeshStreams() {
@@ -261,14 +260,3 @@ func TestNoTwoConsumersDeliverOntoTheSameSubject(t *testing.T) {
 		seen[subject] = c.Name + " on " + c.Stream
 	}
 }
-
-// The controller's events consumer is handed one announcement at a time (novox/hq issue 175): a
-// merge's handler builds for minutes, and what is queued behind it must wait on the server rather
-// than time out on the client and be acted on twice.
-func TestTheControllerTakesOneAnnouncementAtATime(t *testing.T) {
-	for _, c := range MeshConsumers() {
-		if c.Stream == "EVENTS" && c.Name == ControllerName && c.MaxAckPending != 1 {
-			t.Fatalf("the events consumer may have %d outstanding; one announcement at a time", c.MaxAckPending)
-		}
-	}
-}

internal/broker/testdata/composed.conf

@@ -24,8 +24,8 @@ accounts {
     jetstream: enabled
     users = [
       { user: "controller", password: "$2a$11$cccccccccccccccccccccc", permissions: {
-        publish: { allow: ["$JS.ACK.CONTROL.controller.>", "$JS.ACK.EVENTS.controller.>", "$JS.API.>", "_INBOX.enrol.>", "mesh.assignment.>", "mesh.control.>", "mesh.mod.*.tool.>", "mesh.node.>", "mesh.seat.mesh-build-machine.accept.>", "mesh.seat.mesh-controller.event.applied", "mesh.seat.mesh-controller.event.built-before", "mesh.seat.mesh-controller.event.refused", "mesh.seat.node-build-agent.accept.>"] }
+        publish: { allow: ["$JS.ACK.CONTROL.controller.>", "$JS.ACK.EVENTS.controller.>", "$JS.API.>", "_INBOX.enrol.>", "mesh.control.>", "mesh.mod.*.tool.>", "mesh.node.>", "mesh.seat.mesh-build-machine.accept.>", "mesh.seat.mesh-controller.event.applied", "mesh.seat.mesh-controller.event.built-before", "mesh.seat.mesh-controller.event.refused"] }
-        subscribe: { allow: ["$JS.API.>", "$SRV.INFO", "$SRV.INFO.mesh-controller", "$SRV.INFO.mesh-controller.>", "$SRV.PING", "$SRV.PING.mesh-controller", "$SRV.PING.mesh-controller.>", "$SRV.STATS", "$SRV.STATS.mesh-controller", "$SRV.STATS.mesh-controller.>", "_DELIVER.controller", "_DELIVER.controller.>", "_INBOX.controller.>", "mesh.control.>", "mesh.mod.gitea.event.pull.merged", "mesh.mod.mesh-catalog.event.catching-up", "mesh.mod.mesh-catalog.event.upgraded", "mesh.seat.mesh-build-machine.event.built", "mesh.seat.mesh-controller.tool.>", "mesh.seat.node-build-agent.event.built"] }
+        subscribe: { allow: ["$JS.API.>", "_DELIVER.controller", "_DELIVER.controller.>", "_INBOX.controller.>", "mesh.control.>", "mesh.mod.gitea.event.pull.merged", "mesh.mod.mesh-catalog.event.catching-up", "mesh.mod.mesh-catalog.event.upgraded", "mesh.seat.mesh-build-machine.event.built"] }
         allow_responses: { max: 1, ttl: "1m" }
       } }
       { user: "enrol.one", password: "$2a$11$eeeeeeeeeeeeeeeeeeeeee", permissions: {
@@ -37,18 +37,18 @@ accounts {
         subscribe: { allow: ["_DELIVER.one", "_DELIVER.one.>", "_INBOX.node.one.>", "mesh.node.one.declare"] }
       } }
       { user: "one.telegram", password: "$2a$11$tttttttttttttttttttttt", permissions: {
-        publish: { allow: ["$JS.ACK.EVENTS.one_telegram.>", "$JS.ACK.SEAT_TELEGRAM_SENDER.SEAT_TELEGRAM_SENDER_worker.>", "$JS.API.CONSUMER.INFO.EVENTS.one_telegram", "$JS.API.CONSUMER.INFO.SEAT_TELEGRAM_SENDER.SEAT_TELEGRAM_SENDER_worker", "$JS.API.CONSUMER.MSG.NEXT.EVENTS.one_telegram", "$JS.API.CONSUMER.MSG.NEXT.SEAT_TELEGRAM_SENDER.SEAT_TELEGRAM_SENDER_worker", "$JS.API.DIRECT.GET.ASSIGNMENTS.mesh.assignment.one.telegram", "mesh.seat.telegram-sender.event.delivered", "mesh.seat.telegram-sender.event.failed"] }
+        publish: { allow: ["$JS.ACK.EVENTS.one_telegram.>", "$JS.ACK.SEAT_TELEGRAM_SENDER.SEAT_TELEGRAM_SENDER_worker.>", "$JS.API.CONSUMER.INFO.EVENTS.one_telegram", "$JS.API.CONSUMER.INFO.SEAT_TELEGRAM_SENDER.SEAT_TELEGRAM_SENDER_worker", "$JS.API.CONSUMER.MSG.NEXT.EVENTS.one_telegram", "mesh.seat.telegram-sender.event.delivered", "mesh.seat.telegram-sender.event.failed"] }
-        subscribe: { allow: ["$SRV.INFO", "$SRV.INFO.telegram", "$SRV.INFO.telegram.>", "$SRV.PING", "$SRV.PING.telegram", "$SRV.PING.telegram.>", "$SRV.STATS", "$SRV.STATS.telegram", "$SRV.STATS.telegram.>", "_INBOX.one.telegram.>", "mesh.assignment.one.telegram", "mesh.mod.telegram.tool.>", "mesh.seat.telegram-sender.accept.send"] }
+        subscribe: { allow: ["_DELIVER.SEAT_TELEGRAM_SENDER_worker", "_DELIVER.SEAT_TELEGRAM_SENDER_worker.>", "_INBOX.one.telegram.>", "mesh.mod.telegram.tool.>", "mesh.seat.telegram-sender.accept.send"] }
         allow_responses: { max: 1, ttl: "1m" }
       } }
       { user: "two.audit", password: "$2a$11$aaaaaaaaaaaaaaaaaaaaaa", permissions: {
-        publish: { allow: ["$JS.ACK.EVENTS.two_audit.>", "$JS.API.CONSUMER.INFO.EVENTS.two_audit", "$JS.API.CONSUMER.MSG.NEXT.EVENTS.two_audit", "$JS.API.DIRECT.GET.ASSIGNMENTS.mesh.assignment.two.audit"] }
+        publish: { allow: ["$JS.ACK.EVENTS.two_audit.>", "$JS.API.CONSUMER.INFO.EVENTS.two_audit", "$JS.API.CONSUMER.MSG.NEXT.EVENTS.two_audit"] }
-        subscribe: { allow: ["$SRV.INFO", "$SRV.INFO.audit", "$SRV.INFO.audit.>", "$SRV.PING", "$SRV.PING.audit", "$SRV.PING.audit.>", "$SRV.STATS", "$SRV.STATS.audit", "$SRV.STATS.audit.>", "_INBOX.two.audit.>", "mesh.assignment.two.audit", "mesh.mod.audit.tool.>", "mesh.mod.shop.event.order.placed"] }
+        subscribe: { allow: ["_INBOX.two.audit.>", "mesh.mod.audit.tool.>", "mesh.mod.shop.event.order.placed"] }
         allow_responses: { max: 1, ttl: "1m" }
       } }
       { user: "two.shop", password: "$2a$11$ssssssssssssssssssssss", permissions: {
-        publish: { allow: ["$JS.ACK.EVENTS.two_shop.>", "$JS.API.CONSUMER.INFO.EVENTS.two_shop", "$JS.API.CONSUMER.MSG.NEXT.EVENTS.two_shop", "$JS.API.DIRECT.GET.ASSIGNMENTS.mesh.assignment.two.shop", "mesh.mod.shop.event.order.placed", "mesh.seat.telegram-sender.accept.send"] }
+        publish: { allow: ["$JS.ACK.EVENTS.two_shop.>", "$JS.API.CONSUMER.INFO.EVENTS.two_shop", "$JS.API.CONSUMER.MSG.NEXT.EVENTS.two_shop", "mesh.mod.shop.event.order.placed", "mesh.seat.telegram-sender.accept.send"] }
-        subscribe: { allow: ["$SRV.INFO", "$SRV.INFO.shop", "$SRV.INFO.shop.>", "$SRV.PING", "$SRV.PING.shop", "$SRV.PING.shop.>", "$SRV.STATS", "$SRV.STATS.shop", "$SRV.STATS.shop.>", "_INBOX.two.shop.>", "mesh.assignment.two.shop", "mesh.mod.shop.tool.>"] }
+        subscribe: { allow: ["_INBOX.two.shop.>", "mesh.mod.shop.tool.>"] }
         allow_responses: { max: 1, ttl: "1m" }
       } }
     ]

internal/broker/users.go

@@ -31,12 +31,6 @@ type Declared struct {
 	Uses []Seat
 	// Watches are the seats whose events it consumes.
 	Watches []Seat
-	// Invokes are the tools it calls, `<module>.<tool>` or `*` (novox/hq ADR 0152).
-	Invokes []string
-	// State is the state it keeps, each a bucket its instances write (novox/hq ADR 0202).
-	State []Bucket
-	// Reads are other modules' state it reads, each `<module>.<name>` (novox/hq ADR 0202).
-	Reads []string
 }
 
 // Records is what composing a user list needs to know about the mesh, and nothing more.
@@ -51,9 +45,6 @@ type Records struct {
 	Enrolling []string
 	// People is each person's name against the tools they may invoke, `*` for an administrator.
 	People map[string][]string
-	// Interchangeable is each module whose definition says its instances are the same anywhere
-	// (ADR 0160), which decides whether the module's plain subject is issued to every instance.
-	Interchangeable map[string]bool
 }
 
 // Users is every user the composed file should contain, in the order it will be written.
@@ -66,32 +57,11 @@ func Users(r Records) ([]Principal, error) {
 
 	for _, node := range sortedCopy(r.Nodes) {
 		out = append(out, Principal{Kind: KindNode, Node: node})
-		// **Where the runtime is assigned, the machine gets one runtime principal in place of the
-		// runtime module's own** (novox/hq ADR 0175, to-be 38). It carries every module on the
-		// node: its serving grants are the union of theirs. Every other module keeps its own
-		// principal — a module still serving tools from its own container holds its own
-		// credential until it moves, and the two serve side by side in the meantime.
-		runtimeHere := false
 		for _, d := range r.Assigned[node] {
-			if d.Module == RuntimeModule {
-				runtimeHere = true
-			}
-		}
-		for _, d := range r.Assigned[node] {
-			if runtimeHere && d.Module == RuntimeModule {
-				continue
-			}
 			out = append(out, Principal{
 				Kind: KindModule, Node: node, Module: d.Module,
 				Emits: d.Emits, Consumes: d.Consumes, Serves: d.Serves,
-				Holds: d.Holds, Uses: d.Uses, Watches: d.Watches, Invokes: d.Invokes,
+				Holds: d.Holds, Uses: d.Uses, Watches: d.Watches,
-				State: stateNames(d.State), Reads: d.Reads,
-			})
-		}
-		if runtimeHere {
-			out = append(out, Principal{
-				Kind: KindNodeTools, Node: node, Module: RuntimeModule,
-				Carries: append([]Declared(nil), r.Assigned[node]...),
 			})
 		}
 	}

internal/broker/users_test.go

@@ -245,54 +245,3 @@ func TestAUserListIsComposedBeforeAnythingMovesOntoTheBus(t *testing.T) {
 		t.Errorf("the composed list does not contain the machine running the bus")
 	}
 }
-
-// Where the runtime module is assigned, the machine gets one runtime principal in place of the
-// runtime module's own (novox/hq ADR 0175, to-be 38). Every other module keeps its own: a module
-// still serving tools from its own container holds its own credential until it moves.
-func TestTheRuntimeModuleBecomesTheMachinesRuntimePrincipal(t *testing.T) {
-	r := someRecords()
-	r.Assigned["one"] = append(r.Assigned["one"], Declared{Module: RuntimeModule})
-	users, err := Users(r)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var runtime *Principal
-	for i := range users {
-		p := &users[i]
-		if p.Node == "one" && p.Module == RuntimeModule {
-			if p.Kind == KindModule {
-				t.Fatalf("%s on one was composed as an ordinary module beside the runtime", RuntimeModule)
-			}
-			runtime = p
-		}
-	}
-	if runtime == nil || runtime.Kind != KindNodeTools {
-		t.Fatalf("one runs %s and got no runtime principal: %v", RuntimeModule, namesOf(t, r))
-	}
-	if runtime.Username() != "one."+RuntimeModule {
-		t.Errorf("the runtime is named %q; `module issue` names it as the module it stands for", runtime.Username())
-	}
-	carried := map[string]bool{}
-	for _, d := range runtime.Carries {
-		carried[d.Module] = true
-	}
-	if !carried["telegram"] || !carried[RuntimeModule] {
-		t.Errorf("the runtime carries %v; it carries every module on its node", carried)
-	}
-	// And the other node, where the runtime is not assigned, is exactly as before.
-	for _, p := range users {
-		if p.Node == "two" && p.Kind == KindNodeTools {
-			t.Fatal("two runs no runtime and was given a runtime principal")
-		}
-	}
-	// A module serving its own tools beside the runtime keeps its own principal.
-	found := false
-	for _, p := range users {
-		if p.Kind == KindModule && p.Node == "one" && p.Module == "telegram" {
-			found = true
-		}
-	}
-	if !found {
-		t.Error("telegram lost its own principal when the runtime arrived on its node")
-	}
-}

internal/broker/worker_type_change_test.go

@@ -1,167 +0,0 @@
-package broker
-
-import (
-	"os"
-	"testing"
-	"time"
-
-	"github.com/nats-io/nats.go"
-)
-
-// A seat's worker that changed from push to pull delivery strands a holder built for the new shape
-// (novox/hq issue 206): the server refuses a pull subscription on a push consumer, and the controller
-// that would redefine it was the build that nobody could take. The controller owns the worker's
-// shape, type included: on a work queue it re-makes one of the wrong type, losing nothing, and a
-// pull subscription then binds and takes what was pending.
-//
-//	docker run -d --rm --name t -p 14231:4222 nats:2.10-alpine -js
-//	MESH_TEST_NATS=nats://127.0.0.1:14231 go test ./internal/broker/ -run TestAWorker
-func TestAWorkerOfTheWrongTypeIsRemadeOnAWorkQueueAndAPullThenBinds(t *testing.T) {
-	url := os.Getenv("MESH_TEST_NATS")
-	if url == "" {
-		t.Skip("MESH_TEST_NATS unset")
-	}
-	js, err := Dial(url)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer js.Close()
-
-	const stream, worker, filter = "SEAT_T_SHELF", "SEAT_T_SHELF_worker", "mesh.seat.t-shelf.accept.>"
-	_ = js.js.DeleteStream(stream)
-	if _, err := js.js.AddStream(&nats.StreamConfig{
-		Name: stream, Subjects: []string{filter}, Retention: nats.WorkQueuePolicy, Storage: nats.MemoryStorage,
-	}); err != nil {
-		t.Fatal(err)
-	}
-	defer func() { _ = js.js.DeleteStream(stream) }()
-
-	// The worker as the previous controller defined it: push, in a queue group.
-	if _, err := js.js.AddConsumer(stream, &nats.ConsumerConfig{
-		Durable: worker, AckPolicy: nats.AckExplicitPolicy, AckWait: 60 * time.Second, MaxDeliver: 5,
-		FilterSubject: filter, DeliverSubject: "_DELIVER." + worker, DeliverGroup: "holders",
-	}); err != nil {
-		t.Fatal(err)
-	}
-	for _, body := range []string{"one", "two", "three"} {
-		if _, err := js.js.Publish("mesh.seat.t-shelf.accept.build", []byte(body)); err != nil {
-			t.Fatal(err)
-		}
-	}
-	// The old holder took and acknowledged the first ask, then went away.
-	old, err := js.js.QueueSubscribeSync(filter, "holders", nats.Bind(stream, worker))
-	if err != nil {
-		t.Fatal(err)
-	}
-	m, err := old.NextMsg(twoSeconds)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(m.Data) != "one" {
-		t.Fatalf("the first ask is %q", m.Data)
-	}
-	if err := m.AckSync(); err != nil {
-		t.Fatal(err)
-	}
-	if err := old.Unsubscribe(); err != nil {
-		t.Fatal(err)
-	}
-
-	// The new controller asserts the worker as the mesh derives it now: pull.
-	if err := js.EnsureConsumer(Consumer{
-		Name: worker, Stream: stream, Filters: []string{filter}, AckWaitSeconds: 60, MaxDeliver: 5,
-		Why: "the test's worker",
-	}); err != nil {
-		t.Fatal(err)
-	}
-	have, err := js.js.ConsumerInfo(stream, worker)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if have.Config.DeliverSubject != "" || have.Config.DeliverGroup != "" {
-		t.Fatalf("the worker is still push: %+v", have.Config)
-	}
-
-	// A holder built for the new shape binds, and takes exactly what the old one left.
-	sub, err := js.js.PullSubscribe(filter, worker, nats.Bind(stream, worker), nats.ManualAck())
-	if err != nil {
-		t.Fatalf("a pull subscription does not bind the re-made worker: %v", err)
-	}
-	got, err := sub.Fetch(3, nats.MaxWait(twoSeconds))
-	if err != nil && len(got) == 0 {
-		t.Fatalf("nothing pending was delivered: %v", err)
-	}
-	var bodies []string
-	for _, g := range got {
-		bodies = append(bodies, string(g.Data))
-		_ = g.Ack()
-	}
-	if len(bodies) != 2 || bodies[0] != "two" || bodies[1] != "three" {
-		t.Fatalf("the pending asks after the acknowledged one, in order: %v", bodies)
-	}
-
-	// Asserted again, the pull worker is the no-op a restart depends on.
-	if err := js.EnsureConsumer(Consumer{
-		Name: worker, Stream: stream, Filters: []string{filter}, AckWaitSeconds: 60, MaxDeliver: 5,
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// On a stream that keeps its history, a worker of the wrong type is re-made to deliver from now on:
-// re-making it from the start would replay what it acknowledged (novox/hq issue 156), and leaving it
-// for a hand re-made it exactly that way on 2026-10-03 (issue 207).
-func TestAWorkerOfTheWrongTypeOnAHistoryStreamIsRemadeFromNowOn(t *testing.T) {
-	url := os.Getenv("MESH_TEST_NATS")
-	if url == "" {
-		t.Skip("MESH_TEST_NATS unset")
-	}
-	js, err := Dial(url)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer js.Close()
-	const stream, worker, filter = "EVENTS_T", "EVENTS_T_reader", "mesh.t.event.>"
-	_ = js.js.DeleteStream(stream)
-	if _, err := js.js.AddStream(&nats.StreamConfig{Name: stream, Subjects: []string{filter}, Storage: nats.MemoryStorage}); err != nil {
-		t.Fatal(err)
-	}
-	defer func() { _ = js.js.DeleteStream(stream) }()
-	if _, err := js.js.AddConsumer(stream, &nats.ConsumerConfig{
-		Durable: worker, AckPolicy: nats.AckExplicitPolicy, AckWait: 60 * time.Second,
-		FilterSubject: filter, DeliverSubject: "_DELIVER." + worker,
-	}); err != nil {
-		t.Fatal(err)
-	}
-	// History the old consumer would have acknowledged long ago, and must not come back.
-	for i := 0; i < 3; i++ {
-		if _, err := js.js.Publish("mesh.t.event.old", []byte("old")); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := js.EnsureConsumer(Consumer{Name: worker, Stream: stream, Filters: []string{filter}, AckWaitSeconds: 60}); err != nil {
-		t.Fatal(err)
-	}
-	have, err := js.js.ConsumerInfo(stream, worker)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if have.Config.DeliverSubject != "" {
-		t.Fatal("a history stream's consumer of the wrong type was left as it was")
-	}
-	if have.Config.DeliverPolicy != nats.DeliverNewPolicy || have.NumPending != 0 {
-		t.Fatalf("re-made consumer delivers %v with %d pending; it must deliver from now on with nothing of the past", have.Config.DeliverPolicy, have.NumPending)
-	}
-	// And what arrives from now on is delivered.
-	if _, err := js.js.Publish("mesh.t.event.new", []byte("new")); err != nil {
-		t.Fatal(err)
-	}
-	sub, err := js.js.PullSubscribe(filter, worker, nats.Bind(stream, worker))
-	if err != nil {
-		t.Fatal(err)
-	}
-	got, err := sub.Fetch(1, nats.MaxWait(3*time.Second))
-	if err != nil || len(got) != 1 || string(got[0].Data) != "new" {
-		t.Fatalf("the re-made consumer delivered %v, %v; want the one new message", got, err)
-	}
-}

internal/builder/binary_name_test.go

@@ -1,44 +0,0 @@
-package builder
-
-import (
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-)
-
-// The name a machine runs a binary by is not always the name of the package that built it. The host's
-// command is cmd/mesh-host and every machine runs it as nox-mesh-host — the path it is installed at,
-// the name in its unit, and the name its launcher looks for inside a delivered version.
-//
-// A bundle carrying the package's name was delivered to a machine correctly, reported "created … 1
-// file(s)", and was invisible to the launcher (novox/hq 04-ISSUES/142). Found by reading the delivered
-// directory rather than by trusting the line that said it worked.
-
-func TestACompiledArtifactNamesTheBinaryAMachineWillRun(t *testing.T) {
-	got := binaryName(catalogue.Artifact{
-		Name: "host-arch", From: "cmd/mesh-host", Binary: "nox-mesh-host",
-	})
-	if got != "nox-mesh-host" {
-		t.Fatalf("the binary is named %q, and the launcher looks for nox-mesh-host", got)
-	}
-}
-
-func TestSayingNothingKeepsWhatTheCompilerWouldHaveChosen(t *testing.T) {
-	// go build names its output after the package, so an artifact that says nothing gets the same
-	// thing it got before this existed.
-	if got := binaryName(catalogue.Artifact{Name: "host-arch", From: "cmd/mesh-host"}); got != "mesh-host" {
-		t.Fatalf("an artifact naming no binary produced %q", got)
-	}
-	if got := binaryName(catalogue.Artifact{Name: "host-arch", From: "./cmd/agent/"}); got != "agent" {
-		t.Fatalf("a from with slashes produced %q", got)
-	}
-}
-
-func TestABundleBuiltFromTheModuleRootFallsBackToItsArtifactName(t *testing.T) {
-	// A single-command repository names no package, and `go build -o <dir>` would then write a file
-	// named after the module directory — which is not something the manifest states. The artifact's
-	// own name is what the manifest does state.
-	if got := binaryName(catalogue.Artifact{Name: "tool"}); got != "tool" {
-		t.Fatalf("a bundle built from the root produced %q", got)
-	}
-}

internal/builder/builder.go

@@ -90,13 +90,7 @@ type GitCredential struct {
 // records — reachable, unreferenced, and indistinguishable from something in use.
 func Build(ctx context.Context, run Runner, publish Publisher,
 	repository, path, ref, workspace string, held map[string]string, npmrc Npmrc,
-	forge GitCredential, log Log, seats ...map[string]string) (Result, error) {
+	forge GitCredential, log Log) (Result, error) {
-	// The clone base of each seat a context may name (novox/hq ADR 0155); variadic so the callers
-	// that hand none — tests of everything but contexts — read as they did.
-	var seatBases map[string]string
-	if len(seats) > 0 {
-		seatBases = seats[0]
-	}
 
 	say := logging(log)
 	say("clone", "%s%s at %s", repository, describePath(path), refOrHead(ref))
@@ -215,7 +209,7 @@ func Build(ctx context.Context, run Runner, publish Publisher,
 		sort.Slice(artifacts, func(i, j int) bool { return artifacts[i].Name < artifacts[j].Name })
 		for _, a := range artifacts {
 			say("artifact", "%s (%s%s) — starting", a.Name, a.Kind, langSuffix(a))
-			made, err := one(ctx, run, publish, manifest.Module, within, workspace, commit, credentials, a, args, held, npmrcPath, npmrc, seatBases, say)
+			made, err := one(ctx, run, publish, manifest.Module, within, workspace, commit, credentials, a, args, held, npmrcPath, say)
 			if err != nil {
 				say("artifact", "%s FAILED: %v", a.Name, err)
 				return Result{}, err
@@ -252,18 +246,14 @@ func logging(log Log) func(step, format string, args ...any) {
 // module's own repository — a fresh tree, the same way the module's own is, keyed by artifact
 // name so two artifacts of one module naming different contexts do not collide.
 func contextFrom(ctx context.Context, run Runner, workspace, artifact, credentials string,
-	from catalogue.ArtifactContext, seats map[string]string, say func(step, format string, args ...any)) (string, error) {
+	from catalogue.ArtifactContext, say func(step, format string, args ...any)) (string, error) {
-	url, err := contextURL(from, seats)
+	say("context", "cloning %s at %s for %s", from.Repository, refOrHead(from.Ref), artifact)
-	if err != nil {
-		return "", err
-	}
-	say("context", "cloning %s at %s for %s", url, refOrHead(from.Ref), artifact)
 	dir := filepath.Join(workspace, "context-"+artifact)
 	if err := os.RemoveAll(dir); err != nil {
 		return "", err
 	}
-	if _, err := run(ctx, workspace, "git", cloneWith(credentials, "clone", "--quiet", url, dir)...); err != nil {
+	if _, err := run(ctx, workspace, "git", cloneWith(credentials, "clone", "--quiet", from.Repository, dir)...); err != nil {
-		return "", fmt.Errorf("cannot clone %s: %w", url, err)
+		return "", fmt.Errorf("cannot clone %s: %w", from.Repository, err)
 	}
 	if from.Ref != "" {
 		if _, err := run(ctx, dir, "git", "checkout", "--quiet", from.Ref); err != nil {
@@ -274,23 +264,6 @@ func contextFrom(ctx context.Context, run Runner, workspace, artifact, credentia
 	return dir, nil
 }
 
-// contextURL is what a context is cloned from: its URL, or — for a context on a seat — the seat's
-// clone base the mesh sent with the request joined to the repository's path (novox/hq ADR 0155).
-// Refused, never guessed, when the mesh sent no base for that seat: a builder that guessed a forge
-// would be the literal this removes, one layer down.
-func contextURL(from catalogue.ArtifactContext, seats map[string]string) (string, error) {
-	if from.Seat == "" {
-		return from.Repository, nil
-	}
-	base, told := seats[from.Seat]
-	if !told || base == "" {
-		return "", fmt.Errorf("the context is %s on the %s seat, and this build was told no clone "+
-			"base for that seat — nothing holds it in this mesh, or the control plane predates the word",
-			from.Repository, from.Seat)
-	}
-	return strings.TrimRight(base, "/") + "/" + strings.TrimSuffix(strings.Trim(from.Repository, "/"), ".git") + ".git", nil
-}
-
 // cloneWith is a git invocation that may offer a stored credential.
 //
 // The first `-c credential.helper=` clears every helper the environment might carry, so exactly
@@ -443,8 +416,7 @@ func wantsPackages(manifest catalogue.Manifest, within string) bool {
 
 func one(ctx context.Context, run Runner, publish Publisher,
 	module, tree, workspace, commit, credentials string, a catalogue.Artifact, args []string,
-	held map[string]string, npmrc string, registry Npmrc, seats map[string]string,
+	held map[string]string, npmrc string, say func(step, format string, args ...any)) (catalogue.Built, error) {
-	say func(step, format string, args ...any)) (catalogue.Built, error) {
 
 	switch a.Kind {
 	case catalogue.ArtifactUpstream:
@@ -521,7 +493,7 @@ func one(ctx context.Context, run Runner, publish Publisher,
 		recipePath := a.From
 		buildDir := tree
 		if a.Context != nil {
-			cloned, err := contextFrom(ctx, run, workspace, a.Name, credentials, *a.Context, seats, say)
+			cloned, err := contextFrom(ctx, run, workspace, a.Name, credentials, *a.Context, say)
 			if err != nil {
 				return catalogue.Built{}, fmt.Errorf("%s: %s's context: %w", module, a.Name, err)
 			}
@@ -582,28 +554,11 @@ func one(ctx context.Context, run Runner, publish Publisher,
 					"holds no copy of it. Build %s first",
 				module, a.Name, chain.Language, chain.Base, chain.Artifact, chain.Base)
 		}
-		// The module's own packages first, where the compiler and the bundler resolve them from
-		// (dependencies.go); nothing at all for a module whose package.json names only the SDK.
-		if err := installOwn(ctx, run, tree, chain, base, registry, say); err != nil {
-			return catalogue.Built{}, fmt.Errorf("%s: %s: %w", module, a.Name, err)
-		}
 		say("bundle", "compiling %s in %s's toolchain", a.Language, chain.Base)
 		compiled, err := compile(ctx, run, tree, chain, base, a)
 		if err != nil {
 			return catalogue.Built{}, fmt.Errorf("%s: compiling %s failed: %w", module, a.Name, err)
 		}
-		// **Every entrypoint the runtime may serve is executable** (novox/hq ADR 0193). The runtime
-		// knows no language; for one that runs through an interpreter the build writes the launcher.
-		launchers, err := writeLaunchers(compiled, chain, a)
-		if err != nil {
-			return catalogue.Built{}, fmt.Errorf("%s: writing %s's launchers failed: %w", module, a.Name, err)
-		}
-		if chain.Bundler != "" {
-			say("bundle", "bundling each entrypoint into one file")
-			if compiled, err = bundled(ctx, run, tree, chain, base, a, launchers); err != nil {
-				return catalogue.Built{}, fmt.Errorf("%s: bundling %s failed: %w", module, a.Name, err)
-			}
-		}
 		say("bundle", "compiled, packing")
 		body, err := pack(compiled)
 		if err != nil {
@@ -615,7 +570,7 @@ func one(ctx context.Context, run Runner, publish Publisher,
 		if err != nil {
 			return catalogue.Built{}, err
 		}
-		return catalogue.Built{Name: a.Name, Kind: a.Kind, Reference: where, Digest: digest, Launchers: launchers}, nil
+		return catalogue.Built{Name: a.Name, Kind: a.Kind, Reference: where, Digest: digest}, nil
 
 	case catalogue.ArtifactPackage:
 		// Built and published on a public base, to the mesh's package registry, by version
@@ -736,21 +691,6 @@ func short(commit string) string {
 	return commit
 }
 
-// Said is where the lines Command speaks go, beside the build's own Log: what runs, how long it
-// took, and that it failed. Nil prints them to stderr, as a build machine with nobody listening
-// should. The machine sets it per build so every line reaches the bus too (novox/hq ADR 0157) —
-// the step is "run", and the message is the line as it has always been printed.
-var Said Log
-
-func tell(step, format string, args ...any) {
-	message := fmt.Sprintf(format, args...)
-	if Said == nil {
-		fmt.Fprintf(os.Stderr, "  %s\n", message)
-		return
-	}
-	Said(step, message)
-}
-
 // Command is a Runner that actually runs things.
 func Command(ctx context.Context, dir, name string, args ...string) (string, error) {
 	// **Every command is echoed before it runs**, with where. On a build that hangs, the last line
@@ -758,23 +698,16 @@ func Command(ctx context.Context, dir, name string, args ...string) (string, err
 	// nothing" and "git clone is waiting on a network that will not answer". Silent on success is
 	// what made an empty workspace unreadable.
 	started := timeNow()
-	tell("run", "$ (%s) %s %s", short(filepath.Base(dir)), name, strings.Join(args, " "))
+	fmt.Fprintf(os.Stderr, "  $ (%s) %s %s\n", short(filepath.Base(dir)), name, strings.Join(args, " "))
 	cmd := exec.CommandContext(ctx, name, args...)
 	cmd.Dir = dir
 	out, err := cmd.CombinedOutput()
 	if err != nil {
-		tell("run", "! %s %s failed after %s", name, args[0], since(started))
+		fmt.Fprintf(os.Stderr, "  ! %s %s failed after %s\n", name, args[0], since(started))
-		// The command's own output is part of what a reader needs — the compiler's error, the
-		// clone's refusal — and a line per output line keeps it readable on the bus.
-		for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
-			if line != "" {
-				tell("output", "%s", line)
-			}
-		}
 		return string(out), fmt.Errorf("%s %s: %w\n%s",
 			name, strings.Join(args, " "), err, strings.TrimSpace(string(out)))
 	}
-	tell("run", "✓ %s %s (%s)", name, firstArg(args), since(started))
+	fmt.Fprintf(os.Stderr, "  ✓ %s %s (%s)\n", name, firstArg(args), since(started))
 	return string(out), nil
 }
 
@@ -944,32 +877,8 @@ func compile(ctx context.Context, run Runner, tree string, chain Toolchain,
 		base,
 	}
 	invocation = append(invocation, chain.Compile...)
-	// **One `-ldflags`, composed here.** A repeated flag is not a merged one: the Go command takes
-	// the last and drops the first, so passing the toolchain's flags and then the system stamp as a
-	// second `-ldflags` produced a binary that knew its system and had lost `-s -w` — half again the
-	// size, with its debug info (novox/hq 04-ISSUES/161).
-	//
-	// What it was built for is the one thing taken from the artifact, and ADR 0142 says why: the
-	// target is a property of the artifact rather than of the recipe. A host with no system refuses
-	// every declaration before it applies anything.
-	linker := append([]string(nil), chain.LinkerFlags...)
-	if chain.SystemStamp != "" && strings.TrimSpace(a.System) != "" {
-		linker = append(linker, "-X", chain.SystemStamp+"="+strings.TrimSpace(a.System))
-	}
-	if len(linker) > 0 {
-		invocation = append(invocation, "-ldflags", strings.Join(linker, " "))
-	}
 	if chain.OutputFlag != "" {
-		// A compiler pointed at a package is told the file to write, not the directory: the name a
+		invocation = append(invocation, chain.OutputFlag, out)
-		// machine runs it by is not always the name of the package that built it. The host's command
-		// is `cmd/mesh-host` and every machine runs it as `nox-mesh-host` — so a bundle carrying the
-		// package's name lands correctly, reports success, and is invisible to whatever looks for it
-		// (novox/hq 04-ISSUES/142).
-		target := out
-		if chain.Unit == UnitPackage {
-			target = filepath.Join(out, binaryName(a))
-		}
-		invocation = append(invocation, chain.OutputFlag, target)
 	}
 	// What to compile. Named by the module rather than discovered, so adding a file does not
 	// silently change what a build produces.
@@ -985,26 +894,6 @@ func compile(ctx context.Context, run Runner, tree string, chain Toolchain,
 	if _, err := run(ctx, tree, "docker", invocation...); err != nil {
 		return "", err
 	}
-	if chain.Dependencies != "" && chain.Bundler == "" {
-		// **What the bundle runs with, from the image it was compiled in** (Toolchain.Dependencies).
-		// A second run in the same image rather than a shell wrapped around the compiler: the
-		// compile line stays a plain command a reader can run by hand, and the copy is one more
-		// plain command beside it. Refused by name when the image carries no such directory — an
-		// older toolchain image — because a bundle packed without its dependencies starts nowhere
-		// and says so three layers away from here.
-		copying := []string{
-			"run", "--rm",
-			"--volume", tree + ":" + within,
-			"--workdir", within,
-			base,
-			"sh", "-c",
-			`test -d "$1" || { echo "the toolchain image carries no $1: it predates the mesh shipping a bundle's dependencies, rebuild $2 first" >&2; exit 1; }; cp -a "$1/." "$3/"`,
-			"dependencies", chain.Dependencies, chain.Base, out,
-		}
-		if _, err := run(ctx, tree, "docker", copying...); err != nil {
-			return "", fmt.Errorf("copying the %s dependencies a bundle runs with: %w", chain.Language, err)
-		}
-	}
 	return filepath.Join(tree, out), nil
 }
 
@@ -1178,152 +1067,3 @@ func readBy(manifest catalogue.Manifest) []catalogue.ArtifactContext {
 	})
 	return out
 }
-
-// binaryName is what a compiled bundle's executable is called: what the artifact says, or the name of
-// the package it is built from, which is what a compiler would have chosen anyway.
-func binaryName(a catalogue.Artifact) string {
-	if name := catalogue.BinaryOf(a); name != "" {
-		return name
-	}
-	if name := strings.TrimSpace(a.Binary); name != "" {
-		return name
-	}
-	if from := strings.Trim(a.From, "./"); from != "" {
-		return filepath.Base(from)
-	}
-	return a.Name
-}
-
-// launcherSuffix is what a TypeScript entrypoint's launcher is called beside it: index.js is
-// started as index.serve.mjs (novox/hq ADR 0193). An ES module by its own extension, whatever the
-// bundle's package.json says.
-const launcherSuffix = ".serve.mjs"
-
-// writeLaunchers writes, beside every entrypoint of a TypeScript bundle, an executable that
-// imports the entrypoint and serves what it registered over MCP on stdio — through the bundle's
-// own copy of the SDK, so registering and serving meet in one registry (novox/hq ADR 0193). Its
-// answer is each entrypoint's launcher, by entrypoint, relative to the bundle's root; nothing for
-// a language whose build is already executable.
-func writeLaunchers(root string, chain Toolchain, a catalogue.Artifact) (map[string]string, error) {
-	if chain.Language != "typescript" {
-		return nil, nil
-	}
-	out := map[string]string{}
-	for _, entry := range a.Entrypoints {
-		if !strings.HasSuffix(entry, ".js") {
-			continue
-		}
-		launcher := strings.TrimSuffix(entry, ".js") + launcherSuffix
-		body := "#!/usr/bin/env node\n" +
-			"// Written by the mesh's builder (novox/hq ADR 0193): serve what " + entry + " registers,\n" +
-			"// over MCP on stdio, as the module the node's runtime names in MESH_SERVED_MODULE.\n" +
-			"import { serveRegisteredOverStdio } from \"@novox/mesh-sdk/stdio\";\n" +
-			"await import(\"./" + filepath.Base(entry) + "\");\n" +
-			"await serveRegisteredOverStdio();\n"
-		path := filepath.Join(root, filepath.FromSlash(launcher))
-		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-			return nil, err
-		}
-		if err := os.WriteFile(path, []byte(body), 0o755); err != nil {
-			return nil, err
-		}
-		// WriteFile honours the umask; the mode a machine unpacks is the one packed, so it is set.
-		if err := os.Chmod(path, 0o755); err != nil {
-			return nil, err
-		}
-		out[entry] = launcher
-	}
-	return out, nil
-}
-
-// bundledSuffix is where a bundle's one-file output is written, beside what the compiler wrote.
-const bundledSuffix = ".bundled"
-
-// bundled makes every entrypoint and every launcher of a compiled bundle ONE file, in the toolchain
-// image's bundler, and answers the directory to pack (novox/hq ADR 0193).
-//
-// **What a launched bundle runs is what it imports, and nothing else.** Every served bundle is its
-// own process, so it carries its own copy of the SDK and its own dependencies inlined — the
-// toolchain's whole node_modules no longer travels in every bundle. An entrypoint a process runs by
-// name (`node daemon/index.js`) is bundled in place under its own name; a launcher keeps its name
-// and its first line, and stays executable. A package the bundler cannot inline is named by the
-// artifact (`external`), kept as an import, and only then is the toolchain's runtime directory
-// copied beside the files. CommonJS inlined into an ES module still finds `require`.
-func bundled(ctx context.Context, run Runner, tree string, chain Toolchain, base string,
-	a catalogue.Artifact, launchers map[string]string) (string, error) {
-	const within = "/app/modules/module"
-	out, final := Out(a.Name), Out(a.Name)+bundledSuffix
-	if err := os.RemoveAll(filepath.Join(tree, final)); err != nil {
-		return "", err
-	}
-	if err := os.MkdirAll(filepath.Join(tree, final), 0o755); err != nil {
-		return "", err
-	}
-	common := []string{"--bundle", "--platform=node", "--format=esm", "--target=node22",
-		"--outbase=" + out, "--outdir=" + final, "--log-level=warning",
-		"--banner:js=import { createRequire as __meshRequire } from 'node:module'; const require = __meshRequire(import.meta.url);"}
-	for _, x := range a.External {
-		common = append(common, "--external:"+x)
-	}
-	var plain []string
-	for _, e := range a.Entrypoints {
-		if strings.HasSuffix(e, ".js") {
-			plain = append(plain, out+"/"+e)
-		}
-	}
-	var launch []string
-	for _, l := range sortedValues(launchers) {
-		launch = append(launch, out+"/"+l)
-	}
-	// Refused by name in an image that predates the bundler, as the dependencies copy is: a bundle
-	// packed without it would carry nothing it imports. Run as itself: npm installs esbuild's native
-	// binary in place of its script, which `node` cannot run.
-	guard := `test -x "$0" || { echo "the toolchain image carries no bundler at $0: it predates one-file bundles, rebuild mesh-tools first" >&2; exit 1; }; exec "$0" "$@"`
-	step := func(entries []string, extra ...string) error {
-		if len(entries) == 0 {
-			return nil
-		}
-		invocation := []string{"run", "--rm", "--volume", tree + ":" + within, "--workdir", within, base,
-			"sh", "-c", guard, chain.Bundler}
-		invocation = append(invocation, entries...)
-		invocation = append(invocation, common...)
-		invocation = append(invocation, extra...)
-		_, err := run(ctx, tree, "docker", invocation...)
-		return err
-	}
-	if err := step(plain); err != nil {
-		return "", err
-	}
-	if err := step(launch, "--out-extension:.js=.mjs"); err != nil {
-		return "", err
-	}
-	// Plain `.js` output is an ES module; said once, as the runtime directory used to say it.
-	if err := os.WriteFile(filepath.Join(tree, final, "package.json"), []byte(`{"type":"module","private":true}`+"\n"), 0o644); err != nil {
-		return "", err
-	}
-	for _, l := range launchers {
-		path := filepath.Join(tree, final, filepath.FromSlash(l))
-		if _, err := os.Stat(path); err == nil {
-			if err := os.Chmod(path, 0o755); err != nil {
-				return "", err
-			}
-		}
-	}
-	if len(a.External) > 0 && chain.Dependencies != "" {
-		copying := []string{"run", "--rm", "--volume", tree + ":" + within, "--workdir", within, base,
-			"sh", "-c", `cp -a "$0/node_modules" "$1/"`, chain.Dependencies, final}
-		if _, err := run(ctx, tree, "docker", copying...); err != nil {
-			return "", fmt.Errorf("copying the packages %s keeps external: %w", a.Name, err)
-		}
-	}
-	return filepath.Join(tree, final), nil
-}
-
-func sortedValues(m map[string]string) []string {
-	out := make([]string, 0, len(m))
-	for _, v := range m {
-		out = append(out, v)
-	}
-	sort.Strings(out)
-	return out
-}

internal/builder/bundle_test.go

@@ -82,65 +82,6 @@ func TestABundleIsCompiledAndPackedWithNoDockerfile(t *testing.T) {
 	if !strings.HasPrefix(digest, "sha256:") {
 		t.Fatalf("the bundle was not pinned: %v", got.Manifest.Resources[0])
 	}
-
-	// **One file per entrypoint and launcher, in the toolchain's bundler** (novox/hq ADR 0193). A
-	// second run in the same toolchain image bundles each into the artifact's bundled output, the SDK
-	// inlined, refusing by name in an image that predates the bundler; and the toolchain's
-	// node_modules is no longer copied into a bundle that keeps nothing external.
-	var bundling []string
-	for _, line := range r.ran {
-		if strings.HasPrefix(line, "docker run") && strings.Contains(line, "esbuild") {
-			bundling = append(bundling, line)
-		}
-	}
-	if len(bundling) != 2 {
-		t.Fatalf("want one bundling run for the entrypoints and one for the launchers:\n%s", strings.Join(r.ran, "\n"))
-	}
-	for _, want := range []string{"mesh-tools/build@sha256:", "predates one-file bundles", "--bundle", "--format=esm",
-		"--platform=node", "--outdir=" + Out("code") + ".bundled", Out("code") + "/index.js"} {
-		if !strings.Contains(bundling[0], want) {
-			t.Errorf("the entrypoints' bundling lacks %q: %s", want, bundling[0])
-		}
-	}
-	if !strings.Contains(bundling[1], Out("code")+"/index.serve.mjs") || !strings.Contains(bundling[1], "--out-extension:.js=.mjs") {
-		t.Errorf("the launcher is not bundled under its own name: %s", bundling[1])
-	}
-	if strings.Contains(strings.Join(r.ran, "\n"), "/app/runtime") {
-		t.Errorf("the toolchain's node_modules was copied into a bundle that keeps nothing external:\n%s", strings.Join(r.ran, "\n"))
-	}
-	if strings.Index(strings.Join(r.ran, "\n"), "--outDir") > strings.Index(strings.Join(r.ran, "\n"), "esbuild") {
-		t.Fatal("the bundler ran before the compile wrote its output")
-	}
-}
-
-// A bundle naming packages it keeps external is bundled with them as imports, and carries the
-// toolchain's node_modules for them — the one case it still does.
-func TestABundleKeepingAPackageExternalCarriesTheToolchainsModules(t *testing.T) {
-	manifest := strings.Replace(aBundle, `"entrypoints":["index.js"]`, `"entrypoints":["index.js"],"external":["sharp"]`, 1)
-	r, workspace := aRepository(t, manifest, map[string]string{"index.ts": "console.log(1)"})
-	held := map[string]string{"mesh-tools/build": "registry.invalid/mesh-tools/build@sha256:" + strings.Repeat("b", 64)}
-	if _, err := Build(context.Background(), compiling{r}.run, r,
-		"https://forge.invalid/greeter.git", "", "", workspace, held, Npmrc{}, GitCredential{}, nil); err != nil {
-		t.Fatal(err)
-	}
-	all := strings.Join(r.ran, "\n")
-	if !strings.Contains(all, "--external:sharp") || !strings.Contains(all, "/app/runtime") {
-		t.Errorf("an external package was not kept as an import with the toolchain's modules beside it:\n%s", all)
-	}
-}
-
-// A language whose bundle carries its own dependencies copies nothing in: a Go binary is static.
-func TestOnlyALanguageWithARuntimeDirectoryCopiesDependenciesIn(t *testing.T) {
-	ts, _ := ToolchainFor("typescript")
-	if ts.Dependencies != "/app/runtime" {
-		t.Fatalf("typescript bundles run with %q", ts.Dependencies)
-	}
-	for _, language := range []string{"go", "python"} {
-		chain, _ := ToolchainFor(language)
-		if chain.Dependencies != "" {
-			t.Fatalf("%s copies %q into every bundle, and its bundles carry their own", language, chain.Dependencies)
-		}
-	}
 }
 
 // **Refused before anything is built, naming what to build first.** A base the mesh has not built
@@ -204,13 +145,9 @@ func TestTwoBundlesInOneModuleArePackedSeparately(t *testing.T) {
 		t.Fatalf("a module with two bundles did not build: %v", err)
 	}
 
-	// Compiled into two different places. Only the compile lines: the copy of each bundle's
+	// Compiled into two different places.
-	// dependencies names the same directory again, deliberately.
 	var outputs []string
 	for _, line := range r.ran {
-		if !strings.Contains(line, "--outDir") {
-			continue
-		}
 		for _, part := range strings.Fields(line) {
 			if strings.HasPrefix(part, ".mesh-build/") {
 				outputs = append(outputs, part)

internal/builder/context_test.go

@@ -1,26 +0,0 @@
-package builder
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-)
-
-// A context on a seat is cloned from the base the mesh sent, joined to the repository's path; a
-// context by URL is itself; a seat the mesh sent no base for is refused by name (novox/hq ADR 0155).
-func TestAContextOnASeatIsClonedFromTheBaseTheMeshSent(t *testing.T) {
-	seats := map[string]string{"git": "http://forge.example.tld:3000"}
-	got, err := contextURL(catalogue.ArtifactContext{Seat: "git", Repository: "org/controller"}, seats)
-	if err != nil || got != "http://forge.example.tld:3000/org/controller.git" {
-		t.Fatalf("got %q, %v", got, err)
-	}
-	got, err = contextURL(catalogue.ArtifactContext{Repository: "https://elsewhere.example/x.git"}, seats)
-	if err != nil || got != "https://elsewhere.example/x.git" {
-		t.Fatalf("a URL context was changed: %q, %v", got, err)
-	}
-	_, err = contextURL(catalogue.ArtifactContext{Seat: "git", Repository: "org/controller"}, nil)
-	if err == nil || !strings.Contains(err.Error(), "git seat") {
-		t.Fatalf("a seat with no base was not refused by name: %v", err)
-	}
-}

internal/builder/dependencies.go

@@ -1,147 +0,0 @@
-package builder
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-)
-
-// A module's own packages, installed before its bundle is compiled, so the bundler inlines them.
-//
-// **A bundle could only import what the toolchain happened to carry.** The compiler and the bundler
-// resolve an import by walking up from the module's source: the module's own directory first, then
-// the toolchain image's node_modules. Nothing ever put anything in the first, so a module needing a
-// database driver (`pg`, `mongodb`, `mssql`) could not be a bundle at all, and kept a container whose
-// recipe installed it by hand (novox/hq ADR 0198 §4: "the backend's own driver inside the bundle").
-// Now the module's `package.json` says what it depends on, as any Node package does, and the build
-// installs exactly that into the module's own directory before compiling.
-//
-// **The SDK the toolchain carries is the one a bundle is built with, whatever the module says**
-// (novox/hq issue 212: the toolchain is rebuilt on every SDK release and every bundle after it). A
-// module's `package.json` names `@novox/mesh-sdk` with a range — it has to, to type-check on a
-// workstation — and installing that range would shadow the toolchain's copy for this module alone:
-// one module compiled against an older SDK than its neighbours, chosen by a caret nobody re-reads.
-// So the SDK is taken out of what is installed (and never fetched), and any copy something else
-// pulls in is removed afterwards; every import of it resolves past the module's node_modules to the
-// toolchain's. A module therefore cannot pin a different SDK, by design: the toolchain is the pin.
-//
-// **Correctness before speed.** Every build installs afresh into a fresh clone, from the lockfile
-// when the module has one (`npm ci`, exact) and from its ranges otherwise; nothing installed is kept
-// between builds. What is shared is npm's own download cache, a named volume, which is
-// content-addressed and verified by integrity on every read — it saves the network, never the
-// install. Install scripts do not run: the build node runs nobody's postinstall, and what a script
-// would build natively could not be inlined into one file anyway.
-
-// sdkPackage is the package a TypeScript bundle's launcher serves through, and the one package a
-// module's own dependencies never supply (above).
-const sdkPackage = "@novox/mesh-sdk"
-
-// npmCache is the named volume npm's download cache lives in across builds on one build node.
-const npmCache = "mesh-builder-npm-cache"
-
-// ownDependencies is what a module's package.json depends on beyond the SDK, sorted; nothing when
-// the module has no package.json or depends on nothing else — which builds exactly as before.
-func ownDependencies(tree string) ([]string, error) {
-	raw, err := os.ReadFile(filepath.Join(tree, "package.json"))
-	if errors.Is(err, os.ErrNotExist) {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	var p struct {
-		Dependencies map[string]string `json:"dependencies"`
-	}
-	if err := json.Unmarshal(raw, &p); err != nil {
-		return nil, fmt.Errorf("the module's package.json is not JSON: %w", err)
-	}
-	var names []string
-	for name := range p.Dependencies {
-		if name != sdkPackage {
-			names = append(names, name)
-		}
-	}
-	sort.Strings(names)
-	return names, nil
-}
-
-// installSteps is the script run inside the toolchain image, from the module's own directory ($0).
-// It works in a scratch copy so the module's package.json and lockfile are never rewritten, takes
-// the SDK out of what is installed, installs production dependencies only, removes any copy of the
-// SDK something pulled in, and puts the result at the module's node_modules.
-const installSteps = `set -e
-work="$(mktemp -d)"
-cp "$0/package.json" "$work/"
-if [ -f "$0/package-lock.json" ]; then cp "$0/package-lock.json" "$work/"; fi
-cd "$work"
-node -e '
-const fs = require("fs"), sdk = process.argv[1];
-const p = JSON.parse(fs.readFileSync("package.json", "utf8"));
-for (const k of ["dependencies", "peerDependencies", "optionalDependencies"]) if (p[k]) delete p[k][sdk];
-delete p.devDependencies; delete p.scripts;
-fs.writeFileSync("package.json", JSON.stringify(p));
-' "$1"
-shift
-if [ -f package-lock.json ]; then
-  npm ci --omit=dev --omit=peer --ignore-scripts --no-audit --no-fund "$@"
-else
-  npm install --omit=dev --omit=peer --ignore-scripts --no-audit --no-fund --no-package-lock "$@"
-fi
-find node_modules -depth -type d -path "*/node_modules/@novox/mesh-sdk" -exec rm -rf {} +
-rm -rf "$0/node_modules"
-cp -a node_modules "$0/node_modules"
-`
-
-// installOwn installs a TypeScript module's own production dependencies into its directory, in the
-// toolchain image, before the compile — or does nothing at all for a module that has none.
-func installOwn(ctx context.Context, run Runner, tree string, chain Toolchain, base string,
-	registry Npmrc, say func(step, format string, args ...any)) error {
-	if chain.Language != "typescript" {
-		return nil
-	}
-	deps, err := ownDependencies(tree)
-	if err != nil || len(deps) == 0 {
-		return err
-	}
-	scoped := strings.TrimSpace(registry.Scope)
-	if !registry.Enabled() {
-		// **No registry, no scoped package.** Without the mesh's registry a scoped name resolves on
-		// the public one, where anybody may have published it: a dependency that installs is not
-		// the dependency the module meant.
-		for _, d := range deps {
-			if strings.HasPrefix(d, "@novox/") {
-				return fmt.Errorf("the module depends on %s, and this build knows no package registry "+
-					"for its scope; it would resolve from the public registry, which is not where the "+
-					"mesh publishes it", d)
-			}
-		}
-	}
-	const within = "/app/modules/module"
-	invocation := []string{"run", "--rm",
-		"--volume", tree + ":" + within,
-		"--volume", npmCache + ":/root/.npm",
-		"--workdir", within}
-	var flags []string
-	if registry.Enabled() {
-		// The registry is reached where the binding says it is, which may be this machine's own
-		// loopback — the reason an image build that resolves packages runs on the host network too.
-		invocation = append(invocation, "--network", "host")
-		reg := strings.TrimSpace(registry.Registry)
-		if !strings.HasSuffix(reg, "/") {
-			reg += "/"
-		}
-		flags = append(flags, "--"+scoped+":registry="+reg)
-	}
-	invocation = append(invocation, base, "sh", "-c", installSteps, within, sdkPackage)
-	invocation = append(invocation, flags...)
-	say("bundle", "installing the module's own packages: %s", strings.Join(deps, ", "))
-	if _, err := run(ctx, tree, "docker", invocation...); err != nil {
-		return fmt.Errorf("installing the module's own packages (%s): %w", strings.Join(deps, ", "), err)
-	}
-	return nil
-}

internal/builder/dependencies_test.go

@@ -1,131 +0,0 @@
-package builder
-
-import (
-	"context"
-	"strings"
-	"testing"
-)
-
-// A module's own packages (dependencies.go): installed into its own directory, in the toolchain,
-// before the compile, so the bundler inlines them — the SDK always the toolchain's.
-
-func buildWithPackageJSON(t *testing.T, pkg string, extra map[string]string, registry Npmrc) (*recorded, error) {
-	t.Helper()
-	files := map[string]string{"index.ts": "console.log(1)"}
-	if pkg != "" {
-		files["package.json"] = pkg
-	}
-	for k, v := range extra {
-		files[k] = v
-	}
-	r, workspace := aRepository(t, aBundle, files)
-	held := map[string]string{"mesh-tools/build": "registry.invalid/mesh-tools/build@sha256:" + strings.Repeat("b", 64)}
-	_, err := Build(context.Background(), compiling{r}.run, r,
-		"https://forge.invalid/greeter.git", "", "", workspace, held, registry, GitCredential{}, nil)
-	return r, err
-}
-
-func installs(r *recorded) []string {
-	var out []string
-	for _, line := range r.ran {
-		if strings.HasPrefix(line, "docker run") && strings.Contains(line, "npm ci") {
-			out = append(out, line)
-		}
-	}
-	return out
-}
-
-func compileIndex(r *recorded) int {
-	for i, line := range r.ran {
-		if strings.Contains(line, "--outDir") {
-			return i
-		}
-	}
-	return -1
-}
-
-func TestAModulesOwnPackagesAreInstalledInTheToolchainBeforeTheCompile(t *testing.T) {
-	r, err := buildWithPackageJSON(t, `{"type":"module","dependencies":{"@novox/mesh-sdk":"^0.1.0","pg":"^8"},"devDependencies":{"typescript":"^5"}}`,
-		nil, Npmrc{Scope: "@novox", Registry: "https://forge.invalid/api/packages/novox/npm"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	got := installs(r)
-	if len(got) != 1 {
-		t.Fatalf("want one install of the module's own packages:\n%s", strings.Join(r.ran, "\n"))
-	}
-	line := got[0]
-	for _, want := range []string{
-		"mesh-tools/build@sha256:",       // in the toolchain image
-		":/app/modules/module",           // into the module's own directory
-		"--workdir /app/modules/module",  //
-		npmCache + ":/root/.npm",         // npm's verified download cache, and only that
-		"--omit=dev", "--ignore-scripts", // production packages, no build-node scripts
-		"npm ci", "npm install", "--no-package-lock", // the lockfile when there is one, else the ranges
-		"--@novox:registry=https://forge.invalid/api/packages/novox/npm/", // the scope from the mesh's registry
-		"--network host",
-		"@novox/mesh-sdk", // named, to be taken out of what is installed
-	} {
-		if !strings.Contains(line, want) {
-			t.Errorf("the install lacks %q:\n%s", want, line)
-		}
-	}
-	// The SDK is the toolchain's: never installed from the module's range, and any copy removed.
-	if !strings.Contains(line, `delete p[k][sdk]`) || !strings.Contains(line, `-path "*/node_modules/@novox/mesh-sdk" -exec rm -rf`) {
-		t.Errorf("the module's own SDK range could shadow the toolchain's SDK:\n%s", line)
-	}
-	if i, c := strings.Index(strings.Join(r.ran, "\n"), "npm ci"), compileIndex(r); c < 0 ||
-		i > strings.Index(strings.Join(r.ran, "\n"), "--outDir") {
-		t.Fatalf("the install did not run before the compile:\n%s", strings.Join(r.ran, "\n"))
-	}
-}
-
-// **A module with nothing beyond the SDK builds exactly as before**: the same commands, no install.
-func TestAModuleDependingOnlyOnTheSDKBuildsExactlyAsBefore(t *testing.T) {
-	without, err := buildWithPackageJSON(t, "", nil, Npmrc{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, pkg := range []string{
-		`{"type":"module","dependencies":{"@novox/mesh-sdk":"^0.1.0"},"devDependencies":{"typescript":"^5"}}`,
-		`{"type":"module"}`,
-	} {
-		with, err := buildWithPackageJSON(t, pkg, map[string]string{"package-lock.json": "{}"}, Npmrc{Scope: "@novox", Registry: "https://forge.invalid/npm/"})
-		if err != nil {
-			t.Fatal(err)
-		}
-		if strings.Contains(strings.Join(with.ran, "\n"), "npm ") {
-			t.Fatalf("a module depending on nothing but the SDK ran npm:\n%s", strings.Join(with.ran, "\n"))
-		}
-		if len(with.ran) != len(without.ran) {
-			t.Fatalf("a module depending only on the SDK built differently from one with no package.json:\n%s\n---\n%s",
-				strings.Join(with.ran, "\n"), strings.Join(without.ran, "\n"))
-		}
-	}
-}
-
-// Without the mesh's registry a scoped package would resolve on the public one: refused by name.
-func TestAScopedPackageWithNoRegistryIsRefused(t *testing.T) {
-	r, err := buildWithPackageJSON(t, `{"dependencies":{"@novox/mesh-sdk":"^0.1.0","@novox/other":"^1"}}`, nil, Npmrc{})
-	if err == nil || !strings.Contains(err.Error(), "@novox/other") {
-		t.Fatalf("a scoped package was installed with no registry for its scope: %v", err)
-	}
-	if strings.Contains(strings.Join(r.ran, "\n"), "--outDir") {
-		t.Fatal("the compile ran after the refusal")
-	}
-	// A public package installs without one, from the public registry and nothing else.
-	r, err = buildWithPackageJSON(t, `{"dependencies":{"mssql":"^11"}}`, nil, Npmrc{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got := installs(r); len(got) != 1 || strings.Contains(got[0], ":registry=") || strings.Contains(got[0], "--network host") {
-		t.Fatalf("a public package's install: %v", got)
-	}
-}
-
-func TestAnUnreadablePackageJSONIsRefusedByName(t *testing.T) {
-	_, err := buildWithPackageJSON(t, `{"dependencies":`, nil, Npmrc{})
-	if err == nil || !strings.Contains(err.Error(), "package.json") {
-		t.Fatalf("a broken package.json was not refused by name: %v", err)
-	}
-}

internal/builder/launchers_test.go

@@ -1,49 +0,0 @@
-package builder
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/novox/mesh-controller/internal/catalogue"
-)
-
-// novox/hq ADR 0193: every entrypoint the runtime may serve is executable, and the runtime knows no
-// language — so a TypeScript bundle carries a launcher beside each entrypoint.
-func TestATypeScriptBundleCarriesAnExecutableLauncherBesideEachEntrypoint(t *testing.T) {
-	root := t.TempDir()
-	chain, err := ToolchainFor("typescript")
-	if err != nil {
-		t.Fatal(err)
-	}
-	got, err := writeLaunchers(root, chain, catalogue.Artifact{Name: "tools", Kind: catalogue.ArtifactBundle,
-		Language: "typescript", Entrypoints: []string{"tools/index.js", "index.js"}})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got["tools/index.js"] != "tools/index.serve.mjs" || got["index.js"] != "index.serve.mjs" {
-		t.Fatalf("launchers: %v", got)
-	}
-	path := filepath.Join(root, "tools", "index.serve.mjs")
-	info, err := os.Stat(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if info.Mode().Perm() != 0o755 {
-		t.Errorf("the launcher is %v, not executable 0755", info.Mode().Perm())
-	}
-	body, _ := os.ReadFile(path)
-	for _, want := range []string{"#!/usr/bin/env node\n", `from "@novox/mesh-sdk/stdio"`, `await import("./index.js")`, "serveRegisteredOverStdio()"} {
-		if !strings.Contains(string(body), want) {
-			t.Errorf("the launcher lacks %q:\n%s", want, body)
-		}
-	}
-
-	// A compiled language's build is executable already: no launcher.
-	goChain, _ := ToolchainFor("go")
-	none, err := writeLaunchers(t.TempDir(), goChain, catalogue.Artifact{Name: "tools", Kind: catalogue.ArtifactBundle, Language: "go"})
-	if err != nil || len(none) != 0 {
-		t.Errorf("a Go bundle was given launchers: %v %v", none, err)
-	}
-}

internal/builder/standing_on_test.go

@@ -200,23 +200,3 @@ func TestWhatABuildReadIsTheRepositoriesItsRecipesName(t *testing.T) {
 		t.Fatal("a module whose recipes name no other repository read one")
 	}
 }
-
-// novox/hq 04-ISSUES/212: a toolchain stands on the SDK's published package, and is built with the
-// exact version the mesh published — an argument that changes when the SDK does, so a rebuild after
-// a release never reuses an install of the version before it.
-func TestAPackageTheMeshPublishedIsPassedByItsExactVersion(t *testing.T) {
-	manifest := catalogue.Manifest{
-		Module: "mesh-tools",
-		Build: &catalogue.Build{
-			On: []catalogue.BuildsOn{{Arg: "MESH_SDK", Module: "mesh-sdk", Artifact: "lib"}},
-		},
-	}
-	held := map[string]string{"mesh-sdk/lib": "@novox/mesh-sdk@0.1.6"}
-	args, resolved, err := standingOn(context.Background(), manifest, held, noMirror)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if fmt.Sprint(args) != "[--build-arg MESH_SDK=@novox/mesh-sdk@0.1.6]" || fmt.Sprint(resolved) != "[@novox/mesh-sdk@0.1.6]" {
-		t.Errorf("the package was passed as %v, recorded as %v", args, resolved)
-	}
-}

internal/builder/system_stamp_test.go

@@ -1,76 +0,0 @@
-package builder
-
-import (
-	"strings"
-	"testing"
-)
-
-// A host built without knowing its system refuses every declaration before applying anything —
-// safely, totally, and with nothing reporting it. The mesh built one, delivered it, started it, and
-// it would have refused the first thing it was asked to do (novox/hq 04-ISSUES/161).
-
-func TestTheGoToolchainStampsTheArtifactsSystem(t *testing.T) {
-	chain, err := ToolchainFor("go")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if chain.SystemStamp != "main.builtFor" {
-		t.Fatalf("the go toolchain fills %q", chain.SystemStamp)
-	}
-}
-
-func TestALanguageWithNoPinnedSystemStampsNothing(t *testing.T) {
-	// Interpreted output is not pinned to a system, and a manifest declaring one for it is already
-	// refused. Nothing to fill.
-	for _, language := range []string{"typescript", "python"} {
-		chain, err := ToolchainFor(language)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if chain.SystemStamp != "" {
-			t.Fatalf("%s fills %q, and its output is not pinned to a system",
-				language, chain.SystemStamp)
-		}
-	}
-}
-
-func TestTheStampIsTheOneThingTakenFromTheArtifact(t *testing.T) {
-	// The toolchain accepts nothing else from the module — anything it could override it would be
-	// writing a Dockerfile to override. The system is the stated exception, because a compiled
-	// binary is per system and the artifact is what declares one (ADR 0142).
-	chain, err := ToolchainFor("go")
-	if err != nil {
-		t.Fatal(err)
-	}
-	joined := strings.Join(chain.Compile, " ")
-	if strings.Contains(joined, "${") || strings.Contains(joined, "%s") {
-		t.Fatalf("the compile line takes something from the module: %q", joined)
-	}
-}
-
-func TestTheLinkerIsToldOnceNotTwice(t *testing.T) {
-	// A repeated flag is not a merged one: the Go command takes the last -ldflags and drops the
-	// first. Passing the toolchain's flags and then the stamp separately produced a binary that knew
-	// its system and had lost -s -w — 12.2MB against 8.5MB, with its debug info (04-ISSUES/161).
-	chain, err := ToolchainFor("go")
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, arg := range chain.Compile {
-		if arg == "-ldflags" {
-			t.Fatal("the compile line carries -ldflags, so composing one here makes two")
-		}
-	}
-	if len(chain.LinkerFlags) == 0 {
-		t.Fatal("the go toolchain passes no linker flags, so the binary keeps its debug info")
-	}
-	var stripped bool
-	for _, f := range chain.LinkerFlags {
-		if f == "-s" {
-			stripped = true
-		}
-	}
-	if !stripped {
-		t.Fatalf("the go toolchain does not strip: %v", chain.LinkerFlags)
-	}
-}

internal/builder/toolchain.go

@@ -49,53 +49,6 @@ type Toolchain struct {
 	// is named as it will be FOUND, inside the unpacked bundle, so the source is the same path with
 	// the output directory taken off the front and this on the end.
 	SourceExt string
-	// LinkerFlags are passed to the linker as one flag, together with the system stamp below.
-	//
-	// **Separate from Compile because a repeated flag is not a merged one.** They were in the compile
-	// line, and appending the stamp as a second `-ldflags` meant the Go command took the last and
-	// dropped the first — so the binary gained its system and lost `-s -w`, growing by half and
-	// carrying its debug info. The mistake was believing a comment rather than reading the file it
-	// produced (novox/hq 04-ISSUES/161).
-	LinkerFlags []string
-	// Dependencies is a directory inside the toolchain image whose contents a bundle in this
-	// language runs with, copied whole into the compiled output's root after the compile.
-	//
-	// **A bundle that compiles is not yet a bundle that runs.** The compiler resolves `import
-	// "nats"` from the toolchain image's own node_modules and the pack takes only what the compiler
-	// wrote, so what a machine unpacked could not find a single dependency — and no TypeScript bundle
-	// had ever run live to show it (novox/hq to-be 38 WP3). For TypeScript the directory holds a
-	// `package.json` saying `"type": "module"` — Node reads a bare `.js` as CommonJS otherwise, so a
-	// bundle with its dependencies and without that line still fails to start — and the pruned,
-	// production-only node_modules the runtime itself ships with: the SDK's and the runtime's
-	// dependencies, and nothing module-specific (a module's own npm dependencies are installed into
-	// its own directory before the compile and inlined by the bundler: dependencies.go). Empty for a
-	// language whose bundle carries its own —
-	// a Go binary is static, a Python bundle is installed with its dependencies.
-	//
-	// A toolchain image without the directory fails the build by name rather than packing a bundle
-	// that starts nowhere: the image predates this and must be rebuilt first.
-	//
-	// *Since the bundler (below):* copied only for a bundle that names packages it keeps external,
-	// which cannot be inlined; a bundle with none carries no node_modules at all.
-	Dependencies string
-	// Bundler is the bundler inside the toolchain image that makes each compiled entrypoint and each
-	// launcher ONE self-contained file (novox/hq ADR 0193): every served bundle is its own process
-	// now, so each carries its own copy of what it imports — the SDK included — and nothing else.
-	// A bundle shrinks from the toolchain's whole node_modules to the code it runs. Empty for a
-	// language whose build is already one file.
-	Bundler string
-	// SystemStamp is the variable this language's linker fills with the artifact's declared system,
-	// for a language whose binaries are pinned to one at link time (novox/hq ADR 0005).
-	//
-	// **The one thing a toolchain takes from the artifact, and 0142 says why**: the target is a
-	// property of the artifact rather than of the recipe, because a compiled binary is per system
-	// and a toolchain that accepted it from the module would be accepting a build instruction. This
-	// is the narrow exception, named here rather than inferred.
-	//
-	// Empty for a language that compiles to nothing pinned. A host built without it refuses every
-	// declaration before applying anything — safely, totally, and with nothing reporting it
-	// (novox/hq 04-ISSUES/161).
-	SystemStamp string
 }
 
 // What a toolchain is pointed at.
@@ -134,22 +87,14 @@ var toolchains = []Toolchain{
 		// symlinks to a launcher that requires its library relatively — and the base image's own
 		// assembly resolves them away, leaving a launcher whose relative require points nowhere.
 		// Every module's hand-written Dockerfile had to know this. Now none of them does.
-		// **Rooted at the module, so an entrypoint lands where it is named.** Without a root the
-		// compiler takes the common directory of the files it is given: a module compiling only
-		// `tools/index.ts` had its output at `index.js`, and the entrypoint it declared —
-		// `tools/index.js`, "named as it will be found" — named a file the bundle did not
-		// contain. The runtime that loads bundles by their declared entrypoints (novox/hq ADR
-		// 0175) is what made this visible.
 		Compile: []string{
 			"node", "/app/node_modules/typescript/bin/tsc",
 			"--module", "NodeNext", "--moduleResolution", "NodeNext",
-			"--target", "ES2022", "--rootDir", ".",
+			"--target", "ES2022",
 		},
 		OutputFlag: "--outDir",
 		Unit:       UnitSources,
 		SourceExt:  ".ts",
-		Dependencies: "/app/runtime",
-		Bundler:      "/app/node_modules/esbuild/bin/esbuild",
 	},
 	{
 		Language: "go",
@@ -169,20 +114,14 @@ var toolchains = []Toolchain{
 		// rather than from the linker: two builds of one commit produce the same bytes.
 		Compile: []string{
 			"env", "CGO_ENABLED=0", "GOFLAGS=-trimpath",
-			"go", "build",
+			"go", "build", "-ldflags", "-s -w",
 		},
-		// Stripped of symbols and debug info: what a machine holds is a file it runs, not one it
-		// debugs, and the difference measured 12.2MB against 8.5MB.
-		LinkerFlags: []string{"-s", "-w"},
 		OutputFlag: "-o",
 		// Pointed at the package the artifact is built `from`, compiled whole. Go writes the binary
 		// into the output directory, named after the package — so the bundle a machine unpacks is a
 		// directory holding one executable, which is what the delivery mechanism expects
 		// (novox/hq ADR 0141).
 		Unit: UnitPackage,
-		// The mesh's own Go components read the system they were built for from this variable, and
-		// refuse to touch a machine without one.
-		SystemStamp: "main.builtFor",
 	},
 	{
 		Language: "python",

internal/catalogue/a_service_process_test.go

@@ -1,166 +0,0 @@
-package catalogue
-
-import (
-	"encoding/json"
-	"strings"
-	"testing"
-)
-
-// novox/hq issue 213 (ADR 0188 §1, §3): a module's own Go service is a bundle the host runs as a
-// process, not an image. Each test holds one thing that had to change in the composer for the
-// controller to be declared that way.
-
-const aServiceDigest = "sha256:dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
-
-// aServiceModule is the controller's shape in miniature: it answers tools of its own, its code is a
-// Go bundle a process runs as an account it declares, its secrets belong to that account, it
-// prepares its state, and its process replaces the container it used to run as.
-func aServiceModule(t *testing.T) Manifest {
-	t.Helper()
-	raw := `{
-	  "module": "svc", "version": "1", "tools": ["status"], "prepares": true,
-	  "own-secrets": {"store": "${dir:state}/store"},
-	  "secrets-owner": "svc",
-	  "resources": [
-	    {"id": "state", "type": "directory", "mode": "0700", "place": "mesh", "owner": "svc"},
-	    {"id": "service", "type": "process", "name": "svc", "artifact": "code",
-	     "run": ["./svc", "serve"], "user": "svc", "replaces": ["server"],
-	     "env": {"SVC_STORE_FILE": "${dir:state}/store", "SVC_STORE_PORT": "${seat:mesh-store:5432}"}},
-	    {"id": "account", "type": "user", "name": "svc", "shell": "/usr/bin/nologin", "home": "/var/lib/svc"}
-	  ],
-	  "build": {"artifacts": [{"name": "code", "kind": "bundle", "language": "go", "system": "arch",
-	    "from": "cmd/svc", "binary": "svc"}]}
-	}`
-	m, err := ParseManifest([]byte(raw))
-	if err != nil {
-		t.Fatalf("the service's manifest is refused: %v", err)
-	}
-	resolved, err := m.Resolve([]Built{{Name: "code", Kind: ArtifactBundle,
-		Reference: ArtifactStoreScheme + "svc/code@" + aServiceDigest, Digest: aServiceDigest}})
-	if err != nil {
-		t.Fatal(err)
-	}
-	return resolved
-}
-
-func composeTheService(t *testing.T, with Rendering) []map[string]any {
-	t.Helper()
-	with.Needed = map[string]map[string]string{"svc": {"store": "sealed-store"}}
-	with.ArtifactStore = "anchor.internal:5100"
-	out, err := Resolution{Node: "anchor", Modules: []Manifest{aServiceModule(t)}}.Declaration(with)
-	if err != nil {
-		t.Fatalf("the service does not compose: %v", err)
-	}
-	return out
-}
-
-func indexOf(out []map[string]any, id string) int {
-	for i, r := range out {
-		if r["id"] == id {
-			return i
-		}
-	}
-	return -1
-}
-
-// A module that declares tools has every bundle served by the node's runtime unless it says
-// otherwise — and the controller declares the verbs it answers as tools. Its service bundle is run
-// by its own process; launched a second time by the runtime it would be a second controller
-// pretending to be an MCP server.
-func TestABundleItsOwnProcessRunsIsNotServedByTheRuntime(t *testing.T) {
-	m := aServiceModule(t)
-	if len(m.Bundles) != 1 {
-		t.Fatalf("the service's bundle was not kept: %+v", m.Bundles)
-	}
-	if loads := m.Bundles[0].Loads; len(loads) != 0 {
-		t.Fatalf("the runtime would launch the service's own bundle as tools: %v", loads)
-	}
-	// And a bundle no resource runs still is served, as a module declaring tools always had it.
-	tools := Manifest{Module: "t", Version: "1", Tools: []string{"x"},
-		Build: &Build{Artifacts: []Artifact{{Name: "tools", Kind: ArtifactBundle, Language: "go",
-			System: "arch", From: "cmd/t"}}}}
-	resolved, err := tools.Resolve([]Built{{Name: "tools", Kind: ArtifactBundle,
-		Reference: ArtifactStoreScheme + "t/tools@" + aServiceDigest, Digest: aServiceDigest}})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loads := resolved.Bundles[0].Loads; len(loads) != 1 || loads[0] != "t" {
-		t.Fatalf("a tools bundle nothing runs is no longer served: %v", loads)
-	}
-}
-
-// The account is created before anything is given to it. Its secrets are mesh-computed and so
-// placed before the module's own resources; given to a user the machine did not have yet, they were
-// refused on the first apply and the process started without them.
-func TestAModulesAccountComesBeforeWhatBelongsToIt(t *testing.T) {
-	out := composeTheService(t, Rendering{})
-	account, secret := indexOf(out, "svc.account"), indexOf(out, "svc."+NeedID("store"))
-	if account < 0 || secret < 0 {
-		t.Fatalf("the account or the secret is missing: %v", out)
-	}
-	if account > secret {
-		t.Fatalf("the secret owned by svc is written before svc exists: account at %d, secret at %d",
-			account, secret)
-	}
-	if owner := out[secret]["owner"]; owner != "svc" {
-		t.Errorf("the secret belongs to %v, not the account its process runs as", owner)
-	}
-}
-
-// The process is the module's program; its preparation is the same program asked to prepare, as a
-// step before it — with the same account and environment, and handing nothing over.
-func TestAProcessIsPreparedByItsOwnProgram(t *testing.T) {
-	out := composeTheService(t, Rendering{})
-	step, process := indexOf(out, "svc.service-prepare"), indexOf(out, "svc.service")
-	if step < 0 || process < 0 || step > process {
-		t.Fatalf("the preparation is not a step before the process (%d, %d): %v", step, process, out)
-	}
-	s := out[step]
-	if s["type"] != "process" || s["run-once"] != true || s["name"] != "svc-prepare" {
-		t.Errorf("the preparation is not a run-once process: %v", s)
-	}
-	if run, _ := json.Marshal(s["run"]); string(run) != `["./svc","prepare"]` {
-		t.Errorf("the preparation runs %s", run)
-	}
-	if s["user"] != "svc" || s["source"] != out[process]["source"] {
-		t.Errorf("the preparation does not run the same bundle as the same account: %v", s)
-	}
-	if env, _ := s["env"].(map[string]any); env["SVC_STORE_FILE"] == nil {
-		t.Errorf("the preparation is not given the process's environment: %v", s["env"])
-	}
-	if _, has := s["replaces"]; has {
-		t.Errorf("the preparation would hand over what the process replaces: %v", s)
-	}
-	if _, has := s["args"]; has {
-		t.Errorf("the preparation carries a container's args: %v", s)
-	}
-}
-
-// What the process replaces is named as the host recorded it, `<module>.<id>`; unprefixed, the host
-// matches nothing and removes the container first, as before.
-func TestWhatAProcessReplacesIsNamedAsTheHostRecordedIt(t *testing.T) {
-	out := composeTheService(t, Rendering{})
-	p := out[indexOf(out, "svc.service")]
-	if got, _ := json.Marshal(p["replaces"]); string(got) != `["svc.server"]` {
-		t.Fatalf("the process replaces %s", got)
-	}
-}
-
-func TestWhatReplacesMayNameIsRefusedNearItsAuthor(t *testing.T) {
-	for what, resource := range map[string]string{
-		"a container":        `{"id":"c","type":"container","name":"c","image":"x@` + aServiceDigest + `","replaces":["old"]}`,
-		"a step":             `{"id":"p","type":"process","name":"p","run":["./p"],"run-once":true,"replaces":["old"]}`,
-		"something declared": `{"id":"p","type":"process","name":"p","run":["./p"],"replaces":["p"]}`,
-		"another module's":   `{"id":"p","type":"process","name":"p","run":["./p"],"replaces":["other.old"]}`,
-		"not a list":         `{"id":"p","type":"process","name":"p","run":["./p"],"replaces":"old"}`,
-	} {
-		raw := `{"module":"m","version":"1","resources":[` + resource + `]}`
-		if _, err := ParseManifest([]byte(raw)); err == nil || !strings.Contains(err.Error(), "replace") {
-			t.Errorf("replaces on %s was accepted: %v", what, err)
-		}
-	}
-	ok := `{"module":"m","version":"1","resources":[{"id":"p","type":"process","name":"p","run":["./p"],"replaces":["old"]}]}`
-	if _, err := ParseManifest([]byte(ok)); err != nil {
-		t.Errorf("a process replacing what its module no longer declares was refused: %v", err)
-	}
-}

internal/catalogue/artifact_store_alias_test.go

@@ -1,18 +0,0 @@
-package catalogue
-
-import "testing"
-
-// A claim written before the rename still holds (novox/hq ADR 0122, ADR 0156): with the store's
-// aliases loaded, the former name resolves to the seat.
-func TestTheArtifactStoresFormerNameResolvesToIt(t *testing.T) {
-	was := aliases
-	t.Cleanup(func() { aliases = was })
-	UseAliases(map[string]string{"the-artifact-store": "mesh-artifact-store"})
-	seat, known := SeatNamed("the-artifact-store")
-	if !known || seat.Name != "mesh-artifact-store" || seat.Delivers != "artifact-store" {
-		t.Fatalf("the former name did not resolve: %+v %v", seat, known)
-	}
-	if _, known := SeatNamed("mesh-artifact-store"); !known {
-		t.Fatal("the seat is not in the set under its name")
-	}
-}

internal/catalogue/artifact_store_seat_test.go

@@ -23,7 +23,7 @@ func TestASecondArtifactStoreAnywhereIsRefusedByName(t *testing.T) {
 	}
 
 	// A second one, on any other machine, is refused — and the refusal names the seat.
-	elsewhere := World{Held: []Held{{Claim: "mesh-artifact-store", Scope: ScopeMesh,
+	elsewhere := World{Held: []Held{{Claim: "the-artifact-store", Scope: ScopeMesh,
 		Node: "anchor", Module: "distribution"}}}
 	other := workstation()
 	other.Name = "laptop"
@@ -32,7 +32,7 @@ func TestASecondArtifactStoreAnywhereIsRefusedByName(t *testing.T) {
 		t.Fatal("a second store was accepted on another machine; it would offer artifact-store a " +
 			"second time and every consumer elsewhere would refuse to choose")
 	}
-	if !strings.Contains(err.Error(), "mesh-artifact-store") || !strings.Contains(err.Error(), "one per mesh") {
+	if !strings.Contains(err.Error(), "the-artifact-store") || !strings.Contains(err.Error(), "one per mesh") {
 		t.Fatalf("refused without naming the seat: %v", err)
 	}
 }

internal/catalogue/bound_into_files.go

@@ -46,7 +46,7 @@ func boundUsed(content string) [][2]string {
 // Three facts the mesh states about any provision, plus whatever the provider said it serves. A
 // module may not reach a binding it does not have — the same boundary as a secret, for the same
 // reason.
-func knownFor(m Manifest, needs []Needed, node string) (map[string]map[string]string, error) {
+func knownFor(m Manifest, needs []Needed, node string) map[string]map[string]string {
 	out := map[string]map[string]string{}
 	for _, want := range m.Wants() {
 		for i := range needs {
@@ -54,20 +54,12 @@ func knownFor(m Manifest, needs []Needed, node string) (map[string]map[string]st
 			if n.Name != want || n.For != m.Module {
 				continue
 			}
-			as := ConsumerIdentity(node, IdentitySource(m.Slug, m.Module))
 			values := map[string]string{
 				"at":   n.At,
 				"from": n.From,
-				"as":   as,
+				"as":   ConsumerIdentity(node, IdentitySource(m.Slug, m.Module)),
 			}
-			// What the provider derives for this consumer rather than for all of them
+			for key, value := range n.Serves {
-			// (novox/hq ADR 0201). Filled here, the one place a provision and the module
-			// requiring it are both in hand.
-			served, err := ServedTo(n.Serves, as)
-			if err != nil {
-				return nil, fmt.Errorf("%s requires %s: %w", m.Module, want, err)
-			}
-			for key, value := range served {
 				// The provider's own vocabulary. Rendered plainly: a port is 5432, not 5432.000000,
 				// which is what a float would write and what a connection string would refuse.
 				values[key] = plainly(value)
@@ -75,7 +67,7 @@ func knownFor(m Manifest, needs []Needed, node string) (map[string]map[string]st
 			out[want] = values
 		}
 	}
-	return out, nil
+	return out
 }
 
 // withOwnNames adds a module's own composed names to what it may name from one binding:

internal/catalogue/broker_seat_test.go

@@ -59,7 +59,7 @@ func TestRenamingASeatDidNotRenameTheInterfaceItDelivers(t *testing.T) {
 	for _, pair := range []struct{ seat, delivers string }{
 		{"git", "git"},
 		{"npm-package-registry", "npm-package-registry"},
-		{"mesh-artifact-store", "artifact-store"},
+		{"the-artifact-store", "artifact-store"},
 		{"mesh-store", "postgres-database"},
 		{"mesh-broker", "mesh-bus"},
 	} {

internal/catalogue/brokered_test.go

@@ -25,7 +25,7 @@ func reachable() Node {
 func onNetwork(nodes ...string) map[string][]Provider {
 	out := make([]Provider, 0, len(nodes))
 	for _, n := range nodes {
-		out = append(out, Provider{Node: n, At: n + ".internal", Module: "postgres"})
+		out = append(out, Provider{Node: n, At: n + ".internal"})
 	}
 	return map[string][]Provider{"postgres-database": out}
 }
@@ -99,7 +99,7 @@ func TestSayingWhichOneSettlesIt(t *testing.T) {
 	got, err := Resolve(brokeredShelf(), []string{"meshboard"}, reachable(),
 		World{
 			Offered: onNetwork("anchor", "archive"),
-			Pinned:  map[string]Chosen{"postgres-database": {Node: "archive", Module: "postgres"}},
+			Pinned:  map[string]string{"postgres-database": "archive"},
 		})
 	if err != nil {
 		t.Fatal(err)
@@ -115,7 +115,7 @@ func TestBeingPointedAtAMachineThatDoesNotProvideItIsRefused(t *testing.T) {
 	_, err := Resolve(brokeredShelf(), []string{"meshboard"}, reachable(),
 		World{
 			Offered: onNetwork("anchor", "archive"),
-			Pinned:  map[string]Chosen{"postgres-database": {Node: "somewhere-else", Module: "postgres"}},
+			Pinned:  map[string]string{"postgres-database": "somewhere-else"},
 		})
 	if err == nil {
 		t.Fatal("a machine was silently given a different database from the one chosen")
@@ -131,12 +131,12 @@ func TestOneProviderDoesNotOverruleAChoice(t *testing.T) {
 	_, err := Resolve(brokeredShelf(), []string{"meshboard"}, reachable(),
 		World{
 			Offered: onNetwork("anchor"),
-			Pinned:  map[string]Chosen{"postgres-database": {Node: "archive", Module: "postgres"}},
+			Pinned:  map[string]string{"postgres-database": "archive"},
 		})
 	if err == nil {
 		t.Fatal("the only database was used although another was chosen")
 	}
-	if !strings.Contains(err.Error(), "only anchor/postgres provides it") {
+	if !strings.Contains(err.Error(), "only anchor provides it") {
 		t.Fatalf("the refusal does not say what is available: %v", err)
 	}
 }

internal/catalogue/build.go

@@ -2,7 +2,6 @@ package catalogue
 
 import (
 	"fmt"
-	"path"
 	"sort"
 	"strings"
 )
@@ -29,9 +28,6 @@ type Built struct {
 	Reference string
 	// Digest is "sha256:<hex>", for an archive. An image reference already ends in one.
 	Digest string
-	// Launchers are, for a bundle in an interpreted language, the executable the build wrote beside
-	// each entrypoint, by entrypoint (novox/hq ADR 0193): what the node's runtime starts to serve it.
-	Launchers map[string]string
 }
 
 // Resolve fills a manifest's resources in from what was built.
@@ -71,49 +67,6 @@ func (m Manifest) Resolve(built []Built) (Manifest, error) {
 	out := m
 	out.Build = nil
 	out.Resources = nil
-	// What the build compiled, kept on the resolved manifest (novox/hq ADR 0175): a tools bundle is
-	// named by no resource of the module's own — the node's runtime loads it — so this is the only
-	// place the mesh would otherwise not have it. In artifact order, so two resolutions of one
-	// build compare equal.
-	out.Bundles = nil
-	if m.Build != nil {
-		run := runByAResource(m)
-		for _, a := range m.Build.Artifacts {
-			if a.Kind != ArtifactBundle {
-				continue
-			}
-			made := by[a.Name]
-			// What the runtime loads: what the artifact said, else every entrypoint of a module
-			// that declares tools, else nothing (the field's own rule; see Artifact.Loads).
-			//
-			// **Never, unasked, a bundle one of the module's own resources runs** (novox/hq issue 213).
-			// A process the host runs is the module's service, not its tools: the controller declares
-			// the verbs it answers as `tools` and serves them itself, and its bundle would otherwise
-			// have been launched a second time by the node's runtime, as an MCP child it is not.
-			loads := append([]string(nil), a.Loads...)
-			if a.Loads == nil && len(m.Tools) > 0 && !run[a.Name] {
-				loads = append([]string(nil), a.Entrypoints...)
-				// A bundle compiled to a binary has no entrypoints: the binary is what it is, and what
-				// the runtime starts to serve it (novox/hq ADR 0193). So a Go tools bundle is served
-				// as Go — the runtime execs it — exactly as a TypeScript one is through its launcher.
-				if bin := BinaryOf(a); bin != "" {
-					loads = []string{bin}
-				}
-			}
-			// **Kept, never routed** (ADR 0155): the builder publishes to the store at the address
-			// it reached it by, and a manifest carrying that address names an installation —
-			// registration refused node-tools for exactly this on 2026-10-02. The build record
-			// already keeps the store-relative form; the resolved manifest keeps the same, and
-			// composition routes it through the store a machine reaches (Routed).
-			out.Bundles = append(out.Bundles, Bundle{
-				Name: a.Name, Source: Recorded(made.Reference), Digest: made.Digest,
-				Language: a.Language, Entrypoints: append([]string(nil), a.Entrypoints...),
-				Loads: loads, Env: copyWords(a.Env), Launchers: copyWords(made.Launchers),
-				Binary: BinaryOf(a),
-			})
-		}
-		sort.Slice(out.Bundles, func(i, j int) bool { return out.Bundles[i].Name < out.Bundles[j].Name })
-	}
 	for _, r := range m.Resources {
 		named, _ := r["artifact"].(string)
 		if named == "" {
@@ -157,8 +110,7 @@ func (m Manifest) Resolve(built []Built) (Manifest, error) {
 			// The same on the wire: both are bytes fetched by digest and unpacked. They differ in
 			// how they were made — one packed as it stood, the other compiled first — and a
 			// machine has no reason to care which.
-			// Kept, not routed, for the reason the bundles above are (ADR 0155).
+			filled["source"] = artifact.Reference
-			filled["source"] = Recorded(artifact.Reference)
 			filled["digest"] = artifact.Digest
 			// **And `${version}`, so a resource can name a place that is this build's alone**
 			// (novox/hq ADR 0141, 04-ISSUES/142). A component is unpacked into a directory named
@@ -220,17 +172,6 @@ func (b *Build) problems(module string) []string {
 		// A bundle's source is the module's own directory by definition, and what it needs to say
 		// is which compiler — because the mesh chooses that, and cannot choose for a module that
 		// has not said.
-		if len(a.External) > 0 && (a.Kind != ArtifactBundle || a.Language != "typescript") {
-			problems = append(problems, fmt.Sprintf(
-				"%s: %q names packages it keeps external, and only a TypeScript bundle is bundled into "+
-					"one file with some kept out (novox/hq ADR 0193)", module, a.Name))
-		}
-		if len(a.Env) > 0 && a.Kind != ArtifactBundle {
-			problems = append(problems, fmt.Sprintf(
-				"%s: %q is a %q and says what it is given (env). Only a bundle the node's runtime "+
-					"serves is given words (novox/hq ADR 0192); a container says its own environment",
-				module, a.Name, a.Kind))
-		}
 		if a.Kind == ArtifactBundle || a.Kind == ArtifactPackage {
 			// **Except for a language that compiles to a binary, where it names which one**
 			// (novox/hq 04-ISSUES/142). A bundle in an interpreted language is the module's own
@@ -250,26 +191,6 @@ func (b *Build) problems(module string) []string {
 					"%s: %q is a bundle and says no language, so nothing can choose a compiler "+
 						"for it", module, a.Name))
 			}
-			problems = append(problems, bundleEnvProblems(module, a)...)
-			// What the runtime loads is among what was compiled (ADR 0175): a name here that is
-			// not an entrypoint is a file the bundle does not contain, and the runtime would
-			// fail to import it on every machine rather than here.
-			for _, load := range a.Loads {
-				found := false
-				for _, e := range a.Entrypoints {
-					found = found || e == load
-				}
-				// A bundle compiled to a binary is one executable: the runtime loads that or nothing
-				// (novox/hq ADR 0193).
-				if bin := BinaryOf(a); bin != "" {
-					found = load == bin
-				}
-				if !found {
-					problems = append(problems, fmt.Sprintf(
-						"%s: %q says the runtime loads %q, which is not among its entrypoints — "+
-							"what is loaded is compiled, so it is named there too", module, a.Name, load))
-				}
-			}
 			// **A system, for a language that compiles to a binary** (novox/hq ADR 0142). A binary
 			// is pinned to one operating system at link time so a host refuses to touch a machine
 			// it was not built for (novox/hq ADR 0005); an artifact that says nothing would be
@@ -394,104 +315,3 @@ func versionOf(digest string) string {
 	}
 	return hex
 }
-
-// bundleEnvWords are the words the runtime sets for itself; a bundle that named one would be
-// telling the runtime what it is, which is the mesh's to say (novox/hq ADR 0192).
-var bundleEnvWords = map[string]bool{
-	RuntimeToolModules: true, RuntimeBrokerFile: true, RuntimeOperatorAccount: true,
-	RuntimeOperatorHome: true, RuntimeToolEnv: true,
-}
-
-// bundleEnvProblems says what is wrong with what a bundle says it is given (novox/hq ADR 0192):
-// a value is a path or a constant written with the references a container's environment may use
-// for a place or a port, and never a secret's content or another module's binding — a secret
-// reaches a tool as a file whose path is named.
-func bundleEnvProblems(module string, a Artifact) []string {
-	if len(a.Env) == 0 {
-		return nil
-	}
-	var problems []string
-	for _, word := range sortedKeys(a.Env) {
-		value := a.Env[word]
-		if bundleEnvWords[word] {
-			problems = append(problems, fmt.Sprintf(
-				"%s: %q gives itself %s, which the node's runtime sets for itself; a bundle is "+
-					"given its own words beside the runtime's, never in place of them (novox/hq ADR 0192)",
-				module, a.Name, word))
-		}
-		rest := ofPort.ReplaceAllString(dirRef.ReplaceAllString(value, ""), "")
-		if strings.Contains(rest, "${") {
-			problems = append(problems, fmt.Sprintf(
-				"%s: %q gives %s the value %q. A bundle's word is a path or a constant, written with "+
-					"${dir:…} and ${port:…} only; a secret reaches a tool as a file the mesh places, "+
-					"named by its path, never as its content (novox/hq ADR 0192)",
-				module, a.Name, word, value))
-		}
-	}
-	return problems
-}
-
-func copyWords(in map[string]string) map[string]string {
-	if len(in) == 0 {
-		return nil
-	}
-	out := make(map[string]string, len(in))
-	for k, v := range in {
-		out[k] = v
-	}
-	return out
-}
-
-// BinaryOf is what a bundle compiled to a binary is called once built: what the artifact names, else
-// the package it is built from, else the artifact's own name (novox/hq 04-ISSUES/142). Empty for a
-// language that does not compile to one. The builder writes the binary under this name, and the
-// composer runs it by it, so both ask here.
-func BinaryOf(a Artifact) string {
-	if !compilesToABinary(a.Language) {
-		return ""
-	}
-	if name := strings.TrimSpace(a.Binary); name != "" {
-		return name
-	}
-	if from := strings.Trim(a.From, "./"); from != "" {
-		return path.Base(from)
-	}
-	return a.Name
-}
-
-// runByAResource is the artifacts one of a module's own resources names — a process that runs it,
-// a step, an archive that unpacks it — by name.
-func runByAResource(m Manifest) map[string]bool {
-	named := map[string]bool{}
-	for _, r := range m.Resources {
-		if a, ok := r["artifact"].(string); ok && a != "" {
-			named[a] = true
-		}
-	}
-	return named
-}
-
-// undeliveredBundles says which of a module's bundles nothing would ever put on a machine (novox/hq
-// 04-ISSUES/216). A bundle reaches a machine three ways: the node's runtime serves it (it says
-// `loads`, or its module declares `tools`), a resource names it (a process, a step, an archive), or
-// it is the runtime itself. One reached by none of them was built, recorded and pushed as success,
-// and was simply absent — seven modules' tools went missing that way on 2026-10-03. Refused here,
-// naming the field that would deliver it.
-func undeliveredBundles(m Manifest) []string {
-	if m.Build == nil || m.Module == RuntimeModule {
-		return nil
-	}
-	named := runByAResource(m)
-	var problems []string
-	for _, a := range m.Build.Artifacts {
-		if a.Kind != ArtifactBundle || named[a.Name] || len(a.Loads) > 0 || len(m.Tools) > 0 {
-			continue
-		}
-		problems = append(problems, fmt.Sprintf(
-			"%s: the bundle %q would be built and never reach a machine: nothing loads it, runs it or "+
-				"unpacks it. A tools bundle says `loads` (the entrypoints the node's runtime serves) or its "+
-				"module lists its `tools`; a daemon or a step is a resource naming it (novox/hq 04-ISSUES/216)",
-			m.Module, a.Name))
-	}
-	return problems
-}

internal/catalogue/catalogue_check_test.go

@@ -3,7 +3,6 @@ package catalogue
 import (
 	"os"
 	"path/filepath"
-	"strings"
 	"testing"
 )
 
@@ -11,24 +10,11 @@ import (
 //
 // Not a fixture: the point is whether the manifests as written are accepted by the control plane that
 // will read them, and a copy of one manifest proves nothing about the other seventy-one.
-// catalogueRoot is the catalogue these checks run over: MESH_CATALOGUE when set, else the checkout
-// beside this one, the way the main layout has it. A check that only ran when somebody remembered a
-// variable was a check nobody ran (novox/hq issue 134, 2026-09-30); it skips only when there is no
-// catalogue to be found at all.
-func catalogueRoot(t *testing.T) string {
-	t.Helper()
-	if root := os.Getenv("MESH_CATALOGUE"); root != "" {
-		return root
-	}
-	sibling := filepath.Join("..", "..", "..", "mesh-catalog")
-	if _, err := os.Stat(filepath.Join(sibling, "modules")); err != nil {
-		t.Skip("no catalogue beside this checkout and MESH_CATALOGUE unset")
-	}
-	return sibling
-}
-
 func TestEveryCatalogueManifestParses(t *testing.T) {
-	root := catalogueRoot(t)
+	root := os.Getenv("MESH_CATALOGUE")
+	if root == "" {
+		t.Skip("set MESH_CATALOGUE to a catalogue checkout to run this")
+	}
 	found, err := filepath.Glob(filepath.Join(root, "modules", "*", "module.json"))
 	if err != nil || len(found) == 0 {
 		t.Fatalf("no manifests under %s: %v", root, err)
@@ -59,30 +45,3 @@ func TestEveryCatalogueManifestParses(t *testing.T) {
 		t.Fatal("no endpoint in the catalogue is named, so this proved nothing")
 	}
 }
-
-// TestNoCatalogueManifestNamesAnInstallation is ADR 0112's check, run over the real catalogue: no
-// definition names a domain or a public address the mesh acts on, and every value that must for now
-// carries its reason (novox/hq ADR 0155, issue 134). The list it prints is the one that shrinks.
-func TestNoCatalogueManifestNamesAnInstallation(t *testing.T) {
-	root := catalogueRoot(t)
-	found, err := filepath.Glob(filepath.Join(root, "modules", "*", "module.json"))
-	if err != nil || len(found) == 0 {
-		t.Fatalf("no manifests under %s: %v", root, err)
-	}
-	var named []string
-	for _, p := range found {
-		raw, err := os.ReadFile(p)
-		if err != nil {
-			t.Fatalf("%s: %v", p, err)
-		}
-		m, err := ParseManifest(raw)
-		if err != nil {
-			t.Errorf("%s: %v", p, err)
-			continue
-		}
-		named = append(named, InstallationProblems(m)...)
-	}
-	if len(named) > 0 {
-		t.Fatalf("%d value(s) name an installation:\n  %s", len(named), strings.Join(named, "\n  "))
-	}
-}

internal/catalogue/chosen.go

@@ -1,100 +0,0 @@
-package catalogue
-
-import (
-	"sort"
-)
-
-// Chosen is the provider somebody named for a provision: the module, and the node it runs on. Both,
-// always (novox/hq #258) — a provision comes from a module, and the same module on two machines is
-// two answers, so neither half alone says which. Module is empty only on a record made before this
-// was asked, and such a record is honoured exactly as long as it is unambiguous.
-type Chosen struct {
-	Node   string
-	Module string
-}
-
-func (c Chosen) String() string {
-	if c.Module == "" {
-		return c.Node
-	}
-	return c.Node + "/" + c.Module
-}
-
-// matches is whether this provider is the one chosen.
-func (c Chosen) matches(p Provider) bool {
-	return p.Node == c.Node && (c.Module == "" || p.Module == c.Module)
-}
-
-// among is every offered provider the choice names — one, when the choice is whole.
-func (c Chosen) among(where []Provider) []Provider {
-	var out []Provider
-	for _, p := range where {
-		if c.matches(p) {
-			out = append(out, p)
-		}
-	}
-	return out
-}
-
-// nameOf is how a refusal names a provider: the node and the module on it.
-func nameOf(p Provider) string {
-	return Chosen{Node: p.Node, Module: p.Module}.String()
-}
-
-// providerNames is every provider named, sorted, for a refusal to list.
-func providerNames(where []Provider) []string {
-	out := make([]string, 0, len(where))
-	for _, p := range where {
-		out = append(out, nameOf(p))
-	}
-	sort.Strings(out)
-	return out
-}
-
-// providersHere is which modules in this node's own set offer a provision, sorted.
-func providersHere(catalogue map[string]Manifest, here func(string) bool, want string) []string {
-	var out []string
-	for name, m := range catalogue {
-		if !here(name) {
-			continue
-		}
-		for _, o := range m.Offers() {
-			if o == want {
-				out = append(out, name)
-				break
-			}
-		}
-	}
-	sort.Strings(out)
-	return out
-}
-
-// servedByOne is what one provider beside the consumer says a consumer needs to know, or nothing.
-//
-// Serving is *whether* a need is created at all when the provider is on this same machine (novox/hq
-// 04-ISSUES/038's sibling): a need never created is a binding the consumer never gets. The manifest
-// alone answers that; the values are settled later, with the node's settings.
-func servedByOne(m Manifest, want string) map[string]any {
-	if _, ok := m.Serves[want]; ok {
-		return ServedOn(m, want, nil)
-	}
-	return nil
-}
-
-// sharedByOne is the own secret that provider names as its credential (ADR 0158), or "" when it
-// gives each consumer its own.
-func sharedByOne(m Manifest, want string) string {
-	if own, shared := m.SharedCredentialOf(want); shared {
-		return own
-	}
-	return ""
-}
-
-func oneOf(list []string, s string) bool {
-	for _, x := range list {
-		if x == s {
-			return true
-		}
-	}
-	return false
-}

internal/catalogue/consumer_into_serves.go

@@ -1,311 +0,0 @@
-package catalogue
-
-import (
-	"fmt"
-	"regexp"
-	"sort"
-	"strings"
-)
-
-// What a provider derives for one consumer, said once in the provider's definition and delivered
-// to both ends (novox/hq ADR 0201, issue 124).
-//
-// A `serves` block is otherwise literal: the same values for every consumer. Where the provider
-// *names the resource* — a bucket, a database, a vhost — the name is derived from who is asking,
-// and before this the mesh had no channel for it. The provider recomputed it in its own code and
-// every consumer transcribed it into its own definition by hand, which is a copy of somebody
-// else's rule kept in agreement by nobody. One of three transcriptions was wrong for months.
-//
-// **The mesh learns no protocol here; it spells its own name in an alphabet it already knows.**
-// The only fact a served value may name is the identity the mesh itself minted for the consumer,
-// in one of two alphabets: as it was minted, and as a DNS label. Everything a provider wants
-// around it — a prefix, a suffix, a separator — it writes around the placeholder, because a
-// served value is a string.
-
-// consumerFact is `${consumer:<fact>}` or `${consumer:<fact>:<alphabet>}`.
-var consumerFact = regexp.MustCompile(`\$\{consumer:([a-z][a-z0-9-]*)(?::([a-z][a-z0-9-]*))?\}`)
-
-// consumerFacts are what a served value may name about the consumer it is being derived for.
-// One entry, deliberately: the identity is the one thing about a consumer the mesh itself chose,
-// so it is the one thing the mesh can hand to a provider without either end guessing.
-var consumerFacts = []string{"as"}
-
-// consumerAlphabets are the ways the mesh will write that identity. `dns` is the mesh's own
-// identifier with its separator written `-` instead of `_` — the whole of the difference between
-// the alphabet the mesh mints in and the one buckets, vhosts and hostnames accept.
-var consumerAlphabets = []string{"dns"}
-
-// ServedTo fills a provider's served values for one consumer.
-//
-// `as` is the identity the mesh minted for that consumer — the same string it is told to present
-// as a login. Values with no placeholder are returned exactly as they were, and a block with no
-// placeholder at all is returned unchanged, so this costs nothing for the providers that derive
-// nothing.
-//
-// Only strings carry placeholders. A number, a boolean or a nested object is a value the provider
-// stated outright, and is left alone.
-func ServedTo(serves map[string]any, as string) (map[string]any, error) {
-	if len(serves) == 0 {
-		return serves, nil
-	}
-	var out map[string]any
-	for _, key := range sortedAnyKeys(serves) {
-		text, ok := serves[key].(string)
-		if !ok || !strings.Contains(text, "${consumer:") {
-			continue
-		}
-		filled, err := consumerInto(text, as)
-		if err != nil {
-			return nil, fmt.Errorf("the value served as %q: %w", key, err)
-		}
-		if out == nil {
-			// Copied only once something actually changes: the caller's map is the manifest's,
-			// and a provider that derives nothing must not have it rewritten underneath it.
-			out = make(map[string]any, len(serves))
-			for k, v := range serves {
-				out[k] = v
-			}
-		}
-		out[key] = filled
-	}
-	if out == nil {
-		return serves, nil
-	}
-	return out, nil
-}
-
-// consumerInto replaces every `${consumer:…}` in one value.
-//
-// **A fact or an alphabet the mesh does not have is refused, not left standing.** Written through,
-// the literal `${consumer:as}` would reach a configuration file and be read as a bucket name,
-// failing somewhere that names neither the module nor the mesh — the same reasoning `${bound:…}`
-// is refused by (boundInto).
-func consumerInto(value, as string) (string, error) {
-	var failed error
-	out := consumerFact.ReplaceAllStringFunc(value, func(match string) string {
-		parts := consumerFact.FindStringSubmatch(match)
-		fact, alphabet := parts[1], parts[2]
-		if fact != "as" {
-			if failed == nil {
-				failed = fmt.Errorf(
-					"says %s, and the mesh states %s about a consumer", match, orNothing(consumerFacts))
-			}
-			return match
-		}
-		switch alphabet {
-		case "":
-			return as
-		case "dns":
-			return asDNSLabel(as)
-		default:
-			if failed == nil {
-				failed = fmt.Errorf(
-					"says %s, and the mesh writes an identity as %s", match, orNothing(consumerAlphabets))
-			}
-			return match
-		}
-	})
-	if failed != nil {
-		return "", failed
-	}
-	return out, nil
-}
-
-// asDNSLabel writes a minted identity as a DNS label.
-//
-// The mesh's identities are already lower-case letters, digits and `_` (ConsumerIdentity), and
-// already short enough for the tightest backend they reach (CheckIdentity, twenty characters). So
-// this is the separator and nothing else — no lower-casing of what is already lower case, no
-// truncation to a limit the identity is already inside, no padding of a name that is already long
-// enough. Each of those would be the mesh guessing at a rule it has not been given.
-func asDNSLabel(as string) string {
-	return strings.ReplaceAll(as, "_", "-")
-}
-
-// CheckServes refuses a `serves` block that names a consumer fact or an alphabet the mesh does not
-// have, when the definition is parsed rather than when a consumer is resolved.
-//
-// A provision nobody consumes yet still has its rule read: a definition that would be refused the
-// first time somebody required it is a definition that is wrong now.
-func CheckServes(m Manifest) []string {
-	var problems []string
-	for _, provision := range sortedServes(m.Serves) {
-		for _, key := range sortedAnyKeys(m.Serves[provision]) {
-			text, ok := m.Serves[provision][key].(string)
-			if !ok {
-				continue
-			}
-			// A probe identity, because what is checked is the shape of the statement and not
-			// what any consumer is called.
-			if _, err := consumerInto(text, "mesh_node_module"); err != nil {
-				problems = append(problems, fmt.Sprintf(
-					"%s serves %s, and the value it serves as %q %s", m.Module, provision, key, err))
-			}
-		}
-	}
-	return problems
-}
-
-func sortedServes(serves map[string]map[string]any) []string {
-	out := make([]string, 0, len(serves))
-	for k := range serves {
-		out = append(out, k)
-	}
-	sort.Strings(out)
-	return out
-}
-
-func sortedAnyKeys(values map[string]any) []string {
-	out := make([]string, 0, len(values))
-	for k := range values {
-		out = append(out, k)
-	}
-	sort.Strings(out)
-	return out
-}
-
-// derivedFor is what the provider on this machine derives for one consumer of one provision
-// (novox/hq ADR 0201).
-//
-// Settled first, then derived: an operator may set a prefix on what the provider serves and the
-// mesh still fills the consumer's half of it ([ADR 0174]). Only the keys that actually name the
-// consumer are returned — the rest of a `serves` block is the same for every consumer and is
-// already in the provider's own definition, so repeating it here would be a second copy to go
-// stale.
-//
-// The first module in the resolved order that says it serves the provision answers, which is the
-// choice servedOnThisMachine makes for the consumer's half. Nothing serving it on this machine is
-// not an error: a contribution can reach a machine whose provider is a record or an adapter, and
-// then there is nothing derived to tell.
-func (r Resolution) derivedFor(provision, as, consumer, local string, settings SettingsBy) (map[string]any, error) {
-	for _, m := range r.Modules {
-		serves, said := m.Serves[provision]
-		if !said {
-			continue
-		}
-		var names map[string]any
-		for key, value := range serves {
-			if text, ok := value.(string); ok && strings.Contains(text, "${consumer:") {
-				if names == nil {
-					names = map[string]any{}
-				}
-				names[key] = value
-			}
-		}
-		if names == nil {
-			return nil, nil
-		}
-		// **A consumer that keeps several holders of this provision is refused** — this is issue
-		// 124's own failure one case to the side, and it would be just as quiet.
-		//
-		// Each holder gets its own login, `…_<local>` (ADR 0094), and a provider derives from the
-		// login, so it would make one resource per holder. The consumer's side has no such
-		// dimension: one binding file per provision, one `${bound:<provision>:<key>}`, both
-		// derived from the un-suffixed identity. So the provider would create the holder's
-		// resource and the consumer would be configured against a name nothing made — it would
-		// authenticate successfully and be refused on every object, which reads like a credential
-		// fault and is not one.
-		//
-		// Lifting this means giving the consumer's side a local dimension. That is a decision,
-		// not an omission, and until it is taken the mesh says so rather than guessing.
-		if local != "" {
-			return nil, fmt.Errorf(
-				"%s keeps several holders of %s (this one is %q), and %s derives %s for each "+
-					"consumer from the login the mesh minted. Each holder has its own login, and a "+
-					"consumer is told one value per requirement — so the two ends would name "+
-					"different things and nothing would compare them (novox/hq ADR 0201)",
-				consumer, local, provision, m.Module, orNothing(sortedAnyKeys(names)))
-		}
-		settled, err := Settle(names, settings[m.Module])
-		if err != nil {
-			return nil, fmt.Errorf("%s serving %s: %w", m.Module, provision, err)
-		}
-		derived, err := ServedTo(settled, as)
-		if err != nil {
-			return nil, fmt.Errorf("%s serving %s to %s: %w", m.Module, provision, as, err)
-		}
-		return derived, nil
-	}
-	return nil, nil
-}
-
-// notTranscribed refuses a consumer's file that writes out the value its provider derives for it,
-// instead of asking for it (novox/hq ADR 0201, issue 124).
-//
-// **What would have caught the one wrong instance.** The object store's three consumers each wrote
-// their bucket into their own configuration by hand. One of them named a predecessor's bucket, and
-// nothing compared it to what the provider would actually create: the module would have
-// authenticated successfully and been refused on every object, which reads like a credential fault
-// and is not one. It looked authoritative for months.
-//
-// The test is exact and costs one string search: a definition whose file already contains the
-// value the mesh is about to derive for it has written down somebody else's rule. It cannot be a
-// coincidence — a derived value carries the identity the mesh minted for this very consumer on
-// this very machine, which nothing else would spell out — and it cannot be checked afterwards,
-// because after substitution every consumer's file contains it legitimately.
-//
-// Only values that actually name the consumer are judged. A provider that serves a constant under
-// the same key serves the same constant to everyone, and a consumer repeating it is redundant
-// rather than wrong.
-func notTranscribed(resource map[string]any, known map[string]map[string]string, module string) error {
-	if fmt.Sprint(resource["type"]) != "file" {
-		return nil
-	}
-	content, ok := resource["content"].(string)
-	if !ok || content == "" {
-		return nil
-	}
-	for _, provision := range sortedKnown(known) {
-		values := known[provision]
-		identity := values["as"]
-		if identity == "" {
-			continue
-		}
-		for _, key := range sortedStringKeys(values) {
-			if key == "as" {
-				// The login is not derived from itself, and a consumer that must present it in a
-				// connection string legitimately has it from `${bound:…}` — which is what it will
-				// be after substitution, so this would judge the substitution, not the module.
-				continue
-			}
-			value := values[key]
-			if value == "" || !namesTheConsumer(value, identity) {
-				continue
-			}
-			if !strings.Contains(content, value) {
-				continue
-			}
-			return fmt.Errorf(
-				"%s writes %q into %v, and that is exactly what %s derives for it — a definition "+
-					"keeping its own copy of somebody else's naming rule is one that can disagree "+
-					"with it, silently. Say ${bound:%s:%s} and be told",
-				module, value, resource["id"], provision, provision, key)
-		}
-	}
-	return nil
-}
-
-// namesTheConsumer is whether a derived value was built from this consumer's identity — in the
-// alphabet it was minted in, or as a DNS label. A value that does not contain it was not derived
-// from it, whatever else it may be.
-func namesTheConsumer(value, identity string) bool {
-	return strings.Contains(value, identity) || strings.Contains(value, asDNSLabel(identity))
-}
-
-func sortedKnown(known map[string]map[string]string) []string {
-	out := make([]string, 0, len(known))
-	for k := range known {
-		out = append(out, k)
-	}
-	sort.Strings(out)
-	return out
-}
-
-func sortedStringKeys(values map[string]string) []string {
-	out := make([]string, 0, len(values))
-	for k := range values {
-		out = append(out, k)
-	}
-	sort.Strings(out)
-	return out
-}

internal/catalogue/contributes_test.go

@@ -197,27 +197,6 @@ func TestARouteCanBeSetPerMesh(t *testing.T) {
 	}
 }
 
-func TestASettingReachesAContributionOnlyWhereItDeclaresTheKey(t *testing.T) {
-	// novox/hq 04-ISSUES/173: the mail module's site name, set so its environment file could read
-	// it, arrived in every route it contributed. A setting overrides a key the contribution
-	// declares and adds none — the provider reads the contribution as a contract.
-	got, _ := Resolve(shelf(proxy(), published("board", "board", 8080)), []string{"board"}, workstation(), World{})
-
-	out, err := got.Declaration(Rendering{Settings: SettingsBy{
-		"board": {{From: "the mesh", Values: map[string]any{"host": "dashboard", "sitename": "Board"}}},
-	}})
-	if err != nil {
-		t.Fatal(err)
-	}
-	given := received(t, out)
-	if given[0].Values["host"] != "dashboard" {
-		t.Fatalf("the setting did not override the route's host: %v", given[0].Values)
-	}
-	if _, leaked := given[0].Values["sitename"]; leaked {
-		t.Fatalf("a setting the route never declared reached the proxy: %v", given[0].Values)
-	}
-}
-
 func TestReceivingWhatYouDoNotProvideIsRefused(t *testing.T) {
 	// It would create a file nobody ever writes to, on a machine where nothing asked for it.
 	_, err := ParseManifest([]byte(`{"module":"traefik","version":"1",