diff --git a/config/config.exs b/config/config.exs
index e2d7db9..bf52838 100644
--- a/config/config.exs
+++ b/config/config.exs
@@ -1,54 +1,56 @@
 import Config
 
 config :logger, level: :debug
 config :logger, :console,
   format: "$date $time [$level] $metadata$message\n",
   metadata: :all
 
 config :phoenix, :json_library, Jason
 
 # General application configuration
 config :nola,
   namespace: Nola
 
 config :nola, :data_path, "priv"
 
 config :nola, :brand,
   name: "Nola",
-  source_url: "https://phab.random.sh/source/Nola/"
+  source_url: "https://phab.random.sh/source/Nola/",
+  owner: "Ashamed Owner",
+  owner_email: "do@not.mail.him"
 
 config :ex_aws,
   region: "us-east-1",
   host: "s3.wasabisys.com",
   s3: [
     host: "s3.wasabisys.com",
     region: "us-east-1",
     scheme: "https://"
   ]
 
 # Configures the endpoint
 config :nola, NolaWeb.Endpoint,
   url: [host: "localhost"],
   secret_key_base: "cAFb7x2p/D7PdV8/C6Os18uygoD0FVQh3efNEFc5+5L529q3dofZtZye/BG12MRZ",
   render_errors: [view: NolaWeb.ErrorView, accepts: ~w(html json)],
   server: true,
   live_view: [signing_salt: "CHANGE_ME_FFS"],
   pubsub: [name: NolaWeb.PubSub,
            adapter: Phoenix.PubSub.PG2]
 
 config :mime, :types, %{"text/event-stream" => ["sse"]}
 
 config :nola, :lastfm,
   api_key: "x",
   api_secret: "x"
 
 config :nola, :youtube,
   api_key: "x",
   invidious: "yewtu.be"
 
 config :mnesia,
   dir: '.mnesia/#{Mix.env}/#{node()}'
 
 # Import environment specific config. This must remain at the bottom
 # of this file so it overrides the configuration defined above.
 import_config "#{Mix.env}.exs"
diff --git a/lib/plugins/base.ex b/lib/plugins/base.ex
index 1baf066..97aaa05 100644
--- a/lib/plugins/base.ex
+++ b/lib/plugins/base.ex
@@ -1,136 +1,144 @@
 defmodule Nola.Plugins.Base do
 
   def irc_doc, do: nil
 
   def start_link() do
     GenServer.start_link(__MODULE__, [], name: __MODULE__)
   end
 
   def init([]) do
     regopts = [plugin: __MODULE__]
     {:ok, _} = Registry.register(Nola.PubSub, "trigger:version", regopts)
     {:ok, _} = Registry.register(Nola.PubSub, "trigger:help", regopts)
     {:ok, _} = Registry.register(Nola.PubSub, "trigger:liquidrender", regopts)
     {:ok, _} = Registry.register(Nola.PubSub, "trigger:plugin", regopts)
     {:ok, _} = Registry.register(Nola.PubSub, "trigger:plugins", regopts)
     {:ok, nil}
   end
 
   def handle_info({:irc, :trigger, "plugins", msg = %{trigger: %{type: :bang, args: []}}}, _) do
     enabled_string = Nola.Plugins.enabled()
     |> Enum.map(fn(string_or_module) ->
       case string_or_module do
         string when is_binary(string) -> string
         module when is_atom(module) ->
           module
           |> Macro.underscore()
           |> String.split("/", parts: :infinity)
           |> List.last()
         end
     end)
     |> Enum.sort()
     |> Enum.join(", ")
     msg.replyfun.("Enabled plugins: #{enabled_string}")
     {:noreply, nil}
   end
 
   def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :query, args: [plugin]}} = m}, _) do
     module = Module.concat([Nola.Plugins, Macro.camelize(plugin)])
     with true <- Code.ensure_loaded?(module),
          pid when is_pid(pid) <- GenServer.whereis(module)
     do
       m.replyfun.("loaded, active: #{inspect(pid)}")
     else
       false -> m.replyfun.("not loaded")
       nil ->
         msg = case Nola.Plugins.get(module) do
           :disabled -> "disabled"
           {_, false, _} -> "disabled"
           _ -> "not active"
         end
         m.replyfun.(msg)
     end
     {:noreply, nil}
   end
 
   def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :plus, args: [plugin]}} = m}, _) do
     module = Module.concat([Nola.Plugins, Macro.camelize(plugin)])
     with true <- Code.ensure_loaded?(module),
          Nola.Plugins.switch(module, true),
          {:ok, pid} <- Nola.Plugins.start(module)
     do
       m.replyfun.("started: #{inspect(pid)}")
     else
       false -> m.replyfun.("not loaded")
       :ignore -> m.replyfun.("disabled or throttled")
       {:error, _} -> m.replyfun.("start error")
     end
     {:noreply, nil}
   end
 
   def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :tilde, args: [plugin]}} = m}, _) do
     module = Module.concat([Nola.Plugins, Macro.camelize(plugin)])
     with true <- Code.ensure_loaded?(module),
          pid when is_pid(pid) <- GenServer.whereis(module),
          :ok <- GenServer.stop(pid),
          {:ok, pid} <- Nola.Plugins.start(module)
     do
       m.replyfun.("restarted: #{inspect(pid)}")
     else
       false -> m.replyfun.("not loaded")
       nil -> m.replyfun.("not active")
     end
     {:noreply, nil}
   end
 
 
   def handle_info({:irc, :trigger, "plugin", %{trigger: %{type: :minus, args: [plugin]}} = m}, _) do
     module = Module.concat([Nola.Plugins, Macro.camelize(plugin)])
     with true <- Code.ensure_loaded?(module),
          pid when is_pid(pid) <- GenServer.whereis(module),
          :ok <- GenServer.stop(pid)
     do
       Nola.Plugins.switch(module, false)
       m.replyfun.("stopped: #{inspect(pid)}")
     else
       false -> m.replyfun.("not loaded")
       nil -> m.replyfun.("not active")
     end
     {:noreply, nil}
   end
 
   def handle_info({:irc, :trigger, "liquidrender", m = %{trigger: %{args: args}}}, _) do
     template = Enum.join(args, " ")
     m.replyfun.(Tmpl.render(template, m))
     {:noreply, nil}
   end
 
   def handle_info({:irc, :trigger, "help", m = %{trigger: %{type: :bang}}}, _) do
     url = NolaWeb.Router.Helpers.irc_url(NolaWeb.Endpoint, :index, m.network, NolaWeb.format_chan(m.channel))
     m.replyfun.("-> #{url}")
     {:noreply, nil}
   end
 
   def handle_info({:irc, :trigger, "version", message = %{trigger: %{type: :bang}}}, _) do
     {:ok, vsn} = :application.get_key(:nola, :vsn)
     ver = List.to_string(vsn)
     url = NolaWeb.Router.Helpers.irc_url(NolaWeb.Endpoint, :index)
     elixir_ver = Application.started_applications() |> List.keyfind(:elixir, 0) |> elem(2) |> to_string()
     otp_ver = :erlang.system_info(:system_version) |> to_string() |> String.trim()
     system = :erlang.system_info(:system_architecture) |> to_string()
     brand = Nola.brand(:name)
     owner = "#{Nola.brand(:owner)} <#{Nola.brand(:owner_email)}>"
-    message.replyfun.([
-       <<"🤖 I am a robot running", 2, "#{brand}, version #{ver}", 2, " — source: #{Nola.source_url()}">>,
-      "🦾 Elixir #{elixir_ver} #{otp_ver} on #{system}",
-      "👷‍♀️ Owner: h#{owner}",
-      "🌍 Web interface: #{url}"
-    ])
+
+    if message.channel do
+      message.replyfun.([
+        <<"🤖 ", 2, "#{brand}", 2, " v", 2, "#{ver}", 2, "! My owner is #{Nola.brand(:owner)} and help is at #{url}">>,
+      ])
+    else
+      message.replyfun.([
+        <<"🤖 I am a robot running ", 2, "#{brand}", 2, " version ", 2, "#{ver}", 2, " — source: #{Nola.source_url()}">>,
+        "Source code: #{Nola.source_url()}",
+        "🦾 Elixir #{elixir_ver} #{otp_ver} on #{system}",
+        "🙋🏻 Owner: #{owner}",
+         "🌍 Web interface: #{url}"
+      ])
+    end
     {:noreply, nil}
   end
 
-  def handle_info(msg, _) do
+  def handle_info(_msg, _) do
     {:noreply, nil}
   end
 
 end
diff --git a/lib/plugins/last_fm.ex b/lib/plugins/last_fm.ex
index 8e872ea..b7d0a92 100644
--- a/lib/plugins/last_fm.ex
+++ b/lib/plugins/last_fm.ex
@@ -1,187 +1,187 @@
 defmodule Nola.Plugins.LastFm do
   require Logger
 
   @moduledoc """
   # last.fm
 
   * **!lastfm|np `[nick|username]`**
   * **.lastfm|np**
   * **+lastfm, -lastfm `<username last.fm>; ?lastfm`** Configurer un nom d'utilisateur last.fm
   """
 
   @single_trigger ~w(lastfm np)
   @pubsub_topics ~w(trigger:lastfm trigger:np)
 
   defstruct dets: nil
 
   def irc_doc, do: @moduledoc
 
   def start_link() do
     GenServer.start_link(__MODULE__, [], name: __MODULE__)
   end
 
   def init([]) do
-    regopts = [type: __MODULE__]
-    for t <- @pubsub_topics, do: {:ok, _} = Registry.register(Nola.PubSub, t, type: __MODULE__)
+    regopts = [plugin: __MODULE__]
+    for t <- @pubsub_topics, do: {:ok, _} = Registry.register(Nola.PubSub, t, regopts)
     dets_filename = (Nola.data_path() <> "/" <> "lastfm.dets") |> String.to_charlist
     {:ok, dets} = :dets.open_file(dets_filename, [])
     {:ok, %__MODULE__{dets: dets}}
   end
 
   def handle_info({:irc, :trigger, "lastfm", message = %{trigger: %{type: :plus, args: [username]}}}, state) do
     username = String.strip(username)
     :ok = :dets.insert(state.dets, {message.account.id, username})
     message.replyfun.("#{message.sender.nick}: nom d'utilisateur last.fm configuré: \"#{username}\".")
     {:noreply, state}
   end
 
   def handle_info({:irc, :trigger, "lastfm", message = %{trigger: %{type: :minus, args: []}}}, state) do
     text = case :dets.lookup(state.dets, message.account.id) do
              [{_nick, _username}] ->
                :dets.delete(state.dets, message.account.id)
                message.replyfun.("#{message.sender.nick}: nom d'utilisateur last.fm enlevé.")
              _ -> nil
            end
     {:noreply, state}
   end
 
   def handle_info({:irc, :trigger, "lastfm", message = %{trigger: %{type: :query, args: []}}}, state) do
     text = case :dets.lookup(state.dets, message.account.id) do
       [{_nick, username}] ->
         message.replyfun.("#{message.sender.nick}: #{username}.")
       _ -> nil
     end
     {:noreply, state}
   end
 
   def handle_info({:irc, :trigger, _, message = %{trigger: %{type: :bang, args: []}}}, state) do
     irc_now_playing(message.account.id, message, state)
     {:noreply, state}
   end
 
   def handle_info({:irc, :trigger, _, message = %{trigger: %{type: :bang, args: [nick_or_user]}}}, state) do
     irc_now_playing(nick_or_user, message, state)
     {:noreply, state}
   end
 
   def handle_info({:irc, :trigger, _, message = %{trigger: %{type: :dot}}}, state) do
     members = Nola.Membership.members(message.network, message.channel)
     foldfun = fn({nick, user}, acc) -> [{nick,user}|acc] end
     usernames = :dets.foldl(foldfun, [], state.dets)
                 |> Enum.uniq()
                 |> Enum.filter(fn({acct,_}) -> Enum.member?(members, acct) end)
                 |> Enum.map(fn({_, u}) -> u end)
     for u <- usernames, do: irc_now_playing(u, message, state)
     {:noreply, state}
   end
 
   def handle_info(info, state) do
     {:noreply, state}
   end
 
   def terminate(_reason, state) do
     if state.dets do
       :dets.sync(state.dets)
       :dets.close(state.dets)
     end
     :ok
   end
 
   defp irc_now_playing(nick_or_user, message, state) do
     nick_or_user = String.strip(nick_or_user)
 
     id_or_user = if account = Nola.Account.get(nick_or_user) || Nola.Account.find_always_by_nick(message.network, message.channel, nick_or_user) do
       account.id
     else
       nick_or_user
     end
 
     username = case :dets.lookup(state.dets, id_or_user) do
       [{_, username}] -> username
       _ -> id_or_user
     end
 
     case now_playing(username) do
       {:error, text} when is_binary(text) ->
         message.replyfun.(text)
       {:ok, map} when is_map(map) ->
         track = fetch_track(username, map)
         text = format_now_playing(map, track)
         user = if account = Nola.Account.get(id_or_user) do
           user = Nola.UserTrack.find_by_account(message.network, account)
           if(user, do: user.nick, else: account.name)
         else
           username
         end
         if user && text do
           message.replyfun.("#{user} #{text}")
         else
           message.replyfun.("#{username}: pas de résultat")
         end
       other ->
         message.replyfun.("erreur :(")
     end
   end
 
   defp now_playing(user) do
     api = Application.get_env(:nola, :lastfm)[:api_key]
     url = "http://ws.audioscrobbler.com/2.0/?method=user.getrecenttracks&format=json&limit=1&extended=1" <> "&api_key=" <> api <> "&user="<> user
     case HTTPoison.get(url) do
       {:ok, %HTTPoison.Response{status_code: 200, body: body}} -> Jason.decode(body)
       {:ok, %HTTPoison.Response{status_code: 404}} -> {:error, "last.fm: utilisateur \"#{user}\" inexistant"}
       {:ok, %HTTPoison.Response{status_code: code}} -> {:error, "last.fm: erreur #{to_string(code)}"}
       error ->
         Logger.error "Lastfm http error: #{inspect error}"
         :error
     end
   end
   defp fetch_track(user, %{"recenttracks" => %{"track" => [ t = %{"name" => name, "artist" => %{"name" => artist}} | _]}}) do
     api = Application.get_env(:nola, :lastfm)[:api_key]
     url = "http://ws.audioscrobbler.com/2.0/?method=track.getInfo&format=json" <> "&api_key=" <> api <> "&username="<> user <> "&artist="<>URI.encode(artist)<>"&track="<>URI.encode(name)
     case HTTPoison.get(url) do
       {:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
         case Jason.decode(body) do
           {:ok, body} -> body["track"] || %{}
           _ -> %{}
         end
       error ->
         Logger.error "Lastfm http error: #{inspect error}"
         :error
     end
   end
 
   defp format_now_playing(%{"recenttracks" => %{"track" => [track = %{"@attr" => %{"nowplaying" => "true"}} | _]}}, et) do
     format_track(true, track, et)
   end
 
   defp format_now_playing(%{"recenttracks" => %{"track" => [track | _]}}, et) do
     format_track(false, track, et)
   end
 
   defp format_now_playing(%{"error" => err, "message" => message}, _) do
     "last.fm error #{err}: #{message}"
   end
 
   defp format_now_playing(miss) do
     nil
   end
 
   defp format_track(np, track, extended) do
     artist = track["artist"]["name"]
     album = if track["album"]["#text"], do: " (" <> track["album"]["#text"] <> ")", else: ""
     name = track["name"] <> album
     action = if np, do: "écoute ", else: "a écouté"
     love = if track["loved"] != "0", do: "❤️"
     count = if x = extended["userplaycount"], do: "x#{x} #{love}"
     tags = (get_in(extended, ["toptags", "tag"]) || [])
     |> Enum.map(fn(tag) -> tag["name"] end)
     |> Enum.filter(& &1)
     |> Enum.join(", ")
 
     [action, artist, name, count, tags, track["url"]]
     |> Enum.filter(& &1)
     |> Enum.map(&String.trim(&1))
     |> Enum.join(" - ")
   end
 
 end
diff --git a/lib/plugins/link/youtube.ex b/lib/plugins/link/youtube.ex
index 1b14221..0114940 100644
--- a/lib/plugins/link/youtube.ex
+++ b/lib/plugins/link/youtube.ex
@@ -1,72 +1,72 @@
 defmodule Nola.Plugins.Link.YouTube do
   @behaviour Nola.Plugins.Link
 
   @moduledoc """
   # YouTube link preview
 
   needs an API key:
 
   ```
   config :nola, :youtube,
     api_key: "xxxxxxxxxxxxx"
   ```
 
   options:
 
   * `invidious`: Add a link to invidious.
   """
 
   @impl true
   def match(uri = %URI{host: yt, path: "/watch", query: "v="<>video_id}, _opts) when yt in ["youtube.com", "www.youtube.com"] do
     {true, %{video_id: video_id}}
   end
 
   def match(%URI{host: "youtu.be", path: "/"<>video_id}, _opts) do
     {true, %{video_id: video_id}}
   end
 
   def match(_, _), do: false
 
   @impl true
   def post_match(_, _, _, _), do: false
 
   @impl true
-  def expand(uri, %{video_id: video_id}, opts) do
+  def expand(_uri, %{video_id: video_id}, opts) do
     key = Application.get_env(:nola, :youtube)[:api_key]
     params = %{
       "part" => "snippet,contentDetails,statistics",
       "id" => video_id,
       "key" => key
     }
     headers = []
     options = [params: params]
     case HTTPoison.get("https://www.googleapis.com/youtube/v3/videos", [], options) do
       {:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
         case Jason.decode(body) do
           {:ok, json} ->
             item = List.first(json["items"])
             if item do
               snippet = item["snippet"]
               duration = item["contentDetails"]["duration"] |> String.replace("PT", "") |> String.downcase
               date = snippet["publishedAt"]
                      |> DateTime.from_iso8601()
                      |> elem(1)
                      |> Timex.format("{relative}", :relative)
                      |> elem(1)
 
               line = if host = Keyword.get(opts, :invidious) do
                 ["-> https://#{host}/watch?v=#{video_id}"]
               else
                   []
               end
               {:ok, line ++ ["#{snippet["title"]}", "— #{duration} — uploaded by #{snippet["channelTitle"]} — #{date}"
                      <> " — #{item["statistics"]["viewCount"]} views, #{item["statistics"]["likeCount"]} likes"]}
             else
               :error
             end
           _ -> :error
         end
     end
   end
 
 end
diff --git a/lib/telegram.ex b/lib/telegram.ex
index f2c9eca..b161b63 100644
--- a/lib/telegram.ex
+++ b/lib/telegram.ex
@@ -1,233 +1,236 @@
 defmodule Nola.Telegram do
   require Logger
   @behaviour Telegram.ChatBot
 
   def my_path() do
     "https://t.me/beauttebot"
   end
 
   def send_message(id, text, md2 \\ false) do
     md = if md2, do: "MarkdownV2", else: "Markdown"
     token = Keyword.get(Application.get_env(:nola, :telegram, []), :key)
     Telegram.Bot.ChatBot.Chat.Session.Supervisor.start_child(Nola.Telegram, id)
     Telegram.Api.request(token, "sendMessage", chat_id: id, text: text, parse_mode: "Markdown")
   end
 
   @impl Telegram.ChatBot
   def init(chat_id) when chat_id < 0 do
-    {:ok, state} = Nola.TelegramRoom.init(chat_id)
-    {:ok, %{room_state: state}}
+    case Nola.TelegramRoom.init(chat_id) do
+      {:ok, state} -> {:ok, %{room_state: state}}
+      _ -> :ignore
+    end
   end
+
   def init(chat_id) do
     Logger.info("Telegram session starting: #{chat_id}")
     account = Nola.Account.find_meta_account("telegram-id", chat_id)
     account_id = if account, do: account.id
     {:ok, %{account: account_id}}
   end
 
   @impl Telegram.ChatBot
   def handle_update(update, token, %{room_state: room_state}) do
     {:ok, room_state} = Nola.TelegramRoom.handle_update(update, token, room_state)
     {:ok, %{room_state: room_state}}
   end
 
   def handle_update(%{"message" => m = %{"chat" => %{"type" => "private"}, "text" => text = "/start"<>_}}, _token, state) do
     text = "*Welcome to beautte!*\n\nQuery the bot on IRC and say \"enable-telegram\" to continue."
     send_message(m["chat"]["id"], text)
     {:ok, %{account: nil}}
   end
 
   def handle_update(%{"message" => m = %{"chat" => %{"type" => "private"}, "text" => text = "/enable"<>_}}, _token, state) do
     key = case String.split(text, " ") do
       ["/enable", key | _] -> key
       _ -> "nil"
     end
 
     #Handled message "1247435154:AAGnSSCnySn0RuVxy_SUcDEoOX_rbF6vdq0" %{"message" =>
     #  %{"chat" => %{"first_name" => "J", "id" => 2075406, "type" => "private", "username" => "ahref"},
     #    "date" => 1591027272, "entities" =>
     #    [%{"length" => 7, "offset" => 0, "type" => "bot_command"}],
     #    "from" => %{"first_name" => "J", "id" => 2075406, "is_bot" => false, "language_code" => "en", "username" => "ahref"},
     #    "message_id" => 11, "text" => "/enable salope"}, "update_id" => 764148578}
     account = Nola.Account.find_meta_account("telegram-validation-code", String.downcase(key))
     text = if account do
       net = Nola.Account.get_meta(account, "telegram-validation-target")
       Nola.Account.put_meta(account, "telegram-id", m["chat"]["id"])
       Nola.Account.put_meta(account, "telegram-username", m["chat"]["username"])
       Nola.Account.put_meta(account, "telegram-username", m["chat"]["username"])
       Nola.Account.delete_meta(account, "telegram-validation-code")
       Nola.Account.delete_meta(account, "telegram-validation-target")
       Nola.Irc.Connection.broadcast_message(net, account, "Telegram #{m["chat"]["username"]} account added!")
       "Yay! Linked to account **#{account.name}**."
     else
       "Token invalid"
     end
     send_message(m["chat"]["id"], text)
     {:ok, %{account: account.id}}
   end
 
   #[debug] Unhandled update: %{"message" =>
   #  %{"chat" => %{"first_name" => "J", "id" => 2075406, "type" => "private", "username" => "ahref"},
   #    "date" => 1591096015,
   #    "from" => %{"first_name" => "J", "id" => 2075406, "is_bot" => false, "language_code" => "en", "username" => "ahref"},
   #    "message_id" => 29,
   #    "photo" => [
   #      %{"file_id" => "AgACAgQAAxkBAAMdXtYyz4RQqLcpOlR6xKK3w3NayHAAAnCzMRuL4bFSgl_cTXMl4m5G_T0kXQADAQADAgADbQADZVMBAAEaBA",
   #        "file_size" => 9544, "file_unique_id" => "AQADRv09JF0AA2VTAQAB", "height" => 95, "width" => 320},
   #      %{"file_id" => "AgACAgQAAxkBAAMdXtYyz4RQqLcpOlR6xKK3w3NayHAAAnCzMRuL4bFSgl_cTXMl4m5G_T0kXQADAQADAgADeAADZFMBAAEaBA",
   #        "file_size" => 21420, "file_unique_id" => "AQADRv09JF0AA2RTAQAB", "height" => 148, "width" => 501}]},
   #  "update_id" => 218161546}
 
   for type <- ~w(photo voice video document animation) do
     def handle_update(data = %{"message" => %{unquote(type) => _}}, token, state) do
       start_upload(unquote(type), data, token, state)
     end
   end
 
   #[debug] Unhandled update: %{"callback_query" =>
   #  %{
   #    "chat_instance" => "-7948978714441865930", "data" => "evolu.net/#dmz",
   #      "from" => %{"first_name" => "J", "id" => 2075406, "is_bot" => false, "language_code" => "en", "username" => "ahref"},
   #      "id" => "8913804780149600",
   #       "message" => %{"chat" => %{"first_name" => "J", "id" => 2075406, "type" => "private", "username" => "ahref"},
   #                    "date" => 1591098553, "from" => %{"first_name" => "devbeautte", "id" => 1293058838, "is_bot" => true, "username" => "devbeauttebot"},
   #                    "message_id" => 62,
   #                    "reply_markup" => %{"inline_keyboard" => [[%{"callback_data" => "random/#", "text" => "random/#"},
   #                          %{"callback_data" => "evolu.net/#dmz", "text" => "evolu.net/#dmz"}]]},
   #                    "text" => "Where should I send the file?"}
   #   }
   #  , "update_id" => 218161568}
 
   #def handle_update(t, %{"callback_query" => cb = %{"data" => "resend", "id" => id, "message" => m = %{"message_id" => m_id, "chat" => %{"id" => chat_id}, "reply_to_message" => op}}}) do
   #end
 
   def handle_update(%{"callback_query" => cb = %{"data" => "start-upload:"<>target, "id" => id, "message" => m = %{"message_id" => m_id, "chat" => %{"id" => chat_id}, "reply_to_message" => op}}}, t, state) do
     account = Nola.Account.find_meta_account("telegram-id", chat_id)
     if account do
       target = case String.split(target, "/") do
         ["everywhere"] -> Nola.Membership.of_account(account)
         [net, chan] -> [{net, chan}]
       end
         Telegram.Api.request(t, "editMessageText", chat_id: chat_id, message_id: m_id, text: "Processing...", reply_markup: %{})
 
       {content, type} = cond do
         op["photo"] -> {op["photo"], ""}
         op["voice"] -> {op["voice"], " a voice message"}
         op["video"] -> {op["video"], ""}
         op["document"] -> {op["document"], ""}
         op["animation"] -> {op["animation"], ""}
       end
 
       file = if is_list(content) && Enum.count(content) > 1 do
         Enum.sort_by(content, fn(p) -> p["file_size"] end, &>=/2)
         |> List.first()
       else
         content
       end
       file_id = file["file_id"]
       file_unique_id = file["file_unique_id"]
         text = if(op["caption"], do: ": "<> op["caption"] <> "", else: "")
         resend = %{"inline_keyboard" => [ [%{"text" => "re-share", "callback_data" => "resend"}] ]}
       spawn(fn() ->
         with \
           {:ok, file} <- Telegram.Api.request(t, "getFile", file_id: file_id),
           path = "https://api.telegram.org/file/bot#{t}/#{file["file_path"]}",
           {:ok, %HTTPoison.Response{status_code: 200, body: body}} <- HTTPoison.get(path),
           <<smol_body::binary-size(20), _::binary>> = body,
           {:ok, magic} <- GenMagic.Pool.perform(Nola.GenMagic, {:bytes, smol_body}),
           bucket = Application.get_env(:nola, :s3, []) |> Keyword.get(:bucket),
           ext = Path.extname(file["file_path"]),
           s3path = "#{account.id}/#{file_unique_id}#{ext}",
           Telegram.Api.request(t, "editMessageText", chat_id: chat_id, message_id: m_id, text: "*Uploading...*", reply_markup: %{}, parse_mode: "MarkdownV2"),
           s3req = ExAws.S3.put_object(bucket, s3path, body, acl: :public_read, content_type: magic.mime_type),
           {:ok, _} <- ExAws.request(s3req)
         do
           path = NolaWeb.Router.Helpers.url(NolaWeb.Endpoint) <> "/files/#{s3path}"
           sent = for {net, chan} <- target do
             txt = "sent#{type}#{text} #{path}"
             Nola.Irc.send_message_as(account, net, chan, txt)
             "#{net}/#{chan}"
           end
           if caption = op["caption"], do: as_irc_message(chat_id, caption, account)
           text = "Sent on " <> Enum.join(sent, ", ") <> " !"
           Telegram.Api.request(t, "editMessageText", chat_id: chat_id, message_id: m_id, text: "_Sent!_", reply_markup: %{}, parse_mode: "MarkdownV2")
         else
           error ->
             Telegram.Api.request(t, "editMessageText", chat_id: chat_id, message_id: m_id, text: "Something failed.", reply_markup: %{}, parse_mode: "MarkdownV2")
             Logger.error("Failed upload from Telegram: #{inspect error}")
         end
       end)
     end
     {:ok, state}
   end
 
   def handle_update(%{"message" => m = %{"chat" => %{"id" => id, "type" => "private"}, "text" => text}}, _, state) do
     account = Nola.Account.find_meta_account("telegram-id", id)
     if account do
       as_irc_message(id, text, account)
     end
     {:ok, state}
   end
 
   def handle_update(m, _, state) do
     Logger.debug("Unhandled update: #{inspect m}")
     {:ok, state}
   end
 
   @impl Telegram.ChatBot
   def handle_info(info, %{room_state: room_state}) do
     {:ok, room_state} = Nola.TelegramRoom.handle_info(info, room_state)
     {:ok, %{room_state: room_state}}
   end
 
   def handle_info(_info, state) do
     {:ok, state}
   end
 
   defp as_irc_message(id, text, account) do
     reply_fun = fn(text) -> send_message(id, text) end
     trigger_text = cond do
       String.starts_with?(text, "/") ->
         "/"<>text = text
         "!"<>text
       Enum.any?(Nola.Irc.Connection.triggers(), fn({trigger, _}) -> String.starts_with?(text, trigger) end) ->
         text
       true ->
         "!"<>text
     end
       message = %Nola.Message{
         id: FlakeId.get(),
         transport: :telegram,
       network: "telegram",
       channel: nil,
       text: text,
       account: account,
       sender: %ExIRC.SenderInfo{nick: account.name},
       replyfun: reply_fun,
         trigger: Nola.Irc.Connection.extract_trigger(trigger_text),
         at: nil
     }
     Nola.Irc.Connection.publish(message, ["messages:private", "messages:telegram", "telegram/#{account.id}:messages"])
     message
   end
 
   defp start_upload(_type, %{"message" => m = %{"chat" => %{"id" => id, "type" => "private"}}}, token, state) do
     account = Nola.Account.find_meta_account("telegram-id", id)
     if account do
       text = if(m["text"], do: m["text"], else: nil)
       targets = Nola.Membership.of_account(account)
       |> Enum.map(fn({net, chan}) -> "#{net}/#{chan}" end)
       |> Enum.map(fn(i) -> %{"text" => i, "callback_data" => "start-upload:#{i}"} end)
       kb = if Enum.count(targets) > 1 do
         [%{"text" => "everywhere", "callback_data" => "start-upload:everywhere"}] ++ targets
       else
         targets
       end
       |> Enum.chunk_every(2)
       keyboard = %{"inline_keyboard" => kb}
       Telegram.Api.request(token, "sendMessage", chat_id: id, text: "Where should I send this file?", reply_markup: keyboard, reply_to_message_id: m["message_id"], parse_mode: "MarkdownV2")
     end
     {:ok, state}
   end
 
 end
diff --git a/lib/telegram/room.ex b/lib/telegram/room.ex
index ede939e..7a8f427 100644
--- a/lib/telegram/room.ex
+++ b/lib/telegram/room.ex
@@ -1,188 +1,194 @@
 defmodule Nola.TelegramRoom do
   require Logger
   @behaviour Telegram.ChatBot
   alias Telegram.Api
 
   @couch "bot-telegram-rooms"
 
   def rooms(), do: rooms(:with_docs)
 
   @spec rooms(:with_docs | :ids) :: [Map.t | integer( )]
   def rooms(:with_docs) do
     case Couch.get(@couch, :all_docs, include_docs: true) do
       {:ok, %{"rows" => rows}} -> {:ok, for(%{"doc" => doc} <- rows, do: doc)}
       error = {:error, _} -> error
     end
   end
 
   def rooms(:ids) do
     case Couch.get(@couch, :all_docs) do
       {:ok, %{"rows" => rows}} -> {:ok, for(%{"id" => id} <- rows, do: id)}
       error = {:error, _} -> error
     end
   end
 
   def room(id, opts \\ []) do
     Couch.get(@couch, id, opts)
   end
 
   # TODO: Create couch
   def setup() do
     :ok
   end
 
   def after_start() do
-    for id <- room(:ids), do: Telegram.Bot.ChatBot.Chat.Session.Supervisor.start_child(Nola.Telegram, Integer.parse(id) |> elem(0))
+    {:ok, rooms} = rooms(:ids)
+    for id <- rooms do
+      spawn(fn() ->
+        Telegram.Bot.ChatBot.Chat.Session.Supervisor.start_child(Nola.Telegram, Integer.parse(id) |> elem(0))
+      end)
+    end
   end
 
   @impl Telegram.ChatBot
   def init(id) when is_integer(id) and id < 0 do
     token = Keyword.get(Application.get_env(:nola, :telegram, []), :key)
     {:ok, chat} = Api.request(token, "getChat", chat_id: id)
     Logger.metadata(transport: :telegram, id: id, telegram_room_id: id)
-    tg_room = case room(id) do
+    tg_room = case room(to_string(id)) do
       {:ok, tg_room = %{"network" => _net, "channel" => _chan}} -> tg_room
-      {:error, :not_found} ->
+      _ ->
         [net, chan] = String.split(chat["title"], "/", parts: 2)
         {net, chan} = case Nola.Irc.Connection.get_network(net, chan) do
           %Nola.Irc.Connection{} -> {net, chan}
           _ -> {nil, nil}
         end
-        {:ok, _id, _rev} = Couch.post(@couch, %{"_id" => id, "network" => net, "channel" => nil})
-        {:ok, tg_room} = room(id)
+        _ = Couch.post(@couch, %{"_id" => id, "network" => net, "channel" => chan})
+        {:ok, tg_room} = room(to_string(id))
         tg_room
     end
     %{"network" => net, "channel" => chan} = tg_room
     Logger.info("Starting ChatBot for room #{id} \"#{chat["title"]}\" #{inspect tg_room}")
     irc_plumbed = if net && chan do
         {:ok, _} = Registry.register(Nola.PubSub, "#{net}/#{chan}:messages", plugin: __MODULE__)
         {:ok, _} = Registry.register(Nola.PubSub, "#{net}/#{chan}:triggers", plugin: __MODULE__)
         {:ok, _} = Registry.register(Nola.PubSub, "#{net}/#{chan}:outputs", plugin: __MODULE__)
         true
     else
       Logger.warn("Did not found telegram match for #{id} \"#{chat["title"]}\"")
       false
     end
     {:ok, %{id: id, net: net, chan: chan, irc: irc_plumbed}}
   end
 
   def init(id) do
     Logger.error("telegram_room: bad id (not room id)", transport: :telegram, id: id, telegram_room_id: id)
-    :ignoree
+    :ignore
   end
 
   defp find_or_create_meta_account(from = %{"id" => user_id}, state) do
     if account = Nola.Account.find_meta_account("telegram-id", user_id) do
       account
     else
       first_name = Map.get(from, "first_name")
       last_name = Map.get(from, "last_name")
       name = [first_name, last_name]
       |> Enum.filter(& &1)
       |> Enum.join(" ")
 
       username = Map.get(from, "username", first_name)
 
       account = username
       |> Nola.Account.new_account()
       |> Nola.Account.update_account_name(name)
-      |> Nola.Account.put_meta("telegram-id", user_id)
+
+      Nola.Account.put_meta(account, "telegram-id", user_id)
 
       Logger.info("telegram_room: created account #{account.id} for telegram user #{user_id}")
       account
     end
   end
 
   def handle_update(%{"message" => %{"from" => from = %{"id" => user_id}, "text" => text}}, _token, state) do
     account = find_or_create_meta_account(from, state)
-    connection = Nola.Irc.Connection.get_network(state.net)
+    #connection = Nola.Irc.Connection.get_network(state.net)
     Nola.Irc.send_message_as(account, state.net, state.chan, text, true)
     {:ok, state}
   end
 
   def handle_update(data = %{"message" => %{"from" => from = %{"id" => user_id}, "location" => %{"latitude" => lat, "longitude" => lon}}}, _token, state) do
     account = find_or_create_meta_account(from, state)
-    connection = Nola.Irc.Connection.get_network(state.net)
+    #connection = Nola.Irc.Connection.get_network(state.net)
     Nola.Irc.send_message_as(account, state.net, state.chan, "@ #{lat}, #{lon}", true)
     {:ok, state}
   end
 
   for type <- ~w(photo voice video document animation) do
     def handle_update(data = %{"message" => %{unquote(type) => _}}, token, state) do
       upload(unquote(type), data, token, state)
     end
   end
 
   def handle_update(update, token, state) do
     {:ok, state}
   end
 
   def handle_info({:irc, _, _, message}, state) do
     handle_info({:irc, nil, message}, state)
   end
 
   def handle_info({:irc, _, message = %Nola.Message{sender: %{nick: nick}, text: text}}, state) do
     if Map.get(message.meta, :from) == self() do
     else
       body = if Map.get(message.meta, :self), do: text, else: "<#{nick}> #{text}"
       Nola.Telegram.send_message(state.id, body)
     end
     {:ok, state}
   end
 
   def handle_info(info, state) do
     Logger.info("UNhandled #{inspect info}")
     {:ok, state}
   end
 
   defp upload(_type, %{"message" => m = %{"chat" => %{"id" => chat_id}, "from" => from = %{"id" => user_id}}}, token, state) do
     account = find_or_create_meta_account(from, state)
     if account do
       {content, type} = cond do
         m["photo"] -> {m["photo"], "photo"}
         m["voice"] -> {m["voice"], "voice message"}
         m["video"] -> {m["video"], "video"}
         m["document"] -> {m["document"], "file"}
         m["animation"] -> {m["animation"], "gif"}
       end
 
       file = if is_list(content) && Enum.count(content) > 1 do
         Enum.sort_by(content, fn(p) -> p["file_size"] end, &>=/2)
         |> List.first()
       else
         content
       end
 
       file_id = file["file_id"]
       file_unique_id = file["file_unique_id"]
       text = if(m["caption"], do: m["caption"] <> " ", else: "")
 
       spawn(fn() ->
         with \
           {:ok, file} <- Telegram.Api.request(token, "getFile", file_id: file_id),
           path = "https://api.telegram.org/file/bot#{token}/#{file["file_path"]}",
           {:ok, %HTTPoison.Response{status_code: 200, body: body}} <- HTTPoison.get(path),
           <<smol_body::binary-size(20), _::binary>> = body,
           {:ok, magic} <- GenMagic.Pool.perform(Nola.GenMagic, {:bytes, smol_body}),
           bucket = Application.get_env(:nola, :s3, []) |> Keyword.get(:bucket),
           ext = Path.extname(file["file_path"]),
           s3path = "#{account.id}/#{file_unique_id}#{ext}",
           s3req = ExAws.S3.put_object(bucket, s3path, body, acl: :public_read, content_type: magic.mime_type),
           {:ok, _} <- ExAws.request(s3req)
         do
           path = NolaWeb.Router.Helpers.url(NolaWeb.Endpoint) <> "/files/#{s3path}"
           txt = "#{type}: #{text}#{path}"
-          connection = Nola.Irc.Connection.get_network(state.net)
+          #connection = Nola.Irc.Connection.get_network(state.net)
           Nola.Irc.send_message_as(account, state.net, state.chan, txt, true)
         else
           error ->
             Telegram.Api.request(token, "sendMessage", chat_id: chat_id, text: "File upload failed, sorry.")
             Logger.error("Failed upload from Telegram: #{inspect error}")
         end
       end)
 
       {:ok, state}
     end
   end
 
 end
diff --git a/lib/web.ex b/lib/web.ex
index 906e961..c1720a0 100644
--- a/lib/web.ex
+++ b/lib/web.ex
@@ -1,99 +1,99 @@
 defmodule NolaWeb do
   @moduledoc """
   The entrypoint for defining your web interface, such
   as controllers, views, channels and so on.
 
   This can be used in your application as:
 
       use NolaWeb, :controller
       use NolaWeb, :view
 
   The definitions below will be executed for every view,
   controller, etc, so keep them short and clean, focused
   on imports, uses and aliases.
 
   Do NOT define functions inside the quoted expressions
   below. Instead, define any helper function in modules
   and import those modules here.
   """
 
   def format_chan("##") do
     "♯♯"
   end
 
   def format_chan("#") do
     "♯"
   end
 
   def format_chan("#"<>chan) do
     chan
   end
 
   def format_chan(chan = "!"<>_), do: chan
 
   def reformat_chan("♯") do
     "#"
   end
   def reformat_chan("♯♯") do
     "##"
   end
   def reformat_chan(chan = "!"<>_), do: chan
 
   def reformat_chan(chan) do
     "#"<>chan
   end
 
   def controller do
     quote do
       use Phoenix.Controller, namespace: NolaWeb
       import Plug.Conn
       import NolaWeb.Router.Helpers
       import NolaWeb.Gettext
       alias NolaWeb.Router.Helpers, as: Routes
     end
   end
 
   def view do
     quote do
-      use Phoenix.View, root: "lib/nola_web/templates",
+      use Phoenix.View, root: "lib/web/templates",
                         namespace: NolaWeb
 
       # Import convenience functions from controllers
       import Phoenix.Controller, only: [get_flash: 2, view_module: 1]
 
       # Use all HTML functionality (forms, tags, etc)
       use Phoenix.HTML
 
       import NolaWeb.Router.Helpers
       import NolaWeb.ErrorHelpers
       import NolaWeb.Gettext
 
       import Phoenix.LiveView.Helpers
 
       alias NolaWeb.Router.Helpers, as: Routes
     end
   end
 
   def router do
     quote do
       use Phoenix.Router
       import Plug.Conn
       import Phoenix.Controller
       import Phoenix.LiveView.Router
     end
   end
 
   def channel do
     quote do
       use Phoenix.Channel
       import NolaWeb.Gettext
     end
   end
 
   @doc """
   When used, dispatch to the appropriate controller/view/etc.
   """
   defmacro __using__(which) when is_atom(which) do
     apply(__MODULE__, which, [])
   end
 end
diff --git a/lib/web/views/layout_view.ex b/lib/web/views/layout_view.ex
index 2bffc6f..663eccf 100644
--- a/lib/web/views/layout_view.ex
+++ b/lib/web/views/layout_view.ex
@@ -1,81 +1,81 @@
 defmodule NolaWeb.LayoutView do
   use NolaWeb, :view
 
   def liquid_markdown(conn, text) do
     context_path = cond do
       conn.assigns[:chan] -> "/#{conn.assigns[:network]}/#{NolaWeb.format_chan(conn.assigns[:chan])}"
       conn.assigns[:network] -> "/#{conn.assigns[:network]}/-"
       true -> "/-"
     end
 
     {:ok, ast} = Liquex.parse(text)
     context = Liquex.Context.new(%{
       "context_path" => context_path
     })
     {content, _} = Liquex.render(ast, context)
     content
     |> to_string()
     |> Earmark.as_html!()
     |> raw()
   end
 
   def page_title(conn) do
     target = cond do
       conn.assigns[:chan] ->
         "#{conn.assigns.chan} @ #{conn.assigns.network}"
       conn.assigns[:network] -> conn.assigns.network
-      true -> Keyword.get(Nola.name())
+      true -> Nola.name()
     end
 
     breadcrumb_title = Enum.map(Map.get(conn.assigns, :breadcrumbs)||[], fn({title, _href}) -> title end)
 
     title = [conn.assigns[:title], breadcrumb_title, target]
     |> List.flatten()
     |> Enum.uniq()
     |> Enum.filter(fn(x) -> x end)
     |> Enum.intersperse(" / ")
     |> Enum.join()
 
     content_tag(:title, title)
   end
 
   def format_time(date, with_relative \\ true) do
     alias Timex.Format.DateTime.Formatters
     alias Timex.Timezone
     date = if is_integer(date) do
       date
       |> DateTime.from_unix!(:millisecond)
       |> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)
     else
       date
       |> DateTime.shift_zone!("Europe/Paris", Tzdata.TimeZoneDatabase)
     end
 
     now = DateTime.now!("Europe/Paris", Tzdata.TimeZoneDatabase)
 
     now_week = Timex.iso_week(now)
     date_week = Timex.iso_week(date)
 
     {y, w} = now_week
     now_last_week = {y, w-1}
     now_last_roll = 7-Timex.days_to_beginning_of_week(now)
 
     date_date = DateTime.to_date(date)
     now_date = DateTime.to_date(date)
 
     format = cond do
       date.year != now.year -> "{D}/{M}/{YYYY} {h24}:{m}"
       date_date == now_date -> "{h24}:{m}"
       (now_week == date_week) || (date_week == now_last_week && (Date.day_of_week(date) >= now_last_roll)) -> "{WDfull} {h24}:{m}"
       (now.year == date.year && now.month == date.month) -> "{WDfull} {D} {h24}:{m}"
       true -> "{WDfull} {D} {M} {h24}:{m}"
     end
 
     {:ok, relative} = Formatters.Relative.relative_to(date, Timex.now("Europe/Paris"), "{relative}", "fr")
     {:ok, full} = Formatters.Default.lformat(date, "{WDfull} {D} {YYYY} {h24}:{m}", "fr") #"{h24}:{m} {WDfull} {D}", "fr")
     {:ok, detail} = Formatters.Default.lformat(date, format, "fr") #"{h24}:{m} {WDfull} {D}", "fr")
 
     content_tag(:time, if(with_relative, do: relative, else: detail), [title: full])
   end
 
 end