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

                                   (find-comp-paths-in (bolt-depth bolt))
                                   truncate-children max-total-depth))
       (do
         (log/debug (str (string/join ","
                                      (map (fn [bolt-group]
                                             (str "count of bolt-group: " (count bolt-group)))
                                           bolt-groups))))
         (reduce concat bolt-groups))))))

;; TODO: make this non-recursive by using mapcat.

      {:agr agr})
    (if-let [subcat1 (if (not (empty? (get-in spec [:synsem :subcat])))
                      (get-in spec [:synsem :subcat :1 :cat]))]
      {:subcat/:1/:cat subcat1
       :subcat/:1/:agr (get-in spec [:synsem :subcat :1 :agr])}))))

(defn lightning-bolts [language-model spec depth total-depth
                       & {:keys [max-total-depth]
