diff --git a/cmd/mesh-controller/compose_equal_integration_test.go b/cmd/mesh-controller/compose_equal_integration_test.go
index 09bf68e1..335645ca 100644
--- a/cmd/mesh-controller/compose_equal_integration_test.go
+++ b/cmd/mesh-controller/compose_equal_integration_test.go
@@ -49,6 +49,9 @@ func TestEveryMachineComposesAlikeBothWays(t *testing.T) {
 	started := time.Now()
 	phase := func(what string) { t.Logf("[%s] %s", time.Since(started).Round(time.Second), what) }
 	f, source := equalityFacts(t)
+	if len(f.Machines) < 1 {
+		t.Fatalf("the facts (%s) hold no machine, so nothing was composed and nothing is proved", source)
+	}
 	t.Logf("the facts of %s (%s): %d machine(s)", f.Taken.Format("2006-01-02 15:04:05"), source, len(f.Machines))
 	shelf, err := shelfOfFacts(f)
 	if err != nil {
@@ -65,7 +68,7 @@ func TestEveryMachineComposesAlikeBothWays(t *testing.T) {
 		foreseenPorts            = map[string][]string{}
 		readOld, readSDK         = map[string]composedBoth{}, map[string]composedBoth{}
 		oldMade, sdkMade         made
-		oldRefused               = map[string]bool{}
+		oldRefused               = map[string]string{}
 		sendRefused              = map[string]string{}
 		errA, errOld, errSDK     error
 	)
@@ -128,10 +131,11 @@ func TestEveryMachineComposesAlikeBothWays(t *testing.T) {
 		oldGens, oldGensErr := generators(ctx, oldStore)
 		for _, m := range f.Machines {
 			if oldGensErr != nil {
-				break
+				oldRefused[m.Name] = oldGensErr.Error()
+				continue
 			}
 			if _, _, err := composedAndValidated(ctx, oldStore, m.Name, oldGens, Allocating); err != nil {
-				oldRefused[m.Name] = true
+				oldRefused[m.Name] = err.Error()
 			}
 		}
 		phase("(b) the controller's send of every machine")
@@ -184,16 +188,20 @@ func TestEveryMachineComposesAlikeBothWays(t *testing.T) {
 		failures = append(failures, bothWaysDiffer(m.Name, "(a) Foreseeing", oldForeseen[m.Name], sdkForeseen[m.Name], false)...)
 		failures = append(failures, bothWaysDiffer(m.Name, "(c) Reading after the send", readOld[m.Name], readSDK[m.Name], true)...)
 	}
-	// A machine refused on either side sends nothing, so what the controller made on the way to refusing it is no send's.
+	// **The send must compose every machine both ways.** A machine either send refuses is no proof of anything: what the
+	// controller made on the way to refusing it is no send's, and a refusal alike says nothing about what a send of it makes.
+	// So it fails here, naming the machine and both refusals (a refusal alike in (a), the Foreseeing on a store that holds no
+	// secret a send made, is said and stays). A pass proves that every machine of the facts was sent and compared.
 	refused := map[string]bool{}
-	for m := range sendRefused {
-		refused[m] = true
-	}
-	for m := range oldRefused {
-		refused[m] = true
-	}
-	for m := range refused {
-		t.Logf("%s: refused on one side or both, so its ports and secrets are left out of the comparison of the send", m)
+	for _, m := range f.Machines {
+		why, oldNo := oldRefused[m.Name]
+		sdkWhy, sdkNo := sendRefused[m.Name]
+		if !oldNo && !sdkNo {
+			continue
+		}
+		refused[m.Name] = true
+		failures = append(failures, fmt.Sprintf("%s, (b) the send: it is not composed both ways, so nothing of it is compared: "+
+			"the controller's refusal %s, mesh-sdk's %s", m.Name, quoted(oneLine(why)), quoted(oneLine(sdkWhy))))
 	}
 	failures = append(failures, madeDiffer("(b) the send", oldMade, sdkMade, refused)...)
 
@@ -234,7 +242,7 @@ func TestEveryMachineComposesAlikeBothWays(t *testing.T) {
 	if len(failures) > 0 {
 		t.Fatalf("the two compositions differ on %d point(s):\n  %s", len(failures), strings.Join(failures, "\n  "))
 	}
-	t.Logf("%d machine(s) compose alike both ways", len(f.Machines))
+	t.Logf("%d machine(s) were sent and compose alike both ways", len(f.Machines))
 }
 
 // equalityFacts is the snapshot the comparison composes: MESH_FACTS, else the one captured in testdata, else the facts of a