Round 2 T2, T3, T4, T5: the tool runner ends G with its merge-base test count; the wait test runs its rows side by side

The tests G added fold into existing ones as subtests (design 47 G §626, A-306: 171 tests down to 154, integration 9
down to 7). TestMeshWaitRefusesLoudlyAndNeverLoops runs its groups of one-second rows as parallel subtests, each
on a runtime of its own, 15 s down to 5 s (A-311: the one-second floor of a wait's timeout stands, no clock is
injected). The go.mod no longer requires meshconditionsclient, which no package loads (T4). Node names in the
lines G adds are role names (T5).

Builds: design 47 G §626, design 34 every-event §19, A-306, A-311; review round 2 findings T2, T3, T4, T5
Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h

node-tools/internal/runtime/ledger_integration_test.go

@@ -8,6 +8,7 @@ import (
 	"errors"
 	"fmt"
 	"strings"
+	"sync"
 	"testing"
 
 	"git.novox.be/novox/mesh-sdk/go/buscalls"
@@ -287,4 +288,70 @@ func TestTheLedgerKeepsItsPromisesOnTheBus(t *testing.T) {
 			}
 		})
 	}
+	// Design 47 G §559, A-153: against the real bus a publish with ack answers the sequence the bus gave it, and a subscription
+	// for new messages hears only what is published after it was made, on the subject mesh-sdk's one rule names for the event;
+	// a wildcard is refused.
+	t.Run("AnAckedPublishAnswersItsSequenceAndANewSubscriptionHearsOnlyWhatComesAfter", func(t *testing.T) {
+		mt.New(t)
+		nc, err := nats.Connect(mt.URL(t))
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Cleanup(nc.Close)
+		js, _ := jetstream.New(nc)
+		ctx := context.Background()
+		if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: "SEATEVENTS", Subjects: []string{"mesh.seat.mesh-conditions.event.>"}}); err != nil {
+			t.Fatal(err)
+		}
+		conn := connect(t, "node-tools", "anchor")
+		publish := func(body string) {
+			t.Helper()
+			if _, err := js.Publish(ctx, "mesh.seat.mesh-conditions.event.findings-asked", []byte(body)); err != nil {
+				t.Fatal(err)
+			}
+		}
+		publish(`{"before":true}`)
+
+		var mu sync.Mutex
+		var heard []string
+		stop, err := conn.SubscribeNew("mesh-conditions.findings-asked", func(raw json.RawMessage) error {
+			var env bus.Envelope
+			_ = json.Unmarshal(raw, &env)
+			mu.Lock()
+			heard = append(heard, env.Key+" "+string(env.Body))
+			mu.Unlock()
+			return nil
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer stop()
+		publish(`{"after":true}`)
+		publish(`{"after":2}`)
+		mt.Until(t, func() error {
+			mu.Lock()
+			defer mu.Unlock()
+			if len(heard) < 2 {
+				return context.DeadlineExceeded
+			}
+			return nil
+		})
+		mu.Lock()
+		if len(heard) != 2 || heard[0] != `mesh-conditions.findings-asked {"after":true}` {
+			t.Errorf("heard %v, want the messages after the subscription alone, in order", heard)
+		}
+		mu.Unlock()
+
+		for name, want := range map[string]string{"mesh-conditions.*": "[A-Za-z0-9_-]"} {
+			if _, err := conn.SubscribeNew(name, func(json.RawMessage) error { return nil }); err == nil || !strings.Contains(err.Error(), want) {
+				t.Errorf("a subscription for %s answered %v, want one naming %q", name, err, want)
+			}
+		}
+
+		first, err := conn.PublishAsAcked("node-tools", bus.Envelope{Key: "finding-written", Body: json.RawMessage(`{}`)})
+		second, err2 := conn.PublishAsAcked("node-tools", bus.Envelope{Key: "finding-written", Body: json.RawMessage(`{}`)})
+		if err != nil || err2 != nil || first == 0 || second != first+1 {
+			t.Errorf("acknowledged publishes answered %d (%v) and %d (%v), want consecutive sequences", first, err, second, err2)
+		}
+	})
 }