anchor.diff:      (unless valid-p
         (return-from completion-suggestions))
   
  -    (when (empty-p command-words)
  -      (labels
  -          ((compatible-p (command)
  -             (sequence-starts-with-p command (simple-word-text token))))
  -        (eager-map (eager-filter (all-commands) #'compatible-p (fset:empty-seq))
  -                   (lambda (str)
  -                     (make-simple-completion-suggestion str context))
  -                   (fset:empty-seq))))))
  +    (cond
  +      ((empty-p command-words)
  +       (labels
  +           ((compatible-p (command)
  +              (sequence-starts-with-p command (simple-word-text token))))
  +         (eager-map (eager-filter (all-commands) #'compatible-p (fset:empty-seq))
  +                    (lambda (str)
  +                      (make-simple-completion-suggestion str context))
  +                    (fset:empty-seq))))
  +
  +      (t
  +       ;; Technically, this should run even when command-words is
  +       ;; empty.  One step at a time!
  +       (let* ((pipeline (compute-expansion-pipeline :expand-aliases nil :end-at :expand-wild-paths))
  +              (wild-paths (run-expansion-pipeline (list token) pipeline :split-fields nil :allow-side-effects nil)))
  +         (unless (and (not (empty-p wild-paths))
  +                      (empty-p (tail wild-paths)))
  +           (error "Expected exactly one wild path... got ~A" wild-paths))
  +
  +         (when (wild-path-has-wild-component-p (head wild-paths))
  +           (let* ((remaining-pipeline (compute-expansion-pipeline :expand-aliases nil :start-at :expand-wild-paths))
  +                  (paths (run-expansion-pipeline wild-paths remaining-pipeline :split-fields nil :allow-side-effects nil))
  +                  (quoted-paths (eager-map paths (lambda (str) (shell-quote str context)) (fset:empty-seq)))
  +                  (suggestion-text (with-output-to-string (out)
  +                                     (do-while-popf (path quoted-paths)
  +                                       (write-string path out)
  +                                       (unless (empty-p quoted-paths)
  +                                         (write-string " " out))))))
  +             (list
  +              (make-simple-completion-suggestion
  +               suggestion-text
  +               context)))))))))
   
   (defvar *empty-token* (make-instance 'simple-word :text ""))
   
  
positive.code: (defun all-commands ()
    (concatenate-sequences (all-binary-commands) (all-builtin-commands)))
  
  (defmethod completion-suggestions concatenate-sequences
      ((desired (eql (find-class 'simple-word)))
       (token simple-word)
  
negative.code:   (:use :common-lisp :shcl/core/utility :shcl/core/iterator)
    (:import-from :shcl/core/sequence
     #:attachf #:empty-p #:concatenate-sequences #:eager-flatmap-sequence
     #:do-while-popf #:eager-map #:eager-filter #:flatten-sequence #:walk #:head
     #:tail)
    (:import-from :shcl/core/advice #:define-advice)
    (:import-from :shcl/core/shell-grammar
     #:parse-simple-command #:parse-simple-command-word #:commands-for-tokens)
  