EDITED
You are right. We have to look town to the "leaves" in each iteration. I would do it the following way:
If $L_i^{(j)}$ is the set of indices in the $j$ branch ($j \in \{1,2\}$), then we define $s_i^{(j)}=\sum_{n \in L_i^{(j)}w_n}$, the weight of the branch before scaling and $n_i^{(j)}=\left|L_i^{(j)}\right|$ the number of leaves in the branch.
The box constraints for the weights we call $w_\text{min}$ and $w_\text{max}$.
Let $\alpha_i$ be the scaling factor for $L_i^{(1)}$ and $1-\alpha_i$ the scaling factor for $L_i^{(2)}$.
To fulfill the constraints, we need to check the resulting weights.
If we scale the weights of $L_i^{(j)}$ by $\alpha_i$, we must have enough room to maneuver so that the minimum weight constraint can still fit into the branch weight and we must have a limited weight in order to be able to fulfil the upper bounds:
$$ \alpha_i s_i^{(1)} \geq n_i^{(1)} w_\text{min}$$
$$ \alpha_i s_i^{(1)} \leq n_i^{(1)} w_\text{max}$$
For the other side of the branch, we need to check, the analogue thing:
$$ (1-\alpha_i) s_i^{(2)} \geq n_i^{(2)} w_\text{min}$$
$$ (1-\alpha_i) s_i^{(2)} \leq n_i^{(2)} w_\text{max}$$
If we put all four of them together, we get the following inequalities for $\alpha_i$:
$$ \text{max}\left(1-\frac{n_i^{(2)}w_\text{max}}{s_i^{(2)}},\frac{n_i^{(1)}w_\text{max}}{s_i^{(1)}}\right) \leq \alpha_i \leq \text{min}\left(1-\frac{n_i^{(2)}w_\text{min}}{s_i^{(2)}},\frac{n_i^{(1)}w_\text{max}}{s_i^{(1)}}\right)$$
So if we define the lower bound as $\text{LB}_i$ and the upper bound as $\text{UB}_i$, we adjust the scaling factor as follows:
$$ \hat{\alpha}_i = \text{max}(\text{LB}_i,\text{min}(\alpha_i,\text{UB}_i))$$
If $\text{UB}_i \leq \text{LB}_i$, then terminate the function. I hope this only happens if the constraints are incompatible but I didnt attempt a proof.
This way, you can proceed with the algorithm while fulfilling the constraints.
Linear constraints on sigle assets are probably the only useful type of constraints you can impose. Constraints on sector weights for example will be impossible here due to the clustering structure. In practice, I can see this being a big drawback.
Compared to the classical inverse volatility Risk Budgeting, this approach is really elegant, since it only ignores the part of the variance covariance matrix that is of little importance if you will.
