Retry only a failed apply that is not held, answer a repeated compose from the last pass, and say the try the refusal named (issue 774, review round 1)

The verb compose has no warrant (ADR 0563 §2): Agent.Retry released a module held for a failed backup and re-applied
one already running its want. RetryFailed tries again only a failed apply not held, and refuses in words otherwise.
A hand ask no longer restarts the growing bound, and a pass less than askedWithin old is the answer, so a caller in a
loop drives no passes against the vault. A composer whose loop ended refuses at once. The retry line said try N+1.
The test's first shadow now ends before slowAfter is set, a race the race detector found under the new timing.

internal/selfcompose/selfcompose_test.go

@@ -241,6 +241,9 @@ func TestTheNodeComposesItsWantsFromTheBus(t *testing.T) {
 	b.mu.Unlock()
 	// Issue 774, 2026-10-31: the verb compose makes a pass now and says how it went; a composer that runs no watch
 	// makes none, and says so rather than waiting.
+	// The pass made at the start is less than askedWithin old for a moment: the ask waits that out first.
+	setFor(t, &askedWithin, 200*time.Millisecond)
+	time.Sleep(250 * time.Millisecond)
 	madeBefore := composed.Load()
 	cctx, ccancel := context.WithTimeout(ctx, 5*time.Second)
 	nowPass, err := c.ComposeNow(cctx)
@@ -248,9 +251,15 @@ func TestTheNodeComposesItsWantsFromTheBus(t *testing.T) {
 	if err != nil || nowPass.At.IsZero() || nowPass.Refused != "" || !nowPass.Again.IsZero() || composed.Load() == madeBefore {
 		t.Errorf("compose now: %+v (%v), %d pass(es) made; want one pass, composed", nowPass, err, composed.Load()-madeBefore)
 	}
-	idle, icancel := context.WithTimeout(ctx, 20*time.Millisecond)
-	if _, err := New(env).ComposeNow(idle); err == nil {
-		t.Error("a composer that watches nothing answered compose now")
+	// Asked again at once, the last pass is the answer: a caller in a loop drives no passes back to back (review round 1).
+	madeBefore = composed.Load()
+	if again, err := c.ComposeNow(ctx); err != nil || !again.Earlier || !again.At.Equal(nowPass.At) || composed.Load() != madeBefore {
+		t.Errorf("compose now asked again at once: %+v (%v), %d pass(es) made; want the last pass, none made", again, err, composed.Load()-madeBefore)
+	}
+	// A composer whose loop runs not refuses at once, not after the verb's whole bound.
+	idle, icancel := context.WithTimeout(ctx, 5*time.Second)
+	if _, err := New(env).ComposeNow(idle); err == nil || !strings.Contains(err.Error(), "runs no loop") || idle.Err() != nil {
+		t.Errorf("a composer that watches nothing answered compose now: %v", err)
 	}
 	icancel()
 	lemursKey, _ := delivery.ComposedKey("n1", "lemurs", fp)
@@ -347,7 +356,9 @@ func TestTheNodeComposesItsWantsFromTheBus(t *testing.T) {
 			t.Errorf("%s: a pass whose run ended refused %q", name, *refusals)
 		}
 		if !row.composes && !row.cancel && len(*refusals) > 0 {
-			says := strings.Contains((*refusals)[0], "; the node composes again at ") && strings.HasSuffix((*refusals)[0], "(try 1)")
+			// The retry pass says the same try the refusal named (review round 1: it said try 2 for try 1).
+			says := strings.Contains((*refusals)[0], "; the node composes again at ") && strings.HasSuffix((*refusals)[0], "(try 1)") &&
+				strings.Contains(c2.againLine(), "(try 1)")
 			if says != row.again || c2.owed.Load() != row.again || (c2.last.Again.IsZero() == row.again) || c2.last.Refused != (*refusals)[0] {
 				t.Errorf("%s: refused %q, owes a pass %v, last pass %+v; want the time it composes again said and owed: %v",
 					name, (*refusals)[0], c2.owed.Load(), c2.last, row.again)
@@ -935,7 +946,8 @@ func TestTheNodeComposesItsWantsFromTheBus(t *testing.T) {
 	// Review of L2b, round 1, finding 2: the candidates' state is not there when the node starts (a delivery before the
 	// indexer made it): the shadow tries again, and answers once it appears.
 	sb.missing(delivery.PlacementCandidatesBucket, true)
-	go sh.Keep(sctx, func(int) time.Duration { return 5 * time.Millisecond })
+	kept := make(chan struct{})
+	go func() { sh.Keep(sctx, func(int) time.Duration { return 5 * time.Millisecond }); close(kept) }()
 	time.Sleep(30 * time.Millisecond)
 	sb.missing(delivery.PlacementCandidatesBucket, false)
 	sb.made(7)
@@ -1270,6 +1282,9 @@ func TestTheNodeComposesItsWantsFromTheBus(t *testing.T) {
 		t.Errorf("a shadow not ready said %q", nsaid)
 	}
 	nmu.Unlock()
+	// The first shadow ends before slowAfter is set: it reads it while it answers (a race the race detector names).
+	scancel()
+	<-kept
 	setFor(t, &slowAfter, time.Nanosecond) // every answer is slow: said, and noted in words that do not move with the time
 	nb.send(delivery.AssignerWantsBucket, agent.Update{Caught: true})
 	select {