anchor.diff:  (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)))
  +  (add-process (replace-variables (process trigger) mapping) (parent trigger)))
   
   (defmethod activate-continuation (process)
       (remove-process process)
       (add-process (continuation process) (parent process)))
   
  -(defun select-matching-pattern (patterns)
  -  (loop for trigger in patterns
  -     for (processes substitutions)
  -       = (handler-case (match (pattern trigger) (parent trigger))
  -           (unification-failure () (list nil nil)))
  -     if processes
  -     return (progn
  -              (setf (deadp trigger) t)
  -              (mapc (lambda (process) (setf (deadp process) t)) processes)
  -              (list trigger processes substitutions))))
  -
  -(defgeneric really-match-on (process kell)
  +(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)))
  
positive.code:     (call-next-method)
      (activate-process (process process) process))
    (:method ((process parallel-composition) (kell kell))
      (map-parallel-composition (lambda (sub-process)
                                  (activate-process sub-process kell))
                                process))
    (:method ((process pattern-abstraction) (kell kell))
      (setf (parent process) kell)
      (mapc #'push-event (collect-channel-names process kell)))
  
negative.code:        (remove-duplicates (append (gethash name (local-patterns kell))
                                    (gethash name (down-patterns (parent kell)))
                                    (mappend (lambda (subkell)
                                               (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)) process))
    (:method ((process pattern-abstraction) (kell kell))
      "Just match on the new trigger."
      (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-
  