             (log/debug (str "generate-all: cat: " (get-in spec [:synsem :cat])))
             (let [add-complements-to-bolts
                   (fn [bolts path]
-                    (mapcat #(add-complement % path :top grammar lexicon index morph 0)
+                    (mapcat #(if (not (= :none (get-in % path :none)))
+                               (add-complement % path :top grammar lexicon index morph 0)
+                               [%])
                             bolts))]
               (-> (lightning-bolt (lazy-shuffle grammar)
                                      lexicon

(defn add-complement [bolt path spec grammar lexicon cache morph depth]
  (let [input-spec spec
        from-bolt bolt ;; so we can show what (add-complement) did to the input bolt, for logging.
        bolt-spec (get-in bolt path :no-path)
        depth (if depth depth 0)
        spec (unifyc spec bolt-spec)]
    (if (not (= bolt-spec :no-path)) ;; check if this bolt has this path in it.
      (let [immediate-parent (get-in bolt (butlast path))
            start-time (current-time)
            cached (if cache
                     (get-lex immediate-parent :comp cache spec)
                     (do (log/warn (str "no cache: will go through entire lexicon to find candidate complements."))
                         (reduce concat (vals lexicon))))
            complement-candidate-lexemes (if (not (= true
                                                     (get-in bolt (concat path [:phrasal]))))
                                           (if cached cached (flatten (vals lexicon))))]
        (let [complement-pre-check (fn [child parent path-to-child]
                                     (let [child-in-bolt (get-in bolt path-to-child)]
                                       (and (not (fail?
                                                  (unifyc (get-in child [:synsem] :top)
                                                          (get-in child-in-bolt [:synsem] :top)))))))
              filtered-lexical-complements (filter (fn [lexeme]
                                                     (complement-pre-check lexeme bolt path))
                                                   complement-candidate-lexemes)
              shuffled-candidate-lexical-complements (lazy-shuffle filtered-lexical-complements)]
          (filter (fn [complement]
                    (if (fail? complement)
                      true
                      (do
                        (log/debug (str "add-complement(depth=" depth ",path=" path ")=>"
                                        (get-in complement [:synsem :cat] :none) "):" (morph complement)))
                        false)))
                  (map (fn [complement]
                         (unify (copy bolt)
                                (path-to-map path
                                             (copy complement))))
                       (let [phrasal-complements (generate-all spec grammar lexicon cache morph)]
                         (if (lexemes-before-phrases depth)
                           (lazy-cat shuffled-candidate-lexical-complements phrasal-complements)
                           (lazy-cat phrasal-complements shuffled-candidate-lexical-complements)))))))

      ;; path doesn't exist in bolt: simply return the bolt unmodified.
      (list bolt))))

(defn path-to-map [path val]
  (let [feat (first path)]

(def concurrent false)

(declare add-complement)
(declare lexemes-before-phrases)
(declare lightning-bolt)
(declare generate-all)
(declare in-case-of-no-phrasal-complements)
(declare path-to-map)
(declare show-bolt)

(defn exception [error-string]
  #?(:clj
