         bolt-spec (get-in bolt path :no-path)
         spec (unifyc spec bolt-spec)
         lexicon (if (future? lexicon) @lexicon lexicon)]
+    
+    (if (not (= :none (get-in bolt [:head :head :subcat] :none)))
+      (let [message (str "BAD BOLT RESULT: " (get-in bolt [:head :head :subcat] :none))]
+        (log/error message)
+        (throw (Exception. message))))
+    
     (log/debug (str "add-complement to bolt with bolt:["
                     (if (map? bolt) (get-in bolt [:rule]))
                     " '" (wrapped-morph morph bolt) "'"

                          (generate-all (rest spec) grammar lexicon index morph))
                true
                (do
                  (log/trace (str "generate-all with semantics: " (show-spec (remove-false (get-in spec [:synsem :sem])))))
                  (log/trace (str "generate-all with spec: " (strip-refs spec)))
                  (log/trace (str "generate-all with pred: " (show-spec (remove-false (get-in spec [:synsem :sem :pred])))))
                  (log/trace (str "generate-all(details): " (show-spec spec)))
                  (-> (lightning-bolt grammar
                                      lexicon
                                      spec 0 index nil morph)
                      ;; TODO: allow more than a fixed maximum depth of generation (here, 4 levels from top of tree).
                      (add-complements-to-bolts [:head :head :head :comp] :top grammar lexicon index morph)
                      (add-complements-to-bolts [:head :head :comp]       :top grammar lexicon index morph)
                      (add-complements-to-bolts [:head :comp]             :top grammar lexicon index morph)
                      (add-complements-to-bolts [:comp]                   :top grammar lexicon index morph))))))
  
;; TODO: add usage of rule-to-lexicon cache (rather than using lexicon directly)
(defn lightning-bolt [grammar lexicon spec & [ depth index parent morph]]

      (let [lexical ;; 1. generate list of all phrases where the head child of each parent is a lexeme.
            (mapcat (fn [parent]
                      (let [candidate-lexemes (get-lex parent :head index spec)]
                        (log/debug
                         (str "candidate head lexeme for parent: "
                              (get-in parent [:rule]) ": "
                              (string/join ","
