                              :arguments args
                              :temporal-constraints temporal-constraints
                              :irks irks-i})
-                      nt (if make-htn-method?
+                      nt (if (not plant-fn-primitive?)
                            (htn-nonprimitive-task
                              {:pclass pclass
                               :name mname
                               :arguments margs
                               :irks irks-i}))
-                      st (if make-htn-method? [task])]
+                      st (if (not plant-fn-primitive?) [task])
+                      ;; st (if (not plant-fn-primitive?)
+                      ;;      (make-htn-methods ir plant-class method
+                      ;;                        (str method) ;;(str type) ;;TODO: Not sure this will be necessary
+                      ;;                        args (get-in ir [plant-class :methods method :body])))
+                      ]
                   ;; (println "  PLANT-FN-SYMBOL TASK" task)
-                  ;; (println "  PLANT-FN-SYMBOL SUBTASKS" st)
-                  (when make-htn-method? ;; make htn-method
-                    (let [hm (htn-method {:pclass pclass
+                  (println "  PLANT-FN-XXX SUBTASKS" st)
+                  (when (not plant-fn-primitive?) ;; make htn-method
+                    (let [hm (htn-method {:pclass plant-class
                                           :name mname
                                           :display-name display-name
                                           :nonprimitive-task nt
                                           :subtasks st
-                                          :irks irks-i})]
-                      ;; (println "HTN-METHOD" (with-out-str (pprint hm)))
+                                          :irks (if (= plant-class pclass)
+                                                  irks-i
+                                                  [plant-class :methods method :body])})]
+                      (println "HTN-METHOD" (with-out-str (pprint hm)))
                       ;; (pprint-htn-methods)
                       hm))
                   task)

                     (irks->bounds ir irks))
            m-task-expansions (count task-expansions)
            ;; DEBUG
            _ (println "ST#" i "of" n-subtasks "IRKS" irks)
            ;; resolve pclass if (= type :htn-nonprimitive-task)
            ;; to determine if this was really an unresolved primitive task
            ;; DEBUG plant-class (if (htn-isa? type :htn-nonprimitive-task)

                ;; has true or false)
                (let [plant-class (if (= :plant-fn-symbol type)
                                    (if (= name 'this) pclass name)
                                    (get-in ir [pclass :fields field :initial :pclass]))
                      plant-fn-primitive?
                      (get-in ir [plant-class :methods method :primitive])
                      _ (println "plant-class" plant-class "plant-fn-primitive?" plant-fn-primitive?)
                      [plant-class non-primitive?]
                      (if (nil? plant-fn-primitive?)  ;;TODO - Should error here
                        [::unknown false]
