anchor.diff:  (defvar *executable-p* nil)
   
   (declaim (special *system*
  -                  *recursive-flow*
  -                  *recursive-task*
  -                  *current-task*))
  +                  *recursive-flow*))
   
   
   (defvar *recursive-flow* nil)
  -(defvar *recursive-task* nil)
  +
   
   (define-constant +engine-resource-path+ "/bodge/"
     :test #'equal)
  
positive.code: 
  (defun capture-loop (looped-flow)
    (if (eq *recursive-flow* looped-flow)
        (progn
          (setf *current-task* nil)
          (throw 'recursive-task *recursive-task*))
        (setf *recursive-flow* looped-flow
              *recursive-task* *current-task*)))
  
  
  (defmethod dispatch ((this bodge-engine) (task function) invariant &rest keys
  
negative.code:                             (invoke-restart continue-handler))))))
        (labels ((invoke-with-looping (task)
                   ;; Infinite recursion prevention mechanism
                   (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))))
  