                              henpt-irks (:irks henpt)
                              caller_ (get-in ir henpt-irks)
                              caller-pclass (first henpt-irks)]
-                         (dbg-println :trace "RPC name" name "method-arg"
-                                      method-arg "pclass-arg" pclass-arg)
+                         (dbg-println :trace "RPC name" name
+                           "method-arg" method-arg
+                           "pclass-arg" pclass-arg
+                           ;; "caller_" caller_
+                           "henpt-irks" henpt-irks
+                           "IR pclass :args" (get-in ir [pclass :args]))
                          (or method-arg pclass-arg
                              (if (= (:type caller_) :plant-fn-field)
                                (get-in ir [caller-pclass :fields (:field caller_) :initial]))
                              (if (= name 'this)
-                               ;;Use the ancestry-path to resolve the pclass of the caller
-                               (let [[_ parent-subtask_ parent-hem parent-henpt] ancestry-path
-                                     parent-hem-pclass (get-in parent-hem [:irks 0])
-                                     _ (dbg-println :debug "RPC Recursing on ancestry-path"
-                                         (mapv #(list (:uid %) (or (:label %) (:name %)))
-                                           ancestry-path))
-                                     _ (dbg-println :debug "parent-hem-pclass" parent-hem-pclass)
-                                     pc_ (resolve-plant-class
-                                           ir parent-hem-pclass pargs parent-henpt parent-subtask_)
-
-                                     ]
-                                 ;; (dbg-println :debug "RPC this"
-                                 ;;              (with-out-str (pprint ancestry-path)))
-                                 ;; (dbg-println :debug "RPC parent-hem"
-                                 ;;              (with-out-str (pprint parent-hem))
-                                 ;;              "\nparent-henpt"
-                                 ;;              (with-out-str (pprint parent-henpt)))
-                                 _ (dbg-println :debug "RPC Recursion result" pc_)
-                                 pc_
-                                 ))
+                               (if (and (not henpt-irks)
+                                     (empty? (get-in ir [pclass :args])))
+                                 ;; here we assume we need to initialize this
+                                 ;; zero argument plant
+                                 {:type :pclass-ctor,
+                                  :pclass pclass,
+                                  :args []}
+                                 ;; else use the ancestry-path to
+                                 ;; resolve the pclass of the caller
+                                 (let [[_ parent-subtask_ parent-hem parent-henpt] ancestry-path
+                                       parent-hem-pclass (get-in parent-hem [:irks 0])
+                                       _ (dbg-println :debug "RPC Recursing on ancestry-path"
+                                           (mapv #(list (:uid %) (or (:label %) (:name %)))
+                                             ancestry-path))
+                                       _ (dbg-println :debug "parent-hem-pclass" parent-hem-pclass)
+                                       pc_ (resolve-plant-class
+                                             ir parent-hem-pclass pargs parent-henpt parent-subtask_)]
+                                   ;; (dbg-println :debug "RPC this"
+                                   ;;              (with-out-str (pprint ancestry-path)))
+                                   ;; (dbg-println :debug "RPC parent-hem"
+                                   ;;              (with-out-str (pprint parent-hem))
+                                   ;;              "\nparent-henpt"
+                                   ;;              (with-out-str (pprint parent-henpt)))
+                                   _ (dbg-println :debug "RPC Recursion result" pc_)
+                                   pc_
+                                   )))
                              {:error :unresolved-pclass-ctor}))
 
                        (= type :delay)

                                            :nonprimitive-task nonprimitive-task
                                            :subtasks subtasks
                                            :subtask-constraints subtask-constraints
                                            :irks irks-choice})]
                    (recur (conj methods method) (inc i))))))

            :else

          (if mname ;; else (dbg-println :debug "no more methods")
            (let [{:keys [temporal-constraints args primitive display-name body]} method]
              (dbg-println :info "  METHOD" mname "PRIMITIVE" primitive "ARGS" args)
              (when (and (not primitive) body)
                (if (and (= 1 (count body)) (= :choose (get-in body [0 :type])))
                  (dbg-println :info "  TOP LEVEL CHOOSE!")
                  )
                (make-htn-methods ir pargs true pclass-name mname display-name args body))
              )))))))

