         (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 (get-lex parent :head index spec)
-                                results (over/overh parent (mapfn copy candidate-lexemes))]
-                            (log/debug (str "lightning-bolt: " (get-in parent [:rule]) ": first candidate head lexeme:'"
-                                            (morph (first candidate-lexemes)) "'"))
+                          (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 "NOTHING: '" (get-in (first candidate-lexemes)
+                                                                          [:english :english]) "'")
+                                                (str fo)))
+                                            "'"))
                             results)))
                       parents)
               phrasal ;; 2. generate list of all phrases where the head child of each parent is itself a phrase.

        debug (log/debug
               (if (not (empty? filtered-lexical-complements))
                 (str "add-complement: " (show-bolt bolt path morph) ":candidate first complement-lexemes:'"
                      (morph (first filtered-lexical-complements))) "'"))]
    (filter (fn [complement]
              (if (fail? complement)
                (do

        spec (unifyc spec (get-in bolt path))
        immediate-parent (get-in bolt (butlast path))
        start-time (current-time)
        complement-candidate-lexemes (if (not (= true
                                                 (get-in bolt (concat path [:phrasal]))))
                                       (let [cached (if cache
                                                      (lazy-seq (get-lex immediate-parent :comp cache spec))
                                                      (do (log/warn (str "no cache: will go through entire lexicon to find candidate complements."))
                                                          nil))]
                                         (if cached cached (flatten (vals lexicon)))))
        complement-pre-check (fn [child parent path-to-child]
                               (let [child-in-bolt (get-in bolt path-to-child)
                                     result (not (fail?
