Overconstrained planning not working as expected

I've been trying to get over-constrained planning to work for my situation, but keep running into issues where some failed hard constraints are still being assigned. Apologies if this has been answered before, but most examples/solutions I have seen are centered around Drools, and I'm using the streams API on this project. Using the quarkus 1.4.2 implementation of optaplanner, if that helps.

Below are some example constraints of what I'm trying to accomplish:

private Constraint unnassignedPerson(ConstraintFactory constraintFactory) {
    return constraintFactory.from(Assignment.class)
            .filter(assignment -> assignment.getPerson() == null)
            .penalize("Unassigned", HardMediumSoftScore.ONE_MEDIUM);

private Constraint numberAssignmentConflict(ConstraintFactory constraintFactory) {
    return constraintFactory.from(Assignment.class)
            .join(Assignment.class,
                    Joiners.equal(Assignment::getPerson),
                    Joiners.equal(Assignment::getNumber),
                    Joiners.lessThan(Assignment::getId))
            .penalize("Number Conflict", HardMediumSoftScore.of(2, 0, 0));

private Constraint tooLittleSpaceBetweenResourceAssignment(ConstraintFactory constraintFactory) {
    return constraintFactory.from(Assignment.class)
            .join(Assignment.class, Joiners.equal(Assignment::getPerson), Joiners.lessThan(Assignment::getId))
            .filter((assignment, assignment2) -> !assignment.getResourceId().equals(assignment2.getResourceId()))
            .filter(((assignment, assignment2) -> inRange(1, assignment.getNumber(), assignment2.getNumber())))
            .penalize("Not enough space between assignments of different resource (requires 1)", HardMediumSoftScore.of(1, 0, 0));
}

(inRange is a simple local function to get the absolute difference between two numbers)

Note that these both work independently of each other in terms of honoring the nullable planning variable - it's only when both are enabled that I am getting unexpected results. When both are enabled, the one with the lower hard score is still assigned in the solution despite showing up as a hard constraint in the debug log (which in my local testing always finishes at -12hard/-2medium/0soft).

Any insight on what I might be doing wrong would be much appreciated, and thanks in advance

As a follow up, it appears the Joiners.lessThan(Assignment::getId) portion of my assignment conflict constraint is not compatible with nullable assignments. I removed that and added some more explicit checks instead, and now things are working like they should

psuedo-adaptation for anyone it might help:

private Constraint numberAssignmentConflict(ConstraintFactory constraintFactory) {
    return constraintFactory.from(Assignment.class)
            .join(Assignment.class,
                    Joiners.equal(Assignment::getPerson),
                    Joiners.equal(Assignment::getNumber))
            .filter(((assignment, assignment2) -> assignment.getPerson() != null && assignment2.getPerson() != null))
            .filter(((assignment, assignment2) -> !assignment.getId().equals(assignment2.getId())))
            .penalize("Number Conflict", HardMediumSoftScore.of(2, 0, 0));
}

Doesn't the first constraint have to be a fromUnfiltered(Assignment.class) rather than from(Assignment.class). I believe that from()does not pass entities with unassigned planning variables hence the ONE_MEDIUM penalty would never be applied?