 
 (defn inject-compiled []
   (let [comped (compile-state)
-        tick-rules (stratifier/strata->ruleset (:rules comped))
+        tick-rules (stratifier/strata->ruleset (stratifier/stratify (:rules comped)))
         paused? (:paused @cur-env)]
     (pause cur-env)
     (swap! cur-env assoc :tick-rules tick-rules)

        syms (into {} (for [k (keys (dissoc clause :ml))]
                        [k (gensym k)]))
        sees (for [[k v] (dissoc clause :ml)]
               (list '= (syms k) (if (string? v)
                                   (reader/read-string v)
                                   v)))
        jsd (into clause (for [[k v] (dissoc clause :ml)]
                           [k (syms k)]))
        ]
    (conj sees
          (merge clause placeholders)
          (list '- (merge clause placeholders new-bound-syms))
          (list '+ (merge placeholders clause new-bound-syms jsd)))
    )
  )


  (compile-clause (assoc clause :type "find") world))

(defmethod compile-clause "find" [clause world]
  [(denotation/Filter. (dissoc clause :type))])

(defmethod compile-clause "add" [clause world]
  [(denotation/Assert. (dissoc clause :type))])


(defmethod compile-clause "all" [clause world]
  (let [things (get clause "things")]
    [(denotation/AssertMany. (if (string? things)
                               (reader/read-string things)
                               (or things [])))]))

(defmethod compile-clause "forget" [clause world]
  [(denotation/Retract. (dissoc clause :type))])

(defmethod compile-clause "see" [clause world]
  (let [exp (get clause "expression")
