client_secret: System.get_env("GITHUB_CLIENT_SECRET") || "dev-client-secret",

  redirect_uri: "http://localhost:4000/auth/github/callback"

# Overridable like the OAuth pair above: a real local GitHub app issues real

# tokens, and encrypting them under a key checked into the repository would

# make the vault decorative.

config :openagents,

       :github_token_encryption_key,

       Base.encode64("openagents-dev-token-vault-key32")

       System.get_env("GITHUB_TOKEN_ENCRYPTION_KEY") ||

         Base.encode64("openagents-dev-token-vault-key32")

config :openagents, :github_token_encryption_key_id, "development-2026-08"

config :openagents, :github_token_decryption_keys, %{}

    %{

      title: "Landing",

      items: [

        %{

          slug: "sidebar-footer",

          title: "Sidebar footer",

          icon: "stack",

          source: "OpenAgentsWeb.Layouts.sidebar_footer/1",

          summary: "Secondary destinations, gated by environment and role."

        },

        %{

          slug: "landing-section",

          title: "Section",

  slot :inner_block, required: true

  slot :title_menu,

    doc: """

    Actions belonging to this page, rendered beside its name in the command

    bar. Nested, never passed as an attribute: forwarding a slot as an attr

    compiles and renders but loses change tracking.

    """

  slot :sidebar_extra,

    doc: """

    Rows this page contributes to the application sidebar.

      </.sidebar>

      <div class="flex-1 min-w-0 flex flex-col h-screen">

        <.openagents_command_bar current_scope={@current_scope} title={@title} subtitle={@subtitle} />

        <.openagents_command_bar current_scope={@current_scope} title={@title} subtitle={@subtitle}>

          <:menu>{render_slot(@title_menu)}</:menu>

        </.openagents_command_bar>

        <main class={[

          "flex-1 min-w-0",

  attr :current_scope, :map, default: nil

  attr :title, :string, default: nil

  attr :subtitle, :string, default: nil

  slot :menu, doc: "actions belonging to the current page"

  defp openagents_command_bar(assigns) do

    ~H"""

              <p class="text-xs text-muted-foreground truncate">{@subtitle}</p>

            <% end %>

          </div>

          {render_slot(@menu)}

        <% end %>

      </div>

          <.account_dropdown current_scope={@current_scope} />

        <% else %>

          <.button navigate={~p"/#github-tools"} variant={:primary} size={:sm}>

            Sign in with GitHub

            <UI.icon name="brand-github" /> Log in with GitHub

          </.button>

        <% end %>

      </div>

  The component library is advertised outside production only. It documents

  the parts a page is built from rather than anything a visitor came for.

  """

  attr :current_user, :map, default: nil, doc: "used only to decide whether admin shows"

  def sidebar_footer(assigns) do

    assigns =

      assign(assigns, :components_link?, OpenAgents.RuntimeConfig.internal_surfaces_visible?())

      assigns

      |> assign(:components_link?, OpenAgents.RuntimeConfig.internal_surfaces_visible?())

      |> assign(:admin_link?, admin?(assigns[:current_user]))

    ~H"""

    <footer class="sidebar-footer">

      <.link

        :if={@admin_link?}

        id="open-admin"

        navigate={~p"/admin"}

        class="sidebar-footer__link"

        aria-label="Admin"

      >

        <UI.icon name="shield-lock" /> Admin

      </.link>

      <.link :if={@components_link?} navigate={~p"/components"} class="sidebar-footer__link">

        <UI.icon name="widget" /> Components

      </.link>

          icon="folder"

          patchable={false}

        />

        <Layouts.sidebar_link

          path={~p"/computers"}

          label="Computers"

          icon="desktop"

          patchable={false}

        />

        <%!-- Memory is the conversation's, but reaching it should not require

        knowing that: the row goes to chat with the panel open, which is where

        it lives. --%>

        <Layouts.sidebar_link

          path={~p"/chat?panel=memory"}

          label="Memory"

          icon="brain"

          patchable={false}

        />

        <Layouts.sidebar_link

          path={~p"/leaderboard"}

          label="Leaderboard"

          icon="trophy-top"

          patchable={false}

        />

      </nav>

      <%!-- Rows the current page contributes. Chat's destinations, work

      projections and admin actions arrive here instead of in a second rail. --%>

      {render_slot(@extra)}

      <Layouts.sidebar_footer />

      <Layouts.sidebar_footer current_user={@current_scope} />

    </aside>

    """

  end

  # A nil scope is not an operator. The footer renders on public pages too.

  defp admin?(nil), do: false

  defp admin?(user), do: OpenAgents.Accounts.admin?(user)

  defp account_display_name(%{github_name: name}) when is_binary(name) and name != "", do: name

  defp account_display_name(%{github_login: login}), do: "@" <> login

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash}>

    <Layouts.app flash={@flash} current_scope={@current_scope}>

      <main id="admin-forge-page" class="app-shell admin-shell">

        <section class="admin" aria-label="Forge deploy lane">

          <h1>Forge — {@repo}</h1>

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash}>

    <Layouts.app flash={@flash} current_scope={@current_scope}>

      <main id="admin-page" class="app-shell admin-shell">

        <%!-- The same bar every other surface renders, so moving between them

              reads as one application. The lockup carries only the way back:

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash}>

    <Layouts.app flash={@flash} current_scope={@current_scope}>

      <main id="admin-scv-accounts-page" class="app-shell admin-shell">

        <Layouts.command_bar aria_label="SCV Codex account settings" current_user={@current_user}>

          <:lockup>

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash}>

    <Layouts.app flash={@flash} current_scope={@current_scope}>

      <main id="changelog-page" class="app-shell changelog-shell">

        <Layouts.command_bar aria_label="OpenAgents changelog" current_user={@current_user}>

          <:lockup>

  use OpenAgentsWeb, :live_view

  alias OpenAgents.{

    Accounts,

    Conversations,

    DataRights,

    ProfileMemory,

  alias OpenAgents.Voice.Recordings

  alias OpenAgents.Work

  alias OpenAgentsWeb.ToolActivity

  alias OpenAgentsWeb.UI

  # The sidebar's calls and work sections are bounded projections, not

  # unbounded lists: the last eight of each, recomputed on the same PubSub

    {:ok, socket}

  end

  @impl true

  def handle_params(params, _uri, socket) do

    # The sidebar's Memory row is a link, not a chat-local event: it must work

    # from any page, so the panel's state is addressable rather than private.

    # Arriving by URL has to load what arriving by click loads -- a panel that

    # opens empty depending on how you reached it is worse than no panel.

    {:noreply, open_memory(socket, params["panel"] == "memory")}

  end

  defp open_memory(socket, true) do

    socket

    |> assign(:memory_open?, true)

    |> assign(:pending_memory_action, nil)

    |> assign(:memory_status, nil)

    |> reload_memory()

  end

  defp open_memory(socket, false) do

    # Closing restores the conversation, which means reloading it: the panel

    # replaces the transcript rather than covering it, so coming back has to

    # put the messages back whether you left by URL or by control.

    {messages, has_older?} = Conversations.list_messages(socket.assigns.conversation)

    socket

    |> assign(:memory_open?, false)

    |> assign(:pending_memory_action, nil)

    |> assign(:memory_status, nil)

    |> assign(:has_older?, has_older?)

    |> assign(:oldest_message_id, first_id(messages))

    |> stream(:messages, messages, reset: true)

  end

  @impl true

  def handle_event("send_message", %{"chat" => %{"message" => content}}, socket) do

    case voice_route(socket) do

  def handle_event("toggle_memory", _params, socket) do

    if socket.assigns.memory_open? do

      {messages, has_older?} = Conversations.list_messages(socket.assigns.conversation)

      {:noreply,

       socket

       |> assign(:memory_open?, false)

       |> assign(:pending_memory_action, nil)

       |> assign(:memory_status, nil)

       |> assign(:has_older?, has_older?)

       |> assign(:oldest_message_id, first_id(messages))

       |> stream(:messages, messages, reset: true)

       |> push_event("composer:focus", %{})}

      {:noreply, socket |> open_memory(false) |> push_event("composer:focus", %{})}

    else

      {:noreply,

       socket

       |> assign(:memory_open?, true)

       |> assign(:pending_memory_action, nil)

       |> assign(:memory_status, nil)

       |> reload_memory()}

      {:noreply, open_memory(socket, true)}

    end

  end

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} title="Chat" current_scope={@current_scope} flush>

      <%!-- Export is the conversation's action, so it belongs beside the

      conversation's name rather than as a permanent sidebar row competing with

      the places you can go. --%>

      <:title_menu>

        <.button

          id="chat-actions-trigger"

          variant={:ghost}

          size={:sm}

          class="chat-actions-trigger"

          popovertarget="chat-actions-menu"

          popovertargetaction="toggle"

          aria-label="Conversation actions"

        >

          <.icon name="chevron-down" />

        </.button>

        <UI.menu id="chat-actions-menu" label="Conversation actions">

          <a id="export-atif" href="/data/export/atif" download role="menuitem" class="menu__item">

            <.icon name="download" /> Export JSON (ATIF)

          </a>

        </UI.menu>

      </:title_menu>

      <:sidebar_extra>

        <.chat_sidebar_rows

          current_user={@current_user}

  # any future trailing control floats back above it at its own z-index.

  defp chat_sidebar_rows(assigns) do

    ~H"""

    <nav id="sidebar-nav" class="sidebar-nav" aria-label="Chat">

      <div class="sidebar-row">

        <.link

          id="open-computers"

          navigate="/computers"

          class="sidebar-row__hit"

          aria-label="Computers"

        ></.link>

        <span class="sidebar-row__content">

          <span class="sidebar-row__icon"><.icon name="desktop" /></span>

          <span class="sidebar-row__label">Computers</span>

        </span>

      </div>

      <div class="sidebar-row" data-selected={@memory_open?}>

        <button

          id="toggle-memory"

          type="button"

          class="sidebar-row__hit"

          phx-click="toggle_memory"

          aria-expanded={to_string(@memory_open?)}

          aria-controls="memory-manager"

          aria-label={if @memory_open?, do: "Return to conversation", else: "Memory"}

        ></button>

        <span class="sidebar-row__content">

          <span class="sidebar-row__icon">

            <.icon name={if @memory_open?, do: "arrow-left", else: "brain"} />

          </span>

          <span class="sidebar-row__label">

            {if @memory_open?, do: "Return to conversation", else: "Memory"}

          </span>

        </span>

      </div>

      <div class="sidebar-row">

        <.link

          id="open-leaderboard"

          navigate="/leaderboard"

          class="sidebar-row__hit"

          aria-label="Leaderboard"

        ></.link>

        <span class="sidebar-row__content">

          <span class="sidebar-row__icon"><.icon name="trophy-top" /></span>

          <span class="sidebar-row__label">Leaderboard</span>

        </span>

      </div>

      <div class="sidebar-row">

        <.link

          id="export-atif"

          href="/data/export/atif"

          download

          class="sidebar-row__hit"

          aria-label="Export"

        ></.link>

        <span class="sidebar-row__content">

          <span class="sidebar-row__icon"><.icon name="download" /></span>

          <span class="sidebar-row__label">Export</span>

        </span>

      </div>

    </nav>

    <%!-- Calls and work: bounded, durable-backed projections (last eight

            each), refreshed by the same PubSub broadcasts that drive the

            transcript. A row whose evidence is a durable transcript message is

      </section>

    </div>

    <nav

      :if={Accounts.admin?(@current_user) or @reset_enabled?}

      id="sidebar-admin"

      class="sidebar-nav"

      aria-label="Administration and data"

    >

      <div :if={Accounts.admin?(@current_user)} class="sidebar-row">

        <.link id="open-admin" navigate="/admin" class="sidebar-row__hit" aria-label="Admin"></.link>

        <span class="sidebar-row__content">

          <span class="sidebar-row__icon"><.icon name="shield-lock" /></span>

          <span class="sidebar-row__label">Admin</span>

        </span>

      </div>

    <%!-- Admin moved to the sidebar footer, where it is one row for an

    operator on every page rather than a row that only exists on chat. What

    stays here is the conversation's own data action. --%>

    <nav :if={@reset_enabled?} id="sidebar-admin" class="sidebar-nav" aria-label="Data">

      <.form

        :if={@reset_enabled?}

        for={%{}}

        id="reset-conversation-form"

        action="/data/reset"

          </p>

        </div>

        <div class="memory-header__actions">

          <%!-- The way out of a panel belongs in the panel. This used to be a

          sidebar row, which meant leaving depended on chrome outside the thing

          you were leaving. --%>

          <.text_button

            id="toggle-memory"

            phx-click="toggle_memory"

            aria-label="Return to conversation"

          >

            <.icon name="arrow-left" /> Return to conversation

          </.text_button>

          <.text_button id="export-all-data" href="/data/export" download>

            <.icon name="download" /> Export ALL DATA

          </.text_button>

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash}>

    <Layouts.app flash={@flash} current_scope={@current_scope}>

      <main id="code-commit-page" class="app-shell code-shell">

        <Layouts.command_bar aria_label="Sarah code" current_user={@current_user}>

          <:lockup>

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash}>

    <Layouts.app flash={@flash} current_scope={@current_scope}>

      <main id="code-repo-page" class="app-shell code-shell">

        <Layouts.command_bar aria_label="OpenAgents code" current_user={@current_user}>

          <:lockup>

    """

  end

  defp component_demo(%{item: %{slug: "sidebar-footer"}} = assigns) do

    ~H"""

    <div class="space-y-3">

      <p class="text-sm text-base-content/60">

        The foot of every sidebar. Two of its rows are conditional: the component

        library is advertised outside production only, and Admin appears for an

        operator. Shown here with no user, so Admin is absent — which is what a

        visitor sees.

      </p>

      <div class="demo-frame">

        <Layouts.sidebar_footer />

      </div>

    </div>

    """

  end

  # ── Landing ───────────────────────────────────────────────────────────────

  #

  # These demo at reduced scale inside the documentation column. A hero is

              <.button

                id="home-cta-browse"

                navigate={~p"/OpenAgentsInc/openagents.com/issues"}

                variant={:secondary}

                size={:lg}

              >

                View issues

                class="m-0"

              >

                <.button type="submit" variant={:primary} size={:lg} id="home-cta-signin">

                  Sign in and enable GitHub tools

                  <.icon name="brand-github" /> Log in with GitHub

                </.button>

              </.form>

              <.button navigate={~p"/docs"} size={:lg}>Read the docs</.button>

              <%!-- Quieter than the action beside it. `variant` defaults to

              `:primary`, so two filled buttons sat side by side stating that

              both were the thing to do, which leaves a reader picking rather

              than proceeding. --%>

              <.button navigate={~p"/docs"} variant={:secondary} size={:lg}>

                Read the docs

              </.button>

            <% end %>

          </:actions>

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash}>

    <Layouts.app flash={@flash} current_scope={@current_scope}>

      <main id="network-status-page" class="app-shell status-shell">

        <Layouts.command_bar aria_label="OpenAgents network status" current_user={@current_user}>

          <:lockup>

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash}>

    <Layouts.app flash={@flash} current_scope={@current_scope}>

      <main id="voice-spike" class="app-shell">

        <header class="command-bar">

          <div class="brand-lockup"><span class="brand-name">SARAH / VOICE SPIKE</span></div>

    # not Sarah's. These assertions match the current product identity.

    assert html =~ "The Agent Forge"

    assert html =~ ~s(action="/auth/github?github_tools=enabled")

    assert html =~ "Sign in and enable GitHub tools"

    assert html =~ "Log in with GitHub"

    # The scope disclosure was removed from the hero at the owner's direction.

    # GitHub's own consent screen still states the scope before the grant is

      conn = log_in_github_user(conn, "icon-decorative-user")

      {:ok, view, _html} = live(conn, ~p"/chat")

      for id <- ~w(load-older toggle-memory) do

      for id <- ~w(load-older) do

        refute has_element?(view, "##{id} svg[aria-label]"),

               "the glyph in ##{id} announces itself alongside its text label"

      end

      conn = log_in_github_user(conn, "icon-memory-user")

      {:ok, view, _html} = live(conn, ~p"/chat")

      html = view |> element("#toggle-memory") |> render_click()

      html = render_patch(view, ~p"/chat?panel=memory")

      assert html =~ "Export ALL DATA"

      assert html =~ "DELETE ALL DATA"

           end)

  end

  test "the sidebar leads with Computers immediately above Memory", %{conn: conn} do

  test "the sidebar carries Computers, Memory and Leaderboard for everyone", %{conn: conn} do

    conn = log_in_github_user(conn, "computers-nav-browser")

    {:ok, view, _html} = live(conn, ~p"/chat")

    assert has_element?(view, ~s(#sidebar-nav #open-computers[aria-label="Computers"]))

    assert has_element?(view, ~s(#sidebar-nav #open-computers[href="/computers"]))

    assert has_element?(

             view,

             "#sidebar #sidebar-nav > .sidebar-row:first-child #open-computers"

           )

    assert has_element?(

             view,

             "#sidebar-nav .sidebar-row:has(#open-computers) + .sidebar-row #toggle-memory"

           )

    assert has_element?(view, ~s(#sidebar-nav #open-leaderboard[aria-label="Leaderboard"]))

    # Computers, Memory and Leaderboard are destinations for everyone, so they

    # sit in the application sidebar rather than appearing only on chat.

    assert has_element?(view, ~s(#sidebar a.sidebar-row__hit[href="/computers"]))

    assert has_element?(view, ~s(#sidebar a.sidebar-row__hit[href="/chat?panel=memory"]))

    assert has_element?(view, ~s(#sidebar a.sidebar-row__hit[href="/leaderboard"]))

  end

  test "chat contributes its rows to the one application sidebar", %{conn: conn} do

    # Every destination chat used to carry in its own rail is still reachable,

    # with an accessible name on each stretched hit target.

    assert has_element?(view, ~s(#sidebar #toggle-memory[aria-label="Memory"]))

    assert has_element?(view, "#sidebar a#export-atif[href='/data/export/atif'][download]")

    # Export is the conversation's action, so it is in the conversation's

    # header menu rather than a permanent sidebar row.

    refute has_element?(view, "#sidebar #export-atif")

    assert has_element?(

             view,

             "#chat-actions-menu a#export-atif[href='/data/export/atif'][download]"

           )

    assert has_element?(view, "#sidebar #sidebar-sections")

    # Identity is the command bar's, once, rather than a second account

    conn = log_in_admin_user(recycle(conn), "admin-chip-visible-browser")

    {:ok, view, _html} = live(conn, ~p"/chat")

    assert has_element?(view, ~s(#open-admin[aria-label="Admin"]))

    assert has_element?(view, "#sidebar-admin .sidebar-row__label", "Admin")

    # Admin is one row in the sidebar footer for an operator on every page,

    # rather than a row that exists only on chat.

    assert has_element?(view, ~s(#sidebar .sidebar-footer #open-admin[href="/admin"]))

  end

  test "the reset control renders only where it is enabled", %{conn: conn} do

    assert {:ok, view, _html} = live(conn, ~p"/chat")

    assert {:ok, _banned} = OpenAgents.Accounts.ban_user(user, "manual_abuse_review")

    view |> element("#toggle-memory") |> render_click()

    view |> form("#message-form", chat: %{message: "still here?"}) |> render_submit()

    assert_redirect(view, ~p"/")

  end

    conn = log_in_github_user(conn, token)

    assert {:ok, view, _html} = live(conn, ~p"/chat")

    html = view |> element("#toggle-memory") |> render_click()

    html = render_patch(view, ~p"/chat?panel=memory")

    assert html =~ ~s(id="memory-manager")

    assert html =~ ~s(aria-labelledby="memory-heading")

    assert has_element?(view, "#delete-data-form button#delete-all-data[type='submit']")

    refute has_element?(view, "#message-form")

    view |> element("#toggle-memory") |> render_click()

    render_patch(view, ~p"/chat")

    assert has_element?(view, "#message-form")

    assert render(view) =~ "Hello. I'm Sarah—an OpenAgent. What are we working on?"

  end

    conn = log_in_github_user(conn, token)

    assert {:ok, first, _html} = live(conn, ~p"/chat")

    assert {:ok, second, _html} = live(conn, ~p"/chat")

    first |> element("#toggle-memory") |> render_click()

    second |> element("#toggle-memory") |> render_click()

    render_patch(first, ~p"/chat?panel=memory")

    render_patch(second, ~p"/chat?panel=memory")

    first

    |> form("#memory-record-#{record.id} form", %{"claim" => "I prefer concise, direct answers"})

    user = github_user(token)

    conn = log_in_github_user(conn, token)

    assert {:ok, view, _html} = live(conn, ~p"/chat")

    view |> element("#toggle-memory") |> render_click()

    render_patch(view, ~p"/chat?panel=memory")

    view |> element("#forget-record-#{record.id}") |> render_click()

    assert has_element?(view, "#memory-confirmation")

    user = github_user(token)

    conn = log_in_github_user(conn, token)

    assert {:ok, view, _html} = live(conn, ~p"/chat")

    view |> element("#toggle-memory") |> render_click()

    render_patch(view, ~p"/chat?panel=memory")

    view |> element("#forget-category-#{project.id}") |> render_click()

    assert render(view) =~ "Forget every active project memory in this account?"