anchor.diff:                              (invoke-restart continue-handler))))))
         (labels ((invoke-with-looping (task)
                    ;; Infinite recursion prevention mechanism
  -                 (let ((*current-task* task)
  -                       (*recursive-flow* *recursive-flow*)
  -                       (*recursive-task* *recursive-task*))
  -                   (tagbody start
  -                      (when-let ((recursive-task (catch 'recursive-task
  -                                                   (funcall task)
  -                                                   nil)))
  -                        (if (eq *current-task* recursive-task)
  -                            (progn
  -                              (setf *recursive-flow* nil
  -                                    *recursive-task* nil)
  -                              (go start))
  -                            ;; unwind stack until we hit needed task
  -                            (throw 'recursive-task recursive-task))))))
  +                 (tagbody start
  +                    (let ((*recursive-flow* *recursive-flow*))
  +                      (if *recursive-flow*
  +                          (funcall task)
  +                          (when (catch 'recursive-task
  +                                  (funcall task)
  +                                  nil)
  +                            (go start))))))
                  (traps-masking-task ()
                    (claw:with-float-traps-masked ()
                      (invoke-with-looping task))))
  
positive.code: (defvar *executable-p* nil)
  
  (declaim (special *system*
                    *recursive-flow*
                    *recursive-task*
                    *current-task*))
  
  
  (defvar *recursive-flow* nil)
  (defvar *recursive-task* nil)
  
  (define-constant +engine-resource-path+ "/bodge/"
    :test #'equal)
  
negative.code: 
  (defun capture-loop (looped-flow)
    (if (eq *recursive-flow* looped-flow)
        (throw 'recursive-task t)
        (setf *recursive-flow* looped-flow)))
  
  
  (defmethod dispatch ((this bodge-engine) (task function) invariant &rest keys
  