     ;                      (sort-by (comp count :extent-state) 
     ;                               messaged-state-outputs))))) 
     ;          "bad messaged state state")
-    (prop-is (= (set expected-outputs) (set flow-outputs)) "messenger flow values incorrect")
+    (prop-is (= (set expected-outputs) (set (map reset-peer-path flow-outputs))) "messenger flow values incorrect")
     ;(println "Expected: " expected-outputs)
     ;(println "Outputs:" actual-outputs)
     ;; TODO: can only guarantee outputs are in order if there is only one intermediate task
     ;; Implement a better property here
-    #_(check-outputs-in-order! peer-outputs)))
+    (check-outputs-in-order! peer-outputs)))
 
 (defspec deterministic-abs-test {;:seed X 
                                  :num-tests (times 2000)}

;;;;;;;;;
;; Job code

(defn add-path [job-id task+slot {:keys [n] :as segment}]
  (update segment :path conj [job-id task+slot]))

(def add-paths-calls
  {:lifecycle/before-task-start 
   (fn [event lifecycle]
     (if (= :input (:onyx/type (:task-map event))) 
       ;; include slot combinations with input
       {:params [(:job-id event) [(:task event) (:slot-id event)]]}
       {:params [(:job-id event) [(:task event)]]}))})

(defn add-paths-lifecycles [job]
  (update job 

                     (partition-by #(= [:reset-messenger] %))
                     (remove (fn [run] (= #{[:reset-messenger]} (set run)))))]
      (let [segments (apply concat run)
            group-by-input (->> segments 
                                ;; Don't include messaged state
                                (remove :state-output?)
                                ;; We only care about ordering of segments that followed the same path through peers
                                (group-by :peer-path))]
        (doseq [[input-task segments] group-by-input]
          (prop-is (apply < (map :n segments))
                   (str (mapv :n segments)) 
                   (str "outputs not in order " input-task " " segments)))))))
