color: var(--danger);

  }

  /* Merged pull requests and issues closed as completed. */

  .badge[data-variant="done"] {

    color: var(--done);

  }

  /* Technical metadata keeps the monospace accent. */

  .badge[data-variant="dim"] {

    color: var(--text-dim);

    end

  end

  @doc """

  The historical stack placement for a pull request that merged as part

  of a stack.

  Merging removes the entry from the active stack, so `review_context/2`

  stops covering the pull request the moment it lands. This returns the

  stack with every layer it held — removed entries included — so the page

  keeps showing where the pull request sat and where each sibling went. It

  matches only entries whose removal coincided with the merge, so a pull

  request that left a stack and merged on its own stays `:not_stacked`.

  """

  def merged_context(%PullRequest{} = pull_request) do

    with %DateTime{} = merged_at <- pull_request.merged_at,

         %StackEntry{} = entry <- merged_entry_for_pull_request(pull_request, merged_at) do

      stack =

        Stack

        |> Repo.get!(entry.stack_id)

        |> Repo.preload(entries: all_entries_query())

      entries = latest_entry_per_pull_request(stack.entries)

      stack = %{stack | entries: entries}

      entry = Enum.find(entries, &(&1.id == entry.id))

      {:ok,

       %{

         stack: stack,

         entry: entry,

         position: entry.position,

         size: length(entries)

       }}

    else

      _other -> {:error, :not_stacked}

    end

  end

  defp merged_entry_for_pull_request(%PullRequest{id: pull_request_id}, merged_at) do

    Repo.one(

      from entry in StackEntry,

        where: entry.pull_request_id == ^pull_request_id and entry.removed_at == ^merged_at

    )

  end

  defp latest_entry_per_pull_request(entries) do

    entries

    |> Enum.group_by(& &1.pull_request_id)

    |> Enum.map(fn {_pull_request_id, group} ->

      Enum.max_by(group, & &1.inserted_at, DateTime)

    end)

    |> Enum.sort_by(& &1.position)

  end

  defp all_entries_query do

    from entry in StackEntry,

      order_by: [asc: entry.position],

      preload: [pull_request: :issue]

  end

  defp parent_ref(stack, %StackEntry{position: 1}), do: stack.trunk_ref

  defp parent_ref(stack, entry) do

  and never stands in for the words.

  """

  attr :variant, :atom,

    values: [:default, :info, :success, :warning, :danger, :dim],

    values: [:default, :info, :success, :warning, :danger, :done, :dim],

    default: :default

  attr :class, :any, default: nil

  defp stack_placement(repository, pull_request) do

    case safe(fn -> Stacks.review_context(repository, pull_request) end) do

      {:ok, context} -> {context.position, context.size}

      _other -> merged_stack_placement(pull_request)

    end

  end

  defp merged_stack_placement(pull_request) do

    case safe(fn -> Stacks.merged_context(pull_request) end) do

      {:ok, context} -> {context.position, context.size}

      _other -> {nil, nil}

    end

                      #{pull_request.issue.number} from {pull_request.head_repository.owner}/{pull_request.head_repository.name}:{pull_request.head_ref} into {pull_request.base_ref}

                    </p>

                  </div>

                  <.badge variant={if(pull_request.state == "open", do: :success, else: :secondary)}>

                    {pull_request.state}

                  <.badge variant={state_variant(state_label(pull_request))}>

                    {state_label(pull_request)}

                  </.badge>

                </div>

              </.link>

    """

  end

  defp state_label(pull_request) do

    cond do

      pull_request.merged_at -> "merged"

      pull_request.state == "closed" -> "closed"

      pull_request.draft -> "draft"

      true -> "open"

    end

  end

  defp state_variant("merged"), do: :done

  defp state_variant("open"), do: :success

  defp state_variant("draft"), do: :dim

  defp state_variant(_closed), do: :danger

  defp visible_repository!(owner, repo, user) do

    Repositories.get_visible_by_path!(owner, repo, user)

  rescue

        {:error, :not_stacked} -> nil

      end

    stack_history = if stack_context, do: nil, else: merged_history(pull_request)

    stack_placement = stack_context || stack_history

    {:ok,

     socket

     |> assign(:current_scope, socket.assigns[:current_scope])

     |> assign(:repository, repository)

     |> assign(:pull_request, pull_request)

     |> assign(:stack_context, stack_context)

     |> assign(:stack_history, stack_history)

     |> assign(:stack_operation, nil)

     |> assign(

       :og,

       OG.meta(

         OG.pull_request(repository.namespace.slug, repository.name, pull_request,

           stack_position: stack_context && stack_context.position,

           stack_size: stack_context && stack_context.size

           stack_position: stack_placement && stack_placement.position,

           stack_size: stack_placement && stack_placement.size

         )

       )

     )

          <article class="mx-auto w-full max-w-5xl px-4 py-8">

            <div class="flex flex-wrap items-center gap-3">

              <h1 class="text-2xl font-semibold text-foreground">{@pull_request.issue.title}</h1>

              <.badge variant={if(@pull_request.state == "open", do: :success, else: :secondary)}>

                {@pull_request.state}

              <.badge id="pull-request-state" variant={state_variant(layer_state(@pull_request))}>

                {layer_state(@pull_request)}

              </.badge>

            </div>

            <p class="mt-3 text-sm text-muted-foreground">

                The diff is truncated.

              </p>

            </section>

            <section :if={@stack_history} id="stack-history" class="mt-8">

              <div class="flex flex-wrap items-center gap-3">

                <h2 class="text-lg font-semibold text-foreground">

                  Stack #{@stack_history.stack.number} · layer {@stack_history.position} of {@stack_history.size}

                </h2>

                <.badge variant={:done}>merged</.badge>

              </div>

              <.stack_map

                id="stack-history-map"

                number={@stack_history.stack.number}

                trunk={@stack_history.stack.trunk_ref}

                trunk_navigate={~p"/#{@owner}/#{@repo}/tree/#{@stack_history.stack.trunk_ref}"}

                layers={stack_map_layers(@stack_history, @owner, @repo)}

                class="mt-4 max-w-md"

              />

              <p id="stack-history-note" class="mt-3 text-sm text-muted-foreground">

                This pull request merged into {@stack_history.stack.trunk_ref} as part of

                the stack.

              </p>

            </section>

          </article>

        </.repo_view>

      </main>

    """

  end

  defp merged_history(pull_request) do

    case Stacks.merged_context(pull_request) do

      {:ok, context} -> context

      {:error, :not_stacked} -> nil

    end

  end

  defp state_variant("merged"), do: :done

  defp state_variant("open"), do: :success

  defp state_variant("draft"), do: :dim

  defp state_variant(_closed), do: :danger

  defp short(sha), do: String.slice(sha, 0, 12)

  defp stack_map_layers(context, owner, repo) do

    end

  end

  describe "the merged review context" do

    test "a merged pull request resolves its historical stack placement", context do

      %{repository: repository, actor: actor} = context

      %{stack: stack, pull_requests: [pr_1, pr_2]} = seed_stack(repository, actor)

      {:ok, {_operation, :created}} =

        Merge.request_from_api(

          repository,

          stack.number,

          %{"pull_request_number" => pr_2.issue.number, "merge_method" => "merge"},

          actor,

          "merged-context-1"

        )

      assert :processed = OperationWorker.run_once()

      for pr <- [pr_1, pr_2] do

        merged = Repo.one!(from p in PullRequest, where: p.id == ^pr.id)

        assert {:ok, merged_context} = Stacks.merged_context(merged)

        assert merged_context.stack.id == stack.id

        assert merged_context.size == 2

        assert merged_context.entry.pull_request_id == pr.id

        assert Enum.map(merged_context.stack.entries, & &1.position) == [1, 2]

        assert Enum.map(merged_context.stack.entries, & &1.pull_request.issue.number) ==

                 [pr_1.issue.number, pr_2.issue.number]

      end

    end

    test "an unmerged stacked pull request has no merged context", context do

      %{repository: repository, actor: actor} = context

      %{pull_requests: [pr_1, _pr_2]} = seed_stack(repository, actor)

      assert {:error, :not_stacked} = Stacks.merged_context(pr_1)

    end

  end

  ## Fixtures

  # main ── layer-1 ── layer-2 ── …, each layer adding one file.

  alias OpenAgents.PullRequests.PullRequest

  alias OpenAgents.Repo

  alias OpenAgents.Stacks

  alias OpenAgents.Stacks.Stack

  alias OpenAgents.Stacks.StackEntry

  test "the pull request list links to a valid browser detail page", %{conn: conn} do

    target = repository_fixture()

      assert render(show) =~ "The pull request left the stack."

      refute has_element?(show, "#stack-review")

    end

    test "a merged stack member keeps its stack map and shows the merged state", %{

      conn: conn,

      repository: repository,

      pull_requests: pull_requests

    } do

      merge_stack!(pull_requests)

      [bottom, top] = pull_requests

      {:ok, show, _html} = live(conn, pull_path(repository, bottom))

      assert element(show, "#pull-request-state") |> render() =~ "merged"

      refute has_element?(show, "#stack-review")

      assert element(show, "#stack-history") |> render() =~ "layer 1 of 2"

      assert element(show, "#stack-history-note") |> render() =~ "merged into main"

      layers = element(show, "#stack-history-map") |> render()

      assert layers =~ ~s(data-state="merged")

      refute layers =~ ~s(data-state="open")

      assert has_element?(

               show,

               "#stack-history-map a[href='#{pull_path(repository, top)}']"

             )

      refute has_element?(show, "#stack-rebase")

      refute has_element?(show, "#stack-unstack")

    end

    test "a pull request closed without merging shows closed and no stack history", %{

      conn: conn,

      repository: repository,

      pull_requests: pull_requests

    } do

      top = Enum.at(pull_requests, 1)

      {1, _rows} =

        Repo.update_all(

          from(entry in StackEntry, where: entry.pull_request_id == ^top.id),

          set: [removed_at: DateTime.utc_now()]

        )

      {1, _rows} =

        Repo.update_all(

          from(pr in PullRequest, where: pr.id == ^top.id),

          set: [state: "closed"]

        )

      {:ok, show, _html} = live(conn, pull_path(repository, top))

      assert element(show, "#pull-request-state") |> render() =~ "closed"

      refute has_element?(show, "#stack-review")

      refute has_element?(show, "#stack-history")

    end

    test "the pull request list shows the merged state", %{

      conn: conn,

      repository: repository,

      pull_requests: pull_requests

    } do

      merge_stack!(pull_requests)

      {:ok, index, _html} = live(conn, "/#{repository.owner}/#{repository.name}/pulls")

      assert has_element?(index, "span[data-variant='done']", "merged")

    end

  end

  # Marks every layer merged the way `Merge.execute/2` records it: the entry

  # removal and the pull request merge share one timestamp, and the stack

  # completes.

  defp merge_stack!(pull_requests) do

    now = DateTime.utc_now()

    ids = Enum.map(pull_requests, & &1.id)

    {_count, _rows} =

      Repo.update_all(

        from(entry in StackEntry, where: entry.pull_request_id in ^ids),

        set: [removed_at: now]

      )

    {_count, _rows} =

      Repo.update_all(

        from(pr in PullRequest, where: pr.id in ^ids),

        set: [state: "closed", merged_at: now]

      )

    {_count, _rows} = Repo.update_all(Stack, set: [state: "completed"])

    :ok

  end

  defp pull_path(repository, pull_request) do