Leave a kept core move out of what a gate judges (issue 201, review 91)

gatedSend took its judged moves from the record, so on a machine kept at
a newer controller the gate judged the controller moving back to the
record, read its own send's kept controller as a later build there, and
was superseded with nothing judged. The kept moves are now left out
there as in ungatedIn (withoutKept). The doc says the bus step keeps
too, and the three store tests are listed.

cmd/mesh-controller/release.go

@@ -240,6 +240,32 @@ var machineMoves = func(ctx context.Context, open *stores, f moveFacts, node str
 	return f.moves(node, modules, sent, known, all), nil
 }
 
+// withoutKept is a machine's moves less those its send keeps at the build the machine was last sent, and so does
+// not make: the grants step keeps every module (novox/hq issue 490), and every send keeps the controller and the
+// node-engine over an older record (issue 201). Read as the send composes it (sendKeeps, set after the checks that
+// call this), so a move it could not keep is still counted.
+func withoutKept(ctx context.Context, open *stores, node string, moves []inventory.CarriedMove) ([]inventory.CarriedMove, error) {
+	if len(moves) == 0 {
+		return moves, nil
+	}
+	keeping := ctx
+	if _, on := keptExcept(ctx); !on {
+		keeping = keepingRecorded(ctx)
+	}
+	keeps, err := recordedKept(keeping, open, node)
+	if err != nil || len(keeps) == 0 {
+		return moves, err
+	}
+	var out []inventory.CarriedMove
+	for _, mv := range moves {
+		if was, kept := keeps[mv.Module]; kept && sameCommit(was, mv.From) {
+			continue
+		}
+		out = append(out, mv)
+	}
+	return out, nil
+}
+
 // ungatedIn refuses a send whose machines would move a build no gate has seen, outside its scope: the
 // machines named, and why; the machine holding the bus, added only for its user list, is left instead.
 func ungatedIn(ctx context.Context, open *stores, names []string, addedHolder string) ([]string, error) {
@@ -257,22 +283,11 @@ func ungatedIn(ctx context.Context, open *stores, names []string, addedHolder st
 		if err != nil {
 			return nil, err
 		}
-		// The grants step composes every module at the build its machine was last sent (novox/hq issue 490),
-		// and every send keeps the controller and the node-engine over an older record (issue 201): a move it
-		// keeps is not made. Read, not assumed, so a move it could not keep is still refused here.
-		keeping := ctx
-		if _, on := keptExcept(ctx); !on {
-			keeping = keepingRecorded(ctx) // as the send composes it (sendKeeps), which is set after this check
-		}
-		keeps, err := recordedKept(keeping, open, n)
-		if err != nil {
+		if moves, err = withoutKept(ctx, open, n, moves); err != nil {
 			return nil, err
 		}
 		var waiting []string
 		for _, mv := range moves {
-			if was, kept := keeps[mv.Module]; kept && sameCommit(was, mv.From) {
-				continue
-			}
 			if !scope.judged[n] && !scope.modules[mv.Module] {
 				waiting = append(waiting, fmt.Sprintf("%s %s → %s", mv.Module, short(mv.From), short(mv.To)))
 			}
@@ -314,6 +329,11 @@ func gatedSend(ctx context.Context, open *stores, node string, owns []inventory.
 	if err != nil {
 		return nil, nil, nil, err
 	}
+	// A move the send keeps is not made, and is no move for the gate to judge (novox/hq issue 201): a core module
+	// kept over an older record judged as moving back to it would read the gate as superseded by its own send.
+	if moves, err = withoutKept(ctx, open, node, moves); err != nil {
+		return nil, nil, nil, err
+	}
 	own := func(module string) bool {
 		return slices.ContainsFunc(owns, func(o inventory.CarriedMove) bool { return o.Module == module })
 	}