Forget a kept build when its key is written again, and retry data items on the composer's bound (review round 1)

The builder claims a done key again as a new revision, so a build kept as done is dropped on any
write of its key. Data items that could not be worked out or written stay due and owe a pass after
the growing bound, so a first write refused before the state or grant exists is tried again
without waiting for an unrelated composition.

Claude-Session: https://claude.ai/code/session_01NcbgfJ9Gum47zkFKWRaovL

internal/selfcompose/data.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"sort"
 	"strings"
+	"time"
 
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/compose"
@@ -59,7 +60,7 @@ func (c *Composer) publishData(ctx context.Context) {
 	items, unplaced, err := dataItemsOf(ctx, itemsReader{reader{c: c}}, c.env.Mesh, scope)
 	if err != nil {
 		c.sayData("the data items of this node's modules cannot be worked out, and what the engine's state " +
-			delivery.EngineDataBucket + " holds stands: " + err.Error())
+			delivery.EngineDataBucket + " holds stands; " + c.oweData() + ": " + err.Error())
 		return
 	}
 	if len(unplaced) > 0 {
@@ -70,13 +71,13 @@ func (c *Composer) publishData(ctx context.Context) {
 	c.mu.Unlock()
 	wrote, removed, err := c.writeData(ctx, items, digests)
 	if err != nil {
-		c.mu.Lock()
-		c.dataDue = true // the next pass tries again, whatever it hands
-		c.mu.Unlock()
 		c.sayData("the data items of this node's modules are not all kept in " + delivery.EngineDataBucket +
-			", and are written again at the next composition: " + err.Error())
+			"; " + c.oweData() + ": " + err.Error())
 		return
 	}
+	c.mu.Lock()
+	c.dataTries = 0
+	c.mu.Unlock()
 	c.sayData("")
 	if wrote+removed > 0 {
 		c.env.Say(fmt.Sprintf("the data items of this node's modules: %d key(s) of %s written, %d deleted",
@@ -84,6 +85,20 @@ func (c *Composer) publishData(ctx context.Context) {
 	}
 }
 
+// oweData keeps the data items due and has the composer's loop make a pass again after the growing bound (LaterWait), as
+// a pass refused for a bus that did not answer is: the first write after a delivery may be refused while the state or
+// its grant is not on the bus yet, and nothing else would try again until an unrelated composition changed. It answers
+// the words that say when.
+func (c *Composer) oweData() string {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.dataDue = true
+	c.wait = LaterWait(c.dataTries)
+	c.dataTries++
+	c.owed.Store(true)
+	return fmt.Sprintf("tried again at %s (try %d)", time.Now().Add(c.wait).Format("15:04:05"), c.dataTries)
+}
+
 // sayData says a line about the data items once until it changes; "" clears it.
 func (c *Composer) sayData(line string) {
 	c.mu.Lock()