anchor.diff:          (when user-notifications-p
             (b :queue queue-name
                :exchange *user-notifications-exchange-name*
  -             :routing-key (format nil "*.~a" (encode-name-for-routing-key uid))))
  +             :routing-key (format nil "*.~a" encoded-uid)))
           (when unread-p
             (b :queue queue-name
                :exchange *unread-state-exchange-name*
  -             :routing-key (format nil "~a.*" (encode-name-for-routing-key uid))))
  +             :routing-key (format nil "~a.*" encoded-uid)))
  +        (when slashcommand-error-p
  +          (b :queue queue-name
  +             :exchange *slashcommand-unrouted-command-exchange*
  +             :routing-key (format nil "*.*.~a.*" encoded-uid)))
           queue-name))))
   
   (defun process-channel-message (msg msg-formatter)
  
positive.code: messages. Each element is a list of two values: the processed message
  and the delivery tag."
    (let ((existing-messages (loop
                                repeat num-messages
                                for msg = (consume-message-handle-timeout conn 1/1000)
                                while msg
                                for json = (process-message msg subscription-consumer-tag msg-formatter)
                                if json
                                collect (list json (cl-rabbit:envelope/delivery-tag msg))
                                else do (cl-rabbit:basic-ack conn 1 (cl-rabbit:envelope/delivery-tag msg)))))
      (or existing-messages
          (alexandria:when-let ((msg (consume-message-handle-timeout conn timeout)))
            (alexandria:when-let ((json (process-message msg subscription-consumer-tag msg-formatter)))
  
negative.code:      (b cl-rabbit:queue-bind cl-rabbit-async:async-queue-bind)
       (a add-new-channel-binding add-new-channel-binding-async))
      (user channels services)
    (destructuring-bind (&key
                           content-p user-state-p user-notifications-p
                           unread-p channel-updates-p slashcommand-error-p)
        services
      (when (and (not content-p)
                 (not user-state-p)
                 (not user-notifications-p)
                 (not unread-p)
                 (not channel-updates-p)
                 (not slashcommand-error-p))
        (error "At least one service must be enabled"))
      (let* ((uid (potato.core:ensure-user-id user))
             (encoded-uid (encode-name-for-routing-key uid))
             (cid-list (mapcar #'potato.core:ensure-channel-id channels)))
        (let ((queue-name (make-queue-name uid cid-list)))
          (d queue-name nil)
          (dolist (cid cid-list)
  