A catalogue asks for what it was not there to hear

Its event queue is durable, so a running catalogue misses nothing. What it cannot
have is what was announced before it first ran — and on a fresh mesh that is never
arbitrary: the shared base, the store the catalogue runs on, and the catalogue
itself are each necessarily built BEFORE a catalogue exists to hear about them.
The graph's foundation is the part it never sees.

So it says it is catching up, and the control plane re-announces what it
recorded, oldest first, marked as a replay. Oldest first because a graph is built
in the order things happened: registering a module that stands on a base before
the base would point an edge at a version nothing has seen, and the shape of a
fresh mesh guarantees the base is both first and the one that was missed.

The replayer hands announcements back rather than publishing them, because the
wire belongs to the link package and a replay building its own events could drift
from what the builder emits — the one thing it must match exactly, since the
catalogue has a single handler for both.

Its own queue and its own consumer: two consumers on one queue split its
messages, and a catch-up request going to whichever half was not listening is a
gap that looks like a working mesh.

Toward novox/hq 04-ISSUES/050.

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

cmd/mesh-control/push.go

@@ -92,6 +92,11 @@ func serve(ctx context.Context) error {
 	if err := server.Follows(following{open}); err != nil {
 		return err
 	}
+	// And a catalogue that has just started, asking for what it missed. The same type answers
+	// both: what a build meant and what the builds were are two questions about one record.
+	if err := server.Answers(following{open}); err != nil {
+		return err
+	}
 
 	return server.Serve(ctx)
 }

cmd/mesh-control/upgrades.go

@@ -163,3 +163,34 @@ func sayUpgrade(module string, u inventory.Upgrade) string {
 	return fmt.Sprintf("when %s moves, the machines running it are sent the new version one at "+
 		"a time, stopping at the first that fails", module)
 }
+
+// Announceable is every build this mesh recorded, in the shape the builder announces one.
+//
+// **The catalogue asks for this when it starts, and the answer is the graph's foundation**
+// (novox/hq 04-ISSUES/050). A durable queue keeps what arrived after it existed, so a running
+// catalogue misses nothing — but the modules built before it first ran were announced to a queue
+// that did not exist, and on a fresh mesh those are always the same three: the shared base, the
+// store the catalogue runs on, and the catalogue itself.
+func (f following) Announceable(ctx context.Context) ([]link.Announcement, error) {
+	builds, err := f.open.inventory.Announceable(ctx)
+	if err != nil {
+		return nil, err
+	}
+	out := make([]link.Announcement, 0, len(builds))
+	for _, b := range builds {
+		a := link.Announcement{
+			Module: b.Module, Commit: b.Commit, Repository: b.Repository,
+			Path: b.Path, Ref: b.Ref, Against: b.Against,
+		}
+		if len(b.Manifest) > 0 {
+			a.Manifest = b.Manifest
+		}
+		for _, made := range b.Made {
+			a.Made = append(a.Made, link.MadeArtifact{
+				Name: made.Name, Kind: made.Kind, Reference: made.Reference,
+			})
+		}
+		out = append(out, a)
+	}
+	return out, nil
+}