tumwater 0.1.2 → 0.2.0

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

@@ -0,0 +1,266 @@
+// vocabulary: plain
+import { cancelScheduledStopMessage, requestAbort, requestResetCounters, requestScheduledStop, requestRestart, requestWake, cancelWakes, rolePauseMessage, roleResumeMessage, } from "../../operator/operator-intent.js";
+import { isTeamPaused, pausedRoles, pauseTeam, pauseRole, resumeTeam, resumeRole, scheduledStopAt, } from "../../team/team-state.js";
+import { durationLabel } from "../../cli/cli-args.js";
+import { teamPausePhrase, teamResumePhrase } from "../../text/phrases.js";
+import { parsePauseInput, parseRolePauseInput, parseRoleWakeInput, parseStopInInput, } from "./tui-input.js";
+/** The pause/stop/wake editor on the shared prompt line: the whole-team Ctrl+F pause and Ctrl+Q
+ * stop editors, the per-loop Ctrl+P pause / Ctrl+A abort / Ctrl+W wake controls, and the
+ * parse/dispatch leaves those write. It owns its mode flags (pauseEditMode/`pauseEditRole`/
+ * `pauseEditWake`/`pauseEditStop`), its saved-draft pair, its exit helper, and the handleKey
+ * arms for its keys. Mutually exclusive with the other editors via the session's held registry. */
+export function createPauseEditor(session) {
+    let pauseEditMode = false;
+    let pauseEditRole = null;
+    let pauseEditWake = false;
+    let pauseEditStop = false;
+    let pauseSavedInput = "";
+    let pauseSavedCursor = 0;
+    // Leave pause-edit mode (Esc, Ctrl+F again, a written pause, or Ctrl+T): restore the draft.
+    const exitPauseEditMode = () => {
+        if (!pauseEditMode)
+            return;
+        pauseEditMode = false;
+        pauseEditRole = null;
+        pauseEditWake = false;
+        pauseEditStop = false;
+        session.held.pause = false;
+        session.held.pauseEditRole = null;
+        session.held.pauseEditWake = false;
+        session.held.pauseEditStop = false;
+        session.restorePromptFrom(pauseSavedInput, pauseSavedCursor);
+    };
+    const openPauseEditor = (role, wake, stop, hint) => {
+        session.settleDraft((t) => (pauseSavedInput = t), (n) => (pauseSavedCursor = n));
+        pauseEditMode = true;
+        pauseEditRole = role;
+        pauseEditWake = wake;
+        pauseEditStop = stop;
+        session.held.pause = true;
+        session.held.pauseEditRole = role;
+        session.held.pauseEditWake = wake;
+        session.held.pauseEditStop = stop;
+        session.input = "";
+        session.cursor = 0;
+        session.flashMessage(hint);
+    };
+    const handleKey = (_str, key, ctx) => {
+        if (key.ctrl && key.name === "f" &&
+            !session.held.budget && !session.held.rolePromptFor && !session.held.search &&
+            !session.held.queued && !session.held.answer && !session.held.entry &&
+            !session.held.attach && !session.held.notes && !session.held.retire && !session.held.quiet && !session.held.interval) {
+            // 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-loop 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);
+            }
+            return true;
+        }
+        if (key.ctrl && key.name === "q" &&
+            !session.held.budget && !session.held.rolePromptFor && !session.held.search &&
+            !session.held.queued && !session.held.answer && !session.held.entry &&
+            !session.held.attach && !session.held.notes && !session.held.retire && !session.held.quiet && !session.held.interval) {
+            // 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');
+                }
+            }
+            catch (err) {
+                session.flashError(err);
+            }
+            return true;
+        }
+        if (key.ctrl && key.name === "r" && ctx.view === 0 && !pauseEditMode &&
+            !session.held.budget && !session.held.rolePromptFor && !session.held.search &&
+            !session.held.queued && !session.held.answer && !session.held.entry &&
+            !session.held.attach && !session.held.retire) {
+            // 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);
+            }
+            catch (err) {
+                session.flashError(err);
+            }
+            return true;
+        }
+        // Per-loop controls on the transcript pane: Ctrl+P toggles the viewed loop's pause,
+        // Ctrl+A aborts its in-flight tick, 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-loop pause/wake editor, mirroring Ctrl+F's
+            // second press.
+            exitPauseEditMode();
+            return true;
+        }
+        if (!session.held.budget &&
+            !session.held.pause &&
+            !session.held.queued && !session.held.answer && !session.held.entry &&
+            !session.held.notes && !session.held.retire && !session.held.quiet && !session.held.interval &&
+            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 loop 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]));
+                }
+                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;
+        }
+        if (key.name === "escape" && pauseEditMode) {
+            // Esc cancels the pause editor without writing, restoring the previous prompt text.
+            exitPauseEditMode();
+            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);
+                }
+                else {
+                    try {
+                        const result = requestScheduledStop(session.root, stopParsed.inMs);
+                        exitPauseEditMode();
+                        session.flashMessage(result.ok ? result.message : `error: ${result.error}`);
+                    }
+                    catch (err) {
+                        session.flashError(err);
+                    }
+                }
+            }
+            else if (wakeParsed) {
+                if (!wakeParsed.ok) {
+                    session.flashMessage(wakeParsed.error);
+                }
+                else {
+                    try {
+                        const message = wakeParsed.cancel ? cancelWakes(session.root, target) : requestWake(session.root, [target], wakeParsed.inMs);
+                        exitPauseEditMode();
+                        session.flashMessage(message);
+                    }
+                    catch (err) {
+                        session.flashError(err);
+                    }
+                }
+            }
+            else if (!parsed.ok) {
+                session.flashMessage(parsed.error);
+            }
+            else 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);
+                }
+            }
+            else {
+                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);
+                }
+            }
+            return true;
+        }
+        return false;
+    };
+    return { handleKey, exit: exitPauseEditMode };
+}

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

@@ -0,0 +1,95 @@
+// vocabulary: plain
+import { submitRolePromptAndWake } from "../../operator/operator-intent.js";
+import { pushPromptHistory } from "./tui-prompt-history.js";
+import { parseRolePromptInput } from "./tui-input.js";
+/** The per-role prompt Ctrl+R editor on the shared prompt line. It owns its mode flag (the
+ * viewed loop's role id), its saved-draft pair, its exit helper, and the handleKey arms for its
+ * key: the per-loop toggle (guarded out of the other editors' prompt line) and its Esc/Enter
+ * leaves. Mutually exclusive with the other editors via the session's held registry. */
+export function createPromptEditor(session) {
+    let rolePromptFor = null;
+    let roleSavedInput = "";
+    let roleSavedCursor = 0;
+    // Leave role-prompt mode (Esc, Ctrl+R again, or Ctrl+T): restore the saved prompt text,
+    // and reset the recall state with it — the saved draft was saved settled (see the Ctrl+R
+    // handler), so resuming a browse entered in role mode would restore role-mode text onto
+    // the director line and lose the director draft the arrows had saved.
+    const exitRolePromptMode = () => {
+        if (!rolePromptFor)
+            return;
+        rolePromptFor = null;
+        session.held.rolePromptFor = null;
+        session.restorePromptFrom(roleSavedInput, roleSavedCursor);
+    };
+    const handleKey = (_str, key, ctx) => {
+        // Ctrl+R toggles role-prompt mode for the viewed loop (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-loop
+        // guard as the Ctrl+P/A/W pause controls so an editor's prompt line is never disturbed.
+        if (!session.held.budget &&
+            !session.held.pause &&
+            !session.held.queued && !session.held.answer && !session.held.entry &&
+            !session.held.notes && !session.held.quiet && !session.held.interval &&
+            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
+            try {
+                if (rolePromptFor) {
+                    exitRolePromptMode();
+                    session.flashMessage("role prompt cancelled");
+                }
+                else {
+                    // Mid-recall, the line holds a history entry while the real draft sits in the
+                    // recall state: settle first, so the role editor saves (and later restores) the
+                    // draft the operator was writing, and no stale index/draft crosses modes —
+                    // otherwise Esc here would surface role-mode recalls on the director line.
+                    session.settleDraft((t) => (roleSavedInput = t), (n) => (roleSavedCursor = n));
+                    rolePromptFor = role;
+                    session.held.rolePromptFor = role;
+                    session.input = "";
+                    session.cursor = 0;
+                    session.flashMessage(`prompt for ${role}: Enter to send, Esc to cancel`);
+                }
+            }
+            catch (err) {
+                session.flashError(err);
+            }
+            return true;
+        }
+        if (key.name === "escape" && rolePromptFor) {
+            // Esc cancels role-prompt mode the same way, restoring the previous prompt text.
+            exitRolePromptMode();
+            return true;
+        }
+        if (key.name === "return" && rolePromptFor) {
+            // Enter in role-prompt mode submits for the viewed loop through the same path
+            // `tumwater prompt --role` uses: the shared submitRolePromptAndWake enqueues into
+            // that loop's own queue (length-capped by the shared rule), logs under the loop,
+            // and wakes it so a live team's loop 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 {
+                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);
+                }
+            }
+            return true;
+        }
+        return false;
+    };
+    return { handleKey, exit: exitRolePromptMode };
+}

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

@@ -0,0 +1,98 @@
+// vocabulary: plain
+import { editQueuedFile, readQueuedPromptBody } from "../../inbox/inbox-edit.js";
+import { parseRolePromptInput } from "./tui-input.js";
+/** The Queued pane's in-place row editor (Ctrl+E) on the shared prompt line. It owns its target
+ * (`queuedEditFor`), its saved-draft pair, its exit helper, and the readQueuedPromptBody /
+ * editQueuedFile leaves that pre-fill the line and write it back. Mutually exclusive with the
+ * other editors via the session's held registry. */
+export function createQueuedEditor(session) {
+    let queuedEditFor = null;
+    let queuedSavedInput = "";
+    let queuedSavedCursor = 0;
+    // Leave the Queued pane's in-place editor (Esc, a saved edit, or Ctrl+T): restore the saved
+    // prompt text, and reset the recall state with it — the same settle contract the other
+    // editors honor.
+    const exitQueuedEdit = () => {
+        if (!queuedEditFor)
+            return;
+        queuedEditFor = null;
+        session.held.queued = null;
+        session.restorePromptFrom(queuedSavedInput, queuedSavedCursor);
+    };
+    const handleKey = (_str, key, ctx) => {
+        if (key.ctrl && key.name === "e" &&
+            !session.held.budget && !session.held.rolePromptFor && !session.held.search &&
+            !session.held.pause && queuedEditFor === null &&
+            !session.held.answer && !session.held.entry &&
+            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
+            // loop 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.
+                        session.settleDraft((t) => (queuedSavedInput = t), (n) => (queuedSavedCursor = n));
+                        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;
+        }
+        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);
+            }
+            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);
+                }
+            }
+            return true;
+        }
+        return false;
+    };
+    return { handleKey, exit: exitQueuedEdit };
+}

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

@@ -0,0 +1,106 @@
+// vocabulary: plain
+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/loop-ids.js";
+/** The Ctrl+O quiet-hours editor on the shared prompt line, the terminal twin of the dashboard
+ * role drawer's `Quiet hours` row and `tumwater role <id> --quiet-hours`. It owns its mode
+ * flag, its saved-draft pair, and the role pinned when it opened, so a roster shift cannot
+ * redirect the write. Enter writes through the shared setConfigKey/unsetConfigKey family the
+ * CLI and the drawer use — so checkQuietHours (naming `quietHoursPerRole.<id>`) and
+ * validateConfig own the window's truth — and Esc, Ctrl+O again, and Ctrl+T cancel by
+ * restoring the prompt draft. Mutually exclusive with the other editors on the one prompt
+ * line via the session's held registry. */
+export function createQuietEditor(session) {
+    let quietMode = false;
+    let savedInput = "";
+    let savedCursor = 0;
+    // The role scope pinned when the editor opened, so Enter writes the same role's window even
+    // if syncRoster shrinks or reorders the roster while the editor is open.
+    let lockedRole = null;
+    // Leave quiet-edit mode (Esc, Ctrl+O again, or Ctrl+T): restore the saved prompt text.
+    const exitQuietMode = () => {
+        if (!quietMode)
+            return;
+        quietMode = false;
+        session.held.quiet = false;
+        session.restorePromptFrom(savedInput, savedCursor);
+        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, in which case Ctrl+O is the toggle-out arm below. 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 && !(ctx.view >= 1 && ctx.view <= ctx.roleIds.length))
+                return false;
+            const role = ctx.roleIds[ctx.view - 1];
+            const held = session.heldEditorFlash("quiet");
+            if (held) {
+                // Mutually exclusive with the other editors: all share one prompt line, so a mode may
+                // not enter while another holds it. Flash the way out first.
+                session.flashMessage(held);
+                return true;
+            }
+            if (role === DIRECTOR_ROLE) {
+                session.flashMessage("the director has no quiet hours");
+                return true;
+            }
+            if (quietMode) {
+                exitQuietMode();
+                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)] ?? "";
+            session.settleDraft((t) => (savedInput = t), (n) => (savedCursor = n));
+            quietMode = true;
+            session.held.quiet = true;
+            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`);
+            return true;
+        }
+        if (key.name === "escape" && quietMode) {
+            // Esc cancels quiet-edit mode, restoring the previous prompt text.
+            exitQuietMode();
+            return true;
+        }
+        if (key.name === "return" && quietMode) {
+            // Enter commits the window through the shared setter family the CLI's `--quiet-hours`
+            // and the dashboard drawer use: an empty or whitespace-only line clears the key
+            // (`unsetConfigKey`), otherwise `setConfigKey` writes the dotted `quietHoursPerRole
+            // .<base>` entry as a JSON string. checkQuietHours (naming the dotted key) rejects a
+            // malformed window and validateConfig guards the 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 role = lockedRole;
+            const cfgKey = `quietHoursPerRole.${baseRoleOf(role)}`;
+            const text = session.input.trim();
+            const result = text === ""
+                ? unsetConfigKey(session.root, cfgKey)
+                : setConfigKey(session.root, cfgKey, JSON.stringify(text));
+            if (result.ok) {
+                exitQuietMode();
+                session.flashMessage(text === "" ? `${role}: quiet hours cleared` : `${role}: quiet hours set to ${text}`);
+            }
+            else {
+                session.flashMessage(result.error); // broken config or write failure — stay in edit mode
+            }
+            return true;
+        }
+        return false;
+    };
+    return {
+        handleKey,
+        exit: exitQuietMode,
+    };
+}

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

@@ -0,0 +1,83 @@
+// vocabulary: plain
+import { artifactPhrase, retireRole } from "../../operator/retire.js";
+/** The Health view's Ctrl+X retire editor on the shared prompt line, the terminal twin of
+ * `tumwater retire --role <id>` and the dashboard Settings card's Retire button. It owns its
+ * `retireMode` 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 Health view (`ctx.view === roleIds.length + 7`),
+ * so every other view's Ctrl+X arm (Transcript clears notes, Backlog cancels an entry, Inbox
+ * cancels a queued prompt) keeps the key. Enter runs the same `retireRole(session.root, role,
+ * {})` core the CLI and dashboard call, with the same never-force policy, and flashes the
+ * dashboard's own outcome wording; a safety-rail refusal or an empty id flashes and stays open
+ * so the operator can fix the id, Esc cancels and restores the draft. */
+export function createRetireEditor(session) {
+    let retireMode = false;
+    let retireSavedInput = "";
+    let retireSavedCursor = 0;
+    // Leave retire-edit mode (Esc, Enter's success path, or Ctrl+T): restore the saved prompt text.
+    const exitRetireMode = () => {
+        if (!retireMode)
+            return;
+        retireMode = false;
+        session.held.retire = false;
+        session.restorePromptFrom(retireSavedInput, retireSavedCursor);
+    };
+    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 notebook-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.
+            const held = session.heldEditorFlash("retire");
+            if (held) {
+                // Mutually exclusive with the other editors: all share one prompt line, so a mode may
+                // not enter while another holds it. Flash the way out instead of silently dropping
+                // the held mode's saved draft.
+                session.flashMessage(held);
+                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.
+            session.settleDraft((t) => (retireSavedInput = t), (n) => (retireSavedCursor = n));
+            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;
+        }
+        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);
+            });
+            return true;
+        }
+        return false;
+    };
+    return { handleKey, exit: exitRetireMode };
+}