anchor.diff:                (startup-file (probe-file "~/.shclrc.lisp")))
             (when startup-file
               (load startup-file))
  -          (handler-bind
  -              ((parse-failure
  -                (lambda (e)
  -                  (when-let ((restart (find-restart 'ignore-command)))
  -                    (format *error-output* "Parse error: ~A~%" e)
  -                    (invoke-restart restart)))))
  -            (let ((result (truthy-exit-info)))
  -              (handler-case
  -                  (do-iterator (values (main-iterator stream :history h))
  -                    (if (exit-info-p (car values))
  -                        (setf result (car values))
  -                        (warn "Got non-exit-info result: ~A" values)))
  -                (exit-condition (e)
  -                  (setf result (exit-condition-exit-info e))))
  -              (exit (exit-info-code result)))))))))
  +
  +          (handler-case
  +              (shell-repl stream :history h)
  +            (exit-condition (e)
  +              (exit-condition-exit-info e))))))))
  
positive.code:               (debug-log status "EVAL: ~A" form)
                form)))
  
  (defun logging-evaluated-result-sequence (forms)
    (lazy-map forms
              (lambda (form)
                (let ((values (multiple-value-list (eval form))))
                  (debug-log status "RESULT: ~A" values)
                  values))))
  
  (defun main-iterator (stream &key history)
    (let* ((captured-input (when history (make-string-output-stream)))
           (wrapped-stream (if history (make-echo-stream stream captured-input) stream))
           results)
      (make-computed-iterator
        (let ((*fresh-prompt* t))
          (labels
              ((record-history ()
                 (when history
                   (history-enter history (get-output-stream-string captured-input)))
                 (setf *fresh-prompt* t))
               (initialize-sequence ()
                 (setf results (as-> wrapped-stream x
                                 (logging-token-sequence x)
                                 (logging-command-sequence x)
                                 (logging-evaluation-form-sequence x)
                                 (logging-evaluated-result-sequence x))))
               (reset-token-sequence ()
                 (loop :while (read-char-no-hang wrapped-stream nil nil))
                 (initialize-sequence)
                 (record-history)))
            (unless results
              (initialize-sequence))
            (tagbody
             start
               (restart-case
                   (progn
                     (do-while-popf (value results)
                       (record-history)
                       (emit value))
                     (stop))
                 (ignore-command ()
                   (reset-token-sequence)
                   (go start))
                 (die ()
                   (exit 1)))))))))
  
  (defparameter *debug* nil)
  (defparameter *help* nil
  
negative.code:   (:use
     :common-lisp :trivial-gray-streams :shcl/core/lexer :shcl/core/shell-grammar
     :shcl/core/utility :shcl/core/evaluate
     :shcl/core/lisp-interpolation :shcl/core/dispatch-table)
    (:import-from :shcl/core/sequence
     #:lazy-map #:do-while-popf #:do-sequence #:wrap-with #:cache-impure)
    (:import-from :shcl/core/command #:define-builtin)
    (:import-from :shcl/core/shell-lambda
     #:handle-command-errors #:with-parsed-arguments)
    (:import-from :shcl/core/posix #:exit)
    (:import-from :shcl/core/command #:exit-condition #:exit-condition-exit-info)
    (:import-from :shcl/core/exit-info
     #:truthy-exit-info #:exit-info-code #:exit-info-p #:falsey-exit-info)
    (:import-from :shcl/core/environment #:env)
    (:import-from :shcl/shell/directory)
    (:import-from :shcl/shell/builtins)
  