anchor.diff:                         :if-does-not-exist nil)
       (when inf
         (setf (environments-of module) (read inf nil nil))
  -      (setf (leases-of module) (read inf nil nil))
  -      (setf (statuses-of module) (read inf nil nil)))))
  +      (setf (leases-of module)
  +            (loop for lease-data in (read inf nil)
  +               collect (make-instance 'lease
  +                                      :nick (first lease-data)
  +                                      :env (second lease-data)
  +                                      :activity (third lease-data)
  +                                      :expires (fourth lease-data))))
  +      (setf (statuses-of module) (read inf nil nil))
  +      ;; instantiate timers
  +      (let ((now (get-universal-time)))
  +        (dolist (lease (leases-of module))
  +          (instantiate-lease-timer module lease now))))))
   
   (defun expire-env-leases (module)
     (let ((now (get-universal-time)))
       (setf (leases-of module) (delete-if (lambda (lease)
  -                                    (<= (fourth lease) now))
  +                                    (<= (expires-of lease) now))
                                     (leases-of module)))))
   
   (defun parse-expire-time (str)
  
positive.code:        (format nil "Sorry, didn't understand ~a as an amount of time" time-str))
        (t
         (remove-env-lease module env-name nick)
         (push (list nick env-name activity expire-time) (leases-of module))
         (save-env-data module)
         (format nil "~a taken by ~a for ~a"
                 env-name
                 nick
                 (describe-duration (- expire-time (get-universal-time))))))))
  
  (defun env-has-lease-p (module env-name)
    (find env-name (leases-of module)
          :key #'second
          :test #'string-equal))
  
  (defun release-lease (module env-name nick)
    (cond
  
negative.code:              for match-el on matching
               for match = (car match-el)
               do
               (format str "~a (~:[~a/~;~*~]~a)" (nick-of match)
                       (string= (activity-of match) "")
                       (activity-of match)
                       (describe-duration (- (expires-of match) (get-universal-time))))
               (unless (eq match-el end)
                 (format str ", "))))
          (format nil "~a~@[(~a)~] is currently free" env-name status))))
  
  (defun remove-all-env-leases (module env-name)
    (setf (leases-of module) (remove env-name (leases-of module) :test #'string-equal :key #'env-of)))
  
  (defun remove-env-lease (module env-name nick)
    (setf (leases-of module) (remove-if (lambda (lease)
                                    (and (string-equal (env-of lease) env-name)
                                         (string-equal (nick-of lease) nick)))
                                  (leases-of module))))
  
  (defun create-lease (module env-name nick time-str activity)
  