       state.outstanding(new)
     end
     def join_outstanding(new, __MODULE__[outstanding: clock] = state) do
-      try do
-        state.outstanding(ITC.join(clock, new))
-      catch _, _ -> # if we can't join, then we already did                    
-        state
-      end
+      Lager.info "join_outstanding #{inspect new} #{inspect clock}"
+      state.outstanding(ITC.join(clock, new))
     end
 
     defoverridable crash_clock: 2

    :ets.insert(state.children,
                [{channel, channel_clock},
                 {channel_clock, channel}])
    state = state.clock(new_clock).join_outstanding(channel_clock)
    {:reply, {:ok, channel}, state}
  end


      [{^channel, clock}] ->
        :ets.insert(c, [{channel, new_clock}, {new_clock, channel}])
        :ets.delete(c, clock)
        state = state.update_outstanding(fn(o) -> [new_clock|o] -- [clock] end)
      [] -> 
        :ok # TODO: log a warning?
    end
    {:noreply, state}
  end

  def handle_info({:DOWN, _ref, :process, pid, _},
                  __MODULE__.State[clock: clock, crash_clock: crash_clock, children: c] = state) do
    [{^pid, child_clock}] = :ets.lookup(c, pid)
    :ets.delete(c, pid)
    :ets.delete(c, child_clock)
    clock = ITC.join(clock, child_clock)
    state = state.clock(clock).update_outstanding(fn(o) -> o -- [child_clock] end)
    state = state.crash_clock(Enum.reduce(state.outstanding, clock, fn(c, c1) -> ITC.join(c, c1) end))
    {:noreply, state}
  end

  @spec execute(pid, Genomu.key | Genomu.cell, Genomu.command, Keyword.t) :: term
  defcall execute(key, cmd, options), state: State[] = state do
