tumwater 0.4.2 → 0.4.4

package/dist/src/ui/tui/tui-input.js

@@ -1,4 +1,4 @@
-import { parseDurationMs } from "../../cli/cli-args.js";
+import { durationLabel, parseDurationMs } from "../../cli/cli-args.js";
 import { PAUSE_FOR_MAX_MS } from "../../operator/operator-intent.js";
 import { cutSplitsSurrogatePair, gotSuffix } from "../../text/text.js";
 import { displayWidth } from "../../text/text-width.js";
@@ -10,6 +10,16 @@ function snapCursor(text, cursor) {
     const clamp = Math.max(0, Math.min(cursor, text.length));
     return cutSplitsSurrogatePair(text, clamp) ? clamp - 1 : clamp;
 }
+/** Move the cursor one whole code point in `dir` (`-1` left, `+1` right), clamped to the
+ * text's ends — the one home of the surrogate-step rule applyKey's left and right arms
+ * shared, so neither direction can ever land between a surrogate pair's halves (a cursor
+ * there would let a later backspace/delete cut the pair in half). The step backs off one
+ * unit past the clamp when the landed index would split a pair, crossing the whole astral
+ * character instead. */
+function stepCursor(text, cursor, dir) {
+    const n = dir === -1 ? Math.max(0, cursor - 1) : Math.min(text.length, cursor + 1);
+    return cutSplitsSurrogatePair(text, n) ? n + dir : n;
+}
 /** The character immediately before index `i`, as its whole [start, i) span: a surrogate
  * pair is never split, so the backward word-scan killWordBefore runs on always steps a
  * whole character and its boundary lands where a cut is safe. Null at the text's start. */
@@ -19,6 +29,16 @@ function prevChar(text, i) {
     const start = cutSplitsSurrogatePair(text, i - 1) ? i - 2 : i - 1;
     return { start, ch: text.slice(start, i) };
 }
+/** Delete the whole character (surrogate pair or single unit) that starts at code-unit index
+ * `start` and land the cursor on the deleted range's start — the shared shape of applyKey's
+ * backspace and delete arms, which differ only in where the removed character sits relative
+ * to the cursor. A surrogate pair is deleted as both units so no lone surrogate — which
+ * terminals render as a U+FFFD box — is ever left behind (the surrogate-safe rule snapCursor
+ * and prevChar enforce elsewhere). */
+function removeCharAt(text, start) {
+    const width = cutSplitsSurrogatePair(text, start + 1) ? 2 : 1;
+    return { text: text.slice(0, start) + text.slice(start + width), cursor: start };
+}
 /** Backward word kill (readline's unix-word-rubout, Alt+Backspace): whitespace immediately
  * before the cursor goes first, then the non-whitespace token that precedes it — on
  * "configure the  loop" it kills "  loop", leaving "configure the". The whitespace-first
@@ -33,6 +53,77 @@ function killWordBefore(text, c) {
         i = p.start;
     return { text: text.slice(0, i) + text.slice(c), cursor: i };
 }
+/** The cursor-movement keys: left/right step one whole code point, home/end jump to the
+ * text's start/end. Returns undefined for any other key so the caller's chain falls
+ * through to the next helper. */
+function moveKey(text, c, key) {
+    switch (key.name) {
+        case "left":
+            return { text, cursor: stepCursor(text, c, -1) };
+        case "right":
+            return { text, cursor: stepCursor(text, c, 1) };
+        case "home":
+            return { text, cursor: 0 };
+        case "end":
+            return { text, cursor: text.length };
+        default:
+            return undefined;
+    }
+}
+/** The character-deletion keys: backspace removes the character before the cursor (or, with
+ * Alt+Backspace, the whole word before it — readline's unix-word-rubout), delete removes the
+ * one at it. Each deletes a surrogate pair whole so no lone surrogate is left behind.
+ * Returns undefined for any other key so the caller's chain falls through. */
+function deleteKey(text, c, key) {
+    switch (key.name) {
+        case "backspace":
+            if (key.meta)
+                return killWordBefore(text, c); // Alt+Backspace: kill the previous word
+            if (c === 0)
+                return { text, cursor: 0 };
+            // The character before the cursor is a surrogate pair [c-2, c-1]: delete both units.
+            return removeCharAt(text, cutSplitsSurrogatePair(text, c - 1) ? c - 2 : c - 1);
+        case "delete":
+            if (c >= text.length)
+                return { text, cursor: c };
+            // The character at the cursor is a surrogate pair [c, c+1]: delete both units.
+            return removeCharAt(text, c);
+        default:
+            return undefined;
+    }
+}
+/** The line-kill keys, both gated on Ctrl so a plain "u"/"k" never kills: Ctrl+U discards
+ * from the line start to the cursor, Ctrl+K from the cursor to the line end (readline's
+ * two directions of half-line discard). Returns undefined when not Ctrl or not one of these
+ * keys so the caller's chain falls through. */
+function lineKillKey(text, c, key) {
+    if (!key.ctrl)
+        return undefined;
+    switch (key.name) {
+        case "u":
+            // Ctrl+U (readline's unix-line-discard) kills from the line start to the cursor; a
+            // plain "u" is not this key and reaches the printable insert in applyKey, unchanged.
+            return { text: text.slice(c), cursor: 0 };
+        case "k":
+            // Ctrl+K (readline's kill-line) kills from the cursor to the line end; a plain "k"
+            // is not this key and reaches the printable insert in applyKey, unchanged.
+            return { text: text.slice(0, c), cursor: c };
+        default:
+            return undefined;
+    }
+}
+/** Printable insertion: any plain printable string is inserted at the cursor (str can hold a
+ * whole composed string when IME input arrives as one keypress, advancing the cursor by its
+ * full length); every other — including control/meta and empty — key leaves text and the
+ * snapped cursor as they are. This is the chain's last member, so its return is total. */
+function insertKey(text, c, str, key) {
+    if (str && !key.ctrl && !key.meta && str >= " ") {
+        // str can hold a whole composed string (IME input arrives as one keypress); the cursor
+        // must land after ALL of it, not one unit in.
+        return { text: text.slice(0, c) + str + text.slice(c), cursor: c + str.length };
+    }
+    return { text, cursor: c };
+}
 /** Apply one keypress to the prompt text (pure, so it is unit-testable without a TTY).
  * Printable characters insert at the cursor — including multi-character strings readline
  * delivers for IME-composed input, which advance the cursor by their full length; backspace
@@ -54,57 +145,10 @@ function killWordBefore(text, c) {
  * the pair in half). */
 export function applyKey(text, cursor, str, key) {
     const c = snapCursor(text, cursor);
-    switch (key.name) {
-        case "left": {
-            const n = Math.max(0, c - 1);
-            // A cut at n would land inside a pair: step over the whole astral character instead.
-            return { text, cursor: cutSplitsSurrogatePair(text, n) ? n - 1 : n };
-        }
-        case "right": {
-            const n = Math.min(text.length, c + 1);
-            return { text, cursor: cutSplitsSurrogatePair(text, n) ? n + 1 : n };
-        }
-        case "backspace":
-            if (key.meta)
-                return killWordBefore(text, c); // Alt+Backspace: kill the previous word
-            if (c === 0)
-                return { text, cursor: 0 };
-            // The character before the cursor is a surrogate pair [c-2, c-1]: delete both units.
-            if (cutSplitsSurrogatePair(text, c - 1)) {
-                return { text: text.slice(0, c - 2) + text.slice(c), cursor: c - 2 };
-            }
-            return { text: text.slice(0, c - 1) + text.slice(c), cursor: c - 1 };
-        case "home":
-            return { text, cursor: 0 };
-        case "end":
-            return { text, cursor: text.length };
-        case "u":
-            // Ctrl+U (readline's unix-line-discard) kills from the line start to the cursor; a
-            // plain "u" breaks here and reaches the printable insert branch below, unchanged.
-            if (key.ctrl)
-                return { text: text.slice(c), cursor: 0 };
-            break;
-        case "k":
-            // Ctrl+K (readline's kill-line) kills from the cursor to the line end; a plain "k"
-            // breaks here and reaches the printable insert branch below, unchanged.
-            if (key.ctrl)
-                return { text: text.slice(0, c), cursor: c };
-            break;
-        case "delete":
-            if (c >= text.length)
-                return { text, cursor: c };
-            // The character at the cursor is a surrogate pair [c, c+1]: delete both units.
-            if (cutSplitsSurrogatePair(text, c + 1)) {
-                return { text: text.slice(0, c) + text.slice(c + 2), cursor: c };
-            }
-            return { text: text.slice(0, c) + text.slice(c + 1), cursor: c };
-    }
-    if (str && !key.ctrl && !key.meta && str >= " ") {
-        // str can hold a whole composed string (IME input arrives as one keypress); the cursor
-        // must land after ALL of it, not one unit in.
-        return { text: text.slice(0, c) + str + text.slice(c), cursor: c + str.length };
-    }
-    return { text, cursor: c };
+    return (moveKey(text, c, key) ??
+        deleteKey(text, c, key) ??
+        lineKillKey(text, c, key) ??
+        insertKey(text, c, str, key));
 }
 /** Five parsers below signal an invalid value through the same `{ ok: false, error }` arm
  * of a `{ ok: true, … } | { ok: false, error: string }` result. `fail` is that arm's one
@@ -146,12 +190,14 @@ export function parseBudgetInput(text) {
         return fail(`budget must be a number of 0 or more, at most ${Number.MAX_SAFE_INTEGER}${gotSuffix(text)}`);
     return { ok: true, value: n };
 }
-/** The 90d cap refusal every duration editor shares — the same over-cap arm (`ms` past
- * PAUSE_FOR_MAX_MS, the limit `pause --for`/`wake --in`/`stop --in` all admit), spelled once
- * per verb so the wording cannot drift between the four parsers. Returns the error result
- * when `ms` exceeds the cap, else null so the caller keeps its ok result. */
+/** The cap refusal every duration editor shares — the same over-cap arm (`ms` past
+ * PAUSE_FOR_MAX_MS, the limit `pause --for`/`wake --in`/`stop --in` all admit), labeled
+ * through durationLabel(PAUSE_FOR_MAX_MS) so the message can never advertise a bound the
+ * constant does not hold (the CLI surfaces already label their cap the same way), spelled
+ * once per verb so the wording cannot drift between the four parsers. Returns the error
+ * result when `ms` exceeds the cap, else null so the caller keeps its ok result. */
 function overDurationCap(ms, verb) {
-    return ms > PAUSE_FOR_MAX_MS ? fail(`${verb} is capped at 90d`) : null;
+    return ms > PAUSE_FOR_MAX_MS ? fail(`${verb} is capped at ${durationLabel(PAUSE_FOR_MAX_MS)}`) : null;
 }
 /** Parse a duration with parseDurationMs and apply the shared 90d cap in one step, mapping
  * both a non-duration spelling (`bad`, caller-specific wording) and an over-cap value to an
@@ -260,6 +306,62 @@ export function renderInputView(text, cursor, width) {
     // showing the character being edited matters more than signalling clipped text.
     return displayWidth(withEllipsis) <= width - 2 ? withEllipsis : slice;
 }
+/** The code-unit start of each character in `chars`: `starts[k]` is how many UTF-16
+ * code units precede character `k` (a surrogate pair is two). The cursor is always on a
+ * character boundary (applyKey snaps mid-pair cursors; BMP characters are one unit each),
+ * so it names a character. */
+function characterStarts(chars) {
+    const starts = [];
+    let units = 0;
+    for (const ch of chars) {
+        starts.push(units);
+        units += ch.length;
+    }
+    return starts;
+}
+/** The display columns before each character: `prefix[k]` = columns before character `k`,
+ * where each character costs its displayWidth (a CJK character two, an astral pair never
+ * measured as halves). */
+function displayPrefix(chars) {
+    const prefix = [0];
+    for (let k = 0; k < chars.length; k++)
+        prefix.push(prefix[k] + displayWidth(chars[k]));
+    return prefix;
+}
+/** The character the cursor (already snapped to a boundary, at code-unit `c`) sits on, or
+ * `chars.length` past the last as a virtual end marker. */
+function cursorCharIndex(starts, chars, c) {
+    for (let k = 0; k < chars.length; k++) {
+        if (starts[k] <= c && c < starts[k] + chars[k].length)
+            return k;
+    }
+    return chars.length;
+}
+/** The left extent of the window: starts at the cursor's character and extends left while
+ * the column budget holds, so the cursor's character ends up at the right edge. */
+function leftWindowStart(prefix, cursorEnd, room) {
+    let startCp = cursorEnd;
+    while (startCp > 0 && prefix[cursorEnd] - prefix[startCp - 1] <= room)
+        startCp--;
+    return startCp;
+}
+/** The right fill of the window: when the window is anchored at the text's start (cursor
+ * near the beginning), fill rightward from the cursor's character up to the budget. */
+function rightWindowEnd(prefix, startCp, cursorEnd, n, room) {
+    let endCp = cursorEnd;
+    if (startCp === 0 && endCp < n) {
+        while (endCp < n && prefix[endCp + 1] - prefix[0] <= room)
+            endCp++;
+    }
+    return endCp;
+}
+/** The whole-character overflow fallback: the smallest window around the cursor when the
+ * character it sits on alone exceeds `room` — that whole character (two columns when
+ * wide), or the whole character before it at end of text. */
+function wholeCharSpan(starts, chars, ci, n) {
+    const k = ci < n ? ci : n - 1;
+    return { start: starts[k], end: starts[k] + chars[k].length };
+}
 /** The code-unit window `[start, end)` renderInputView shows for a prompt line wider than
  * its `room` display columns. The budget is spent in terminal display columns — each
  * character costs its displayWidth, so a CJK character costs two and astral pairs are never
@@ -275,50 +377,17 @@ export function renderInputView(text, cursor, width) {
  * longer both fit. Pure, so it is unit-testable without a TTY. */
 export function inputViewWindow(text, cursor, room) {
     const c = snapCursor(text, cursor);
-    // Per-character decomposition: where each code point starts (in units) and how many
-    // terminal columns it renders as. The cursor is always on a character boundary (applyKey
-    // snaps mid-pair cursors; BMP characters are one unit each), so it names a character.
     const chars = Array.from(text);
     const n = chars.length;
-    const starts = [];
-    let units = 0;
-    for (const ch of chars) {
-        starts.push(units);
-        units += ch.length;
-    }
-    const prefix = [0]; // prefix[k] = display columns before character k
-    for (let k = 0; k < n; k++)
-        prefix.push(prefix[k] + displayWidth(chars[k]));
-    // The character the cursor sits on; past the last character it is a virtual end marker.
-    let ci = n;
-    for (let k = 0; k < n; k++) {
-        if (starts[k] <= c && c < starts[k] + chars[k].length) {
-            ci = k;
-            break;
-        }
-    }
-    // Window ending at the cursor's character, extended left while the column budget holds
-    // (cursor at the right edge); anchored at the text's start instead when the cursor is
-    // near the beginning, then filled rightward up to the budget.
+    const starts = characterStarts(chars);
+    const prefix = displayPrefix(chars);
+    const ci = cursorCharIndex(starts, chars, c);
     const cursorEnd = Math.min(n, ci + 1);
-    let startCp = cursorEnd;
-    while (startCp > 0 && prefix[cursorEnd] - prefix[startCp - 1] <= room)
-        startCp--;
-    let endCp = cursorEnd;
-    if (startCp === 0 && endCp < n) {
-        while (endCp < n && prefix[endCp + 1] - prefix[0] <= room)
-            endCp++;
-    }
-    let start = startCp < n ? starts[startCp] : units;
-    let end = endCp < n ? starts[endCp] : units;
-    if (end <= start && n > 0) {
-        // The character under the cursor alone exceeds the budget: show that whole character
-        // (two columns when wide), or the whole character before it at end of text.
-        const k = ci < n ? ci : n - 1;
-        start = starts[k];
-        end = starts[k] + chars[k].length;
-    }
-    return { start, end };
+    const startCp = leftWindowStart(prefix, cursorEnd, room);
+    const endCp = rightWindowEnd(prefix, startCp, cursorEnd, n, room);
+    const start = startCp < n ? starts[startCp] : text.length;
+    const end = endCp < n ? starts[endCp] : text.length;
+    return end <= start && n > 0 ? wholeCharSpan(starts, chars, ci, n) : { start, end };
 }
 /** The runTui start guard's error message: names the missing stream — a piped stdin and a
  * redirected stdout are distinct failures (the former cannot take typed prompts, the latter

package/dist/src/ui/tui/tui-keymap.js

@@ -3,6 +3,50 @@
  * tui-keys.ts's createTuiKeys consumes the readline (str, key) shape — this module mints
  * those names and classifies the vertical directions the dispatch branches steer by. Pure,
  * so every mapping is unit-testable without ink mounted. */
+/** The flag-named keys in their chain order, each an ink flag and the readline name it maps
+ * to — the ordered table the inkKeyToReadline chain used to hand-roll as a flat if-chain.
+ * Named keys win first (ink sets `ctrl` alongside arrows too). */
+const NAMED_KEYS = [
+    ["delete", "delete"],
+    ["tab", "tab"],
+    ["upArrow", "up"],
+    ["downArrow", "down"],
+    ["leftArrow", "left"],
+    ["rightArrow", "right"],
+    ["pageUp", "pageup"],
+    ["pageDown", "pagedown"],
+    ["home", "home"],
+    ["end", "end"],
+];
+/** The name a flag-named key maps to — the backspace/backspace+meta pair first, then the
+ * NAMED_KEYS table scan (an arrow that also carries `ctrl` still returns the arrow name,
+ * because this runs before controlKey). undefined when no named-key flag matches. */
+function namedKeyName(key) {
+    if (key.backspace) {
+        return key.meta ? { name: "backspace", meta: true } : { name: "backspace" };
+    }
+    for (const [flag, name] of NAMED_KEYS) {
+        if (key[flag])
+            return { name };
+    }
+    return undefined;
+}
+/** The modifier-chord shape a Ctrl/Alt key maps to, or undefined when neither matches — the
+ * Ctrl branch (readline `ctrl: true` plus the bare lowercased letter from `input`), then the
+ * Alt single-char branch (`meta: true` plus the lowercased `input`). */
+function controlKey(input, key) {
+    if (key.ctrl)
+        return { ctrl: true, name: input.toLowerCase() };
+    if (key.meta && input.length === 1) {
+        return { meta: true, name: input.toLowerCase() };
+    }
+    return undefined;
+}
+/** The printable/empty fallback: text with no key flags flows through as `str`, and an empty
+ * non-key input (ink suppresses text for unrecognized sequences) is inert (str undefined). */
+function printableKey(input) {
+    return { str: input || undefined, key: {} };
+}
 /** Map one ink `useInput` (input, key) pair to the shape handleKey consumes — ink's parsed
  * flags and input text become the readline (str, key) pair the 2a dispatch was extracted
  * with. Pure, so the mapping is unit-testable without ink mounted. Named keys win first
@@ -14,35 +58,13 @@ export function inkKeyToReadline(input, key) {
         return { str: undefined, key: { name: "escape" } };
     if (key.return)
         return { str: undefined, key: { name: "return" } };
-    if (key.backspace) {
-        return { str: undefined, key: key.meta ? { name: "backspace", meta: true } : { name: "backspace" } };
-    }
-    if (key.delete)
-        return { str: undefined, key: { name: "delete" } };
-    if (key.tab)
-        return { str: undefined, key: { name: "tab" } };
-    if (key.upArrow)
-        return { str: undefined, key: { name: "up" } };
-    if (key.downArrow)
-        return { str: undefined, key: { name: "down" } };
-    if (key.leftArrow)
-        return { str: undefined, key: { name: "left" } };
-    if (key.rightArrow)
-        return { str: undefined, key: { name: "right" } };
-    if (key.pageUp)
-        return { str: undefined, key: { name: "pageup" } };
-    if (key.pageDown)
-        return { str: undefined, key: { name: "pagedown" } };
-    if (key.home)
-        return { str: undefined, key: { name: "home" } };
-    if (key.end)
-        return { str: undefined, key: { name: "end" } };
-    if (key.ctrl)
-        return { str: undefined, key: { ctrl: true, name: input.toLowerCase() } };
-    if (key.meta && input.length === 1) {
-        return { str: undefined, key: { meta: true, name: input.toLowerCase() } };
-    }
-    return { str: input || undefined, key: {} };
+    const named = namedKeyName(key);
+    if (named)
+        return { str: undefined, key: named };
+    const chord = controlKey(input, key);
+    if (chord)
+        return { str: undefined, key: chord };
+    return printableKey(input);
 }
 /** The `"up" | "down"` direction an arrow key names — Up/Down only, so the branches that
  * reserve the arrows for one purpose (entry browse, history recall) reject the page keys —

package/dist/src/ui/tui/tui-keys.js

@@ -9,7 +9,7 @@ import { loadConfigSafe } from "../../config/config.js";
 import { MERGE_LOCK_WAIT_MS } from "../../paths.js";
 import { commitOperatorBacklogEdit } from "../../backlog/backlog-commit.js";
 import { stampedSubject } from "../../git/commit-message.js";
-import { previewRevert, revertMergedCommit } from "../../operator/revert.js";
+import { previewRevert, revertMergedCommit } from "../../operator/operator-revert.js";
 import { requestAbort } from "../../operator/operator-intent.js";
 import { errorMessage } from "../../text/text.js";
 import { DIRECTOR_ROLE } from "../../roles/roles.js";

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

@@ -2,10 +2,11 @@ import { activityEvents } from "./tui-pane.js";
 import { stepEntryScroll } from "./tui-backlog.js";
 import { pageDir } from "./tui-keymap.js";
 import { promptLineFree } from "./tui-pane-ctx.js";
+import { distinctOrdered } from "../../collections.js";
 /** The Activity pane (view 0) of the TUI (src/ui/tui/tui.tsx): the session live-tail scope
- * (Ctrl+G), the free-text search (`/`), and the PgUp/PgDn tail-paging arm. Split out of the
- * pane-navigation monolith; it owns the pane's own scroll/scope/search state and the arms
- * that touch them. */
+ * (Ctrl+G), the event type/notable cull cycle (Ctrl+O), the free-text search (`/`), and the
+ * PgUp/PgDn tail-paging arm. Split out of the pane-navigation monolith; it owns the pane's
+ * own scroll/scope/search state and the arms that touch them. */
 export function createActivityPane(session) {
     // The Activity pane's body-window start into the loaded event tail, or null to follow the
     // live tail (the newest eventBudget events). PgUp pauses follow and pages back; PgDn returns
@@ -60,7 +61,7 @@ export function createActivityPane(session) {
     const activityTypeCycle = (ctx) => {
         if (!promptLineFree(ctx.es))
             return false;
-        const present = [...new Set(activityEvents(session.root, activityRole, activityGrep, null).map((e) => e.type))].sort();
+        const present = distinctOrdered(activityEvents(session.root, activityRole, activityGrep, null).map((e) => e.type)).sort();
         const slots = [
             { notable: false, type: null },
             { notable: true, type: null },

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

@@ -8,6 +8,7 @@ import { requestWake } from "../../operator/operator-intent.js";
 import { isOpenBacklogLabel, moveEntrySelection, pageMarkdownBody, visibleBacklogIndexes } from "./tui-backlog.js";
 import { arrowDir, pageDir } from "./tui-keymap.js";
 import { promptLineFree } from "./tui-pane-ctx.js";
+import { guardError } from "./tui-guard.js";
 /** Resolve the selected plan/bug from the flat backlog list, deduping the four entry-action
  * arms' common prologue (Ctrl+X cancel, Ctrl+V move-to-top, Ctrl+R release, Ctrl+E edit): the
  * flat-index clamp and the empty / read-only-done / question guards, whose refusal flash
@@ -38,10 +39,13 @@ export function selectedEditableEntry(session, selectedEntry, verb) {
     return { kind, position, picked };
 }
 /** The project-status pane (view roleIds.length + 1) of the TUI (src/ui/tui/tui.tsx): the
- * entry browser's selection/scroll state, the up/down and PgUp/PgDn entry arms, and the
- * three entry-action arms (Ctrl+X cancel, Ctrl+V move-to-top and Ctrl+R release) — each
- * two-step arming except the one-press move — plus the answer/title-edit selection clear the
- * editors call back.
+ * entry browser's selection/scroll state, and its six key arms — the Ctrl+O Ready-only
+ * toggle, the two-press Ctrl+X cancel, the one-press Ctrl+V move-to-top, the two-press
+ * Ctrl+R release, the arrow up/down entry selection and the PgUp/PgDn body page — each
+ * one inner named helper owning its whole guard, flash wording and repaint, dispatched in
+ * order by `handleKey`. The entry-action arms are each two-step except the one-press move;
+ * the answer/title-edit selection clear the editors call back through
+ * clearBacklogSelection.
  * Split out of the pane-navigation monolith; it owns the pane's selection/scroll state and
  * the arms that touch them. */
 export function createBacklogPane(session) {
@@ -76,7 +80,7 @@ export function createBacklogPane(session) {
     // cancel/release read the same as the dashboard drawer's non-exiting action.
     const cancelArmed = (target, armedTitle) => {
         const { kind, position } = target;
-        try {
+        guardError(session, () => {
             const claims = allLiveClaims(session.root);
             const outcome = tryCancelEntry(session.root, kind, position, armedTitle);
             const claimNote = outcome.status === "cancelled" ? cancelledClaimNote(claims.get(entryKey(outcome.title)) ?? null) : "";
@@ -90,10 +94,7 @@ export function createBacklogPane(session) {
             session.flashMessage(outcome.status === "cancelled"
                 ? `cancelled ${kind} #${position}: ${target.title}${note === "" ? "" : ` — ${note}`}`
                 : `that ${kind} was already removed or moved — nothing cancelled`);
-        }
-        catch (err) {
-            session.flashError(err);
-        }
+        });
     };
     /** ` — still held [...]` for the entry now at a 1-based position, "" when it is eligible. */
     const heldTailAt = (kind, position) => {
@@ -102,7 +103,7 @@ export function createBacklogPane(session) {
         return hold === null ? "" : ` — ${stillHeldNote(hold)}`;
     };
     const moveEntryToTop = (kind, position, title) => {
-        try {
+        guardError(session, () => {
             const outcome = tryMoveEntryToTop(session.root, kind, position, title);
             let heldTail = "";
             if (outcome.status === "moved_to_top") {
@@ -116,14 +117,11 @@ export function createBacklogPane(session) {
                 : outcome.status === "already_first"
                     ? `that ${kind} is already at the top`
                     : `that ${kind} was already removed or moved — nothing moved`);
-        }
-        catch (err) {
-            session.flashError(err);
-        }
+        });
     };
     const releaseArmed = (target, armedTitle) => {
         const { kind, position } = target;
-        try {
+        guardError(session, () => {
             const outcome = tryReleaseEntry(session.root, kind, position, armedTitle);
             let heldTail = "";
             if (outcome.status === "released") {
@@ -139,15 +137,15 @@ export function createBacklogPane(session) {
                 : outcome.status === "not_refused"
                     ? `that ${kind} carries no Refused note`
                     : `that ${kind} was already removed or moved — nothing released`);
-        }
-        catch (err) {
-            session.flashError(err);
-        }
+        });
     };
-    const handleKey = (key, ctx) => {
-        if (key.ctrl && key.name === "o" &&
-            promptLineFree(ctx.es) &&
-            session.view === session.roleIds.length + 1) {
+    // The Ctrl+O arm: flips the Ready-only filter to keep only the open plans and bugs no hold
+    // keeps from being picked, the terminal twin of `tumwater backlog --ready` and the dashboard
+    // Backlog card's Ready only toggle. A second press restores the full list. Returns false
+    // when the prompt is busy or the Backlog view is not showing, so the key falls through the
+    // dispatch as today.
+    const backlogToggleReady = (ctx) => {
+        if (promptLineFree(ctx.es) && session.view === session.roleIds.length + 1) {
             // Ctrl+O flips the Ready-only filter: keep only the open plans and bugs no hold keeps
             // from being picked (questions and the answered/done/fixed rows stay), the terminal twin
             // of `tumwater backlog --ready` and the dashboard Backlog card's Ready only toggle. A
@@ -160,9 +158,13 @@ export function createBacklogPane(session) {
             session.requestRender();
             return true;
         }
-        if (key.ctrl && key.name === "x" &&
-            promptLineFree(ctx.es) &&
-            session.view === session.roleIds.length + 1) {
+        return false;
+    };
+    // The two-press Ctrl+X arm: cancels the selected plan or bug through the non-exiting core
+    // the dashboard drawer uses. Returns false when the prompt is busy or the Backlog view is
+    // not showing, so the key falls through the dispatch as today.
+    const backlogCancel = (ctx) => {
+        if (promptLineFree(ctx.es) && session.view === session.roleIds.length + 1) {
             // Ctrl+X twice cancels the selected plan or bug through the non-exiting core the
             // dashboard drawer uses; the title check inside tryCancelEntry refuses a stale selection.
             const selected = selectedEditableEntry(session, selectedEntry, "cancelled");
@@ -183,9 +185,13 @@ export function createBacklogPane(session) {
             session.requestRender();
             return true;
         }
-        if (key.ctrl && key.name === "v" &&
-            promptLineFree(ctx.es) &&
-            session.view === session.roleIds.length + 1) {
+        return false;
+    };
+    // The one-press Ctrl+V arm: moves the selected plan or bug to the head of its section
+    // through the non-exiting core the dashboard drawer uses. Returns false when the prompt is
+    // busy or the Backlog view is not showing, so the key falls through the dispatch as today.
+    const backlogMoveToTop = (ctx) => {
+        if (promptLineFree(ctx.es) && session.view === session.roleIds.length + 1) {
             // Ctrl+V moves the selected plan or bug to the head of its section through the
             // non-exiting core the dashboard drawer uses; the title check inside tryMoveEntryToTop
             // refuses a stale selection. It is the terminal twin of `tumwater plan|bug --top <n>`
@@ -199,9 +205,13 @@ export function createBacklogPane(session) {
             session.requestRender();
             return true;
         }
-        if (key.ctrl && key.name === "r" &&
-            promptLineFree(ctx.es) &&
-            session.view === session.roleIds.length + 1) {
+        return false;
+    };
+    // The two-press Ctrl+R arm: releases the Refused note on the selected plan or bug through
+    // the non-exiting core the dashboard drawer uses. Returns false when the prompt is busy or
+    // the Backlog view is not showing, so the key falls through the dispatch as today.
+    const backlogRelease = (ctx) => {
+        if (promptLineFree(ctx.es) && session.view === session.roleIds.length + 1) {
             // Ctrl+R twice releases the Refused
             // note on the selected plan or bug through the non-exiting core the dashboard drawer
             // uses; the title check inside tryReleaseEntry refuses a stale selection. Releasing is the
@@ -228,9 +238,12 @@ export function createBacklogPane(session) {
             session.requestRender();
             return true;
         }
-        const arrow = arrowDir(key.name);
-        const page = pageDir(key.name);
-        if (session.view === session.roleIds.length + 1 && arrow !== null) {
+        return false;
+    };
+    // The up/down arm: browses entries in full instead of editing the prompt, stepping only
+    // through the search/Ready-only kept entries when either filter is applied.
+    const backlogSelect = (ctx, arrow) => {
+        if (session.view === session.roleIds.length + 1) {
             // In the project-status pane, up/down browse entries in full instead of editing the
             // prompt; every other view keeps today's behavior (arrows are ignored by applyKey).
             // An open answer editor pins the selection (its position was taken from it).
@@ -253,7 +266,11 @@ export function createBacklogPane(session) {
             session.requestRender();
             return true;
         }
-        if (session.view === session.roleIds.length + 1 && page !== null) {
+        return false;
+    };
+    // The PgUp/PgDn arm: scrolls the selected entry's body within the Backlog view's entry mode.
+    const backlogPage = (ctx, page) => {
+        if (session.view === session.roleIds.length + 1) {
             // Within-body scroll in project-status ENTRY mode: PgDn/PgUp page the selected entry's
             // body, clamped at both ends. No-op in list mode and for bodies that fit — every other
             // view ignores these keys as today (applyKey drops them).
@@ -268,6 +285,27 @@ export function createBacklogPane(session) {
         }
         return false;
     };
+    const handleKey = (key, ctx) => {
+        // The Backlog view's six key arms live in the named helpers above, each owning its whole
+        // guard, flash wording and repaint; this body is only the flat ordered dispatch in today's
+        // arm order (Ctrl+O, Ctrl+X, Ctrl+V, Ctrl+R, up/down, PgUp/PgDn), so each key's behavior
+        // is found by name.
+        if (key.ctrl && key.name === "o")
+            return backlogToggleReady(ctx);
+        if (key.ctrl && key.name === "x")
+            return backlogCancel(ctx);
+        if (key.ctrl && key.name === "v")
+            return backlogMoveToTop(ctx);
+        if (key.ctrl && key.name === "r")
+            return backlogRelease(ctx);
+        const arrow = arrowDir(key.name);
+        if (arrow !== null)
+            return backlogSelect(ctx, arrow);
+        const page = pageDir(key.name);
+        if (page !== null)
+            return backlogPage(ctx, page);
+        return false;
+    };
     return {
         handleKey,
         reset() {