tumwater 0.4.0 → 0.4.2

package/dist/src/ui/tui/tui-editor-queued.js

@@ -17,77 +17,87 @@ export function createQueuedEditor(session) {
         session.held.queued = null;
         restoreDraft();
     };
-    const handleKey = (_str, key, ctx) => {
-        if (key.ctrl && key.name === "e" &&
-            !session.anyEditorHeld() &&
-            ctx.view === ctx.roleIds.length + 6 && ctx.selectedQueued !== null) {
-            // Ctrl+E opens the Queued pane's in-place editor on the selected row (mnemonic:
-            // **E**dit) through the same readQueuedPromptBody/editQueuedFile pair the dashboard's
-            // Edit uses: the body is pre-filled marker- and attachment-stripped, and Enter writes
-            // it back to the same queue file, so its position, enqueue stamp, deferral, and
-            // attached images survive. A row that vanished between selection and this press (the
-            // role dequeued it, or another operator cancelled it) flashes the gone notice and
-            // refreshes the list. A no-selection press (list mode) falls through to the report
-            // window below, exactly as before.
-            try {
-                const position = Math.min(ctx.selectedQueued, ctx.queuedRows.length - 1);
-                const row = ctx.queuedRows[position];
-                if (row !== undefined) {
-                    const body = readQueuedPromptBody(session.root, row.role, row.file);
-                    if (body === null) {
-                        session.flashMessage(`inbox message #${row.position} for ${row.role} is gone`);
-                        session.refreshQueued();
-                    }
-                    else {
-                        // Mid-recall, the line holds a history entry while the real draft sits in the
-                        // recall state: settle first, so the queued editor saves (and later restores)
-                        // the draft the operator was writing.
-                        restoreDraft = session.takeDraft();
-                        queuedEditFor = { role: row.role, file: row.file };
-                        session.held.queued = queuedEditFor;
-                        session.input = body;
-                        session.cursor = body.length;
-                        session.flashMessage(`editing inbox message #${row.position} for ${row.role} — Enter to save, Esc to cancel`);
-                    }
+    // Ctrl+E opens the Queued pane's in-place editor on the selected row (mnemonic:
+    // **E**dit) through the same readQueuedPromptBody/editQueuedFile pair the dashboard's
+    // Edit uses: the body is pre-filled marker- and attachment-stripped, and Enter writes
+    // it back to the same queue file, so its position, enqueue stamp, deferral, and
+    // attached images survive. A row that vanished between selection and this press (the
+    // role dequeued it, or another operator cancelled it) flashes the gone notice and
+    // refreshes the list. A no-selection press (list mode) falls through to the report
+    // window below, exactly as before.
+    const queuedOpenEdit = (ctx) => {
+        if (session.anyEditorHeld() ||
+            ctx.view !== ctx.roleIds.length + 6 ||
+            ctx.selectedQueued === null) {
+            return false;
+        }
+        try {
+            const position = Math.min(ctx.selectedQueued, ctx.queuedRows.length - 1);
+            const row = ctx.queuedRows[position];
+            if (row !== undefined) {
+                const body = readQueuedPromptBody(session.root, row.role, row.file);
+                if (body === null) {
+                    session.flashMessage(`inbox message #${row.position} for ${row.role} is gone`);
+                    session.refreshQueued();
+                }
+                else {
+                    // Mid-recall, the line holds a history entry while the real draft sits in the
+                    // recall state: settle first, so the queued editor saves (and later restores)
+                    // the draft the operator was writing.
+                    restoreDraft = session.takeDraft();
+                    queuedEditFor = { role: row.role, file: row.file };
+                    session.held.queued = queuedEditFor;
+                    session.input = body;
+                    session.cursor = body.length;
+                    session.flashMessage(`editing inbox message #${row.position} for ${row.role} — Enter to save, Esc to cancel`);
                 }
             }
-            catch (err) {
-                session.flashError(err);
-            }
-            return true;
         }
-        if (key.name === "escape" && queuedEditFor) {
-            // Esc cancels the Queued pane's in-place editor, restoring the previous prompt text.
-            exitQueuedEdit();
-            return true;
+        catch (err) {
+            session.flashError(err);
         }
-        if (key.name === "return" && queuedEditFor) {
-            // Enter saves the queued editor's line through the same file-addressed
-            // editQueuedFile pair the dashboard's Edit uses: the write targets the queue file
-            // the row named, so a concurrent dequeue cannot land it on the wrong prompt. An
-            // invalid (whitespace-only) line flashes and STAYS in the editor; a gone outcome
-            // is the concurrent-dequeue race, flashed honestly and returned to the list; a
-            // throw keeps the text in the editor for a retry.
-            const parsed = parseRolePromptInput(session.input);
-            if (!parsed.ok) {
-                session.flashMessage(parsed.error);
+        return true;
+    };
+    // Esc cancels the Queued pane's in-place editor, restoring the previous prompt text.
+    const cancelQueuedEdit = () => {
+        exitQueuedEdit();
+        return true;
+    };
+    // Enter saves the queued editor's line through the same file-addressed
+    // editQueuedFile pair the dashboard's Edit uses: the write targets the queue file
+    // the row named, so a concurrent dequeue cannot land it on the wrong prompt. An
+    // invalid (whitespace-only) line flashes and STAYS in the editor; a gone outcome
+    // is the concurrent-dequeue race, flashed honestly and returned to the list; a
+    // throw keeps the text in the editor for a retry.
+    const commitQueuedEdit = () => {
+        const parsed = parseRolePromptInput(session.input);
+        if (!parsed.ok) {
+            session.flashMessage(parsed.error);
+        }
+        else {
+            // The dispatch guards on `queuedEditFor`, so it is never null when this arm runs.
+            const target = queuedEditFor;
+            try {
+                const outcome = editQueuedFile(session.root, target.role, target.file, parsed.value);
+                exitQueuedEdit();
+                session.refreshQueued();
+                session.flashMessage(outcome.status === "edited"
+                    ? `edited inbox message for ${target.role}`
+                    : "the inbox message was already gone");
             }
-            else {
-                const target = queuedEditFor;
-                try {
-                    const outcome = editQueuedFile(session.root, target.role, target.file, parsed.value);
-                    exitQueuedEdit();
-                    session.refreshQueued();
-                    session.flashMessage(outcome.status === "edited"
-                        ? `edited inbox message for ${target.role}`
-                        : "the inbox message was already gone");
-                }
-                catch (err) {
-                    session.flashError(err);
-                }
+            catch (err) {
+                session.flashError(err);
             }
-            return true;
         }
+        return true;
+    };
+    const handleKey = (_str, key, ctx) => {
+        if (key.ctrl && key.name === "e")
+            return queuedOpenEdit(ctx);
+        if (key.name === "escape" && queuedEditFor)
+            return cancelQueuedEdit();
+        if (key.name === "return" && queuedEditFor)
+            return commitQueuedEdit();
         return false;
     };
     return { handleKey, exit: exitQueuedEdit };

package/dist/src/ui/tui/tui-editor-quiet.js

@@ -2,6 +2,7 @@ import { setConfigKey, unsetConfigKey } from "../../config/config-write.js";
 import { loadConfigSafe } from "../../config/config.js";
 import { DIRECTOR_ROLE } from "../../roles/roles.js";
 import { baseRoleOf } from "../../roles/runner-ids.js";
+import { viewedRole } from "./tui-editor-ctx.js";
 /** The Ctrl+O per-role / Ctrl+S team-wide quiet-hours editor on the shared prompt line, the
  * terminal twin of the dashboard's `Quiet hours` rows and `tumwater role <id> --quiet-hours`
  * / `tumwater config set quietHours`. It owns its mode flags, its saved-draft pair, and the
@@ -34,123 +35,136 @@ export function createQuietEditor(session) {
         restoreDraft();
         lockedRole = null;
     };
-    const handleKey = (_str, key, ctx) => {
-        if (key.ctrl && key.name === "o") {
-            // Ctrl+O edits the viewed role's own quiet-hours window (mnemonic: the silent *o*ur
-            // hours) on its Transcript view. Every non-transcript view keeps Ctrl+O — the guard
-            // lets the key fall through to the pane arms (Activity's event-type cycle, History's
-            // outcome cycle, Health's problems-only toggle) unless the quiet editor already holds
-            // the line. While a scope is open, Ctrl+O toggles only the per-role scope out; in the
-            // team scope it is consumed and does nothing. Entering pre-fills the window from
-            // `quietHoursPerRole.<base>` (empty when unset — empty means "off" on save) and saves
-            // the prompt text; leaving restores it. The director is exempt — its
-            // quietHoursPerRole.director entry is inert (the gate and doctor both exempt it).
-            if (quietMode) {
-                // Consumed either way: in the per-role scope it toggles the editor out, in the team
-                // scope Ctrl+O leaves the team editor open.
-                if (!quietTeam)
-                    exitQuietMode();
-                return true;
-            }
-            if (!(ctx.view >= 1 && ctx.view <= ctx.roleIds.length))
-                return false;
-            const role = ctx.roleIds[ctx.view - 1];
-            if (session.editorEntryDenied("quiet"))
-                return true;
-            if (role === DIRECTOR_ROLE) {
-                session.flashMessage("the director has no quiet hours");
-                return true;
-            }
-            // Pin the role first so the write below is safe against a mid-edit roster shift, then
-            // pre-fill from the file's own entry — one fresh read per open is the smallest honest
-            // source; a broken config degrades to no pre-fill and the write reports the error.
-            lockedRole = role;
-            const existing = loadConfigSafe(session.root).config?.quietHoursPerRole?.[baseRoleOf(role)] ?? "";
-            restoreDraft = session.takeDraft();
-            quietMode = true;
-            quietTeam = false;
-            session.held.quiet = true;
-            session.held.quietTeam = false;
-            session.input = existing;
-            session.cursor = session.input.length;
-            session.flashMessage(`edit ${role}'s quiet hours (e.g. 23:00-07:00, empty clears): Enter to save, Esc to cancel`);
+    // The shared way both open paths put the editor on the line: take the prompt draft to
+    // restore on exit, raise the mode flags and the held registry for the chosen scope, pre-fill
+    // the prompt text (cursor at its end) and flash the guidance line.
+    const openQuietEditor = (team, existing, message) => {
+        restoreDraft = session.takeDraft();
+        quietMode = true;
+        quietTeam = team;
+        session.held.quiet = true;
+        session.held.quietTeam = team;
+        session.input = existing;
+        session.cursor = session.input.length;
+        session.flashMessage(message);
+    };
+    // The Ctrl+O arm: edits the viewed role's own quiet-hours window (mnemonic: the silent *o*ur
+    // hours) on its Transcript view. Every non-transcript view keeps Ctrl+O — the guard lets the
+    // key fall through to the pane arms (Activity's event-type cycle, History's outcome cycle,
+    // Health's problems-only toggle) unless the quiet editor already holds the line. While a
+    // scope is open, Ctrl+O toggles only the per-role scope out; in the team scope it is consumed
+    // and does nothing. Entering pre-fills the window from `quietHoursPerRole.<base>` (empty when
+    // unset — empty means "off" on save) and saves the prompt text; leaving restores it. The
+    // director is exempt — its quietHoursPerRole.director entry is inert (the gate and doctor
+    // both exempt it).
+    const roleQuietKey = (ctx) => {
+        if (quietMode) {
+            // Consumed either way: in the per-role scope it toggles the editor out, in the team
+            // scope Ctrl+O leaves the team editor open.
+            if (!quietTeam)
+                exitQuietMode();
             return true;
         }
-        if (key.ctrl && key.name === "s") {
-            // Ctrl+S edits the team-wide quiet-hours window on the Activity view (view 0) — the
-            // terminal twin of the dashboard Settings `quietHours` row and `tumwater config set
-            // quietHours`, so an operator can put the whole team to sleep for a nightly window. On
-            // every non-Activity view Ctrl+S keeps its other meaning — the guard lets the key fall
-            // through to the interval editor (a role's Transcript) and the pane arms (History's
-            // trailing-window cycle). While a scope is open, Ctrl+S toggles only the team scope out;
-            // in the per-role scope it is consumed and does nothing (so it never opens the interval
-            // editor over the quiet editor). Entering pre-fills the window from the FILE's top-level
-            // `quietHours` (empty when unset — empty means "off" on save) and saves the prompt text;
-            // leaving restores it. The team window owns no role, so lockedRole stays null.
-            if (quietMode) {
-                // In the team scope Ctrl+S toggles the editor out. In the per-role scope it must not
-                // touch the per-role editor, but it also must not silently vanish: fall through so the
-                // interval editor (the other Ctrl+S arm, which runs after this one) flashes the way out,
-                // naming the per-role quiet editor as the holder.
-                if (!quietTeam)
-                    return false;
-                exitQuietMode();
-                return true;
-            }
-            if (ctx.view !== 0)
-                return false;
-            if (session.editorEntryDenied("quiet"))
-                return true;
-            const existing = loadConfigSafe(session.root).config?.quietHours ?? "";
-            restoreDraft = session.takeDraft();
-            quietMode = true;
-            quietTeam = true;
-            session.held.quiet = true;
-            session.held.quietTeam = true;
-            session.input = existing;
-            session.cursor = session.input.length;
-            session.flashMessage("edit the team's quiet hours (e.g. 23:00-07:00, empty clears): Enter to save, Esc to cancel");
+        if (!(ctx.view >= 1 && ctx.view <= ctx.roleIds.length))
+            return false;
+        const role = viewedRole(ctx);
+        if (session.editorEntryDenied("quiet"))
+            return true;
+        if (role === DIRECTOR_ROLE) {
+            session.flashMessage("the director has no quiet hours");
             return true;
         }
-        if (key.name === "escape" && quietMode) {
-            // Esc cancels quiet-edit mode, restoring the previous prompt text.
+        // Pin the role first so the write below is safe against a mid-edit roster shift, then
+        // pre-fill from the file's own entry — one fresh read per open is the smallest honest
+        // source; a broken config degrades to no pre-fill and the write reports the error.
+        lockedRole = role;
+        const existing = loadConfigSafe(session.root).config?.quietHoursPerRole?.[baseRoleOf(role)] ?? "";
+        openQuietEditor(false, existing, `edit ${role}'s quiet hours (e.g. 23:00-07:00, empty clears): Enter to save, Esc to cancel`);
+        return true;
+    };
+    // The Ctrl+S arm: edits the team-wide quiet-hours window on the Activity view (view 0) — the
+    // terminal twin of the dashboard Settings `quietHours` row and `tumwater config set
+    // quietHours`, so an operator can put the whole team to sleep for a nightly window. On every
+    // non-Activity view Ctrl+S keeps its other meaning — the guard lets the key fall through to
+    // the interval editor (a role's Transcript) and the pane arms (History's trailing-window
+    // cycle). While a scope is open, Ctrl+S toggles only the team scope out; in the per-role
+    // scope it is consumed and does nothing (so it never opens the interval editor over the
+    // quiet editor). Entering pre-fills the window from the FILE's top-level `quietHours` (empty
+    // when unset — empty means "off" on save) and saves the prompt text; leaving restores it.
+    // The team window owns no role, so lockedRole stays null.
+    const teamQuietKey = (ctx) => {
+        if (quietMode) {
+            // In the team scope Ctrl+S toggles the editor out. In the per-role scope it must not
+            // touch the per-role editor, but it also must not silently vanish: fall through so the
+            // interval editor (the other Ctrl+S arm, which runs after this one) flashes the way out,
+            // naming the per-role quiet editor as the holder.
+            if (!quietTeam)
+                return false;
             exitQuietMode();
             return true;
         }
-        if (key.name === "return" && quietMode) {
-            // Enter commits the window through the shared setter family the CLI's `--quiet-hours`
-            // and `tumwater config set quietHours` / the dashboard rows use: an empty or
-            // whitespace-only line clears the key (`unsetConfigKey`), otherwise `setConfigKey` writes
-            // the dotted `quietHoursPerRole.<base>` entry (per-role scope) or the top-level
-            // `quietHours` (team scope) as a JSON string. checkQuietHours (naming the dotted key)
-            // rejects a malformed per-role window and validateConfig guards the team write; both
-            // write tumwater.json atomically and the running orchestrator picks the change up on its
-            // next poll. An invalid window flashes and STAYS in edit mode so the operator can fix
-            // it; success restores the saved prompt text.
-            const cfgKey = quietTeam ? "quietHours" : `quietHoursPerRole.${baseRoleOf(lockedRole)}`;
-            const text = session.input.trim();
-            const result = text === ""
-                ? unsetConfigKey(session.root, cfgKey)
-                : setConfigKey(session.root, cfgKey, JSON.stringify(text));
-            if (result.ok) {
-                const team = quietTeam;
-                const role = lockedRole;
-                exitQuietMode();
-                const scope = team ? "team" : `${role}`;
-                const noop = text === "" ? result.oldValue === undefined : "unchanged" in result;
-                session.flashMessage(noop
-                    ? text === ""
-                        ? `${scope}: quiet hours is not set in tumwater.json, so nothing was cleared`
-                        : `${scope}: quiet hours is already ${text}, so tumwater.json was not written`
-                    : text === ""
-                        ? `${scope}: quiet hours cleared`
-                        : `${scope}: quiet hours set to ${text}`);
-            }
-            else {
-                session.flashMessage(result.error); // broken config or write failure — stay in edit mode
-            }
+        if (ctx.view !== 0)
+            return false;
+        if (session.editorEntryDenied("quiet"))
+            return true;
+        const existing = loadConfigSafe(session.root).config?.quietHours ?? "";
+        openQuietEditor(true, existing, "edit the team's quiet hours (e.g. 23:00-07:00, empty clears): Enter to save, Esc to cancel");
+        return true;
+    };
+    // The Esc arm: cancels quiet-edit mode, restoring the previous prompt text.
+    const cancelQuietEdit = () => {
+        exitQuietMode();
+        return true;
+    };
+    // The Enter arm: commits the window through the shared setter family the CLI's `--quiet-hours`
+    // and `tumwater config set quietHours` / the dashboard rows use: an empty or whitespace-only
+    // line clears the key (`unsetConfigKey`), otherwise `setConfigKey` writes the dotted
+    // `quietHoursPerRole.<base>` entry (per-role scope) or the top-level `quietHours` (team scope)
+    // as a JSON string. checkQuietHours (naming the dotted key) rejects a malformed per-role
+    // window and validateConfig guards the team write; both write tumwater.json atomically and the
+    // running orchestrator picks the change up on its next poll. An invalid window flashes and
+    // STAYS in edit mode so the operator can fix it; success restores the saved prompt text.
+    const commitQuietEntry = () => {
+        const cfgKey = quietTeam ? "quietHours" : `quietHoursPerRole.${baseRoleOf(lockedRole)}`;
+        const text = session.input.trim();
+        const result = text === ""
+            ? unsetConfigKey(session.root, cfgKey)
+            : setConfigKey(session.root, cfgKey, JSON.stringify(text));
+        if (result.ok) {
+            flashQuietOutcome(result, text);
             return true;
         }
+        session.flashMessage(result.error); // broken config or write failure — stay in edit mode
+        return true;
+    };
+    // The one success flash, shared by both scopes: reads the scope and role before exiting so
+    // the message still names the window that was just written, computes the no-op case (nothing
+    // was set and an empty line was cleared, or the value was already in place) and flashes the
+    // matching line. Both setConfigKey's and unsetConfigKey's success members carry `oldValue`, so
+    // the shared structural type accepts either branch's `result`.
+    const flashQuietOutcome = (result, text) => {
+        const team = quietTeam;
+        const role = lockedRole;
+        exitQuietMode();
+        const scope = team ? "team" : `${role}`;
+        const noop = text === "" ? result.oldValue === undefined : "unchanged" in result;
+        session.flashMessage(noop
+            ? text === ""
+                ? `${scope}: quiet hours is not set in tumwater.json, so nothing was cleared`
+                : `${scope}: quiet hours is already ${text}, so tumwater.json was not written`
+            : text === ""
+                ? `${scope}: quiet hours cleared`
+                : `${scope}: quiet hours set to ${text}`);
+    };
+    const handleKey = (_str, key, ctx) => {
+        if (key.ctrl && key.name === "o")
+            return roleQuietKey(ctx);
+        if (key.ctrl && key.name === "s")
+            return teamQuietKey(ctx);
+        if (key.name === "escape" && quietMode)
+            return cancelQuietEdit();
+        if (key.name === "return" && quietMode)
+            return commitQuietEntry();
         return false;
     };
     return {

package/dist/src/ui/tui/tui-editor-release.js

@@ -0,0 +1,85 @@
+import { releaseQuarantinedTest } from "../../review/known-flakes.js";
+/** The Failures view's Ctrl+X release editor on the shared prompt line, the terminal twin of
+ * `tumwater quarantine --release <n>` and the dashboard Failures card's Release button. Like
+ * the retire editor it owns its `releaseMode` flag, its saved-draft pair, and the handleKey
+ * arms for its key (the toggle with the `heldEditorFlash(entering)` guard clause — the shared
+ * guard priority lives in the session module — plus Esc and Enter). Guarded to the Failures
+ * view (`ctx.view === roleIds.length + 3`), so every other view's Ctrl+X arm (Transcript clears
+ * notes, Backlog/Inbox/Pending cancel, History model filter, Activity backends) keeps the key.
+ * Enter runs the same `releaseQuarantinedTest(session.root, test)` core the CLI and the
+ * dashboard button call, with a typed test path as its confirmation (no two-press arm): the
+ * exact path the Failures list shows, Enter to release, Esc to cancel. A success removes the
+ * entry from `.tumwater/state/quarantine.json`, exits the editor, flashes the outcome, and
+ * repaints the Failures body; a name not in the list flashes `not in the flake quarantine` and
+ * STAYS open so the operator can fix the name; an empty name flashes and stays. */
+export function createQuarantineReleaseEditor(session) {
+    let releaseMode = false;
+    let restoreDraft = () => { };
+    // Leave release-edit mode (Esc, Enter's success path, or Ctrl+T): restore the saved prompt
+    // text.
+    const exitReleaseMode = () => {
+        if (!releaseMode)
+            return;
+        releaseMode = false;
+        session.held.release = false;
+        restoreDraft();
+    };
+    // Open release-edit mode on the Failures view's prompt line (Ctrl+X). The Failures index
+    // guard keeps the same key's other arms (Transcript notes-clear, Backlog cancel, and the
+    // like) on their own views; a guard miss returns false so the key falls through. The line
+    // edits one quarantined test path, typed exactly as the Failures list shows it; Enter
+    // releases that test through the same releaseQuarantinedTest core the CLI and the dashboard
+    // button use. Entering saves the prompt draft and blanks the line; leaving restores it.
+    const openReleaseEdit = (ctx) => {
+        if (ctx.view !== ctx.roleIds.length + 3 || releaseMode)
+            return false;
+        if (session.editorEntryDenied("release"))
+            return true;
+        // Mid-recall, hand the arrows' saved draft back before the release editor takes the line —
+        // the same settle the retire and role editors do — so leaving restores the draft, not a
+        // history entry, with no stale recall state riding along.
+        restoreDraft = session.takeDraft();
+        releaseMode = true;
+        session.held.release = true;
+        session.input = "";
+        session.cursor = 0;
+        session.flashMessage("release a quarantined test: type its test path as the Failures list shows it, Enter to release, Esc to cancel");
+        return true;
+    };
+    // Esc cancels release-edit mode, restoring the previous prompt text and removing nothing.
+    const cancelReleaseEdit = () => {
+        exitReleaseMode();
+        session.flashMessage("release cancelled");
+        return true;
+    };
+    // Enter releases the typed test path through releaseQuarantinedTest — the same core, and
+    // the same single-press confirmation, the CLI's `tumwater quarantine --release <n>` and
+    // the dashboard Failures card's Release button use — then flashes the shared outcome
+    // wording and repaints the Failures body so the released line is gone. An empty name, or
+    // one not in the quarantine, flashes and STAYS in the editor so the operator can fix it.
+    const submitReleaseEdit = () => {
+        const test = session.input.trim();
+        if (test === "") {
+            session.flashMessage("a test name is required");
+            return true;
+        }
+        if (!releaseQuarantinedTest(session.root, test)) {
+            session.flashMessage(`not in the flake quarantine: ${test}`);
+            return true;
+        }
+        exitReleaseMode();
+        session.flashMessage(`released quarantined test ${test} — the gate no longer excuses it`);
+        session.refreshReport();
+        return true;
+    };
+    const handleKey = (_str, key, ctx) => {
+        if (key.ctrl && key.name === "x")
+            return openReleaseEdit(ctx);
+        if (key.name === "escape" && releaseMode)
+            return cancelReleaseEdit();
+        if (key.name === "return" && releaseMode)
+            return submitReleaseEdit();
+        return false;
+    };
+    return { handleKey, exit: exitReleaseMode };
+}

package/dist/src/ui/tui/tui-editor-retire.js

@@ -20,55 +20,66 @@ export function createRetireEditor(session) {
         session.held.retire = false;
         restoreDraft();
     };
-    const handleKey = (_str, key, ctx) => {
-        if (key.ctrl && key.name === "x" && ctx.view === ctx.roleIds.length + 7 && !retireMode) {
-            // Ctrl+X toggles retire-edit mode on the Health view's prompt line (mnemonic: **x**
-            // remove — the same key the Transcript notes-clear, Backlog cancel, and Inbox cancel
-            // arms use on their own views, guarded away here by the Health index). The line edits one
-            // role id; Enter retires that role's leftovers through the same retireRole core the CLI
-            // and the dashboard button use. Entering saves the prompt draft and blanks the line;
-            // leaving restores it.
-            if (session.editorEntryDenied("retire"))
-                return true;
-            // Mid-recall, hand the arrows' saved draft back before the retire editor takes the line —
-            // the same settle the role editors do — so leaving restores the draft, not a
-            // history entry, with no stale recall state riding along.
-            restoreDraft = session.takeDraft();
-            retireMode = true;
-            session.held.retire = true;
-            session.input = "";
-            session.cursor = 0;
-            session.flashMessage("retire a disabled role's leftovers: type the role id, Enter to retire, Esc to cancel");
+    // Ctrl+X toggles retire-edit mode on the Health view's prompt line (mnemonic: **x**
+    // remove — the same key the Transcript notes-clear, Backlog cancel, and Inbox cancel
+    // arms use on their own views, guarded away here by the Health index). The line edits one
+    // role id; Enter retires that role's leftovers through the same retireRole core the CLI
+    // and the dashboard button use. Entering saves the prompt draft and blanks the line;
+    // leaving restores it. The guard returns false on a miss so the key falls through to the
+    // panes' own Ctrl+X arms on their views.
+    const openRetireEdit = (ctx) => {
+        if (ctx.view !== ctx.roleIds.length + 7)
+            return false;
+        if (retireMode)
+            return false;
+        if (session.editorEntryDenied("retire"))
             return true;
-        }
-        if (key.name === "escape" && retireMode) {
-            // Esc cancels retire-edit mode, restoring the previous prompt text and removing nothing.
-            exitRetireMode();
-            session.flashMessage("retire cancelled");
-            return true;
-        }
-        if (key.name === "return" && retireMode) {
-            // Enter retires the typed role id through retireRole — the same core, and the same
-            // never-force policy, the CLI's `tumwater retire --role <id>` and the dashboard's Retire
-            // button use — then flashes the dashboard's own outcome wording. An empty id flashes and
-            // STAYS in the editor so the operator can type one; a safety-rail refusal throws (the
-            // role still enabled, unmerged commits, a dirty or unusable worktree, a run in progress)
-            // and the cursor stays so the operator can fix the id or reach for the CLI's --force.
-            const role = session.input.trim();
-            if (role === "") {
-                session.flashMessage("a role id is required");
-                return true;
-            }
-            void retireRole(session.root, role, {}).then(({ removed }) => {
-                exitRetireMode();
-                session.flashMessage(removed.length === 0
-                    ? `nothing to remove for role ${role}`
-                    : removed.map((a) => `removed ${artifactPhrase(a, role)}`).join("; "));
-            }, (err) => {
-                session.flashError(err);
-            });
+        // Mid-recall, hand the arrows' saved draft back before the retire editor takes the line —
+        // the same settle the role editors do — so leaving restores the draft, not a
+        // history entry, with no stale recall state riding along.
+        restoreDraft = session.takeDraft();
+        retireMode = true;
+        session.held.retire = true;
+        session.input = "";
+        session.cursor = 0;
+        session.flashMessage("retire a disabled role's leftovers: type the role id, Enter to retire, Esc to cancel");
+        return true;
+    };
+    // Esc cancels retire-edit mode, restoring the previous prompt text and removing nothing.
+    const cancelRetireEdit = () => {
+        exitRetireMode();
+        session.flashMessage("retire cancelled");
+        return true;
+    };
+    // Enter retires the typed role id through retireRole — the same core, and the same
+    // never-force policy, the CLI's `tumwater retire --role <id>` and the dashboard's Retire
+    // button use — then flashes the dashboard's own outcome wording. An empty id flashes and
+    // STAYS in the editor so the operator can type one; a safety-rail refusal throws (the
+    // role still enabled, unmerged commits, a dirty or unusable worktree, a run in progress)
+    // and the cursor stays so the operator can fix the id or reach for the CLI's --force.
+    const submitRetireEdit = () => {
+        const role = session.input.trim();
+        if (role === "") {
+            session.flashMessage("a role id is required");
             return true;
         }
+        void retireRole(session.root, role, {}).then(({ removed }) => {
+            exitRetireMode();
+            session.flashMessage(removed.length === 0
+                ? `nothing to remove for role ${role}`
+                : removed.map((a) => `removed ${artifactPhrase(a, role)}`).join("; "));
+        }, (err) => {
+            session.flashError(err);
+        });
+        return true;
+    };
+    const handleKey = (_str, key, ctx) => {
+        if (key.ctrl && key.name === "x")
+            return openRetireEdit(ctx);
+        if (key.name === "escape" && retireMode)
+            return cancelRetireEdit();
+        if (key.name === "return" && retireMode)
+            return submitRetireEdit();
         return false;
     };
     return { handleKey, exit: exitRetireMode };