                               & {:keys [max-total-depth truncate-children]
                                  :or {max-total-depth max-total-depth
                                       truncate-children true}}]
-  (log/debug (str "add-complement-to-bolt: " (show-bolt bolt language-model)
+  (log/trace (str "add-complement-to-bolt: " (show-bolt bolt language-model)
                   "@[" (string/join " " path) "]" "^" total-depth))
   (let [index (:index language-model)
         lexicon (if (-> :generate :lexicon language-model)

        ;; total-depth, on the other hand, is the depth all the way to the top of the entire
        ;; expression, which might involve several parent lightning bolts.
        parents (shuffle (candidate-parents grammar spec))]
    (log/debug (str "lightning-bolt: candidate-parents:" (string/join "," (map :rule parents))))
    (log/debug (str "lightning-bolt:  for spec: " (strip-refs spec)))
    (let [lexical ;; 1. generate list of all phrases where the head child of each parent is a lexeme.
          (mapfn (fn [parent]
                   (log/debug (str "looking for lexical heads of parent: " (:rule parent)))
                   (if (= false (get-in parent [:head :phrasal] false))
                     (let [candidate-lexemes (get-lex parent :head index)
                           filter-on-spec {:synsem {:cat (get-in parent [:head :cat] :top)

                                          candidate-lexemes)]
                       (filter #(not (nil? %))
                               (do (when (not (empty? subset))
                                     (log/debug (str "adding lexical heads to parent:" (:rule parent)))
                                     
                                     (log/debug (str " with lexemes:" (string/join ";" (sort (map morph subset)))))
                                     (log/trace (str " with spec:" (spec-info spec))))
                                   (if (not (empty? subset))
                                     (over/overh parent (shuffle subset))
