 (defn xpand-body
   [parent-fn-meta idx fn-body]
   (let [[args & tail] fn-body]
-    (cons args  ;; wrong
-          (xpand (with-meta (vec tail)
+    (assoc (xpand (with-meta (vec tail)
                    {:outer true})
                  idx
-                 parent-fn-meta))))
+                 parent-fn-meta)
+           :args
+           args)))
 
 #_(defn xpand-fn*
   [form parent-fn-meta]

                                   (clojure.walk/macroexpand-all form))
        olop->op (util/deep-zipmap (swap-in-path-syms form) form)
        f (fn [xl]
            {(if (coll? xl)
               (sym-seq->parent xl)
               xl)
             {:tree nil ;; placeholder for trace tree
              :xl xl    ;; expanded location
              :orig (-> xl
                        xl->xform
                        xform->form) ;; original symbol or value
              :x (-> xl
                     xl->xform)
              :xlxp (xl->xlxp xl) ;; expanded locations expanded parent
              :ol (xloc->oloc xl)
              :olop (-> xl
                        xloc->oloc
                        ol->olop)
              :xp  (-> xl
                       xl->xlxp
                       xlxp->xp)
              :op (-> xl
                      xloc->oloc
                      ol->olop
                      olop->op)
              :olxp (-> xl
                        xloc->oloc
                        ol->olxp)
              :xlop (-> xl
                        xloc->oloc
                        ol->olop
                        ((partial deep-replace-symbols oloc->xloc)))}})]
    (util/$- ->> xls
             (map f)
             (apply merge))))

(defn record-trace-tree!
  [tree-atom]
  :NOT-IMPLEMENTED)

          :else (apply xpand-fn head args)))

      (coll? form) (apply xpand-all args)
      :else {:form form})))

#_ (defn xpand
  [form parent-fn-meta]
