anchor.diff:  (defun lem (&rest args)
     (if *in-the-editor*
         (mapc 'find-file args)
  -      (let ((report (with-editor ()
  -                      (mapc 'find-file args)
  -                      (lem-internal))))
  -        (when report
  -          (format t "~&~A~%" report)))))
  +      (with-editor ()
  +        (mapc 'find-file args)
  +        (lem-internal))))
  
positive.code:        :stream stream
         :count 100))))
  
  (defun error-report (condition)
    (with-output-to-string (stream)
      (princ condition stream)
      (uiop/image:print-backtrace
       :stream stream
       :condition condition)))
  
  (defun bailout (condition)
    (throw 'toplevel
      (error-report condition)))
  
  (defmacro with-error-handler (() &body body)
    `(handler-case-bind ((lambda (condition)
  
negative.code:     (stop-idle-timers)))
  
  (defun toplevel-editor-loop ()
    (do-commandloop (:toplevel t)
      (with-error-handler ()
        (when (= 0 (event-queue-length)) (redraw-display))
        (handler-case
            (handler-bind ((editor-condition
                            (lambda (c)
                              (declare (ignore c))
                              (stop-record-key))))
              (let ((cmd (read-key-command-with-idle-timers)))
                (message nil)
                (cmd-call cmd nil)))
          (editor-abort ()
                        (buffer-mark-cancel (current-buffer))
                        (message "Quit"))
          (editor-condition (c)
                            (message "~A" c))))))
  
  (defun lem-internal ()
    (let* ((main-thread (bt:current-thread))
           (editor-thread (bt:make-thread
                           (lambda ()
                             (let ((*in-the-editor* t))
                               (let ((report (with-catch-bailout
                                               (toplevel-editor-loop))))
                                 (bt:interrupt-thread
                                  main-thread
                                  (lambda ()
                                    (error 'exit-editor :value report))))))
                           :name "editor")))
      (handler-case
          (loop
  