tumwater 0.1.2 → 0.2.0

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

@@ -0,0 +1,73 @@
+/** The shared `/` search editor on the prompt line: over the History pane's tick rows or the
+ * Activity feed's events. It owns its mode flag (`searchMode`), its target pane (`searchFor`),
+ * its saved-draft pair, and the applyHistorySearch / applyActivitySearch leaves. Mutually
+ * exclusive with the other editors via the session's held registry. */
+export function createSearchEditor(session) {
+    let searchMode = false;
+    // Which pane the shared `/` editor feeds: History's tick search or Activity's event search.
+    // The target is captured when `/` opens so a roster change mid-edit cannot retarget Enter.
+    let searchFor = "history";
+    let searchSavedInput = "";
+    let searchSavedCursor = 0;
+    // Leave the shared search editor (Enter applies, Esc cancels, Ctrl+T cycles): restore the
+    // saved prompt text, and reset the recall state with it — the same settle contract the budget
+    // and role-prompt editors honor. The applied activityGrep/historyGrep itself persists across
+    // view cycling, like historyWindow/historyResult.
+    const exitHistorySearch = () => {
+        if (!searchMode)
+            return;
+        searchMode = false;
+        session.held.search = false;
+        session.restorePromptFrom(searchSavedInput, searchSavedCursor);
+    };
+    const handleKey = (str, key, ctx) => {
+        if (!key.ctrl && str === "/" && !searchMode && !session.held.budget &&
+            !session.held.rolePromptFor && !session.held.pause &&
+            !session.held.queued && !session.held.answer && !session.held.entry &&
+            !session.held.attach && !session.held.retire &&
+            (ctx.view === 0 || ctx.view === ctx.roleIds.length + 4) && session.input === "") {
+            // `/` opens a free-text search on the prompt line (the pager's search key; this project
+            // already reserves `/` for a meta action): over the History pane's tick rows on History,
+            // over the Activity feed's events on Activity. Guarded to those two views and to an empty
+            // line, so elsewhere it types into the prompt as today and a director draft is never
+            // disturbed. Pre-fills the applied pattern so Enter re-submits it and the operator can
+            // edit it; Esc cancels without applying.
+            session.settleDraft((t) => (searchSavedInput = t), (n) => (searchSavedCursor = n));
+            searchFor = ctx.view === 0 ? "activity" : "history";
+            searchMode = true;
+            session.held.search = true;
+            session.input = (searchFor === "activity" ? ctx.activityGrep : ctx.historyGrep) ?? "";
+            session.cursor = session.input.length;
+            session.flashMessage(searchFor === "activity" ? "search events: Enter to filter, Esc to cancel" : "search runs: Enter to filter, Esc to cancel");
+            return true;
+        }
+        if (key.name === "escape" && searchMode) {
+            // Esc cancels the History search without applying it; the applied pattern is unchanged.
+            exitHistorySearch();
+            return true;
+        }
+        if (key.name === "return" && searchMode) {
+            // Enter applies the trimmed line to the pane the editor opened over: Activity sets
+            // activityGrep (an empty line clears it) and resets the scroll to the live tail — the
+            // offset indexed the old filtered list; History recomputes its row cache now (the pane
+            // is showing) and re-enters at its head. A successful apply restores the saved prompt
+            // draft through exitHistorySearch, the shared editor's exit.
+            const pattern = session.input.trim();
+            if (searchFor === "activity") {
+                const applied = pattern === "" ? null : pattern;
+                session.applyActivitySearch(applied);
+                exitHistorySearch();
+                session.flashMessage(applied === null ? "search cleared" : `search: "${applied}"`);
+            }
+            else {
+                const applied = pattern === "" ? null : pattern;
+                session.applyHistorySearch(applied);
+                exitHistorySearch();
+                session.flashMessage(applied === null ? "search cleared" : `search: "${applied}"`);
+            }
+            return true;
+        }
+        return false;
+    };
+    return { handleKey, exit: exitHistorySearch };
+}

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

@@ -0,0 +1,97 @@
+// vocabulary: plain
+import { newPromptHistory, resetPromptRecall, settlePromptRecall, } from "./tui-prompt-history.js";
+/** Build the shared prompt-line session from the disk-side deps the aggregator received. The
+ * editor modules then take this session plus each keypress's `TuiEditorCtx`. */
+export function createTuiEditorSession(deps) {
+    const session = {
+        input: "",
+        cursor: 0,
+        promptHistory: newPromptHistory(),
+        images: [],
+        held: {
+            budget: false,
+            rolePromptFor: null,
+            search: false,
+            pause: false,
+            pauseEditRole: null,
+            pauseEditWake: false,
+            pauseEditStop: false,
+            queued: null,
+            answer: null,
+            entry: null,
+            attach: false,
+            notes: null,
+            brief: false,
+            retire: false,
+            quiet: false,
+            interval: false,
+        },
+        root: deps.root,
+        now: deps.now,
+        flat: deps.flat,
+        refreshQueued: deps.refreshQueued,
+        refreshNotes: deps.refreshNotes,
+        refreshBrief: deps.refreshBrief,
+        clearBacklogSelection: deps.clearBacklogSelection,
+        applyHistorySearch: deps.applyHistorySearch,
+        applyActivitySearch: deps.applyActivitySearch,
+        flashMessage: deps.flashMessage,
+        flashError: deps.flashError,
+        commitBacklogEdit: deps.commitBacklogEdit,
+        restorePromptFrom(text, pos) {
+            session.input = text;
+            session.cursor = pos;
+            session.promptHistory = resetPromptRecall(session.promptHistory);
+        },
+        settleDraft(saveInput, saveCursor) {
+            const settled = settlePromptRecall(session.promptHistory, session.input, session.cursor);
+            session.promptHistory = settled.history;
+            saveInput(settled.text);
+            saveCursor(settled.cursor);
+        },
+        busyFlash(subject) {
+            return `finish or cancel the ${subject} first (Esc cancels)`;
+        },
+        heldEditorFlash(entering) {
+            const h = session.held;
+            if (h.search)
+                return session.busyFlash("search");
+            if (h.pause)
+                return session.busyFlash("pause");
+            if (h.queued)
+                return session.busyFlash("inbox edit");
+            if (h.answer)
+                return session.busyFlash("answer");
+            if (h.entry)
+                return session.busyFlash("entry edit");
+            if (h.rolePromptFor)
+                return session.busyFlash(`prompt for ${h.rolePromptFor}`);
+            if (h.attach && entering !== "attach")
+                return session.busyFlash("image attach");
+            if (h.notes && entering !== "notes")
+                return session.busyFlash("notes edit");
+            if (h.brief && entering !== "brief")
+                return session.busyFlash("brief edit");
+            if (h.retire && entering !== "retire")
+                return session.busyFlash("retire role");
+            if (h.quiet && entering !== "quiet")
+                return session.busyFlash("quiet hours");
+            if (h.interval && entering !== "interval")
+                return session.busyFlash("min run interval");
+            if (entering === "attach" && h.budget)
+                return session.busyFlash("budget edit");
+            if (entering === "notes" && (h.attach || h.budget))
+                return session.busyFlash(h.attach ? "image attach" : "budget edit");
+            if (entering === "brief" && h.budget)
+                return session.busyFlash("budget edit");
+            if (entering === "retire" && (h.attach || h.notes || h.budget))
+                return session.busyFlash(h.attach ? "image attach" : h.notes ? "notes edit" : "budget edit");
+            if (entering === "quiet" && (h.attach || h.notes || h.budget || h.brief || h.retire))
+                return session.busyFlash(h.attach ? "image attach" : h.notes ? "notes edit" : h.brief ? "brief edit" : h.retire ? "retire role" : "budget edit");
+            if (entering === "interval" && (h.attach || h.notes || h.budget || h.brief || h.retire || h.quiet))
+                return session.busyFlash(h.attach ? "image attach" : h.notes ? "notes edit" : h.brief ? "brief edit" : h.retire ? "retire role" : h.quiet ? "quiet hours" : "budget edit");
+            return null;
+        },
+    };
+    return session;
+}

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

@@ -0,0 +1,152 @@
+// vocabulary: plain
+import { submitPrompt } from "../../inbox/inbox-submit.js";
+import { applyKey } from "./tui-input.js";
+import { pushPromptHistory, recallPromptHistory } from "./tui-prompt-history.js";
+import { createTuiEditorSession } from "./tui-editor-session.js";
+import { createBudgetEditor } from "./tui-editor-budget.js";
+import { createQuietEditor } from "./tui-editor-quiet.js";
+import { createIntervalEditor } from "./tui-editor-interval.js";
+import { createAttachEditor } from "./tui-editor-attach.js";
+import { createNotesEditor } from "./tui-editor-notes.js";
+import { createBriefEditor } from "./tui-editor-brief.js";
+import { createRetireEditor } from "./tui-editor-retire.js";
+import { createPromptEditor } from "./tui-editor-prompt.js";
+import { createPauseEditor } from "./tui-editor-pause.js";
+import { createQueuedEditor } from "./tui-editor-queued.js";
+import { createAnswerEditor } from "./tui-editor-answer.js";
+import { createEntryEditor } from "./tui-editor-entry.js";
+import { createSearchEditor } from "./tui-editor-search.js";
+/** The prompt-line editor half of the createTuiKeys closure: a thin aggregator that builds the
+ * shared prompt-line session (tui-editor-session.ts) and the set of mutually-exclusive modal
+ * editors on it — budget Ctrl+B, quiet-hours Ctrl+O, role-prompt Ctrl+R, pause
+ * Ctrl+F/Ctrl+Q, answer, entry-edit, queued-edit, and the `/` search — each with its own
+ * saved-draft pair and exit
+ * helper in its own module beside the session. `handleKey` routes each key to the editors in
+ * today's priority order (each module returns true when it consumed the key and false to fall
+ * through, so the mutually-exclusive/busy-guard ordering is preserved exactly); the session's
+ * `held` registry and `heldEditorFlash` hold the exclusive-line invariants once, at the module
+ * boundary, instead of being re-stated per editor. The disk/commit responsibilities and the pane
+ * state stay on the tui-keys.ts and tui-panes.ts side; this factory receives them as deps and
+ * the per-keypress pane reads as ctx. */
+export function createTuiEditors(deps) {
+    const session = createTuiEditorSession(deps);
+    const editors = [
+        createBudgetEditor(session),
+        createQuietEditor(session),
+        createIntervalEditor(session),
+        createAttachEditor(session),
+        createNotesEditor(session),
+        createPauseEditor(session),
+        createPromptEditor(session),
+        createQueuedEditor(session),
+        createAnswerEditor(session),
+        createEntryEditor(session),
+        createSearchEditor(session),
+        createBriefEditor(session),
+        createRetireEditor(session),
+    ];
+    const handleKey = (str, key, ctx) => {
+        // Route the key to each editor in today's priority order; each module returns true when it
+        // consumed the key (the mutually-exclusive/busy-guard ordering is preserved exactly) and
+        // false to fall through to the next.
+        for (const editor of editors) {
+            if (editor.handleKey(str, key, ctx))
+                return true;
+        }
+        // The Enter key submits the director prompt when no modal editor holds the line — the
+        // shared/none case of the Enter arm. Only reached when the key was "return" and no editor
+        // consumed it; any other unhandled key falls through to the pane arms.
+        if (key.name === "return") {
+            const prompt = session.input.trim();
+            if (!prompt) {
+                // Whitespace-only input queues nothing; drop it like an empty line.
+                session.input = "";
+                session.cursor = 0;
+            }
+            else {
+                const images = session.images.length > 0 ? session.images : undefined;
+                try {
+                    submitPrompt(session.root, prompt, images);
+                    session.promptHistory = pushPromptHistory(session.promptHistory, prompt);
+                    // A successful send consumes the pending image attachments; a thrown submit below
+                    // keeps them so the operator can resubmit with the images still attached.
+                    session.images = [];
+                    session.input = "";
+                    session.cursor = 0;
+                    session.flashMessage("added to the director's inbox");
+                }
+                catch (err) {
+                    // The queue write failed (disk full, permissions): keep the operator's text so
+                    // it can be resubmitted, and flash the reason — the same contract the GUI's
+                    // prompt form honors. Clearing the line first would silently lose the prompt,
+                    // and an unguarded throw would escape the keypress handler and kill the TUI.
+                    session.flashError(err);
+                }
+            }
+            return true;
+        }
+        return false;
+    };
+    const onArrow = (direction) => {
+        // Up/Down walk the submitted-prompt history the way readline does (tui-prompt-history.ts's
+        // recall rules). The backlog pane keeps the arrows for entry browsing (its branch
+        // above already returned), and budget, pause and search modes keep them out —
+        // recalling a prompt into the cap/field text would be a paste, not a recall. No
+        // history in this direction: fall through to applyKey, which ignores arrows as before.
+        if (!session.held.budget && !session.held.quiet && !session.held.interval && !session.held.attach && !session.held.pause && !session.held.search && !session.held.notes && !session.held.brief && !session.held.retire) {
+            const recalled = recallPromptHistory(session.promptHistory, session.input, session.cursor, direction === "up" ? "older" : "newer");
+            if (recalled) {
+                session.promptHistory = recalled.history;
+                session.input = recalled.text;
+                session.cursor = recalled.cursor;
+                return true;
+            }
+        }
+        return false;
+    };
+    const apply = (str, key) => {
+        const next = applyKey(session.input, session.cursor, str, key);
+        session.input = next.text;
+        session.cursor = next.cursor;
+    };
+    // Leave every editor (Ctrl+T): view cycling is orthogonal to them, so a cycle never strands
+    // an editor's pre-filled text in the prompt line. Each restores its own saved draft.
+    const exitAll = () => {
+        for (const editor of editors)
+            editor.exit();
+    };
+    const sync = (capUsd, budgetFree) => {
+        // Only the budget editor reads the snapshot-fed cap/free flags.
+        editors.forEach((editor) => editor.sync?.(capUsd, budgetFree));
+    };
+    return {
+        handleKey,
+        onArrow,
+        apply,
+        exitAll,
+        sync,
+        state() {
+            return {
+                input: session.input,
+                cursor: session.cursor,
+                budgetMode: session.held.budget,
+                rolePromptFor: session.held.rolePromptFor,
+                pauseEditMode: session.held.pause,
+                pauseEditRole: session.held.pauseEditRole,
+                pauseEditWake: session.held.pauseEditWake,
+                pauseEditStop: session.held.pauseEditStop,
+                queuedEditFor: session.held.queued,
+                searchMode: session.held.search,
+                answerFor: session.held.answer,
+                entryEditFor: session.held.entry,
+                attachMode: session.held.attach,
+                images: session.images.length,
+                notesEditFor: session.held.notes,
+                briefEditMode: session.held.brief,
+                retireMode: session.held.retire,
+                quietMode: session.held.quiet,
+                intervalMode: session.held.interval,
+            };
+        },
+    };
+}

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

@@ -1,54 +1,39 @@
-import { clipSpans } from "../status-render.js";
+import { alertLines, clipSpans, toneLine } from "../status-render.js";
+// Re-export the attention-banner helpers so the TUI's consumers (tui.tsx, tui-pane.ts, and
+// the tui-frame tests) keep importing them from this module; their definitions now live with
+// the other shared status renderers and the `tumwater status` banner block.
+export { alertLines, toneLine };
 import { eventResult } from "../../events/event-format.js";
+import { eventTypeLabel } from "../../events/event-labels.js";
 import { eventKind, resultTone } from "../tone.js";
+import { roleLabel } from "../../roles/role-labels.js";
 import { displayWidth } from "../../text/text-width.js";
+import { plural } from "../../text/phrases.js";
 import { stripTerminalControls } from "../../text/text.js";
-/** A plain line clipped to the pane, in one tone. */
-export function toneLine(text, width, tone) {
-    return clipSpans([{ text, ...(tone ? { tone } : {}) }], width);
-}
 /** Strip terminal control characters from every span of a composed frame — the TUI's single
  * terminal boundary, applied in tui.tsx to the whole line list (status table, attention
  * lines, queued-prompt previews, the pane body, flash/hint/input) just before ink draws it.
  * This is what closes the same gap say() closes for the CLI: model-written text (tick
  * summaries, lastError, backlog/QUESTION titles, transcript turns) reaches the terminal
- * through fleetAlerts, renderStatusSpans, and paneBody, not through say(), so sanitizing the
+ * through teamAlerts, renderStatusSpans, and paneBody, not through say(), so sanitizing the
  * final spans — rather than each producer — covers every current and future line builder. */
 export function sanitizeFrameLines(lines) {
     return lines.map((line) => line.map((span) => ({ ...span, text: stripTerminalControls(span.text) })));
 }
-const ALERT_MARKS = {
-    red: { mark: "!", tone: "red" },
-    amber: { mark: "!", tone: "yellow" },
-    indigo: { mark: "?", tone: "magenta" },
-    blue: { mark: "i", tone: "blue" },
-    gray: { mark: "i", tone: "dim" },
-};
-/** The attention lines under the header: one per alert — its mark and title in its tone, then
- * the detail — at most `max` of them, the rest counted on a last line. */
-export function alertLines(alerts, width, max = 3) {
-    const shown = alerts.length > max ? alerts.slice(0, max - 1) : alerts;
-    const lines = shown.map((a) => {
-        const { mark, tone } = ALERT_MARKS[a.tone];
-        const t = tone ? { tone } : {};
-        return clipSpans([{ text: `${mark} `, ...t }, { text: a.title, ...t }, { text: a.detail ? ` — ${a.detail}` : "" }], width);
-    });
-    if (shown.length < alerts.length)
-        lines.push(toneLine(`  +${alerts.length - shown.length} more — the dashboard lists them all`, width, "dim"));
-    return lines;
-}
 /** The pane's tab strip: every view by name, the current one bracketed (and bright), so the
  * Ctrl+T cycle can be seen rather than remembered. */
 export function tabStrip(view, width) {
     const tabs = [
-        ["activity", view.kind === "activity" && view.role ? `Activity: ${view.role}` : "Activity"],
-        ["transcript", view.kind === "transcript" ? `${view.note ? "Notebook" : view.change ? "Change" : "Transcript"}: ${view.role} (${view.index}/${view.count})` : "Transcript"],
+        ["activity", view.kind === "activity" && view.role ? `Activity: ${roleLabel(view.role)}` : "Activity"],
+        ["transcript", view.kind === "transcript" ? `${view.note ? "Notes" : view.change ? "Change" : "Transcript"}: ${roleLabel(view.role)} (${view.index}/${view.count})` : "Transcript"],
         ["backlog", "Backlog"],
         ["usage", view.kind === "usage" && view.scope ? `Usage: ${view.scope}` : "Usage"],
         ["failures", view.kind === "failures" && view.scope ? `Failures: ${view.scope}` : "Failures"],
-        ["history", view.kind === "history" ? `${view.trail ? "Tick" : "History"}${view.role ? ": " + view.role : ""}` : "History"],
+        ["history", view.kind === "history" ? `${view.trail ? "Run" : "History"}${view.role ? ": " + roleLabel(view.role) : ""}` : "History"],
         ["pending", "Pending"],
-        ["queued", "Queued"],
+        ["queued", "Inbox"],
+        ["health", "Health"],
+        ["brief", "Brief"],
     ];
     const spans = [];
     tabs.forEach(([kind, label], i) => {
@@ -65,41 +50,53 @@ export function hintLine(view, mode, width) {
     if (mode.entryEditFor?.position === null)
         keys = [["Enter", `file ${mode.entryEditFor.kind}`], ["Ctrl+N", `switch to ${mode.entryEditFor.kind === "plan" ? "bug" : "plan"}`], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
     else if (mode.entryEditFor)
-        keys = [["Enter", "save title"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
+        keys = [["Enter", "save title"], ["Ctrl+E", "body file"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
     else if (mode.answerFor)
         keys = [["Enter", "record answer"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
     else if (mode.queuedEditFor)
         keys = [["Enter", "save the edit"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
+    else if (mode.pauseEditMode && mode.pauseEditStop)
+        keys = [["Enter", "schedule stop"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
     else if (mode.pauseEditMode)
         keys = [["Enter", mode.pauseEditRole ? `${mode.pauseEditWake ? "wake" : "pause"} ${mode.pauseEditRole}` : "pause"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
-    else if (mode.deferMode)
-        keys = [["Enter", "save the delay"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
+    else if (mode.attachMode)
+        keys = [["Enter", "attach image path"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
+    else if (mode.notesEditFor)
+        keys = [["Enter", "replace notes from file"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
+    else if (mode.retireMode)
+        keys = [["Enter", "retire role"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
     else if (mode.budget)
         keys = [["Enter", "save the daily cap"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
+    else if (mode.quietMode)
+        keys = [["Enter", "save quiet hours"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
+    else if (mode.intervalMode)
+        keys = [["Enter", "save interval"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
     else if (mode.rolePromptFor)
         keys = [["Enter", `send to ${mode.rolePromptFor}`], ["↑↓", "history"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
+    else if (mode.briefEditMode)
+        keys = [["Enter", "replace brief from file"], ["Esc", "cancel"], ["Ctrl+D", "quit"]];
     else if (view.kind === "transcript") {
-        keys = [["Enter", "send"], ["↑↓", "history"], ["Ctrl+R", `prompt ${view.role}`], ["Ctrl+N", view.note ? "change" : view.change ? "transcript" : "notebook"], ...(view.note ? [["Ctrl+X", "clear notebook"]] : []), ["Ctrl+P", "pause/resume"], ["Ctrl+W", "wake"], ["Ctrl+A", "abort"],
+        keys = [["Enter", "send"], ["↑↓", "history"], ["Ctrl+R", `prompt ${view.role}`], ["Ctrl+N", view.note ? "change" : view.change ? "transcript" : "notes"], ...(view.note ? [["Ctrl+X", "clear notes"], ["Ctrl+E", "edit notes"]] : []), ["Ctrl+P", "pause/resume"], ["Ctrl+W", "wake"], ["Ctrl+A", "stop run"], ["Ctrl+V", "reset counters"], ["Ctrl+B", "daily cap"], ["Ctrl+O", "quiet hours"],
             ["Ctrl+T", "next view"], ["Ctrl+D", "quit"]];
     }
     else if (view.kind === "backlog")
-        keys = [["Enter", "send"], ["↑↓", "open entries"], ["Ctrl+X", "cancel entry"], ["Ctrl+E", "edit entry"], ["Ctrl+N", "new plan/bug"], ["Ctrl+A", "answer question"], ["PgUp/PgDn", "scroll"], ["Ctrl+T", "next view"], ["Ctrl+D", "quit"]];
+        keys = [["Enter", "send"], ["↑↓", "open entries"], ["Ctrl+X", "cancel entry"], ["Ctrl+R", "release entry"], ["Ctrl+V", "top entry"], ["Ctrl+E", "edit entry"], ["Ctrl+N", "new plan/bug"], ["Ctrl+A", "answer question"], ["PgUp/PgDn", "scroll"], ["Ctrl+T", "next view"], ["Ctrl+D", "quit"]];
     else if (view.kind === "usage" || view.kind === "failures")
-        keys = [["Enter", "send"], ["↑↓", "history"], ["PgUp/PgDn", "scroll"], ["Ctrl+G", view.scope ? `scope: ${view.scope}` : "scope: fleet"], ["Ctrl+E", view.window ? `window: ${view.window}` : "window: default"], ["Ctrl+T", "next view"], ["Ctrl+D", "quit"]];
+        keys = [["Enter", "send"], ["↑↓", "history"], ["PgUp/PgDn", "scroll"], ["Ctrl+G", view.scope ? `scope: ${view.scope}` : "scope: team"], ["Ctrl+E", view.window ? `window: ${view.window}` : "window: default"], ["Ctrl+T", "next view"], ["Ctrl+D", "quit"]];
     else if (view.kind === "history")
-        keys = [["Enter", "send"], ["↑↓", "history"], ["PgUp/PgDn", "scroll"], ["Ctrl+G", view.role ? `scope: ${view.role}` : "scope: fleet"], ["Ctrl+S", view.since ? `window: ${view.since}` : "window: default"], ["Ctrl+O", view.result ? `result: ${view.result}` : "result: all"], ["Ctrl+N", view.trail ? "history" : "tick trail"], ["/", view.grep ? `search: ${view.grep}` : "search"], ["Ctrl+T", "next view"], ["Ctrl+D", "quit"]];
+        keys = [["Enter", "send"], ["↑↓", "history"], ["PgUp/PgDn", "scroll"], ["Ctrl+G", view.role ? `scope: ${view.role}` : "scope: team"], ["Ctrl+S", view.since ? `window: ${view.since}` : "window: default"], ["Ctrl+O", view.result ? `result: ${view.result}` : "result: all"], ["Ctrl+Y", view.summary ? "rows" : "summary"], ["Ctrl+N", view.trail ? "history" : "run trail"], ["/", view.grep ? `search: ${view.grep}` : "search"], ["Ctrl+T", "next view"], ["Ctrl+D", "quit"]];
     else if (view.kind === "pending")
-        keys = [["Enter", "send"], ["↑↓", "history"], ["PgUp/PgDn", "scroll"], ["Ctrl+T", "next view"], ["Ctrl+D", "quit"]];
+        keys = [["Enter", "send"], ["↑↓", "history"], ["PgUp/PgDn", "scroll"], ["Ctrl+R", "refresh"], ["Ctrl+T", "next view"], ["Ctrl+D", "quit"]];
+    else if (view.kind === "health")
+        keys = [["Enter", "send"], ["↑↓", "history"], ["PgUp/PgDn", "scroll"], ["Ctrl+O", view.problems ? "problems only" : "all checks"], ["Ctrl+R", "re-run checks"], ["Ctrl+E", "reclaim disk"], ["Ctrl+N", "test notify"], ["Ctrl+X", "retire role"], ["Ctrl+T", "next view"], ["Ctrl+D", "quit"]];
+    else if (view.kind === "brief")
+        keys = [["Enter", "send"], ["↑↓", "history"], ["PgUp/PgDn", "scroll"], ["Ctrl+E", "edit brief"], ["Ctrl+T", "next view"], ["Ctrl+D", "quit"]];
     else if (view.kind === "queued")
-        keys = [["Enter", "send"], ["↑↓", "history"], ["Ctrl+E", "edit"], ["Ctrl+X", "cancel"], ["PgUp/PgDn", "scroll"], ["Ctrl+T", "next view"], ["Ctrl+D", "quit"]];
+        keys = [["Enter", "send"], ["↑↓", "history"], ["Ctrl+V", "top"], ["Ctrl+E", "edit"], ["Ctrl+X", "cancel"], ["PgUp/PgDn", "scroll"], ["Ctrl+T", "next view"], ["Ctrl+D", "quit"]];
     else
-        keys = [["Enter", "send"], ["↑↓", "history"], ["PgUp/PgDn", "scroll"], ["Ctrl+B", "daily cap"], ["Ctrl+G", view.role ? `scope: ${view.role}` : "scope: fleet"], ["/", view.grep ? `search: ${view.grep}` : "search"], ["Ctrl+T", "next view"], ["Ctrl+F", "pause fleet"], ["Ctrl+C", "interrupt director"], ["Ctrl+D", "quit"]];
-    // The defer editor is the prompt line's fourth meta-editor (after budget, role, and
-    // search), so every view whose hint is about sending names its state: the pending delay
-    // when one is set, otherwise the way to open it. The mode branches above already name
-    // their own keys and keep the line, so this only rides the view hints.
-    if (!mode.deferMode && !mode.pauseEditMode && !mode.budget && !mode.rolePromptFor && !mode.queuedEditFor && !mode.answerFor && !mode.entryEditFor)
-        keys.push(["Ctrl+L", mode.defer ? `defer: ${mode.defer}` : "defer"]);
+        keys = [["Enter", "send"], ["↑↓", "history"], ["PgUp/PgDn", "scroll"], ["Ctrl+B", "daily cap"], ["Ctrl+O", view.type ? `type: ${eventTypeLabel(view.type)}` : "type: all"], ["Ctrl+G", view.role ? `scope: ${view.role}` : "scope: team"], ["/", view.grep ? `search: ${view.grep}` : "search"], ["Ctrl+T", "next view"], ["Ctrl+F", "pause team"], ["Ctrl+Q", "stop later"], ["Ctrl+C", "interrupt director"], ["Ctrl+V", "attach image"], ["Ctrl+R", "restart"], ["Ctrl+D", "quit"]];
+    // The mode branches above name their own keys and keep the line, so every remaining
+    // view hint always shows the send affordance. This comment marks that ordering.
     const spans = [];
     keys.forEach(([key, what], i) => {
         if (i > 0)
@@ -112,37 +109,52 @@ export function hintLine(view, mode, width) {
 export function promptPrefix(mode) {
     if (mode.budget)
         return [{ text: "daily cap $", tone: "brand" }, { text: " " }];
+    if (mode.quietMode)
+        return [{ text: "quiet hours", tone: "brand" }, { text: " › " }];
+    if (mode.intervalMode)
+        return [{ text: "min run interval", tone: "brand" }, { text: " › " }];
+    if (mode.briefEditMode)
+        return [{ text: "brief", tone: "brand" }, { text: " › " }];
+    if (mode.retireMode)
+        return [{ text: "retire", tone: "brand" }, { text: " › " }];
+    if (mode.notesEditFor)
+        return [{ text: `notes for ${mode.notesEditFor}`, tone: "brand" }, { text: " › " }];
     if (mode.entryEditFor)
         return [{ text: mode.entryEditFor.position === null ? `new ${mode.entryEditFor.kind}` : `edit ${mode.entryEditFor.kind} #${mode.entryEditFor.position}`, tone: "brand" }, { text: " › " }];
     if (mode.answerFor)
         return [{ text: `answer #${mode.answerFor.position}`, tone: "brand" }, { text: " › " }];
     if (mode.queuedEditFor)
         return [{ text: `edit ${mode.queuedEditFor.role}`, tone: "brand" }, { text: " › " }];
+    if (mode.pauseEditMode && mode.pauseEditStop)
+        return [{ text: "stop in", tone: "brand" }, { text: " › " }];
     if (mode.pauseEditMode)
         return [{ text: mode.pauseEditRole ? `${mode.pauseEditWake ? "wake" : "pause"} ${mode.pauseEditRole}` : "pause", tone: "brand" }, { text: " › " }];
-    if (mode.deferMode)
-        return [{ text: "defer", tone: "brand" }, { text: " › " }];
-    // A pending delay is named beside the target (e.g. `director (defer 45m) › `), so the
-    // operator sees what the next Enter will schedule before pressing it.
-    const target = mode.defer ? `${mode.rolePromptFor ?? "director"} (defer ${mode.defer})` : (mode.rolePromptFor ?? "director");
-    return [{ text: target, tone: "brand" }, { text: " › " }];
+    // The pending image count (e.g. `director (2 images) › `) is named beside the target, so
+    // the user sees what the next Enter will send before pressing it. The image count names the
+    // director prompt only: session.images ride into the next director submit (submitPrompt),
+    // while a role prompt (submitRolePromptAndWake) passes images undefined, so the count must
+    // not claim an attachment a role-targeted Enter won't send.
+    const target = mode.rolePromptFor ?? "director";
+    const withImages = mode.rolePromptFor === null && (mode.images ?? 0) > 0;
+    const named = withImages ? `${target} (${plural(mode.images ?? 0, "image")})` : target;
+    return [{ text: named, tone: "brand" }, { text: " › " }];
 }
 /** The prefix's width in terminal columns, for sizing the input beside it. */
 export function prefixWidth(prefix) {
     return displayWidth(prefix.map((sp) => sp.text).join(""));
 }
 /** An activity line's tone, by the event's kind (tone.ts's eventKind — the dashboard's
- * activity card uses the same rule): landings green, problems in their outcome's color,
+ * activity card uses the same rule): merges green, problems in their outcome's color,
  * questions magenta, routine bookkeeping dim. */
 export function eventTone(e) {
     const result = eventResult(e);
     const kind = eventKind(e.type, result);
     if (kind === "landing")
-        return "green";
+        return "green"; // vocabulary-ok: event kind code
     if (kind === "attention")
         return "magenta";
     if (kind === "problem")
-        return (e.type === "tick_end" ? resultTone(result) : undefined) ?? "red";
+        return (e.type === "run_end" ? resultTone(result) : undefined) ?? "red";
     if (kind === "routine")
         return "dim";
     return undefined;

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

@@ -1,3 +1,4 @@
+// vocabulary: plain
 /** The TUI's History pane body: the completed-tick rows `tumwater history` prints (and the
  * dashboard's History view renders), one line each, newest first. history-data.ts already
  * builds the rows (`readTickRows`); this only renders them for the pane, so the TUI, the CLI,
@@ -6,19 +7,23 @@
  * rows and their fields, not the CLI table's padding. Pure: a function of the rows it is
  * handed. */
 import { tickRowCells } from "../../history/history-data.js";
-/** The pane body for a set of tick rows: `time  loop #tick  result  duration`, then `usage`
- * and `detail` when they carry anything, joined newest-first by newlines. The cells come from
- * history-data.ts's tickRowCells, the one home the CLI's table builds on too, so a null
- * `durationMs` (the tick's start sits outside the scanned window) shows the em dash here the
- * same way; an empty `usage` (neither tokens nor cost) and an empty
+/** The pane body for a set of tick rows: `time  loop #tick  result  duration`, then `model`
+ * (between the result and the duration), and `usage` and `detail` when they carry anything,
+ * joined newest-first by newlines. The cells come from history-data.ts's tickRowCells, the one
+ * home the CLI's table builds on too, so a null `durationMs` (the tick's start sits outside
+ * the scanned window) shows the em dash here the same way; an empty `model` (the start named
+ * none or sat outside the window), an empty `usage` (neither tokens nor cost), and an empty
  * `detail` are omitted rather than leaving a gap. No rows renders `""`, which the pane's
  * `emptyNote` replaces. `row.result` is the string history-data.ts resolved (including a
- * joined landing verdict), never reclassified here. */
+ * joined merge verdict), never reclassified here. */
 export function historyPaneText(rows) {
     return rows
         .map((row) => {
         const { duration } = tickRowCells(row);
-        const parts = [row.time, `${row.loop} #${row.tick}`, row.result, duration];
+        const parts = [row.time, `${row.role} #${row.run}`, row.result];
+        if (row.model)
+            parts.push(row.model);
+        parts.push(duration);
         if (row.usage)
             parts.push(row.usage);
         if (row.detail)