                                    (update-current-recipe
                                      update :events conj (get recipe :current-stage)))]
           (assert (not (nil? state-with-results)))
-          (log/info "next-state" (rw/current-state state-with-results))
+          (log/trace "next-state" (rw/current-state state-with-results))
           ; done with recipe?
           (cond
             (contains? choice :done)

              (if (not-empty (get choice :choice/events))
                ; find next event
                (let [next-event (rand-nth (get choice :choice/events))]
                  (log/info "next-event" next-event)
                  (assoc-current-recipe
                    state-with-results
                    :current-stage

                                                                :done
                                                                :choice/id])
                                           (select-keys current-stage [:gen]))))
              _ (log/debug "results" results)
              choice-variables (->> choice
                                 (filter (fn [[k v]] (= "$" (namespace k))))
                                 (map (fn [[k v]] (let [f (eval-in-ns v recipe-ns)]
                                                    (log/trace "evaluating" v "into" f "arg" (get recipe k))
                                                    [k (f (get recipe k))])))
                                 (into {}))
              ; merge results into current recipe
