A bundle stands on the toolchain it is compiled in (hq issue 211)

A manifest names its toolchain by language, not in build.on, so the planner did not know a bundle
depends on the module that publishes its toolchain and built the two in one tier: the bundle
against the old toolchain, recorded as built from the new commit. The edge is read from the
manifest, so it holds before any build recorded it, and a toolchain that moves rebuilds every
bundle compiled in it.

internal/broker/nats.go

@@ -465,7 +465,9 @@ func PermissionsFor(p Principal) (Permissions, error) {
 		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.
-		sub = append(sub, announcing(serves...)...)
+		// 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()...)
 		// Nothing about consumers: it consumes nothing. A module's reactions to events are its
 		// own long-lived process, which ADR 0175 leaves where it is; what moves here is tools.
@@ -793,12 +795,14 @@ func invokedSubjects(invokes []string) ([]string, error) {
 // 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"}
+	out := []string{"$SRV.PING", "$SRV.INFO", "$SRV.STATS"}
 	for _, n := range names {
 		if !safeSubject.MatchString(n) {
 			continue
 		}
-		out = append(out, "$SRV.PING."+n, "$SRV.PING."+n+".>", "$SRV.INFO."+n, "$SRV.INFO."+n+".>")
+		for _, verb := range []string{"PING", "INFO", "STATS"} {
+			out = append(out, "$SRV."+verb+"."+n, "$SRV."+verb+"."+n+".>")
+		}
 	}
 	return out
 }

internal/inventory/dependencies.go

@@ -5,6 +5,7 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/novox/mesh-controller/internal/builder"
 	"github.com/novox/mesh-controller/internal/catalogue"
 )
 
@@ -96,6 +97,21 @@ func dependenciesOf(entries []Entry, against map[string][]string, read map[strin
 					add(name, on.Module, EdgeDeclared)
 				}
 			}
+			// **A bundle stands on the toolchain it is compiled in** (novox/hq 04-ISSUES/211). A
+			// manifest names its toolchain by language, not in `build.on`, so the edge was implicit
+			// and a merge that moved the toolchain and a bundle together built both in one tier —
+			// the bundle against the toolchain as it was, recorded as built from the new commit. Read
+			// from the manifest, so it holds before any build has recorded what it stood on; and a
+			// toolchain that moves rebuilds every bundle compiled in it, which is what a toolchain
+			// carrying a bundle's dependencies requires.
+			for _, a := range e.Manifest.Build.Artifacts {
+				if a.Kind != catalogue.ArtifactBundle {
+					continue
+				}
+				if chain, err := builder.ToolchainFor(a.Language); err == nil {
+					add(name, chain.Base, EdgeStandsOn)
+				}
+			}
 		}
 		for _, ref := range against[name] {
 			if rest, ok := strings.CutPrefix(ref, catalogue.ArtifactStoreScheme); ok {

internal/inventory/dependencies_test.go

@@ -62,3 +62,41 @@ func TestDependenciesAreOneRelationWithTheirKinds(t *testing.T) {
 		}
 	}
 }
+
+// novox/hq 04-ISSUES/211: a bundle stands on the toolchain it is compiled in, so a merge moving both
+// builds the toolchain first — read from the manifest, before any build recorded it.
+func TestABundleStandsOnTheToolchainItIsCompiledIn(t *testing.T) {
+	entries := []Entry{
+		{Manifest: catalogue.Manifest{Module: "mesh-tools"}, Source: Source{Repository: "novox/mesh-tools"}},
+		{Manifest: catalogue.Manifest{Module: "mesh-tools-go"}, Source: Source{Repository: "novox/mesh-tools-go"}},
+		{Manifest: catalogue.Manifest{Module: "node-tools", Build: &catalogue.Build{Artifacts: []catalogue.Artifact{
+			{Name: "runtime", Kind: catalogue.ArtifactBundle, Language: "go", System: "arch", From: "cmd/node-tools"}}}},
+			Source: Source{Repository: "novox/mesh-tools"}},
+		{Manifest: catalogue.Manifest{Module: "nftables", Build: &catalogue.Build{Artifacts: []catalogue.Artifact{
+			{Name: "tools", Kind: catalogue.ArtifactBundle, Language: "typescript", Entrypoints: []string{"tools/index.js"}}}}},
+			Source: Source{Repository: "novox/mesh-catalog"}},
+		{Manifest: catalogue.Manifest{Module: "photos", Build: &catalogue.Build{Artifacts: []catalogue.Artifact{
+			{Name: "server", Kind: catalogue.ArtifactImage, From: "Dockerfile"}}}},
+			Source: Source{Repository: "novox/photos"}},
+	}
+	edges := dependenciesOf(entries, nil, nil)
+	has := func(from, to string) bool {
+		for _, e := range edges {
+			if e.From == from && e.To == to && e.Kind == EdgeStandsOn {
+				return true
+			}
+		}
+		return false
+	}
+	if !has("nftables", "mesh-tools") {
+		t.Errorf("a TypeScript bundle does not stand on the TypeScript toolchain: %v", edges)
+	}
+	if !has("node-tools", "mesh-tools-go") {
+		t.Errorf("a Go bundle does not stand on the Go toolchain: %v", edges)
+	}
+	for _, e := range edges {
+		if e.From == "photos" && e.Kind == EdgeStandsOn {
+			t.Errorf("an image stands on a toolchain it is not compiled in: %v", e)
+		}
+	}
+}

internal/link/announce.go

@@ -17,7 +17,7 @@ import (
 // DiscoverySubjects are where one service instance is asked to say what it is.
 func DiscoverySubjects(name, id string) []string {
 	var out []string
-	for _, verb := range []string{"PING", "INFO"} {
+	for _, verb := range []string{"PING", "INFO", "STATS"} {
 		out = append(out, "$SRV."+verb, "$SRV."+verb+"."+name, "$SRV."+verb+"."+name+"."+id)
 	}
 	return out
@@ -35,6 +35,16 @@ func (b OverNATS) Announce(info micro.Info, logger *log.Logger) (func(), error)
 	if err != nil {
 		return nil, err
 	}
+	// Statistics the protocol asks for; the controller keeps none per verb, so it answers its
+	// identity and its endpoints with nothing counted — an honest zero, not a refusal.
+	stats := micro.Stats{ServiceIdentity: info.ServiceIdentity, Type: micro.StatsResponseType}
+	for _, e := range info.Endpoints {
+		stats.Endpoints = append(stats.Endpoints, &micro.EndpointStats{Name: e.Name, Subject: e.Subject, QueueGroup: e.QueueGroup})
+	}
+	statsBody, err := json.Marshal(stats)
+	if err != nil {
+		return nil, err
+	}
 	var subs []*nats.Subscription
 	done := make(chan struct{})
 	stop := func() {
@@ -46,8 +56,11 @@ func (b OverNATS) Announce(info micro.Info, logger *log.Logger) (func(), error)
 	for _, subject := range DiscoverySubjects(info.Name, info.ID) {
 		subject := subject
 		body := infoBody
-		if len(subject) >= 9 && subject[:9] == "$SRV.PING" {
+		switch {
+		case len(subject) >= 9 && subject[:9] == "$SRV.PING":
 			body = pingBody
+		case len(subject) >= 10 && subject[:10] == "$SRV.STATS":
+			body = statsBody
 		}
 		bind := func() (*nats.Subscription, error) {
 			return b.Conn.Subscribe(subject, func(msg *nats.Msg) {