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:                  "channel" (potato.core:user-unread-state-rabbitmq-message/channel content)
                   "count" (potato.core:user-unread-state-rabbitmq-message/count content))))
  
  (defun process-unrouted-command (msg)
    (let ((headers (cdr (assoc :headers (cl-rabbit:message/properties (cl-rabbit:envelope/message msg))))))
      (st-json:jso "type" "illegal-command"
                   "cmd" (cdr (assoc "cmd" headers :test #'equal))
                   "channel" (cdr (assoc "channel" headers :test #'equal)))))
  
  (defun process-message (msg subscription-consumer-tag msg-formatter)
    (let ((consumer (cl-rabbit:envelope/consumer-tag msg)))
      (unless (equal consumer subscription-consumer-tag)
  