anchor.diff:    (or (frame-calling-frame frame)
         (frame-manager frame)))
   
  +(defmethod frame-query-io ((frame standard-application-frame))
  +  (or (frame-standard-input frame)
  +      (frame-standard-output frame)))
  +
   (defgeneric frame-geometry* (frame))
   
   (defmethod frame-geometry* ((frame standard-application-frame))
  
positive.code:                 :accessor frame-standard-output
                  :accessor frame-error-output)
     (input-pane :initform nil
                 :accessor frame-standard-input
                 :accessor frame-query-io)
     (documentation-pane :initform nil
                         :accessor frame-pointer-documentation-output)
  
  
negative.code:            'command-line-read-remaining-arguments-for-partial-command)
            (prompt "Command: "))
    ;; Give each pane a fresh start first time through.
    (let ((needs-redisplay t)
          (first-time t))
      (loop
         ;; The variables are rebound each time through the loop because the
         ;; values of frame-standard-input et al. might be changed by a command.
         ;;
         ;; We rebind *QUERY-IO* ensuring variable is always a stream,
         ;; but we use FRAME-QUERY-IO for our own actions and to decide
         ;; whenever frame has the query IO stream associated with it..
         (let* ((frame-query-io (frame-query-io frame))
                (interactorp (typep frame-query-io 'interactor-pane))
                (*standard-input*  (or (frame-standard-input frame)  *standard-input*))
                (*standard-output* (or (frame-standard-output frame) *standard-output*))
                (*query-io* (or frame-query-io *query-io*))
                ;; during development, don't alter *error-output*
                ;; (*error-output* (frame-error-output frame))
                (*pointer-documentation-output* (frame-pointer-documentation-output frame))
                (*command-parser* command-parser)
                (*command-unparser* command-unparser)
                (*partial-command-parser* partial-command-parser))
           (restart-case
               (flet ((execute-command ()
                        (when-let ((command (read-frame-command frame :stream frame-query-io)))
                          (setq needs-redisplay t)
                          (execute-frame-command frame command))))
                 (when needs-redisplay
                   (redisplay-frame-panes frame :force-p first-time)
                   (setq first-time nil
                         needs-redisplay nil))
                 (when interactorp
                   (setf (cursor-visibility (stream-text-cursor frame-query-io)) nil)
                   (when prompt
                     (with-text-style (frame-query-io +default-prompt-style+)
                       (if (stringp prompt)
                           (write-string prompt frame-query-io)
                           (funcall prompt frame-query-io frame))
                       (force-output frame-query-io))))
                 (execute-command)
                 (when interactorp
                   (fresh-line frame-query-io)))
             (abort ()
               :report "Return to application command loop."
               (if interactorp
                   (format frame-query-io "~&Command aborted.~&")
                   (beep))))))))
  
  (defmethod read-frame-command :around ((frame application-frame)
  