Defining a unique-pairs procedure
Your code

(define (enumerate-integers start end)
  (if (&gt;= start end)
      (list end)
      (cons start (enumerate-integers (+ 1 start) end))))

(define (unique-pairs n)
  (flat-map (lambda (i) 
              (map (lambda (j) (list i j)) 
                   (enumerate-integers 1 (- i 1))))
            (enumerate-integers 2 n)))


looks fine to me. If you want to massage some details, you could rewrite enumerate-integers e.g. to:

(define (enumerate-integers start end)
  (if (&gt; start end) '()
      (cons start (enumerate-integers (+ 1 start) end))))


which is cleaner because you don't have (list end) as a special case, and you can correctly produce an empty list of integers if start > end.

If you want to be even cleaner, you can do:

(define (enumerate-integers start end)
  (define (iter n)
    (if (&gt; n end) '()
        (cons n (iter (+ n 1)))))
  (iter start))


This is a good pattern in case of more complex procedures.

Your flat-map is more complex than needed, your code:

(define (flat-map f seq)
  (accumulate append
              null
              (map (lambda (x) (f x)) seq)))


can be replaced with:

(define (flat-map f seq)
  (accumulate append
              null
              (map f seq)))


because (lambda (x) (f x)) is equal to f.