Read how a module says each resource is ready, and send it to engines that read it (hq ADR 0240, to-be 48 Phase B)

A module could say nothing about what ready means for what it runs, so a web
application with its port open and its requests hanging passed everything for
eleven hours (issue 145). A long-running resource now carries `health` — the
image's own check adopted by name, http, tcp, exec, unit or a module's own tool,
with its timing — refused near its author when it names a port or an address,
an endpoint the module does not declare, a tool it does not serve, a tool check
alone, or a timing outside the record's bounds. It is composed with the endpoint
as the port this machine published it on, and sent only to a node-engine whose
statement says it reads it: an older one would refuse the whole declaration.
The engine is granted its own machine's instance of each health tool. `module
check` warns of every long-running resource without `health`, counts them for
the catalogue, and refuses them from 2026-11-18. A check's findings stay out of
a condition's summary. The node-engine's validator is vendored at its Phase B
commit, so what is composed is judged by the words the engine takes.

internal/link/protocol.go

@@ -415,6 +415,11 @@ func EnrolProof(secret string, public []byte, overlay, sealing, serving string)
 // LivenessContract is the version of the health statement this controller reads (ADR 0240 Phase A).
 const LivenessContract = 1
 
+// ReadinessContract is the statement of an engine that also reads a resource's declared `health` and
+// judges it (ADR 0240 Phase B): only to an engine whose statement says this or later is the field sent,
+// because an older one parses strictly and would refuse the whole declaration for it.
+const ReadinessContract = 2
+
 // Health is one statement of a machine's long-running resources (to-be 48 §4): in every report, as the
 // event HealthSubject between reports on each change, and again every minute while one is not healthy.
 // The node-engine's own (mesh-host internal/link Health); a test on each side holds the field names.
@@ -445,6 +450,10 @@ type ResourceHealth struct {
 	Since    time.Time `json:"since"`
 	Streak   int       `json:"streak,omitempty"`
 	Restarts int       `json:"restarts,omitempty"`
+	// Check is the declared check's kind (ADR 0240 Phase B), empty for a resource judged by liveness
+	// alone; Needs is the provision the check exercises (to-be 48 §6).
+	Check string `json:"check,omitempty"`
+	Needs string `json:"needs,omitempty"`
 }
 
 // HealthSaid is the health event's body: the machine and its statement. The machine is read from the

internal/link/protocol_test.go

@@ -29,8 +29,9 @@ func TestTheWireFormatIsExactlyTheseFieldNames(t *testing.T) {
 		{Report{Node: "n", Health: &Health{Contract: LivenessContract}}, []string{"node", "health"}},
 		{Health{Contract: LivenessContract, Resources: []ResourceHealth{}}, []string{"contract", "at", "resources"}},
 		{ResourceHealth{Module: "m", Resource: "m.r", Kind: "container", Target: "t", State: StateUnhealthy,
-			Reason: "restarting", Streak: 2, Restarts: 3},
-			[]string{"module", "resource", "kind", "target", "state", "reason", "since", "streak", "restarts"}},
+			Reason: "restarting", Streak: 2, Restarts: 3, Check: "http", Needs: "postgres-database"},
+			[]string{"module", "resource", "kind", "target", "state", "reason", "since", "streak", "restarts",
+				"check", "needs"}},
 		{HealthSaid{Node: "n"}, []string{"node", "health"}},
 	} {
 		raw, err := json.Marshal(c.value)