         (let [shuffled-candidate-lexical-complements (lazy-shuffle complement-candidate-lexemes)
               return-val
               (filter (fn [result]
-                        (or true
-                        (not (fail? result))))
+                        (not (fail? result)))
                       (map (fn [complement]
                              (let [debug (log/debug (str "Trying complement:" (morph complement)))
                                    result

                                   is-fail? (fail? result)]
                               (if is-fail?
                                 (do
                                   (log/debug (str "fail-path-between:" (fail-path-between (strip-refs (get-in bolt path))
                                                                                           (strip-refs complement))))))
                               (if is-fail? :fail result)))
                     

                                                                                                                   "NULL MORPH"))))
                                    candidate-lexemes))
                        (let [result (over/overh parent (lazy-shuffle (get-lex parent :head index spec)) morph)]
                          (log/debug (str "results of attaching lexemes to: " (:rule parent) ": (size=" (if result (.size result) "0") ")"
                                          (string/join ","
                                                       (map #(if morph (morph %1)
                                                                 "(string)")
                                                            result))))
                          result)))
                    candidate-parents)
            phrasal ;; 2. generate list of all phrases where the head child of each parent is itself a phrase.
