diff --git a/src/components/PullRequestList.spec.js b/src/components/PullRequestList.spec.js
new file mode 100644
index 000000000..edbdfca3f
--- /dev/null
+++ b/src/components/PullRequestList.spec.js
@@ -0,0 +1,347 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { flushPromises, mount, RouterLinkStub } from '@vue/test-utils'
+import { VPagination } from 'vuetify/components'
+
+const api = vi.hoisted(() => ({ apiFetch: vi.fn() }))
+
+vi.mock('@/composables/api', async (importOriginal) => ({
+  ...(await importOriginal()),
+  apiFetch: api.apiFetch,
+}))
+
+function action(n, overrides = {}) {
+  return {
+    url: `https://github.com/updatecli/udash/pull/${n}`,
+    title: `Bump dependency ${n}`,
+    repository: 'https://github.com/updatecli/udash.git',
+    branch: 'main',
+    updated_at: '2026-09-22T11:57:00Z',
+    pipelines: [{ id: `p${n}`, name: `Pipeline ${n}`, result: '✔', updated_at: '2026-09-22T11:57:00Z' }],
+    ...overrides,
+  }
+}
+
+function answer(response) {
+  api.apiFetch.mockImplementation(async () => {
+    if (response instanceof Error) throw response
+    return response
+  })
+}
+
+async function mountList(props = {}) {
+  vi.resetModules()
+  const { default: PullRequestList } = await import('@/components/PullRequestList.vue')
+  const wrapper = mount(PullRequestList, { props, global: { stubs: { RouterLink: RouterLinkStub } } })
+  await flushPromises()
+  return wrapper
+}
+
+function lastBody() {
+  return api.apiFetch.mock.calls.at(-1)[1].body
+}
+
+beforeEach(() => {
+  vi.useFakeTimers({ toFake: ['setInterval', 'Date'] })
+  vi.setSystemTime(new Date('2026-09-22T12:00:00Z'))
+})
+
+afterEach(() => {
+  vi.useRealTimers()
+  api.apiFetch.mockReset()
+})
+
+describe('PullRequestList', () => {
+  it('asks for the open pull requests matching the filter', async () => {
+    answer({ data: [], total_count: 0 })
+    await mountList({
+      limit: 10,
+      filter: {
+        startTime: '2026-09-01T00:00:00Z',
+        endTime: '2026-09-02T00:00:00Z',
+        labels: { team: 'infra' },
+        results: ['✗'],
+        openAction: true,
+      },
+    })
+
+    expect(api.apiFetch).toHaveBeenCalledWith('/pipeline/actions/search', {
+      method: 'POST',
+      body: {
+        start_time: '2026-09-01T00:00:00Z',
+        end_time: '2026-09-02T00:00:00Z',
+        labels: { team: 'infra' },
+        results: ['✗'],
+        limit: 10,
+        page: 1,
+      },
+    })
+  })
+
+  it('narrows the pull requests to the repository branch the filter picked', async () => {
+    answer({ data: [], total_count: 0 })
+    await mountList({ filter: { scmid: 'scm-1', results: ['✗'] } })
+
+    expect(lastBody()).toEqual({ results: ['✗'], scmid: 'scm-1', limit: 5, page: 1 })
+  })
+
+  it('lists a pull request with its repository, age and pipeline', async () => {
+    answer({ data: [action(7)], total_count: 1 })
+    const wrapper = await mountList()
+
+    const item = wrapper.get('.pull-requests__item')
+    const link = item.get('a[target="_blank"]')
+    expect(link.attributes('href')).toBe('https://github.com/updatecli/udash/pull/7')
+    expect(link.attributes('rel')).toBe('noopener noreferrer')
+    expect(item.text()).toContain('Bump dependency 7')
+    expect(item.text()).toContain('updatecli/udash · main')
+    expect(item.text()).toContain('3 minutes ago')
+    expect(item.findComponent(RouterLinkStub).props('to')).toBe('/pipeline/reports/p7')
+    expect(item.find('button').exists()).toBe(false)
+    expect(wrapper.text()).toContain('1 pull request')
+  })
+
+  it('leads with the worst result and tallies the pipelines of a pull request fed by several', async () => {
+    answer({
+      data: [action(7, {
+        pipelines: [
+          { id: 'a', name: 'First manifest', result: '✔' },
+          { id: 'b', name: 'Second manifest', result: '✗' },
+          { id: 'c', name: 'Third manifest', result: '✔' },
+        ],
+      })],
+      total_count: 1,
+    })
+    const wrapper = await mountList()
+
+    expect(wrapper.get('.pull-requests__icon').classes()).toContain('text-error')
+
+    const toggle = wrapper.get('.pull-requests__toggle')
+    expect(toggle.text()).toContain('✗ 1')
+    expect(toggle.text()).toContain('✔ 2')
+    expect(toggle.text()).toContain('3 pipelines')
+    expect(toggle.attributes('aria-label')).toBe('3 pipelines feeding Bump dependency 7: 1 failed, 2 success')
+    expect(toggle.attributes('aria-expanded')).toBe('false')
+
+    // The list it controls always exists, hidden until expanded.
+    const list = wrapper.get(`#${toggle.attributes('aria-controls')}`)
+    expect(list.attributes('style')).toContain('display: none')
+
+    await toggle.trigger('click')
+
+    expect(toggle.attributes('aria-expanded')).toBe('true')
+    expect(list.attributes('style') || '').not.toContain('display: none')
+    // The failing pipeline comes first, and each result is spelled out for screen readers.
+    const links = wrapper.findAllComponents(RouterLinkStub)
+    expect(links.map((link) => link.props('to'))).toEqual(['/pipeline/reports/b', '/pipeline/reports/a', '/pipeline/reports/c'])
+    expect(list.findAll('li')[0].text()).toContain('Failed:')
+  })
+
+  it('dims the pipelines the result filter left out', async () => {
+    answer({
+      data: [action(7, {
+        pipelines: [
+          { id: 'a', name: 'Changed', result: '⚠' },
+          { id: 'b', name: 'Failing', result: '✗' },
+        ],
+      })],
+      total_count: 1,
+    })
+    const wrapper = await mountList({ filter: { results: ['✗'] } })
+
+    const items = wrapper.findAll('.pull-requests__pipelines li')
+    expect(items[0].classes()).not.toContain('pull-requests__pipeline--unmatched')
+    expect(items[1].classes()).toContain('pull-requests__pipeline--unmatched')
+  })
+
+  it('falls back to the link, as an identifier, when the pull request has no title', async () => {
+    answer({ data: [action(7, { title: '', url: 'https://gitlab.com/group/project/-/merge_requests/7' })], total_count: 1 })
+    const wrapper = await mountList()
+
+    const title = wrapper.get('.pull-requests__title')
+    expect(title.text()).toContain('gitlab.com/group/project/-/merge_requests/7')
+    expect(title.classes()).toContain('text-mono')
+    expect(title.text()).toContain('opens the merge request in a new tab')
+  })
+
+  it('lists a pull request whose link is not http or https as plain text', async () => {
+    answer({ data: [action(7, { url: 'javascript:alert(1)', title: 'Unsafe' }), action(8)], total_count: 2 })
+    const wrapper = await mountList()
+
+    // Both are counted and listed, only the safe one is a link.
+    expect(wrapper.findAll('.pull-requests__item')).toHaveLength(2)
+    const hrefs = wrapper.findAll('a[target="_blank"]').map((link) => link.attributes('href'))
+    expect(hrefs).toEqual(['https://github.com/updatecli/udash/pull/8'])
+    const unsafe = wrapper.findAll('.pull-requests__title')[0]
+    expect(unsafe.element.tagName).toBe('SPAN')
+    expect(unsafe.text()).toBe('Unsafe')
+  })
+
+  it('keeps the pager on the rows shown when the page asked for fails to load', async () => {
+    answer({ data: [action(1)], total_count: 30 })
+    const wrapper = await mountList({ paginated: true, limit: 10 })
+
+    api.apiFetch.mockImplementation(async () => { throw Object.assign(new Error('boom'), { status: 503 }) })
+    wrapper.getComponent(VPagination).vm.$emit('update:modelValue', 3)
+    await flushPromises()
+
+    expect(wrapper.getComponent(VPagination).props('modelValue')).toBe(1)
+    expect(wrapper.text()).toContain('Bump dependency 1')
+    expect(wrapper.get('.pull-requests__page-error').text()).toBe('Page 3 could not be loaded. The Udash API is unavailable right now. Try again in a moment.')
+
+    // A later refresh still reads the page on screen, not the one that failed, and keeps
+    // saying the page asked for could not be loaded.
+    answer({ data: [action(1)], total_count: 30 })
+    await vi.advanceTimersByTimeAsync(60 * 1000)
+    await flushPromises()
+    expect(lastBody()).toMatchObject({ page: 1 })
+    expect(wrapper.find('.pull-requests__page-error').exists()).toBe(true)
+
+    // Asking for a page again replaces it.
+    answer({ data: [action(11)], total_count: 30 })
+    wrapper.getComponent(VPagination).vm.$emit('update:modelValue', 2)
+    await flushPromises()
+    expect(wrapper.find('.pull-requests__page-error').exists()).toBe(false)
+  })
+
+  it('drops the count of the previous filter while the new one loads', async () => {
+    answer({ data: [action(1)], total_count: 12 })
+    const wrapper = await mountList({ filter: {}, countQualifier: 'in this period' })
+    expect(wrapper.get('.pull-requests__count').text()).toBe('12 pull requests in this period')
+
+    api.apiFetch.mockImplementation(() => new Promise(() => {}))
+    await wrapper.setProps({ filter: { results: ['✗'] } })
+
+    expect(wrapper.find('.pull-requests__count').exists()).toBe(false)
+  })
+
+  it('pages through every pull request', async () => {
+    answer({ data: [action(1), action(2)], total_count: 30 })
+    const wrapper = await mountList({ paginated: true, limit: 10 })
+
+    expect(lastBody()).toMatchObject({ limit: 10, page: 1 })
+    const pagination = wrapper.getComponent(VPagination)
+    expect(pagination.props('length')).toBe(3)
+
+    pagination.vm.$emit('update:modelValue', 2)
+    await flushPromises()
+    expect(lastBody()).toMatchObject({ limit: 10, page: 2 })
+    expect(wrapper.get('[aria-live="polite"]').text()).toBe('Page 2 of 3, pull requests 11 to 12 of 30')
+  })
+
+  it('shows only the first page when it is not paginated', async () => {
+    answer({ data: [action(1)], total_count: 30 })
+    const wrapper = await mountList({ limit: 5 })
+
+    expect(lastBody()).toMatchObject({ limit: 5, page: 1 })
+    expect(wrapper.findComponent(VPagination).exists()).toBe(false)
+  })
+
+  it('does not offer pages when everything fits on one', async () => {
+    answer({ data: [action(1)], total_count: 10 })
+    const wrapper = await mountList({ paginated: true, limit: 10 })
+
+    expect(wrapper.findComponent(VPagination).exists()).toBe(false)
+  })
+
+  it('goes back to the first page when the filter changes', async () => {
+    answer({ data: [action(1)], total_count: 30 })
+    const wrapper = await mountList({ paginated: true, limit: 10, filter: {} })
+
+    wrapper.getComponent(VPagination).vm.$emit('update:modelValue', 3)
+    await flushPromises()
+    api.apiFetch.mockClear()
+
+    await wrapper.setProps({ filter: { results: ['⚠'] } })
+    await flushPromises()
+
+    expect(api.apiFetch).toHaveBeenCalledOnce()
+    expect(lastBody()).toEqual({ results: ['⚠'], limit: 10, page: 1 })
+  })
+
+  it('moves back to the last page when a refresh leaves the current one past it', async () => {
+    answer({ data: [action(1)], total_count: 30 })
+    const wrapper = await mountList({ paginated: true, limit: 10 })
+    wrapper.getComponent(VPagination).vm.$emit('update:modelValue', 3)
+    await flushPromises()
+
+    // Pull requests got merged: 12 are left, so page 3 of 10 no longer exists.
+    api.apiFetch.mockImplementation(async (path, { body }) => (
+      body.page === 3 ? { data: [], total_count: 12 } : { data: [action(11), action(12)], total_count: 12 }
+    ))
+    await vi.advanceTimersByTimeAsync(60 * 1000)
+    await flushPromises()
+
+    expect(lastBody()).toMatchObject({ page: 2 })
+    expect(wrapper.text()).toContain('Bump dependency 12')
+  })
+
+  it('keeps the page asked for when a refresh comes before it arrived', async () => {
+    answer({ data: [action(1)], total_count: 30 })
+    const wrapper = await mountList({ paginated: true, limit: 10 })
+
+    api.apiFetch.mockImplementation(() => new Promise(() => {}))
+    wrapper.getComponent(VPagination).vm.$emit('update:modelValue', 3)
+    await flushPromises()
+
+    answer({ data: [action(21)], total_count: 30 })
+    await vi.advanceTimersByTimeAsync(60 * 1000)
+    await flushPromises()
+
+    expect(lastBody()).toMatchObject({ page: 3 })
+    expect(wrapper.getComponent(VPagination).props('modelValue')).toBe(3)
+    expect(wrapper.text()).toContain('Bump dependency 21')
+    expect(wrapper.get('[aria-live="polite"]').text()).toBe('Page 3 of 3, pull requests 21 to 21 of 30')
+  })
+
+  it('says nothing when a refresh fails to move back to the last page', async () => {
+    answer({ data: [action(1)], total_count: 30 })
+    const wrapper = await mountList({ paginated: true, limit: 10 })
+    wrapper.getComponent(VPagination).vm.$emit('update:modelValue', 3)
+    await flushPromises()
+
+    api.apiFetch.mockImplementation(async (path, { body }) => {
+      if (body.page === 3) return { data: [], total_count: 12 }
+      throw Object.assign(new Error('boom'), { status: 503 })
+    })
+    await vi.advanceTimersByTimeAsync(60 * 1000)
+    await flushPromises()
+
+    expect(lastBody()).toMatchObject({ page: 2 })
+    expect(wrapper.find('.pull-requests__page-error').exists()).toBe(false)
+  })
+
+  it('qualifies the count when a filter narrows it', async () => {
+    answer({ data: [action(1)], total_count: 3 })
+    const wrapper = await mountList({ countQualifier: 'in this period' })
+
+    expect(wrapper.get('.pull-requests__count').text()).toBe('3 pull requests in this period')
+  })
+
+  it('links the count when it is given somewhere to go', async () => {
+    answer({ data: [action(1)], total_count: 12 })
+    const wrapper = await mountList({ seeAllLink: '/scm/dashboard' })
+
+    const link = wrapper.findAllComponents(RouterLinkStub).find((stub) => stub.props('to') === '/scm/dashboard')
+    expect(link.text()).toBe('12 pull requests · see all')
+  })
+
+  it('says so when no pull request is waiting', async () => {
+    answer({ data: [], total_count: 0 })
+    const wrapper = await mountList()
+
+    expect(wrapper.text()).toContain('No pull request is waiting.')
+  })
+
+  it('shows the error and retries', async () => {
+    answer(Object.assign(new Error('boom'), { status: 503 }))
+    const wrapper = await mountList()
+
+    expect(wrapper.get('[role="alert"]').text()).toContain('The Udash API is unavailable right now.')
+
+    answer({ data: [action(1)], total_count: 1 })
+    await wrapper.get('[role="alert"] button').trigger('click')
+    await flushPromises()
+
+    expect(wrapper.text()).toContain('Bump dependency 1')
+  })
+})
diff --git a/src/components/PullRequestList.vue b/src/components/PullRequestList.vue
new file mode 100644
index 000000000..1d2efd42a
--- /dev/null
+++ b/src/components/PullRequestList.vue
@@ -0,0 +1,504 @@
+<template>
+  <!-- The actions left open by the latest report of every pipeline, one row per pull
+       request however many pipelines feed it. Each row leads with the worst result among
+       those pipelines, so a pull request fed by a failing pipeline stands out unopened. -->
+  <section class="pull-requests" :aria-labelledby="headingId">
+    <header class="pull-requests__header">
+      <component :is="headingTag" :id="headingId" :class="headingClass">
+        <v-icon :icon="openActionIcon" color="result-waiting" size="small" aria-hidden="true"></v-icon>
+        {{ title }}
+      </component>
+      <component
+        :is="seeAllLink ? 'router-link' : 'span'"
+        v-if="total > 0"
+        :to="seeAllLink || undefined"
+        class="pull-requests__count text-body-small"
+      >
+        <span class="text-mono">{{ total.toLocaleString() }}</span>
+        {{ countLabel }}
+      </component>
+    </header>
+
+    <LoadError v-if="error" compact :message="error" @retry="load" />
+
+    <div v-else-if="rows === null" class="pull-requests__list" aria-busy="true">
+      <v-skeleton-loader v-for="n in Math.min(limit, 3)" :key="n" type="list-item-two-line" />
+    </div>
+
+    <p v-else-if="rows.length === 0" class="pull-requests__empty text-body-medium text-medium-emphasis">
+      {{ empty }}
+    </p>
+
+    <ul v-else class="pull-requests__list" :aria-busy="loading">
+      <li v-for="(row, index) in rows" :key="row.key" class="pull-requests__item">
+        <v-icon
+          :icon="getStatusIcon(row.worst)"
+          :color="getStatusColor(row.worst)"
+          size="small"
+          class="pull-requests__icon"
+          aria-hidden="true"
+        ></v-icon>
+        <div class="pull-requests__body">
+          <a
+            v-if="row.url"
+            :href="row.url"
+            target="_blank"
+            rel="noopener noreferrer"
+            class="pull-requests__title text-body-medium"
+            :class="{ 'text-mono': !row.hasTitle }"
+          >
+            {{ row.title }}<span class="d-sr-only"> (opens the {{ row.noun }} in a new tab)</span>
+            <v-icon icon="mdi-open-in-new" size="x-small" class="pull-requests__external" aria-hidden="true"></v-icon>
+          </a>
+          <!-- A link which is not http(s) is still a pull request waiting, so it is listed and
+               counted, only not offered as a link. -->
+          <span
+            v-else
+            class="pull-requests__title text-body-medium"
+            :class="{ 'text-mono': !row.hasTitle }"
+          >{{ row.title }}</span>
+          <div class="pull-requests__meta text-body-small text-medium-emphasis">
+            <span v-if="row.repository" class="text-mono">{{ row.repository }}<template v-if="row.branch"> · {{ row.branch }}</template></span>
+            <span class="text-mono" :title="formatAbsoluteDate(row.updatedAt)">{{ toRelativeTime(row.updatedAt, now) }}</span>
+          </div>
+
+          <button
+            v-if="row.pipelines.length > 1"
+            type="button"
+            class="pull-requests__toggle text-body-small"
+            :aria-expanded="String(!!expanded[row.key])"
+            :aria-controls="pipelinesId(index)"
+            :aria-label="`${row.pipelines.length} pipelines feeding ${row.title}: ${row.tallyText}`"
+            @click="expanded[row.key] = !expanded[row.key]"
+          >
+            <span
+              v-for="entry in row.tally"
+              :key="entry.result"
+              :class="entry.textClass"
+              class="pull-requests__tally"
+            >{{ entry.result }} {{ entry.count }}</span>
+            <span class="pull-requests__toggle-label">{{ row.pipelines.length }} pipelines</span>
+            <v-icon icon="$expand" size="x-small" class="pull-requests__chevron" aria-hidden="true"></v-icon>
+          </button>
+
+          <ul
+            v-show="row.pipelines.length === 1 || expanded[row.key]"
+            :id="pipelinesId(index)"
+            class="pull-requests__pipelines text-body-small"
+            :aria-label="`Pipelines feeding ${row.title}`"
+          >
+            <li
+              v-for="pipeline in row.pipelines"
+              :key="pipeline.id"
+              :class="{ 'pull-requests__pipeline--unmatched': !pipeline.matches }"
+            >
+              <v-icon
+                :icon="getStatusIcon(pipeline.result)"
+                :color="getStatusColor(pipeline.result)"
+                size="x-small"
+                aria-hidden="true"
+              ></v-icon>
+              <span class="d-sr-only">{{ getPipelineResultText(pipeline.result) }}:</span>
+              <router-link :to="`/pipeline/reports/${pipeline.id}`">{{ pipeline.name || 'Unnamed pipeline' }}</router-link>
+            </li>
+          </ul>
+        </div>
+      </li>
+    </ul>
+
+    <v-pagination
+      v-if="paginated && rows !== null && pageCount > 1"
+      :model-value="page"
+      :length="pageCount"
+      :total-visible="xs ? 3 : 5"
+      density="compact"
+      class="pull-requests__pagination"
+      @update:model-value="goTo"
+    ></v-pagination>
+
+    <p v-if="pageError" class="pull-requests__page-error text-body-small text-error" role="status">
+      {{ pageError }}
+    </p>
+
+    <p class="d-sr-only" aria-live="polite">{{ announcement }}</p>
+  </section>
+</template>
+
+<script setup>
+import { computed, reactive, ref, watch } from 'vue'
+import { useDisplay } from 'vuetify'
+import LoadError from '@/components/LoadError.vue'
+import { apiFetch, describeLoadError } from '@/composables/api'
+import { filterRequestBody } from '@/composables/filter'
+import { formatAbsoluteDate, toRelativeTime } from '@/composables/date'
+import { extractGitURLInfo } from '@/composables/git'
+import { getPipelineResultText, getStatusColor, getStatusIcon, OPEN_ACTION_ICON } from '@/composables/status'
+import { markUpdated, useLiveRefresh, useNow } from '@/composables/live'
+import { safeHttpUrl, shortRepository } from '@/composables/url'
+
+const props = defineProps({
+  title: { type: String, default: 'Waiting to be merged' },
+  headingTag: { type: String, default: 'h2' },
+  headingId: { type: String, default: 'pull-requests' },
+  // headingClass lets a page match the list's heading to its other section headings.
+  headingClass: { type: String, default: 'text-title-medium font-weight-bold' },
+  // filter is the filter the dashboard or the reports page emits. Its date range, labels,
+  // results and scm apply.
+  filter: { type: Object, default: null },
+  // limit is how many pull requests a page holds.
+  limit: { type: Number, default: 5 },
+  // paginated pages through every pull request. Without it, only the first page shows.
+  paginated: { type: Boolean, default: false },
+  seeAllLink: { type: [Object, String], default: null },
+  // countQualifier follows the count, such as "in this period" when a filter narrows it.
+  countQualifier: { type: String, default: '' },
+  empty: { type: String, default: 'No pull request is waiting.' },
+})
+
+// The order a triager reads results in: what failed, what changed, what nobody can tell,
+// what was skipped, and last what is fine.
+const SEVERITY = ['✗', '⚠', '?', '-', '✔']
+const TALLY_CLASSES = {
+  '✗': 'text-error',
+  '⚠': 'text-warning',
+  '?': 'text-result-unknown',
+  '-': 'text-result-skipped',
+  '✔': 'text-medium-emphasis',
+}
+
+const openActionIcon = OPEN_ACTION_ICON
+const now = useNow()
+const { xs } = useDisplay()
+
+const rows = ref(null)
+const total = ref(0)
+const error = ref(null)
+const loading = ref(false)
+const page = ref(1)
+const announcement = ref('')
+const pageError = ref('')
+const expanded = reactive({})
+
+const pageCount = computed(() => Math.ceil(total.value / props.limit))
+const countLabel = computed(() => [
+  total.value === 1 ? 'pull request' : 'pull requests',
+  props.countQualifier,
+  props.seeAllLink ? '· see all' : '',
+].filter(Boolean).join(' '))
+
+let generation = 0
+// The page the reader asked for, until its request settled. A refresh meanwhile loads
+// it too, so it does not drop the page the reader is waiting on.
+let requested = null
+
+function severity(result) {
+  const rank = SEVERITY.indexOf(result)
+  return rank === -1 ? SEVERITY.indexOf('?') : rank
+}
+
+function pipelinesId(index) {
+  return `${props.headingId}-pipelines-${index}`
+}
+
+function toRow(action) {
+  const url = safeHttpUrl(action.url)
+  const results = props.filter?.results || []
+  const pipelines = (action.pipelines || [])
+    .map((pipeline) => ({
+      ...pipeline,
+      // Without a result filter every pipeline matches. With one, only those it kept.
+      matches: results.length === 0 || results.includes(pipeline.result),
+    }))
+    .sort((a, b) => severity(a.result) - severity(b.result))
+
+  const counts = {}
+  pipelines.forEach((pipeline) => {
+    const result = SEVERITY.includes(pipeline.result) ? pipeline.result : '?'
+    counts[result] = (counts[result] || 0) + 1
+  })
+  const tally = SEVERITY
+    .filter((result) => counts[result])
+    .map((result) => ({ result, count: counts[result], textClass: TALLY_CLASSES[result] }))
+
+  return {
+    key: action.url,
+    // url is empty when the link is not http(s), which the row then shows as plain text.
+    url,
+    hasTitle: Boolean(action.title),
+    title: action.title || String(action.url || '').replace(/^https?:\/\//i, ''),
+    noun: extractGitURLInfo(url)?.provider === 'gitlab' ? 'merge request' : 'pull request',
+    repository: shortRepository(action.repository),
+    branch: action.branch || '',
+    updatedAt: action.updated_at,
+    pipelines,
+    worst: pipelines[0]?.result,
+    tally,
+    tallyText: tally.map((entry) => `${entry.count} ${getPipelineResultText(entry.result).toLowerCase()}`).join(', '),
+  }
+}
+
+// load fetches a page, the one the reader asked for or else the current one. The page
+// only becomes the current one once it arrived, so a page that fails to load leaves the
+// pager on the rows shown. announce says whether the reader asked for that page, which
+// warrants telling screen readers what it holds, or that it could not be loaded.
+async function load({ target = requested ?? page.value, announce = requested !== null } = {}) {
+  error.value = null
+  // Only a page the reader asks for replaces the message: a background refresh, even one
+  // that succeeds, still leaves the pager short of the page that could not be loaded.
+  if (announce) pageError.value = ''
+  loading.value = true
+  // A slow response must not overwrite the one from a later refresh.
+  const current = ++generation
+
+  try {
+    const data = await apiFetch('/pipeline/actions/search', {
+      method: 'POST',
+      body: {
+        ...filterRequestBody(props.filter),
+        ...(props.filter?.scmid ? { scmid: props.filter.scmid } : {}),
+        limit: props.limit,
+        page: target,
+      },
+    })
+    if (current !== generation) return
+
+    total.value = data.total_count || 0
+    // A refresh can leave the page past the last one, once pull requests got merged.
+    if ((data.data || []).length === 0 && total.value > 0 && target > pageCount.value) {
+      load({ target: pageCount.value, announce })
+      return
+    }
+
+    requested = null
+    page.value = target
+    rows.value = (data.data || []).map(toRow)
+    markUpdated()
+
+    if (announce) {
+      const first = (page.value - 1) * props.limit + 1
+      const last = first + rows.value.length - 1
+      announcement.value = `Page ${page.value} of ${pageCount.value}, pull requests ${first} to ${last} of ${total.value}`
+    }
+  } catch (loadError) {
+    if (current !== generation) return
+    requested = null
+    // A background refresh that fails keeps what is already on screen. A page the reader
+    // asked for says it could not be loaded, next to the pager still on the rows shown.
+    if (rows.value === null) {
+      error.value = describeLoadError(loadError, 'the pull requests')
+    } else if (announce) {
+      pageError.value = `Page ${target} could not be loaded. ${describeLoadError(loadError, 'it')}`
+    }
+  } finally {
+    if (current === generation) loading.value = false
+  }
+}
+
+// goTo moves to a page the reader asked for, so what it now holds is announced.
+function goTo(nextPage) {
+  requested = nextPage
+  load()
+}
+
+watch(() => props.filter, () => {
+  rows.value = null
+  total.value = 0
+  page.value = 1
+  requested = null
+  pageError.value = ''
+  load()
+}, { deep: true })
+
+load()
+useLiveRefresh(() => load())
+</script>
+
+<style scoped>
+.pull-requests__header {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 4px 12px;
+  margin-bottom: 8px;
+}
+
+.pull-requests__header h2,
+.pull-requests__header h3 {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin: 0;
+}
+
+.pull-requests__count {
+  color: rgb(var(--v-theme-on-surface));
+  opacity: var(--v-medium-emphasis-opacity);
+  text-decoration: none;
+}
+
+a.pull-requests__count:hover,
+a.pull-requests__count:focus-visible {
+  opacity: 1;
+  text-decoration: underline;
+}
+
+.pull-requests__list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  border: 1px solid rgba(var(--v-border-color), var(--v-border-opacity));
+  border-radius: 4px;
+  background: rgb(var(--v-theme-surface));
+}
+
+.pull-requests__list[aria-busy="true"] {
+  opacity: 0.7;
+}
+
+/* Same rhythm as the failing column next to it on the home page. */
+.pull-requests__item {
+  display: flex;
+  align-items: flex-start;
+  gap: 12px;
+  padding: 10px 8px 10px 16px;
+}
+
+.pull-requests__item + .pull-requests__item {
+  border-top: 1px solid rgba(var(--v-border-color), var(--v-border-opacity));
+}
+
+.pull-requests__icon {
+  flex-shrink: 0;
+  margin-top: 2px;
+}
+
+.pull-requests__body {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+.pull-requests__title {
+  color: inherit;
+  font-weight: 500;
+  text-decoration: none;
+  overflow-wrap: anywhere;
+}
+
+.pull-requests__title:hover,
+.pull-requests__title:focus-visible {
+  text-decoration: underline;
+}
+
+.pull-requests__external {
+  margin-left: 2px;
+  opacity: var(--v-medium-emphasis-opacity);
+}
+
+.pull-requests__meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 2px 12px;
+  margin-top: 2px;
+}
+
+/* A neutral control: the tally inside it carries the colour, the button itself must
+   not read as one more status. */
+.pull-requests__toggle {
+  display: inline-flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 2px 8px;
+  min-height: 24px;
+  margin-top: 4px;
+  padding: 2px 0;
+  border: 0;
+  background: none;
+  color: rgb(var(--v-theme-on-surface));
+  cursor: pointer;
+}
+
+.pull-requests__toggle-label {
+  text-decoration: underline;
+  text-underline-offset: 2px;
+  text-decoration-color: rgba(var(--v-theme-on-surface), 0.4);
+}
+
+.pull-requests__toggle:hover .pull-requests__toggle-label,
+.pull-requests__toggle:focus-visible .pull-requests__toggle-label {
+  text-decoration-color: currentColor;
+}
+
+.pull-requests__tally {
+  font-weight: 600;
+  white-space: nowrap;
+}
+
+.pull-requests__chevron {
+  transition: transform 150ms ease-out;
+}
+
+.pull-requests__toggle[aria-expanded="true"] .pull-requests__chevron {
+  transform: rotate(180deg);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .pull-requests__chevron {
+    transition: none;
+  }
+}
+
+@media (pointer: coarse) {
+  .pull-requests__toggle {
+    min-height: 44px;
+  }
+}
+
+.pull-requests__pipelines {
+  list-style: none;
+  margin: 6px 0 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.pull-requests__pipelines li {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  min-width: 0;
+}
+
+.pull-requests__pipelines a {
+  color: inherit;
+  overflow-wrap: anywhere;
+}
+
+.pull-requests__pipeline--unmatched {
+  opacity: var(--v-medium-emphasis-opacity);
+}
+
+.pull-requests__empty {
+  margin: 0;
+  padding: 16px;
+  border: 1px dashed rgba(var(--v-border-color), var(--v-border-opacity));
+  border-radius: 4px;
+}
+
+
+
+/* Page numbers start under the list rather than floating in the middle of it. */
+.pull-requests__pagination {
+  margin-top: 8px;
+}
+
+.pull-requests__page-error {
+  margin: 4px 0 0;
+}
+
+.pull-requests__pagination :deep(.v-pagination__list) {
+  justify-content: flex-start;
+}
+
+</style>
diff --git a/src/components/TodayQueue.spec.js b/src/components/TodayQueue.spec.js
index f892ea049..03a5b7f0f 100644
--- a/src/components/TodayQueue.spec.js
+++ b/src/components/TodayQueue.spec.js
@@ -23,10 +23,10 @@ function report(id, overrides = {}) {
   }
 }
 
-// Answers the failing queue and the waiting queue from what each request asks for.
+// Answers the failing queue and the waiting queue from the endpoint each one asks.
 function answer({ failing, waiting }) {
-  api.apiFetch.mockImplementation(async (path, { body }) => {
-    const result = body.open_action ? waiting : failing
+  api.apiFetch.mockImplementation(async (path) => {
+    const result = path === '/pipeline/actions/search' ? waiting : failing
     if (result instanceof Error) {
       throw result
     }
@@ -57,14 +57,14 @@ afterEach(() => {
 })
 
 describe('TodayQueue', () => {
-  it('asks for the latest failing reports and the latest ones with an open pull request', async () => {
+  it('asks for the latest failing reports and the open pull requests', async () => {
     answer({ failing: { data: [], total_count: 0 }, waiting: { data: [], total_count: 0 } })
     await mountQueue()
 
     const bodies = api.apiFetch.mock.calls.map(([path, { method, body }]) => ({ path, method, body }))
     expect(bodies).toEqual([
       { path: '/pipeline/reports/search', method: 'POST', body: { limit: 5, page: 1, latest: true, results: ['✗'] } },
-      { path: '/pipeline/reports/search', method: 'POST', body: { limit: 5, page: 1, latest: true, open_action: true } },
+      { path: '/pipeline/actions/search', method: 'POST', body: { limit: 5, page: 1 } },
     ])
   })
 
@@ -92,18 +92,32 @@ describe('TodayQueue', () => {
     })
   })
 
-  it('offers the pull request of a waiting pipeline', async () => {
-    const waiting = report('w', {
-      Result: '✔',
-      Report: { Targets: {}, Actions: { a1: { actionUrl: 'https://github.com/updatecli/udash/pull/7' } } },
-    })
+  it('lists each pull request once, linked to the dashboard', async () => {
+    const waiting = {
+      url: 'https://github.com/updatecli/udash/pull/7',
+      title: 'Bump udash',
+      repository: 'https://github.com/updatecli/udash.git',
+      branch: 'main',
+      updated_at: '2026-09-22T11:57:00Z',
+      pipelines: [
+        { id: 'p1', name: 'First manifest', result: '✔', updated_at: '2026-09-22T11:57:00Z' },
+        { id: 'p2', name: 'Second manifest', result: '⚠', updated_at: '2026-09-22T11:50:00Z' },
+      ],
+    }
     answer({ failing: { data: [], total_count: 0 }, waiting: { data: [waiting], total_count: 1 } })
     const wrapper = await mountQueue()
 
-    const button = column(wrapper, 'waiting').get('a[target="_blank"]')
-    expect(button.attributes('href')).toBe('https://github.com/updatecli/udash/pull/7')
-    expect(button.attributes('aria-label')).toBe('Open the pull request for Bump w (opens in a new tab)')
-    expect(column(wrapper, 'waiting').text()).toContain('1 pull request · see all')
+    const items = column(wrapper, 'waiting').findAll('.pull-requests__item')
+    expect(items).toHaveLength(1)
+    expect(items[0].get('a[target="_blank"]').attributes('href')).toBe('https://github.com/updatecli/udash/pull/7')
+    expect(items[0].text()).toContain('2 pipelines')
+
+    const link = column(wrapper, 'waiting').findComponent(RouterLinkStub)
+    expect(link.text()).toBe('1 pull request · see all')
+    expect(decodeFilterState(link.props('to').query.filter)).toEqual({
+      dateRange: [0, 53],
+      selectedOpenAction: 'open',
+    })
   })
 
   it('says so when a queue is empty', async () => {
diff --git a/src/components/TodayQueue.vue b/src/components/TodayQueue.vue
index 36edaf2d6..8fb216fbf 100644
--- a/src/components/TodayQueue.vue
+++ b/src/components/TodayQueue.vue
@@ -1,46 +1,40 @@
 <template>
-  <!-- What needs a human right now, from the latest report of every pipeline: the ones
-       failing and the ones whose change is waiting in an open pull request. -->
+  <!-- What needs a human right now: the pipelines whose latest report is failing, and the
+       pull requests still waiting to be merged. -->
   <div class="today-queue">
-    <section
-      v-for="queue in queues"
-      :key="queue.key"
-      class="today-queue__column"
-      :aria-labelledby="`queue-${queue.key}`"
-    >
+    <section class="today-queue__column" aria-labelledby="queue-failing">
       <header class="today-queue__header">
-        <h3 :id="`queue-${queue.key}`" class="text-title-medium font-weight-bold">
-          <v-icon v-if="queue.icon" :icon="queue.icon" :color="queue.color" size="small" aria-hidden="true"></v-icon>
-          <span v-else :class="`text-${queue.color}`" aria-hidden="true">{{ queue.glyph }}</span>
-          {{ queue.title }}
+        <h3 id="queue-failing" class="text-title-medium font-weight-bold">
+          <span class="text-error" aria-hidden="true">✗</span>
+          Failing
         </h3>
         <router-link
-          v-if="state[queue.key].total > 0"
-          :to="queue.link"
+          v-if="failing.total > 0"
+          :to="failingLink"
           class="today-queue__count text-body-small"
         >
-          <span class="text-mono">{{ state[queue.key].total.toLocaleString() }}</span>
-          {{ queue.noun(state[queue.key].total) }} · see all
+          <span class="text-mono">{{ failing.total.toLocaleString() }}</span>
+          {{ failing.total === 1 ? 'pipeline' : 'pipelines' }} · see all
         </router-link>
       </header>
 
       <LoadError
-        v-if="state[queue.key].error"
+        v-if="failing.error"
         compact
-        :message="state[queue.key].error"
-        @retry="load(queue)"
+        :message="failing.error"
+        @retry="loadFailing"
       />
 
-      <div v-else-if="state[queue.key].rows === null" class="today-queue__list" aria-busy="true">
+      <div v-else-if="failing.rows === null" class="today-queue__list" aria-busy="true">
         <v-skeleton-loader v-for="n in 3" :key="n" type="list-item-two-line" />
       </div>
 
-      <p v-else-if="state[queue.key].rows.length === 0" class="today-queue__empty text-body-medium text-medium-emphasis">
-        {{ queue.empty }}
+      <p v-else-if="failing.rows.length === 0" class="today-queue__empty text-body-medium text-medium-emphasis">
+        No pipeline is failing.
       </p>
 
       <ul v-else class="today-queue__list">
-        <li v-for="row in state[queue.key].rows" :key="row.id" class="today-queue__item">
+        <li v-for="row in failing.rows" :key="row.id" class="today-queue__item">
           <v-icon
             :icon="getStatusIcon(row.result)"
             :color="getStatusColor(row.result)"
@@ -57,126 +51,87 @@
               <span class="text-mono" :title="formatAbsoluteDate(row.updatedAt)">{{ toRelativeTime(row.updatedAt, now) }}</span>
             </div>
           </div>
-          <v-btn
-            v-if="row.actionUrl"
-            :href="row.actionUrl"
-            target="_blank"
-            rel="noopener noreferrer"
-            :icon="openActionIcon"
-            variant="text"
-            size="small"
-            :aria-label="`Open the pull request for ${row.name} (opens in a new tab)`"
-          ></v-btn>
         </li>
       </ul>
     </section>
+
+    <PullRequestList
+      class="today-queue__column"
+      title="Waiting to be merged"
+      heading-tag="h3"
+      heading-id="queue-waiting"
+      :limit="QUEUE_SIZE"
+      :see-all-link="waitingLink"
+    />
   </div>
 </template>
 
 <script setup>
 import { reactive } from 'vue'
 import LoadError from '@/components/LoadError.vue'
+import PullRequestList from '@/components/PullRequestList.vue'
 import { apiFetch, describeLoadError } from '@/composables/api'
 import { encodeFilterState } from '@/composables/filter'
 import { formatAbsoluteDate, toRelativeTime } from '@/composables/date'
-import { getStatusColor, getStatusIcon, OPEN_ACTION_ICON } from '@/composables/status'
+import { getStatusColor, getStatusIcon } from '@/composables/status'
 import { getMaxHistoryDays } from '@/composables/runtime'
 import { markUpdated, useLiveRefresh, useNow } from '@/composables/live'
+import { shortRepository } from '@/composables/url'
 
 const QUEUE_SIZE = 5
 // The dashboard link spans the whole history the instance serves: "latest" reports can
 // be older than the dashboard's default window of one day.
 const FULL_RANGE = [0, 23 + getMaxHistoryDays()]
 
-const openActionIcon = OPEN_ACTION_ICON
-const now = useNow()
+const failingLink = { path: '/scm/dashboard', query: { filter: encodeFilterState({ dateRange: FULL_RANGE, selectedResults: ['✗'] }) } }
+const waitingLink = { path: '/scm/dashboard', query: { filter: encodeFilterState({ dateRange: FULL_RANGE, selectedOpenAction: 'open' }) } }
 
-const queues = [
-  {
-    key: 'failing',
-    title: 'Failing',
-    glyph: '✗',
-    color: 'error',
-    body: { results: ['✗'] },
-    noun: (count) => (count === 1 ? 'pipeline' : 'pipelines'),
-    empty: 'No pipeline is failing.',
-    link: { path: '/scm/dashboard', query: { filter: encodeFilterState({ dateRange: FULL_RANGE, selectedResults: ['✗'] }) } },
-  },
-  {
-    key: 'waiting',
-    title: 'Waiting to be merged',
-    icon: OPEN_ACTION_ICON,
-    color: 'result-waiting',
-    body: { open_action: true },
-    noun: (count) => (count === 1 ? 'pull request' : 'pull requests'),
-    empty: 'No pull request is waiting.',
-    link: { path: '/scm/dashboard', query: { filter: encodeFilterState({ dateRange: FULL_RANGE, selectedOpenAction: 'open' }) } },
-  },
-]
+const now = useNow()
 
-const state = reactive(Object.fromEntries(queues.map((queue) => [queue.key, { rows: null, total: 0, error: null }])))
+const failing = reactive({ rows: null, total: 0, error: null })
 
-const generations = {}
+let generation = 0
 
 function toRow(report) {
   const targets = Object.values(report.Report?.Targets || {})
   const scm = targets.find((target) => target?.Scm?.URL)?.Scm
-  const action = Object.values(report.Report?.Actions || {}).find((item) => item?.actionUrl)
 
   return {
     id: report.ID,
     name: report.Name || 'Unnamed report',
     result: report.Result,
     updatedAt: report.UpdatedAt,
-    repository: scm?.URL?.replace(/^https?:\/\/[^/]+\//, '').replace(/\.git$/, '') || '',
+    repository: shortRepository(scm?.URL),
     branch: scm?.Branch?.Source || '',
-    actionUrl: safeHttpUrl(action?.actionUrl),
   }
 }
 
-// safeHttpUrl keeps a link only when it is http or https, so a report cannot slip a
-// javascript: URL into the page.
-function safeHttpUrl(value) {
-  try {
-    const url = new URL(value)
-    return url.protocol === 'http:' || url.protocol === 'https:' ? url.href : ''
-  } catch {
-    return ''
-  }
-}
-
-async function load(queue) {
-  const entry = state[queue.key]
-  entry.error = null
+async function loadFailing() {
+  failing.error = null
   // A slow response must not overwrite the one from a later refresh.
-  const generation = (generations[queue.key] || 0) + 1
-  generations[queue.key] = generation
+  const current = ++generation
 
   try {
     const data = await apiFetch('/pipeline/reports/search', {
       method: 'POST',
-      body: { limit: QUEUE_SIZE, page: 1, latest: true, ...queue.body },
+      body: { limit: QUEUE_SIZE, page: 1, latest: true, results: ['✗'] },
     })
-    if (generations[queue.key] !== generation) return
+    if (current !== generation) return
 
-    entry.rows = (data.data || data.reports || []).map(toRow)
-    entry.total = data.total_count || 0
+    failing.rows = (data.data || data.reports || []).map(toRow)
+    failing.total = data.total_count || 0
     markUpdated()
   } catch (error) {
-    if (generations[queue.key] !== generation) return
+    if (current !== generation) return
     // A background refresh that fails keeps what is already on screen.
-    if (entry.rows === null) {
-      entry.error = describeLoadError(error, `the ${queue.title.toLowerCase()} pipelines`)
+    if (failing.rows === null) {
+      failing.error = describeLoadError(error, 'the failing pipelines')
     }
   }
 }
 
-function loadAll() {
-  queues.forEach(load)
-}
-
-loadAll()
-useLiveRefresh(loadAll)
+loadFailing()
+useLiveRefresh(loadFailing)
 </script>
 
 <style scoped>
diff --git a/src/components/pipeline/activityChart.vue b/src/components/pipeline/activityChart.vue
index e94427c6e..dd6a5c20c 100644
--- a/src/components/pipeline/activityChart.vue
+++ b/src/components/pipeline/activityChart.vue
@@ -1,18 +1,18 @@
 <template>
-  <!-- While the first request is in flight we only reserve the plot height, so the
-       host does not have to know anything about the loading state. -->
   <div
     v-if="loading && !summary"
     class="d-flex align-center justify-center"
     :style="{ height }"
   >
+    <!-- While the first request is in flight we only reserve the plot height, so the
+         host does not have to know anything about the loading state. -->
     <v-progress-circular indeterminate color="primary" size="32" />
   </div>
-
-  <!-- Nothing is rendered when the request failed or returned no report at all:
-       a host page stays exactly as it would be without this component. -->
   <div v-else-if="hasData" class="activity-chart" :class="{ 'activity-chart--refreshing': loading }">
-    <!-- We show counts instead of a success rate. A change Updatecli applied is neither
+    <!-- Nothing is rendered when the request failed or returned no report at all:
+         a host page stays exactly as it would be without this component.
+
+         We show counts instead of a success rate. A change Updatecli applied is neither
          a success nor a failure, and a percentage would have to count it as one. -->
     <p v-if="showStats" class="activity-stats text-body-medium text-medium-emphasis mb-3">
       <span>
@@ -28,14 +28,12 @@
       <Bar :data="chartData" :options="chartOptions" />
     </div>
   </div>
-
-  <!-- A refused request is reported where the plot would be. Everything else still
-       renders nothing, so a host page stays exactly as it would be without this
-       component. -->
   <p v-else-if="error && compact" class="text-body-small text-medium-emphasis mb-0">
+    <!-- A refused request is reported where the plot would be. Everything else still
+         renders nothing, so a host page stays exactly as it would be without this
+         component. -->
     {{ error }}
   </p>
-
   <LoadError
     v-else-if="error"
     compact
@@ -47,6 +45,10 @@
 </template>
 
 <script>
+// The template keeps no comment before or between its root branches. A dev build keeps
+// template comments, so one there turns the rendered root into a fragment, and the
+// <Transition> of a v-lazy host (the dashboard strips) leaves it stuck at opacity 0.
+// Each branch documents itself from the inside instead.
 import { Bar } from 'vue-chartjs'
 
 import {
diff --git a/src/components/pipeline/reports.vue b/src/components/pipeline/reports.vue
index 5f6e7db49..0eb417fe1 100644
--- a/src/components/pipeline/reports.vue
+++ b/src/components/pipeline/reports.vue
@@ -22,66 +22,6 @@
     </v-container>
 
     <v-container class="pa-0" v-if="pipelines.length > 0 && !loadError">
-      <v-row>
-        <v-col
-            cols="12"
-            lg="6"
-            v-if="actionURLs && actionURLs.length > 0"
-          >
-          <div class="mb-3">
-            <h3 class="text-title-medium d-flex align-center mb-2">
-              Open pull requests
-            </h3>
-            <p class="text-body-small text-medium-emphasis mb-0">
-              {{ actionURLs.length === 1 ? 'Opened by these pipelines and still waiting to be merged.' : `${actionURLs.length} opened by these pipelines and still waiting to be merged.` }}
-            </p>
-          </div>
-
-          <!-- Actions card -->
-          <v-card flat class="mb-4 action-summary-card">
-            <v-card-text class="pa-0">
-              <v-list density="compact" class="py-0">
-                <v-list-item
-                  v-for="(action, index) in actionURLs"
-                  :key="index"
-                  :href="action.url"
-                  target="_blank"
-                  rel="noopener noreferrer"
-                  class="action-list-item"
-                >
-                  <template v-slot:prepend>
-                    <v-avatar size="32" class="mr-3">
-                      <v-icon size="18">
-                        {{ getActionProviderIcon(action.url) }}
-                      </v-icon>
-                    </v-avatar>
-                  </template>
-
-                  <v-list-item-title class="text-body-medium font-weight-medium">
-                    {{ action.title }}
-                  </v-list-item-title>
-
-                  <v-list-item-subtitle class="text-body-small">
-                    {{ getProviderName(action.url) }}
-                  </v-list-item-subtitle>
-
-                  <template v-slot:append>
-                    <v-icon size="small" class="text-medium-emphasis" aria-label="Opens in a new tab">
-                      mdi-open-in-new
-                    </v-icon>
-                  </template>
-
-                  <!-- Add divider except for last item -->
-                  <template v-if="index < actionURLs.length - 1">
-                    <v-divider class="my-2"></v-divider>
-                  </template>
-                </v-list-item>
-              </v-list>
-            </v-card-text>
-          </v-card>
-        </v-col>
-      </v-row>
-
       <v-row>
         <v-col
             cols="12"
@@ -224,7 +164,6 @@ export default {
   },
 
   data: () => ({
-    actionURLs: [], // Changed from {} to []
     openActionIcon: OPEN_ACTION_ICON,
     openActionColor: OPEN_ACTION_COLOR,
     pipelinesHeaders: [
@@ -276,15 +215,6 @@ export default {
     },
 
 
-    // getProviderName returns the provider name for the subtitle.
-    getProviderName(url) {
-      const info = extractGitURLInfo(url)
-      if (info?.provider) {
-        return info.provider.charAt(0).toUpperCase() + info.provider.slice(1)
-      }
-      return 'External link'
-    },
-
     getActionTooltipText(action) {
       return `${action.title} (${action.url})`
     },
@@ -322,29 +252,6 @@ export default {
       return actionURLs
     },
 
-    getPipelinesActionsURL(){
-      let localActionURLs = []
-      // Remove duplicates by tracking unique URL+title combinations
-      const seen = new Set()
-
-      this.pipelines.forEach(pipeline => {
-        if (pipeline.Report && pipeline.Report.Actions) {
-          for (const [action] of Object.entries(pipeline.Report.Actions)) {
-            const actionURL = pipeline.Report.Actions[action].actionUrl
-            const title = pipeline.Report.Actions[action].title
-            if (actionURL && title) {
-              const key = `${actionURL}-${title}`
-              if (!seen.has(key)) {
-                seen.add(key)
-                localActionURLs.push({"url": actionURL, title: title})
-              }
-            }
-          }
-        }
-      });
-
-      this.actionURLs = localActionURLs
-    },
 
     // A silent refresh leaves the page's loading overlay alone and keeps the rows on
     // screen if it fails.
@@ -425,7 +332,6 @@ export default {
         if (requestId !== this.requestId) return
 
         this.pipelines = data.data || data.reports || [];
-        this.getPipelinesActionsURL()
         this.totalItems = data.total_count || 0;
         this.currentPage = page;
         this.loadError = null;
@@ -484,21 +390,6 @@ export default {
 </script>
 
 <style scoped>
-.action-summary-card {
-  border: 1px solid rgba(var(--v-border-color), var(--v-border-opacity));
-  border-radius: 8px;
-}
-
-.action-list-item {
-  transition: background-color 0.2s ease;
-  border-radius: 4px;
-  margin: 2px 8px;
-}
-
-.action-list-item:hover {
-  background-color: rgba(var(--v-theme-on-surface), 0.04);
-}
-
 .report-name {
   display: inline-block;
   min-width: 12rem;
diff --git a/src/components/scm/_filter.spec.js b/src/components/scm/_filter.spec.js
new file mode 100644
index 000000000..07ad18084
--- /dev/null
+++ b/src/components/scm/_filter.spec.js
@@ -0,0 +1,147 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { flushPromises, mount } from '@vue/test-utils'
+import { FILTER_STORAGE_KEY } from '@/composables/date'
+
+const api = vi.hoisted(() => ({ apiFetch: vi.fn() }))
+
+vi.mock('@/composables/api', async (importOriginal) => ({
+  ...(await importOriginal()),
+  apiFetch: api.apiFetch,
+}))
+
+vi.mock('@/router', () => ({
+  default: {
+    currentRoute: { value: { query: {} } },
+    replace: vi.fn(() => Promise.resolve()),
+  },
+}))
+
+// labels answers the label endpoint: the key list, or the values of the asked key.
+function labels(keys, valuesByKey = {}) {
+  return async (query) => {
+    const key = new URLSearchParams(query.split('?')[1]).get('key')
+    if (key) {
+      return { labels: (valuesByKey[key] || []).map((value) => ({ key, value })) }
+    }
+    return { labels: keys }
+  }
+}
+
+function keyCalls() {
+  return api.apiFetch.mock.calls.map(([query]) => query).filter((query) => query.includes('keyonly=true'))
+}
+
+// The live module keeps its timers and tick at module level, so each mount gets fresh
+// copies and refreshNow comes from the same copy the component subscribed to.
+async function mountFilter() {
+  vi.resetModules()
+  const { default: Filter } = await import('@/components/scm/_filter.vue')
+  const { refreshNow } = await import('@/composables/live')
+  const wrapper = mount(Filter, { props: { showRepositoryBranch: false } })
+  await flushPromises()
+  return { wrapper, refreshNow }
+}
+
+beforeEach(() => {
+  vi.useFakeTimers({ toFake: ['setInterval', 'Date'] })
+  vi.setSystemTime(new Date('2026-09-22T12:00:00Z'))
+})
+
+afterEach(() => {
+  vi.useRealTimers()
+  api.apiFetch.mockReset()
+  localStorage.clear()
+})
+
+describe('PipelineSCMS label lists', () => {
+  it('asks for the window as it stands when the live refresh fires', async () => {
+    api.apiFetch.mockImplementation(labels(['team']))
+    const { refreshNow } = await mountFilter()
+    expect(keyCalls().at(-1)).toContain(encodeURIComponent('2026-09-22 12:00:00+00:00'))
+
+    vi.setSystemTime(new Date('2026-09-22T13:00:00Z'))
+    api.apiFetch.mockImplementation(labels(['team', 'squad']))
+    refreshNow()
+    await flushPromises()
+
+    expect(keyCalls().at(-1)).toContain(encodeURIComponent('2026-09-22 13:00:00+00:00'))
+  })
+
+  it('offers keys first reported after the page loaded', async () => {
+    api.apiFetch.mockImplementation(labels(['team']))
+    const { wrapper, refreshNow } = await mountFilter()
+    expect(wrapper.vm.labelKeys).toEqual(['team'])
+
+    api.apiFetch.mockImplementation(labels(['team', 'squad']))
+    refreshNow()
+    await flushPromises()
+
+    expect(wrapper.vm.labelKeys).toEqual(['team', 'squad'])
+  })
+
+  it('loads the values of a label restored from the saved filter', async () => {
+    localStorage.setItem(FILTER_STORAGE_KEY, JSON.stringify({
+      dateRange: [0, 24],
+      selectedLabels: [{ key: 'team', value: 'core' }],
+    }))
+    api.apiFetch.mockImplementation(labels(['team'], { team: ['core', 'web'] }))
+
+    const { wrapper } = await mountFilter()
+
+    expect(wrapper.vm.getLabelValuesForIndex(0)).toEqual(['core', 'web'])
+  })
+
+  it('keeps the lists it has when a refresh fails', async () => {
+    localStorage.setItem(FILTER_STORAGE_KEY, JSON.stringify({
+      dateRange: [0, 24],
+      selectedLabels: [{ key: 'team', value: 'core' }],
+    }))
+    api.apiFetch.mockImplementation(labels(['team'], { team: ['core'] }))
+    const { wrapper, refreshNow } = await mountFilter()
+
+    const error = vi.spyOn(console, 'error').mockImplementation(() => {})
+    api.apiFetch.mockRejectedValue(new Error('offline'))
+    refreshNow()
+    await flushPromises()
+    error.mockRestore()
+
+    expect(wrapper.vm.labelKeys).toEqual(['team'])
+    expect(wrapper.vm.getLabelValuesForIndex(0)).toEqual(['core'])
+  })
+
+  it('does not keep the lists of the previous range when a refresh fails', async () => {
+    localStorage.setItem(FILTER_STORAGE_KEY, JSON.stringify({
+      dateRange: [0, 24],
+      selectedLabels: [{ key: 'team', value: 'core' }],
+    }))
+    api.apiFetch.mockImplementation(labels(['team'], { team: ['core'] }))
+    const { wrapper } = await mountFilter()
+
+    const error = vi.spyOn(console, 'error').mockImplementation(() => {})
+    api.apiFetch.mockRejectedValue(new Error('offline'))
+    wrapper.vm.dateRange = [0, 2]
+    await wrapper.vm.refreshLabels()
+    await flushPromises()
+    error.mockRestore()
+
+    expect(wrapper.vm.labelKeys).toEqual([])
+    expect(wrapper.vm.getLabelValuesForIndex(0)).toEqual([])
+    wrapper.unmount()
+  })
+
+  it('drops a response that a newer refresh has superseded', async () => {
+    api.apiFetch.mockImplementation(labels(['team']))
+    const { wrapper } = await mountFilter()
+
+    let answerOld
+    api.apiFetch.mockImplementationOnce(() => new Promise((resolve) => { answerOld = resolve }))
+    const older = wrapper.vm.refreshLabels()
+    api.apiFetch.mockImplementation(labels(['squad']))
+    await wrapper.vm.refreshLabels()
+
+    answerOld({ labels: ['stale'] })
+    await older
+
+    expect(wrapper.vm.labelKeys).toEqual(['squad'])
+  })
+})
diff --git a/src/components/scm/_filter.vue b/src/components/scm/_filter.vue
index ae1db3a1c..0c9999728 100644
--- a/src/components/scm/_filter.vue
+++ b/src/components/scm/_filter.vue
@@ -227,6 +227,7 @@ import { apiFetch, describeLoadError } from '@/composables/api';
 import LoadError from '../LoadError.vue';
 import { getMaxHistoryDays } from '@/composables/runtime';
 import { FILTER_STORAGE_KEY, stepToISO } from '@/composables/date';
+import { subscribeRefresh } from '@/composables/live';
 import { PIPELINE_RESULTS, PIPELINE_RESULT_VALUES, OPEN_ACTION_OPTIONS, OPEN_ACTION_VALUES, openActionToQuery } from '@/composables/status';
 import { encodeFilterState, decodeFilterState } from '@/composables/filter';
 
@@ -264,6 +265,8 @@ export default {
     dateRange: [...DEFAULT_DATE_RANGE],  // [start step, end step] by default
     labelKeys: [],
     labelValuesByKey: {},  // Map to store label values for each key
+    labelsRequest: 0,  // Bumped by every label refresh, so older responses can be dropped
+    labelsSteps: null,  // The dateRange the label lists were loaded for, as "newest,oldest"
     selectedLabels: [{ key: null, value: null }],  // Array of label selections
     selectedResults: [],  // Pipeline results to keep, empty meaning all of them
     pipelineResults: PIPELINE_RESULTS,
@@ -276,7 +279,14 @@ export default {
     scmLoadError: null,
   }),
 
+  // The label lists follow the live refresh like the reports and charts they filter.
+  // Without it a page left open never offered a label first reported after it loaded.
+  mounted() {
+    this.stopRefresh = subscribeRefresh(() => this.refreshLabels())
+  },
+
   beforeUnmount() {
+    this.stopRefresh?.();
     this.cancelAutoUpdate();
     clearTimeout(this.debounceTimer);
   },
@@ -388,17 +398,6 @@ export default {
       },
     },
 
-    // dateRange[0] is the step closest to now and dateRange[1] the furthest back, so
-    // the range starts at the second entry. The API also accepts the two in the wrong
-    // order, which is why this code read them backwards for a long time without
-    // breaking anything.
-    formattedStartTime() {
-      return stepToISO(this.dateRange[1])
-    },
-
-    formattedEndTime() {
-      return stepToISO(this.dateRange[0])
-    },
 
     // maxDateStep is how far the slider reaches. It comes from the instance's
     // configured history window.
@@ -539,41 +538,98 @@ export default {
       return this.restrictedSCM != ""
     },
 
-    async getLabelKeys() {
-      try {
-        const query = `/pipeline/labels?keyonly=true&start_time=${encodeURIComponent(this.formattedStartTime)}&end_time=${encodeURIComponent(this.formattedEndTime)}`;
+    // timeWindow turns dateRange into API timestamps. It reads the clock on every call:
+    // a computed would cache "now" until the range changed, so a page left open kept
+    // asking for the window it was loaded with.
+    //
+    // dateRange[0] is the step closest to now and dateRange[1] the furthest back, so
+    // the range starts at the second entry. The API also accepts the two in the wrong
+    // order, which is why this code read them backwards for a long time without
+    // breaking anything.
+    timeWindow() {
+      return {
+        start: stepToISO(this.dateRange[1]),
+        end: stepToISO(this.dateRange[0]),
+      }
+    },
 
-        const data = await apiFetch(query);
-        this.labelKeys = data.labels || [];
+    selectedLabelKeys() {
+      return [...new Set(this.selectedLabels.map((label) => label.key).filter(Boolean))]
+    },
+
+    // fetchLabelKeys and fetchLabelValues return null when the request fails, so a
+    // failed background refresh keeps the lists it already had.
+    async fetchLabelKeys(range) {
+      try {
+        const data = await apiFetch(`/pipeline/labels?keyonly=true&start_time=${encodeURIComponent(range.start)}&end_time=${encodeURIComponent(range.end)}`);
+        return data.labels || [];
       } catch (error) {
         console.error('Error fetching label keys:', error);
-        this.labelKeys = [];
+        return null;
       }
     },
 
-    async getLabelValues(labelKey) {
+    async fetchLabelValues(labelKey, range) {
       try {
-        if (!labelKey) {
-          return [];
-        }
+        const data = await apiFetch(`/pipeline/labels?key=${encodeURIComponent(labelKey)}&start_time=${encodeURIComponent(range.start)}&end_time=${encodeURIComponent(range.end)}`);
+        return [...new Set((data.labels || []).map(label => label.value))];
+      } catch (error) {
+        console.error('Error fetching label values:', error);
+        return null;
+      }
+    },
 
-        // Return cached values if available
-        if (this.labelValuesByKey[labelKey]) {
-          return this.labelValuesByKey[labelKey];
+    // refreshLabels reloads the keys, and the values of every selected key, for the
+    // current window. Each call supersedes the previous one: a slow response for an
+    // older window is dropped instead of overwriting a newer list.
+    async refreshLabels() {
+      const request = ++this.labelsRequest
+      const steps = this.dateRange.join()
+      const range = this.timeWindow()
+      const keys = this.selectedLabelKeys()
+
+      const [labelKeys, ...values] = await Promise.all([
+        this.fetchLabelKeys(range),
+        ...keys.map((key) => this.fetchLabelValues(key, range)),
+      ])
+      if (request !== this.labelsRequest) {
+        return
+      }
+
+      // A failed request keeps the previous list only while the range is the one it was
+      // loaded for. After a range change it would offer labels the new range may not have.
+      const sameRange = steps === this.labelsSteps
+      this.labelsSteps = steps
+
+      this.labelKeys = labelKeys ?? (sameRange ? this.labelKeys : [])
+
+      const valuesByKey = {}
+      keys.forEach((key, index) => {
+        const keyValues = values[index] ?? (sameRange ? this.labelValuesByKey[key] : null)
+        if (keyValues) {
+          valuesByKey[key] = keyValues
         }
+      })
+      this.labelValuesByKey = valuesByKey
 
-        const query = `/pipeline/labels?key=${encodeURIComponent(labelKey)}&start_time=${encodeURIComponent(this.formattedStartTime)}&end_time=${encodeURIComponent(this.formattedEndTime)}`;
+      // A key picked while this refresh was in flight is not in it.
+      this.selectedLabelKeys().forEach((key) => this.loadLabelValues(key))
+    },
 
-        const data = await apiFetch(query);
+    // loadLabelValues fetches the values of one key unless the current window already
+    // has them.
+    async loadLabelValues(labelKey) {
+      if (!labelKey || this.labelValuesByKey[labelKey]) {
+        return
+      }
 
-        // Extract unique values from the labels array
-        const uniqueValues = [...new Set((data.labels || []).map(label => label.value))];
-        this.labelValuesByKey[labelKey] = uniqueValues;
-        return this.labelValuesByKey[labelKey];
-      } catch (error) {
-        console.error('Error fetching label values:', error);
-        return [];
+      const request = this.labelsRequest
+      const values = await this.fetchLabelValues(labelKey, this.timeWindow())
+      if (request !== this.labelsRequest || values === null) {
+        return
       }
+
+      this.labelValuesByKey[labelKey] = values
     },
 
     resetRestrictedSCM() {
@@ -592,9 +648,8 @@ export default {
       this.selectedLabels = [{ key: null, value: null }]
       this.selectedResults = []
       this.selectedOpenAction = null
-      this.labelValuesByKey = {}
       this.getSCMSData()
-      this.getLabelKeys()
+      this.refreshLabels()
     },
 
     prettifyURL: function(url) {
@@ -749,9 +804,10 @@ export default {
 
     applyFilter() {
 
+      const range = this.timeWindow()
       var newFilter = {
-        startTime: this.formattedStartTime,
-        endTime: this.formattedEndTime,
+        startTime: range.start,
+        endTime: range.end,
       }
 
       if (this.showRepositoryBranch) {
@@ -910,11 +966,12 @@ export default {
         return;
       }
 
+      // Clear value when key changes. It has to happen before the values load: a live
+      // refresh can fill them in first, and a value picked from those would be lost.
+      this.selectedLabels[index].value = null;
       if (labelKey) {
-        await this.getLabelValues(labelKey);
+        await this.loadLabelValues(labelKey);
       }
-      // Clear value when key changes
-      this.selectedLabels[index].value = null;
     },
 
     onLabelValueChange(index) {
@@ -978,8 +1035,7 @@ export default {
         // Debounce label refresh to avoid an API call on every slider tick
         clearTimeout(this.debounceTimer)
         this.debounceTimer = setTimeout(() => {
-          this.labelValuesByKey = {}
-          this.getLabelKeys()
+          this.refreshLabels()
         }, 500)
       },
       repository (val) {
@@ -1025,12 +1081,12 @@ export default {
           } else {
             this.getSCMSData()
           }
-          await this.getLabelKeys()
+          await this.refreshLabels()
         } else {
           // When not showing repository/branch selectors, emit the initial
           // time-range filter directly so child components get the correct filter.
           this.$emit('loaded', false)
-          await this.getLabelKeys()
+          await this.refreshLabels()
           this.applyFilter()
           this.$emit('loaded', true)
         }
diff --git a/src/components/scm/_summary.vue b/src/components/scm/_summary.vue
index 01d46703e..d1511791d 100644
--- a/src/components/scm/_summary.vue
+++ b/src/components/scm/_summary.vue
@@ -396,7 +396,7 @@ import { apiFetch, describeLoadError } from '@/composables/api';
 import { getPipelineResultText, PIPELINE_RESULT_VALUES } from '@/composables/status';
 import { extractGitURLInfo } from '@/composables/git';
 import { getStorageKey, getMaxHistoryDays } from '@/composables/runtime';
-import { encodeFilterState, decodeFilterState } from '@/composables/filter';
+import { encodeFilterState, decodeFilterState, filterRequestBody } from '@/composables/filter';
 
 ChartJS.register(RadialLinearScale, ArcElement, Tooltip, Legend)
 
@@ -814,28 +814,7 @@ export default {
                     requestBody.scmid = this.filter.scmid;
                 }
 
-                 // Add starttime and endtime filters if provided
-                if (this.filter?.startTime && this.filter.endTime ) {
-                    requestBody.start_time = this.filter.startTime;
-                    requestBody.end_time = this.filter.endTime;
-                }
-
-                if (this.filter?.labels && typeof this.filter.labels === 'object' && !Array.isArray(this.filter.labels)) {
-                    const labels = {};
-                    Object.entries(this.filter.labels).forEach(([key, value]) => {
-                        if (typeof key === 'string' && value !== undefined && value !== null) {
-                            labels[key] = String(value);
-                        }
-                    });
-
-                    if (Object.keys(labels).length > 0) {
-                        requestBody.labels = labels;
-                    }
-                }
-
-                if (Array.isArray(this.filter?.results) && this.filter.results.length > 0) {
-                    requestBody.results = this.filter.results;
-                }
+                Object.assign(requestBody, filterRequestBody(this.filter));
 
                 // Tri-state: an unset filter must be left out of the body. Sending false
                 // would drop every pipeline with an open pull request.
diff --git a/src/composables/filter.js b/src/composables/filter.js
index 51f7e4f44..68b08dcd5 100644
--- a/src/composables/filter.js
+++ b/src/composables/filter.js
@@ -49,3 +49,34 @@ export function decodeFilterState(encoded) {
     return null
   }
 }
+
+// filterRequestBody turns the filter the dashboard emits into the fields every search
+// endpoint reads the same way: the date range, the labels and the results. Fields left
+// unset are left out of the body rather than sent empty.
+export function filterRequestBody(filter) {
+  const body = {}
+
+  if (filter?.startTime && filter.endTime) {
+    body.start_time = filter.startTime
+    body.end_time = filter.endTime
+  }
+
+  if (filter?.labels && typeof filter.labels === 'object' && !Array.isArray(filter.labels)) {
+    const labels = {}
+    Object.entries(filter.labels).forEach(([key, value]) => {
+      if (typeof key === 'string' && value !== undefined && value !== null) {
+        labels[key] = String(value)
+      }
+    })
+
+    if (Object.keys(labels).length > 0) {
+      body.labels = labels
+    }
+  }
+
+  if (Array.isArray(filter?.results) && filter.results.length > 0) {
+    body.results = filter.results
+  }
+
+  return body
+}
diff --git a/src/composables/filter.spec.js b/src/composables/filter.spec.js
index 1f50e8d17..e67506fe9 100644
--- a/src/composables/filter.spec.js
+++ b/src/composables/filter.spec.js
@@ -4,6 +4,7 @@ import {
   decodeFilterState,
   encodeBase64UrlUtf8,
   encodeFilterState,
+  filterRequestBody,
 } from '@/composables/filter'
 
 describe('base64url', () => {
@@ -49,3 +50,25 @@ describe('filter state', () => {
     expect(decodeFilterState(encodeBase64UrlUtf8('null'))).toBeNull()
   })
 })
+
+describe('filterRequestBody', () => {
+  it('reads the date range, the labels and the results', () => {
+    expect(filterRequestBody({
+      startTime: '2026-09-01T00:00:00Z',
+      endTime: '2026-09-02T00:00:00Z',
+      labels: { team: 'infra', tier: 1 },
+      results: ['✗'],
+      openAction: true,
+    })).toEqual({
+      start_time: '2026-09-01T00:00:00Z',
+      end_time: '2026-09-02T00:00:00Z',
+      labels: { team: 'infra', tier: '1' },
+      results: ['✗'],
+    })
+  })
+
+  it('leaves out what is unset', () => {
+    expect(filterRequestBody(null)).toEqual({})
+    expect(filterRequestBody({ startTime: '2026-09-01T00:00:00Z', labels: {}, results: [] })).toEqual({})
+  })
+})
diff --git a/src/composables/url.js b/src/composables/url.js
new file mode 100644
index 000000000..16bc434d2
--- /dev/null
+++ b/src/composables/url.js
@@ -0,0 +1,16 @@
+// safeHttpUrl keeps a link only when it is http or https, so a report cannot slip a
+// javascript: URL into the page.
+export function safeHttpUrl(value) {
+  try {
+    const url = new URL(value)
+    return url.protocol === 'http:' || url.protocol === 'https:' ? url.href : ''
+  } catch {
+    return ''
+  }
+}
+
+// shortRepository reads a git repository url as "owner/name", dropping the host and the
+// .git suffix.
+export function shortRepository(url) {
+  return String(url || '').replace(/^https?:\/\/[^/]+\//, '').replace(/\.git$/, '')
+}
diff --git a/src/views/Dashboard.vue b/src/views/Dashboard.vue
index f7e251051..128f2d2ef 100644
--- a/src/views/Dashboard.vue
+++ b/src/views/Dashboard.vue
@@ -24,6 +24,30 @@
         />
       </v-col>
     </v-row>
+    <!-- The pull requests follow the same filter as the repositories below. Filtering on
+         the pipelines without an open action leaves nothing for them to show. -->
+    <v-row v-if="isFilterLoaded && filter.openAction !== false">
+      <v-col
+        cols="12"
+      >
+        <!-- The same container as the repository cards below, so both share one width. -->
+        <v-container class="pa-0">
+          <PullRequestList
+            :filter="filter"
+            paginated
+            :limit="5"
+            count-qualifier="in this period"
+            empty="No pull request matches this filter."
+          />
+        </v-container>
+      </v-col>
+    </v-row>
+    <p
+      v-else-if="isFilterLoaded"
+      class="dashboard-note text-body-small text-medium-emphasis"
+    >
+      Pull requests are hidden while the filter keeps only pipelines without one.
+    </p>
     <v-row>
       <v-col
         cols="12"
@@ -41,6 +65,7 @@
 <script>
 import SCMSDashboard from '../components/scm/_summary.vue';
 import PageTitle from '../components/PageTitle.vue';
+import PullRequestList from '../components/PullRequestList.vue';
 
 import PipelineSCMFilter from '../components/scm/_filter.vue';
 
@@ -49,6 +74,7 @@ export default {
   components: {
     PageTitle,
     PipelineSCMFilter,
+    PullRequestList,
     PipelineSCMSSummary: SCMSDashboard,
   },
 
@@ -85,3 +111,9 @@ export default {
 }
 </script>
 
+
+<style scoped>
+.dashboard-note {
+  margin: 0 0 8px;
+}
+</style>
diff --git a/src/views/pipeline/ReportsView.vue b/src/views/pipeline/ReportsView.vue
index 1a19931a5..e4dbe8db6 100644
--- a/src/views/pipeline/ReportsView.vue
+++ b/src/views/pipeline/ReportsView.vue
@@ -53,6 +53,28 @@
         />
       </v-col>
     </v-row>
+    <!-- The pull requests still open on what the filter selects, once each, whichever page
+         of reports below they come from. -->
+    <v-row v-if="isFilterLoaded && filter.openAction !== false">
+      <v-col
+        cols="12"
+      >
+        <PullRequestList
+          :filter="filter"
+          paginated
+          :limit="5"
+          heading-class="text-title-large"
+          count-qualifier="in this period"
+          empty="No pull request matches this filter."
+        />
+      </v-col>
+    </v-row>
+    <p
+      v-else-if="isFilterLoaded"
+      class="reports-note text-body-small text-medium-emphasis"
+    >
+      Pull requests are hidden while the filter keeps only pipelines without one.
+    </p>
     <v-row>
       <v-col
         cols="12"
@@ -80,6 +102,7 @@
 
 import PipelineReports from '../../components/pipeline/reports.vue';
 import PageTitle from '../../components/PageTitle.vue';
+import PullRequestList from '../../components/PullRequestList.vue';
 
 import PipelineSCMSummary from '../../components/scm/_summary.vue';
 import PipelineSCMFilter from '../../components/scm/_filter.vue';
@@ -92,6 +115,7 @@ export default {
   components: {
     PageTitle,
     PipelineReports,
+    PullRequestList,
     PipelineSCMFilter,
     PipelineSCMSummary
   },
@@ -174,3 +198,9 @@ export default {
   }
 }
 </script>
+
+<style scoped>
+.reports-note {
+  margin: 0 0 8px;
+}
+</style>