anchor.diff:                                             procs))
                                          (subkells kell)))
                             (destructuring-bind (procs subst)
  -                              (match-up (up-message-pattern pattern)
  -                                        (messages (parent kell))
  -                                        substitutions)
  +                              (match-list #'match-up
  +                                          (up-message-pattern pattern)
  +                                          (messages (parent kell))
  +                                          substitutions)
                               (setf substitutions subst)
                               procs)
                             (destructuring-bind (procs subst)
  -                              (match-kell (kell-message-pattern pattern)
  +                              (match-list #'match-kell
  +                                          (kell-message-pattern pattern)
                                             (kells kell)
                                             substitutions)
                               (setf substitutions subst)
  -                            procs))
  -                  substitutions)))
  +                            procs)))
  +          substitutions))
     (:method ((pattern process) (process process)
               &optional (substitutions (make-empty-environment)))
  -    ;;; FIXME: This should ensure that _all_ processes match, not just enough to satisfy pattern
  -    (remove nil
  -            (list (append (destructuring-bind (procs subst)
  +    ;; FIXME: This should ensure that _all_ processes match, not just enough to
  +    ;;        satisfy pattern.
  +    (list (remove nil
  +                  (append (destructuring-bind (procs subst)
                                 (match-local (messages-in pattern)
                                              (messages-in process)
                                              substitutions)
  
positive.code: ;;;     to match immediate subkells.
  
  (defclass pattern ()
    ((local-message-pattern :initform nil :type list :accessor local-message-pattern)
     (down-message-pattern :initform nil :type list :accessor down-message-pattern)
     (up-message-pattern :initform nil :type list :accessor up-message-pattern)
     (kell-message-pattern :initform nil :type list :accessor kell-message-pattern)))
  
  
negative.code: ;;; FIXME: somewhere around here we need to ensure only one kell is in the pattern
  
  (defgeneric convert-process-to-pattern (process &optional pattern)
    (:method ((process parallel-composition)
              &optional (pattern (make-instance 'pattern)))
      (mapc (lambda (sub-process)
              (convert-process-to-pattern sub-process pattern))
            (append (messages process) (kells process)))
  