anchor.diff:  
   (defparameter *shell-readtable* +standard-shell-readtable+)
   
  -(defclass echo (trivial-gray-streams:fundamental-character-output-stream)
  +(defparameter *fresh-prompt* t)
  +
  +(defun next-line ()
  +  (let ((prompt (if *fresh-prompt* "shcl> " "> ")))
  +    (setf *fresh-prompt* nil)
  +    (get-line prompt)))
  +
  +(defclass interactive-buffer (fundamental-character-input-stream)
  +  ((text
  +    :initform (fset:empty-seq))))
  +
  +(defun extend-interactive-buffer (stream)
  +  (with-slots (text) stream
  +    (unless (open-stream-p stream)
  +      (error "Stream is closed"))
  +    (unless (zerop (fset:size text))
  +      (error "Stream isn't empty yet"))
  +    (let ((next-line (next-line)))
  +      (cond
  +        (next-line
  +         (assert (plusp (length next-line)))
  +         (fset:appendf text next-line))
  +
  +        (t
  +         (close stream)))
  +      (values))))
  +
  +(defun buffer-read-char (s hang-p)
  +  (with-slots (text) s
  +    (tagbody
  +     again
  +       (return-from buffer-read-char
  +         (cond
  +           ((plusp (fset:size text))
  +            (let ((result (fset:pop-first text)))
  +              result))
  +
  +           ((not (open-stream-p s))
  +            :eof)
  +
  +           (hang-p
  +            (extend-interactive-buffer s)
  +            (go again))
  +
  +           (t
  +            nil))))))
  +
  +(defmethod stream-read-char ((s interactive-buffer))
  +  (let ((value (buffer-read-char s t)))
  +    (assert value)
  +    value))
  +
  +(defmethod stream-unread-char ((s interactive-buffer) char)
  +  (with-slots (text) s
  +    (fset:push-first text char)
  +    nil))
  +
  +(defmethod stream-read-char-no-hang ((s interactive-buffer))
  +  (buffer-read-char s nil))
  +
  +(defmethod stream-clear-input ((s interactive-buffer))
  +  (with-slots (text) s
  +    (setf text (fset:empty-seq))))
  +
  +(defclass echo (fundamental-character-output-stream)
       ())
   
  -(defmethod trivial-gray-streams:stream-write-char ((s echo) char)
  +(defmethod stream-write-char ((s echo) char)
     (format *standard-output* "CHAR: ~W~%" char)
     char)
   
  
positive.code:     (when *enable-lisp-splice*
        (setf *shell-readtable* *splice-table*))
  
      (run-shell-commands-in-stream *standard-input* :prompt-stream *standard-output*)))
  
negative.code:        (progv ,vars ,values
           ,@body))))
  
  (defun run-shell-commands-in-stream (stream)
    (let* ((form-queue (make-queue))
           (commands (restartable-command-iterator stream form-queue))
           (*fresh-prompt* t)
           last-result)
      (restart-case
          (do-iterator (tree commands)
            (loop
  