Keep a machine's discovery answer under the bus's message limit

Every tool's schema in one $SRV.INFO reply outgrew max_payload on machines
serving 137-206 tools, and the refused reply was dropped silently, so search
and a machine's view went empty. Module tools now announce without schema;
describe and tools/list ask the module for it. An answer still too large has
its descriptions cut to a line, and a failed reply is logged.

node-tools/internal/announce/announce.go

@@ -74,11 +74,19 @@ func (e Endpoint) info() micro.EndpointInfo {
 		"kind": e.Kind, "module": e.Module, "tool": e.Tool, "node": e.Node,
 		"description": e.Description, "interchangeable": boolWord(e.Interchangeable),
 	}
-	schema := strings.TrimSpace(string(e.Schema))
-	if schema == "" || schema == "null" {
-		schema = "{}"
+	// **A seat's verb carries its schema; a module's tool does not.** Every tool's schema, once per
+	// subject it answers on, made a runtime's one answer outgrow the bus's largest message (1 MiB) once
+	// machines served a couple of hundred tools — and the answer that cannot be sent is silence: the
+	// machine vanished from discovery (2026-10-04). A module's tool's schema is asked of the runtime that
+	// serves it when a person describes it (its `tools` verb); a seat's verbs are few, and a seat has no
+	// `tools` verb of its own to ask.
+	if e.Kind == KindSeat {
+		schema := strings.TrimSpace(string(e.Schema))
+		if schema == "" || schema == "null" {
+			schema = "{}"
+		}
+		md["schema"] = schema
 	}
-	md["schema"] = schema
 	if e.Kind == KindSeat {
 		md["seat"] = e.Seat
 		md["scope"] = e.Scope
@@ -154,6 +162,20 @@ func Serve(conn *bus.Conn, s Service, current func() []Endpoint) (func(), error)
 		if err != nil {
 			return nil
 		}
+		// Too large for the bus is no answer at all, and was silent: shorten every description to its
+		// first line and say so, rather than vanish.
+		if limit := conn.MaxPayload(); limit > 0 && int64(len(body)) > limit {
+			if info, ok := v.(micro.Info); ok {
+				for i := range info.Endpoints {
+					info.Endpoints[i].Metadata["description"] = firstLine(info.Endpoints[i].Metadata["description"])
+				}
+				if shorter, err := json.Marshal(info); err == nil {
+					conn.Logf("[mesh-tools] what this runtime serves is %d bytes, beyond the bus's %d; announced with each description cut to its first line (%d bytes)",
+						len(body), limit, len(shorter))
+					body = shorter
+				}
+			}
+		}
 		return body
 	}
 	var stops []func()
@@ -209,3 +231,17 @@ func Endpoints(i micro.Info) []Endpoint {
 	}
 	return out
 }
+
+// firstLine is a description's first sentence or line, at most 160 characters.
+func firstLine(s string) string {
+	if i := strings.IndexAny(s, "\n"); i >= 0 {
+		s = s[:i]
+	}
+	if i := strings.Index(s, ". "); i >= 0 {
+		s = s[:i+1]
+	}
+	if len(s) > 160 {
+		s = s[:157] + "..."
+	}
+	return s
+}

node-tools/internal/announce/announce_test.go

@@ -0,0 +1,54 @@
+package announce
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// What a machine serves fits the bus's largest message (1 MiB) with room to spare at several hundred
+// tools: a module's tool is announced without its schema, which made a machine with ~200 tools outgrow it
+// and vanish from discovery (2026-10-04). A seat's verb keeps its schema.
+func TestAMachinesAnnouncementFitsTheBusAtSeveralHundredTools(t *testing.T) {
+	schema := json.RawMessage(`{"type":"object","properties":{` + strings.Repeat(`"field_with_a_long_name":{"type":"string","description":"a description of what this argument means, long enough to matter"},`, 12) + `"last":{"type":"string"}}}`)
+	description := strings.Repeat("A tool that does something useful, described at the length the catalogue's tools are. ", 3)
+	var endpoints []Endpoint
+	for i := 0; i < 400; i++ {
+		for _, subject := range []string{fmt.Sprintf("mesh.mod.m%d.tool.t", i), fmt.Sprintf("mesh.mod.m%d.tool.t.laptop", i)} {
+			endpoints = append(endpoints, Endpoint{Kind: KindTool, Module: fmt.Sprintf("m%d", i), Tool: "t", Node: "laptop",
+				Description: description, Schema: schema, Subject: subject})
+		}
+	}
+	endpoints = append(endpoints, Endpoint{Kind: KindSeat, Module: "m0", Tool: "verb", Seat: "a-seat", Scope: "mesh",
+		Description: "a verb", Schema: schema, Subject: "mesh.seat.a-seat.tool.verb"})
+	body, err := json.Marshal(Info(Service{Name: "node-tools", ID: "laptop"}, endpoints))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(body) > 1<<20 {
+		t.Fatalf("400 tools announce %d bytes, beyond the bus's 1 MiB", len(body))
+	}
+	t.Logf("400 tools on two subjects each announce %d bytes", len(body))
+	back := Endpoints(Info(Service{Name: "node-tools", ID: "laptop"}, endpoints))
+	if len(back[0].Schema) != 0 {
+		t.Fatalf("a module's tool still carries its schema: %s", back[0].Schema)
+	}
+	if seat := back[len(back)-1]; !strings.Contains(string(seat.Schema), "field_with_a_long_name") {
+		t.Fatalf("a seat's verb lost its schema: %s", seat.Schema)
+	}
+	withSchemas := 0
+	for range endpoints {
+		withSchemas += len(schema) * 2 // escaped inside a string
+	}
+	t.Logf("with every schema it would have been over %d bytes", len(body)+withSchemas)
+}
+
+func TestFirstLineShortensADescription(t *testing.T) {
+	if got := firstLine("One thing. And more after it."); got != "One thing." {
+		t.Fatalf("%q", got)
+	}
+	if got := firstLine(strings.Repeat("x", 300)); len(got) != 160 {
+		t.Fatalf("%d", len(got))
+	}
+}