           (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)
-              (if (and (not primitive) body)
+              (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))
               )))))))
 

                             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)
                         (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_
                                 ))
                             {:error :unresolved-pclass-ctor}))

                       (= type :delay)

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

            :else
