         debug (if (not (empty? candidate-heads))
                 (log/debug (str "candidate-heads: " (string/join "," (map #(get-in % [:rule])
                                                                             candidate-heads))))
-                (log/debug (str "no candidate head phrases for spec: " (strip-refs spec))))]
+                (log/trace (str "no candidate head phrases for spec: " (strip-refs spec))))]
     ;; TODO: remove or parameterize this hard-coded value.
     (if (> depth 5)
-      (throw (exception (str "DEPTH IS GREATER THAN 5; HOW DID YOU END UP IN THIS TERRIBLE SITUATION? LOOK AT THE STACK. I'M OUTTA HERE."))))
+      (throw (exception (str "depth is greater than 5: should never happen."))))
 
     (if (seq candidate-heads)
       (let [lexical ;; 1. generate list of all phrases where the head child of each parent is a lexeme.

  (if (and (not (= :fail spec))
           (not (= :top spec))
           (not (empty? (strip-refs spec))))
    (log/debug (str "lighting-bolt@" depth " spec: " (strip-refs spec) "; parent: " (if parent
                                                                                      (:rule parent)))))
  (if (not parent)
    (log/debug (str "no parent for lightning-bolt@" depth " with spec: " (strip-refs spec))))
  (let [maxdepth 3 ;; maximum depth of a lightning bolt: H1 -> H2 -> H3 where H3 must be a lexeme, not a phrase.
        debug (log/debug (str "lightning-bolt@" depth " grammar:" (string/join ", " (map #(get-in % [:rule]) grammar))))

        depth (if depth depth 0)        
        ;; TODO: unifyc is expensive: factor out into a let.
        debug (log/debug (str "looking for candidate head phrases with parent: " (:rule parent) " and spec: " (strip-refs spec)))
        candidate-heads (filter #(not (fail? %))
                                  (map (fn [rule]
                                         (do (log/debug (str "testing rule: " (:rule rule)
                                                             ":" (strip-refs rule)))
                                             (if (fail? rule)
                                               (throw (exception (str "rule has a fail: " (strip-refs rule)))))
                                             (log/debug (str " result: " (strip-refs (unifyc spec rule))))
                                             (log/debug (if (fail? (unifyc spec rule))
                                                          (str "fail path: " (fail-path-between spec rule))
                                                          (str "rule: " (:rule rule) " successfully unified with spec: " (strip-refs spec))))
                                             (unifyc spec rule)))
                                       (if parent
                                         (let [hp (get-head-phrases-of parent index)]

                           (do
                             (log/debug (str "generating phrasal complements with spec: " (strip-refs spec)))
                             (let [phrasal-complements (generate-all spec grammar lexicon cache morph)]
                               (if (not (empty? phrasal-complements))
                                 (log/debug (str "phrasal complements were not empty; first: "
                                                 (get-in (first phrasal-complements) [:rule])))
                                 ;; phrasal complements were empty.
                                 (if (= true (get-in spec [:phrasal] false))
                                   (log/warn (str "no phrasal complements of spec: " (strip-refs spec)
