anchor.diff:  
    
  +(defun scan-current-package (point)
  +  (with-point ((p point))
  +    (loop
  +      (multiple-value-bind (result groups)
  +          (looking-at (line-start p)
  +                      "^\\s*\\(in-package (?:#?:|')?([^\)]*)\\)")
  +        (when result
  +          (let ((package (aref groups 0)))
  +            (when package
  +              (return package))))
  +        (unless (line-offset p -1)
  +          (return))))))
  +
   (defun idle-timer-function ()
     (when (and (eq (buffer-major-mode (current-buffer)) 'slime-mode)
                (connected-p))
  -    (let ((package (lem.lisp-mode::scan-current-package #'identity)))
  +    (let ((package (scan-current-package (current-point))))
         (when package
           (slime-set-package package)))))
   
  
positive.code:     (self-connect)))
  
  (defun buffer-package (buffer &optional default)
    (or (lem.lisp-mode::lisp-buffer-package buffer)
        default))
  
  (defun current-package ()
    (or (buffer-package (current-buffer))
  
negative.code: (defun repl-get-prompt ()
    (format nil "~A> " *slime-prompt-string*))
  
  (defun repl-paren-correspond-p (point)
    (loop :with count := 0
          :do
          (insert-character point #\))
          (incf count)
          (unless (form-offset (copy-point point :temporary) -1)
            (delete-character point (- count))
            (return (= 1 count)))))
  
  (defun repl-reset-input ()
    (let ((buffer (repl-buffer)))
      (when buffer
        (setf (variable-value 'lem.listener-mode:listener-get-prompt-function :buffer buffer)
              'repl-get-prompt
              (variable-value 'lem.listener-mode:listener-check-confirm-function :buffer buffer)
              'repl-paren-correspond-p
              (variable-value 'lem.listener-mode:listener-confirm-function :buffer buffer)
              'repl-confirm))))
  
  