           (let [ret (make-simple-subproblem stub subsuming-sp out-set false summaries/or-summary ri-fn reward)]
             (connect-and-watch! ret subsuming-sp
               (fn [sub-out]
-                (connect-and-watch! ret (refine-input sub-out inp-set) #(add-sp-child! ret %))
+                (connect-and-watch-stub! ret (refine-input sub-out inp-set) #(add-sp-child! ret %))
                 (summaries/summary-changed! ret))) ;; TODO: needed?                       
             ret)
           
           :else 
           (let [ret (make-simple-subproblem stub subsuming-sp out-set false summaries/or-summary ri-fn reward)]
             (doseq [child (map #(make-fs-seq-stub inp-set %) (fs/child-seqs function-set inp-set))]
-              (connect-and-watch! ret child #(add-sp-child! ret %)))
+              (connect-and-watch-stub! ret child #(add-sp-child! ret %)))
             ret))))
 
 ;; Note: this is double-stage to lazily generate children.  Could be simpler single-stage.

                       (add-watcher! left-sp (fn [o] (def *sum* [s left-sp o])
                                               (throw (RuntimeException. "Solved and children."))))
                       ;; TODO: do more efficiently?
                       (connect-and-watch! s (make-pair-stub2 subsuming-sp left-sp (stub right-sp))
                                           (fn [os] (connect-and-watch! s os #(add-sp-child! s %))))
 ;                       (add-sp-child! s (make-pair-subproblem subsuming-sp pair-stub left-sp right-sp))
                       )

(defn- get-root-subproblem [inp-set fs]
  (let [root-stub (make-atomic-stub nil nil inp-set fs)]
    (dotimes [_ 2] (evaluate! root-stub))
    (get-stub-output! root-stub)))

(defn implicit-fah-a*-eval2 [henv]
  (binding [summaries/*cache-method* :eager
