anchor.diff:        (attachf result (executables-in-directory path)))
       (flatten-sequence result)))
   
  +(defun all-builtin-commands ()
  +  (let ((result (fset:empty-set))
  +        (command-table (command-namespace-table *command-namespace*)))
  +    (fset:do-map (key value command-table)
  +      (declare (ignore value))
  +      (fset:adjoinf result key))
  +    result))
  +
  +(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)
        context
        parser-vars)
  -  (multiple-value-bind (command-words valid-p) (fset:lookup parser-vars 'parsed-simple-command-words)
  +  (multiple-value-bind (command-words valid-p) (fset:lookup parser-vars +parsed-simple-command-words+)
       (unless valid-p
         (return-from completion-suggestions))
   
  
positive.code:     (return-from parse-simple-command-word
        (call-next-method)))
  
    (assert (parser-var 'parsed-simple-command-words))
    (let ((return-values (multiple-value-list (call-next-method))))
      (attachf (parser-var 'parsed-simple-command-words) (car return-values))
      (values-list return-values)))
  
  (defgeneric parse-error-involves-sigil-token-p (err sigil-token))
  
negative.code:       (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))))))
  