anchor.diff:      (write (environments-of module) :stream ouf)
       (terpri ouf)
       (write-line ";; Leases" ouf)
  -    (write (leases-of module) :stream ouf)
  -    (terpri ouf)
  +    (write (mapcar
  +            (lambda (lease)
  +              (list (nick-of lease)
  +                    (env-of lease)
  +                    (activity-of lease)
  +                    (expires-of lease)))
  +            (leases-of module))
  +           :stream ouf)
       (write-line ";; Statuses" ouf)
       (write (statuses-of module) :stream ouf)
       (terpri ouf)))
  +
  +(defun instantiate-lease-timer (module lease now)
  +  (when (and (expires-of lease)
  +             (> (expires-of lease) now))
  +    (setf (timer-of lease)
  +          (iolib:add-timer *event-base*
  +                           (lambda ()
  +                             (cl-irc:notice (conn-of module)
  +                                            (nick-of lease)
  +                                            (format nil "Your lease on ~a has expired."
  +                                                    (env-of lease))))
  +                           (- (expires-of lease) now)
  +                           :one-shot t))))
   
   (defun load-env-data (module)
     (with-open-file (inf (orcabot-path "data/pss-envs.lisp")
  
positive.code:   (leases :accessor leases-of :initform nil)
    (statuses :accessor statuses-of :initform nil))
  
  (defmethod initialize-module ((module env-module) config)
    (load-env-data module))
  
  (defun save-env-data (module)
    (with-open-file (ouf (orcabot-path "data/pss-envs.lisp")
  
negative.code:                        :if-does-not-exist nil)
      (when inf
        (setf (environments-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)
                                      (<= (expires-of lease) now))
                                    (leases-of module)))))
  
  (defun parse-expire-time (str)
  