The seat declares the facts its holder states

The grant permitted the control plane to state what it applied and the seat said nothing about it, so
the check that every derived subscription has an owner found the catalogue subscribing to a subject
nothing publishes — which is exactly the fault that check exists for, pointed at me.

A seat carries the protocol of its role (novox/hq ADR 0129), so the facts are the mesh-controller
seat's `emits`. That is also what lets another module declare it consumes them. No accepts, so no work
queue is raised for the seat — only what its holder may say. The agreement test now holds all three
places to one another: the seat, the grant, and the words the mesh states them with.

internal/broker/states_agreement_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/novox/mesh-controller/internal/broker"
+	"github.com/novox/mesh-controller/internal/catalogue"
 	"github.com/novox/mesh-controller/internal/link"
 )
 
@@ -27,4 +28,17 @@ func TestTheFactsTheGrantPermitsAreTheFactsTheMeshStates(t *testing.T) {
 	if len(broker.ControllerStates) != 3 {
 		t.Errorf("the grant permits %v, which is more than the mesh states", broker.ControllerStates)
 	}
+	// **And the seat says it.** A seat carries the protocol of its role (novox/hq ADR 0129), so the
+	// facts the control plane states are the seat's `emits` — which is what lets anything else declare
+	// that it consumes them, and what the subject-agreement check reads to know they have an owner.
+	var declared []string
+	for _, seat := range catalogue.SeatsWithAProtocol() {
+		if seat.Name == broker.ControllerSeat {
+			declared = seat.Emits
+		}
+	}
+	if !slices.Equal(declared, broker.ControllerStates) {
+		t.Errorf("the %s seat emits %v and the grant permits %v", broker.ControllerSeat,
+			declared, broker.ControllerStates)
+	}
 }

internal/builder/registry.go

@@ -137,7 +137,7 @@ func (r Registry) has(ctx context.Context, url string, accept ...string) (bool,
 		return false, err
 	}
 	for _, media := range accept {
-		request.Header.Add("Accept", media)
+		request.Header.Set("Accept", media)
 	}
 	response, err := r.client().Do(request)
 	if err != nil {

internal/catalogue/seats.go

@@ -48,7 +48,11 @@ type Seat struct {
 //
 // In the order a person reads it: the mesh's own, then a node's.
 var defaultSeats = []Seat{
-	{Name: "mesh-controller", Scope: ScopeMesh, Decision: "novox/hq ADR 0079"},
+	// The control plane states what it did under the seat it holds (novox/hq ADR 0134): a role's
+	// events belong to the role, so they keep their address while the holder is replaced. No accepts,
+	// so no work queue is raised for it — only what its holder may say.
+	{Name: "mesh-controller", Scope: ScopeMesh, Decision: "novox/hq ADR 0079",
+		Emits: []string{"applied", "refused", "built-before"}},
 	{Name: "mesh-store", Scope: ScopeMesh, Delivers: "postgres-database", Decision: "novox/hq ADR 0079"},
 	// **Delivers the mesh's own bus, not `amqp`.** Those were the same word until
 	// ADR 0127 separated them: `amqp` is a backing service a module may require, and this seat is

internal/link/serve.go

@@ -476,15 +476,7 @@ func (s *Server) catchingUp(ctx context.Context, m Control) {
 		// module's event from a module called "control-plane", which does not exist — so the
 		// controller's own account refused it, every catalogue that asked what it missed was
 		// answered with nothing, and its graph kept the gap (found 2026-09-28).
-		body, err := json.Marshal(a)
-		if err != nil {
-			// A body that cannot be written is this program's fault, not the bus's, and publishing
-			// an empty one would put a fact on the mesh that says nothing.
-			s.log.Printf("cannot re-announce %s at %s: %v", a.Module, short(a.Commit), err)
-			_ = m.Took()
-			return
-		}
-		if err := s.bus.PublishSeatEvent(ctx, MeshControllerSeat, KeyBuiltBefore, body); err != nil {
+		if err := s.bus.PublishSeatEvent(ctx, MeshControllerSeat, KeyBuiltBefore, replayed(a)); err != nil {
 			// Said and abandoned rather than retried: the catalogue asks again every time it
 			// starts, and half a graph delivered twice is no better than half delivered once.
 			s.log.Printf("replaying %s at %s failed, and the rest is abandoned: %v",
@@ -609,3 +601,15 @@ func (s *Server) saysWhatItDid(ctx context.Context, report Report) {
 		s.log.Printf("could not say that %s %s: %v", report.Node, event, err)
 	}
 }
+
+// replayed is one announcement as the control plane states it. The same body the build machine's
+// outcome carries, because what the catalogue does with it is the same.
+func replayed(a Announcement) []byte {
+	raw, err := json.Marshal(a)
+	if err != nil {
+		// A body that cannot be marshalled is a programming error, not a bus failure, and an empty
+		// one is refused by the reader rather than silently taken as an announcement of nothing.
+		return nil
+	}
+	return raw
+}