                             cb?(resp.error)
                         else
                             @session_uuid = resp.session_uuid
+                            @chat         = resp.chat
                             codemirror_sessions.by_uuid[@session_uuid] = @
 
-                            # Reconnect to the upstream (local_hub) server, being careful to save our current edits.
-                            edit_stack = @diffsync_server.edit_stack
+                            # Reconnect to the upstream (local_hub) server
                             @diffsync_server = new diffsync.DiffSync(doc:resp.content)
                             @diffsync_server.connect(new CodeMirrorDiffSyncLocalHub(@))
 
-                            # Apply all of the edits we couldn't send while the local hub was down
-                            # to upstream, then set this to our live.  When there are multiple hubs,
-                            # a lot can happen between sync's with a local_hub.
-                            live_content = resp.content
-                            for p in edit_stack
-                                live_content =  diffsync.dmp.patch_apply(p.edits, live_content)[0]
-                            @diffsync_server.live = live_content
-
-                            # Forget our downstream clients -- they will get
-                            # reconnect messages, and keep going fine, eventually.
-                            @diffsync_clients = {}
+                            #
+                            # TODO: apply lost changes!!
+                            #
+                            @set_content(resp.content)
+
+                            codemirror_sessions.by_path[@project_id + @path] = @
+                            codemirror_sessions.by_uuid[@session_uuid] = @
 
                             cb()
 

            if session?
                opts.cb(false, session)
                return
        # Create a new session object.
        @call
            mesg : message.codemirror_get_session(session_uuid:opts.session_uuid, project_id:opts.project_id, path:opts.path)
            cb   : (err, resp) =>
                # winston.debug("new codemirror session: local_hub --> hub: #{err}, #{misc.to_json(resp)}")
                if err
                    opts.cb(err)
                else if resp.event == 'error'
                    opts.cb(resp.error)
                else
                    session = new CodeMirrorSession
                        local_hub    : @
                        project_id   : opts.project_id
                        session_uuid : resp.session_uuid
                        path         : resp.path
                        content      : resp.content
                        chat         : resp.chat
                    codemirror_sessions.by_uuid[resp.session_uuid] = session
                    codemirror_sessions.by_path[opts.project_id + resp.path] = session
                    opts.cb(false, session)

    #########################################
    # Sage sessions -- TODO!

        opts = defaults opts,
            local_hub    : required
            project_id   : required
            path         : required
            cb           : required

        @local_hub    = opts.local_hub
        @project_id   = opts.project_id
        @path         = opts.path

        # min_interval: to avoid possibly DOS's a local hub -- not sure what best choice is here.
        @sync = misc.retry_until_success_wrapper(f:@_sync, min_interval:200, logname:'localhub_sync')

        # The downstream clients of this hub
        @diffsync_clients = {}

        @reconnect (err) =>
            if err
                opts.cb(err)
            else
                opts.cb(false, @)

    reconnect: (cb) =>
        misc.retry_until_success
