             if session?
                 opts.cb(false, session)
                 return
+        if not (opts.path? and opts.project_id?)
+            opts.cb("reconnect")  # will send path next time
+            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)
+        new CodeMirrorSession
+            local_hub   : @
+            project_id  : opts.project_id
+            path        : opts.path
+            cb          : opts.cb
 
     #########################################
     # Sage sessions -- TODO!

                            cb?(resp.error)
                        else
                            @session_uuid = resp.session_uuid
                            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
                            @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 = {}

                            cb()


        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
