                           (dt pred x form)
                           ::invalid))
         (explain* [_ path via in x]
-                  (if-let [pred (predx x)]
-                    (explain-1 form pred path via in x)
-                    {path {:pred form :val x :reason "no method" :via via :in in}}))
+                  (let [dv (dval x)
+                        path (conj path dv)]
+                    (if-let [pred (predx x)]
+                      (explain-1 form pred path via in x)
+                      {path {:pred form :val x :reason "no method" :via via :in in}})))
          (gen* [_ overrides path rmap]
               (if gfn
                 (gfn)
                 (let [gen (fn [[k f]]
                             (let [p (f nil)]
-                              (let [idk [id k]
-                                    rmap (inck rmap idk)]
-                                (when-not (recur-limit? rmap idk [idk] idk)
+                              (let [rmap (inck rmap id)]
+                                (when-not (recur-limit? rmap id path k)
                                   (gen/delay
                                    (gen/fmap
                                     #(tag % k)
-                                    (gensub p overrides path rmap (list 'method form k))))))))
+                                    (gensub p overrides (conj path k) rmap (list 'method form k))))))))
                       gs (->> (methods @mmvar)
                               (remove (fn [[k]] (= k ::invalid)))
                               (map gen)

             (str "Multimethod :" form " does not contain nil-returning default method for :clojure.spec/invalid" ))
     (let [id (java.util.UUID/randomUUID)
           predx #(@mmvar %)
           tag (if (keyword? retag)
                 #(assoc %1 retag %2)
                 retag)]

  dispatch-tag that should return an appropriately retagged value.

  Note that because the tags themselves comprise an open set,
  the tag key spec cannot enumerate the values, but can e.g.
  test for keyword?.

  Note also that the dispatch values of the multimethod will be
  included in the path, i.e. in reporting and gen overrides, even
  though those values are not evident in the spec.
"
  [mm retag]
  `(multi-spec-impl '~(res mm) (var ~mm) ~retag))
