diff --git a/console/app/components/QueueOrderPanel.vue b/console/app/components/QueueOrderPanel.vue
new file mode 100644
index 0000000..10c24ab
--- /dev/null
+++ b/console/app/components/QueueOrderPanel.vue
@@ -0,0 +1,611 @@
+<script setup lang="ts">
+/**
+ * The order a server's queued work will run in, and the two ways to change
+ * it.
+ *
+ * Everything that is a *decision* is elsewhere and tested without a render:
+ * where a dropped session goes and how that is expressed to the API is
+ * `~/utils/queueReorder`, what the answer means and what a quick action has
+ * to say before it runs is `~/utils/queueOrder`, and which page numbers to
+ * offer is `~/utils/paging` by way of `UiPagination`. What is left here is
+ * the half no module can hold: which row the pointer is over, where focus
+ * goes when a row moves, and when to send the one request a whole gesture
+ * produces.
+ *
+ * **The keyboard is not the fallback path, it is the same path.** A row is
+ * picked up, moved and put down; the arrow keys and a mouse drag both
+ * produce a `Grab`, and a `Grab` produces one placement. There is no second
+ * implementation to drift, and no move a mouse can make that a keyboard
+ * cannot — including the two that matter most, "put this at the front" and
+ * "put this at the back", which the keyboard can make across the whole
+ * queue while a mouse drag is confined to the page it started on. The
+ * handle says all of that in its own description rather than leaving it to
+ * be discovered.
+ *
+ * One request per gesture, not one per keystroke. Four arrow presses to
+ * move a session four places would otherwise be four writes, and the three
+ * in the middle are orders nobody wanted the queue to be in even briefly.
+ *
+ * **`UiDisclosureList` is deliberately not the base for this list.** That
+ * control owns two things this list must not have: a disclosure, and a
+ * selection that survives a page change. Nothing on a queue row is hidden —
+ * the page argues at length that a row's state has to be readable without
+ * hovering or expanding — and a selection outliving the page is exactly the
+ * property that must not be reused here, because the position a row is
+ * being dragged to is meaningless on a page the reader has left. Teaching
+ * that component to reorder would also push a queue-only concern into a
+ * control two other pages share. So this is an `<ol>`, which is what a list
+ * whose order is its content already is.
+ *
+ * **A 409 is not an error here.** Two administrators reordering at once
+ * serialise, and the loser is told so with the queue as it now stands
+ * attached. That body is the whole point of asking for it, so the request
+ * is sent with `ignoreResponseError` and the *shape* of the reply decides
+ * whether it was answered: an order is an order whether or not it was
+ * accepted, and everything else is a failure with a status to report.
+ */
+import { ApiError } from '~/utils/apiError'
+import type { Message } from '~/utils/message'
+import { pageCount } from '~/utils/paging'
+import {
+  QUEUE_TONE_COLOUR,
+  queueSliceSummary,
+  queuedSummary,
+  type QueuedSession,
+} from '~/utils/queue'
+import {
+  QUEUE_RULES,
+  guildPriorityPath,
+  parseQueueOrder,
+  reorderFailure,
+  reorderReport,
+  ruleConfirmation,
+  sessionPriorityPath,
+  type QueueOrder,
+  type QueueRuleName,
+  type ReorderTone,
+} from '~/utils/queueOrder'
+import {
+  QUEUE_PAGE_SIZE,
+  REORDER_INSTRUCTIONS,
+  droppedBackMessage,
+  grabSession,
+  grabbedOrder,
+  heldMessage,
+  moveGrabBy,
+  moveGrabTo,
+  pageForGrab,
+  pageSlice,
+  pickedUpMessage,
+  placementFor,
+  type Grab,
+} from '~/utils/queueReorder'
+import { channelNaming } from '~/utils/recordings'
+
+const props = defineProps<{
+  guildId: string
+  /** The queue, already in the order a worker will reach it. */
+  sessions: readonly QueuedSession[]
+}>()
+
+const emit = defineEmits<{
+  /** An order the server committed to, refusal included. The page renumbers
+   *  from it rather than this panel reaching into the page's own data. */
+  order: [QueueOrder]
+  /** Something changed that the whole page should re-read. */
+  reload: []
+}>()
+
+const api = useApi()
+const say = useSay()
+const instructionsId = useId()
+
+const page = ref(1)
+const grab = ref<Grab | null>(null)
+const busy = ref(false)
+const confirming = ref<QueueRuleName | null>(null)
+
+/** The last thing that happened, in a sentence. It lives on the page and
+ *  not in a toast: what the queue did is part of the queue, and a message
+ *  that fades is a message the person who looked away has lost. */
+const report = ref<{ message: Message, tone: ReorderTone } | null>(null)
+
+/** What is being held right now, said after every keystroke. Separate from
+ *  `report` because they are two announcements with two jobs — one narrates
+ *  a gesture in progress, the other says what came of it. */
+const holding = ref<Message | null>(null)
+
+/** The handles, so focus can be put back on one after its row has been
+ *  rebuilt in a different page of the list. Vue moves an element that keeps
+ *  its key, so an ordinary move keeps focus by itself; crossing a page
+ *  boundary destroys and rebuilds the row, and nothing else would bring
+ *  focus with it. */
+const handles = new Map<string, HTMLElement>()
+
+function keepHandle(id: string, element: unknown) {
+  if (element instanceof HTMLElement) handles.set(id, element)
+  else handles.delete(id)
+}
+
+const ids = computed(() => props.sessions.map((session) => session.id))
+const total = computed(() => props.sessions.length)
+
+/** The queue as it would be if what is held were dropped now. A preview,
+ *  never a claim: nothing has been written until the server answers. */
+const previewed = computed<QueuedSession[]>(() => {
+  const current = grab.value
+  if (!current) return [...props.sessions]
+  const byId = new Map(props.sessions.map((session) => [session.id, session]))
+  return grabbedOrder(ids.value, current).flatMap((id) => {
+    const session = byId.get(id)
+    return session ? [session] : []
+  })
+})
+
+/**
+ * The window follows the grab, so a move never stops at a page boundary
+ * for a reason that has nothing to do with the queue.
+ *
+ * Clamped to the list rather than trusted, because the list shrinks on its
+ * own: a session finishing while somebody is reading page three of a queue
+ * that now has two would otherwise leave them looking at an empty section
+ * under a pager that still offers three pages.
+ */
+const shownPage = computed(() =>
+  Math.min(pageForGrab(grab.value, page.value), pageCount(props.sessions.length, QUEUE_PAGE_SIZE)),
+)
+const offset = computed(() => (shownPage.value - 1) * QUEUE_PAGE_SIZE)
+const rows = computed(() => pageSlice(previewed.value, shownPage.value))
+const summary = computed(() => queueSliceSummary(total.value, offset.value, rows.value.length))
+
+/** The one open confirmation, already worded. Computed rather than called
+ *  three times in the template, which would ask the same question three
+ *  times and leave three places for the answer to be got wrong. */
+const confirmation = computed(() =>
+  confirming.value === null
+    ? null
+    : { rule: confirming.value, ...ruleConfirmation(confirming.value) },
+)
+
+function label(session: QueuedSession): string {
+  return say(channelNaming(session).heading)
+}
+
+function sessionById(id: string): QueuedSession | undefined {
+  return props.sessions.find((session) => session.id === id)
+}
+
+/** Where a row sits in the whole queue, not in the page of it on screen. A
+ *  row that says "runs 2nd" on page three has told the reader nothing. */
+function positionMessage(index: number): Message {
+  return {
+    key: 'admin.queue.order.position',
+    params: { position: String(offset.value + index + 1), total: String(total.value) },
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/* Picking a row up, moving it, putting it down                        */
+/* ------------------------------------------------------------------ */
+
+function pickUp(session: QueuedSession) {
+  const picked = grabSession(ids.value, session.id)
+  if (!picked) return
+  grab.value = picked
+  report.value = null
+  holding.value = pickedUpMessage(label(session), picked, total.value)
+}
+
+async function focusHandle(id: string) {
+  await nextTick()
+  handles.get(id)?.focus()
+}
+
+/**
+ * Holds the row somewhere else.
+ *
+ * `narrate` is false for a pointer drag and true for a keystroke, and the
+ * difference is not cosmetic. A drag already shows where the row is, at
+ * about sixty positions a second; announcing every one of them would bury
+ * the one sentence that matters, and calling `focus()` mid-drag takes focus
+ * off whatever the reader was actually on.
+ */
+function move(next: Grab, narrate: boolean) {
+  grab.value = next
+  if (!narrate) return
+  holding.value = heldMessage(next, total.value)
+  void focusHandle(next.id)
+}
+
+function nudge(delta: number) {
+  const current = grab.value
+  if (current) move(moveGrabBy(current, total.value, delta), true)
+}
+
+function moveToIndex(at: number, narrate: boolean) {
+  const current = grab.value
+  if (current) move(moveGrabTo(current, total.value, at), narrate)
+}
+
+/** A grab abandoned. Said out loud, because the list has been showing the
+ *  row somewhere else and the reader has to know that undid itself rather
+ *  than half-applied. */
+function cancelGrab() {
+  const current = grab.value
+  if (!current) return
+  const session = sessionById(current.id)
+  grab.value = null
+  holding.value = null
+  report.value = {
+    message: droppedBackMessage(session ? label(session) : current.id),
+    tone: 'clear',
+  }
+  void focusHandle(current.id)
+}
+
+function onKeydown(event: KeyboardEvent, session: QueuedSession) {
+  // A `<button>` turns Enter and Space into a click, so both are stopped
+  // here and answered once rather than once per event.
+  if (event.key === 'Enter' || event.key === ' ' || event.key === 'Spacebar') {
+    event.preventDefault()
+    if (grab.value) void commit()
+    else pickUp(session)
+    return
+  }
+  if (!grab.value) return
+  switch (event.key) {
+    case 'Escape':
+      event.preventDefault()
+      cancelGrab()
+      break
+    case 'ArrowUp':
+      event.preventDefault()
+      nudge(-1)
+      break
+    case 'ArrowDown':
+      event.preventDefault()
+      nudge(1)
+      break
+    case 'Home':
+      event.preventDefault()
+      moveToIndex(0, true)
+      break
+    case 'End':
+      event.preventDefault()
+      moveToIndex(total.value - 1, true)
+      break
+  }
+}
+
+function onHandleClick(session: QueuedSession) {
+  // Clicking any handle while something is held puts that thing down. The
+  // alternative — swapping which row is held mid-gesture — is a click that
+  // moves a session the reader was not looking at.
+  if (grab.value) void commit()
+  else pickUp(session)
+}
+
+/* ------------------------------------------------------------------ */
+/* The mouse                                                           */
+/* ------------------------------------------------------------------ */
+
+function onDragStart(event: DragEvent, session: QueuedSession) {
+  if (busy.value) return
+  pickUp(session)
+  if (event.dataTransfer) {
+    event.dataTransfer.effectAllowed = 'move'
+    // Some browsers refuse to start a drag with nothing on the transfer.
+    // It is never read back: the grab already knows what is held.
+    event.dataTransfer.setData('text/plain', session.id)
+  }
+}
+
+function onDragOver(event: DragEvent, index: number) {
+  if (!grab.value) return
+  // Without this the browser refuses the drop and `drop` never fires.
+  event.preventDefault()
+  if (event.dataTransfer) event.dataTransfer.dropEffect = 'move'
+  moveToIndex(offset.value + index, false)
+}
+
+function onDragEnd() {
+  // Reached when a drag ended somewhere that is not a row. `commit` clears
+  // the grab before it awaits anything, so a drop that already committed
+  // leaves nothing here to cancel.
+  if (grab.value) cancelGrab()
+}
+
+/* ------------------------------------------------------------------ */
+/* Talking to the API                                                  */
+/* ------------------------------------------------------------------ */
+
+/**
+ * One reorder, and the order it produced.
+ *
+ * `ignoreResponseError` is here for exactly one status. A 409 means the
+ * queue moved under this request, and its body is the queue as it now
+ * stands — the one thing a page that has just been told its picture is
+ * stale actually needs. Discarding it and re-reading would ask the same
+ * question twice and answer it with a list assembled a moment later.
+ *
+ * The status is captured on the way past rather than inferred, so a reply
+ * that is not an order at all can still be reported as the refusal it is,
+ * in the words its status deserves.
+ */
+async function send(path: string, body: Record<string, string>): Promise<QueueOrder> {
+  let status = 200
+  const payload = await api<unknown>(path, {
+    method: 'POST',
+    body,
+    ignoreResponseError: true,
+    onResponse: (context: { response?: { status?: number } }) => {
+      if (typeof context.response?.status === 'number') status = context.response.status
+    },
+  })
+  const order = parseQueueOrder(payload)
+  if (!order) throw new ApiError(path, { status })
+  return order
+}
+
+async function announce(run: () => Promise<QueueOrder>) {
+  busy.value = true
+  holding.value = null
+  try {
+    const order = await run()
+    const outcome = reorderReport(order)
+    report.value = { message: outcome.message, tone: outcome.tone }
+    emit('order', order)
+    // Re-read afterwards as well as renumbering from the answer. The order
+    // says where everything sits; it does not say that a session has since
+    // been documented and should no longer be listed at all.
+    emit('reload')
+  } catch (error) {
+    report.value = { message: reorderFailure(error), tone: 'alarm' }
+  } finally {
+    busy.value = false
+  }
+}
+
+async function commit() {
+  const current = grab.value
+  if (!current) return
+  // Cleared before anything is awaited, so a `dragend` arriving after a
+  // drop finds nothing to cancel and a second Enter cannot send the same
+  // move twice.
+  grab.value = null
+  const placement = placementFor(ids.value, current)
+  if (!placement) {
+    const session = sessionById(current.id)
+    holding.value = null
+    // No request at all. A session dropped where it started would earn
+    // `changed: []` and a sentence written after the fact; not asking is
+    // both truer and cheaper.
+    report.value = {
+      message: session ? droppedBackMessage(label(session)) : { key: 'admin.queue.order.stale' },
+      tone: 'clear',
+    }
+    void focusHandle(current.id)
+    return
+  }
+  await announce(() =>
+    send(sessionPriorityPath(current.id), {
+      place: placement.place,
+      // Absent rather than null for the two ends: the endpoint refuses a
+      // placement that names both an end and a neighbour.
+      ...(placement.session ? { session: placement.session } : {}),
+    }),
+  )
+  void focusHandle(current.id)
+}
+
+async function runRule(rule: QueueRuleName) {
+  confirming.value = null
+  await announce(() => send(guildPriorityPath(props.guildId), { rule }))
+}
+
+/** A session that left the queue while it was being held. Nothing can be
+ *  placed relative to a list it is no longer in, and holding on would leave
+ *  a row on screen at a position the queue does not have. */
+watch(ids, (current) => {
+  const held = grab.value
+  if (held && !current.includes(held.id)) {
+    grab.value = null
+    holding.value = null
+    report.value = { message: { key: 'admin.queue.order.stale' }, tone: 'watch' }
+  }
+})
+
+onBeforeUnmount(() => handles.clear())
+</script>
+
+<template>
+  <section
+    class="mb-8 rounded-xl border p-4"
+    :style="{ borderColor: 'var(--border)', background: 'var(--surface)' }"
+  >
+    <h2 class="mb-1 text-sm font-semibold">{{ $t('admin.queue.list.queuedHeading') }}</h2>
+    <p class="mb-4 text-xs" :style="{ color: 'var(--text-muted)' }">
+      {{ $t('admin.queue.list.queuedNote') }}
+    </p>
+
+    <!-- The two quick actions, above the list they reorder. A control that
+         rewrites what is underneath it belongs where the reader is already
+         looking. -->
+    <div
+      class="mb-4 rounded-lg border p-3"
+      :style="{ borderColor: 'var(--border)', background: 'var(--surface-raised)' }"
+    >
+      <h3 class="mb-1 text-xs font-semibold">{{ $t('admin.queue.rules.heading') }}</h3>
+      <p class="mb-3 text-xs" :style="{ color: 'var(--text-muted)' }">
+        {{ $t('admin.queue.rules.note') }}
+      </p>
+      <div class="flex flex-wrap gap-2">
+        <button
+          v-for="rule in QUEUE_RULES"
+          :key="rule.rule"
+          type="button"
+          class="rounded-lg border px-3 py-1.5 text-sm font-medium transition-colors hover:bg-[var(--surface)] disabled:opacity-40"
+          :style="{ borderColor: 'var(--border)' }"
+          :disabled="busy || sessions.length === 0"
+          :aria-expanded="confirming === rule.rule"
+          @click="confirming = confirming === rule.rule ? null : rule.rule"
+        >
+          {{ $t(rule.nameKey) }}
+        </button>
+      </div>
+      <!-- What each one ranks by, beside the button and not only inside the
+           confirmation: choosing between two rules is a decision made
+           before either is pressed. -->
+      <p
+        v-for="rule in QUEUE_RULES"
+        :key="`blurb-${rule.rule}`"
+        class="mt-2 text-xs"
+        :style="{ color: 'var(--text-muted)' }"
+      >
+        <span class="font-medium">{{ $t(rule.nameKey) }}</span> — {{ $t(rule.blurbKey) }}
+      </p>
+
+      <!-- What it will do, before it does it, where the button that opened
+           it is. A guild-wide reorder reaches sessions the list below was
+           cut short of showing, and it is not undone by pressing the other
+           button — neither of which is visible from a button. -->
+      <section
+        v-if="confirmation"
+        class="mt-3 rounded-lg border p-3"
+        :style="{ borderColor: 'var(--color-brand-yellow)', background: 'var(--surface)' }"
+      >
+        <h4 class="mb-2 text-sm font-semibold">{{ say(confirmation.title) }}</h4>
+        <!-- Kept as separate sentences. One paragraph carrying all of them
+             is skimmed exactly where the reader most needs to notice that
+             this reaches rows they cannot see. -->
+        <p
+          v-for="consequence in confirmation.consequences"
+          :key="consequence.key"
+          class="mb-2 text-sm"
+          :style="{ color: 'var(--text-muted)' }"
+        >
+          {{ say(consequence) }}
+        </p>
+        <div class="mt-3 flex flex-wrap gap-2">
+          <button
+            type="button"
+            class="rounded-lg border px-3 py-1.5 text-sm font-medium transition-colors hover:bg-[var(--surface-raised)] disabled:opacity-40"
+            :style="{ borderColor: 'var(--color-brand-yellow)' }"
+            :disabled="busy"
+            @click="runRule(confirmation.rule)"
+          >
+            {{ busy ? $t('admin.queue.rules.working') : say(confirmation.confirm) }}
+          </button>
+          <button
+            type="button"
+            class="rounded-lg border px-3 py-1.5 text-sm transition-colors hover:bg-[var(--surface-raised)]"
+            :style="{ borderColor: 'var(--border)' }"
+            @click="confirming = null"
+          >
+            {{ $t('admin.queue.rules.cancel') }}
+          </button>
+        </div>
+      </section>
+    </div>
+
+    <p class="mb-2 text-sm" :style="{ color: 'var(--text-muted)' }">
+      {{ say(queuedSummary(sessions)) }}
+    </p>
+
+    <!-- What the keyboard does, on the page rather than only in an
+         announcement: a control reachable only by dragging is not a
+         control, and one reachable by keys nobody mentions is barely
+         better. -->
+    <p :id="instructionsId" class="mb-3 text-xs" :style="{ color: 'var(--text-muted)' }">
+      {{ say(REORDER_INSTRUCTIONS) }}
+    </p>
+
+    <!-- Two announcements, two jobs: one narrates a gesture in progress and
+         is only ever heard, the other says what came of it and stays on the
+         page for whoever looked away. -->
+    <p class="sr-only" role="status" aria-live="assertive">{{ holding ? say(holding) : '' }}</p>
+    <p
+      v-if="report"
+      class="mb-3 rounded-lg border p-3 text-sm"
+      role="status"
+      aria-live="polite"
+      :style="{ borderColor: QUEUE_TONE_COLOUR[report.tone] }"
+    >
+      {{ say(report.message) }}
+    </p>
+
+    <p v-if="sessions.length === 0" class="text-sm" :style="{ color: 'var(--text-muted)' }">
+      {{ $t('admin.queue.list.queuedNone') }}
+    </p>
+
+    <template v-else>
+      <!-- An ordered list, because the order *is* the content. Twenty bare
+           articles give assistive technology no count and no way to step
+           between them, and this list additionally has to say which number
+           each row carries. -->
+      <ol
+        class="overflow-hidden rounded-xl border"
+        :style="{ borderColor: 'var(--border)', background: 'var(--surface-raised)' }"
+        :start="offset + 1"
+        :aria-busy="busy"
+      >
+        <li
+          v-for="(session, index) in rows"
+          :key="session.id"
+          class="border-t first:border-t-0"
+          :style="{
+            borderColor: 'var(--border)',
+            background: grab && grab.id === session.id ? 'var(--surface)' : 'transparent',
+          }"
+          draggable="true"
+          @dragstart="onDragStart($event, session)"
+          @dragover="onDragOver($event, index)"
+          @drop.prevent="commit()"
+          @dragend="onDragEnd()"
+        >
+          <QueueSessionRow :session="session">
+            <template #lead>
+              <div class="flex shrink-0 flex-col items-center gap-1">
+                <button
+                  :ref="(element) => keepHandle(session.id, element)"
+                  type="button"
+                  class="rounded-lg border px-2 py-1 text-sm transition-colors hover:bg-[var(--surface)] disabled:opacity-40"
+                  :style="{
+                    borderColor:
+                      grab && grab.id === session.id
+                        ? 'var(--color-brand-cyan)'
+                        : 'var(--border)',
+                  }"
+                  :disabled="busy"
+                  :aria-pressed="Boolean(grab && grab.id === session.id)"
+                  :aria-label="$t('admin.queue.order.handle', { session: label(session) })"
+                  :aria-describedby="instructionsId"
+                  @keydown="onKeydown($event, session)"
+                  @click="onHandleClick(session)"
+                >
+                  <span aria-hidden="true">⠿</span>
+                </button>
+                <span class="text-xs tabular-nums" :style="{ color: 'var(--text-muted)' }">
+                  {{ say(positionMessage(index)) }}
+                </span>
+              </div>
+            </template>
+          </QueueSessionRow>
+        </li>
+      </ol>
+
+      <div class="mt-4 flex flex-col items-center gap-2">
+        <UiPagination
+          :page="shownPage"
+          :total="total"
+          :size="QUEUE_PAGE_SIZE"
+          :label="$t('admin.queue.list.pagerQueued')"
+          @update:page="page = $event"
+        />
+        <p v-if="summary" class="text-sm" :style="{ color: 'var(--text-muted)' }">
+          {{ say(summary) }}
+        </p>
+      </div>
+    </template>
+  </section>
+</template>
diff --git a/console/app/components/QueueSessionRow.vue b/console/app/components/QueueSessionRow.vue
new file mode 100644
index 0000000..768e223
--- /dev/null
+++ b/console/app/components/QueueSessionRow.vue
@@ -0,0 +1,122 @@
+<script setup lang="ts">
+/**
+ * One unfinished session, as the Queue page lists it.
+ *
+ * Extracted because the page now lists sessions in two places — the ones
+ * with a place in the queue, in the order they will run, and the ones with
+ * nothing queued at all — and a row rendered twice from two copies of the
+ * same markup is a row that stops agreeing with itself. The first thing to
+ * diverge would be the state badge, which is the one thing on the row that
+ * decides what somebody does next.
+ *
+ * **The channel is named the way #141 settled.** A channel whose name has
+ * gone is an *absence*, not a name: the heading says there is no name, in
+ * the muted role and in normal weight, and the id goes underneath as a
+ * subordinate line. Eighteen digits set in semibold read as what the
+ * meeting is called, and nobody has a meeting called
+ * `Channel 1240377558927872021`. The answer comes from `channelNaming`,
+ * which is the console's only answer to that question.
+ *
+ * The long form of the badge stays on the row rather than behind a
+ * tooltip, as it always has: which of the four states a row is in decides
+ * what to do next, and nobody hovers to find that out.
+ *
+ * The `lead` slot is where the queued list puts its move handle. It is a
+ * slot rather than a prop because the rows that are *not* in the queue
+ * have nothing to put there, and a handle rendered disabled would be an
+ * offer of a control that cannot exist — the API sends `priority: null`
+ * for exactly those rows and says so.
+ */
+import { QUEUE_TONE_COLOUR, queueChannelNote, queueSessionState, sessionCounts, sessionStartLine, type QueuedSession } from '~/utils/queue'
+import { channelNaming, recordingPath } from '~/utils/recordings'
+
+const props = defineProps<{ session: QueuedSession }>()
+
+const say = useSay()
+
+const channel = computed(() => channelNaming(props.session))
+const state = computed(() => queueSessionState(props.session))
+</script>
+
+<template>
+  <article class="p-4">
+    <header class="mb-3 flex flex-col gap-2 sm:flex-row sm:items-start sm:justify-between">
+      <div class="flex items-start gap-3">
+        <slot name="lead" />
+        <div class="min-w-0">
+          <!-- Normal weight and the muted role when there is no name, so
+               the heading reads as the absence it is. -->
+          <h3
+            class="text-sm"
+            :class="channel.named ? 'font-semibold' : 'font-normal italic'"
+            :style="{ color: channel.named ? 'var(--text)' : 'var(--text-muted)' }"
+          >
+            {{ say(channel.heading) }}
+          </h3>
+          <p
+            v-if="channel.id"
+            class="truncate text-xs tabular-nums"
+            :style="{ color: 'var(--text-muted)' }"
+          >
+            {{ channel.id }}
+          </p>
+          <p class="text-xs" :style="{ color: 'var(--text-muted)' }">
+            {{ sessionStartLine(session) }}
+          </p>
+        </div>
+      </div>
+      <span
+        class="shrink-0 self-start rounded-full border px-2.5 py-1 text-xs font-medium"
+        :style="{
+          borderColor: QUEUE_TONE_COLOUR[state.tone],
+          color: QUEUE_TONE_COLOUR[state.tone],
+        }"
+      >
+        {{ state.label }}
+      </span>
+    </header>
+
+    <p class="text-sm" :style="{ color: 'var(--text-muted)' }">{{ state.detail }}</p>
+
+    <!-- Why the id is standing in for a name, said once on the row that
+         needs it. A recordings row shows the absence and stops there;
+         somebody reading a backlog is additionally owed the reason. -->
+    <p
+      v-if="queueChannelNote(session)"
+      class="mt-2 text-xs"
+      :style="{ color: 'var(--text-muted)' }"
+    >
+      {{ queueChannelNote(session) }}
+    </p>
+
+    <dl class="mt-3 flex flex-wrap gap-x-6 gap-y-1 text-xs">
+      <div v-for="count in sessionCounts(session)" :key="count.key">
+        <dt class="inline font-medium">{{ count.label }} ·</dt>
+        <dd class="inline tabular-nums" :style="{ color: 'var(--text-muted)' }">
+          {{ count.value }}
+        </dd>
+      </div>
+    </dl>
+
+    <div class="mt-3 flex flex-wrap items-center gap-3">
+      <!-- The only link on a row, and deliberately the only control that
+           is not about order. Whether a re-queue is safe for this session
+           is decided on the recording page, once. -->
+      <NuxtLink
+        :to="recordingPath(session.id)"
+        class="rounded-lg border px-3 py-1.5 text-sm font-medium transition-colors hover:bg-[var(--surface-raised)]"
+        :style="{ borderColor: 'var(--color-brand-cyan)', color: 'var(--color-brand-cyan)' }"
+      >
+        Open this recording
+      </NuxtLink>
+      <span class="text-xs" :style="{ color: 'var(--text-muted)' }">
+        Session status
+        <code class="rounded bg-[var(--surface-raised)] px-1 font-mono">{{
+          session.status || 'unknown'
+        }}</code>
+        — asking for the transcription again is done there, where what the redo would overwrite is
+        on the screen next to the button.
+      </span>
+    </div>
+  </article>
+</template>
diff --git a/console/app/pages/admin/queue.vue b/console/app/pages/admin/queue.vue
index 97600f2..f55f7f2 100644
--- a/console/app/pages/admin/queue.vue
+++ b/console/app/pages/admin/queue.vue
@@ -12,6 +12,23 @@
  * Settings and User Settings pages use, down to the remembered choice, so
  * switching servers on one admin page carries to the others.
  *
+ * **The page is sections, and one of them used not to be.** Everything on
+ * it lived in a bordered `<section>` under an `<h2>` except the one part
+ * that grows without limit — the list of sessions, which was a bare
+ * heading followed by loose paragraphs and a stack of cards. That is why a
+ * long queue read as an endless page with nothing to navigate by, and it
+ * is also why there was nowhere to put a pager or a reordering control
+ * without hanging it off a `<div>`. The list is now two sections, split by
+ * the one distinction that decides what can be done to a row:
+ *
+ * - **In the queue** — a session with outstanding jobs, which the API
+ *   gives a `priority`. Shown in the order a worker will reach them,
+ *   reorderable, and paged.
+ * - **Listed, but not in the queue** — `priority` present and null. A
+ *   meeting being recorded now, or one nothing will move on without a
+ *   person. Shown in the order that ranks attention, and paged, and
+ *   carrying no move handle at all, because there is nothing to move.
+ *
  * Three things this page refuses to do, all three on purpose:
  *
  * - **It never presents a derived figure as a fact.** Three of the numbers
@@ -45,29 +62,30 @@
  * not to be changing, which is exactly when somebody is deciding whether
  * to believe them.
  */
+import { pageCount } from '~/utils/paging'
 import {
   CLEAR_QUEUE_HEADING,
   CLEAR_QUEUE_NOTE,
   LIFECYCLE_SCOPE_NOTE,
+  QUEUE_TONE_COLOUR,
   type GuildQueue,
   attentionItems,
+  claimOrderSessions,
   describeQueueError,
   isQueueClear,
   isQueueMoving,
   lifecycleFigures,
-  orderQueueSessions,
   parseGuildQueue,
-  queueChannelLabel,
-  queueChannelNote,
   queuePath,
-  queueSessionState,
+  queueSliceSummary,
   queueStreamPath,
-  sessionCounts,
-  sessionStartLine,
-  sessionsSummaryLine,
   startQueuePolling,
   truncationNotice,
+  unqueuedSessions,
+  unqueuedSummary,
 } from '~/utils/queue'
+import { applyQueueOrder, type QueueOrder } from '~/utils/queueOrder'
+import { QUEUE_PAGE_SIZE, pageSlice } from '~/utils/queueReorder'
 import {
   describeQueueMode,
   isQueueStreamFinished,
@@ -75,7 +93,6 @@ import {
   type QueueStreamHandle,
   type QueueStreamMode,
 } from '~/utils/queueStream'
-import { recordingPath } from '~/utils/recordings'
 import {
   chooseGuild,
   guildLabel,
@@ -141,7 +158,66 @@ const currentGuild = computed(
   () => guilds.value.find((guild) => guild.id === selected.value) ?? null,
 )
 
-const sessions = computed(() => orderQueueSessions(queue.value?.sessions ?? []))
+const say = useSay()
+
+/**
+ * The two lists this page keeps, and why they are two.
+ *
+ * A session either has a place in the queue or it does not, and the API
+ * says which by sending `priority` present-and-null. The difference is not
+ * cosmetic: the queued ones can be reordered and are shown in the order a
+ * worker will reach them, and the rest cannot be reordered at all and are
+ * shown in the order that ranks what a person still has to do. One list
+ * carrying both would have to be in one of those orders, which makes the
+ * other one wrong — and it would offer a handle on rows that have nothing
+ * to move.
+ */
+const queued = computed(() => claimOrderSessions(queue.value?.sessions ?? []))
+const waiting = computed(() => unqueuedSessions(queue.value?.sessions ?? []))
+
+/** Which page of the not-queued list is on screen. That list is not
+ *  reordered, so its window is an ordinary pager with nothing following a
+ *  grab around. */
+const waitingPage = ref(1)
+const waitingShown = computed(() => pageSlice(waiting.value, waitingPage.value))
+const waitingOffset = computed(() => (waitingPage.value - 1) * QUEUE_PAGE_SIZE)
+const waitingSummary = computed(() =>
+  queueSliceSummary(waiting.value.length, waitingOffset.value, waitingShown.value.length),
+)
+
+// A guild switched is a different list entirely, so it starts at the top.
+watch(selected, () => {
+  waitingPage.value = 1
+})
+
+// The list also shrinks on its own, as sessions finish. Clamped rather than
+// reset, because a reader on page three whose section lost one row has not
+// asked to be sent back to the beginning — but a page that no longer exists
+// is an empty section under a pager still offering it.
+watch(
+  () => waiting.value.length,
+  (count) => {
+    waitingPage.value = Math.min(waitingPage.value, pageCount(count, QUEUE_PAGE_SIZE))
+  },
+)
+
+/**
+ * The queue renumbered by an order the server has just committed to.
+ *
+ * Applied here rather than inside the panel because the answer is about
+ * the *page's* copy of the queue: every reorder changes numbers on rows
+ * nobody touched — that is what "nothing is ever moved forward" means —
+ * and a panel reaching into the page's data to say so would be a second
+ * owner of it.
+ */
+function applyOrder(order: QueueOrder) {
+  const held = queueData.value
+  if (!held?.queue) return
+  queueData.value = {
+    guildId: held.guildId,
+    queue: { ...held.queue, sessions: applyQueueOrder(held.queue.sessions, order) },
+  }
+}
 
 /**
  * The reader's clock, and `null` until there is one.
@@ -327,15 +403,6 @@ onMounted(() => {
 watch([selected, moving], () => syncWatcher())
 
 onBeforeUnmount(stopWatching)
-
-/** Three tones, three colours. Rendering "a speaker failed for good" and
- *  "a worker has it in hand" in the same grey would hide the one
- *  distinction this page exists to draw. */
-const TONE_COLOUR: Record<string, string> = {
-  clear: 'var(--color-brand-green)',
-  watch: 'var(--color-brand-cyan)',
-  alarm: 'var(--color-brand-red)',
-}
 </script>
 
 <template>
@@ -475,7 +542,7 @@ const TONE_COLOUR: Record<string, string> = {
                 </dt>
                 <dd
                   class="text-2xl font-semibold tabular-nums"
-                  :style="{ color: TONE_COLOUR[figure.tone] }"
+                  :style="{ color: QUEUE_TONE_COLOUR[figure.tone] }"
                 >
                   {{ figure.value }}
                 </dd>
@@ -511,7 +578,7 @@ const TONE_COLOUR: Record<string, string> = {
                 :key="item.key"
                 class="rounded-lg border p-3"
                 :style="{
-                  borderColor: TONE_COLOUR[item.tone],
+                  borderColor: QUEUE_TONE_COLOUR[item.tone],
                   background: 'var(--surface-raised)',
                 }"
               >
@@ -519,7 +586,7 @@ const TONE_COLOUR: Record<string, string> = {
                   <span class="text-sm font-medium">{{ item.label }}</span>
                   <span
                     class="text-lg font-semibold tabular-nums"
-                    :style="{ color: TONE_COLOUR[item.tone] }"
+                    :style="{ color: QUEUE_TONE_COLOUR[item.tone] }"
                   >
                     {{ item.value }}
                   </span>
@@ -544,16 +611,13 @@ const TONE_COLOUR: Record<string, string> = {
           </section>
 
           <template v-else>
-            <h2 class="mb-1 text-sm font-semibold">Unfinished sessions</h2>
-            <p class="mb-2 text-sm" :style="{ color: 'var(--text-muted)' }">
-              {{ sessionsSummaryLine(sessions) }}
-            </p>
             <!-- Otherwise a page showing twenty sessions reads as "there
                  are twenty", which is the one question a backlog page is
-                 opened with. -->
+                 opened with. Above both sections rather than inside one,
+                 because the cut is made before either exists. -->
             <p
               v-if="truncation"
-              class="mb-4 rounded-lg border p-3 text-xs"
+              class="mb-6 rounded-lg border p-3 text-xs"
               :style="{ borderColor: 'var(--color-brand-yellow)', background: 'var(--surface)' }"
             >
               {{ truncation }}
@@ -564,7 +628,7 @@ const TONE_COLOUR: Record<string, string> = {
                  and a closed session missing its protocol is counted there
                  without necessarily fitting in a cut list. -->
             <p
-              v-if="sessions.length === 0"
+              v-if="queued.length === 0 && waiting.length === 0"
               class="rounded-xl border p-4 text-sm"
               :style="{
                 borderColor: 'var(--border)',
@@ -576,79 +640,69 @@ const TONE_COLOUR: Record<string, string> = {
               read them rather than this list to see whether anything is outstanding.
             </p>
 
-            <div v-else class="flex flex-col gap-4">
-              <article
-                v-for="item in sessions"
-                :key="item.id"
-                class="rounded-xl border p-4"
+            <template v-else>
+              <!-- The queue proper: what will run, in the order it will run
+                   in, with the controls that change that order. -->
+              <QueueOrderPanel
+                v-if="selected"
+                :guild-id="selected"
+                :sessions="queued"
+                @order="applyOrder"
+                @reload="reload()"
+              />
+
+              <!-- Kept apart from the queue above rather than mixed into
+                   it. These rows have no place in the queue at all — the
+                   API sends them a null priority — so there is nothing on
+                   them to reorder, and a handle offered on one would be an
+                   offer of a control that cannot exist. -->
+              <section
+                v-if="waiting.length"
+                class="mb-8 rounded-xl border p-4"
                 :style="{ borderColor: 'var(--border)', background: 'var(--surface)' }"
               >
-                <header
-                  class="mb-3 flex flex-col gap-2 sm:flex-row sm:items-start sm:justify-between"
-                >
-                  <div>
-                    <h3 class="text-sm font-semibold">{{ queueChannelLabel(item) }}</h3>
-                    <p class="text-xs" :style="{ color: 'var(--text-muted)' }">
-                      {{ sessionStartLine(item) }}
-                    </p>
-                  </div>
-                  <span
-                    class="shrink-0 self-start rounded-full border px-2.5 py-1 text-xs font-medium"
-                    :style="{
-                      borderColor: TONE_COLOUR[queueSessionState(item).tone],
-                      color: TONE_COLOUR[queueSessionState(item).tone],
-                    }"
-                  >
-                    {{ queueSessionState(item).label }}
-                  </span>
-                </header>
-
-                <!-- The badge's long form is on the row rather than in a
-                     tooltip: which of the four states a row is in decides
-                     what to do next, and nobody hovers to find that out. -->
-                <p class="text-sm" :style="{ color: 'var(--text-muted)' }">
-                  {{ queueSessionState(item).detail }}
+                <h2 class="mb-1 text-sm font-semibold">
+                  {{ $t('admin.queue.list.unqueuedHeading') }}
+                </h2>
+                <p class="mb-3 text-xs" :style="{ color: 'var(--text-muted)' }">
+                  {{ $t('admin.queue.list.unqueuedNote') }}
                 </p>
-
-                <p
-                  v-if="queueChannelNote(item)"
-                  class="mt-2 text-xs"
-                  :style="{ color: 'var(--text-muted)' }"
-                >
-                  {{ queueChannelNote(item) }}
+                <p class="mb-3 text-sm" :style="{ color: 'var(--text-muted)' }">
+                  {{ say(unqueuedSummary(waiting)) }}
                 </p>
 
-                <dl class="mt-3 flex flex-wrap gap-x-6 gap-y-1 text-xs">
-                  <div v-for="count in sessionCounts(item)" :key="count.key">
-                    <dt class="inline font-medium">{{ count.label }} ·</dt>
-                    <dd class="inline tabular-nums" :style="{ color: 'var(--text-muted)' }">
-                      {{ count.value }}
-                    </dd>
-                  </div>
-                </dl>
-
-                <div class="mt-3 flex flex-wrap items-center gap-3">
-                  <!-- The only control on a row, and deliberately the only
-                       one. Whether a re-queue is safe for this session is
-                       decided on the recording page, once. -->
-                  <NuxtLink
-                    :to="recordingPath(item.id)"
-                    class="rounded-lg border px-3 py-1.5 text-sm font-medium transition-colors hover:bg-[var(--surface-raised)]"
-                    :style="{ borderColor: 'var(--color-brand-cyan)', color: 'var(--color-brand-cyan)' }"
+                <ul
+                  class="overflow-hidden rounded-xl border"
+                  :style="{ borderColor: 'var(--border)', background: 'var(--surface-raised)' }"
+                >
+                  <li
+                    v-for="item in waitingShown"
+                    :key="item.id"
+                    class="border-t first:border-t-0"
+                    :style="{ borderColor: 'var(--border)' }"
                   >
-                    Open this recording
-                  </NuxtLink>
-                  <span class="text-xs" :style="{ color: 'var(--text-muted)' }">
-                    Session status
-                    <code class="rounded bg-[var(--surface-raised)] px-1 font-mono">{{
-                      item.status || 'unknown'
-                    }}</code>
-                    — asking for the transcription again is done there, where what the redo would
-                    overwrite is on the screen next to the button.
-                  </span>
+                    <QueueSessionRow :session="item" />
+                  </li>
+                </ul>
+
+                <div class="mt-4 flex flex-col items-center gap-2">
+                  <UiPagination
+                    :page="waitingPage"
+                    :total="waiting.length"
+                    :size="QUEUE_PAGE_SIZE"
+                    :label="$t('admin.queue.list.pagerWaiting')"
+                    @update:page="waitingPage = $event"
+                  />
+                  <p
+                    v-if="waitingSummary"
+                    class="text-sm"
+                    :style="{ color: 'var(--text-muted)' }"
+                  >
+                    {{ say(waitingSummary) }}
+                  </p>
                 </div>
-              </article>
-            </div>
+              </section>
+            </template>
           </template>
         </template>
       </template>
diff --git a/console/app/utils/queue.ts b/console/app/utils/queue.ts
index 4d5f56b..334627a 100644
--- a/console/app/utils/queue.ts
+++ b/console/app/utils/queue.ts
@@ -39,6 +39,7 @@
  */
 import { formatDuration } from '~/utils/duration'
 import { formatCount, formatMoment } from '~/utils/format'
+import type { Message } from '~/utils/message'
 
 /* -------------------------------------------------------------------- */
 /* What the API describes                                                */
@@ -81,6 +82,19 @@ export interface QueuedSession {
   status: string
   document_url: string | null
   counts: QueueCounts
+  /**
+   * The number this session's outstanding jobs are claimed in, lower
+   * first — and **`null` when it has none**.
+   *
+   * Null is not zero, and the difference is the one this page acts on.
+   * Zero is the ordinary priority and a real place in the queue; null is a
+   * session with nothing to reorder — still recording, or listed only
+   * because one of its jobs died — and a row that must therefore not offer
+   * a way to move it. The API sends the field present-and-null rather than
+   * omitting it, so this console never has to tell "no place in the queue"
+   * from "an API that predates the field".
+   */
+  priority: number | null
 }
 
 export interface GuildQueue {
@@ -129,6 +143,22 @@ function asCount(value: unknown): number {
   return Math.round(value)
 }
 
+/**
+ * A place in the queue, or `null` for a row that has none.
+ *
+ * Everything that is not a whole number becomes `null`, and that includes
+ * a negative one. The server only ever raises a priority and `0` is what
+ * untouched work carries, so a negative number is not a queue position
+ * this console has ever been able to produce — and reading one as a place
+ * would put a drag handle on a row and then argue with the server about
+ * where it went. `null` says "there is nothing here to move", which is
+ * true of a row whose priority cannot be read for any reason.
+ */
+function asPriority(value: unknown): number | null {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) return null
+  return Math.round(value)
+}
+
 function asCounts(value: unknown): QueueCounts {
   const raw = isRecord(value) ? value : {}
   return {
@@ -192,6 +222,7 @@ export function parseGuildQueue(payload: unknown): GuildQueue {
           status: asText(entry.status) ?? '',
           document_url: asText(entry.document_url),
           counts: asCounts(entry.counts),
+          priority: asPriority(entry.priority),
         },
       ]
     }),
@@ -218,15 +249,23 @@ export function queueStreamPath(guildId: string): string {
 /* Naming a session                                                      */
 /* -------------------------------------------------------------------- */
 
-/** What to call the channel a session happened in. The whole id when there
- *  is no name -- never a shortened one, since snowflakes minted in the
- *  same era share their leading digits, and a truncated id is something
- *  nobody can search a page for either. */
-export function queueChannelLabel(session: QueuedSession): string {
-  const name = session.channel_name?.trim()
-  if (name) return `#${name}`
-  return session.channel_id ? `Channel ${session.channel_id}` : 'An unnamed channel'
-}
+/**
+ * What to call the channel a session happened in.
+ *
+ * **Not a function any more, and that is the point.** This module used to
+ * answer `Channel 1240377558927872021` and the page set it as a row's
+ * heading in semibold, which is exactly the thing #141 abolished on the
+ * recordings list: eighteen digits in the heading slot read as the
+ * meeting's *name*, nobody has a meeting called that, and a column of them
+ * cannot be scanned. `channelNaming` in `~/utils/recordings` is the one
+ * answer to that question — an absence in the muted role with the id
+ * demoted underneath — and the Queue asks it rather than keeping a second,
+ * older one that no longer agrees with the rest of the console.
+ *
+ * `queueChannelNote` below stays, and is the reason the two pages differ
+ * at all: a recordings row shows an absence, and an administrator looking
+ * at a backlog is additionally owed the explanation for it.
+ */
 
 /**
  * The line under a row whose channel has no name, or `null` when it has
@@ -269,6 +308,22 @@ export function sessionStartLine(session: QueuedSession): string {
  */
 export type QueueTone = 'clear' | 'watch' | 'alarm'
 
+/**
+ * Which role token each tone is painted in.
+ *
+ * Here rather than in the page because the page is no longer the only
+ * thing that paints one: a row, the panel that reorders rows, and the
+ * lifecycle band all read the same three tones, and three copies of this
+ * map is how "a speaker failed for good" ends up green in one of them.
+ * The tokens themselves, and whether they can be read against the surface
+ * they sit on, are `main.css` and `palette.spec.ts`.
+ */
+export const QUEUE_TONE_COLOUR: Record<QueueTone, string> = {
+  clear: 'var(--color-brand-green)',
+  watch: 'var(--color-brand-cyan)',
+  alarm: 'var(--color-brand-red)',
+}
+
 /**
  * What kind of row this is.
  *
@@ -542,6 +597,61 @@ export function orderQueueSessions(sessions: readonly QueuedSession[]): QueuedSe
   })
 }
 
+/**
+ * Whether this session has a place in the queue at all.
+ *
+ * Read off the API's `priority` and never re-derived from the counts.
+ * They agree today — a session has a priority exactly when it has a
+ * pending or running job — and the moment they stop agreeing, the one
+ * that decides whether a row can be moved has to be the one the endpoint
+ * that moves it also reads. A console that worked it out for itself would
+ * offer a handle on a row the server then refuses to place.
+ */
+export function isQueued(session: QueuedSession): boolean {
+  return session.priority !== null
+}
+
+/**
+ * The sessions that have a place in the queue, in the order a worker will
+ * reach them: `(priority, id)` ascending.
+ *
+ * This is `JobQueue.claim`'s own `ORDER BY priority, id` said in
+ * TypeScript, and it is deliberately **not** `orderQueueSessions`. That
+ * one ranks rows by what a reader can still do about them, which is the
+ * right order for triage and a meaningless one to drag in: a list sorted
+ * by somebody's attention cannot express "this meeting runs before that
+ * one", so a session dropped in it would land somewhere the queue does not
+ * have. The two orders are two questions, and this page now asks both
+ * separately rather than answering one of them with the other.
+ */
+export function claimOrderSessions(sessions: readonly QueuedSession[]): QueuedSession[] {
+  return sessions
+    .filter(isQueued)
+    .sort((a, b) => {
+      const byPriority = (a.priority ?? 0) - (b.priority ?? 0)
+      if (byPriority !== 0) return byPriority
+      // Lower id first, which is what the claim does. Note this points the
+      // opposite way to `orderQueueSessions`' tiebreak, and on purpose:
+      // that one is showing the newest first, this one is showing what
+      // runs first.
+      return compareIds(a.id, b.id)
+    })
+}
+
+/**
+ * The sessions with no place in the queue, in the order they were already
+ * listed in.
+ *
+ * Nothing queued will move any of these on: the meeting is still being
+ * recorded, or every job of it is terminal and one of them died, or it
+ * closed with nothing ever queued. `orderQueueSessions` is exactly the
+ * right order for them — rows needing a person first, newest first inside
+ * that — because attention is all these rows have left to be sorted by.
+ */
+export function unqueuedSessions(sessions: readonly QueuedSession[]): QueuedSession[] {
+  return orderQueueSessions(sessions.filter((session) => !isQueued(session)))
+}
+
 /** How many rows nothing will move without a person. The headline figure
  *  for the list: twelve unfinished sessions where three are stuck says
  *  something a bare row count does not. */
@@ -549,24 +659,61 @@ export function needsPersonCount(sessions: readonly QueuedSession[]): number {
   return sessions.filter((session) => queueAttention(session) === 'needs-person').length
 }
 
-/** The line above the list, naming what it holds and how much of it is
- *  actually somebody's problem. */
-export function sessionsSummaryLine(sessions: readonly QueuedSession[]): string {
-  const total = sessions.length
-  if (total === 0) return 'No unfinished sessions are listed for this server.'
+/**
+ * The line above the queue, naming what is in it.
+ *
+ * It says one thing the old single-list summary could not: that this order
+ * is the order a worker will reach them in, and therefore the thing the
+ * controls beside it change. The stuck rows are no longer counted here
+ * because they are no longer in this list — they have a section of their
+ * own, and a count of them in the wrong section is a count nobody can
+ * reconcile with what they can see.
+ */
+export function queuedSummary(sessions: readonly QueuedSession[]): Message {
+  const count = sessions.length
+  if (count === 0) return { key: 'admin.queue.list.queuedNone' }
+  return { key: 'admin.queue.list.queuedSome', params: { count } }
+}
+
+/**
+ * The line above the sessions with nothing queued, and how many of them
+ * are somebody's problem.
+ *
+ * The two counts are kept apart for the reason the old summary kept them
+ * apart: twelve rows of which three are stuck says something a bare row
+ * count does not. What has changed is that "those are listed first" is no
+ * longer part of it — this whole section is rows nothing will move on its
+ * own, so being first inside it means nothing.
+ */
+export function unqueuedSummary(sessions: readonly QueuedSession[]): Message {
+  const count = sessions.length
+  if (count === 0) return { key: 'admin.queue.list.unqueuedNone' }
   const stuck = needsPersonCount(sessions)
-  const noun = total === 1 ? 'session' : 'sessions'
-  if (stuck === 0) {
-    return (
-      `${formatCount(total)} unfinished ${noun} here, and none of them is waiting on a person — `
-      + 'every one is either being worked on or still being recorded.'
-    )
+  if (stuck === 0) return { key: 'admin.queue.list.unqueuedWaiting', params: { count } }
+  return {
+    key: 'admin.queue.list.unqueuedStuck',
+    // `count` governs the verb, so it is the number of sessions that need
+    // somebody; the size of the section rides beside it as a value.
+    params: { count: stuck, total: sessions.length },
+  }
+}
+
+/**
+ * Which slice of a section is on screen, or `null` when the whole of it
+ * is.
+ *
+ * Null rather than "1–3 of 3". A list short enough to fit on one page
+ * needs no arithmetic underneath it, and a sentence that counts three rows
+ * a reader can see all three of reads as a page apologising for itself.
+ */
+export function queueSliceSummary(total: number, offset: number, shown: number): Message | null {
+  if (shown <= 0 || shown >= total) return null
+  return {
+    key: 'admin.queue.list.showing',
+    // Ordinals rather than quantities: these are positions in a list, and
+    // `1,024` is not a position. `i18n/README.md` draws that line.
+    params: { from: String(offset + 1), to: String(offset + shown), total: String(total) },
   }
-  const verb = stuck === 1 ? 'needs' : 'need'
-  return (
-    `${formatCount(total)} unfinished ${noun} here; ${formatCount(stuck)} of them ${verb} `
-    + 'somebody, because nothing queued will move them on. Those are listed first.'
-  )
 }
 
 /* -------------------------------------------------------------------- */
diff --git a/console/app/utils/queueOrder.ts b/console/app/utils/queueOrder.ts
new file mode 100644
index 0000000..48ead0b
--- /dev/null
+++ b/console/app/utils/queueOrder.ts
@@ -0,0 +1,345 @@
+/**
+ * What the two reorder endpoints answer, and what a person has to be told
+ * before and after asking for one.
+ *
+ * `POST /api/sessions/{id}/queue/priority` and
+ * `POST /api/guilds/{id}/queue/priority` reply with the same body — a drag
+ * and a quick action are one kind of event, "somebody changed the order
+ * work will be done in", and the console reads them through one parser for
+ * the same reason the API writes them through one serialiser.
+ *
+ * Three properties of that endpoint govern every sentence below, and none
+ * of them are softened. Each one is a way this page could make an
+ * administrator believe something untrue about their own queue:
+ *
+ * - **A reorder only ever holds sessions back.** Priority is one column
+ *   shared by every guild in the deployment, so nothing can be moved
+ *   forward; "go first" is expressed as everything that was ahead going
+ *   second. The visible consequence is that **rows nobody touched show
+ *   different numbers afterwards**, and the page must present that as the
+ *   move working rather than as something having gone wrong. The invisible
+ *   one is that holding a session back holds it back globally, behind other
+ *   servers' untouched work as well as this server's, and a quick action
+ *   that does it to a whole queue has to say so before it runs.
+ * - **A stale drag is an ordinary outcome, not an error.** Two
+ *   administrators reordering at once serialise; the second is answered
+ *   `409` with `accepted: false` and **the queue as it now stands**. That
+ *   is somebody else having moved something, which deserves a sentence and
+ *   a redrawn list — not a dialog, and not the word "failed".
+ * - **`changed` is the only thing that says whether anything happened.**
+ *   An order that already held is answered with an empty one, and somebody
+ *   who dropped a session back where it came from is owed "nothing to do"
+ *   rather than "done".
+ *
+ * Every sentence is a {@link Message} keyed under `admin.queue.*`; see
+ * `i18n/README.md` for why a module returns a key and never words.
+ */
+import type { Message } from './message'
+import type { QueuedSession } from './queue'
+
+/* -------------------------------------------------------------------- */
+/* What the endpoints answer                                             */
+/* -------------------------------------------------------------------- */
+
+/** One session's place in the queue. `priority` is never null here, unlike
+ *  the field of the same name on a queue listing: everything in this list
+ *  has outstanding work by construction, which is what having a place
+ *  means. */
+export interface QueuePosition {
+  sessionId: string
+  priority: number
+}
+
+export interface QueueOrder {
+  /** False when nothing was written. The only reason that happens is a
+   *  queue that moved under the request. */
+  accepted: boolean
+  /** The API's own words for a refusal. Never displayed — this console
+   *  writes its own sentences — but parsed so that a refusal without one
+   *  is distinguishable from a refusal this console failed to read. */
+  refusal: string | null
+  /** The sessions this request actually moved. Empty is a real answer and
+   *  means "the queue was already in this order". */
+  changed: string[]
+  /** The whole queue, in the order a worker will now reach it. */
+  order: QueuePosition[]
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function asId(value: unknown): string | null {
+  if (typeof value !== 'string') return null
+  const text = value.trim()
+  return text === '' ? null : text
+}
+
+/**
+ * The order in a payload, or `null` when the payload is not one.
+ *
+ * Null is doing real work here and is not the defensive habit
+ * `parseGuildQueue` deliberately avoids. Both a success and a stale drag
+ * answer with this shape — the difference is `accepted`, not the body — so
+ * the console asks for the body of every reply and decides from the shape
+ * whether it was answered or refused for some other reason entirely. A
+ * `404` carries `{"error": "no such session"}`, which has no order in it,
+ * and reading that as an empty queue would redraw the page as though every
+ * session had left it.
+ */
+export function parseQueueOrder(payload: unknown): QueueOrder | null {
+  if (!isRecord(payload)) return null
+  if (typeof payload.accepted !== 'boolean') return null
+  if (!Array.isArray(payload.order)) return null
+  const changed = Array.isArray(payload.changed) ? payload.changed : []
+  return {
+    accepted: payload.accepted,
+    refusal: typeof payload.refusal === 'string' ? payload.refusal : null,
+    changed: changed.flatMap((entry) => {
+      const id = asId(entry)
+      return id ? [id] : []
+    }),
+    order: payload.order.flatMap((entry) => {
+      if (!isRecord(entry)) return []
+      const id = asId(entry.session_id)
+      const priority = entry.priority
+      if (!id || typeof priority !== 'number' || !Number.isFinite(priority)) return []
+      return [{ sessionId: id, priority: Math.round(priority) }]
+    }),
+  }
+}
+
+/** Where one session is placed relative to its neighbours. The id is
+ *  escaped for the reason `queuePath` escapes its own: a string allowed to
+ *  contain a slash is a string allowed to address a different endpoint. */
+export function sessionPriorityPath(sessionId: string): string {
+  return `/sessions/${encodeURIComponent(sessionId)}/queue/priority`
+}
+
+/** Where a whole guild's queue is reordered by a rule. */
+export function guildPriorityPath(guildId: string): string {
+  return `/guilds/${encodeURIComponent(guildId)}/queue/priority`
+}
+
+/**
+ * The rows the page is showing, renumbered by the order that came back.
+ *
+ * Applied rather than waited for. The answer carries the whole queue —
+ * including, necessarily, the numbers of sessions nobody touched, because
+ * that is how "go first" is expressed — so the list can settle into the
+ * order the server just committed to without a round trip, and without the
+ * moved row appearing to snap back while a re-read is in flight.
+ *
+ * **A session missing from the answer has left the queue**, not kept its
+ * old place: the order is the whole of it, so an id that is not in it has
+ * no outstanding work any more. Its priority becomes null, which is what
+ * takes its handle away, and the row itself stays — a re-read decides
+ * whether it is still worth listing at all, and that is not this function's
+ * question.
+ */
+export function applyQueueOrder(
+  sessions: readonly QueuedSession[],
+  order: QueueOrder,
+): QueuedSession[] {
+  const places = new Map(order.order.map((position) => [position.sessionId, position.priority]))
+  return sessions.map((session) => {
+    const priority = places.get(session.id)
+    if (priority === undefined) {
+      return session.priority === null ? session : { ...session, priority: null }
+    }
+    return session.priority === priority ? session : { ...session, priority }
+  })
+}
+
+/* -------------------------------------------------------------------- */
+/* What to say once it has landed                                        */
+/* -------------------------------------------------------------------- */
+
+/** Whether a sentence about a reorder is news, a refusal, or neither. Used
+ *  for the colour of the line and nothing else — the words say the same
+ *  thing without it. */
+export type ReorderTone = 'clear' | 'watch' | 'alarm'
+
+export interface ReorderReport {
+  message: Message
+  tone: ReorderTone
+  /** Whether the page should redraw from `order`. True even for a refusal:
+   *  a 409's body is the queue as it now stands, which is exactly what a
+   *  page that has just been told its picture is stale needs. */
+  redraw: boolean
+}
+
+/**
+ * What happened, in one sentence.
+ *
+ * The refusal is deliberately not worded as a failure. Nothing broke and
+ * nobody did anything wrong: somebody else moved a session, or one
+ * finished, between the list being drawn and the drop being sent. The
+ * sentence therefore says what happened, that nothing was written, and
+ * that the list underneath is now the real order — which is the only thing
+ * that makes trying again a sensible act rather than a guess.
+ *
+ * `changed` separates "done" from "nothing to do". An administrator who
+ * dropped a session back where it started, or pressed a quick action twice,
+ * gets the second — because the alternative is a page that says "done"
+ * about a request that did nothing, which is how somebody comes to believe
+ * a reorder is in place that is not.
+ */
+export function reorderReport(order: QueueOrder): ReorderReport {
+  if (!order.accepted) {
+    return {
+      message: { key: 'admin.queue.order.stale' },
+      tone: 'watch',
+      redraw: true,
+    }
+  }
+  if (order.changed.length === 0) {
+    return {
+      message: { key: 'admin.queue.order.unchanged' },
+      tone: 'clear',
+      redraw: true,
+    }
+  }
+  return {
+    message: { key: 'admin.queue.order.moved', params: { count: order.changed.length } },
+    tone: 'clear',
+    redraw: true,
+  }
+}
+
+/** `ApiError` names it `status`; a raw `$fetch` failure may name it
+ *  `statusCode`; a request that never got a response has neither. The same
+ *  reading `describeQueueError` does, restated here rather than shared
+ *  because that one answers about a *read* and this one about a write, and
+ *  the two sets of sentences are not interchangeable. */
+function statusOf(error: unknown): number | null {
+  if (!isRecord(error)) return null
+  for (const candidate of [error.status, error.statusCode]) {
+    if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+      return candidate === 0 ? null : candidate
+    }
+  }
+  return null
+}
+
+/**
+ * A reorder the API would not do, in a sentence somebody can act on.
+ *
+ * Built from the status alone, because that is all `ApiError` carries —
+ * the API's own `{"error": …}` never reaches this console by design. The
+ * 409 is not here on purpose: it is not a failure and never travels as
+ * one, it is parsed as an order and reported by {@link reorderReport}.
+ */
+export function reorderFailure(error: unknown): Message {
+  switch (statusOf(error)) {
+    case 401:
+      return { key: 'admin.queue.order.failedSignedOut' }
+    case 403:
+    case 404:
+      // The API answers 404 both for a session that is gone and for a
+      // guild the caller does not administer, and refuses to tell them
+      // apart. One sentence has to cover both without guessing.
+      return { key: 'admin.queue.order.failedGone' }
+    case 400:
+      // Nothing a person can type reaches this endpoint: the placement is
+      // built from a list the page is holding, and the rule is one of two
+      // literals. A 400 is therefore this console's bug, and saying so is
+      // more use than a sentence that implies the reader mis-clicked.
+      return { key: 'admin.queue.order.failedRefused' }
+    case null:
+      return { key: 'admin.queue.order.failedUnreachable' }
+    default:
+      return { key: 'admin.queue.order.failedUnknown' }
+  }
+}
+
+/* -------------------------------------------------------------------- */
+/* The two quick actions                                                 */
+/* -------------------------------------------------------------------- */
+
+/** A rule the guild-wide endpoint knows. Literals of the API's own
+ *  registry: an unknown one is a 400 rather than a fallback, so this list
+ *  and `sturnus.application.priorities.KNOWN_RULES` have to agree. */
+export type QueueRuleName = 'many-participants-first' | 'short-recordings-first'
+
+export interface QueueRule {
+  rule: QueueRuleName
+  /** The button. */
+  nameKey: string
+  /** What it ranks by, beside the button, before anything is pressed. */
+  blurbKey: string
+}
+
+/**
+ * The quick actions, in the order they are offered.
+ *
+ * Biggest-meeting-first leads because it is the one that answers the
+ * question people actually arrive with — eight people are waiting on one
+ * document and one person is waiting on another.
+ */
+export const QUEUE_RULES: readonly QueueRule[] = [
+  {
+    rule: 'many-participants-first',
+    nameKey: 'admin.queue.rules.participants.name',
+    blurbKey: 'admin.queue.rules.participants.blurb',
+  },
+  {
+    rule: 'short-recordings-first',
+    nameKey: 'admin.queue.rules.short.name',
+    blurbKey: 'admin.queue.rules.short.blurb',
+  },
+]
+
+export function findQueueRule(rule: string): QueueRule | null {
+  return QUEUE_RULES.find((known) => known.rule === rule) ?? null
+}
+
+export interface RuleConfirmation {
+  title: Message
+  /** Said as separate sentences and kept separate. A paragraph carrying
+   *  all of them is skimmed exactly where the reader most needs to notice
+   *  that this reaches sessions which are not on the screen. */
+  consequences: Message[]
+  confirm: Message
+}
+
+/**
+ * What a quick action will do, said before it does it.
+ *
+ * Pressing one of these is not like pressing a button on a row. It
+ * rewrites the priority of **every** outstanding session in the server,
+ * including the ones the list was cut short of showing, and it cannot be
+ * undone by pressing it again — the numbers it wrote are the numbers that
+ * stay, and the opposite rule would hold yet more work back rather than
+ * putting anything back where it was. None of that is visible from the
+ * button, so it is said in a panel that opens where the button is, in the
+ * shape `ConsentCard` established for a decision somebody may not be able
+ * to see the whole of.
+ *
+ * The unmeasured-audio caveat is part of the shortest-first confirmation
+ * rather than a note somewhere on the page, because it is the difference
+ * between that rule being useful and being a no-op: a session nothing has
+ * ever transcribed has no measured length, ranks after every measured one,
+ * and keeps the place it had. On a queue of fresh recordings the rule
+ * therefore does very little, and somebody choosing it deserves to learn
+ * that where they are choosing it rather than afterwards.
+ */
+export function ruleConfirmation(rule: QueueRuleName): RuleConfirmation {
+  const shared: Message[] = [
+    { key: 'admin.queue.rules.wholeServer' },
+    { key: 'admin.queue.rules.neverForward' },
+    { key: 'admin.queue.rules.notUndone' },
+  ]
+  if (rule === 'short-recordings-first') {
+    return {
+      title: { key: 'admin.queue.rules.short.confirmTitle' },
+      consequences: [{ key: 'admin.queue.rules.short.unmeasured' }, ...shared],
+      confirm: { key: 'admin.queue.rules.short.confirm' },
+    }
+  }
+  return {
+    title: { key: 'admin.queue.rules.participants.confirmTitle' },
+    consequences: [{ key: 'admin.queue.rules.participants.ties' }, ...shared],
+    confirm: { key: 'admin.queue.rules.participants.confirm' },
+  }
+}
diff --git a/console/app/utils/queueReorder.ts b/console/app/utils/queueReorder.ts
new file mode 100644
index 0000000..90dc72c
--- /dev/null
+++ b/console/app/utils/queueReorder.ts
@@ -0,0 +1,240 @@
+/**
+ * Moving one session to a different place in the queue — the arithmetic,
+ * with no pointer and no element anywhere near it.
+ *
+ * A drag is the one interaction in this console that has no meaning at all
+ * until something has been decided about position, and every one of those
+ * decisions is a way a queue can be reordered into something nobody asked
+ * for. So they live here, where they are ordinary functions over lists of
+ * ids, and the page is left with the two things that genuinely need a
+ * browser: which element the pointer is over, and where focus goes.
+ *
+ * **A move is expressed relative to a neighbour, never as an index.** The
+ * API refuses an index and it is right to: an index is an absolute claim
+ * about a list the browser was showing a moment ago, and two
+ * administrators dragging at once would each be numbering a different
+ * list. `placementFor` therefore ends at `first`, `last`, or the id of the
+ * session to sit beside — a sentence that still means something after
+ * somebody else's move has landed.
+ *
+ * **A row is picked up, moved, and put down.** The alternative — one
+ * request per arrow press — sends four writes to move a session four
+ * places, and the three in the middle are orders nobody wanted the queue
+ * to be in even briefly. So a {@link Grab} is a held position: the page
+ * previews it, and one request is sent when it is dropped. A mouse drag
+ * and a keyboard move produce the same `Grab` and therefore the same
+ * request, which is what keeps the keyboard path from being a second,
+ * lesser implementation that drifts.
+ *
+ * **Nothing moved is not the same as something moved back.** A grab whose
+ * held position equals where it started yields no placement at all, so a
+ * session dragged two pixels and released costs no request — rather than a
+ * write the server would answer with `changed: []` and the page would have
+ * to word as "nothing to do" after the fact.
+ *
+ * Every sentence here is a {@link Message}, keyed under `admin.queue.*`;
+ * see `i18n/README.md` for why a module returns a key and never words.
+ */
+import type { Message } from './message'
+
+/* -------------------------------------------------------------------- */
+/* Where a session ends up                                               */
+/* -------------------------------------------------------------------- */
+
+/** The four things a drop can mean, and exactly the four the API takes. */
+export type PlacementWhere = 'first' | 'last' | 'before' | 'after'
+
+/**
+ * A placement, in the shape `POST /sessions/{id}/queue/priority` reads.
+ *
+ * `session` is the neighbour to sit beside. It is required by `before` and
+ * `after` and **refused** by `first` and `last` rather than ignored, so the
+ * field is absent from those two rather than null: the endpoint treats a
+ * placement that names both an end and a neighbour as somebody who
+ * believes they said where, and refuses the whole request.
+ */
+export interface Placement {
+  place: PlacementWhere
+  session?: string
+}
+
+/**
+ * A session picked up, and where it is currently being held.
+ *
+ * `from` and `to` are indexes into the queue's own order — the whole
+ * queue, not the page of it on screen. Paging is a window, and a window
+ * must not be able to change what a move means.
+ */
+export interface Grab {
+  id: string
+  from: number
+  to: number
+}
+
+function clamp(value: number, last: number): number {
+  return Math.min(Math.max(0, Math.floor(value)), Math.max(0, last))
+}
+
+/**
+ * Picks a session up, or `null` when it is not in this queue.
+ *
+ * Null rather than a grab at index zero. A session that is not in the list
+ * cannot be moved within it, and a grab that quietly meant "the first row"
+ * would move whichever row happened to be first — which is the one failure
+ * a reorder must not have, because it looks exactly like the feature
+ * working.
+ */
+export function grabSession(ids: readonly string[], id: string): Grab | null {
+  const at = ids.indexOf(id)
+  if (at < 0) return null
+  return { id, from: at, to: at }
+}
+
+/**
+ * The same session held one place further up or down, refusing to leave
+ * the list.
+ *
+ * Clamped rather than wrapped. A row at the top that answers ArrowUp by
+ * jumping to the bottom has moved the session to the far end of the queue
+ * on a keystroke somebody pressed to check they were already at the top.
+ */
+export function moveGrabBy(grab: Grab, total: number, delta: number): Grab {
+  return { ...grab, to: clamp(grab.to + delta, total - 1) }
+}
+
+/** The same session held at a named position — a mouse drop, or the ends
+ *  the Home and End keys ask for. */
+export function moveGrabTo(grab: Grab, total: number, at: number): Grab {
+  return { ...grab, to: clamp(at, total - 1) }
+}
+
+/**
+ * The order this queue would be in if the grab were dropped now.
+ *
+ * What the page renders while a row is being held. It is a preview and
+ * never a claim: nothing has been written until the drop is answered, and
+ * the answer is the order the page then draws.
+ */
+export function grabbedOrder(ids: readonly string[], grab: Grab): string[] {
+  const rest = ids.filter((id) => id !== grab.id)
+  const at = clamp(grab.to, rest.length)
+  return [...rest.slice(0, at), grab.id, ...rest.slice(at)]
+}
+
+/**
+ * What to ask the server for, or `null` when the grab landed where it
+ * started.
+ *
+ * The neighbour is read off the list **with the grabbed session taken
+ * out**, which is the only reading that survives a move in either
+ * direction: with it left in, "after the row above me" means one thing
+ * moving up and a different thing moving down, and the off-by-one is
+ * invisible until somebody drags a session downwards.
+ *
+ * The two ends are named as ends rather than as "after the last one",
+ * because they are the two placements that stay true when the queue
+ * changes underneath them. A session dropped at the front is meant to run
+ * first, and it should still run first if two more sessions arrive between
+ * the drop and the write.
+ */
+export function placementFor(ids: readonly string[], grab: Grab): Placement | null {
+  if (!ids.includes(grab.id)) return null
+  if (grab.to === grab.from) return null
+  const rest = ids.filter((id) => id !== grab.id)
+  const at = clamp(grab.to, rest.length)
+  if (at === 0) return { place: 'first' }
+  if (at >= rest.length) return { place: 'last' }
+  const neighbour = rest[at - 1]
+  if (neighbour === undefined) return null
+  return { place: 'after', session: neighbour }
+}
+
+/* -------------------------------------------------------------------- */
+/* The window the queue is read through                                  */
+/* -------------------------------------------------------------------- */
+
+/**
+ * How many sessions of the queue are shown at once.
+ *
+ * Five, and not the twenty `~/utils/paging` uses for recordings. A row
+ * there is a line in a list; a row here is a heading, a sentence saying
+ * what will happen next without anybody doing anything, four counts and a
+ * link — so twenty of them is several screens, which is the complaint this
+ * pager exists to answer. Twenty would also be a pager that never appears:
+ * the API cuts the list at twenty sessions, so a page of twenty is always
+ * page one of one.
+ */
+export const QUEUE_PAGE_SIZE = 5
+
+/** Which page a position in the whole queue falls on, counting from one. */
+export function pageOfIndex(index: number, size: number = QUEUE_PAGE_SIZE): number {
+  if (size <= 0) return 1
+  return Math.floor(Math.max(0, index) / size) + 1
+}
+
+/**
+ * The page the reader should be looking at while a row is held.
+ *
+ * The window follows the grab rather than the grab being confined to the
+ * window. Otherwise a keyboard move stops dead at the fifth row for a
+ * reason that is about pagination and nothing to do with the queue, and
+ * "move this to the front" — the move somebody most often wants — would be
+ * the one move the keyboard could not make.
+ */
+export function pageForGrab(grab: Grab | null, page: number, size: number = QUEUE_PAGE_SIZE): number {
+  if (!grab) return page
+  return pageOfIndex(grab.to, size)
+}
+
+/** The slice of the queue on one page. */
+export function pageSlice<T>(rows: readonly T[], page: number, size: number = QUEUE_PAGE_SIZE): T[] {
+  if (size <= 0) return [...rows]
+  const from = Math.max(0, (Math.max(1, Math.floor(page)) - 1) * size)
+  return rows.slice(from, from + size)
+}
+
+/* -------------------------------------------------------------------- */
+/* What a move sounds like                                               */
+/* -------------------------------------------------------------------- */
+
+/**
+ * What the keyboard does here, said on the control rather than left to be
+ * discovered.
+ *
+ * A reorder that is only reachable by dragging is not a control at all for
+ * anybody who does not drag, and one that is reachable by arrow keys
+ * nobody mentions is barely better. The handle carries this sentence as
+ * its description, so it is read out when the handle is focused and is on
+ * screen for everybody else.
+ */
+export const REORDER_INSTRUCTIONS: Message = { key: 'admin.queue.order.instructions' }
+
+/**
+ * Where a held row is now, for the live region that says so after every
+ * keystroke.
+ *
+ * Both numbers are strings rather than quantities: a position in a queue
+ * is an ordinal, and `1,024` is not a place — the same line `i18n/README.md`
+ * draws for page numbers and years.
+ */
+export function heldMessage(grab: Grab, total: number): Message {
+  return {
+    key: 'admin.queue.order.held',
+    params: { position: String(grab.to + 1), total: String(total) },
+  }
+}
+
+/** What was picked up, said once when it is picked up. */
+export function pickedUpMessage(label: string, grab: Grab, total: number): Message {
+  return {
+    key: 'admin.queue.order.pickedUp',
+    params: { session: label, position: String(grab.to + 1), total: String(total) },
+  }
+}
+
+/** A grab abandoned. Says the row went back, because the page has been
+ *  showing it somewhere else and the reader needs to know that undid
+ *  itself rather than half-applied. */
+export function droppedBackMessage(label: string): Message {
+  return { key: 'admin.queue.order.droppedBack', params: { session: label } }
+}
diff --git a/console/app/utils/recordings.ts b/console/app/utils/recordings.ts
index 9bf0b32..0da3fb2 100644
--- a/console/app/utils/recordings.ts
+++ b/console/app/utils/recordings.ts
@@ -218,7 +218,26 @@ export interface ChannelNaming {
   id: string | null
 }
 
-export function channelNaming(session: RecordedSession): ChannelNaming {
+/**
+ * The two fields naming a channel actually reads.
+ *
+ * Written out so that the queue page can ask the same question of its own
+ * rows without either owning a second copy of the answer. "An unresolved
+ * channel reads as an absence, not as a name" is one decision about how
+ * this console presents a snowflake, and a second implementation of it is
+ * a second answer — the one that goes on saying `Channel 1240377…` in
+ * semibold long after everybody agreed it should not.
+ *
+ * That is also why the sentence stays keyed under `recordings.*` when the
+ * Queue borrows it: one absence, one translation. `i18n/README.md` records
+ * the exception.
+ */
+export interface ChannelNamed {
+  channel_id: string
+  channel_name: string | null
+}
+
+export function channelNaming(session: ChannelNamed): ChannelNaming {
   const name = session.channel_name?.trim()
   if (name) return { named: true, heading: `#${name}`, id: null }
   return { named: false, heading: { key: 'recordings.channelUnnamed' }, id: session.channel_id }
diff --git a/console/i18n/README.md b/console/i18n/README.md
index 8f66390..77db10e 100644
--- a/console/i18n/README.md
+++ b/console/i18n/README.md
@@ -51,11 +51,11 @@ matches the file that renders it:
 | `admin.reporting.*`| `pages/admin/reporting.vue`                           |
 | `ui.*`             | `components/ui/*` — the shared controls, and the gallery |
 
-`admin.settings.*`, `admin.consents.*` and `admin.queue.*` do not exist yet:
-Bot Settings, User Settings and the Queue are still English, and are being
-rewritten in three other pull requests. They are listed so that whichever of
-those lands first does not have to invent a name, and so that two of them
-landing in parallel do not invent two.
+`admin.settings.*` and `admin.consents.*` do not exist in full yet: Bot
+Settings and User Settings are still English, and are being rewritten in
+other pull requests. They are listed so that whichever of those lands first
+does not have to invent a name, and so that two of them landing in parallel
+do not invent two.
 
 Until then `utils/queue.ts` and `utils/consents.ts` still build English
 sentences by hand, and three helpers exist only to serve them:
@@ -85,6 +85,23 @@ name (`common.formatOutline` and its two neighbours) lives in `common.*`,
 because the recording page has to say the same three words beside a
 published document and two copies of a word are two words that drift.
 
+`admin.queue.*` is half-populated on the same terms. The Queue page's older
+prose — its four lifecycle notes, its three caveats, its per-row state
+sentences — is still hard-coded English in `utils/queue.ts` and moves when
+the sweep reaches it. What is keyed is everything the reordering work added:
+the two sections the list was split into, the move handle and what it
+announces, and the two quick actions with the consequences they state before
+they run. New strings on that page go through `$t` from now on.
+
+One sentence on that page is deliberately **not** in its own namespace.
+`recordings.channelUnnamed` — the "Unnamed channel" a row shows where the
+channel's name has gone — is rendered by the Queue as well, because
+`channelNaming` in `utils/recordings.ts` is the console's single answer to
+"how is an unresolved snowflake presented", and a second copy of the string
+under `admin.queue.*` would be a second translation of one absence, free to
+drift from the first. The namespace rule holds for sentences a page owns;
+this is a sentence a *decision* owns.
+
 `ui.*` is the one namespace that does not name a page. It serves
 `app/components/ui/*` — the six shared controls every page is about to be
 built out of — and the gallery at `/dev/ui` that renders them. They are keyed
diff --git a/console/i18n/locales/de.json b/console/i18n/locales/de.json
index e63c72c..8c5c15e 100644
--- a/console/i18n/locales/de.json
+++ b/console/i18n/locales/de.json
@@ -559,6 +559,62 @@
         "outcomeRefused": "Abgelehnt, ohne dass Sturnus einen Grund genannt hat. Bei dieser Person hat sich nichts geändert."
       }
     },
+    "queue": {
+      "list": {
+        "queuedHeading": "Die Reihenfolge, in der dieser Server abgearbeitet wird",
+        "queuedNote": "Jede Sitzung, für die noch ein Auftrag wartet oder läuft, von vorn nach hinten. Genau in dieser Reihenfolge greift ein Worker zu, und genau diese Reihenfolge ändern die Bedienelemente hier.",
+        "queuedNone": "Auf diesem Server wartet und läuft nichts, also gibt es keine Reihenfolge festzulegen.",
+        "queuedSome": "Eine Sitzung wartet auf ihre Abarbeitung. | {count} Sitzungen warten auf ihre Abarbeitung, in der gezeigten Reihenfolge.",
+        "unqueuedHeading": "Aufgeführt, aber nicht in der Warteschlange",
+        "unqueuedNote": "Für diese Sitzungen wartet und läuft kein Auftrag, also gibt es nichts umzusortieren und keinen Griff zum Verschieben. Jede steht hier, weil sie gerade aufgezeichnet wird oder weil ohne eine Person nichts weitergeht.",
+        "unqueuedNone": "Für jede unfertige Sitzung dieses Servers ist Arbeit eingeplant.",
+        "unqueuedWaiting": "Eine Sitzung ist ohne eingeplante Arbeit aufgeführt und wartet nicht auf eine Person. | {count} Sitzungen sind ohne eingeplante Arbeit aufgeführt, und keine davon wartet auf eine Person.",
+        "unqueuedStuck": "Eine Sitzung hier braucht jemanden: ohne Zutun geht nichts weiter. | {count} der {total} Sitzungen hier brauchen jemanden: ohne Zutun geht nichts weiter.",
+        "showing": "Angezeigt: {from}–{to} von {total}.",
+        "pagerQueued": "Seiten der Warteschlange",
+        "pagerWaiting": "Seiten der Sitzungen ohne eingeplante Arbeit"
+      },
+      "order": {
+        "handle": "{session} verschieben",
+        "instructions": "Mit Eingabe oder Leertaste eine Sitzung aufnehmen, dann mit Pfeil hoch und runter verschieben, Pos1 nach ganz vorn, Ende nach ganz hinten. Eingabe legt sie dort ab, Escape lässt sie, wo sie war. Mit der Maus ist sie innerhalb der aktuellen Seite ziehbar.",
+        "position": "Läuft als {position} von {total}",
+        "pickedUp": "{session} aufgenommen, Platz {position} von {total}. Mit den Pfeiltasten verschieben, danach mit Eingabe ablegen.",
+        "held": "Platz {position} von {total}.",
+        "droppedBack": "{session} liegt wieder an der alten Stelle, geändert wurde nichts.",
+        "sending": "Sitzung wird verschoben…",
+        "moved": "Verschoben. Eine Sitzung hat ihren Platz gewechselt. | Verschoben. {count} Sitzungen haben den Platz gewechselt — nach vorn geht es nur, indem alles davor nach hinten rückt, deshalb tragen auch unberührte Zeilen jetzt neue Nummern.",
+        "unchanged": "Nichts zu tun: diese Warteschlange stand bereits so.",
+        "stale": "Währenddessen hat jemand anderes in dieser Warteschlange etwas verschoben, deshalb wurde nichts geschrieben. Die Liste unten zeigt die Reihenfolge, wie sie jetzt ist — bei Bedarf erneut verschieben.",
+        "failedSignedOut": "Die Anmeldung ist abgelaufen, verschoben wurde nichts. Erneut anmelden.",
+        "failedGone": "Die Sitzung ist nicht mehr in dieser Warteschlange, oder dieser Server wird von diesem Konto nicht mehr verwaltet — Sturnus antwortet auf beides gleich. Geschrieben wurde nichts; zum aktuellen Stand neu laden.",
+        "failedRefused": "Sturnus hat das als fehlerhaft abgelehnt und nichts geschrieben. Das ist ein Fehler dieser Konsole und nichts, was anders zu bedienen wäre — nur ein Neuladen der Seite hilft.",
+        "failedUnreachable": "Die API war nicht erreichbar, verschoben wurde nichts. Unten steht der zuletzt gelesene Stand.",
+        "failedUnknown": "Sturnus konnte nicht verschieben und nannte keinen Grund. Geschrieben wurde nichts."
+      },
+      "rules": {
+        "heading": "Die ganze Reihenfolge auf einmal ändern",
+        "note": "Zwei Arten, alles Ausstehende dieses Servers neu zu ordnen. Beide schreiben jede Priorität der Warteschlange neu und sagen vorher, was sie tun.",
+        "cancel": "Reihenfolge so lassen",
+        "working": "Wird neu geordnet…",
+        "wholeServer": "Das betrifft jede ausstehende Sitzung dieses Servers, auch die, für die die Liste oben zu kurz war.",
+        "neverForward": "Nichts rückt nach vorn. Dass eine Sitzung zuerst läuft, entsteht dadurch, dass alles davor nach hinten rückt — das hält Arbeit zurück, statt etwas zu beschleunigen, und zwar auch hinter der Arbeit jedes anderen Servers, nicht nur hinter der dieses Servers.",
+        "notUndone": "Die andere Schaltfläche macht das danach nicht rückgängig, sondern schreibt eine eigene Reihenfolge über die Nummern, die diese hier hinterlässt.",
+        "participants": {
+          "name": "Größte Besprechungen zuerst",
+          "blurb": "Ordnet danach, wie viele Personen in einer Sitzung aufgezeichnet wurden.",
+          "confirmTitle": "Größte Besprechungen zuerst laufen lassen?",
+          "ties": "Sitzungen mit gleich vielen Teilnehmenden behalten die Reihenfolge, die sie schon hatten.",
+          "confirm": "Nach Teilnehmenden ordnen"
+        },
+        "short": {
+          "name": "Kürzeste Aufnahmen zuerst",
+          "blurb": "Ordnet nach gemessener Audiolänge, und was nie gemessen wurde, kommt zuletzt.",
+          "confirmTitle": "Kürzeste Aufnahmen zuerst laufen lassen?",
+          "unmeasured": "Eine Aufnahme, die nie gemessen wurde, hat keine Länge zum Ordnen; sie kommt hinter jede gemessene und behält ihren bisherigen Platz. Die meisten Sitzungen sind ungemessen, bis sie einmal transkribiert wurden — bei lauter frischen Aufnahmen ändert das also kaum etwas, bei erneut eingereihten dagegen schon.",
+          "confirm": "Nach Länge ordnen"
+        }
+      }
+    },
     "settings": {
       "kindVoice": "Sprachkanäle",
       "kindStage": "Bühnenkanäle",
diff --git a/console/i18n/locales/en.json b/console/i18n/locales/en.json
index 1126f7f..be9297a 100644
--- a/console/i18n/locales/en.json
+++ b/console/i18n/locales/en.json
@@ -559,6 +559,62 @@
         "outcomeRefused": "Refused, and Sturnus did not say why. Nothing of theirs was changed."
       }
     },
+    "queue": {
+      "list": {
+        "queuedHeading": "The order this server’s work will run in",
+        "queuedNote": "Every session with a job still queued or running, first to last. This is the order a worker reaches them in, and it is the order the controls here change.",
+        "queuedNone": "Nothing is queued or running in this server, so there is no order to set.",
+        "queuedSome": "One session is waiting to run. | {count} sessions are waiting to run, in the order shown.",
+        "unqueuedHeading": "Listed, but not in the queue",
+        "unqueuedNote": "These sessions have no job queued or running, so there is nothing about them to reorder and no handle to move them by. Each one is here because it is being recorded at this moment, or because nothing will move it on without a person.",
+        "unqueuedNone": "Every unfinished session in this server has work queued for it.",
+        "unqueuedWaiting": "One session is listed with nothing queued, and it is not waiting on a person. | {count} sessions are listed with nothing queued, and none of them is waiting on a person.",
+        "unqueuedStuck": "One session here needs somebody: nothing queued will move it on. | {count} of the {total} sessions here need somebody: nothing queued will move them on.",
+        "showing": "Showing {from}–{to} of {total}.",
+        "pagerQueued": "Pages of the queue",
+        "pagerWaiting": "Pages of the sessions with nothing queued"
+      },
+      "order": {
+        "handle": "Move {session}",
+        "instructions": "Press Enter or Space to pick a session up, then Up and Down to move it, Home to send it to the front and End to the back. Enter puts it down where it is; Escape leaves it where it was. It can also be dragged with a mouse, within the page it is on.",
+        "position": "Runs {position} of {total}",
+        "pickedUp": "{session} picked up, position {position} of {total}. Move it with the arrow keys, then press Enter to put it down.",
+        "held": "Position {position} of {total}.",
+        "droppedBack": "{session} was put back where it was, and nothing was changed.",
+        "sending": "Moving this session…",
+        "moved": "Moved. One session’s place in this queue changed. | Moved. {count} sessions changed place — going first is expressed as everything that was ahead going second, so rows nobody touched carry new numbers too.",
+        "unchanged": "Nothing to do: this queue was already in that order.",
+        "stale": "Somebody else moved something in this queue while that was in the air, so nothing was written. The list below is the order as it now stands — move it again if it still needs moving.",
+        "failedSignedOut": "Your session has ended, so nothing was moved. Sign in again.",
+        "failedGone": "The session has left this queue, or you no longer administer this server — Sturnus answers the same way to both. Nothing was written; refresh to see where things stand.",
+        "failedRefused": "Sturnus refused that as malformed and wrote nothing. That is a fault in this console rather than anything to do differently, so reloading the page is the only thing worth trying.",
+        "failedUnreachable": "Could not reach the API, so nothing was moved. The order below is the last one read.",
+        "failedUnknown": "Sturnus could not move it and said nothing about why. Nothing was written."
+      },
+      "rules": {
+        "heading": "Change the whole order at once",
+        "note": "Two ways to re-rank everything this server has outstanding. Each rewrites every priority in the queue, so each says what it will do before it does it.",
+        "cancel": "Leave the order alone",
+        "working": "Reordering…",
+        "wholeServer": "This reaches every session this server has outstanding, including any the list above was cut short of showing.",
+        "neverForward": "Nothing is moved forward. A session going first is expressed as everything that was ahead of it going second, so this holds work back rather than speeding anything up — and it holds it back behind every other server’s work as well, not only behind this server’s.",
+        "notUndone": "Pressing the other button afterwards does not undo this. It writes an order of its own on top of the numbers this one leaves behind.",
+        "participants": {
+          "name": "Biggest meetings first",
+          "blurb": "Ranks by how many people were recorded in each session.",
+          "confirmTitle": "Run the biggest meetings first?",
+          "ties": "Sessions with the same number of participants keep the order they already had.",
+          "confirm": "Reorder by participants"
+        },
+        "short": {
+          "name": "Shortest recordings first",
+          "blurb": "Ranks by how much audio has been measured, and a session nothing has measured ranks last.",
+          "confirmTitle": "Run the shortest recordings first?",
+          "unmeasured": "A recording nothing has ever measured has no length to rank by, so it goes after every measured one and keeps the place it had. Most sessions are unmeasured until they have been transcribed once, so on a queue of fresh recordings this changes very little — it earns its place on a queue of re-queued ones.",
+          "confirm": "Reorder by length"
+        }
+      }
+    },
     "settings": {
       "kindVoice": "Voice channels",
       "kindStage": "Stage channels",
diff --git a/console/test/adminQueuePage.spec.ts b/console/test/adminQueuePage.spec.ts
index 3f26d5f..b962ee4 100644
--- a/console/test/adminQueuePage.spec.ts
+++ b/console/test/adminQueuePage.spec.ts
@@ -21,12 +21,39 @@
  * same reason it is in `requeuePanel.spec.ts`: which of the two ways of
  * watching runs is the thing under test.
  */
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
 import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest'
 import { mount, flushPromises } from '@vue/test-utils'
-import { Suspense, computed, defineComponent, h, onBeforeUnmount, onMounted, ref, watch } from 'vue'
-
+import {
+  Suspense,
+  computed,
+  defineComponent,
+  h,
+  nextTick,
+  onBeforeUnmount,
+  onMounted,
+  ref,
+  useId,
+  watch,
+} from 'vue'
+import { createI18n, useI18n } from 'vue-i18n'
+
+import QueueOrderPanel from '../app/components/QueueOrderPanel.vue'
+import QueueSessionRow from '../app/components/QueueSessionRow.vue'
+import UiPagination from '../app/components/ui/UiPagination.vue'
+import { useSay } from '../app/composables/useSay'
 import QueuePage from '../app/pages/admin/queue.vue'
 
+/** The real locale files, loaded from disk, for the reason
+ *  `uiComponents.spec.ts` loads them: a template asking for
+ *  `admin.queue.list.queuedHeadng` renders the key at somebody, and
+ *  nothing but a render catches it. */
+function load(locale: string) {
+  return JSON.parse(readFileSync(resolve(process.cwd(), `i18n/locales/${locale}.json`), 'utf8'))
+}
+
 /** One guild, so the page renders its name rather than a switcher, and the
  *  only `<button>` on it is Refresh. */
 const GUILDS = { guilds: [{ guild_id: '1', name: 'Alpha' }] }
@@ -121,6 +148,13 @@ function stubAutoImports(api: (path: string) => Promise<unknown>) {
   vi.stubGlobal('watch', watch)
   vi.stubGlobal('onMounted', onMounted)
   vi.stubGlobal('onBeforeUnmount', onBeforeUnmount)
+  vi.stubGlobal('nextTick', nextTick)
+  vi.stubGlobal('useId', useId)
+  vi.stubGlobal('useI18n', () => ({
+    ...useI18n(),
+    locales: computed(() => [{ code: 'en', language: 'en-GB' }]),
+  }))
+  vi.stubGlobal('useSay', useSay)
   vi.stubGlobal('useHead', () => {})
   vi.stubGlobal('useApi', () => api)
   vi.stubGlobal('useAsyncData', fakeUseAsyncData())
@@ -141,7 +175,22 @@ const Host = defineComponent({
 
 async function openPage(api: ReturnType<typeof servingQueue>) {
   stubAutoImports(api as never)
-  const page = mount(Host, { global: { stubs: { NuxtLink: true } } })
+  const i18n = createI18n({
+    legacy: false,
+    locale: 'en',
+    fallbackLocale: 'en',
+    messages: { en: load('en'), de: load('de') },
+  })
+  const page = mount(Host, {
+    global: {
+      plugins: [i18n],
+      // The three components Nuxt would auto-import. Registered rather
+      // than stubbed: which section a row lands in is the thing under
+      // test, and a stub would answer that question by not asking it.
+      components: { QueueOrderPanel, QueueSessionRow, UiPagination },
+      stubs: { NuxtLink: true },
+    },
+  })
   await flushPromises()
   await flushPromises()
   return page
@@ -248,3 +297,89 @@ describe('when the queue comes to rest', () => {
     expect(page.text()).toContain('stopped reading')
   })
 })
+
+/**
+ * The page's other job, which is where a row is put.
+ *
+ * A session either has a place in the queue or it does not, and the API
+ * says which by sending `priority` present-and-null. Everything the
+ * reordering controls can do hangs on that one field being read the right
+ * way round, and the failure it prevents is silent: a handle offered on a
+ * meeting that is still being recorded is an offer of a control the server
+ * refuses, on the one row where a reader is least likely to expect one.
+ */
+function queueWith(sessions: unknown[]) {
+  return {
+    ...MOVING,
+    // Nothing in flight, so the page stops watching and the test is about
+    // the list rather than about a feed.
+    counts: { pending: 0, running: 0, done: 4, dead: 0 },
+    sessions,
+  }
+}
+
+function row(id: string, priority: number | null, extra: Record<string, unknown> = {}) {
+  return {
+    id,
+    channel_id: '555',
+    channel_name: `room-${id}`,
+    started_at: '2026-08-21T12:00:00+00:00',
+    ended_at: '2026-08-21T13:00:00+00:00',
+    status: 'closed',
+    document_url: null,
+    counts: { pending: 1, running: 0, done: 0, dead: 0 },
+    priority,
+    ...extra,
+  }
+}
+
+describe('which section a session is listed in', () => {
+  it('puts a row with a place in the queue where it can be moved', async () => {
+    withEventSource()
+    const page = await openPage(servingQueue(() => queueWith([row('7', 0)])))
+
+    expect(page.text()).toContain('The order this server’s work will run in')
+    // One handle, for the one row that has something to move.
+    expect(page.findAll('[aria-describedby]')).toHaveLength(1)
+    expect(page.text()).toContain('Runs 1 of 1')
+  })
+
+  it('gives a row with no place no handle at all, and says why', async () => {
+    withEventSource()
+    const page = await openPage(
+      servingQueue(() =>
+        queueWith([
+          row('9', null, {
+            status: 'open',
+            ended_at: null,
+            counts: { pending: 0, running: 0, done: 0, dead: 0 },
+          }),
+        ]),
+      ),
+    )
+
+    expect(page.text()).toContain('Listed, but not in the queue')
+    // Never a disabled handle. A control that cannot exist is not offered
+    // greyed out; the section says in prose that there is nothing to move.
+    expect(page.findAll('[aria-describedby]')).toHaveLength(0)
+    expect(page.text()).toContain('no handle to move them by')
+  })
+
+  it('keeps the ids secondary when a channel has lost its name', async () => {
+    // #141: an unresolved channel reads as an absence, not as a name.
+    // Eighteen digits in the heading slot read as what the meeting is
+    // called, and nobody has a meeting called `Channel 1129384756123456789`.
+    withEventSource()
+    const page = await openPage(
+      servingQueue(() =>
+        queueWith([row('7', 0, { channel_name: null, channel_id: '1129384756123456789' })]),
+      ),
+    )
+
+    const heading = page.find('article h3')
+    expect(heading.text()).toBe('Unnamed channel')
+    expect(heading.classes()).toContain('italic')
+    expect(page.text()).toContain('1129384756123456789')
+    expect(page.text()).toContain('Sturnus has no name for this channel')
+  })
+})
diff --git a/console/test/queue.spec.ts b/console/test/queue.spec.ts
index a5b7ae9..bc7e913 100644
--- a/console/test/queue.spec.ts
+++ b/console/test/queue.spec.ts
@@ -32,19 +32,23 @@ import {
   isQueueClear,
   isQueueMoving,
   lifecycleFigures,
+  claimOrderSessions,
+  isQueued,
   needsPersonCount,
   oldestPendingLine,
   orderQueueSessions,
+  queueSliceSummary,
+  queuedSummary,
+  unqueuedSessions,
+  unqueuedSummary,
   parseGuildQueue,
   pastLeaseLine,
   queueAttention,
-  queueChannelLabel,
   queueChannelNote,
   queuePath,
   queueSessionState,
   sessionCounts,
   sessionStartLine,
-  sessionsSummaryLine,
   truncationNotice,
   undocumentedLine,
   type GuildQueue,
@@ -65,6 +69,9 @@ function session(overrides: Partial<QueuedSession> & { id: string }): QueuedSess
     status: 'documented',
     document_url: 'https://outline.example/doc',
     counts: { pending: 0, running: 0, done: 4, dead: 0 },
+    // Nothing outstanding, so no place in the queue. Null is not zero:
+    // zero is a real position and null is a row with nothing to move.
+    priority: null,
     ...overrides,
   }
 }
@@ -151,6 +158,25 @@ describe('reading the queue payload', () => {
     ).toBeNull()
   })
 
+  it('keeps a place of zero and reads a missing one as no place at all', () => {
+    // The whole of the drag handle's existence hangs on this. Zero is the
+    // ordinary priority and a real position in the queue; null is a row
+    // with nothing outstanding, which is a row nothing can be moved
+    // about. Reading the two as the same would put a handle on a session
+    // that is still being recorded.
+    const rows = parseGuildQueue({
+      sessions: [
+        { id: '1', priority: 0 },
+        { id: '2', priority: null },
+        { id: '3' },
+        { id: '4', priority: 7 },
+        { id: '5', priority: -1 },
+        { id: '6', priority: 'first' },
+      ],
+    }).sessions
+    expect(rows.map((row) => row.priority)).toEqual([0, null, null, 7, null, null])
+  })
+
   it('never reports a negative or nonsensical count', () => {
     // A defect upstream must not render as "-3 pending" beside a server's
     // name, where it reads as a fact about that server.
@@ -192,18 +218,6 @@ describe('reading the queue payload', () => {
 })
 
 describe('naming a session', () => {
-  it('names the channel it happened in', () => {
-    expect(queueChannelLabel(session({ id: '1', channel_name: 'meeting' }))).toBe('#meeting')
-  })
-
-  it('falls back to the whole channel id, never a shortened one', () => {
-    // Snowflakes minted in the same era share their leading digits, so a
-    // truncated id names a group rather than a channel.
-    expect(
-      queueChannelLabel(session({ id: '1', channel_name: null, channel_id: '1129384756123456789' })),
-    ).toBe('Channel 1129384756123456789')
-  })
-
   it('says why a row has an id instead of a name', () => {
     // A bare snowflake where every other row carries a #name reads as a
     // fault in the console. It is not one.
@@ -443,24 +457,87 @@ describe('how much of the list is somebody’s problem', () => {
     ).toBe(2)
   })
 
-  it('says how many rows need a person and that they are listed first', () => {
-    const line = sessionsSummaryLine([
-      session({ id: '1', counts: counts({ dead: 1 }) }),
-      session({ id: '2', document_url: null, counts: counts({ running: 1 }) }),
-    ])
-    expect(line).toContain('2 unfinished sessions here')
-    expect(line).toContain('1 of them needs somebody')
-    expect(line).toContain('Those are listed first.')
+  it('counts the rows needing somebody, and the size of the section beside it', () => {
+    // Two numbers rather than one: twelve rows of which three are stuck
+    // says something a bare row count does not.
+    expect(
+      unqueuedSummary([
+        session({ id: '1', counts: counts({ dead: 1 }) }),
+        session({ id: '2', status: 'open', ended_at: null, document_url: null, counts: counts() }),
+      ]),
+    ).toEqual({ key: 'admin.queue.list.unqueuedStuck', params: { count: 1, total: 2 } })
   })
 
   it('says outright when none of them is waiting on a person', () => {
-    const line = sessionsSummaryLine([session({ id: '1', document_url: null, counts: counts({ running: 1 }) })])
-    expect(line).toContain('1 unfinished session here')
-    expect(line).toContain('none of them is waiting on a person')
+    expect(
+      unqueuedSummary([
+        session({ id: '1', status: 'open', ended_at: null, document_url: null, counts: counts() }),
+      ]),
+    ).toEqual({ key: 'admin.queue.list.unqueuedWaiting', params: { count: 1 } })
+  })
+
+  it('has something to say about either section being empty', () => {
+    expect(unqueuedSummary([])).toEqual({ key: 'admin.queue.list.unqueuedNone' })
+    expect(queuedSummary([])).toEqual({ key: 'admin.queue.list.queuedNone' })
+  })
+
+  it('counts the queue by how many are waiting to run', () => {
+    expect(queuedSummary([session({ id: '1', priority: 0 })])).toEqual({
+      key: 'admin.queue.list.queuedSome',
+      params: { count: 1 },
+    })
+  })
+})
+
+describe('splitting the list by whether a row is in the queue at all', () => {
+  it('reads the place off the API rather than working one out', () => {
+    // The field that decides whether a row can be moved has to be the one
+    // the endpoint that moves it also reads. A console that derived it
+    // from the counts would offer a handle the server then refuses.
+    expect(isQueued(session({ id: '1', priority: 0 }))).toBe(true)
+    expect(isQueued(session({ id: '1', priority: null }))).toBe(false)
+  })
+
+  it('lists the queued ones in the order a worker will claim them', () => {
+    // `ORDER BY priority, id`: lower priority first, and the lower id
+    // first within a priority, which is the opposite way round to the
+    // triage order and deliberately so.
+    const ordered = claimOrderSessions([
+      session({ id: '30', priority: 1 }),
+      session({ id: '20', priority: 0 }),
+      session({ id: '10', priority: 1 }),
+      session({ id: '40', priority: null }),
+    ])
+    expect(ordered.map((row) => row.id)).toEqual(['20', '10', '30'])
   })
 
-  it('has something to say about an empty list', () => {
-    expect(sessionsSummaryLine([])).toBe('No unfinished sessions are listed for this server.')
+  it('leaves every row with no place out of the queue entirely', () => {
+    expect(claimOrderSessions([session({ id: '1', priority: null })])).toEqual([])
+  })
+
+  it('ranks the rest by what a person still has to do about them', () => {
+    const rest = unqueuedSessions([
+      session({ id: '1', priority: null, status: 'open', ended_at: null, document_url: null }),
+      session({ id: '2', priority: null, counts: counts({ dead: 1 }) }),
+      session({ id: '3', priority: 0, counts: counts({ pending: 1 }) }),
+    ])
+    expect(rest.map((row) => row.id)).toEqual(['2', '1'])
+  })
+
+  it('says nothing underneath a section short enough to be read whole', () => {
+    // A sentence counting three rows a reader can see all three of reads
+    // as a page apologising for itself.
+    expect(queueSliceSummary(3, 0, 3)).toBeNull()
+    expect(queueSliceSummary(0, 0, 0)).toBeNull()
+  })
+
+  it('says which slice is on screen once there is more than one', () => {
+    expect(queueSliceSummary(12, 5, 5)).toEqual({
+      key: 'admin.queue.list.showing',
+      // Strings: a position in a list is an ordinal, and `1,024` is not a
+      // position.
+      params: { from: '6', to: '10', total: '12' },
+    })
   })
 })
 
diff --git a/console/test/queueOrder.spec.ts b/console/test/queueOrder.spec.ts
new file mode 100644
index 0000000..30d0550
--- /dev/null
+++ b/console/test/queueOrder.spec.ts
@@ -0,0 +1,210 @@
+/**
+ * What the reorder endpoints answer, and what a person is told about it.
+ *
+ * Two of these are worth more than the rest, and both are about a reply
+ * that is not a success:
+ *
+ * - **A 409 carries an order, and an order is what it has to be read as.**
+ *   Two administrators reordering at once serialise, and the loser gets
+ *   the queue as it now stands. Reading that as a failure would throw away
+ *   the one thing a page whose picture has just gone stale actually needs.
+ * - **`{"error": "no such session"}` is not an empty queue.** It has no
+ *   `order` in it, and a parser that shrugged and returned one would
+ *   redraw the page as though every session had left the queue at once.
+ *
+ * The wording is asserted as keys rather than as sentences, because these
+ * functions return keys -- see `i18n/README.md`. What the keys say is
+ * `i18n.spec.ts`'s business, and that both files say it is too.
+ */
+import { describe, expect, it } from 'vitest'
+
+import type { QueuedSession } from '../app/utils/queue'
+import {
+  QUEUE_RULES,
+  applyQueueOrder,
+  findQueueRule,
+  guildPriorityPath,
+  parseQueueOrder,
+  reorderFailure,
+  reorderReport,
+  ruleConfirmation,
+  sessionPriorityPath,
+} from '../app/utils/queueOrder'
+
+function session(id: string, priority: number | null): QueuedSession {
+  return {
+    id,
+    channel_id: '555',
+    channel_name: 'meeting',
+    started_at: '2026-08-21T12:00:00+00:00',
+    ended_at: '2026-08-21T13:00:00+00:00',
+    status: 'closed',
+    document_url: null,
+    counts: { pending: 1, running: 0, done: 0, dead: 0 },
+    priority,
+  }
+}
+
+const ACCEPTED = {
+  accepted: true,
+  refusal: null,
+  changed: ['512'],
+  order: [
+    { session_id: '77', priority: 0 },
+    { session_id: '512', priority: 1 },
+  ],
+}
+
+describe('reading what the endpoints answered', () => {
+  it('reads a success', () => {
+    expect(parseQueueOrder(ACCEPTED)).toEqual({
+      accepted: true,
+      refusal: null,
+      changed: ['512'],
+      order: [
+        { sessionId: '77', priority: 0 },
+        { sessionId: '512', priority: 1 },
+      ],
+    })
+  })
+
+  it('reads a stale drag as an order, because that is what it is', () => {
+    const refused = parseQueueOrder({ ...ACCEPTED, accepted: false, changed: [], refusal: 'moved' })
+    expect(refused?.accepted).toBe(false)
+    expect(refused?.refusal).toBe('moved')
+    expect(refused?.order).toHaveLength(2)
+  })
+
+  it('refuses a reply that is not an order at all', () => {
+    // A 404's body. Reading it as an empty queue would redraw the page as
+    // though every session had left at once.
+    expect(parseQueueOrder({ error: 'no such session' })).toBeNull()
+    expect(parseQueueOrder(null)).toBeNull()
+    expect(parseQueueOrder('nonsense')).toBeNull()
+    expect(parseQueueOrder({ accepted: true })).toBeNull()
+  })
+
+  it('drops a position it cannot read rather than inventing one', () => {
+    const order = parseQueueOrder({
+      accepted: true,
+      refusal: null,
+      changed: ['', 5, '9'],
+      order: [{ session_id: '1' }, { priority: 2 }, { session_id: '3', priority: 2 }],
+    })
+    expect(order?.order).toEqual([{ sessionId: '3', priority: 2 }])
+    expect(order?.changed).toEqual(['9'])
+  })
+})
+
+describe('where a reorder is sent', () => {
+  it('escapes an id, the same way every other path in this console does', () => {
+    expect(sessionPriorityPath('512')).toBe('/sessions/512/queue/priority')
+    expect(guildPriorityPath('../guilds/1')).toBe('/guilds/..%2Fguilds%2F1/queue/priority')
+  })
+})
+
+describe('renumbering the rows from what came back', () => {
+  it('gives every row the number the server just committed to', () => {
+    // Including rows nobody touched. That is not a bug to be hidden: it is
+    // what "nothing is ever moved forward" looks like from the page.
+    const rows = applyQueueOrder([session('77', 0), session('512', 0)], parseQueueOrder(ACCEPTED)!)
+    expect(rows.map((row) => [row.id, row.priority])).toEqual([
+      ['77', 0],
+      ['512', 1],
+    ])
+  })
+
+  it('takes the place away from a session the order does not mention', () => {
+    // The order is the whole queue, so an id missing from it has no
+    // outstanding work any more -- and a row with no place must not offer
+    // a handle.
+    const rows = applyQueueOrder([session('99', 3)], parseQueueOrder(ACCEPTED)!)
+    expect(rows[0]!.priority).toBeNull()
+  })
+
+  it('leaves a row it has nothing to say about exactly as it was', () => {
+    const rows = [session('1', null)]
+    expect(applyQueueOrder(rows, { accepted: true, refusal: null, changed: [], order: [] })[0]).toBe(
+      rows[0],
+    )
+  })
+})
+
+describe('what to say once it has landed', () => {
+  it('says how many places changed, and why untouched rows are among them', () => {
+    expect(reorderReport(parseQueueOrder(ACCEPTED)!)).toEqual({
+      message: { key: 'admin.queue.order.moved', params: { count: 1 } },
+      tone: 'clear',
+      redraw: true,
+    })
+  })
+
+  it('says "nothing to do" rather than "done" when nothing moved', () => {
+    // An administrator who dragged a session two pixels and put it back,
+    // or pressed a quick action twice. Saying "done" about a request that
+    // did nothing is how somebody comes to believe an order is in place
+    // that is not.
+    const report = reorderReport({ accepted: true, refusal: null, changed: [], order: [] })
+    expect(report.message.key).toBe('admin.queue.order.unchanged')
+  })
+
+  it('reads a refusal as somebody else having moved something, not as a failure', () => {
+    const report = reorderReport({ accepted: false, refusal: 'moved', changed: [], order: [] })
+    expect(report.message.key).toBe('admin.queue.order.stale')
+    // Redrawn from the refusal's own body, which is the queue as it now
+    // stands. That is the whole reason the body is asked for.
+    expect(report.redraw).toBe(true)
+    expect(report.tone).not.toBe('alarm')
+  })
+})
+
+describe('a reorder the API would not do', () => {
+  it('tells a signed-out reader from one who no longer administers the server', () => {
+    expect(reorderFailure({ status: 401 }).key).toBe('admin.queue.order.failedSignedOut')
+    expect(reorderFailure({ status: 404 }).key).toBe('admin.queue.order.failedGone')
+    expect(reorderFailure({ status: 403 }).key).toBe('admin.queue.order.failedGone')
+  })
+
+  it('says a malformed request is this console’s fault rather than the reader’s', () => {
+    // Nothing a person can type reaches this endpoint: the placement comes
+    // from a list the page is holding and the rule is one of two literals.
+    expect(reorderFailure({ status: 400 }).key).toBe('admin.queue.order.failedRefused')
+  })
+
+  it('tells "could not reach it" from "it answered"', () => {
+    expect(reorderFailure({ status: 0 }).key).toBe('admin.queue.order.failedUnreachable')
+    expect(reorderFailure(new Error('offline')).key).toBe('admin.queue.order.failedUnreachable')
+    expect(reorderFailure({ status: 500 }).key).toBe('admin.queue.order.failedUnknown')
+  })
+})
+
+describe('the two quick actions', () => {
+  it('names exactly the rules the API has', () => {
+    // Literals of the API's own registry. An unknown one is a 400 rather
+    // than a fallback, so this list and `KNOWN_RULES` have to agree.
+    expect(QUEUE_RULES.map((rule) => rule.rule)).toEqual([
+      'many-participants-first',
+      'short-recordings-first',
+    ])
+    expect(findQueueRule('newest-first')).toBeNull()
+  })
+
+  it('says the three things a button cannot show, before it is pressed', () => {
+    const keys = ruleConfirmation('many-participants-first').consequences.map((line) => line.key)
+    // It reaches sessions the list was cut short of showing; it holds work
+    // back rather than speeding anything up; and the other button does not
+    // undo it.
+    expect(keys).toContain('admin.queue.rules.wholeServer')
+    expect(keys).toContain('admin.queue.rules.neverForward')
+    expect(keys).toContain('admin.queue.rules.notUndone')
+  })
+
+  it('warns the shortest-first rule does little on a queue of fresh recordings', () => {
+    // Null is not zero: a recording nothing has measured ranks after every
+    // measured one and keeps the place it had. Somebody choosing this rule
+    // deserves to learn that where they choose it, not afterwards.
+    const confirmation = ruleConfirmation('short-recordings-first')
+    expect(confirmation.consequences[0]!.key).toBe('admin.queue.rules.short.unmeasured')
+    expect(confirmation.title.key).toBe('admin.queue.rules.short.confirmTitle')
+  })
+})
diff --git a/console/test/queueOrderPanel.spec.ts b/console/test/queueOrderPanel.spec.ts
new file mode 100644
index 0000000..962e1b6
--- /dev/null
+++ b/console/test/queueOrderPanel.spec.ts
@@ -0,0 +1,374 @@
+/**
+ * What the reordering controls do to a real queue, once there are
+ * elements.
+ *
+ * The arithmetic is `~/utils/queueReorder` and the wording is
+ * `~/utils/queueOrder`, both tested without a render. What is left for a
+ * mount to prove is the half neither module can reach, and it is the half
+ * that decides whether this is a control at all:
+ *
+ * - **A session can be moved with a keyboard, and the move that lands is
+ *   the same one a drag would have sent.** A reorder reachable only by
+ *   dragging is not a reorder for anybody who does not drag, and one
+ *   reachable by arrow keys nobody mentions is barely better — so the
+ *   handle's own description is asserted here too.
+ * - **One request per gesture.** Four arrow presses are one write, not
+ *   four, and the three intermediate orders are ones nobody asked the
+ *   queue to be in.
+ * - **A 409 reads as somebody else having moved something**, is not
+ *   spoken of as a failure, and redraws the list from the order it
+ *   carries rather than replaying a drag it has just been told is stale.
+ * - **A quick action says what it will do before it does it**, and does
+ *   nothing at all until it is confirmed.
+ *
+ * The locale files are the real ones, loaded from disk, for the reason
+ * `uiComponents.spec.ts` loads them: a template asking for a key that does
+ * not exist renders the key at somebody, and nothing but a render catches
+ * that.
+ */
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import { flushPromises, mount, type VueWrapper } from '@vue/test-utils'
+import {
+  computed,
+  nextTick,
+  onBeforeUnmount,
+  onMounted,
+  ref,
+  useId,
+  watch,
+} from 'vue'
+import { createI18n, useI18n } from 'vue-i18n'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import QueueOrderPanel from '../app/components/QueueOrderPanel.vue'
+import QueueSessionRow from '../app/components/QueueSessionRow.vue'
+import UiPagination from '../app/components/ui/UiPagination.vue'
+import { useSay } from '../app/composables/useSay'
+import type { QueuedSession } from '../app/utils/queue'
+
+function load(locale: string) {
+  return JSON.parse(readFileSync(resolve(process.cwd(), `i18n/locales/${locale}.json`), 'utf8'))
+}
+
+function session(id: string, priority: number): QueuedSession {
+  return {
+    id,
+    channel_id: `9${id}`,
+    channel_name: `room-${id}`,
+    started_at: '2026-08-21T12:00:00+00:00',
+    ended_at: '2026-08-21T13:00:00+00:00',
+    status: 'closed',
+    document_url: null,
+    counts: { pending: 1, running: 0, done: 0, dead: 0 },
+    priority,
+  }
+}
+
+const QUEUE = [session('1', 0), session('2', 1), session('3', 2), session('4', 3)]
+
+/** What the API answered, and what it was asked. */
+interface Call {
+  path: string
+  body: Record<string, string>
+}
+
+function order(accepted: boolean, changed: string[]) {
+  return {
+    accepted,
+    refusal: accepted ? null : 'the queue moved',
+    changed,
+    order: QUEUE.map((row, index) => ({ session_id: row.id, priority: index })),
+  }
+}
+
+/** Nuxt auto-imports these; vitest runs without Nuxt. */
+function stubAutoImports(api: unknown) {
+  vi.stubGlobal('ref', ref)
+  vi.stubGlobal('computed', computed)
+  vi.stubGlobal('watch', watch)
+  vi.stubGlobal('nextTick', nextTick)
+  vi.stubGlobal('onMounted', onMounted)
+  vi.stubGlobal('onBeforeUnmount', onBeforeUnmount)
+  vi.stubGlobal('useId', useId)
+  vi.stubGlobal('useApi', () => api)
+  vi.stubGlobal('useSay', useSay)
+  vi.stubGlobal('useI18n', () => ({
+    ...useI18n(),
+    locales: computed(() => [{ code: 'en', language: 'en-GB' }]),
+  }))
+}
+
+function open(answer: (call: Call) => unknown, sessions: QueuedSession[] = QUEUE) {
+  const calls: Call[] = []
+  const api = vi.fn((path: string, options: Record<string, unknown>) => {
+    const call = { path, body: options.body as Record<string, string> }
+    calls.push(call)
+    const reply = answer(call)
+    // The real `useApi` hands `ofetch` an `onResponse`, which is how a 409
+    // reaches the page with its body intact. A reply carrying a status
+    // says so the same way here.
+    const status
+      = typeof reply === 'object' && reply !== null && 'accepted' in reply
+        ? (reply as { accepted: boolean }).accepted
+          ? 200
+          : 409
+        : 404
+    ;(options.onResponse as ((context: unknown) => void) | undefined)?.({ response: { status } })
+    return Promise.resolve(reply)
+  })
+  stubAutoImports(api)
+  const i18n = createI18n({
+    legacy: false,
+    locale: 'en',
+    fallbackLocale: 'en',
+    messages: { en: load('en'), de: load('de') },
+  })
+  const panel = mount(QueueOrderPanel, {
+    props: { guildId: '4711', sessions },
+    global: {
+      plugins: [i18n],
+      components: { QueueSessionRow, UiPagination },
+      stubs: { NuxtLink: true },
+    },
+    attachTo: document.body,
+  })
+  return { panel, calls, api }
+}
+
+function handles(panel: VueWrapper) {
+  return panel.findAll('ol button')
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+  document.body.innerHTML = ''
+})
+
+describe('moving a session with a keyboard', () => {
+  it('says on the page what the keys do, rather than leaving it to be found', async () => {
+    const { panel } = open(() => order(true, ['1']))
+    expect(panel.text()).toContain('Press Enter or Space to pick a session up')
+    // And the handle points at that sentence, so it is read out when the
+    // handle is focused rather than only seen.
+    const described = handles(panel)[0]!.attributes('aria-describedby')
+    expect(described).toBeTruthy()
+    expect(panel.find(`#${described}`).text()).toContain('Home to send it to the front')
+  })
+
+  it('picks a row up, says where it is, and puts it down as one request', async () => {
+    const { panel, calls } = open(() => order(true, ['1']))
+    const handle = handles(panel)[0]!
+
+    await handle.trigger('keydown', { key: 'Enter' })
+    expect(panel.text()).toContain('#room-1 picked up, position 1 of 4')
+    expect(handle.attributes('aria-pressed')).toBe('true')
+
+    await handle.trigger('keydown', { key: 'ArrowDown' })
+    await handle.trigger('keydown', { key: 'ArrowDown' })
+    // Still nothing written. Four arrow presses would otherwise be four
+    // writes, and the orders in between are ones nobody asked for.
+    expect(calls).toHaveLength(0)
+    expect(panel.text()).toContain('Position 3 of 4')
+
+    await handle.trigger('keydown', { key: 'Enter' })
+    await flushPromises()
+
+    expect(calls).toHaveLength(1)
+    expect(calls[0]).toEqual({
+      path: '/sessions/1/queue/priority',
+      // Relative to a neighbour, never an index: an index is an absolute
+      // claim about a list the browser was showing a moment ago.
+      body: { place: 'after', session: '3' },
+    })
+  })
+
+  it('sends a row to the front and to the back, which a page-bound drag cannot', async () => {
+    const { panel, calls } = open(() => order(true, ['4']))
+    const handle = handles(panel)[3]!
+
+    await handle.trigger('keydown', { key: 'Enter' })
+    await handle.trigger('keydown', { key: 'Home' })
+    await handle.trigger('keydown', { key: 'Enter' })
+    await flushPromises()
+
+    // The ends are named as ends, because they stay true if the queue
+    // changes between the drop and the write.
+    expect(calls[0]!.body).toEqual({ place: 'first' })
+  })
+
+  it('puts a row back where it was, and asks for nothing', async () => {
+    const { panel, calls } = open(() => order(true, []))
+    const handle = handles(panel)[1]!
+
+    await handle.trigger('keydown', { key: 'Enter' })
+    await handle.trigger('keydown', { key: 'ArrowDown' })
+    await handle.trigger('keydown', { key: 'Escape' })
+    await flushPromises()
+
+    expect(calls).toHaveLength(0)
+    expect(panel.text()).toContain('#room-2 was put back where it was')
+  })
+
+  it('asks for nothing when the row was dropped where it started', async () => {
+    // The server would answer `changed: []` and the page would have to
+    // word "nothing to do" after the fact. Not asking is truer and cheaper.
+    const { panel, calls } = open(() => order(true, []))
+    const handle = handles(panel)[1]!
+
+    await handle.trigger('keydown', { key: 'Enter' })
+    await handle.trigger('keydown', { key: 'ArrowUp' })
+    await handle.trigger('keydown', { key: 'ArrowDown' })
+    await handle.trigger('keydown', { key: 'Enter' })
+    await flushPromises()
+
+    expect(calls).toHaveLength(0)
+  })
+})
+
+describe('when the queue moved under a drag', () => {
+  it('says somebody else moved something, and does not call it a failure', async () => {
+    const { panel } = open(() => order(false, []))
+    const handle = handles(panel)[0]!
+
+    await handle.trigger('keydown', { key: 'Enter' })
+    await handle.trigger('keydown', { key: 'ArrowDown' })
+    await handle.trigger('keydown', { key: 'Enter' })
+    await flushPromises()
+
+    expect(panel.text()).toContain('Somebody else moved something in this queue')
+    expect(panel.text()).toContain('nothing was written')
+    // Never the word for a fault. This is the endpoint working.
+    expect(panel.text()).not.toContain('failed')
+    // And the list below is offered as the real order, which is what makes
+    // trying again a sensible act rather than a guess.
+    expect(panel.text()).toContain('the order as it now stands')
+  })
+
+  it('hands the order it carried to the page, refusal included', async () => {
+    const { panel } = open(() => order(false, []))
+    const handle = handles(panel)[0]!
+
+    await handle.trigger('keydown', { key: 'Enter' })
+    await handle.trigger('keydown', { key: 'ArrowDown' })
+    await handle.trigger('keydown', { key: 'Enter' })
+    await flushPromises()
+
+    // A 409's body is the queue as it now stands, which is exactly what a
+    // page whose picture has just gone stale needs.
+    expect(panel.emitted('order')).toHaveLength(1)
+    expect(panel.emitted('reload')).toHaveLength(1)
+  })
+})
+
+describe('when the API refuses outright', () => {
+  it('says which refusal it was, from the status alone', async () => {
+    const { panel } = open(() => ({ error: 'no such session' }))
+    const handle = handles(panel)[0]!
+
+    await handle.trigger('keydown', { key: 'Enter' })
+    await handle.trigger('keydown', { key: 'ArrowDown' })
+    await handle.trigger('keydown', { key: 'Enter' })
+    await flushPromises()
+
+    expect(panel.text()).toContain('no longer administer this server')
+    // Nothing was renumbered from a reply that carried no order.
+    expect(panel.emitted('order')).toBeUndefined()
+  })
+})
+
+describe('the quick actions', () => {
+  it('does nothing at all until it has said what it will do', async () => {
+    const { panel, calls } = open(() => order(true, ['1', '2']))
+
+    const button = panel
+      .findAll('button')
+      .find((candidate) => candidate.text() === 'Shortest recordings first')!
+    await button.trigger('click')
+
+    expect(calls).toHaveLength(0)
+    expect(panel.text()).toContain('Run the shortest recordings first?')
+    // The three things a button cannot show.
+    expect(panel.text()).toContain('including any the list above was cut short of showing')
+    expect(panel.text()).toContain('Nothing is moved forward')
+    expect(panel.text()).toContain('does not undo this')
+    // And the caveat that decides whether this rule is worth choosing at
+    // all: null is not zero, so an unmeasured recording ranks last.
+    expect(panel.text()).toContain('has no length to rank by')
+    expect(panel.text()).toContain('on a queue of fresh recordings this changes very little')
+  })
+
+  it('names the rule as one of the API’s own literals once confirmed', async () => {
+    const { panel, calls } = open(() => order(true, ['1', '2']))
+
+    await panel
+      .findAll('button')
+      .find((candidate) => candidate.text() === 'Shortest recordings first')!
+      .trigger('click')
+    await panel
+      .findAll('button')
+      .find((candidate) => candidate.text() === 'Reorder by length')!
+      .trigger('click')
+    await flushPromises()
+
+    expect(calls).toEqual([
+      { path: '/guilds/4711/queue/priority', body: { rule: 'short-recordings-first' } },
+    ])
+    expect(panel.text()).toContain('sessions changed place')
+    // Said out loud, because it is the property that makes a reorder look
+    // broken to somebody who does not know it.
+    expect(panel.text()).toContain('rows nobody touched carry new numbers')
+  })
+
+  it('leaves the order alone when the confirmation is dismissed', async () => {
+    const { panel, calls } = open(() => order(true, ['1']))
+
+    await panel
+      .findAll('button')
+      .find((candidate) => candidate.text() === 'Biggest meetings first')!
+      .trigger('click')
+    await panel
+      .findAll('button')
+      .find((candidate) => candidate.text() === 'Leave the order alone')!
+      .trigger('click')
+    await flushPromises()
+
+    expect(calls).toHaveLength(0)
+    expect(panel.text()).not.toContain('Run the biggest meetings first?')
+  })
+})
+
+describe('a queue longer than one page', () => {
+  const LONG = Array.from({ length: 12 }, (_, index) => session(String(index + 1), index))
+
+  it('shows a window on it and says which window', async () => {
+    const { panel } = open(() => order(true, []), LONG)
+
+    expect(handles(panel).length).toBeLessThan(LONG.length)
+    expect(panel.text()).toContain('Showing 1–5 of 12')
+    // The position is the row's place in the whole queue, not in the page
+    // of it on screen: a row that says "runs 2nd" on page three has told
+    // the reader nothing.
+    expect(panel.text()).toContain('Runs 1 of 12')
+  })
+
+  it('follows a held row across a page boundary rather than stopping at it', async () => {
+    // Otherwise "move this to the front" is the one move the keyboard
+    // cannot make, for a reason that is about pagination and nothing to do
+    // with the queue.
+    const { panel, calls } = open(() => order(true, ['12']), LONG)
+    await panel.findAll('nav button').find((button) => button.text() === '3')!.trigger('click')
+    await nextTick()
+
+    const handle = handles(panel)[1]!
+    await handle.trigger('keydown', { key: 'Enter' })
+    await handle.trigger('keydown', { key: 'Home' })
+    expect(panel.text()).toContain('Position 1 of 12')
+    expect(panel.text()).toContain('Showing 1–5 of 12')
+
+    await handle.trigger('keydown', { key: 'Enter' })
+    await flushPromises()
+    expect(calls[0]!.body).toEqual({ place: 'first' })
+  })
+})
diff --git a/console/test/queueReorder.spec.ts b/console/test/queueReorder.spec.ts
new file mode 100644
index 0000000..4bc540b
--- /dev/null
+++ b/console/test/queueReorder.spec.ts
@@ -0,0 +1,195 @@
+/**
+ * Where a dragged session actually goes.
+ *
+ * All of it is arithmetic over lists of ids, and all of it is a way a
+ * queue can end up in an order nobody asked for. The two that would be
+ * hardest to notice, and which each have a test of their own below:
+ *
+ * - **The neighbour is read off the list with the dragged row taken out.**
+ *   With it left in, "after the row above me" means one thing when a
+ *   session moves up and a different thing when it moves down, and the
+ *   off-by-one only appears when somebody drags downwards.
+ * - **Nothing moved sends nothing.** A session picked up and put back
+ *   would otherwise be a write the server answers `changed: []` to, and a
+ *   page that has to word "done" after the fact.
+ *
+ * Nothing here touches an element, a pointer or a key. The component
+ * decides which row the pointer is over; what that *means* is here, where
+ * it can be asked without a browser.
+ */
+import { describe, expect, it } from 'vitest'
+
+import {
+  QUEUE_PAGE_SIZE,
+  droppedBackMessage,
+  grabSession,
+  grabbedOrder,
+  heldMessage,
+  moveGrabBy,
+  moveGrabTo,
+  pageForGrab,
+  pageOfIndex,
+  pageSlice,
+  pickedUpMessage,
+  placementFor,
+} from '../app/utils/queueReorder'
+
+const QUEUE = ['a', 'b', 'c', 'd']
+
+describe('picking a session up', () => {
+  it('holds it where it already is', () => {
+    expect(grabSession(QUEUE, 'c')).toEqual({ id: 'c', from: 2, to: 2 })
+  })
+
+  it('refuses a session that is not in this queue', () => {
+    // Never a grab at index zero, which would move whichever row happened
+    // to be first -- the one failure a reorder must not have, because it
+    // looks exactly like the feature working.
+    expect(grabSession(QUEUE, 'z')).toBeNull()
+  })
+})
+
+describe('moving what is held', () => {
+  it('steps one place at a time', () => {
+    const grab = grabSession(QUEUE, 'c')!
+    expect(moveGrabBy(grab, QUEUE.length, -1).to).toBe(1)
+    expect(moveGrabBy(grab, QUEUE.length, 1).to).toBe(3)
+  })
+
+  it('refuses to leave the list rather than wrapping round it', () => {
+    // A row at the top answering ArrowUp by jumping to the bottom has sent
+    // the session to the far end of the queue on a keystroke somebody
+    // pressed to check they were already at the top.
+    const first = grabSession(QUEUE, 'a')!
+    expect(moveGrabBy(first, QUEUE.length, -1).to).toBe(0)
+    const last = grabSession(QUEUE, 'd')!
+    expect(moveGrabBy(last, QUEUE.length, 1).to).toBe(3)
+  })
+
+  it('goes to a named position, clamped to the list', () => {
+    const grab = grabSession(QUEUE, 'a')!
+    expect(moveGrabTo(grab, QUEUE.length, 2).to).toBe(2)
+    expect(moveGrabTo(grab, QUEUE.length, 99).to).toBe(3)
+    expect(moveGrabTo(grab, QUEUE.length, -5).to).toBe(0)
+  })
+
+  it('previews the order the drop would produce', () => {
+    const grab = moveGrabTo(grabSession(QUEUE, 'd')!, QUEUE.length, 1)
+    expect(grabbedOrder(QUEUE, grab)).toEqual(['a', 'd', 'b', 'c'])
+  })
+})
+
+describe('what the server is asked for', () => {
+  it('names the ends as ends rather than as a neighbour', () => {
+    // The two placements that stay true when the queue changes underneath
+    // them. A session dropped at the front is meant to run first, and it
+    // should still run first if two more arrive before the write lands.
+    expect(placementFor(QUEUE, moveGrabTo(grabSession(QUEUE, 'c')!, 4, 0))).toEqual({
+      place: 'first',
+    })
+    expect(placementFor(QUEUE, moveGrabTo(grabSession(QUEUE, 'a')!, 4, 3))).toEqual({
+      place: 'last',
+    })
+  })
+
+  it('names the neighbour from the list without the dragged row in it', () => {
+    // Moving down. `b` landing at index 2 sits after `c`, not after `b`
+    // itself -- which is what reading the neighbour off the untouched list
+    // would have said.
+    expect(placementFor(QUEUE, moveGrabTo(grabSession(QUEUE, 'b')!, 4, 2))).toEqual({
+      place: 'after',
+      session: 'c',
+    })
+  })
+
+  it('names the neighbour the same way when the row moves up', () => {
+    expect(placementFor(QUEUE, moveGrabTo(grabSession(QUEUE, 'd')!, 4, 1))).toEqual({
+      place: 'after',
+      session: 'a',
+    })
+  })
+
+  it('produces the order it asked for', () => {
+    // The property that ties the two halves together: what the preview
+    // showed and what the placement means have to be the same list.
+    for (const id of QUEUE) {
+      for (let at = 0; at < QUEUE.length; at += 1) {
+        const grab = moveGrabTo(grabSession(QUEUE, id)!, QUEUE.length, at)
+        const placement = placementFor(QUEUE, grab)
+        if (!placement) continue
+        const rest = QUEUE.filter((other) => other !== id)
+        const landed
+          = placement.place === 'first'
+            ? [id, ...rest]
+            : placement.place === 'last'
+              ? [...rest, id]
+              : rest.flatMap((other) => (other === placement.session ? [other, id] : [other]))
+        expect(landed).toEqual(grabbedOrder(QUEUE, grab))
+      }
+    }
+  })
+
+  it('asks for nothing at all when the row landed where it started', () => {
+    expect(placementFor(QUEUE, grabSession(QUEUE, 'c')!)).toBeNull()
+  })
+
+  it('asks for nothing when the session has left the queue', () => {
+    expect(placementFor(QUEUE, { id: 'z', from: 0, to: 2 })).toBeNull()
+  })
+})
+
+describe('the window the queue is read through', () => {
+  it('shows fewer rows than the recordings list, because a row here is a paragraph', () => {
+    // Twenty would also be a pager that never appears: the API cuts the
+    // list at twenty sessions, so a page of twenty is always page one of
+    // one.
+    expect(QUEUE_PAGE_SIZE).toBeLessThan(20)
+  })
+
+  it('counts pages from one', () => {
+    expect(pageOfIndex(0, 5)).toBe(1)
+    expect(pageOfIndex(4, 5)).toBe(1)
+    expect(pageOfIndex(5, 5)).toBe(2)
+  })
+
+  it('follows a held row across a page boundary', () => {
+    // Otherwise a keyboard move stops dead at the fifth row for a reason
+    // that is about pagination and nothing to do with the queue -- and
+    // "move this to the front" would be the one move the keyboard could
+    // not make.
+    expect(pageForGrab({ id: 'x', from: 0, to: 7 }, 1, 5)).toBe(2)
+    expect(pageForGrab(null, 3, 5)).toBe(3)
+  })
+
+  it('cuts the list into the slice on screen', () => {
+    expect(pageSlice([1, 2, 3, 4, 5, 6, 7], 2, 3)).toEqual([4, 5, 6])
+    expect(pageSlice([1, 2], 9, 3)).toEqual([])
+  })
+})
+
+describe('what a move sounds like', () => {
+  it('says where a held row is now, as a position rather than a quantity', () => {
+    // `1,024` is not a place. The same line `i18n/README.md` draws for
+    // page numbers and years.
+    expect(heldMessage({ id: 'a', from: 0, to: 3 }, 12)).toEqual({
+      key: 'admin.queue.order.held',
+      params: { position: '4', total: '12' },
+    })
+  })
+
+  it('names what was picked up, once, when it is picked up', () => {
+    expect(pickedUpMessage('#standup', { id: 'a', from: 1, to: 1 }, 4)).toEqual({
+      key: 'admin.queue.order.pickedUp',
+      params: { session: '#standup', position: '2', total: '4' },
+    })
+  })
+
+  it('says a grab was abandoned rather than leaving it to be inferred', () => {
+    // The list has been showing the row somewhere else, and the reader has
+    // to know that undid itself rather than half-applying.
+    expect(droppedBackMessage('#standup')).toEqual({
+      key: 'admin.queue.order.droppedBack',
+      params: { session: '#standup' },
+    })
+  })
+})