anchor.diff:      (with-event-loop (:catch-app-errors t)
         (let ((server (as::tcp-server-new
                         host port
  -                      #'(lambda (socket stream)
  -                          (client-read-cb socket stream
  +                      #'(lambda (socket data)
  +                          (client-read-cb socket data
                                             swank-host swank-port))
                         :event-cb #'socket-event-cb
  -                      :connect-cb #'client-connect-cb
  -                      :stream t)))
  +                      :connect-cb #'client-connect-cb)))
           (vom:debug "Server created: ~s" server)))))
  
positive.code: 
  
  (defun handle-client-msg (msg client-conn)
    (let* ((msg-str (babel:octets-to-string msg))
           (msg-to-swank (msg-client-to-swank msg-str)))
      (with-slots ((swank-conn peer)) client-conn
        (write-sequence
          (babel:string-to-octets msg-to-swank)
          (connection-stream swank-conn)))))
  
  
  (defun ensure-swank-connection (client-conn swank-host swank-port)
    (with-slots ((swank-conn peer)) client-conn
      (when (not swank-conn)
        (vom:debug "Connecting to peer...")
        (let* ((swank-stream
                 (tcp-connect swank-host swank-port
                              #'swank-read-cb
                              :event-cb  #'socket-event-cb
                              :stream t))
               (swank-socket (streamish swank-stream)))
          (make-connection :socket swank-socket
                           :stream swank-stream
                           :peer client-conn)
          (vom:debug "Connection count: ~s" (hash-table-count *connections*))))))
  
  
  (defun client-read-cb (socket stream swank-host swank-port)
    (let* ((data-cache '())
           (client-conn (gethash socket *connections*))
           (line-list (async-stream-read-line stream client-conn data-cache)))
      (when line-list
        (with-slots ((client-stream stream)) client-conn
          (when (not client-stream)
            (setf client-stream stream)))
        (ensure-swank-connection client-conn swank-host swank-port)
        (vom:debug "Raw data from ~s: ~s" socket line-list)
        (dolist (line line-list)
  
negative.code:     (vom:debug "Connection count: ~s" (hash-table-count *connections*))))
  
  
  (defun parse-line (data conn)
    (with-slots (read-buffer) conn
      (setf read-buffer
            (concatenate '(vector (unsigned-byte 8)) read-buffer data))
      (let ((lf-pos (position (char-code #\linefeed) read-buffer)))
        (loop
          when lf-pos
            collect (babel:octets-to-string (subseq read-buffer 0 (1+ lf-pos))) into lines
            and do
              (setf read-buffer (subseq read-buffer (1+ lf-pos)))
              (setf lf-pos
                    (position (char-code #\linefeed) read-buffer :start 0))
          else return lines))))
  
  
  (defun parse-swank-msg-len (buffer)
    (parse-integer (babel:octets-to-string (subseq buffer 0 +swank-msg-len-size+)) :radix 16))
  
  
  (defun parse-swank-msg (data conn)
    (with-slots (read-buffer) conn
      (setf read-buffer
            (concatenate '(vector (unsigned-byte 8)) read-buffer data))
      (let ((msg-total-len
              (when (>= (length read-buffer) +swank-msg-len-size+)
                (+ +swank-msg-len-size+
                   (parse-swank-msg-len read-buffer)))))
        (loop
          when (and msg-total-len (>= (length read-buffer) msg-total-len))
            collect (babel:octets-to-string
                      (subseq read-buffer +swank-msg-len-size+ msg-total-len))
                    into msgs
            and do
              (setf read-buffer (subseq read-buffer msg-total-len))
              (if (>= (length read-buffer) +swank-msg-len-size+)
                (setf msg-total-len
                      (+ +swank-msg-len-size+
                         (parse-swank-msg-len read-buffer)))
                (setf msg-total-len nil))
          else
            return msgs))))
  
  
  (defun handle-swank-msg (msg swank-conn)
    (let ((msg-to-client (msg-swank-to-client msg)))
      (with-slots ((client-conn peer)) swank-conn
        (as:write-socket-data
          (connection-socket client-conn)
          (babel:string-to-octets msg-to-client)))))
  
  
  (defun swank-read-cb (socket data)
    (let* ((swank-conn (gethash socket *connections*))
           (msg-list (parse-swank-msg data swank-conn)))
      (when msg-list
        (dolist (msg msg-list)
          (vom:debug "Message from SWANK: ~s" msg)
          (handler-case (handle-swank-msg msg swank-conn)
            (error (err)
                   (vom:debug
  