                               (get-output-set @right-sp))                     
                      (reset! right?-atom true)
                      (summaries/disconnect! ss (sp-ts @right-sp))
-                     (add-child-watcher! left-sp (fn [o c] (throw (RuntimeException. "Solved and children."))))
+                     (add-child-watcher! left-sp (fn [c] (throw (RuntimeException. "Solved and children."))))
                      (connect-and-watch! ss @right-sp
-                       (fn ignore-output [o] nil)
-                       (fn right-child [right-sp right-child]
+                       (fn ignore-output [] nil)
+                       (fn right-child [right-child]
                          (summaries/summary-changed-local! ss)
                          (add-sp-child! s (make-pair-subproblem left-sp right-child) true))))
                    (summaries/or-summary s)))]    
        (summaries/connect! ret ss)
        (connect-and-watch! ss left-sp
-         (fn left-output [left-sp]
+         (fn left-output []
            (summaries/summary-changed-local! ss)
-           (when (connect-and-watch-ts! ss @right-sp ;; TODO: too eager/ 
-                   (fn [right-sp] (summaries/summary-changed-local! ss) (set-output-set! ret (get-output-set! right-sp))))
+           (when (connect-and-watch-ts! ss @right-sp ;; TODO: too eager?
+                   (fn [] (summaries/summary-changed-local! ss) (set-output-set! ret (get-output-set! @right-sp))))
              (summaries/summary-changed! ret)))
-         (fn left-child [left-sp left-child]
+         (fn left-child [left-child]
            (summaries/summary-changed-local! ss)
            (add-sp-child! ret (make-pair-subproblem left-child right-name #(refine-input @right-sp %)) true)))
        ret)))

    (when (canonical? s)
      (summaries/connect! (sp-ts s) (sp-ts c))
      (when (get-output-set s) (summaries/summary-changed! (sp-ts s)))) ;; TODO: remove this overhead from atomic.   
    (when (get-output-set s) (doseq [w (doall (seq child-watchers))] (swap! *out-count* inc) (w s c))))

  (subsuming-sps [s] (keys subsuming-sp-set))
  (add-subsuming-sp! [s subsuming-sp]
    (util/assert-is (= nm (sp-name subsuming-sp)))                 
    (when-not (.containsKey subsuming-sp-set subsuming-sp)
      (.put subsuming-sp-set subsuming-sp true)

  (evaluate!           [s] (eval!-fn s))
  
  (get-output-set      [s] @out-set-atom)
  (add-output-watcher! [s w] (if @out-set-atom (w) (.add output-watchers w)))
  (set-output-set!    [s o]
    (assert (nil? @out-set-atom))
    (reset! out-set-atom o)
    (summaries/summary-changed-local! s)
    (when (canonical? s) 
      (summaries/summary-changed! (sp-ts s)))    
    (doseq [w output-watchers] (w))
    (doseq [c (get-children s), w (doall (seq child-watchers))] (w c)))
  
  (get-children        [s] (doall (seq child-list)))
  (add-child-watcher!  [s w]
    (.add child-watchers w)                   
    (when (get-output-set s)) (doseq [c (get-children s)] (swap! *out-count* inc) (w c)))
  (add-sp-child!*      [s c] ;; TODO: wait if output not set yet, send them above?
    (util/assert-is (and (not (identical? s c)) (get-output-set c)))
    (.add child-list c)
