         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))) "'"))]
+                      (morph (first filtered-lexical-complements)) "'")))]
     (filter (fn [complement]
               (if (fail? complement)
                 (do

        (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)) "'"))
                            results)))
                      parents)
              phrasal ;; 2. generate list of all phrases where the head child of each parent is itself a phrase.

        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?
