tumwater 0.4.2 → 0.4.4

package/dist/src/ui/tui/tui-pane-pending.js

@@ -3,7 +3,7 @@ import { renderMergeQueue, revisionNote, retryNote, scopeMergeQueue } from "../.
 import { cancelQueuedMerge } from "../../merge/merge-cancel.js";
 import { moveQueuedMergeToTop } from "../../merge/merge-top.js";
 import { mergeChanges } from "../../merge/merge-slot.js";
-import { orchestratorAlive } from "../../team/orchestrator-info.js";
+import { orchestratorAlive } from "../../team/team-orchestrator-info.js";
 import { queueInFlight } from "../../status/status-polls.js";
 import { renderChangeOverlaps, renderRoleChanges, renderTeamChange } from "../../change/change-render.js";
 import { scopeChangeOverlaps } from "../../change/change-data.js";
@@ -15,7 +15,9 @@ import { renderPostReviews, postReviewStatusLabel, scopePostReviews, POST_REVIEW
 import { acceptPostReview } from "../../review/post-merge-review-accept.js";
 import { squash } from "../../text/text.js";
 import { promptLineFree } from "./tui-pane-ctx.js";
+import { paneAtHead } from "./tui-pane-session.js";
 import { arrowDir } from "./tui-keymap.js";
+import { distinctOrdered } from "../../collections.js";
 import { moveEntrySelection } from "./tui-backlog.js";
 /** The overlapping-files block under the roster: empty for a no-base view (the roster above
  * already says the main branch is missing), else the CLI's renderChangeOverlaps under a
@@ -37,32 +39,19 @@ export function pendingOverlapsText(view, scope) {
 export function overlapHolders(view) {
     if (view.state === "no-base")
         return [];
-    const seen = [];
-    for (const o of view.overlaps)
-        for (const r of o.roles)
-            if (!seen.includes(r))
-                seen.push(r);
-    return seen;
+    return distinctOrdered(view.overlaps.flatMap((o) => o.roles));
 }
 /** The distinct roles named across the merge queue, in first-seen (queue) order; empty for an
  * empty queue. The queue's own roles lead the pane's Ctrl+G scope cycle, before the overlap
  * holders — the queue scope is the `tumwater queue --role <id>` twin. */
 export function mergeQueueRoles(view) {
-    const seen = [];
-    for (const e of view.entries)
-        if (!seen.includes(e.role))
-            seen.push(e.role);
-    return seen;
+    return distinctOrdered(view.entries.map((e) => e.role));
 }
 /** The distinct roles named across the post-merge review queue, in first-seen (FIFO) order;
  * empty for an empty queue. The review block's contribution to the pane's Ctrl+G scope cycle,
  * after the queue's roles — the review scope is the `tumwater reviews --role <id>` twin. */
 export function postReviewRoles(entries) {
-    const seen = [];
-    for (const e of entries)
-        if (!seen.includes(e.role))
-            seen.push(e.role);
-    return seen;
+    return distinctOrdered(entries.map((e) => e.role));
 }
 /** The heading over one overlap's drill-down: its place in the list and the path. */
 export function overlapDrillHeading(index, total, path) {
@@ -274,6 +263,19 @@ export function createPendingPane(session) {
             }
         }
     };
+    // Re-render the whole queue body from scratch after a filter (Ctrl+G role scope, Ctrl+O
+    // review state) cycled: rebuild the rows off the current filter, drop any overlap drill,
+    // reset the composed body and the pane cache to the new content, and repaint from the top.
+    // The shared tail of the two filter-cycle arms, so both filters repaint identically.
+    const repaintQueueBody = () => {
+        rebuildQueueRows();
+        overlapIndex = -1;
+        ++drillGen;
+        head = queueAndReviews() + rosterText;
+        compose();
+        session.paneCache = base;
+        paneAtHead(session);
+    };
     const refresh = () => {
         // Generation guard: each refresh bumps the counter, and a resolution paints only if it
         // is the latest request's — Ctrl+R held twice, or a refresh raced with a re-entry,
@@ -307,275 +309,314 @@ export function createPendingPane(session) {
             session.requestRender();
         });
     };
-    const handleKey = (key, ctx) => {
-        if (key.ctrl && key.name === "r" && promptLineFree(ctx.es) && session.view === session.roleIds.length + 5) {
-            // Ctrl+R on the Pending pane refreshes in place — the terminal twin of the dashboard
-            // Pending view's Refresh button: re-read the durable merge queue and restart the
-            // change-roster collector, painting what the queue holds now. The pane re-enters at
-            // its head so the changed body starts at the top; the roster's git read is a fresh
-            // collector run, and a run already in flight is superseded by the new read.
-            refresh();
-            session.paneScroll = 0;
-            session.requestRender();
-            return true;
-        }
-        if (key.ctrl && key.name === "g" && promptLineFree(ctx.es) && session.view === session.roleIds.length + 5) {
-            const queueRoles = lastQueue ? mergeQueueRoles(lastQueue) : [];
-            const reviewRoles = postReviewRoles(lastReviews);
-            const holders = lastOverlaps?.state === "ready" ? overlapHolders(lastOverlaps) : [];
-            const roles = [
-                ...queueRoles,
-                ...reviewRoles.filter((r) => !queueRoles.includes(r)),
-                ...holders.filter((h) => !queueRoles.includes(h) && !reviewRoles.includes(h)),
-            ];
-            if (roles.length === 0) {
-                roleScope = null;
-                rebuildQueueRows();
-                head = queueAndReviews() + rosterText;
-                compose();
-                session.paneCache = base;
-                session.flashMessage("no queued merges, post-merge reviews or overlapping files to scope");
-                return true;
-            }
-            const slots = [null, ...roles];
-            const at = roleScope === null ? 0 : slots.indexOf(roleScope);
-            roleScope = slots[(at + 1) % slots.length] ?? null;
+    // The shared Pending-pane key-arm guard: the prompt line is free (an editor would keep the
+    // key for its own view's meaning) and the Pending view (roleIds.length + 5) is current. True
+    // means the arm may run.
+    const onPendingView = (ctx) => promptLineFree(ctx.es) && session.view === session.roleIds.length + 5;
+    // Ctrl+R on the Pending pane refreshes in place — the terminal twin of the dashboard
+    // Pending view's Refresh button: re-read the durable merge queue and restart the
+    // change-roster collector, painting what the queue holds now. The pane re-enters at
+    // its head so the changed body starts at the top; the roster's git read is a fresh
+    // collector run, and a run already in flight is superseded by the new read.
+    const pendingRefresh = (ctx) => {
+        if (!onPendingView(ctx))
+            return false;
+        refresh();
+        paneAtHead(session);
+        return true;
+    };
+    // Ctrl+G on the Pending pane cycles roleScope through each role the merge queue, the
+    // post-merge reviews and the overlapping files name and back to all (the `queue --role <id>`,
+    // `reviews --role <id>` and `diff --overlaps --role <id>` twins, one scope covering all three
+    // surfaces); with nothing to scope it resets to null and flashes the empty message. Rebounds
+    // the queue and review rows off the new scope and repaints from the top.
+    const pendingScopeCycle = (ctx) => {
+        if (!onPendingView(ctx))
+            return false;
+        const queueRoles = lastQueue ? mergeQueueRoles(lastQueue) : [];
+        const reviewRoles = postReviewRoles(lastReviews);
+        const holders = lastOverlaps?.state === "ready" ? overlapHolders(lastOverlaps) : [];
+        const roles = [
+            ...queueRoles,
+            ...reviewRoles.filter((r) => !queueRoles.includes(r)),
+            ...holders.filter((h) => !queueRoles.includes(h) && !reviewRoles.includes(h)),
+        ];
+        if (roles.length === 0) {
+            roleScope = null;
             rebuildQueueRows();
-            overlapIndex = -1;
-            ++drillGen;
             head = queueAndReviews() + rosterText;
             compose();
             session.paneCache = base;
-            session.paneScroll = 0;
-            session.requestRender();
+            session.flashMessage("no queued merges, post-merge reviews or overlapping files to scope");
             return true;
         }
-        if (key.ctrl && key.name === "o" && promptLineFree(ctx.es) && session.view === session.roleIds.length + 5) {
-            // Ctrl+O on the Pending pane cycles the post-merge review state filter through all,
-            // waiting, failing and rejected and back — the `tumwater reviews --status` twin and the
-            // dashboard Post-merge reviews State picker, meaning the full state vocabulary even when
-            // the queue holds none of a state (the renderer's `no post-merge reviews matching
-            // --status …` line is the empty-selection state). Each kept review keeps its whole-queue
-            // position, so Ctrl+A still accepts the right entry under any filter. The pane's own arm
-            // is routed ahead of History's in tui-panes.ts, so it never advances the History outcome
-            // filter; the Ctrl+G role scope composes with this filter in the block's header.
-            const slots = [null, ...POST_REVIEW_STATES];
-            const at = reviewState === null ? 0 : slots.indexOf(reviewState);
-            reviewState = slots[(at + 1) % slots.length] ?? null;
-            rebuildQueueRows();
+        const slots = [null, ...roles];
+        const at = roleScope === null ? 0 : slots.indexOf(roleScope);
+        roleScope = slots[(at + 1) % slots.length] ?? null;
+        repaintQueueBody();
+        return true;
+    };
+    // Ctrl+O on the Pending pane cycles the post-merge review state filter through all,
+    // waiting, failing and rejected and back — the `tumwater reviews --status` twin and the
+    // dashboard Post-merge reviews State picker, meaning the full state vocabulary even when
+    // the queue holds none of a state (the renderer's `no post-merge reviews matching
+    // --status …` line is the empty-selection state). Each kept review keeps its whole-queue
+    // position, so Ctrl+A still accepts the right entry under any filter. The pane's own arm
+    // is routed ahead of History's in tui-panes.ts, so it never advances the History outcome
+    // filter; the Ctrl+G role scope composes with this filter in the block's header.
+    const pendingReviewStateCycle = (ctx) => {
+        if (!onPendingView(ctx))
+            return false;
+        const slots = [null, ...POST_REVIEW_STATES];
+        const at = reviewState === null ? 0 : slots.indexOf(reviewState);
+        reviewState = slots[(at + 1) % slots.length] ?? null;
+        repaintQueueBody();
+        return true;
+    };
+    // Ctrl+N on the Pending pane steps through the overlapping files, painting each holder's
+    // change limited to that file (the `tumwater diff --role a,b --path <path>` view), scoped
+    // by the Ctrl+G role selection; an exhausted list returns to the composed base. Each step
+    // re-runs the collector guarded against a stale resolution (drill/refresh generation and
+    // the view still being current).
+    const pendingOverlapDrill = (ctx) => {
+        if (!onPendingView(ctx))
+            return false;
+        const overlaps = lastOverlaps && roleScope !== null ? scopeChangeOverlaps(lastOverlaps, [roleScope]) : lastOverlaps;
+        if (overlaps?.state !== "ready" || overlaps.overlaps.length === 0) {
+            session.flashMessage("no overlapping files to step through");
+            return true;
+        }
+        if (++overlapIndex >= overlaps.overlaps.length) {
             overlapIndex = -1;
             ++drillGen;
-            head = queueAndReviews() + rosterText;
-            compose();
             session.paneCache = base;
-            session.paneScroll = 0;
-            session.requestRender();
+            paneAtHead(session);
             return true;
         }
-        if (key.ctrl && key.name === "n" && promptLineFree(ctx.es) && session.view === session.roleIds.length + 5) {
-            const overlaps = lastOverlaps && roleScope !== null ? scopeChangeOverlaps(lastOverlaps, [roleScope]) : lastOverlaps;
-            if (overlaps?.state !== "ready" || overlaps.overlaps.length === 0) {
-                session.flashMessage("no overlapping files to step through");
-                return true;
-            }
-            if (++overlapIndex >= overlaps.overlaps.length) {
-                overlapIndex = -1;
-                ++drillGen;
-                session.paneCache = base;
-                session.paneScroll = 0;
-                session.requestRender();
-                return true;
-            }
-            const { path, roles } = overlaps.overlaps[overlapIndex];
-            const heading = overlapDrillHeading(overlapIndex, overlaps.overlaps.length, path);
-            session.paneCache = heading + "\n\nloading…";
-            session.paneScroll = 0;
+        const { path, roles } = overlaps.overlaps[overlapIndex];
+        const heading = overlapDrillHeading(overlapIndex, overlaps.overlaps.length, path);
+        session.paneCache = heading + "\n\nloading…";
+        paneAtHead(session);
+        const gen = ++drillGen;
+        const refresh0 = refreshGen;
+        const current = () => gen === drillGen && refresh0 === refreshGen && session.view === session.roleIds.length + 5;
+        void Promise.all(roles.map((r) => session.collectChange(session.root, r, { path }))).then((views) => {
+            if (!current())
+                return;
+            session.paneCache = heading + "\n\n" + renderRoleChanges({ mainBranch: overlaps.mainBranch, roles: views });
             session.requestRender();
-            const gen = ++drillGen;
-            const refresh0 = refreshGen;
-            const current = () => gen === drillGen && refresh0 === refreshGen && session.view === session.roleIds.length + 5;
-            void Promise.all(roles.map((r) => session.collectChange(session.root, r, { path }))).then((views) => {
-                if (!current())
-                    return;
-                session.paneCache = heading + "\n\n" + renderRoleChanges({ mainBranch: overlaps.mainBranch, roles: views });
-                session.requestRender();
-            }, (err) => {
-                if (!current())
-                    return;
-                session.flashError(err);
-                session.requestRender();
-            });
-            return true;
-        }
-        const arrow = arrowDir(key.name);
-        if (session.view === session.roleIds.length + 5 && arrow !== null && promptLineFree(ctx.es)) {
-            // In the Pending pane, up/down select a queued merge row in full (wrapping, the backlog
-            // pane's rule) instead of editing the prompt; an empty queue has nothing to select, so
-            // moveEntrySelection clears the selection. The selected detail shares paneScroll with the
-            // list, so a newly opened row must start at its head, or it renders scrolled into the
-            // middle of the previous row's body.
-            selectedQueue = moveEntrySelection(queueRows.length, selectedQueue, arrow);
-            const selRow = selectedQueue === null ? undefined : queueRows[selectedQueue];
-            queueDetail = selRow ? rowDetail(selRow) : "";
-            session.paneScroll = 0;
+        }, (err) => {
+            if (!current())
+                return;
+            session.flashError(err);
             session.requestRender();
+        });
+        return true;
+    };
+    // Up/down in the Pending pane select a queued merge row in full (wrapping, the backlog
+    // pane's rule) instead of editing the prompt; an empty queue has nothing to select, so
+    // moveEntrySelection clears the selection. The selected detail shares paneScroll with the
+    // list, so a newly opened row must start at its head, or it renders scrolled into the
+    // middle of the previous row's body.
+    const pendingSelectRow = (arrow, ctx) => {
+        if (!onPendingView(ctx))
+            return false;
+        selectedQueue = moveEntrySelection(queueRows.length, selectedQueue, arrow);
+        const selRow = selectedQueue === null ? undefined : queueRows[selectedQueue];
+        queueDetail = selRow ? rowDetail(selRow) : "";
+        paneAtHead(session);
+        return true;
+    };
+    // Esc on the Pending pane returns it to list mode; the cached list is untouched (nothing
+    // was cancelled), so the pane shows the same renderMergeQueue it entered with. The shared
+    // paneScroll resets with the body switch, like a selection move.
+    const pendingClearSelection = (ctx) => {
+        if (!onPendingView(ctx) || selectedQueue === null)
+            return false;
+        selectedQueue = null;
+        queueDetail = "";
+        paneAtHead(session);
+        return true;
+    };
+    // Ctrl+X on the Pending pane cancels the selected queued merge (the terminal twin of
+    // `tumwater queue --cancel <n>`): a review row names its own action, the first press on a
+    // merge arms it (any other key keeps it), and the second press re-reads the queue, guards
+    // the in-flight and shifted-away races, then removes the entry through the CLI's own core.
+    const pendingCancelMerge = (ctx) => {
+        if (!onPendingView(ctx))
+            return false;
+        const row = selectedRow();
+        if (row === null)
             return true;
-        }
-        if (key.name === "escape" && session.view === session.roleIds.length + 5 && selectedQueue !== null && promptLineFree(ctx.es)) {
-            // Esc on the Pending pane returns it to list mode; the cached list is untouched (nothing
-            // was cancelled), so the pane shows the same renderMergeQueue it entered with. The shared
-            // paneScroll resets with the body switch, like a selection move.
-            selectedQueue = null;
-            queueDetail = "";
-            session.paneScroll = 0;
+        if (row.kind === "review") {
+            session.flashMessage("that row is a post-merge review — Ctrl+A accepts it");
             session.requestRender();
             return true;
         }
-        if (key.ctrl && key.name === "x" && promptLineFree(ctx.es) && session.view === session.roleIds.length + 5) {
-            const row = selectedRow();
-            if (row === null)
-                return true;
-            if (row.kind === "review") {
-                session.flashMessage("that row is a post-merge review — Ctrl+A accepts it");
-                session.requestRender();
-                return true;
-            }
-            if (session.armedQueue?.sha === row.entry.sha && session.armedQueue?.position === row.position) {
-                // Second press on the same entry: re-read the queue, guard the in-flight race, then
-                // remove it through the CLI's own core (`tumwater queue --cancel <n>`), so the pane,
-                // the CLI, and the dashboard cancel cannot drift.
-                const confirm = async () => {
-                    if (queueShiftedAway(row))
-                        return;
-                    if (guardMergeInFlight(row))
-                        return;
-                    const outcome = await cancelQueuedMerge(session.root, row.position);
-                    if (outcome.status === "cancelled") {
-                        selectedQueue = null;
-                        queueDetail = "";
-                        session.flashMessage(`cancelled queue entry ${row.position}: ${roleLabel(outcome.role)} ${shortSha(outcome.sha)} — ${outcome.summary}`);
-                        refresh();
-                        session.requestRender();
-                    }
-                    else {
-                        selectedQueue = null;
-                        queueDetail = "";
-                        session.flashMessage("that merge already left the queue");
-                        refresh();
-                        session.requestRender();
-                    }
-                };
-                void confirm();
-            }
-            else {
-                session.queueArmed = { position: row.position, sha: row.entry.sha };
-                session.flashMessage(`press Ctrl+X again to cancel merge #${row.position} — any other key keeps it`);
-                session.requestRender();
-            }
-            return true;
-        }
-        if (key.ctrl && key.name === "a" && promptLineFree(ctx.es) && session.view === session.roleIds.length + 5) {
-            // Ctrl+A on the Pending pane accepts the selected post-merge review unreviewed (the
-            // terminal twin of `tumwater reviews --accept <n>`), once selected and twice pressed
-            // like the queue's Ctrl+X cancel. A merge row names its own action instead; an unarmed
-            // press sets reviewArmed, and the second press re-reads the queue and settles the entry
-            // through the CLI's own core, so the pane and the CLI cannot drift.
-            const review = selectedRow();
-            if (review === null)
-                return true;
-            if (review.kind === "merge") {
-                session.flashMessage("that row is a queued merge — Ctrl+X cancels it");
-                session.requestRender();
-                return true;
-            }
-            if (session.armedReview?.position === review.position && session.armedReview?.commit === review.entry.commit) {
-                const confirm = async () => {
-                    const entries = readPostReviews(session.root);
-                    if (entries[review.position - 1]?.commit !== review.entry.commit) {
-                        session.flashMessage("the review queue changed — try again");
-                        refresh();
-                        session.requestRender();
-                        return;
-                    }
-                    const outcome = acceptPostReview(session.root, review.position);
-                    if (outcome.status === "accepted") {
-                        selectedQueue = null;
-                        queueDetail = "";
-                        session.flashMessage(`accepted post-merge review of ${shortSha(outcome.commit)} unreviewed — ${outcome.summary}`);
-                        refresh();
-                        session.requestRender();
-                    }
-                    else if (outcome.status === "settled") {
-                        session.flashMessage(`review #${review.position} already merged its fix on main — nothing to accept`);
-                        refresh();
-                        session.requestRender();
-                    }
-                    else {
-                        session.flashMessage("the review queue changed — try again");
-                        refresh();
-                        session.requestRender();
-                    }
-                };
-                void confirm();
-            }
-            else {
-                session.reviewArmed = { position: review.position, commit: review.entry.commit };
-                session.flashMessage(`press Ctrl+A again to accept review #${review.position} — any other key keeps it`);
-                session.requestRender();
-            }
-            return true;
-        }
-        if (key.ctrl && key.name === "v" && promptLineFree(ctx.es) && session.view === session.roleIds.length + 5) {
-            // Move the selected merge to the head of the queue — the pane's twin of `tumwater
-            // queue --top <n>`, through the same core the CLI and the dashboard use, so the three
-            // cannot drift on the rename or the already-first/out-of-range outcomes. A single
-            // keypress is enough because the move is reversible and non-destructive (unlike
-            // Ctrl+X's two-step cancel arm).
-            const row = selectedRow();
-            if (row === null)
-                return true;
-            if (row.kind === "review") {
-                session.flashMessage("that row is a post-merge review — Ctrl+A accepts it");
-                session.requestRender();
-                return true;
-            }
-            const top = async () => {
-                if (row.position === 1) {
-                    session.flashMessage("merge #1 is already at the front");
-                    session.requestRender();
-                    return;
-                }
+        if (session.armedQueue?.sha === row.entry.sha && session.armedQueue?.position === row.position) {
+            // Second press on the same entry: re-read the queue, guard the in-flight race, then
+            // remove it through the CLI's own core (`tumwater queue --cancel <n>`), so the pane,
+            // the CLI, and the dashboard cancel cannot drift.
+            const confirm = async () => {
                 if (queueShiftedAway(row))
                     return;
                 if (guardMergeInFlight(row))
                     return;
-                const outcome = moveQueuedMergeToTop(session.root, row.position);
-                if (outcome.status === "topped") {
+                const outcome = await cancelQueuedMerge(session.root, row.position);
+                if (outcome.status === "cancelled") {
                     selectedQueue = null;
                     queueDetail = "";
-                    session.flashMessage(`moved merge #${row.position} to the front: ${roleLabel(outcome.role)} ${shortSha(outcome.sha)} — ${outcome.summary}`);
+                    session.flashMessage(`cancelled queue entry ${row.position}: ${roleLabel(outcome.role)} ${shortSha(outcome.sha)} — ${outcome.summary}`);
+                    refresh();
+                    session.requestRender();
+                }
+                else {
+                    selectedQueue = null;
+                    queueDetail = "";
+                    session.flashMessage("that merge already left the queue");
+                    refresh();
+                    session.requestRender();
+                }
+            };
+            void confirm();
+        }
+        else {
+            session.queueArmed = { position: row.position, sha: row.entry.sha };
+            session.flashMessage(`press Ctrl+X again to cancel merge #${row.position} — any other key keeps it`);
+            session.requestRender();
+        }
+        return true;
+    };
+    // Ctrl+A on the Pending pane accepts the selected post-merge review unreviewed (the
+    // terminal twin of `tumwater reviews --accept <n>`), once selected and twice pressed
+    // like the queue's Ctrl+X cancel. A merge row names its own action instead; an unarmed
+    // press sets reviewArmed, and the second press re-reads the queue and settles the entry
+    // through the CLI's own core, so the pane and the CLI cannot drift.
+    const pendingAcceptReview = (ctx) => {
+        if (!onPendingView(ctx))
+            return false;
+        const review = selectedRow();
+        if (review === null)
+            return true;
+        if (review.kind === "merge") {
+            session.flashMessage("that row is a queued merge — Ctrl+X cancels it");
+            session.requestRender();
+            return true;
+        }
+        if (session.armedReview?.position === review.position && session.armedReview?.commit === review.entry.commit) {
+            const confirm = async () => {
+                const entries = readPostReviews(session.root);
+                if (entries[review.position - 1]?.commit !== review.entry.commit) {
+                    session.flashMessage("the review queue changed — try again");
                     refresh();
                     session.requestRender();
+                    return;
                 }
-                else if (outcome.status === "already-first") {
-                    session.flashMessage(`merge #${row.position} is already at the front`);
+                const outcome = acceptPostReview(session.root, review.position);
+                if (outcome.status === "accepted") {
+                    selectedQueue = null;
+                    queueDetail = "";
+                    session.flashMessage(`accepted post-merge review of ${shortSha(outcome.commit)} unreviewed — ${outcome.summary}`);
                     refresh();
                     session.requestRender();
                 }
-                else if (outcome.status === "out-of-range") {
-                    session.flashMessage("the merge queue changed — try again");
+                else if (outcome.status === "settled") {
+                    session.flashMessage(`review #${review.position} already merged its fix on main — nothing to accept`);
                     refresh();
                     session.requestRender();
                 }
                 else {
-                    session.flashMessage("that merge already left the queue");
+                    session.flashMessage("the review queue changed — try again");
                     refresh();
                     session.requestRender();
                 }
             };
-            void top();
+            void confirm();
+        }
+        else {
+            session.reviewArmed = { position: review.position, commit: review.entry.commit };
+            session.flashMessage(`press Ctrl+A again to accept review #${review.position} — any other key keeps it`);
+            session.requestRender();
+        }
+        return true;
+    };
+    // Ctrl+V moves the selected merge to the head of the queue — the pane's twin of `tumwater
+    // queue --top <n>`, through the same core the CLI and the dashboard use, so the three
+    // cannot drift on the rename or the already-first/out-of-range outcomes. A single
+    // keypress is enough because the move is reversible and non-destructive (unlike
+    // Ctrl+X's two-step cancel arm); a review row names its own action instead.
+    const pendingMoveToTop = (ctx) => {
+        if (!onPendingView(ctx))
+            return false;
+        const row = selectedRow();
+        if (row === null)
+            return true;
+        if (row.kind === "review") {
+            session.flashMessage("that row is a post-merge review — Ctrl+A accepts it");
+            session.requestRender();
             return true;
         }
+        const top = async () => {
+            if (row.position === 1) {
+                session.flashMessage(`merge #${row.position} is already at the front`);
+                session.requestRender();
+                return;
+            }
+            if (queueShiftedAway(row))
+                return;
+            if (guardMergeInFlight(row))
+                return;
+            const outcome = moveQueuedMergeToTop(session.root, row.position);
+            if (outcome.status === "topped") {
+                selectedQueue = null;
+                queueDetail = "";
+                session.flashMessage(`moved merge #${row.position} to the front: ${roleLabel(outcome.role)} ${shortSha(outcome.sha)} — ${outcome.summary}`);
+                refresh();
+                session.requestRender();
+            }
+            else if (outcome.status === "already-first") {
+                session.flashMessage(`merge #${row.position} is already at the front`);
+                refresh();
+                session.requestRender();
+            }
+            else if (outcome.status === "out-of-range") {
+                session.flashMessage("the merge queue changed — try again");
+                refresh();
+                session.requestRender();
+            }
+            else {
+                session.flashMessage("that merge already left the queue");
+                refresh();
+                session.requestRender();
+            }
+        };
+        void top();
+        return true;
+    };
+    const ctrlRoutes = {
+        r: pendingRefresh,
+        g: pendingScopeCycle,
+        o: pendingReviewStateCycle,
+        n: pendingOverlapDrill,
+        x: pendingCancelMerge,
+        a: pendingAcceptReview,
+        v: pendingMoveToTop,
+    };
+    const ctrlRoute = (key, ctx) => {
+        if (!key.ctrl || key.name === undefined)
+            return null;
+        const route = ctrlRoutes[key.name];
+        return route === undefined ? null : route(ctx);
+    };
+    const handleKey = (key, ctx) => {
+        const ctrl = ctrlRoute(key, ctx);
+        if (ctrl !== null)
+            return ctrl;
+        const arrow = arrowDir(key.name);
+        if (arrow !== null)
+            return pendingSelectRow(arrow, ctx);
+        if (key.name === "escape")
+            return pendingClearSelection(ctx);
         return false;
     };
     return {