         (let [lexical ;; 1. generate list of all phrases where the head child of each parent is a lexeme.
               (mapcat (fn [parent]
                         (if (= false (get-in parent [:head :phrasal] false))
-                          (let [candidate-lexemes (lazy-seq (get-lex parent :head index spec))
-                                results (filter #(not (nil? %))
-                                                (over/overh parent (mapfn copy candidate-lexemes)))]
-                            (log/debug (str "lightning-bolt: " (get-in parent [:rule])
-                                            ": first candidate head lexeme:"
-                                            (let [fo (morph (first candidate-lexemes))]
-                                              (if (or (nil? fo)
-                                                      (= '' (trim fo)))
-                                                (str
-                                                 "'"
-                                                 (get-in (first candidate-lexemes)
-                                                         [:english :english])
-                                                 "'")
-                                                (str fo)))))
-                            results)))
+                          (let [candidate-lexemes (filter #(not (nil? %)) (get-lex parent :head index spec))]
+                            (filter #(not (nil? %))
+                                    (over/overh parent (mapfn copy candidate-lexemes))))))
                       parents)
               phrasal ;; 2. generate list of all phrases where the head child of each parent is itself a phrase.
               (if (< depth max-total-depth)

                                 result))
        filtered-lexical-complements (filter (fn [lexeme]
                                               (complement-pre-check lexeme bolt path))
                                             complement-candidate-lexemes)
        debug (log/debug
               (if (not (empty? filtered-lexical-complements))
                 (str "add-complement: candidate first complement-lexemes:'"
                      (morph (first filtered-lexical-complements)) "'")))]
    (filter (fn [complement]
              (if (fail? complement)
                (do
                  (log/debug (str "add-complement(depth=" depth ",total-depth=" total-depth
                                  ",path=" path ",bolt=(" (show-bolt bolt path morph) ") FAILED:"
                                  "'" (morph-with-recovery morph complement) "'"))
                  
                  false)
                (do
                  (log/debug (str "add-complement(depth=" depth ",total-depth=" total-depth
                                  ",path=" path ",bolt=(" (show-bolt bolt path morph) ")=>"
                                  "'" (morph-with-recovery morph complement) "'"))
                  true)))
            (mapfn (fn [complement]
                    (unify (copy bolt)
                           (path-to-map path

    result))

(defn add-complement [bolt path spec grammar lexicon cache morph depth total-depth]
  (log/debug (str "add-complement: start: " (show-bolt bolt path morph)))
  (let [input-spec spec
        from-bolt bolt ;; so we can show what (add-complement) did to the input bolt, for logging.
        spec (unifyc spec (get-in bolt path))
        immediate-parent (get-in bolt (butlast path))
        complement-candidate-lexemes (if (not (= true
                                                 (get-in bolt (concat path [:phrasal]))))
                                       (let [cached (if cache
