tumwater 0.4.2 → 0.4.3

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

@@ -1,5 +1,6 @@
 import { setConfigKey, unsetConfigKey } from "../../config/config-write.js";
 import { isExponentSpelling } from "../../text/text.js";
+import { savedPromptDraft } from "./tui-editor-session.js";
 /** Build a team-scope config-key editor. The editor owns its mode flag and saved-draft pair
  * in a closure; it may take the line only on the Activity view (view 0, the team scope) or
  * when it already holds it (the toggle-out arm), and only while no other editor holds the
@@ -8,86 +9,97 @@ import { isExponentSpelling } from "../../text/text.js";
  * (the file is untouched), success restores the saved prompt text. */
 export function createTeamConfigKeyEditor(session, spec) {
     let mode = false;
-    let restoreDraft = () => { };
+    const draft = savedPromptDraft(session);
     // Leave the editor (Esc, the key again, or Ctrl+T): restore the saved prompt text.
     const exit = () => {
         if (!mode)
             return;
         mode = false;
         session.held[spec.mode] = false;
-        restoreDraft();
+        draft.restore();
     };
-    const handleKey = (_str, key, ctx) => {
-        if (key.ctrl && key.name === spec.openCtrl) {
-            // The key opens this team-scope editor only on the Activity view (view 0, the team
-            // scope): on the other views the key keeps its own meaning and this arm falls through
-            // so the later guards run. While open, the key toggles the editor out. Entering saves
-            // the prompt draft; leaving restores it.
-            if (mode) {
-                exit();
-                return true;
-            }
-            if (ctx.view !== 0)
-                return false;
-            // A check-cap editor with text on the line must fall through to applyKey's kill before the
-            // hold-guard runs: while another editor holds the (non-empty) line, Ctrl+K should still
-            // kill from the cursor to the line end rather than be consumed by the mutual-exclusion
-            // flash, and a typed draft must never be swallowed. Only Ctrl+K sets `requireEmptyPrompt`,
-            // so only it takes this fall-through.
-            if (spec.requireEmptyPrompt && session.input !== "")
-                return false;
-            if (session.editorEntryDenied(spec.mode))
-                return true;
-            const existing = spec.prefill(session);
-            restoreDraft = session.takeDraft();
-            mode = true;
-            session.held[spec.mode] = true;
-            session.input = existing;
-            session.cursor = session.input.length;
-            session.flashMessage(spec.openFlash);
-            return true;
-        }
-        if (key.name === "escape" && mode) {
-            // Esc cancels the editor, restoring the previous prompt text.
+    // The key opens this team-scope editor only on the Activity view (view 0, the team
+    // scope): on the other views the key keeps its own meaning and this arm falls through
+    // so the later guards run. While open, the key toggles the editor out. Entering saves
+    // the prompt draft; leaving restores it.
+    const openOrToggle = (ctx) => {
+        if (mode) {
             exit();
             return true;
         }
-        if (key.name === "return" && mode) {
-            // Enter commits through the shared setter family the config CLI and the dashboard
-            // Settings use: a whitespace-trimmed empty line clears the key (`unsetConfigKey`),
-            // otherwise `setConfigKey` writes the trimmed line — it JSON-parses the text, so a
-            // bare command or typed value stays the literal while a typed number becomes a number
-            // — and validateConfig owns the value's truth (naming `configKey`) on the way out. An
-            // invalid value flashes and STAYS in edit mode so the operator can fix it (the file is
-            // untouched); success restores the saved prompt text.
-            const text = session.input.trim();
-            // Shape, before the write, for the plain-integer team keys: an exponent spelling is
-            // itself a JSON number that setConfigKey's JSON.parse would read past validateConfig
-            // and silently write, so refuse it here and stay in edit mode (the twin of the per-role
-            // instances/interval guards); a non-exponent invalid falls through to validateConfig.
-            if (spec.plainIntegerKey && text !== "" && isExponentSpelling(text)) {
-                session.flashMessage(`${spec.configKey} must be a plain integer — no exponent notation`);
-                return true;
-            }
-            const result = text === ""
-                ? unsetConfigKey(session.root, spec.configKey)
-                : setConfigKey(session.root, spec.configKey, text);
-            if (result.ok) {
-                exit();
-                const noop = text === "" ? result.oldValue === undefined : "unchanged" in result;
-                session.flashMessage(noop
-                    ? text === ""
-                        ? `${spec.configKey} is not set in tumwater.json, so nothing was cleared`
-                        : `${spec.configKey} is already ${text}, so tumwater.json was not written`
-                    : text === ""
-                        ? spec.clearedFlash
-                        : spec.setFlash(text));
-            }
-            else {
-                session.flashMessage(result.error); // broken config or write failure — stay in edit mode
-            }
+        if (ctx.view !== 0)
+            return false;
+        // A check-cap editor with text on the line must fall through to applyKey's kill before the
+        // hold-guard runs: while another editor holds the (non-empty) line, Ctrl+K should still
+        // kill from the cursor to the line end rather than be consumed by the mutual-exclusion
+        // flash, and a typed draft must never be swallowed. Only Ctrl+K sets `requireEmptyPrompt`,
+        // so only it takes this fall-through.
+        if (spec.requireEmptyPrompt && session.input !== "")
+            return false;
+        if (session.editorEntryDenied(spec.mode))
+            return true;
+        const existing = spec.prefill(session);
+        draft.save();
+        mode = true;
+        session.held[spec.mode] = true;
+        session.input = existing;
+        session.cursor = session.input.length;
+        session.flashMessage(spec.openFlash);
+        return true;
+    };
+    // Esc cancels the editor, restoring the previous prompt text.
+    const cancel = () => {
+        exit();
+        return true;
+    };
+    // The four-way message a successful commit flashes: an empty-line no-op clear, a real
+    // clear, an unchanged set, and a real set.
+    const commitFlash = (result, text) => {
+        const noop = text === "" ? result.oldValue === undefined : "unchanged" in result;
+        return noop
+            ? text === ""
+                ? `${spec.configKey} is not set in tumwater.json, so nothing was cleared`
+                : `${spec.configKey} is already ${text}, so tumwater.json was not written`
+            : text === ""
+                ? spec.clearedFlash
+                : spec.setFlash(text);
+    };
+    // Enter commits through the shared setter family the config CLI and the dashboard
+    // Settings use: a whitespace-trimmed empty line clears the key (`unsetConfigKey`),
+    // otherwise `setConfigKey` writes the trimmed line — it JSON-parses the text, so a
+    // bare command or typed value stays the literal while a typed number becomes a number
+    // — and validateConfig owns the value's truth (naming `configKey`) on the way out. An
+    // invalid value flashes and STAYS in edit mode so the operator can fix it (the file is
+    // untouched); success restores the saved prompt text.
+    const commit = () => {
+        const text = session.input.trim();
+        // Shape, before the write, for the plain-integer team keys: an exponent spelling is
+        // itself a JSON number that setConfigKey's JSON.parse would read past validateConfig
+        // and silently write, so refuse it here and stay in edit mode (the twin of the per-role
+        // instances/interval guards); a non-exponent invalid falls through to validateConfig.
+        if (spec.plainIntegerKey && text !== "" && isExponentSpelling(text)) {
+            session.flashMessage(`${spec.configKey} must be a plain integer — no exponent notation`);
             return true;
         }
+        const result = text === ""
+            ? unsetConfigKey(session.root, spec.configKey)
+            : setConfigKey(session.root, spec.configKey, text);
+        if (result.ok) {
+            exit();
+            session.flashMessage(commitFlash(result, text));
+        }
+        else {
+            session.flashMessage(result.error); // broken config or write failure — stay in edit mode
+        }
+        return true;
+    };
+    const handleKey = (_str, key, ctx) => {
+        if (key.ctrl && key.name === spec.openCtrl)
+            return openOrToggle(ctx);
+        if (key.name === "escape" && mode)
+            return cancel();
+        if (key.name === "return" && mode)
+            return commit();
         return false;
     };
     return {

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

@@ -5,7 +5,8 @@ import { submitRolePromptAndWake } from "../../operator/operator-intent.js";
 import { promptLengthProblem } from "../../inbox/inbox-submit.js";
 import { collapseWhitespace } from "../../text/text.js";
 import { selectedEditableEntry } from "./tui-pane-backlog.js";
-import { readEditorPath } from "./tui-editor-session.js";
+import { guardError } from "./tui-guard.js";
+import { readEditorPath, savedPromptDraft } from "./tui-editor-session.js";
 /** The backlog pane's title editor (Ctrl+N new entry, Ctrl+E on a selected plan or bug) on the
  * shared prompt line. It owns its target (`entryEditFor`), its plan↔bug flip, its saved-draft
  * pair, its exit helper, and the fileEntryWithBody / tryEditEntry / commit arms, plus the
@@ -13,7 +14,7 @@ import { readEditorPath } from "./tui-editor-session.js";
  * the session's held registry. */
 export function createEntryEditor(session) {
     let entryEditFor = null;
-    let restoreDraft = () => { };
+    const draft = savedPromptDraft(session);
     // The triple state of the entry editor's prompt line: false (the title field), true (the
     // file-path field whose contents replace the whole entry), and the draft the toggle parks
     // when it hands the line to a different field.
@@ -29,7 +30,7 @@ export function createEntryEditor(session) {
         entryEditFor = null;
         entryBodyFile = false;
         session.held.entry = null;
-        restoreDraft();
+        draft.restore();
     };
     // On the Backlog view Ctrl+N files a new entry: it opens the title editor with a null
     // position (new plan), and pressed again inside that editor flips plan <-> bug.
@@ -44,7 +45,7 @@ export function createEntryEditor(session) {
     // already holding the line) is the notes/change/trail cycle, a pane arm the outer
     // dispatch handles — this factory returns false so it runs.
     const openNewEntry = () => {
-        restoreDraft = session.takeDraft();
+        draft.save();
         entryEditFor = { kind: "plan", position: null, title: "" };
         session.held.entry = entryEditFor;
         session.input = "";
@@ -76,22 +77,19 @@ export function createEntryEditor(session) {
     // saves through tryEditEntry, the non-exiting core the dashboard drawer shares, keeping
     // the body and stamp. The prompt line is single-line, so only the title is editable here.
     const openSelectedEntry = (ctx) => {
-        try {
+        guardError(session, () => {
             const selected = selectedEditableEntry(session, ctx.selectedEntry, "edited");
             if (selected !== null) {
                 const kind = selected.kind;
                 const position = selected.position;
-                restoreDraft = session.takeDraft();
+                draft.save();
                 entryEditFor = { kind, position, title: selected.picked.title };
                 session.held.entry = entryEditFor;
                 session.input = stripEntryStamp(selected.picked.title);
                 session.cursor = session.input.length;
                 session.flashMessage(`editing ${kind} #${position} — Enter to save, Esc to cancel`);
             }
-        }
-        catch (err) {
-            session.flashError(err);
-        }
+        });
         return true;
     };
     // Esc cancels the title editor, restoring the previous prompt text; nothing is written.
@@ -107,7 +105,7 @@ export function createEntryEditor(session) {
     // the two arms pass differently is the (title, body) pair taking the entry's place;
     // an omitted body preserves the matched entry's own body (the title edit arm).
     const applyEntryEdit = (target, newTitle, newBody) => {
-        try {
+        guardError(session, () => {
             // Both call sites (the file arm's and the title arm's Entry-save paths) run only
             // when `target.position` is non-null, so the position math never sees a null.
             const position = target.position;
@@ -131,10 +129,7 @@ export function createEntryEditor(session) {
                 session.clearBacklogSelection();
                 session.flashMessage(`that ${target.kind} was already removed or moved — nothing edited`);
             }
-        }
-        catch (err) {
-            session.flashError(err);
-        }
+        });
     };
     // File mode: the line holds a path whose contents replace title and body through the
     // same title-checked tryEditEntry core the title edit uses, keeping the entry's
@@ -160,7 +155,7 @@ export function createEntryEditor(session) {
     // New entry (Ctrl+N): file by title with an empty body and wake its role, the same
     // steps handleBacklogFile takes; a length problem or a throw stays in the editor.
     const fileNewEntry = (target) => {
-        try {
+        guardError(session, () => {
             const { role, wakeText } = OPERATOR_FILE_KINDS[target.kind];
             const problem = promptLengthProblem(wakeText(collapseWhitespace(session.input)), role);
             if (problem) {
@@ -172,10 +167,7 @@ export function createEntryEditor(session) {
             submitRolePromptAndWake(session.root, role, wakeText(filed.title));
             exitEntryEdit();
             session.flashMessage(`filed ${target.kind}: ${filed.title} — woke ${role}`);
-        }
-        catch (err) {
-            session.flashError(err);
-        }
+        });
     };
     const commitEntryTitle = (target) => {
         applyEntryEdit(target, session.input);

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

@@ -3,7 +3,9 @@ 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 { guardError } from "./tui-guard.js";
 import { viewedRole } from "./tui-editor-ctx.js";
+import { savedPromptDraft } from "./tui-editor-session.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`/
@@ -14,7 +16,7 @@ export function createPauseEditor(session) {
     let pauseEditRole = null;
     let pauseEditWake = false;
     let pauseEditStop = false;
-    let restoreDraft = () => { };
+    const draft = savedPromptDraft(session);
     // Leave pause-edit mode (Esc, Ctrl+F again, a written pause, or Ctrl+T): restore the draft.
     const exitPauseEditMode = () => {
         if (!pauseEditMode)
@@ -27,10 +29,10 @@ export function createPauseEditor(session) {
         session.held.pauseEditRole = null;
         session.held.pauseEditWake = false;
         session.held.pauseEditStop = false;
-        restoreDraft();
+        draft.restore();
     };
     const openPauseEditor = (role, wake, stop, hint) => {
-        restoreDraft = session.takeDraft();
+        draft.save();
         pauseEditMode = true;
         pauseEditRole = role;
         pauseEditWake = wake;
@@ -57,7 +59,7 @@ export function createPauseEditor(session) {
             exitPauseEditMode();
             return true;
         }
-        try {
+        guardError(session, () => {
             if (isTeamPaused(session.root)) {
                 session.flashMessage(resumeTeam(session.root) ? teamResumePhrase() : "team was not paused");
             }
@@ -66,10 +68,7 @@ export function createPauseEditor(session) {
                 // 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
@@ -81,7 +80,7 @@ export function createPauseEditor(session) {
             exitPauseEditMode();
             return true;
         }
-        try {
+        guardError(session, () => {
             if (scheduledStopAt(session.root) !== undefined) {
                 session.flashMessage(cancelScheduledStopMessage(session.root));
             }
@@ -90,10 +89,7 @@ export function createPauseEditor(session) {
                 // 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;
     };
     // Ctrl+R on the Activity view applies the pending self-redeploy now — the terminal twin
@@ -106,13 +102,10 @@ export function createPauseEditor(session) {
     // 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 {
+        guardError(session, () => {
             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
@@ -132,7 +125,7 @@ export function createPauseEditor(session) {
     // 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 {
+        guardError(session, () => {
             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
@@ -163,10 +156,7 @@ export function createPauseEditor(session) {
                 // 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.
@@ -208,43 +198,34 @@ export function createPauseEditor(session) {
             session.flashMessage(stopParsed.error);
             return;
         }
-        try {
+        guardError(session, () => {
             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 {
+        guardError(session, () => {
             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 {
+        guardError(session, () => {
             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 {
+        guardError(session, () => {
             const until = parsed.forMs === undefined ? undefined : session.now() + parsed.forMs;
             const changed = pauseTeam(session.root, until, parsed.reason);
             exitPauseEditMode();
@@ -252,31 +233,44 @@ export function createPauseEditor(session) {
             session.flashMessage(changed || until !== undefined
                 ? `${teamPausePhrase()}${forSuffix}${changed && parsed.reason ? `: ${parsed.reason}` : ""}`
                 : "team is already paused");
+        });
+    };
+    const pauseLineFree = () => !session.anyEditorHeld("pause");
+    const restartAllowed = (ctx) => ctx.view === 0 && !pauseEditMode && pauseLineFree();
+    const roleViewEditable = (ctx) => !session.anyEditorHeld("rolePromptFor", "search") &&
+        ctx.roleIds.length > 0 &&
+        ctx.view >= 1 && ctx.view <= ctx.roleIds.length;
+    const ctrlRoutes = [
+        { name: "f", should: pauseLineFree, run: teamPauseToggle },
+        { name: "q", should: pauseLineFree, run: stopLaterToggle },
+        { name: "r", should: restartAllowed, run: restartNow },
+        { name: "p", should: () => pauseEditRole !== null, run: closeRolePauseEdit },
+        { name: "w", should: () => pauseEditRole !== null, run: closeRolePauseEdit },
+        { name: "p", should: roleViewEditable, run: (ctx) => roleControlArm("p", ctx) },
+        { name: "a", should: roleViewEditable, run: (ctx) => roleControlArm("a", ctx) },
+        { name: "w", should: roleViewEditable, run: (ctx) => roleControlArm("w", ctx) },
+        { name: "v", should: roleViewEditable, run: (ctx) => roleControlArm("v", ctx) },
+    ];
+    const routeCtrl = (key, ctx) => {
+        for (const route of ctrlRoutes) {
+            if (route.name === key.name && route.should(ctx))
+                return route.run(ctx);
         }
-        catch (err) {
-            session.flashError(err);
-        }
+        return null;
     };
-    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);
+    const editEntryArm = (key) => {
         if (key.name === "escape" && pauseEditMode)
             return cancelPauseEdit();
         if (key.name === "return" && pauseEditMode)
             return commitPauseEntry();
         return false;
     };
+    const handleKey = (_str, key, ctx) => {
+        // Ordered dispatch: a guard miss falls through to the next route, then to editEntryArm.
+        const ctrl = key.ctrl ? routeCtrl(key, ctx) : null;
+        if (ctrl !== null)
+            return ctrl;
+        return editEntryArm(key);
+    };
     return { handleKey, exit: exitPauseEditMode };
 }

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

@@ -1,14 +1,16 @@
 import { submitRolePromptAndWake } from "../../operator/operator-intent.js";
 import { pushPromptHistory } from "./tui-prompt-history.js";
 import { parseRolePromptInput } from "./tui-input.js";
+import { guardError } from "./tui-guard.js";
 import { viewedRole } from "./tui-editor-ctx.js";
+import { savedPromptDraft } from "./tui-editor-session.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
  * leaves. Mutually exclusive with the other editors via the session's held registry. */
 export function createPromptEditor(session) {
     let rolePromptFor = null;
-    let restoreDraft = () => { };
+    const draft = savedPromptDraft(session);
     // 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
@@ -18,7 +20,7 @@ export function createPromptEditor(session) {
             return;
         rolePromptFor = null;
         session.held.rolePromptFor = null;
-        restoreDraft();
+        draft.restore();
     };
     // 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
@@ -30,7 +32,7 @@ export function createPromptEditor(session) {
             ctx.roleIds.length > 0 &&
             ctx.view >= 1 && ctx.view <= ctx.roleIds.length) {
             const role = viewedRole(ctx); // defined: view is clamped inside the transcript range
-            try {
+            guardError(session, () => {
                 if (rolePromptFor) {
                     exitRolePromptMode();
                     session.flashMessage("role prompt cancelled");
@@ -40,17 +42,14 @@ export function createPromptEditor(session) {
                     // 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.
-                    restoreDraft = session.takeDraft();
+                    draft.save();
                     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;
         }
         return false;
@@ -76,15 +75,12 @@ export function createPromptEditor(session) {
             session.flashMessage(parsed.error);
         }
         else {
-            try {
+            guardError(session, () => {
                 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;
     };

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

@@ -1,12 +1,14 @@
 import { editQueuedFile, readQueuedPromptBody } from "../../inbox/inbox-edit.js";
 import { parseRolePromptInput } from "./tui-input.js";
+import { guardError } from "./tui-guard.js";
+import { savedPromptDraft } from "./tui-editor-session.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 restoreDraft = () => { };
+    const draft = savedPromptDraft(session);
     // 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.
@@ -15,7 +17,7 @@ export function createQueuedEditor(session) {
             return;
         queuedEditFor = null;
         session.held.queued = null;
-        restoreDraft();
+        draft.restore();
     };
     // 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
@@ -31,8 +33,9 @@ export function createQueuedEditor(session) {
             ctx.selectedQueued === null) {
             return false;
         }
-        try {
-            const position = Math.min(ctx.selectedQueued, ctx.queuedRows.length - 1);
+        const selected = ctx.selectedQueued; // narrowed to number by the guard above
+        guardError(session, () => {
+            const position = Math.min(selected, ctx.queuedRows.length - 1);
             const row = ctx.queuedRows[position];
             if (row !== undefined) {
                 const body = readQueuedPromptBody(session.root, row.role, row.file);
@@ -44,7 +47,7 @@ export function createQueuedEditor(session) {
                     // 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();
+                    draft.save();
                     queuedEditFor = { role: row.role, file: row.file };
                     session.held.queued = queuedEditFor;
                     session.input = body;
@@ -52,10 +55,7 @@ export function createQueuedEditor(session) {
                     session.flashMessage(`editing inbox message #${row.position} for ${row.role} — Enter to save, Esc to cancel`);
                 }
             }
-        }
-        catch (err) {
-            session.flashError(err);
-        }
+        });
         return true;
     };
     // Esc cancels the Queued pane's in-place editor, restoring the previous prompt text.
@@ -77,17 +77,14 @@ export function createQueuedEditor(session) {
         else {
             // The dispatch guards on `queuedEditFor`, so it is never null when this arm runs.
             const target = queuedEditFor;
-            try {
+            guardError(session, () => {
                 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;
     };