   (let [[_ reward-cycle-depth] (first (subseq cutoff-depth-map > reward))]
     (min cycle-depth reward-cycle-depth)))
 
-(defn extend-cutoff-depth-map [cdm cutoff depth]
+(defn extend-cutoff-depth-map [cdm cutoff depth node-depth]
 ;  (println cdm cutoff depth)
   (let [[g-cutoff g-depth] (first (subseq cdm >= cutoff))]
-    (if (< depth g-depth) (assoc cdm cutoff depth) cdm)))
+    (if (< depth (min node-depth  g-depth)) (assoc cdm cutoff depth) cdm)))
 
 ;; May return states better than next-best, but these will be held at the parent.
 (defn expand-sa-node [node #^HashMap cache next-best state reward-to-state last-cutoff
                       #^IdentityHashMap stack-node-depths depth]
   (assert (not (.containsKey stack-node-depths node)))
-;  (println "Entering " (env/action-name (:action node)))
+  (println "Entering " (env/action-name (:action node)) "at depth" depth)
   (.put stack-node-depths node depth)
   (let [good-queue (:queue node)
         bad-queue  (queues/make-graph-stack-pq)

            (queues/g-pq-replace! good-queue entry 
              (- 0 (:reward-to-state entry) (if-let [n  (:sanode entry)] (cutoff (:queue n)) 0))))
          (.remove stack-node-depths node) ;; TODO: catchup!! 
          (PartialResult (stitch-effect-map 
                           (into {} (map (fn [[s r]] [(vary-meta s assoc :cycle-depth 
                                                        (final-cycle-depth r (or (:cycle-depth (:entry (meta s))) 

                                          bad-nodes)]
              (doseq [n good-nodes]       (queues/g-pq-add! good-queue n (- (:reward-to-state n))))
              (doseq [n (concat nbn sbn)] (queues/g-pq-add! bad-queue  n (- (:reward-to-state n))))
              (queues/pq-remove-min-with-cost! both-queue)
              (when (> (:cutoff rec) Double/NEGATIVE_INFINITY)
                (queues/g-pq-replace! (if (< cd depth) bad-queue good-queue) entry (- 0 b-rts (:cutoff rec))))
              (recur new-results
                     (extend-cutoff-depth-map cutoff-depth-map (:cutoff rec) cd depth)
                     (concat (when (and (>= b-cd depth) (< cd depth)) [entry])
                             (doall (for [n sbn] (queues/g-pq-remove! good-queue n)))
                             good-roots)))))))))

;; Need same fix as regular since in cycles we may still check cutoff. 

;; ALMOST: except suboptimal states may get cached at higher levels too.
;; Such bad states cannot be cached.  
