         console.warn 'not implemented'
         return
 
+    ###
+    MANAGE:
+
+    Code that manages execution and conflict resolution/sanity.
+    This must run in exactly ONE client.   For now, that client
+    will be the project itself.
+    ###
+
+    # Called when the manager first starts up after the store is initialized.
+    # Here we ensure everything is in a consistent state so that we can react
+    # to changes later.
+    initialize_manager: =>
+        dbg = @dbg("initialize_manager")
+        dbg("cells at manage_init = #{JSON.stringify(@store.get('cells')?.toJS())}")
+
+
+    # _manage_cell_change is called after a cell change has been
+    # incorporated into the store by _syncdb_cell_change.
+    # It should do things like ensure any cell with a compute request
+    # gets computed, that all positions are unique, that there is a
+    # cell, etc.  Only one client will run this code.
+    manage_on_cell_change: (id, new_cell, old_cell) =>
+        if not new_cell?
+            # delete cell -- if it was running, stop it.
+            # TODO
+            return
+        if new_cell.get('state') == 'start'
+            @manager_run_cell(id)
+
     # Runs only on the backend
-    project_run_cell: (id) =>
-        dbg = @_client.dbg("jupyter-project_run_cell")
+    manager_run_cell: (id) =>
+        dbg = @dbg("manager_run_cell")
         dbg()
         cell = @store.get('cells').get(id)
 
+        try
+            out = "#{eval(cell.get('input'))}"
+        catch e
+            out = "#{e}"
         @_set
             type  : 'cell'
             id    : id
-            state : 'starting'
-
-        f1 = =>
-            dbg('f1')
-            @_set
-                type  : 'cell'
-                id    : id
-                state : 'running'
-
-        f2 = =>
-            dbg('f2')
-            try
-                out = "#{eval(cell.get('input'))}"
-            catch e
-                out = "#{e}"
-            @_set
-                type  : 'cell'
-                id    : id
-                state : 'done'
-                output : [out]
-        setTimeout(f1, 500)
-        setTimeout(f2, 1000)
+            state : 'done'
+            output : [out]

            @setState(cell_list : cell_list)
        return

    _syncdb_cell_change: (id, record) =>
        cells = @store.get('cells') ? immutable.Map()
        cell_list_needs_recompute = false
        #@_client.dbg("_syncdb_cell_change")("#{id} #{JSON.stringify(record?.toJS())}")
        if not record?
            # delete cell
            if cells?.get(id)?
                obj = {cells: cells.delete(id)}
                cell_list = @store.get('cell_list')
                if cell_list?

                @setState(obj)
        else
            # change or add cell
            old_cell = cells.get(id)
            if new_cell.equals(old_cell)
                return # nothing to do
            obj = {cells: cells.set(id, new_cell)}
            if not old_cell? or old_cell.get('pos') != new_cell.get('pos')
                cell_list_needs_recompute = true
            @setState(obj)
        if @_is_manager
            @manage_on_cell_change(id, new_cell, old_cell)
        return cell_list_needs_recompute

    _syncdb_change: (changes) =>
        do_init = @_is_manager and not @store.get('cells')?
        #console.log 'changes', changes, changes?.toJS()
        #@dbg("_syncdb_change")(JSON.stringify(changes?.toJS()))
        @set_has_unsaved_changes()
        cell_list_needs_recompute = false
        changes?.forEach (key) =>
