anchor.diff:         (remove-duplicates (append (gethash name (local-patterns kell))
                                     (gethash name (down-patterns (parent kell)))
                                     (mappend (lambda (subkell)
  -                                             (gethash name
  -                                                      (up-patterns subkell)))
  -                                           (subkells kell)))))))
  +                                             (gethash name (up-patterns subkell)))
  +                                           (subkells kell))))
  +       process)))
     (:method ((process kell) (kell kell))
       "Find all triggers that could match."
  -    (select-matching-pattern (gethash (name process) (kell-patterns kell))))
  +    (select-matching-pattern (gethash (name process) (kell-patterns kell)) process))
     (:method ((process pattern-abstraction) (kell kell))
       "Just match on the new trigger."
  -    (select-matching-pattern (list process))))
  -
  -(defun match-on (process kell)
  -  (when (not (deadp process))
  -    (handler-case
  -        (lock-neighboring-kells (kell)
  -          (destructuring-bind (&optional trigger matched-processes substitutions)
  -              (really-match-on process kell)
  -            (when (and trigger matched-processes)
  -              (trigger-process trigger substitutions)
  -              (mapc #'activate-continuation matched-processes))))
  -      (kiln-error (c) (handle-error c)))))
  +    (select-matching-pattern (list process) process)))
   
   (defun find-triggers-matching-message (name kell)
     "Collect down-patterns from parent kell, up-patterns from subkells, and local-
  
positive.code:     (setf (process kell) (compose-processes process (process kell)))
      (activate-process process kell))
    (:method ((process parallel-composition) (kell kell))
      (map-parallel-composition (lambda (sub-process)
                                  (add-process sub-process kell))
                                process))
    (:method ((process kell) (kell kell))
      (if (gethash (name process) (kells kell))
          (error 'duplicate-kell-name-error :name (name process))
  
negative.code: (defmethod trigger-process ((trigger pattern-abstraction) mapping)
    "Activates process after substituting the process-variables in the trigger."
    (remove-process trigger)
    (add-process (replace-variables (process trigger) mapping) (parent trigger)))
  
  (defmethod activate-continuation (process)
      (remove-process process)
      (add-process (continuation process) (parent process)))
  
  (defun find-kells-to-lock (trigger)
    (append (when (up-message-pattern (pattern trigger))
              (list (parent (parent trigger))))
            ;; always lock the current, because even if there isn't a local or kell
            ;; pattern, any result process would affect this kell
            (list (parent trigger))
            (when (down-message-pattern (pattern trigger)) (subkells (parent trigger)))))
  
  (defun execute-match (trigger processes substitutions)
    (trigger-process trigger substitutions)
    (mapc #'activate-continuation processes)
    (setf (deadp trigger) t)
    (mapc (lambda (process) (setf (deadp process) t)) processes))
  
  (defun select-matching-pattern (patterns live-process)
    (dolist (trigger patterns)
      (let ((locked-kells (find-kells-to-lock trigger)))
        (mapc (lambda (kell) (acquire-lock (lock kell) t)) locked-kells)
        (unwind-protect
            (if (deadp live-process)
              (return)
              (when (not (deadp trigger))
                (destructuring-bind (processes substitutions)
                                    (handler-case (match (pattern trigger) (parent trigger))
                                      (unification-failure () (list nil nil)))
                  (when processes
                    (execute-match trigger processes substitutions)
                    (return)))))
          (mapc (lambda (kell) (release-lock (lock kell))) locked-kells)))))
  
  (defgeneric match-on (process kell)
    (:documentation "Tries to find a match for all the patterns that could match
                     channel NAME in KELL.")
    (:method :around (process kell)
      (declare (ignorable kell)) ; FIXME: kell is _not_ ignorable, but CCL complains
      (when (not (deadp process))
        (handler-case (call-next-method)
          (kiln-error (c) (handle-error c)))))
    (:method ((process message) (kell kell))
      "Find all triggers that could match – up, down, or local."
      (let ((name (name process)))
  