A walk let go behind another reads as a wait: its note on the line, never late, and no tier of it watched (hq ADR 0276 review of #200)

cmd/mesh-controller/release_plan.go

@@ -448,7 +448,7 @@ func planBuilt(ctx context.Context, open *stores, module, commit, failed string,
 
 // startedBeside is the id of a started walk open beside this one — a merge's walk past its wait, not the
 // backlog's — or empty: one walk at a time (novox/hq ADR 0276).
-func startedBeside(ctx context.Context, inv *inventory.Inventory, id string) (string, error) {
+func startedBeside(ctx context.Context, inv *inventory.Inventory, id string, created time.Time) (string, error) {
 	plans, err := inv.OpenPlans(ctx)
 	if err != nil {
 		return "", err
@@ -458,13 +458,21 @@ func startedBeside(ctx context.Context, inv *inventory.Inventory, id string) (st
 			continue
 		}
 		// Started: a tier asked, or on its way (let go, or waiting for nobody) before this one.
-		if q.Tier > 0 || askedAny(q) || q.Created.Before(createdOf(ctx, inv, id)) {
+		if q.Tier > 0 || askedAny(q) || q.Created.Before(created) {
 			return q.ID, nil
 		}
 	}
 	return "", nil
 }
 
+// deferred says a walk has its word and has not started: let go while another walk was started, it waits for
+// that one to end (startedBeside). Read as a wait, not as a tier running late: `plans` and `status` say its
+// note, and S3 leaves it out.
+func deferred(p inventory.Plan) bool {
+	return p.Open() && p.Release == nil && p.Tier == 0 && !askedAny(p) && p.Delivery != nil &&
+		p.Delivery.Awaits != "" && p.Delivery.Go != nil
+}
+
 // askedAny says a plan asked any module.
 func askedAny(p inventory.Plan) bool {
 	for _, s := range p.Modules {
@@ -475,15 +483,6 @@ func askedAny(p inventory.Plan) bool {
 	return false
 }
 
-// createdOf is when a plan was made; zero when it cannot be read.
-func createdOf(ctx context.Context, inv *inventory.Inventory, id string) time.Time {
-	p, err := inv.PlanByID(ctx, id)
-	if err != nil {
-		return time.Time{}
-	}
-	return p.Created
-}
-
 // advancePlans moves every open plan as far as the facts allow: a tier whose modules are all built
 // and whose gates are applied gives way to the next; the last tier done is the plan done. Called
 // after every outcome and on a timer, so a plan waiting on a machine's report moves when it comes.
@@ -619,7 +618,7 @@ func advanceOnce(ctx context.Context, open *stores, p *inventory.Plan,
 		// **One walk at a time** (novox/hq ADR 0276): a walk about to ask its first tier while another started
 		// walk is open waits for that one to end, let go or not, and says so.
 		if p.Tier == 0 {
-			if behind, err := startedBeside(ctx, inv, p.ID); err != nil {
+			if behind, err := startedBeside(ctx, inv, p.ID, p.Created); err != nil {
 				return false, err
 			} else if behind != "" {
 				note := fmt.Sprintf("let go; starts once %s ended — one walk at a time", behind)
@@ -1257,6 +1256,10 @@ func planLineOn(p inventory.Plan, now time.Time, pause pauseView, bound time.Dur
 		// Waiting for its delivery's word is no lateness of the walk's (novox/hq ADR 0239).
 		return fmt.Sprintf("%s · %s, %s, for %s", name, where, waitingNote(p), since)
 	}
+	if deferred(p) {
+		// Nor is waiting for the walk before it to end (one walk at a time, novox/hq ADR 0276).
+		return fmt.Sprintf("%s · %s, %s, for %s", name, where, p.Note, since)
+	}
 	if waiting, paused := pausedWaiting(p, pause, now); paused {
 		return fmt.Sprintf("%s · %s, %s", name, where, waiting)
 	}