anchor.diff:                 (slime-quit)))))
   
   (define-command slime (&optional ask-impl) ("P")
  -  (let ((impl (if ask-impl
  +  (let ((command (if ask-impl
                     (prompt-for-impl)
  -                  *impl-name*)))
  -    (run-slime (get-lisp-command :impl impl))))
  +                  (get-lisp-command :impl *impl-name*))))
  +    (run-slime command)))
   
   (define-command slime-quit () ()
     (when *connection*
  
positive.code: 
  (defparameter *impl-name* nil)
  
  (let (cache)
    (defun completion-impls (str)
      (unless (and cache
                   (< (get-universal-time) (+ 3600 (cdr cache))))
        (setf cache (cons (nreverse (uiop:split-string (string-right-trim
                                              (format nil "~%")
                                              (with-output-to-string (out)
                                               (uiop:run-program "ros list installed" :output out)))
                                             :separator '(#\Newline)))
                          (get-universal-time))))
      (completion-strings
       str (append (first cache)
                   (when (and #+ros.init (roswell.util:which "qlot"))
                     (mapcar (lambda (x) (format nil "qlot/~A" x)) (first cache)))
                   '("")))))
  
  (defun prompt-for-impl (&key (existing t))
    (let ((impl (prompt-for-line
  
negative.code:                'completion-impls
                 (and existing
                      (lambda (name)
                        (member name (completion-impls name) :test #'string=)))
                 'mh-read-impl)))
      (loop :for f :in *slime-command-impls*
            :for command := (funcall f impl)
            :when command
            :do (return-from prompt-for-impl command))))
  
  (defun run-slime (cmd)
    (uiop:with-current-directory ((or (buffer-directory) (uiop:getcwd)))
  