anchor.diff:                          (respond event "~a: You don't need to apologize for ~a, silly!" (nick event) (name rule))))
                     T))
           
  -        (loop for rule being the hash-value of (rules module)
  +        (loop for rule being the hash-value of (uc:config-tree :rules)
              if (and (find server-format (active-on rule) :test #'string-equal)
                      (cl-ppcre:scan (regex rule) (string-downcase (message event))))
              do 
  
positive.code: (define-command (rules activate) (name &optional channel server) (:authorization T :documentation "Activate a rule for a channel.")
    (unless channel (setf channel (channel event)))
    (unless server (setf server (name (server event))))
    (let ((rule (gethash name (rules module))))
      (if rule
          (progn
            (pushnew (format NIL "~a/~a" server channel) (active-on rule) :test #'string-equal)
  
negative.code:    (%active-on :initarg :active-on :initform () :accessor active-on))
    (:documentation "Class for containing rulesets."))
  
  (uc:define-serializer (rule rule T)
    (make-array 8 :initial-contents (list (name rule) (regex rule) (rule-type rule) (probation rule)
                                          (breach-msg rule) (apology-msg rule) (punish-msg rule)
                                          (active-on rule))))
  
  (uc:define-deserializer (rule array T)
    (make-instance 'rule
                   :name (aref array 0) :regex (aref array 1) :type (aref array 2) :probation (aref array 3)
                   :breach-msg (aref array 4) :apology-msg (aref array 5) :punish-msg (aref array 6)
                   :active-on (aref array 7)))
  
  (defmethod print-object ((rule rule) stream)
    (print-unreadable-object (rule stream :type T)
      (format stream "~a \"~a\"" (rule-type rule) (regex rule))))
  
  (defun rule-format (event rule probation-count message)
    (format-message event message
                    (cons "\\$RULE\\$" (name rule))
                    (cons "\\$COUNT\\$" (format NIL "~a" probation-count))))
  
  (defparameter *apology-regex* (cl-ppcre:create-scanner "^(Colleen:\\s*)?(Sorry for|I apologize for|I'm sorry for)\\s+(breaking|violating|breaching|not minding|disregarding|saying)?\\s*(the\\s+)?(\\w+).*" :case-insensitive-mode T))
  (define-handler (privmsg-event event) ()
    (when (not (find (format NIL "~a/~a" (string-upcase (name (server event))) (string-upcase (nick event)))
                     (uc:config-tree :whitelist) :test #'string-equal))
      (let ((name-format (format NIL "~a/~a" (name (server event)) (nick event)))
            (server-format (format NIL "~a/~a" (name (server event)) (channel event))))
        (unless (cl-ppcre:register-groups-bind (NIL NIL NIL NIL name) (*apology-regex* (message event))
                  (let ((rule (uc:config-tree :rules name)))
                    (when (and rule (find server-format (active-on rule) :test #'string-equal))
                      (if (gethash name-format (users-on-probation rule))
                          (progn
  