anchor.diff:  The evaluation may happen on its own instance or on an already running instance."
     (unless (or (getf *options* :no-init)
                 (not (init-file-path)))
  -    (load-lisp (init-file-path) :interactive nil :package (find-package :next-user)))
  +    (load-lisp (init-file-path) :package (find-package :next-user)))
     ;; We need a browser instance so that listen-socket-p can know the socket path.
     ;; TODO: Use slot default instead?  Ideally, socket could also
     ;; be a command line parameter so that multiple instances can be started.
  
positive.code:     (unless (or (getf *options* :no-init)
                  (not (init-file-path)))
        (handler-case
            (load-lisp (init-file-path) :interactive t :package (find-package :next-user))
          (error (c)
            (setf startup-error-reporter
                  (lambda ()
  
negative.code: (defparameter *load-init-type-error-message* (str:concat *load-init-error-message*
                                                           " because of a type error"))
  
  (declaim (ftype (function (trivial-types:pathname-designator &key (:package (or null package))))
                  load-lisp))
  (defun load-lisp (file &key package)
    "Load the Lisp FILE (or stream).
     If FILE is \"-\", read from the standard input."
    (let ((*package* (or (find-package package) *package*)))
      (flet ((safe-load ()
               (when (equal "" file)
                 (error "Can't load empty file name."))
               (cond
                 ((and (not (streamp file)) (string= (pathname-name file) "-"))
                  (progn
                    (format t "Loading Lisp from standard input...")
                    (loop for object = (read *standard-input* nil :eof)
                          until (eq object :eof)
                          do (eval object))))
                 ((streamp file)
                  (load file))
                 ((uiop:file-exists-p file)
                  (format t "~&Loading Lisp file ~s...~&" file)
                  (load file)))))
        (if *keep-alive*
            (safe-load)
            (handler-case
                (safe-load)
              (error (c)
                (let ((message (if (subtypep (type-of c) 'type-error)
                                   *load-init-type-error-message*
                                   *load-init-error-message*)))
                  (echo-warning "~a: ~a" message c)
                  (notify (str:concat message ".")))))))))
  
  (define-command load-file ()
    "Load the prompted Lisp file."
    (with-result (file-name-input (read-from-minibuffer
                                   (make-minibuffer
                                    :input-prompt "Load file"
                                    :show-completion-count nil)))
      (load-lisp file-name-input)))
  
  (define-command load-init-file (&key (init-file (init-file-path)))
    "Load or reload the init file."
    (load-lisp init-file :package (find-package :next-user)))
  
  (defun eval-expr (expr)
    "Evaluate the form EXPR (string) and print the result of the last expresion."
  