anchor.diff:    (log/error "~A with invariant ~A and keys ~A ignored" task invariant keys))
   
   
  -(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
                        &key (priority :medium) concurrently)
     "Use engine instance as a dispatcher. If :invariant and :concurrently-p are both nil task is
  
positive.code:   "Turns passed flow into a loop. Flow will be repeated while test function returns `t`.
  Test happens before each flow execution. Result of the last flow iteration is passed to the next
  flow block after the looped flow."
    (declare (type function test))
    (let (looped recurred-result)
      (setf looped (->> (value)
                     (setf recurred-result value)
                     (if (funcall test)
                         (>> (instantly ()
                               ;; prevent infinite recursion
                               (capture-loop flow)
                               ;; feed result from the previous loop iteration
                               recurred-result)
                             flow
                             looped)
                         (instantly ()
                           recurred-result))))))
  
  ;;
  (defclass system ()
  
negative.code: (defvar *predefined-event-callbacks* nil)
  (defvar *executable-p* nil)
  
  (declaim (special *system*))
  
  
  (define-constant +engine-resource-path+ "/bodge/"
  