tumwater 0.4.0 → 0.4.2

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

@@ -3,6 +3,7 @@ import { isTeamPaused, pausedRoles, pauseTeam, pauseRole, resumeTeam, resumeRole
 import { durationLabel } from "../../cli/cli-args.js";
 import { teamPausePhrase, teamResumePhrase } from "../../text/phrases.js";
 import { parsePauseInput, parseRolePauseInput, parseRoleWakeInput, parseStopInInput, } from "./tui-input.js";
+import { viewedRole } from "./tui-editor-ctx.js";
 /** The pause/stop/wake editor on the shared prompt line: the whole-team Ctrl+F pause and Ctrl+Q
  * stop editors, the per-role Ctrl+P pause / Ctrl+A abort / Ctrl+W wake controls, and the
  * parse/dispatch leaves those write. It owns its mode flags (pauseEditMode/`pauseEditRole`/
@@ -42,213 +43,239 @@ export function createPauseEditor(session) {
         session.cursor = 0;
         session.flashMessage(hint);
     };
-    const handleKey = (_str, key, ctx) => {
-        if (key.ctrl && key.name === "f" &&
-            !session.anyEditorHeld("pause")) {
-            // Ctrl+F toggles the whole-team pause (mnemonic: **F**leet) through the same
-            // pauseTeam/resumeTeam marker writers `tumwater pause`/`resume` and the dashboard's
-            // /api/pause call use, so the surfaces cannot drift on marker format or idempotence.
-            // The shared teamPausePhrase/teamResumePhrase base lines keep the flash wording the
-            // event feed and failure digest already read; a no-op flashes the same
-            // already-paused/was-not-paused contract the CLI prints. Guarded out of the budget and
-            // role-prompt editors, whose prompt line the team toggle must not disturb — the same
-            // inertness the per-role keys honor below. The write can fail (a lock timeout, a torn
-            // fs), so flash the reason instead of letting the throw kill the TUI.
-            if (pauseEditMode) {
-                exitPauseEditMode();
-                return true;
-            }
-            try {
-                if (isTeamPaused(session.root)) {
-                    session.flashMessage(resumeTeam(session.root) ? teamResumePhrase() : "team was not paused");
-                }
-                else {
-                    // An unpaused team opens the one-line editor: "[duration] [reason]", empty pauses
-                    // until resumed. A paused team resumes at once.
-                    openPauseEditor(null, false, false, 'pause the team: [duration] [reason], e.g. "2h deploy freeze" (empty pauses until resumed) — Enter to pause, Esc to cancel');
-                }
-            }
-            catch (err) {
-                session.flashError(err);
-            }
+    // Ctrl+F toggles the whole-team pause (mnemonic: **F**leet) through the same
+    // pauseTeam/resumeTeam marker writers `tumwater pause`/`resume` and the dashboard's
+    // /api/pause call use, so the surfaces cannot drift on marker format or idempotence.
+    // The shared teamPausePhrase/teamResumePhrase base lines keep the flash wording the
+    // event feed and failure digest already read; a no-op flashes the same
+    // already-paused/was-not-paused contract the CLI prints. Guarded out of the budget and
+    // role-prompt editors, whose prompt line the team toggle must not disturb — the same
+    // inertness the per-role keys honor below. The write can fail (a lock timeout, a torn
+    // fs), so flash the reason instead of letting the throw kill the TUI.
+    const teamPauseToggle = (_ctx) => {
+        if (pauseEditMode) {
+            exitPauseEditMode();
             return true;
         }
-        if (key.ctrl && key.name === "q" &&
-            !session.anyEditorHeld("pause")) {
-            // Ctrl+Q (mnemonic: **q**uit later) schedules or cancels a graceful team stop through
-            // the same requestScheduledStop/cancelScheduledStopMessage cores `tumwater stop --in` /
-            // `--cancel` and the dashboard use. A pending stop cancels at once; otherwise it opens
-            // the duration editor. A second press closes any open pause/wake/stop editor unwritten.
-            if (pauseEditMode) {
-                exitPauseEditMode();
-                return true;
-            }
-            try {
-                if (scheduledStopAt(session.root) !== undefined) {
-                    session.flashMessage(cancelScheduledStopMessage(session.root));
-                }
-                else {
-                    // The same one-line entry state as the Ctrl+F and per-role editors, scoped to the
-                    // stop intent (no role pinned, stop mode on): nothing is written until Enter.
-                    openPauseEditor(null, false, true, 'stop the team later: a duration, e.g. "2h" — current runs finish, then the team stops — Enter to schedule, Esc to cancel');
-                }
+        try {
+            if (isTeamPaused(session.root)) {
+                session.flashMessage(resumeTeam(session.root) ? teamResumePhrase() : "team was not paused");
             }
-            catch (err) {
-                session.flashError(err);
+            else {
+                // An unpaused team opens the one-line editor: "[duration] [reason]", empty pauses
+                // until resumed. A paused team resumes at once.
+                openPauseEditor(null, false, false, 'pause the team: [duration] [reason], e.g. "2h deploy freeze" (empty pauses until resumed) — Enter to pause, Esc to cancel');
             }
+        }
+        catch (err) {
+            session.flashError(err);
+        }
+        return true;
+    };
+    // Ctrl+Q (mnemonic: **q**uit later) schedules or cancels a graceful team stop through
+    // the same requestScheduledStop/cancelScheduledStopMessage cores `tumwater stop --in` /
+    // `--cancel` and the dashboard use. A pending stop cancels at once; otherwise it opens
+    // the duration editor. A second press closes any open pause/wake/stop editor unwritten.
+    const stopLaterToggle = (_ctx) => {
+        if (pauseEditMode) {
+            exitPauseEditMode();
             return true;
         }
-        if (key.ctrl && key.name === "r" && ctx.view === 0 && !pauseEditMode &&
-            !session.anyEditorHeld("pause")) {
-            // Ctrl+R on the Activity view applies the pending self-redeploy now — the terminal twin
-            // of `tumwater restart` and the dashboard update alert's restart button, all three
-            // through the same requestRestart marker writer. A refusal carries the CLI's wording
-            // (a red main, failed compile, swap error, or boot refusal still blocks; a fresh build
-            // refuses as "current with main"), so the flash matches what a terminal press would
-            // print. Inert on every other view (the transcript's Ctrl+R still opens the per-role
-            // prompt editor, Backlog's still releases an entry, Pending/Health's still refresh) and
-            // out of pause-edit mode, whose prompt line the restart must not disturb. The write can
-            // fail like any marker write, so flash the reason instead of letting the throw escape.
-            try {
-                const result = requestRestart(session.root);
-                session.flashMessage(result.ok ? result.message : result.error);
+        try {
+            if (scheduledStopAt(session.root) !== undefined) {
+                session.flashMessage(cancelScheduledStopMessage(session.root));
             }
-            catch (err) {
-                session.flashError(err);
+            else {
+                // The same one-line entry state as the Ctrl+F and per-role editors, scoped to the
+                // stop intent (no role pinned, stop mode on): nothing is written until Enter.
+                openPauseEditor(null, false, true, 'stop the team later: a duration, e.g. "2h" — current runs finish, then the team stops — Enter to schedule, Esc to cancel');
             }
-            return true;
         }
-        // Per-role controls on the transcript pane: Ctrl+P toggles the viewed role's pause,
-        // Ctrl+A aborts its in-flight run, Ctrl+V zeroes its counters, Ctrl+W opens the wake
-        // editor (Ctrl+R opens the role-prompt editor for it — the prompt editor's arms handle
-        // that key). They call the
-        // same marker-writing/submit cores the CLI's --role flags do, so the surfaces cannot
-        // drift on marker format, idempotence, or wording. Guarded to the transcript views and
-        // out of budget-edit mode; everywhere else the keys fall through to applyKey. Every
-        // branch is a disk write that can fail (a lock timeout, a torn fs), and an unguarded
-        // throw would escape this keypress handler and kill the TUI — flash the reason instead.
-        if (key.ctrl && (key.name === "p" || key.name === "w") && pauseEditRole !== null) {
-            // A second Ctrl+P or Ctrl+W closes the per-role pause/wake editor, mirroring Ctrl+F's
-            // second press.
-            exitPauseEditMode();
-            return true;
+        catch (err) {
+            session.flashError(err);
         }
-        if (!session.anyEditorHeld("rolePromptFor", "search") &&
-            ctx.roleIds.length > 0 &&
-            ctx.view >= 1 && ctx.view <= ctx.roleIds.length &&
-            key.ctrl && (key.name === "p" || key.name === "a" || key.name === "w" || key.name === "v")) {
-            const role = ctx.roleIds[ctx.view - 1]; // defined: view is clamped inside the transcript range
-            try {
-                if (key.name === "p") {
-                    // Toggle by the marker's current state, read fresh: pauseRole/resumeRole's false
-                    // return means another window raced us to the same state, and the wording
-                    // helpers render that honestly — the changed-state contract the CLI prints.
-                    if (pausedRoles(session.root).includes(role)) {
-                        session.flashMessage(roleResumeMessage(session.root, role, resumeRole(session.root, role)));
-                    }
-                    else if (session.held.rolePromptFor || session.held.search) {
-                        session.flashMessage(session.held.rolePromptFor ? session.busyFlash("role prompt") : session.busyFlash("search"));
-                    }
-                    else {
-                        // An unpaused role opens the one-line duration editor; nothing is written until
-                        // Enter. Empty pauses until resumed.
-                        openPauseEditor(role, false, false, `pause ${role}: [duration], e.g. "2h" (empty pauses until resumed) — Enter to pause, Esc to cancel`);
-                    }
-                }
-                else if (key.name === "a") {
-                    const result = requestAbort(session.root, role);
-                    session.flashMessage(result.ok ? result.message : `error: ${result.error}`);
-                }
-                else if (key.name === "v") {
-                    session.flashMessage(requestResetCounters(session.root, [role]));
+        return true;
+    };
+    // Ctrl+R on the Activity view applies the pending self-redeploy now — the terminal twin
+    // of `tumwater restart` and the dashboard update alert's restart button, all three
+    // through the same requestRestart marker writer. A refusal carries the CLI's wording
+    // (a red main, failed compile, swap error, or boot refusal still blocks; a fresh build
+    // refuses as "current with main"), so the flash matches what a terminal press would
+    // print. Inert on every other view (the transcript's Ctrl+R still opens the per-role
+    // prompt editor, Backlog's still releases an entry, Pending/Health's still refresh) and
+    // out of pause-edit mode, whose prompt line the restart must not disturb. The write can
+    // fail like any marker write, so flash the reason instead of letting the throw escape.
+    const restartNow = (_ctx) => {
+        try {
+            const result = requestRestart(session.root);
+            session.flashMessage(result.ok ? result.message : result.error);
+        }
+        catch (err) {
+            session.flashError(err);
+        }
+        return true;
+    };
+    // A second Ctrl+P or Ctrl+W closes the per-role pause/wake editor, mirroring Ctrl+F's
+    // second press.
+    const closeRolePauseEdit = () => {
+        exitPauseEditMode();
+        return true;
+    };
+    // Per-role controls on the transcript pane: Ctrl+P toggles the viewed role's pause,
+    // Ctrl+A aborts its in-flight run, Ctrl+V zeroes its counters, Ctrl+W opens the wake
+    // editor (Ctrl+R opens the role-prompt editor for it — the prompt editor's arms handle
+    // that key). They call the
+    // same marker-writing/submit cores the CLI's --role flags do, so the surfaces cannot
+    // drift on marker format, idempotence, or wording. Guarded to the transcript views and
+    // out of budget-edit mode; everywhere else the keys fall through to applyKey. Every
+    // branch is a disk write that can fail (a lock timeout, a torn fs), and an unguarded
+    // throw would escape this keypress handler and kill the TUI — flash the reason instead.
+    const roleControlArm = (name, ctx) => {
+        const role = viewedRole(ctx); // defined: view is clamped inside the transcript range
+        try {
+            if (name === "p") {
+                // Toggle by the marker's current state, read fresh: pauseRole/resumeRole's false
+                // return means another window raced us to the same state, and the wording
+                // helpers render that honestly — the changed-state contract the CLI prints.
+                if (pausedRoles(session.root).includes(role)) {
+                    session.flashMessage(roleResumeMessage(session.root, role, resumeRole(session.root, role)));
                 }
                 else if (session.held.rolePromptFor || session.held.search) {
                     session.flashMessage(session.held.rolePromptFor ? session.busyFlash("role prompt") : session.busyFlash("search"));
                 }
                 else {
-                    // Ctrl+W opens the one-line wake editor; nothing is written until Enter. Empty wakes now.
-                    openPauseEditor(role, true, false, `wake ${role}: [duration], e.g. "2h", or "cancel" (empty wakes now) — Enter to apply, Esc to cancel`);
+                    // An unpaused role opens the one-line duration editor; nothing is written until
+                    // Enter. Empty pauses until resumed.
+                    openPauseEditor(role, false, false, `pause ${role}: [duration], e.g. "2h" (empty pauses until resumed) — Enter to pause, Esc to cancel`);
                 }
             }
-            catch (err) {
-                session.flashError(err);
+            else if (name === "a") {
+                const result = requestAbort(session.root, role);
+                session.flashMessage(result.ok ? result.message : `error: ${result.error}`);
+            }
+            else if (name === "v") {
+                session.flashMessage(requestResetCounters(session.root, [role]));
             }
+            else if (session.held.rolePromptFor || session.held.search) {
+                session.flashMessage(session.held.rolePromptFor ? session.busyFlash("role prompt") : session.busyFlash("search"));
+            }
+            else {
+                // Ctrl+W opens the one-line wake editor; nothing is written until Enter. Empty wakes now.
+                openPauseEditor(role, true, false, `wake ${role}: [duration], e.g. "2h", or "cancel" (empty wakes now) — Enter to apply, Esc to cancel`);
+            }
+        }
+        catch (err) {
+            session.flashError(err);
+        }
+        return true;
+    };
+    // Esc cancels the pause editor without writing, restoring the previous prompt text.
+    const cancelPauseEdit = () => {
+        exitPauseEditMode();
+        return true;
+    };
+    // Enter in pause-edit mode parses "[duration] [reason]" and writes the same marker
+    // `tumwater pause --for/--reason` does. An invalid entry flashes and STAYS in the editor.
+    // It reads the current mode/draft and dispatches to the single named writer for the
+    // intent it resolves: a scheduled stop, a per-role wake, a per-role pause, or the team
+    // pause.
+    const commitPauseEntry = () => {
+        const target = pauseEditRole;
+        const stopParsed = pauseEditStop ? parseStopInInput(session.input) : null;
+        const wakeParsed = pauseEditWake && target !== null ? parseRoleWakeInput(session.input) : null;
+        const parsed = target !== null ? parseRolePauseInput(session.input) : parsePauseInput(session.input);
+        if (stopParsed) {
+            applyStopEntry(stopParsed);
             return true;
         }
-        if (key.name === "escape" && pauseEditMode) {
-            // Esc cancels the pause editor without writing, restoring the previous prompt text.
-            exitPauseEditMode();
+        if (wakeParsed) {
+            applyWakeEntry(wakeParsed, target);
             return true;
         }
-        if (key.name === "return" && pauseEditMode) {
-            // Enter in pause-edit mode parses "[duration] [reason]" and writes the same marker
-            // `tumwater pause --for/--reason` does. An invalid entry flashes and STAYS in the editor.
-            const target = pauseEditRole;
-            const stopParsed = pauseEditStop ? parseStopInInput(session.input) : null;
-            const wakeParsed = pauseEditWake && target !== null ? parseRoleWakeInput(session.input) : null;
-            const parsed = target !== null ? parseRolePauseInput(session.input) : parsePauseInput(session.input);
-            if (stopParsed) {
-                if (!stopParsed.ok) {
-                    session.flashMessage(stopParsed.error);
-                    return true;
-                }
-                try {
-                    const result = requestScheduledStop(session.root, stopParsed.inMs);
-                    exitPauseEditMode();
-                    session.flashMessage(result.ok ? result.message : `error: ${result.error}`);
-                }
-                catch (err) {
-                    session.flashError(err);
-                }
-                return true;
-            }
-            if (wakeParsed) {
-                if (!wakeParsed.ok) {
-                    session.flashMessage(wakeParsed.error);
-                    return true;
-                }
-                try {
-                    const message = wakeParsed.cancel ? cancelWakes(session.root, [target]) : requestWake(session.root, [target], wakeParsed.inMs);
-                    exitPauseEditMode();
-                    session.flashMessage(message);
-                }
-                catch (err) {
-                    session.flashError(err);
-                }
-                return true;
-            }
-            if (!parsed.ok) {
-                session.flashMessage(parsed.error);
-                return true;
-            }
-            if (target !== null) {
-                try {
-                    const at = session.now();
-                    const until = parsed.forMs === undefined ? undefined : at + parsed.forMs;
-                    const changed = pauseRole(session.root, target, until);
-                    exitPauseEditMode();
-                    session.flashMessage(rolePauseMessage(session.root, target, changed, until === undefined ? undefined : { ms: parsed.forMs, untilMs: until }, at));
-                }
-                catch (err) {
-                    session.flashError(err);
-                }
-                return true;
-            }
-            const team = parsed;
-            try {
-                const until = team.forMs === undefined ? undefined : session.now() + team.forMs;
-                const changed = pauseTeam(session.root, until, team.reason);
-                exitPauseEditMode();
-                const forSuffix = team.forMs === undefined ? "" : ` for ${durationLabel(team.forMs)}`;
-                session.flashMessage(changed || until !== undefined
-                    ? `${teamPausePhrase()}${forSuffix}${changed && team.reason ? `: ${team.reason}` : ""}`
-                    : "team is already paused");
-            }
-            catch (err) {
-                session.flashError(err);
-            }
+        if (!parsed.ok) {
+            session.flashMessage(parsed.error);
             return true;
         }
+        if (target !== null) {
+            applyRolePauseEntry(parsed, target);
+            return true;
+        }
+        applyTeamPauseEntry(parsed);
+        return true;
+    };
+    const applyStopEntry = (stopParsed) => {
+        if (!stopParsed.ok) {
+            session.flashMessage(stopParsed.error);
+            return;
+        }
+        try {
+            const result = requestScheduledStop(session.root, stopParsed.inMs);
+            exitPauseEditMode();
+            session.flashMessage(result.ok ? result.message : `error: ${result.error}`);
+        }
+        catch (err) {
+            session.flashError(err);
+        }
+    };
+    const applyWakeEntry = (wakeParsed, target) => {
+        if (!wakeParsed.ok) {
+            session.flashMessage(wakeParsed.error);
+            return;
+        }
+        try {
+            const message = wakeParsed.cancel ? cancelWakes(session.root, [target]) : requestWake(session.root, [target], wakeParsed.inMs);
+            exitPauseEditMode();
+            session.flashMessage(message);
+        }
+        catch (err) {
+            session.flashError(err);
+        }
+    };
+    const applyRolePauseEntry = (parsed, target) => {
+        try {
+            const at = session.now();
+            const until = parsed.forMs === undefined ? undefined : at + parsed.forMs;
+            const changed = pauseRole(session.root, target, until);
+            exitPauseEditMode();
+            session.flashMessage(rolePauseMessage(session.root, target, changed, until === undefined ? undefined : { ms: parsed.forMs, untilMs: until }, at));
+        }
+        catch (err) {
+            session.flashError(err);
+        }
+    };
+    const applyTeamPauseEntry = (parsed) => {
+        try {
+            const until = parsed.forMs === undefined ? undefined : session.now() + parsed.forMs;
+            const changed = pauseTeam(session.root, until, parsed.reason);
+            exitPauseEditMode();
+            const forSuffix = parsed.forMs === undefined ? "" : ` for ${durationLabel(parsed.forMs)}`;
+            session.flashMessage(changed || until !== undefined
+                ? `${teamPausePhrase()}${forSuffix}${changed && parsed.reason ? `: ${parsed.reason}` : ""}`
+                : "team is already paused");
+        }
+        catch (err) {
+            session.flashError(err);
+        }
+    };
+    const handleKey = (_str, key, ctx) => {
+        // Ordered dispatch: a guard miss falls through to the next arm, then to applyKey.
+        if (key.ctrl && key.name === "f" && !session.anyEditorHeld("pause"))
+            return teamPauseToggle(ctx);
+        if (key.ctrl && key.name === "q" && !session.anyEditorHeld("pause"))
+            return stopLaterToggle(ctx);
+        if (key.ctrl && key.name === "r" && ctx.view === 0 && !pauseEditMode && !session.anyEditorHeld("pause"))
+            return restartNow(ctx);
+        if (key.ctrl && (key.name === "p" || key.name === "w") && pauseEditRole !== null)
+            return closeRolePauseEdit();
+        if (!session.anyEditorHeld("rolePromptFor", "search") &&
+            ctx.roleIds.length > 0 &&
+            ctx.view >= 1 && ctx.view <= ctx.roleIds.length &&
+            key.ctrl && (key.name === "p" || key.name === "a" || key.name === "w" || key.name === "v"))
+            return roleControlArm(key.name, ctx);
+        if (key.name === "escape" && pauseEditMode)
+            return cancelPauseEdit();
+        if (key.name === "return" && pauseEditMode)
+            return commitPauseEntry();
         return false;
     };
     return { handleKey, exit: exitPauseEditMode };

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

@@ -1,6 +1,7 @@
 import { submitRolePromptAndWake } from "../../operator/operator-intent.js";
 import { pushPromptHistory } from "./tui-prompt-history.js";
 import { parseRolePromptInput } from "./tui-input.js";
+import { viewedRole } from "./tui-editor-ctx.js";
 /** The per-role prompt Ctrl+R editor on the shared prompt line. It owns its mode flag (the
  * viewed role's role id), its saved-draft pair, its exit helper, and the handleKey arms for its
  * key: the per-role toggle (guarded out of the other editors' prompt line) and its Esc/Enter
@@ -19,17 +20,16 @@ export function createPromptEditor(session) {
         session.held.rolePromptFor = null;
         restoreDraft();
     };
-    const handleKey = (_str, key, ctx) => {
-        // Ctrl+R toggles role-prompt mode for the viewed role (mnemonic: p**R**ompt — Ctrl+P is
-        // taken by pause): entering saves the director draft in this mode's own pair and blanks
-        // the line; entering again (or Esc) restores it. Mutually exclusive with budget mode by
-        // the outer guard and the mirrored refusal in the Ctrl+B branch. Rides the same per-role
-        // guard as the Ctrl+P/A/W pause controls so an editor's prompt line is never disturbed.
+    // Ctrl+R toggles role-prompt mode for the viewed role (mnemonic: p**R**ompt — Ctrl+P is
+    // taken by pause): entering saves the director draft in this mode's own pair and blanks
+    // the line; entering again (or Esc) restores it. Mutually exclusive with budget mode by
+    // the outer guard and the mirrored refusal in the Ctrl+B branch. Rides the same per-role
+    // guard as the Ctrl+P/A/W pause controls so an editor's prompt line is never disturbed.
+    const toggleRolePromptEdit = (ctx) => {
         if (!session.anyEditorHeld("rolePromptFor") &&
             ctx.roleIds.length > 0 &&
-            ctx.view >= 1 && ctx.view <= ctx.roleIds.length &&
-            key.ctrl && key.name === "r") {
-            const role = ctx.roleIds[ctx.view - 1]; // defined: view is clamped inside the transcript range
+            ctx.view >= 1 && ctx.view <= ctx.roleIds.length) {
+            const role = viewedRole(ctx); // defined: view is clamped inside the transcript range
             try {
                 if (rolePromptFor) {
                     exitRolePromptMode();
@@ -53,37 +53,48 @@ export function createPromptEditor(session) {
             }
             return true;
         }
-        if (key.name === "escape" && rolePromptFor) {
-            // Esc cancels role-prompt mode the same way, restoring the previous prompt text.
-            exitRolePromptMode();
+        return false;
+    };
+    // Esc cancels role-prompt mode the same way, restoring the previous prompt text.
+    const cancelRolePromptEdit = () => {
+        exitRolePromptMode();
+        return true;
+    };
+    // Enter in role-prompt mode submits for the viewed role through the same path
+    // `tumwater prompt --role` uses: the shared submitRolePromptAndWake enqueues into
+    // that role's own queue (length-capped by the shared rule), logs under the role,
+    // and wakes it so a live team's role comes in within one poll. An invalid
+    // (whitespace-only) line flashes and STAYS in edit mode; a failed queue write
+    // flashes the reason and keeps the text, the same contract the director path
+    // honors; success restores the saved draft.
+    const submitRolePromptEdit = () => {
+        const role = rolePromptFor; // dispatch guarantees it is set; kept for TS narrowing
+        if (role === null)
             return true;
+        const parsed = parseRolePromptInput(session.input);
+        if (!parsed.ok) {
+            session.flashMessage(parsed.error);
         }
-        if (key.name === "return" && rolePromptFor) {
-            // Enter in role-prompt mode submits for the viewed role through the same path
-            // `tumwater prompt --role` uses: the shared submitRolePromptAndWake enqueues into
-            // that role's own queue (length-capped by the shared rule), logs under the role,
-            // and wakes it so a live team's role comes in within one poll. An invalid
-            // (whitespace-only) line flashes and STAYS in edit mode; a failed queue write
-            // flashes the reason and keeps the text, the same contract the director path
-            // honors; success restores the saved draft.
-            const parsed = parseRolePromptInput(session.input);
-            if (!parsed.ok) {
-                session.flashMessage(parsed.error);
+        else {
+            try {
+                submitRolePromptAndWake(session.root, role, parsed.value, undefined);
+                session.promptHistory = pushPromptHistory(session.promptHistory, parsed.value);
+                exitRolePromptMode();
+                session.flashMessage(`added to ${role}'s inbox`);
             }
-            else {
-                const role = rolePromptFor;
-                try {
-                    submitRolePromptAndWake(session.root, role, parsed.value, undefined);
-                    session.promptHistory = pushPromptHistory(session.promptHistory, parsed.value);
-                    exitRolePromptMode();
-                    session.flashMessage(`added to ${role}'s inbox`);
-                }
-                catch (err) {
-                    session.flashError(err);
-                }
+            catch (err) {
+                session.flashError(err);
             }
-            return true;
         }
+        return true;
+    };
+    const handleKey = (_str, key, ctx) => {
+        if (key.ctrl && key.name === "r")
+            return toggleRolePromptEdit(ctx);
+        if (key.name === "escape" && rolePromptFor)
+            return cancelRolePromptEdit();
+        if (key.name === "return" && rolePromptFor)
+            return submitRolePromptEdit();
         return false;
     };
     return { handleKey, exit: exitRolePromptMode };