.sidebar-section {

  position: relative;

  /* A section heading needs air above it or it reads as one more row in the

     list it is naming. The nav lost its block padding when the sticky heading

     was fixed, and nothing replaced it, so "Sarah" sat hard against the row

     above. The space belongs to the section rather than the nav, which is why

     it survives a heading sticking to the scrollport edge. */

  margin-block-start: 16px;

}

/* A section that opens the rail has nothing above it to be held off from. */

.sidebar-section:first-child {

  margin-block-start: 0;

}

/* Only an open section needs holding off the next one. Paying that gap while

    left: 0;

    width: 100%;

    pointer-events: none;

    /* Two independent dials, multiplied, so neither has to know the other's

       value: `--glow-base` is what the theme allows, `--glow-scale` is what a

       given placement asks for. A single `opacity` cannot do this -- the light

       theme's rule outranks a placement's, so dimming one glow would silently

       do nothing in light mode. */

    opacity: calc(var(--glow-base, 1) * var(--glow-scale, 1));

  }

  .glow--top { top: 0; }

     backdrop on a dark surface reads as a stain on a white one. */

  :root[data-theme="light"] .glow,

  :root:not([data-theme="dark"]) .glow {

    opacity: 0.35;

    --glow-base: 0.35;

  }

  @media (min-width: 640px) {

  .hero__glow {

    top: 38%;

    z-index: 0;

    /* Half strength. At full it lit the headline from behind hard enough to

       read as a light source in the page rather than depth behind it. */

    --glow-scale: 0.5;

  }

  /* Two edges of one line. The copyright says who owns this and the note says

@layer components {

  /* A project row plus its own destructive control. The row fills the width and

     the control sits outside it, so clicking the row can only ever navigate. */

  .project-list__row {

     the control sits outside it, so clicking the row can only ever navigate.

     Named for the index, not for "project list": the dashboard already had a

     `.project-list__row`, and this rule's `> :first-child { flex: 1 }` landed

     on that row's leading icon and stretched it, pushing the title into the

     middle of an empty row. Two different rows had the same name. */

  .project-index__row {

    display: flex;

    align-items: center;

    gap: 8px;

  }

  .project-list__row > :first-child {

  .project-index__row > :first-child {

    min-width: 0;

    flex: 1;

  }

  .project-list__delete {

  .project-index__delete {

    flex: none;

  }

}

    field :public_leaderboard_opted_out, :boolean, default: false

    field :browser_key_hash, :binary

    # Not a column: resolved once by `UserAuth.on_mount/4` when it builds the

    # scope, because the sidebar asks on every render and the answer must not

    # be a query each time. Defaults to false, so a user loaded by any other

    # path is treated as new rather than accidentally grandfathered.

    field :agent_surfaces?, :boolean, virtual: true, default: false

    has_one :storage_owner, OpenAgents.Conversations.Visitor

    timestamps()

          github_token_rotated_at: DateTime.t() | nil,

          public_leaderboard_opted_out: boolean(),

          browser_key_hash: binary() | nil,

          agent_surfaces?: boolean(),

          inserted_at: DateTime.t(),

          updated_at: DateTime.t()

        }

    end)

  end

  @doc """

  Whether this account has ever sent a message to the agent.

  Asks for a message the *person* wrote. Every conversation is created with an

  assistant greeting already in it, so "has any message" is true for an account

  that has never opened chat, and would grandfather everyone.

  Existence only, and bounded by `limit: 1`: this runs on every page render to

  decide whether the sidebar shows the agent's surfaces at all.

  """

  @spec user_has_messages?(User.t() | nil) :: boolean()

  def user_has_messages?(nil), do: false

  def user_has_messages?(%User{id: user_id}) do

    from(m in Message,

      join: c in Conversation,

      on: c.id == m.conversation_id,

      join: v in assoc(c, :visitor),

      where: v.user_id == ^user_id and m.role == "user",

      select: 1,

      limit: 1

    )

    |> Repo.one()

    |> is_integer()

  end

  def get_conversation_for_user(%User{id: user_id}) do

    from(c in Conversation,

      join: v in assoc(c, :visitor),

  the section you are reading would hide your own location.

  """

  attr :title, :string, required: true

  attr :open, :boolean, default: false

  attr :open, :boolean, default: false, doc: "first paint only; the reader's choice wins after"

  attr :id, :string, default: nil, doc: "defaults to a slug of the title"

  slot :inner_block, required: true

      class="docs-sidebar__section sidebar-section"

      open={@open}

      phx-hook=".SidebarSection"

      data-holds-active={to_string(@open)}

    >

      <summary class="sidebar-section-label sidebar-section__summary">

        <UI.icon name="chevron-right" class="sidebar-section__caret" />

        {render_slot(@inner_block)}

      </div>

    </details>

    <%!-- `open` above is a seed, not the truth. The server can only derive it

    from the active page, so re-deriving it on every navigation collapses every

    section the reader opened but is not currently inside. The hook makes the

    reader's own choices the state and keeps them in sessionStorage; the server

    still decides on first paint and whenever a section holds the active page,

    so a page can never be hidden inside a section the reader had closed, and

    the sidebar works with no JavaScript at all. --%>

    <%!-- `open` above is a seed, not the truth. Re-applying it on every

    navigation collapses every section the reader opened but is not currently

    inside, and re-opens every section they closed that happens to be open by

    default. The hook makes the reader's own choices the state and keeps them

    in sessionStorage; the seed decides first paint, and a section containing

    the active row still opens regardless, so a page can never be hidden inside

    a section the reader had closed. With no JavaScript the seed governs and

    the sidebar still works. --%>

    <script :type={Phoenix.LiveView.ColocatedHook} name=".SidebarSection">

      const KEY = "sidebar-sections"

        restore() {

          // A section holding the active page opens regardless of what the

          // reader last did, so navigation can never land on a hidden row.

          if (this.el.dataset.holdsActive === "true") {

          // Asked of the DOM rather than of the server: the active row already

          // marks itself `aria-current`, and a server-side answer has to be

          // derived from the section's `open` attribute, which is true for a

          // section that is merely open by default -- so every navigation

          // re-forced such a section open and undid the reader's collapse.

          if (this.el.querySelector("[aria-current]")) {

            this.el.open = true

            this.onToggle()

            return

  slot :extra, doc: "rows contributed by the current page"

  defp sidebar(assigns) do

    assigns = assign(assigns, :agent_surfaces?, agent_surfaces?(assigns[:current_scope]))

    ~H"""

    <aside id="sidebar" class="sidebar hidden lg:flex">

      <Layouts.sidebar_brand />

      the two things it can reach -- and reading as a group says that in a way

      six flat rows cannot. Open by default: grouping is for orientation here,

      not for hiding. --%>

      <Layouts.sidebar_section title="Sarah" open>

      <Layouts.sidebar_section :if={@agent_surfaces?} title="Sarah" open>

        <Layouts.sidebar_link path={~p"/chat"} label="Chat" icon="chat" patchable={false} />

        <Layouts.sidebar_link

          path={~p"/computers"}

    """

  end

  # The agent's surfaces are grandfathered, not launched: an account that has

  # already talked to her keeps them, and an operator always has them, but a

  # new account never sees them. `agent_surfaces?` is resolved once by

  # `UserAuth.on_mount/4`; this runs on every render, so it must stay a field

  # read and never become a query.

  defp agent_surfaces?(nil), do: false

  defp agent_surfaces?(user), do: user.agent_surfaces? or admin?(user)

  # 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)

          |> assign(:tool_activity, [])

          |> assign(:composer_error, nil)

          |> assign(:form, composer_form())

          |> grant_agent_surfaces()

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

          |> push_event("chat:scroll-bottom", %{})

    end

  end

  # Writing to her is the act that earns the sidebar section. The scope is

  # resolved once at mount, so without this the person who just sent their

  # first message would not see the section until their next page load.

  defp grant_agent_surfaces(

         %{assigns: %{current_scope: %{agent_surfaces?: false} = scope}} = socket

       ) do

    Phoenix.Component.assign(socket, :current_scope, %{scope | agent_surfaces?: true})

  end

  defp grant_agent_surfaces(socket), do: socket

  @maximum_queued_messages 10

  # Append a message to run after the active turn(s), so the composer never

        <section>No projects yet.</section>

      </div>

      <div :if={@projects != []} class="project-list">

        <div :for={project <- @projects} class="project-list__row">

      <div :if={@projects != []} class="project-index">

        <div :for={project <- @projects} class="project-index__row">

          <Circle.project_row

            name={project.title}

            navigate={~p"/#{@owner}/#{@repo}/projects/#{project.number}"}

          row grew: the row is a link to a board, and a destructive action

          inside a link target is how people delete things by accident. --%>

          <button

            class="btn project-list__delete"

            class="btn project-index__delete"

            data-variant="ghost"

            data-size="sm"

            data-tone="danger"

    end

  end

  # The scope is the user, plus the answers the layout needs on every render

  # and must not re-ask for. Resolved once here, at mount.

  defp scope(user) do

    %{user | agent_surfaces?: OpenAgents.Conversations.user_has_messages?(user)}

  end

  def on_mount(:mount_current_user, _params, session, socket) do

    with user_id when is_binary(user_id) <- session[@session_key],

         {:ok, user} <- Accounts.get_active_user(user_id) do

      {:cont,

       socket

       |> Phoenix.Component.assign(:current_user, user)

       |> Phoenix.Component.assign(:current_scope, user)}

       |> Phoenix.Component.assign(:current_scope, scope(user))}

    else

      _missing_or_inactive ->

        {:cont,

      {:cont,

       socket

       |> Phoenix.Component.assign(:current_user, user)

       |> Phoenix.Component.assign(:current_scope, user)

       |> Phoenix.Component.assign(:current_scope, scope(user))

       |> Phoenix.LiveView.attach_hook(

         :active_user_guard,

         :handle_event,

    assert length(older) == 6

    assert MapSet.disjoint?(MapSet.new(recent, & &1.id), MapSet.new(older, & &1.id))

  end

  describe "user_has_messages?/1" do

    # This decides whether the agent's surfaces appear in the sidebar at all:

    # an account that has already talked to her keeps them, a new one never

    # sees them. Getting it wrong in the permissive direction is invisible --

    # the section simply shows for everybody -- so the greeting case below is

    # the one that matters.

    test "an account that has never opened chat has not sent a message" do

      user = OpenAgents.AccountsFixtures.repository_user_fixture("never-chatted")

      refute Conversations.user_has_messages?(user)

    end

    test "the seeded greeting does not count as the person having written" do

      # Every conversation is created with an assistant greeting already in it,

      # so "does this account have any message" is true the instant chat is

      # opened -- which would grandfather every account that ever loaded the

      # page. The question has to be about a message the person wrote.

      user = OpenAgents.AccountsFixtures.repository_user_fixture("only-greeted")

      assert {:ok, conversation} = Conversations.ensure_conversation(user)

      {[%Message{role: "assistant"}], false} = Conversations.list_messages(conversation)

      refute Conversations.user_has_messages?(user)

    end

    test "an account that has written is grandfathered" do

      user = OpenAgents.AccountsFixtures.repository_user_fixture("has-chatted")

      assert {:ok, conversation} = Conversations.ensure_conversation(user)

      assert {:ok, _records} = Conversations.create_turn(conversation, "Hello.")

      assert Conversations.user_has_messages?(user)

    end

    test "one account's messages do not grandfather another" do

      talker = OpenAgents.AccountsFixtures.repository_user_fixture("talker")

      bystander = OpenAgents.AccountsFixtures.repository_user_fixture("bystander")

      assert {:ok, conversation} = Conversations.ensure_conversation(talker)

      assert {:ok, _records} = Conversations.create_turn(conversation, "Hello.")

      refute Conversations.user_has_messages?(bystander)

    end

    test "no account at all has no messages" do

      refute Conversations.user_has_messages?(nil)

    end

  end

end

defmodule OpenAgentsWeb.AgentSurfacesTest do

  @moduledoc """

  The agent's sidebar section is grandfathered, not launched.

  An account that has already talked to her keeps her surfaces, and an operator

  always has them. A new account does not, and will not until it writes to her.

  These are worth holding because the failure is silent in the direction that

  matters: if the check goes permissive -- and the obvious implementation does,

  since every conversation is created with a greeting message already in it --

  the section simply appears for everybody and nothing anywhere complains.

  """

  use OpenAgentsWeb.ConnCase

  import Phoenix.LiveViewTest

  @section "#sidebar #sidebar-section-sarah"

  describe "who sees her" do

    test "a new account does not", %{conn: conn} do

      conn = log_in_github_user(conn, "brand-new-account")

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

      refute has_element?(view, @section)

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

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

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

    end

    test "an account that has written to her does", %{conn: conn} do

      conn = log_in_chatting_user(conn, "already-talked")

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

      assert has_element?(view, @section)

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

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

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

    end

    test "an operator does, without having written", %{conn: conn} do

      conn = log_in_admin_user(conn, "operator-who-never-chatted")

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

      assert has_element?(view, @section)

    end

    test "the rest of the sidebar is unaffected either way", %{conn: conn} do

      # The gate hides one section, not the application. A new account still

      # gets the shared destinations and the footer.

      conn = log_in_github_user(conn, "new-account-still-has-a-sidebar")

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

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

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

      assert has_element?(view, "#account-bar-trigger")

    end

  end

  describe "earning her" do

    test "the first message reveals the section without a reload", %{conn: conn} do

      conn = log_in_github_user(conn, "first-message-account")

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

      refute has_element?(view, @section)

      view

      |> form("#message-form", chat: %{message: "Hello."})

      |> render_submit()

      assert has_element?(view, @section)

    end

  end

end

  end

  test "carries the shell sidebar when logged in", %{conn: conn} do

    conn = log_in_github_user(conn, "changelog-header-browser")

    conn = log_in_chatting_user(conn, "changelog-header-browser")

    {:ok, _view, html} = live(conn, ~p"/changelog")

           end)

  end

  test "the sidebar carries the shared destinations for everyone", %{conn: conn} do

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

  test "the sidebar carries the shared destinations for an account that has written",

       %{conn: conn} do

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

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

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

  import Phoenix.LiveViewTest

  test "the canonical Computers surface carries authenticated application chrome", %{conn: conn} do

    conn = log_in_github_user(conn, "computers-surface")

    conn = log_in_chatting_user(conn, "computers-surface")

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

    assert has_element?(view, "#computers-page")

  end

  test "carries the shell account menu and sidebar when logged in", %{conn: conn} do

    conn = log_in_github_user(conn, "leaderboard-header-browser")

    conn = log_in_chatting_user(conn, "leaderboard-header-browser")

    {:ok, _view, html} = live(conn, ~p"/leaderboard")

    Plug.Test.init_test_session(conn, %{"user_id" => user.id})

  end

  @doc """

  Logs in an account that has already written to the agent.

  Her surfaces are grandfathered rather than launched, so an account that has

  never sent a message does not see them. A test about the sidebar's shared

  destinations wants an account that does.

  """

  def log_in_chatting_user(conn, key) when is_binary(key) do

    user = github_user(key)

    {:ok, conversation} = OpenAgents.Conversations.ensure_conversation(user)

    {:ok, _records} = OpenAgents.Conversations.create_turn(conversation, "Hello.")

    Plug.Test.init_test_session(conn, %{"user_id" => user.id})

  end

  def put_forge_api_token(conn, key) when is_binary(key) do

    user = github_user("api-token-" <> key)