anchor.diff:        (bordeaux-threads:make-thread
          (lambda ()
            ;; prevent two watcher threads from being started due to race
  -         (%without-interrupts
  -           (when (with-hierarchies-lock
  -                   (cond (*watcher-thread*
  -                          (%with-local-interrupts
  -                            (log-debug "Watcher thread already started")
  -                            nil))
  -                         (t (setq *watcher-thread* (bt:current-thread)))))
  -             (unwind-protect
  -                  (%with-local-interrupts
  -                    (handler-case
  -                        (progn
  -                          (log-info :logger logger "Hierarchy watcher started")
  -                          (loop for *watcher-event-time* = (get-universal-time)
  -                             do (hierarchy-watcher-once)
  -                             until
  +         (when (with-hierarchies-lock
  +                 (cond (*watcher-thread*
  +                        (log-debug "Watcher thread already started")
  +                        nil)
  +                       (t (setq *watcher-thread* (bt:current-thread)))))
  +           (unwind-protect
  +                (handler-case
  +                    (progn
  +                      (log-info :logger logger "Hierarchy watcher started")
  +                      (loop for *watcher-event-time* = (get-universal-time)
  +                            do (hierarchy-watcher-once)
  +                            until
                                  #-ecl ; timeout on cv signals error in ECL 16.1.3
                                  (bt:with-lock-held (*stop-lock*)
                                    (bt:condition-wait *stop-cv* *stop-lock*
  
positive.code:                                    (bt:with-timeout (*hierarchy-watcher-heartbeat*)
                                       (bt:acquire-lock *stop-lock*))
                                   (serious-condition () nil))))
                        (error (e)
                          (log-error :logger logger "Error in hierarchy watcher thread:~%~A" e))))
                 (with-hierarchies-lock
                   ;; lock might not have been acquired (i.e terminate-thread was called)
                   #+ecl (ignore-errors (bt:release-lock *stop-lock*))
                   (setf *watcher-thread* nil))
                 (%with-local-interrupts (log-info :logger logger "Hierarchy watcher thread ended"))))))
         :name "Hierarchy Watcher"
         :initial-bindings
         `((*hierarchy* . 0)
           (*package* . (find-package :log4cl-impl))
           ,@*watcher-thread-bindings*)))))
  
  
  (defun hierarchy-watcher-do-one-token (hier token)
    (with-slots (name) hier
  
negative.code: 
  (defvar *watcher-thread-bindings* nil
    "Extra bindings for watcher thread")
  
  (defun call-with-logged-problems (context thunk)
    (handler-case (funcall thunk)
  