private Optional<Plan> promoteConflict(Conflict conflict) {
        List<List<Step>> newOrderedSteps = removeStepFromList(conflict.getStep(), orderedSteps);

        int leftIndex = getStepIndex(conflict.getRelationship().getRelationship().getLeft(), newOrderedSteps).get();
        int rightIndex = getStepIndex(conflict.getRelationship().getRelationship().getRight(), newOrderedSteps).get();

        if (Math.max(leftIndex, rightIndex) == newOrderedSteps.size() - 1) {
            return Optional.empty();
        }

        int insertIndex = Math.max(leftIndex, rightIndex) + 1;

        if (relationships.stream()
                .anyMatch(r -> r.getRelationship().getLeft().equals(conflict.getStep()) &&
                        r.getRelationship().getRight().equals(conflict.getRelationship().getRelationship().getRight()))) {

            return Optional.empty();
        }

        int lowestDependentStepIndex = relationships.stream()
                .filter(r -> r.getRelationship().getLeft().equals(conflict.getStep()))
                .mapToInt(r -> getStepIndex(r.getRelationship().getRight()).get())
                .min()
                .orElse(Integer.MAX_VALUE);

        if (insertIndex > lowestDependentStepIndex) {
            return Optional.empty();
        }

        if (newOrderedSteps.get(insertIndex).stream().anyMatch(s -> s instanceof GoalStep) || insertIndex == lowestDependentStepIndex) {
            newOrderedSteps.add(insertIndex, Arrays.asList(conflict.getStep()));
        } else {
            newOrderedSteps.get(insertIndex).add(conflict.getStep());
        }

        Plan newPlan = new Plan(newOrderedSteps, relationships);

        if (newPlan.getConflicts().isEmpty()) {
            App.getReportContext().report("Solving conflict: " + conflict + " by step promotion.");
            return Optional.of(new Plan(newOrderedSteps, relationships));
        } else {
            return Optional.empty();
        }
    }