anchor.diff:                    (let ((value (funcall condition)))
                       (when value (return-from progress-until value))))
                   (inner ()
  -                  (let ((task  (loop-get-task state (aref locks i) cvar
  -                                              queue stacks i
  -                                              wait-time))
  -                        (queue (weak-pointer-value weak-queue)))
  -                    (unless (and task (not (eql task :timeout))
  -                                 queue)
  -                      (go retry))
  -                    (if (bulk-task-p task)
  -                        (work-stack:push stack task hint)
  -                        (work-stack:execute-task task))
  -                    (loop while (progn
  -                                  (check)
  -                                  (work-stack:run-one stack))
  -                          do
  -                             (when (eq (car state) :done)
  -                               (return-from progress-until)))
  -                    (setf queue nil))))
  +                  (%worker-loop weak-queue i *worker-hint*
  +                                #'check wait-time)))
            (declare (notinline inner)
                     (inline check))
            (check)
            (inner)
            (sb-sys:scrub-control-stack)
  -         (go retry)))))
  +         (unless (eql :done (car state))
  +           (go retry))
  +         (check)))))
   
   (defun make (nthread &optional constructor &rest arguments)
     (declare (type (and unsigned-byte fixnum) nthread)
  
positive.code:          (return :timeout))
         (setf timeout (min 1.0 (* timeout 1.1)))))))
  
  (defun %make-worker (wqueue i &optional binding-names binding-compute)
    (let* ((locks  (queue-locks  wqueue))
           (cvar   (queue-cvar   wqueue))
           (state  (queue-state  wqueue))
           (queue  (queue-queue  wqueue))
           (stacks (queue-stacks wqueue))
           (nthread (queue-nthread wqueue))
           (stack  (aref stacks i))
           (hint   (float (/ i nthread) 1d0))
           (weak-queue (make-weak-pointer wqueue)))
      (make-thread
  
negative.code:        (progv binding-names (mapcar (lambda (x)
                                        (if (functionp x) (funcall x) x))
                                      binding-compute)
           (loop
             (flet ((inner ()
                      (%worker-loop weak-queue i hint)))
               (declare (notinline inner))
               (inner)
               (sb-sys:scrub-control-stack)
               (when (eq (car state) :done)
                 (return))))))
       :name (format nil "Work queue worker ~A/~A" i nthread))))
  
  (defun progress-until (condition)
    (let* ((condition (if (functionp condition)
                          condition (fdefinition condition)))
           (i         (worker-id))
           (weak-queue *current-queue*)
           (state     (queue-state
                       (or (current-queue)
                           (error "Not in recursive wait?!"))))
           (wait-time 1d-3))
      (tagbody
         retry
         (if (< wait-time 1)
  