                                    alternative
                                    present-id-packages
                                    (or (get present-packages id)
-                                                (get found-packages id))
+                                       (get found-packages id))
                                    present-package
                                    (when (not (nil? present-id-packages))
                                      (if (= conflict-strat :prioritized)

                                             :package-id id}]}]
                                         (let [candidate-results
                                               (first-found
                                                 (fn
                                                   try-candidate
                                                   [candidate]
                                                   (resolve-deps
                                                     repo
                                                     present-packages
                                                     (update-in found-packages [id]
                                                                conj
                                                                candidate)
                                                     absent-specs
                                                     (concat-reqs
                                                       rclauses
                                                       (map
                                                         #(->DecoratedRequirement
                                                            %
                                                            candidate)
                                                         (:requirements
                                                           candidate)))
                                                     (update-in
                                                       present-packages
                                                       [parent]
                                                       conj candidate)))
                                                successful?
                                                filtered-query-results)]
                                           (or

                                               visited
                                               grandchildren-visited)]
                            (if (and (= search-strat :depth-first)
                                     (not (get base-visited v)))
                              {:pkg-list (conj base-pkg-list v)
                               :visited (conj base-visited v)}
                              {:pkg-list base-pkg-list
                               :visited base-visited})))
                        {:pkg-list []
                         :visited already-visited}
                        children)]
                  (if (= search-strat :breadth-first)
                    {:pkg-list (into list-from-children
