anchor.diff:    (first (second (buffer-siblings buffer))))
   
   (define-command switch-buffer-previous (&optional (buffer (current-buffer)))
  -  "Switch to the previous sibling buffer.
  -A sibling buffer is a buffer with the same parent.
  -The 'previous' one here means the one with the closest ID below it.
  -If there is no sibling, go to the parent."
  -  (alex:when-let ((previous (or (buffer-sibling-previous buffer)
  -                                (buffer-parent buffer))))
  +  "Switch to the previous buffer in the buffer tree.
  +The tree is browse in a depth-first fashion.
  +When there is no previous buffer, go to the last one so as to cycle."
  +  (alex:when-let ((previous (or (alex:when-let ((previous-sibling (buffer-sibling-previous buffer)))
  +                                  (alex:if-let ((children (buffer-children previous-sibling)))
  +                                    (buffer-last-child (first children))
  +                                    previous-sibling))
  +                                (buffer-parent buffer)
  +                                (buffer-last-child buffer))))
       (set-current-buffer previous)))
   
   (define-command switch-buffer-next (&optional (buffer (current-buffer)))
  -  "Switch to the next sibling buffer.
  -A sibling buffer is a buffer with the same parent.
  -The 'next' one here means the one with the closest ID above it.
  -If there is no sibling, go to the parent."
  -  (alex:when-let ((next (or (buffer-sibling-next buffer)
  -                            (buffer-parent buffer))))
  +  "Switch to the next buffer in the buffer tree.
  +The tree is browse in a depth-first fashion.
  +When there is no next buffer, go to the first one so as to cycle."
  +  (alex:when-let ((next (or (first (buffer-children buffer))
  +                            (buffer-sibling-next buffer)
  +                            (buffer-next-parent-sibling buffer)
  +                            (buffer-first-root buffer))))
       (set-current-buffer next)))
   
   (define-command switch-buffer-last ()
  
positive.code:        :key (lambda (b) (alex:when-let ((owner (htree:owner history (id b))))
                            (htree:creator-id owner)))))))
  
  (defun buffer-siblings (&optional (buffer (current-buffer)))
    (let* ((current-history (get-data (history-path buffer)))
           (buffers (remove-if (complement (sera:eqs current-history))
  
negative.code:                (sort common-parent-buffers #'string< :key #'id)))
          (sera:split-sequence-if (sera:equals (id buffer))
           common-parent-buffers
           :key #'id)))))
  
  (defun buffer-sibling-previous (&optional (buffer (current-buffer)))
    (alex:when-let ((previous-siblings (first (buffer-siblings buffer))))
  