A push raises what a module hears, not only a start

A module's declaration and its consumer are derived from the same records, and only one of them
followed a push: the consumers were raised when the control plane started serving, so a module that
gained a `consumes` was sent a declaration it could act on and a consumer that never delivered the
event — with nothing anywhere saying the two disagreed. Found on review: the catalogue's own replay
subscription was recorded, granted and never delivered.

Everything the raise does is idempotent, so a push may do it.

cmd/mesh-controller/push.go

@@ -162,7 +162,13 @@ func declare(ctx context.Context, args []string) error {
 		return err
 	}
 
-	server, err := connectLink(ctx, nil, nil, nil)
+	// **With the inventory, so the bus is raised** (novox/hq ADR 0134, design 30). A module's
+	// declaration and how it hears what it consumes move together: its consumer is derived from the
+	// same records this declaration is composed from. Raised only when the control plane started
+	// serving, a module that gained a `consumes` was sent a declaration it could act on and a
+	// consumer that never delivered the event — and nothing anywhere said the two disagreed
+	// (found on review, 2026-09-28). Everything the raise does is idempotent.
+	server, err := connectLink(ctx, inv, nil, nil)
 	if err != nil {
 		return err
 	}

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.Set("Accept", media)
+		request.Header.Add("Accept", media)
 	}
 	response, err := r.client().Do(request)
 	if err != nil {

internal/link/serve.go

@@ -476,7 +476,15 @@ 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).
-		if err := s.bus.PublishSeatEvent(ctx, MeshControllerSeat, KeyBuiltBefore, replayed(a)); err != nil {
+		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 {
 			// 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",
@@ -601,15 +609,3 @@ 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
-}