     (cond
       (not (nil? bolts))
       (do
-        (log/debug (str "found compiled bolts."))
+        (log/trace (str "found compiled bolts."))
         (shufflefn (->> bolts
                         (map #(unify spec %))
                         (filter #(not (= :fail %))))))
       true
-      (do (log/debug (str "no compiled bolts found for: " search-for-key))
+      (do (log/trace (str "no compiled bolts found for: " search-for-key))
           (lazy-seq (lightning-bolts model spec 0 depth))))))
 
 (defn lightning-bolts

  ;; Each head child may be a leaf or
  ;; otherwise has a child with the same two options (leaf or a head child),
  ;; up to the maximum depth.
  (if (and (< depth max-depth)
           (not (= false (get-in spec [:phrasal] true))))
    (let [candidate-parents (or use-candidate-parents
                                (->>
                                 (:grammar model)
                                 (map #(unify % spec))
                                 (filter #(not (= :fail %)))
                                 (shufflefn)))]
      (if (not (empty? candidate-parents))
        (let [candidate-parent (first candidate-parents)]
          (lazy-cat

                                 max-depth)
                (map (fn [head]
                       (assoc-in candidate-parent [:head] head))))
           (lightning-bolts model spec depth max-depth (rest candidate-parents))))
        (do
          (log/debug (str "no rules found at depth: " depth " for spec: "
                          (dag_unify.core/strip-refs spec)))
          candidate-parents)))
    (shufflefn (get-lexemes model spec))))

(defn add-comps-to-bolt
