tumwater 0.1.2 → 0.2.0

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

@@ -1,238 +1,41 @@
-import { collectReport, collectReportSince } from "../../report/report-data.js";
-import { renderReportMarkdown, renderSinceReportMarkdown } from "../../report/report-render.js";
-import { REPORT_DEFAULT_DAYS, REPORT_SINCE_MAX_MS, SPARSE_WINDOW_NOTE } from "../../events/event-window.js";
-import { collectFailureReport, collectFailureReportSince } from "../../failure/failure-data.js";
-import { renderFailureMarkdown } from "../../failure/failure-render.js";
-import { HISTORY_DEFAULT_TICKS, HISTORY_RESULT_CLASSES, historyClass, readTickRows, readTickRowsSince, tickRowsMatchingGrep, } from "../../history/history-data.js";
-import { historyPaneText } from "./tui-history.js";
-import { readTickDetail } from "../../tick/tick-detail-data.js";
-import { renderTickDetail } from "../../tick/tick-detail.js";
-import { collectFleetChanges, collectRoleChange } from "../../change/change-data.js";
-import { renderFleetChange, renderRoleChange } from "../../change/change-render.js";
-import { readLandingQueue } from "../../landing/landing-queue.js";
-import { renderLandingQueue } from "../../landing/landing-queue-render.js";
-import { promptLengthProblem, submitPrompt } from "../../inbox/inbox-submit.js";
-import { listWideScope, queuedListRows, renderQueuedList } from "../../inbox/inbox.js";
-import { fileEntryWithBody, OPERATOR_FILE_KINDS, tryCancelEntry, tryEditEntry } from "../../backlog/backlog-write.js";
-import { stripEntryStamp } from "../../backlog/backlog-structure.js";
-import { cancelRolePrompt } from "../../inbox/inbox-cancel.js";
-import { durationLabel } from "../../cli/cli-args.js";
-import { tryAnswerQuestion, UNCLOSED_FENCE_MESSAGE } from "../../cli/question-commands.js";
-import { editQueuedFile, readQueuedPromptBody } from "../../inbox/inbox-edit.js";
-import { setDailyBudgetUsd } from "../../config/config-write.js";
-import { isFleetPaused, pausedRoles, pauseFleet, pauseRole, resumeFleet, resumeRole, } from "../../fleet/fleet-state.js";
-import { requestAbort, requestWake, cancelWakes, rolePauseMessage, roleResumeMessage, submitRolePromptAndWake, } from "../../operator/operator-intent.js";
-import { collapseWhitespace, errorMessage } from "../../text/text.js";
-import { saveRoleNote } from "../../agent/role-notes-write.js";
-import { roleNotesPath } from "../../paths.js";
-import { fleetPausePhrase, fleetResumePhrase } from "../../text/phrases.js";
-import { usdCap } from "../../text/format.js";
+import { tickDetailStat } from "../../tick/tick-detail.js";
+import { collectTeamChanges, collectRoleChange } from "../../change/change-data.js";
+import { runDoctor } from "../../doctor/doctor.js";
+import { commitOperatorBacklogEdit } from "../../backlog/backlog-commit.js";
+import { stampedSubject } from "../../git/commit-message.js";
+import { requestAbort } from "../../operator/operator-intent.js";
+import { errorMessage } from "../../text/text.js";
 import { DIRECTOR_ROLE } from "../../roles/roles.js";
-import { baseRoleOf } from "../../roles/loop-ids.js";
-import { applyKey, parseBudgetInput, parseDeferInput, parsePauseInput, parseRolePauseInput, parseRoleWakeInput, parseRolePromptInput, } from "./tui-input.js";
-import { newPromptHistory, pushPromptHistory, recallPromptHistory, resetPromptRecall, settlePromptRecall, } from "./tui-prompt-history.js";
-import { labeledBacklogEntries, moveEntrySelection, stepEntryScroll } from "./tui-backlog.js";
-import { activityEvents, roleInspectMarkdown } from "./tui-pane.js";
-import { arrowDir, pageDir } from "./tui-keymap.js";
+import { browsableBacklogEntries } from "./tui-backlog.js";
+import { arrowDir } from "./tui-keymap.js";
+import { createTuiEditors } from "./tui-editors.js";
+import { createTuiPanes } from "./tui-panes.js";
 /** How long a TUI flash notice stays visible (ms). */
 const FLASH_MS = 3000;
-/** Every Ctrl+<key> cycle walks its own ReadonlyArray<[key, label]> table one slot at a time,
- * wrapping past the last back to the first. Each handler holds a key the table carries (a null
- * default slot included), so findIndex always hits. The null fallback in cycleLabel keeps a
- * would-be stale key from rendering "undefined". */
-function nextInCycle(table, current) {
-    const i = table.findIndex(([key]) => key === current);
-    return table[(i + 1) % table.length][0];
-}
-function cycleLabel(table, current) {
-    return table.find(([key]) => key === current)?.[1] ?? null;
-}
-/** The History pane's session window cycle, Ctrl+S: the default newest-N read, then the same
- * trailing windows the dashboard's History view and `tumwater history --since` offer — 1h,
- * 6h, 1d, and the 7d cap the CLI's flag and the dashboard both stop at. The label is what the
- * hint line names; the length is what readTickRowsSince takes. `null` is the default read
- * through readTickRows, kept first so the pane opens on today's behavior. */
-const HISTORY_WINDOWS = [
-    [null, "default"],
-    [3_600_000, "1h"],
-    [21_600_000, "6h"],
-    [86_400_000, "1d"],
-    [604_800_000, "7d"],
-];
-/** The Ctrl+G scope cycle: fleet-wide (null), then each unique base role the roster names, in
- * roster order. An instance id (`feature-2`) folds into its base role because the scoped
- * collectors aggregate by base role — report-data.ts's role scope groups an instance's usage
- * with its siblings' — so cycling through the instance ids would relabel the same body with
- * names that collect it identically. `feature`/`feature-2` therefore offer one slot, and the
- * name the tab strip and hint show is the name the collector honors. */
-function scopeCycle(roleIds) {
-    const bases = [];
-    for (const id of roleIds) {
-        const base = baseRoleOf(id);
-        if (!bases.includes(base))
-            bases.push(base);
-    }
-    return [null, ...bases];
-}
-/** The History pane's session outcome cycle, Ctrl+O: all ticks, then the canonical classes
- * `tumwater history --result` and the dashboard's History filter speak. The class list comes
- * from history-data.ts (HISTORY_RESULT_CLASSES) rather than a copy, so the TUI, the CLI, and
- * the dashboard bucket a result the same way; the class id doubles as the label. `null` is no
- * filter, kept first so the pane opens on today's behavior. */
-const HISTORY_RESULTS = [
-    [null, "all"],
-    ...HISTORY_RESULT_CLASSES.map((c) => [c, c]),
-];
-/** The History pane's body for one trailing window, one outcome class, one exact-loop scope,
- * and one free-text search: the paneCache the Ctrl+T/Ctrl+S/Ctrl+O/Ctrl+G/`/` handlers store.
- * The default (null/null/null/null) read is byte-for-byte the newest-N pane that predates the
- * window, outcome, loop, and search cycles — readTickRows with HISTORY_DEFAULT_TICKS,
- * unfiltered. A trailing window reads through the same readTickRowsSince collector `tumwater
- * history --since` uses, a class filters through history-data.ts's canonical historyClass rule,
- * and the search filters through tickRowGrepHaystack — the same haystack and case-insensitive
- * substring rule `tumwater history --grep` and the dashboard's History search use — so the TUI,
- * the CLI, and the dashboard cannot disagree about the rows. The role is the exact loop id the
- * raw roster (and `history --role`, and the dashboard picker) names — readTickRows filters
- * `e.loop === role`, so an instance id is its own scope, never folded into a base role. An empty
- * read with no class and no search returns "" so the pane keeps its own no-ticks note instead of
- * a lone header; when a class or a search is active and the read returned rows, an empty
- * filtered body names whichever filter the CLI's precedence blames, so the pane states the
- * filter instead of claiming the log is empty. Otherwise the body is prefixed with the active
- * role/window/result/search labels and, when the read cannot prove full coverage, the same
- * sparse-window note every windowed render prints (SPARSE_WINDOW_NOTE). */
-function historyPaneCache(root, sinceMs, resultClass, role, grep) {
-    const { rows, covered } = sinceMs === null
-        ? { rows: readTickRows(root, HISTORY_DEFAULT_TICKS, role), covered: true }
-        : readTickRowsSince(root, sinceMs, role);
-    // The search runs first, exactly as `tumwater history` orders --grep ahead of --result, and
-    // its admitted count is saved so the empty-body wording blames the filter that actually
-    // emptied the set (`afterGrep > 0` means rows matched the pattern and the class then removed
-    // them). The search applies history-data.ts's shared tick-grep rule (tickRowsMatchingGrep),
-    // the same one the CLI and the dashboard search use, so the three surfaces cannot disagree.
-    const grepped = grep === null ? rows : tickRowsMatchingGrep(rows, grep);
-    const afterGrep = grepped.length;
-    const filtered = resultClass === null ? grepped : grepped.filter((r) => historyClass(r.result) === resultClass);
-    const body = historyPaneText(filtered);
-    // null when no class is active, so the header/empty-body paths below only name a result
-    // filter the session actually holds (cycleLabel(HISTORY_RESULTS, null) is the "all" label).
-    const resultLabel = resultClass === null ? null : cycleLabel(HISTORY_RESULTS, resultClass);
-    // The role first, then the window/result/search labels: the loop is the coarsest cut, and a
-    // role-only read (no window, no class) still prints its scope line above the rows.
-    const header = [
-        ...(role === null ? [] : ["role: " + role]),
-        ...(sinceMs === null ? [] : ["window: last " + (cycleLabel(HISTORY_WINDOWS, sinceMs) ?? "default")]),
-        ...(resultLabel === null ? [] : ["result: " + resultLabel]),
-        ...(grep === null ? [] : ["search: " + grep]),
-    ].join("\n");
-    if (!body) {
-        // The class names itself only when it emptied a set grep admitted (`afterGrep > 0`) — the
-        // CLI's condition and the dashboard's `hasRows` draw the same line — so an empty log or
-        // window keeps the pane's own no-ticks note instead of blaming a filter that removed
-        // nothing. A pattern that admitted nothing names itself next, with the CLI's wording. An
-        // empty read with neither filter returns "" so the pane keeps its own note, and a role-only
-        // empty read returns "" too (the CLI's empty-state wording does not name --role), so the
-        // pane never grows a lone `role:` header.
-        if (resultClass !== null && afterGrep > 0) {
-            return header + "\nno ticks with result \"" + resultLabel + "\"";
-        }
-        if (grep !== null)
-            return header + "\nno ticks matching \"" + grep + "\"";
-        return "";
-    }
-    return (header ? header + "\n" : "") + body + (sinceMs !== null && !covered ? "\n" + SPARSE_WINDOW_NOTE : "");
-}
-/** The Usage and Failures panes' session window cycle, Ctrl+E: the default whole-day report,
- * then 1h, 6h, 1d, and the REPORT_SINCE_MAX_MS 7d cap — the trailing windows
- * `tumwater report --since` / `tumwater report --failures --since` collect. (The dashboard's
- * report tabs stop at 1d.) The label is what the hint line names; the
- * length is what collectReportSince / collectFailureReportSince take. `null` is the default
- * REPORT_DEFAULT_DAYS shape, kept first so the panes open on today's behavior. */
-const REPORT_WINDOWS = [
-    [null, "default"],
-    [3_600_000, "1h"],
-    [21_600_000, "6h"],
-    [86_400_000, "1d"],
-    [REPORT_SINCE_MAX_MS, "7d"],
-];
-/** The Usage pane's body for one window and role scope: the paneCache the Ctrl+T/Ctrl+G/Ctrl+E
- * handlers store. The default (null) read is byte-for-byte the day report the pane showed
- * before the window cycle — collectReport at REPORT_DEFAULT_DAYS; a trailing window reads
- * through the same collectReportSince collector `tumwater report --since` uses, so the TUI,
- * CLI, and dashboard cannot disagree. Both honor the Ctrl+G role scope, so the two session
- * cycles compose. */
-function usagePaneCache(root, sinceMs, scope) {
-    if (sinceMs === null)
-        return renderReportMarkdown(collectReport(root, REPORT_DEFAULT_DAYS, scope));
-    return renderSinceReportMarkdown(collectReportSince(root, sinceMs, scope));
-}
-/** The Failures pane's body for one window and role scope, the digest sibling of
- * usagePaneCache; renderFailureMarkdown renders both the day and --since shapes. */
-function failuresPaneCache(root, sinceMs, scope) {
-    if (sinceMs === null)
-        return renderFailureMarkdown(collectFailureReport(root, REPORT_DEFAULT_DAYS, scope));
-    return renderFailureMarkdown(collectFailureReportSince(root, sinceMs, scope));
-}
 /** The framework-free owner of the TUI's keypress handling (extracted from runTui, and fed
  * by ink's `useInput` through tui-keymap.ts's inkKeyToReadline adapter): the factory owns
- * every mutable local the keypress dispatch used to keep in runTui's closure — the prompt line,
- * budget-edit and role-prompt modes, the session history, the flash notice, the
- * view/selection/scroll state, and the line budgets render feeds back. It takes only the
- * seams it cannot own itself: the repo root the disk actions run against, the quit callback
- * (Ctrl+D), a render request callback (every branch that painted a frame), and an injectable clock
- * so the flash expiry is testable without waiting the real 3 s. Rendering (src/ui/tui/tui.tsx)
- * stays the caller: it syncs snapshot data and line budgets in, and reads the resulting state
- * out to compose the frame — the same data flow, one module boundary added. */
+ * every mutable local the keypress dispatch used to keep in runTui's closure — the prompt line
+ * and its modal editors (owned by the tui-editors.ts sub-factory it constructs), the view and
+ * pane-navigation state, the flash notice, and the line budgets render feeds back. It takes
+ * only the seams it cannot own itself: the repo root the disk actions run against, the quit
+ * callback (Ctrl+D), a render request callback (every branch that painted a frame), and an
+ * injectable clock so the flash expiry is testable without waiting the real 3 s. Rendering
+ * (src/ui/tui/tui.tsx) stays the caller: it syncs snapshot data and line budgets in, and reads
+ * the resulting state out to compose the frame — the same data flow, one module boundary added.
+ * The prompt-line editor half of this closure lives in tui-editors.ts and the pane-navigation
+ * half in the tui-panes.ts factory beside its per-pane modules; this file keeps the outer
+ * dispatch, the flash notice, and the director gate. */
 export function createTuiKeys(deps) {
     const now = deps.now ?? Date.now;
     const { root } = deps;
-    const collectPending = deps.collectPending ?? collectFleetChanges;
+    const collectPending = deps.collectPending ?? collectTeamChanges;
+    const runDoctorSeam = deps.runDoctor ?? ((r) => runDoctor(r, undefined, undefined, "never"));
     const collectChange = deps.collectChange ?? collectRoleChange;
-    // The project-status pane's flat entry list (plans, then bugs, then questions), read fresh —
-    // tui-backlog.ts's one definition, shared with the render so stale-selection clamping cannot
-    // drift.
-    const flat = () => labeledBacklogEntries(root);
-    let input = "";
-    let cursor = 0;
-    // Ctrl+B budget-edit mode on the prompt line: while set, the line edits the daily cost cap
-    // (pre-filled with the current cap — empty when disabled) instead of a director prompt.
-    // The previous prompt text is saved so leaving the mode restores it byte-for-byte.
-    let budgetMode = false;
-    let savedInput = "";
-    let savedCursor = 0;
-    // Ctrl+R role-prompt mode on the prompt line: while set (to the viewed loop's role id), the
-    // line edits a prompt for that one loop instead of a director prompt. It keeps its OWN saved
-    // pair, separate from budget mode's: the two modes are mutually exclusive (each refuses to
-    // open while the other holds the line), and with separate pairs neither can clobber the
-    // other's saved draft even if a guard is ever loosened.
-    let rolePromptFor = null;
-    let roleSavedInput = "";
-    let roleSavedCursor = 0;
-    // Ctrl+L defer mode on the prompt line: while set, the line edits a duration that rides
-    // into the next delivered prompt as the same `tumwater:not-before` marker `tumwater prompt
-    // --at` and the dashboard composer write. deferMs is a DURATION, not an epoch: submit
-    // computes now() + deferMs, so a prompt queued later still defers by the full span. It is
-    // session-only and one-shot: a successful submit or an empty line clears it. Its own saved
-    // pair, mutually exclusive with the budget/role/search editors on the one prompt line.
-    let deferMs = null;
-    let deferMode = false;
-    let deferSavedInput = "";
-    let deferSavedCursor = 0;
-    let pauseEditMode = false;
-    let pauseEditRole = null;
-    let pauseEditWake = false;
-    let pauseSavedInput = "";
-    let pauseSavedCursor = 0;
-    // The prompt line's session history (tui-prompt-history.ts's rules): every successfully submitted
-    // prompt — director and per-role alike — joins it, and Up/Down walk it the way readline
-    // does. Not persisted: a TUI session starts blank, like a fresh shell.
-    let promptHistory = newPromptHistory();
-    // The last snapshot's cap, captured by render so the Ctrl+B handler can pre-fill without
-    // re-reading config itself (render already polls snapshot every second).
-    let currentCapUsd = 0;
-    // The last snapshot's free flag: true when every model the fleet could use is unpriced,
-    // so a cap could never bind — the Ctrl+B handler flashes a notice instead of opening
-    // the editor (BUGS.md 2026-09-14), leaving the prompt line untouched.
-    let currentBudgetFree = false;
+    const tickStat = deps.tickStat ?? tickDetailStat;
+    // The project-status pane's flat entry list (plans, bugs, questions, then the newest done plans
+    // and fixed bugs), read fresh — tui-backlog.ts's one definition, shared with the render so
+    // stale-selection clamping cannot drift.
+    const flat = () => browsableBacklogEntries(root);
     let flash = "";
     let flashUntil = 0;
     // Flash a one-line notice on the prompt line: the single owner of the message+expiry
@@ -247,277 +50,53 @@ export function createTuiKeys(deps) {
     const flashError = (err) => {
         flashMessage(`error: ${errorMessage(err)}`);
     };
-    // The activity pane cycles: 0 = recent events, then one transcript per loop, then project
-    // status (planned features + open bugs + open questions), then the usage report, the failure
-    // digest, the completed-tick history, the pending-change roster, and the queued prompts —
-    // Ctrl+T.
-    let view = 0;
-    // The session-scoped role the Usage and Failures panes collect for, cycled by Ctrl+G, null
-    // for the fleet. Session-only, like the view/selection/scroll state: a fresh TUI starts
-    // fleet-wide, and syncSnapshot clears it when the roster drops the role.
-    let scopeRole = null;
-    // The project-status pane's entry selection (null = list mode): the flat index of the
-    // entry shown in full — plans first, then bugs, then questions. Cleared on every Ctrl+T,
-    // so cycling back into the view always starts at today's heading list.
-    let selectedEntry = null;
-    /** The role whose notebook a second Ctrl+X would clear, null once any other key lands. */
-    let notesClearArmed = null;
-    let cancelArmed = null;
-    // The Queued pane's row selection (null = list mode): the index into queuedRows of the
-    // prompt shown in full. Cleared on every Ctrl+T, like selectedEntry, so cycling back into
-    // the pane starts at today's list.
-    let selectedQueued = null;
-    // The Queued pane's cached rows, the same queuedListRows traversal the cached
-    // renderQueuedList string was built from, so a selection addresses a row's role/position
-    // without re-reading the queue on every frame.
-    let queuedRows = [];
-    // The Queued pane's in-place editor (Ctrl+E): the role and queue-file basename of the row
-    // the prompt line is rewriting, with its own saved-draft pair exactly like the budget and
-    // role-prompt editors. All four editors share the one prompt line and are mutually
-    // exclusive, so no editor can clobber another's saved draft.
-    let queuedEditFor = null;
-    let queuedSavedInput = "";
-    let queuedSavedCursor = 0;
-    let answerFor = null;
-    let answerSavedInput = "";
-    let answerSavedCursor = 0;
-    let entryEditFor = null;
-    let entryEditSavedInput = "";
-    let entryEditSavedCursor = 0;
-    // The within-body scroll offset (line index of the window head, 0 = head) for the selected
-    // entry's body — PgDn/PgUp in project-status entry mode. Reset whenever the selection
-    // changes or clears, so every newly opened entry starts at its head.
-    let entryScroll = 0;
-    // The Markdown/row panes' (usage report, failures, history) rendered bodies, computed once
-    // per activation: the Ctrl+T handler sets it when cycling into one and nulls it on leaving.
-    // collectReport/collectFailureReport tail-scan events.jsonl and readTickRows reads the log,
-    // so they must not run on every second's re-render — those only re-window this string.
-    let paneCache = null;
-    // Ctrl+N toggles the viewed loop's pane between its live transcript and a read-only
-    // notebook view (its note and next tick's prompt). Like paneCache, noteCache is computed
-    // once on entry and only re-windowed each frame; both reset when the mode changes or the
-    // view cycles.
-    let noteMode = false;
-    let noteCache = null;
-    // Ctrl+N on the History pane swaps the row list for the newest completed tick's full event
-    // trail (renderTickDetail over readTickDetail) — the same text `tumwater tick --last` and
-    // the dashboard's History drill-down serve. Session-only like the other pane snapshots:
-    // computed once on entry and only re-windowed each frame.
-    let trailMode = false;
-    let trailCache = null;
-    // Ctrl+N's third step: the viewed loop's collected unlanded change (the CLI's
-    // `renderRoleChange` text). changeCache is null until the async collector resolves, and the
-    // pane paints a loading note meanwhile; both reset on leaving the mode or cycling the view.
-    let changeMode = false;
-    let changeCache = null;
-    // The within-body scroll offset (line index of the window head) shared by the two Markdown
-    // panes and the notebook view — PgDn/PgUp there. Reset to the head whenever the view is
-    // entered, like entryScroll.
-    let paneScroll = 0;
-    // The Activity pane's body-window start into the loaded event tail, or null to follow the
-    // live tail (the newest eventBudget events). PgUp pauses follow and pages back; PgDn returns
-    // toward the tail and re-enables follow at the bottom. Reset on every Ctrl+T view cycle, so
-    // re-entering Activity always starts at the live tail.
-    let activityScroll = null;
-    // The Activity pane's session exact-loop scope (Ctrl+G), a raw roster id or null for the
-    // fleet's full tail. Session-only like the view/scroll state; syncSnapshot clears it when the
-    // roster drops the id. The raw ids, not scopeCycle's base roles: the feed filters by exact
-    // loop (eventRole), so `feature-2` is its own slot.
-    let activityRole = null;
-    // The Activity pane's session free-text search (the `/` prompt-line editor), a
-    // case-insensitive substring over eventMatchesGrep's type-prefixed rendered line — the same
-    // rule `tumwater logs --grep` and the dashboard search use. null is no search; session-only
-    // like the scope, so the next read computes with it.
-    let activityGrep = null;
-    // The History pane's session trailing window (Ctrl+S), a HISTORY_WINDOWS length or null for
-    // the default newest-N read. Session-only like the view/scroll state; the next Ctrl+T into
-    // History computes the cache with it.
-    let historyWindow = null;
-    // The Usage and Failures panes' session trailing window (Ctrl+E), a REPORT_WINDOWS length or
-    // null for the default day report. Session-only like the view/scroll state; the next Ctrl+T
-    // into either pane computes the cache with it.
-    let reportWindow = null;
-    // The History pane's session outcome filter (Ctrl+O), a HISTORY_RESULTS class or null for no
-    // filter. Session-only like the window; the next Ctrl+T into History computes with it.
-    let historyResult = null;
-    // The History pane's session exact-loop scope (Ctrl+G), a raw roster id or null for the
-    // fleet's full read. Session-only like the window/result; syncSnapshot clears it when the
-    // roster drops the id. The raw ids, not scopeCycle's base roles: History filters by exact
-    // loop (`history --role`), so `feature-2` is its own slot.
-    let historyRole = null;
-    // The History pane's session free-text search (the `/` prompt-line editor), a
-    // case-insensitive substring over history-data.ts's tickRowGrepHaystack — the same rule
-    // `tumwater history --grep` and the dashboard search use. null is no search; session-only
-    // like the window/result/role, so the next Ctrl+T into History computes the cache with it.
-    let historyGrep = null;
-    // The History search editor on the prompt line: `/` enters it (only on History with an empty
-    // line), pre-filling the applied pattern; Enter applies it, Esc restores the draft. Its own
-    // saved-draft pair, exactly like the budget and role-prompt editors: the three share one
-    // prompt line and are mutually exclusive, so no editor can clobber another's saved draft.
-    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;
-    // The activity pane's current line budget, refreshed by every render so keypress handlers
-    // can page within it without re-deriving the height math. An open backlog entry spends the
-    // pane's first line on its title, so its body pages by one line less (entryBudget).
-    let eventBudget = 0;
-    let entryBudget = 0;
-    let roleIds = [];
+    // Commit an operator's backlog edit to main and flash when the commit did not land: the
+    // one home for the "written but NOT committed" warning every edit, file, cancel, and
+    // answer arm shares.
+    const commitBacklogEdit = (file, subject) => {
+        void commitOperatorBacklogEdit(root, file, stampedSubject("operator", subject)).then((committed) => {
+            if (!committed)
+                flashMessage(`${file} written but NOT committed to main — commit it before the next fast-forward`);
+        });
+    };
+    // The pane-navigation state is constructed first because the prompt-line editors take its
+    // leaves (the queued refresh, the selection clear, the applied searches).
+    const panes = createTuiPanes({
+        root,
+        now,
+        requestRender: deps.requestRender,
+        flat,
+        flashMessage,
+        flashError,
+        commitBacklogEdit,
+        collectPending,
+        runDoctor: runDoctorSeam,
+        collectChange,
+        tickStat,
+    });
     // Whether the director's status row is in flight, fed by render each frame: the gate for
     // Ctrl+C's interrupt — with no director tick running, Ctrl+C flashes a notice instead of
     // writing an abort marker nothing would consume.
     let directorInFlight = false;
-    // Leave budget-edit mode (Esc, Ctrl+B again, or Ctrl+T): restore the saved prompt text.
-    // The recall state resets with it: the restored text is the live draft now, so the next
-    // Up starts a fresh browse instead of resuming whatever the cap editor's line left behind.
-    const exitBudgetMode = () => {
-        if (!budgetMode)
-            return;
-        budgetMode = false;
-        input = savedInput;
-        cursor = savedCursor;
-        promptHistory = resetPromptRecall(promptHistory);
-    };
-    // 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;
-        input = roleSavedInput;
-        cursor = roleSavedCursor;
-        promptHistory = resetPromptRecall(promptHistory);
-    };
-    // Leave defer-edit mode (Esc, Ctrl+L again, or Ctrl+T): restore the saved prompt text. The
-    // pending deferMs itself is untouched — Esc cancels the edit, not a delay already saved.
-    const exitDeferMode = () => {
-        if (!deferMode)
-            return;
-        deferMode = false;
-        input = deferSavedInput;
-        cursor = deferSavedCursor;
-        promptHistory = resetPromptRecall(promptHistory);
-    };
-    // 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;
-        input = pauseSavedInput;
-        cursor = pauseSavedCursor;
-        promptHistory = resetPromptRecall(promptHistory);
-    };
-    // Leave the backlog pane's answer editor (Esc, a recorded answer, or Ctrl+T): restore the
-    // saved prompt text and reset the recall state, mirroring exitQueuedEdit.
-    const exitAnswerMode = () => {
-        if (!answerFor)
-            return;
-        answerFor = null;
-        input = answerSavedInput;
-        cursor = answerSavedCursor;
-        promptHistory = resetPromptRecall(promptHistory);
-    };
-    // Leave the backlog pane's title editor (Esc, a saved edit, or Ctrl+T): the same settle
-    // contract as exitAnswerMode.
-    const exitEntryEdit = () => {
-        if (!entryEditFor)
-            return;
-        entryEditFor = null;
-        input = entryEditSavedInput;
-        cursor = entryEditSavedCursor;
-        promptHistory = resetPromptRecall(promptHistory);
-    };
-    // 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;
-        input = queuedSavedInput;
-        cursor = queuedSavedCursor;
-        promptHistory = resetPromptRecall(promptHistory);
-    };
-    /** Recompute the active pane's cached Markdown after `changed` state moved, re-entering the
-     * body at its head, and return whether the current view holds such a pane. "report" covers
-     * the Usage/Failures panes (fed by the report window and base-role scope); "history" the
-     * History pane (its window, outcome filter, exact-loop scope, and free-text search); "all"
-     * either. A view that is not the named pane is left untouched, so advancing one window
-     * redraws only the pane it feeds. The one home of the view-index→collector mapping the pane
-     * key handlers and syncSnapshot share. */
-    const refreshPaneCache = (changed) => {
-        const isReport = view === roleIds.length + 2 || view === roleIds.length + 3;
-        const isHistory = view === roleIds.length + 4;
-        if ((changed === "report" || changed === "all") && isReport) {
-            paneCache = view === roleIds.length + 2
-                ? usagePaneCache(root, reportWindow, scopeRole ?? undefined)
-                : failuresPaneCache(root, reportWindow, scopeRole ?? undefined);
-        }
-        else if ((changed === "history" || changed === "all") && isHistory) {
-            paneCache = historyPaneCache(root, historyWindow, historyResult, historyRole, historyGrep);
-        }
-        else {
-            return false;
-        }
-        paneScroll = 0;
-        return true;
-    };
-    // Re-read the pane-scoped newest completed tick into trailCache for an on-screen trail
-    // (Ctrl+N), so the trail cannot keep showing a retired loop's tick after Ctrl+G or a roster
-    // change drops the History scope. The reader throw is caught and flashed rather than escaping
-    // a key or sync path, the same guard the initial Ctrl+N entry uses.
-    const refreshTrail = () => {
-        try {
-            const row = readTickRows(root, 1, historyRole)[0];
-            const detail = row === undefined ? null : readTickDetail(root, row.loop, row.tick);
-            trailCache = detail === null ? null : renderTickDetail(detail);
-        }
-        catch (err) {
-            trailCache = null;
-            flashError(err);
-        }
-    };
-    // Re-read the Queued pane's rows and cached list after the queue changed (entry or cancel)
-    // and clamp the row selection to the shortened queue — a selection past the new end lands
-    // on the last remaining prompt, never on a stale role/position. An emptied queue clears it
-    // back to list mode. The refreshed list and any clamped-in row share paneScroll, so the
-    // offset resets too: a cancel that moves the selection opens the newly selected prompt at
-    // its head. The one home of the queuedRows/paneCache pairing the Ctrl+T entry and the Ctrl+X
-    // cancel share, so the pane's list and its selectable rows cannot drift.
-    const refreshQueued = () => {
-        queuedRows = queuedListRows(root, null, listWideScope(root));
-        paneCache = renderQueuedList(queuedRows, now());
-        selectedQueued = selectedQueued === null || queuedRows.length === 0
-            ? null
-            : Math.min(selectedQueued, queuedRows.length - 1);
-        paneScroll = 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;
-        input = searchSavedInput;
-        cursor = searchSavedCursor;
-        promptHistory = resetPromptRecall(promptHistory);
-    };
+    // The prompt-line editors, constructed with the pane-side leaves they call on commit/exit:
+    // the disk writes, the flash pair, the selections/caches they return to, and the clock.
+    const editors = createTuiEditors({
+        root,
+        now,
+        flat,
+        refreshQueued: panes.refreshQueued,
+        refreshNotes: panes.refreshNotes,
+        refreshBrief: panes.refreshBrief,
+        clearBacklogSelection: panes.clearBacklogSelection,
+        applyHistorySearch: panes.applyHistorySearch,
+        applyActivitySearch: panes.applyActivitySearch,
+        flashMessage,
+        flashError,
+        commitBacklogEdit,
+    });
     const handleKey = (str, key) => {
-        // Every key starts disarmed; only the backlog Ctrl+X branch reads `armed` and only the
-        // notebook Ctrl+X branch reads `armedNotes`.
-        const armed = cancelArmed;
-        cancelArmed = null;
-        const armedNotes = notesClearArmed;
-        notesClearArmed = null;
+        // Every key starts disarmed, whichever arm then consumes it.
+        panes.beginKey();
         if (key.ctrl && key.name === "d") {
             deps.quit();
             return;
@@ -527,7 +106,7 @@ export function createTuiKeys(deps) {
             // Ctrl+D): when the director row is in flight, write the same abort marker the
             // CLI's `abort --role director` does, through the shared requestAbort core so the
             // marker format and wording cannot drift; when none is, flash a notice and leave
-            // the fleet untouched. A failed marker write flashes the reason instead of
+            // the team untouched. A failed marker write flashes the reason instead of
             // escaping the handler — the same contract the per-loop controls above honor.
             if (!directorInFlight) {
                 flashMessage("no director task in flight");
@@ -544,1237 +123,45 @@ export function createTuiKeys(deps) {
             deps.requestRender();
             return;
         }
-        if (key.ctrl && key.name === "b") {
-            // Ctrl+B toggles budget-edit mode on the prompt line (mnemonic for *b*udget): entering
-            // pre-fills the current cap (empty when disabled — empty means "no cap" on save) and
-            // saves the prompt text; leaving restores it. Esc cancels the same way.
-            if (rolePromptFor || searchMode || deferMode || pauseEditMode || queuedEditFor || answerFor || entryEditFor) {
-                // Mutually exclusive with the role-prompt, History-search, defer, and Queued-edit
-                // editors: all five 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 (or parsing its text as a cap on Enter).
-                flashMessage(searchMode
-                    ? "finish or cancel the search first (Esc cancels)"
-                    : pauseEditMode
-                        ? "finish or cancel the pause first (Esc cancels)"
-                        : deferMode
-                            ? "finish or cancel the defer edit first (Esc cancels)"
-                            : queuedEditFor
-                                ? "finish or cancel the queued edit first (Esc cancels)"
-                                : answerFor
-                                    ? "finish or cancel the answer first (Esc cancels)"
-                                    : entryEditFor
-                                        ? "finish or cancel the entry edit first (Esc cancels)"
-                                        : `finish or cancel the prompt for ${rolePromptFor} first (Esc cancels)`);
-                deps.requestRender();
-                return;
-            }
-            if (budgetMode) {
-                exitBudgetMode();
-            }
-            else if (currentBudgetFree) {
-                // An all-free fleet has no spend a cap could bind: the editor would pre-fill a
-                // value that can never take effect, so Ctrl+B flashes a one-line notice and
-                // leaves the prompt line untouched (toggle/Esc logic unchanged).
-                flashMessage("budget n/a — all models free");
-            }
-            else {
-                // Mid-recall, hand the arrows' saved draft back before the cap editor takes the
-                // line — the same settle the role editor does — so leaving budget mode restores
-                // the draft, not a history entry, with no stale recall state riding along.
-                const settled = settlePromptRecall(promptHistory, input, cursor);
-                promptHistory = settled.history;
-                savedInput = settled.text;
-                savedCursor = settled.cursor;
-                budgetMode = true;
-                input = currentCapUsd > 0 ? String(currentCapUsd) : "";
-                cursor = input.length;
-                flashMessage("edit daily cost budget (USD): Enter to save, Esc to cancel");
-            }
-            deps.requestRender();
-            return;
-        }
-        if (key.ctrl && key.name === "l") {
-            // Ctrl+L toggles defer-edit mode on the prompt line (mnemonic: **l**ater): the line edits
-            // a duration that rides into the next delivered prompt as the same `tumwater:not-before`
-            // marker `tumwater prompt --at` and the dashboard composer write. Entering pre-fills the
-            // pending delay (empty when none) and saves the prompt text; leaving restores it. Empty
-            // means "deliver now", so Esc cancels the edit without clearing an already-saved delay.
-            if (budgetMode || rolePromptFor || searchMode || pauseEditMode || queuedEditFor || answerFor || entryEditFor) {
-                // Mutually exclusive with the budget, role-prompt, History-search, pause, and Queued-edit
-                // editors: all five 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.
-                flashMessage(budgetMode
-                    ? "finish or cancel the budget edit first (Esc cancels)"
-                    : pauseEditMode
-                        ? "finish or cancel the pause first (Esc cancels)"
-                        : searchMode
-                            ? "finish or cancel the search first (Esc cancels)"
-                            : queuedEditFor
-                                ? "finish or cancel the queued edit first (Esc cancels)"
-                                : answerFor
-                                    ? "finish or cancel the answer first (Esc cancels)"
-                                    : entryEditFor
-                                        ? "finish or cancel the entry edit first (Esc cancels)"
-                                        : `finish or cancel the prompt for ${rolePromptFor} first (Esc cancels)`);
-                deps.requestRender();
-                return;
-            }
-            if (deferMode) {
-                exitDeferMode();
-            }
-            else {
-                // Mid-recall, hand the arrows' saved draft back before the defer editor takes the
-                // line — the same settle the budget and role editors do — so leaving restores the
-                // draft, not a history entry, with no stale recall state riding along.
-                const settled = settlePromptRecall(promptHistory, input, cursor);
-                promptHistory = settled.history;
-                deferSavedInput = settled.text;
-                deferSavedCursor = settled.cursor;
-                deferMode = true;
-                input = deferMs === null ? "" : durationLabel(deferMs);
-                cursor = input.length;
-                flashMessage("defer the next prompt: a duration like 45m (empty sends now) — Enter to save, Esc to cancel");
-            }
-            deps.requestRender();
-            return;
-        }
-        if (key.ctrl && key.name === "f" && !budgetMode && !rolePromptFor && !searchMode && !deferMode && !queuedEditFor && !answerFor && !entryEditFor) {
-            // Ctrl+F toggles the whole-fleet pause (mnemonic: **F**leet) through the same
-            // pauseFleet/resumeFleet 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 fleetPausePhrase/fleetResumePhrase 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 fleet 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();
-                deps.requestRender();
-                return;
-            }
-            try {
-                if (isFleetPaused(root)) {
-                    flashMessage(resumeFleet(root) ? fleetResumePhrase() : "fleet was not paused");
-                }
-                else {
-                    // An unpaused fleet opens the one-line editor: "[duration] [reason]", empty pauses
-                    // until resumed. A paused fleet resumes at once.
-                    const settled = settlePromptRecall(promptHistory, input, cursor);
-                    promptHistory = settled.history;
-                    pauseSavedInput = settled.text;
-                    pauseSavedCursor = settled.cursor;
-                    pauseEditMode = true;
-                    input = "";
-                    cursor = 0;
-                    flashMessage('pause the fleet: [duration] [reason], e.g. "2h deploy freeze" (empty pauses until resumed) — Enter to pause, Esc to cancel');
-                }
-            }
-            catch (err) {
-                flashError(err);
-            }
-            deps.requestRender();
-            return;
-        }
-        // Per-loop controls on the transcript pane: Ctrl+P
-        // toggles the viewed loop's pause, Ctrl+A aborts its in-flight tick, Ctrl+W opens the wake editor,
-        // and Ctrl+R opens the role-prompt editor for it.
-        // 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, where only Ctrl+U (kill to line start) and Ctrl+K (kill to line end)
-        // edit the prompt line and the rest of these ctrl-key presses stay inert.
-        // 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, the same contract the prompt-submit path below honors.
-        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();
-            deps.requestRender();
-            return;
-        }
-        if (!budgetMode &&
-            !deferMode && !pauseEditMode &&
-            !queuedEditFor && !answerFor && !entryEditFor &&
-            roleIds.length > 0 &&
-            view >= 1 && view <= roleIds.length &&
-            key.ctrl && (key.name === "p" || key.name === "a" || key.name === "w" || key.name === "r")) {
-            const role = roleIds[view - 1]; // defined: view is clamped inside the transcript range
-            try {
-                if (key.name === "r") {
-                    // 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.
-                    if (rolePromptFor) {
-                        exitRolePromptMode();
-                        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.
-                        const settled = settlePromptRecall(promptHistory, input, cursor);
-                        promptHistory = settled.history;
-                        roleSavedInput = settled.text;
-                        roleSavedCursor = settled.cursor;
-                        rolePromptFor = role;
-                        input = "";
-                        cursor = 0;
-                        flashMessage(`prompt for ${role}: Enter to send, Esc to cancel`);
-                    }
-                }
-                else 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(root).includes(role)) {
-                        flashMessage(roleResumeMessage(root, role, resumeRole(root, role)));
-                    }
-                    else if (rolePromptFor || searchMode) {
-                        flashMessage(rolePromptFor
-                            ? "finish or cancel the role prompt first (Esc cancels)"
-                            : "finish or cancel the search first (Esc cancels)");
-                    }
-                    else {
-                        // An unpaused loop opens the one-line duration editor; nothing is written until
-                        // Enter. Empty pauses until resumed.
-                        const settled = settlePromptRecall(promptHistory, input, cursor);
-                        promptHistory = settled.history;
-                        pauseSavedInput = settled.text;
-                        pauseSavedCursor = settled.cursor;
-                        pauseEditMode = true;
-                        pauseEditRole = role;
-                        input = "";
-                        cursor = 0;
-                        flashMessage(`pause ${role}: [duration], e.g. "2h" (empty pauses until resumed) — Enter to pause, Esc to cancel`);
-                    }
-                }
-                else if (key.name === "a") {
-                    const result = requestAbort(root, role);
-                    flashMessage(result.ok ? result.message : `error: ${result.error}`);
-                }
-                else if (rolePromptFor || searchMode) {
-                    flashMessage(rolePromptFor
-                        ? "finish or cancel the role prompt first (Esc cancels)"
-                        : "finish or cancel the search first (Esc cancels)");
-                }
-                else {
-                    // Ctrl+W opens the one-line wake editor; nothing is written until Enter. Empty wakes now.
-                    const settled = settlePromptRecall(promptHistory, input, cursor);
-                    promptHistory = settled.history;
-                    pauseSavedInput = settled.text;
-                    pauseSavedCursor = settled.cursor;
-                    pauseEditMode = true;
-                    pauseEditRole = role;
-                    pauseEditWake = true;
-                    input = "";
-                    cursor = 0;
-                    flashMessage(`wake ${role}: [duration], e.g. "2h", or "cancel" (empty wakes now) — Enter to apply, Esc to cancel`);
-                }
-            }
-            catch (err) {
-                flashError(err);
-            }
-            deps.requestRender();
-            return;
-        }
-        if (key.ctrl && key.name === "n") {
-            // 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.
-            if (entryEditFor !== null && entryEditFor.position === null) {
-                const other = entryEditFor.kind === "plan" ? "bug" : "plan";
-                entryEditFor = { ...entryEditFor, kind: other };
-                flashMessage(`new ${other} — Enter to file, Ctrl+N switches to ${other === "plan" ? "bug" : "plan"}, Esc cancels`);
-                deps.requestRender();
-                return;
-            }
-            if (view === roleIds.length + 1 &&
-                !budgetMode && !rolePromptFor && !searchMode && !deferMode && !pauseEditMode && !queuedEditFor && !answerFor && !entryEditFor) {
-                const settled = settlePromptRecall(promptHistory, input, cursor);
-                promptHistory = settled.history;
-                entryEditSavedInput = settled.text;
-                entryEditSavedCursor = settled.cursor;
-                entryEditFor = { kind: "plan", position: null, title: "" };
-                input = "";
-                cursor = 0;
-                flashMessage("new plan — Enter to file, Ctrl+N switches to bug, Esc cancels");
-                deps.requestRender();
-                return;
-            }
-            // Ctrl+N cycles the viewed loop's pane live transcript → notebook → change → transcript
-            // (PLANS.md "Inspect a loop's notebook and next tick prompt in the TUI" and "Show a
-            // loop's pending change in the TUI transcript pane"). The change step renders the same
-            // collectRoleChange/renderRoleChange view the CLI's `tumwater diff --role <id>` and the
-            // dashboard drawer use. Guarded to a transcript view and out of budget-edit and
-            // role-prompt modes, the same way the per-loop controls below are; everywhere else the
-            // key falls through to applyKey. On the History pane the same key swaps the row list for
-            // one tick's full event trail instead (the CLI's `tumwater tick --last` text), so it is
-            // handled before the transcript guard below.
-            if (view === roleIds.length + 4 && !budgetMode && !rolePromptFor && !searchMode && !deferMode && !pauseEditMode && !queuedEditFor && !answerFor && !entryEditFor) {
-                if (trailMode) {
-                    trailMode = false;
-                    trailCache = null;
-                }
-                else {
-                    // The newest completed tick in the pane's scope: the loop's when Ctrl+G set
-                    // historyRole, else the fleet's. A log holding none flashes and leaves the rows.
-                    const row = readTickRows(root, 1, historyRole)[0];
-                    if (row === undefined) {
-                        flashMessage("no completed ticks to inspect");
-                    }
-                    else {
-                        // readTickDetail reads the log and renderTickDetail renders it; a throw (an
-                        // injected seam or an unexpected failure) flashes the reason and leaves the rows
-                        // shown rather than escaping the handler and killing the TUI.
-                        try {
-                            const detail = readTickDetail(root, row.loop, row.tick);
-                            trailCache = detail === null ? null : renderTickDetail(detail);
-                            trailMode = true;
-                        }
-                        catch (err) {
-                            trailCache = null;
-                            flashError(err);
-                        }
-                    }
-                }
-                paneScroll = 0; // either way the pane starts at its head
-                deps.requestRender();
-                return;
-            }
-            if (budgetMode || rolePromptFor || deferMode || pauseEditMode || queuedEditFor || answerFor || entryEditFor || roleIds.length === 0 || view < 1 || view > roleIds.length) {
-                deps.requestRender();
-                return;
-            }
-            const role = roleIds[view - 1]; // defined: view is clamped inside the transcript range
-            if (changeMode) {
-                changeMode = false;
-                changeCache = null;
-            }
-            else if (noteMode) {
-                // notebook → change: reset the notebook snapshot and kick off the collector
-                // fire-and-forget, caching the rendered text when it resolves (the Pending pane's
-                // pattern). Guard on the change pane still being current — changeMode on, same role
-                // at the same index — so a cycle away or a roster shift cannot overwrite the pane now
-                // shown. The default collector degrades rather than throws, so the rejection arm only
-                // covers an injected seam (or an unexpected throw).
-                noteMode = false;
-                noteCache = null;
-                changeMode = true;
-                changeCache = null;
-                const target = role;
-                void collectChange(root, target).then((change) => {
-                    if (!changeMode || roleIds[view - 1] !== target)
-                        return;
-                    changeCache = renderRoleChange(change);
-                    deps.requestRender();
-                }, (err) => {
-                    if (!changeMode || roleIds[view - 1] !== target)
-                        return;
-                    flashError(err);
-                    deps.requestRender();
-                });
-            }
-            else {
-                // rolePayload reads the notebook and assembles the next tick's prompt off disk; a
-                // throw leaves the transcript shown (the mode stays off) and flashes the reason
-                // instead of escaping the handler and killing the TUI.
-                try {
-                    noteCache = roleInspectMarkdown(root, role);
-                    noteMode = true;
-                }
-                catch (err) {
-                    noteCache = null;
-                    flashError(err);
-                }
-            }
-            paneScroll = 0; // either way the pane starts at its head
-            deps.requestRender();
-            return;
-        }
-        if (key.ctrl && key.name === "g" && !budgetMode && !rolePromptFor && !searchMode && !deferMode && !pauseEditMode && !queuedEditFor && !answerFor && !entryEditFor) {
-            // Ctrl+G cycles the active pane's loop scope (mnemonic: the **g**lobal scope / the
-            // **g**roup). Guarded out of the budget and role-prompt editors, whose prompt line the
-            // key must not disturb — the same inertness the per-loop keys honor. On the History
-            // pane it walks the raw roster ids (`[null, ...roleIds]`) so an instance id is its own
-            // slot, matching `history --role` and the dashboard picker; on every other view it cycles
-            // the base-role report scope the Usage and Failures collectors aggregate by, exactly as
-            // before. A pane showing the scope recomputes its cached Markdown and re-enters the body
-            // at its head; every other view keeps the scope for the Ctrl+T entry that later computes
-            // with it.
-            if (view === 0) {
-                // The Activity feed scopes over the same raw roster ids, so `feature-2` is its own
-                // slot; the filter reads exact loop ids through eventRole. The scroll resets because
-                // its offset indexed the old (unfiltered or differently filtered) list.
-                const slots = [null, ...roleIds];
-                const slot = slots.indexOf(activityRole);
-                activityRole = slots[(slot + 1) % slots.length] ?? null;
-                activityScroll = null;
-            }
-            else if (view === roleIds.length + 4) {
-                const slots = [null, ...roleIds];
-                const slot = slots.indexOf(historyRole);
-                historyRole = slots[(slot + 1) % slots.length] ?? null;
-                // A trail already on screen follows the scope: re-read the new scope's newest
-                // completed tick (or drop to the pane's no-trail note when it has none) so the trail
-                // and the tab strip cannot name different loops.
-                if (trailMode)
-                    refreshTrail();
-            }
-            else {
-                const slots = scopeCycle(roleIds);
-                const slot = slots.indexOf(scopeRole);
-                scopeRole = slots[(slot + 1) % slots.length] ?? null;
-            }
-            refreshPaneCache("all");
-            deps.requestRender();
-            return;
-        }
-        if (key.ctrl && key.name === "e" &&
-            !budgetMode && !rolePromptFor && !searchMode && !deferMode && !pauseEditMode && queuedEditFor === null && !answerFor && !entryEditFor &&
-            view === roleIds.length + 6 && 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(selectedQueued, queuedRows.length - 1);
-                const row = queuedRows[position];
-                if (row !== undefined) {
-                    const body = readQueuedPromptBody(root, row.role, row.file);
-                    if (body === null) {
-                        flashMessage(`queued prompt #${row.position} for ${row.role} is gone`);
-                        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.
-                        const settled = settlePromptRecall(promptHistory, input, cursor);
-                        promptHistory = settled.history;
-                        queuedSavedInput = settled.text;
-                        queuedSavedCursor = settled.cursor;
-                        queuedEditFor = { role: row.role, file: row.file };
-                        input = body;
-                        cursor = body.length;
-                        flashMessage(`editing queued prompt #${row.position} for ${row.role} — Enter to save, Esc to cancel`);
-                    }
-                }
-            }
-            catch (err) {
-                flashError(err);
-            }
-            deps.requestRender();
-            return;
-        }
-        if (key.ctrl && key.name === "a" &&
-            !budgetMode && !rolePromptFor && !searchMode && !deferMode && !pauseEditMode && !queuedEditFor && !answerFor && !entryEditFor &&
-            view === roleIds.length + 1 && selectedEntry !== null) {
-            // Ctrl+A opens the answer editor on the selected open question (mnemonic: **A**nswer);
-            // Enter records the decision through tryAnswerQuestion, the core `tumwater questions
-            // answer` and the dashboard's form share. The position is the question's 1-based index
-            // among the open questions: labeledBacklogEntries lists plans, then bugs, then questions.
-            try {
-                const entries = flat();
-                const sel = Math.min(selectedEntry, entries.length - 1);
-                const entry = entries[sel];
-                if (entry?.label !== "question") {
-                    flashMessage("only an open question can be answered here");
-                }
-                else {
-                    const position = sel - entries.filter((e) => e.label !== "question").length + 1;
-                    const settled = settlePromptRecall(promptHistory, input, cursor);
-                    promptHistory = settled.history;
-                    answerSavedInput = settled.text;
-                    answerSavedCursor = settled.cursor;
-                    answerFor = { position, title: entry.title };
-                    input = "";
-                    cursor = 0;
-                    flashMessage(`answering question #${position} — Enter to record, Esc to cancel`);
-                }
-            }
-            catch (err) {
-                flashError(err);
-            }
-            deps.requestRender();
-            return;
-        }
-        if (key.ctrl && key.name === "e" &&
-            !budgetMode && !rolePromptFor && !searchMode && !deferMode && !pauseEditMode && !queuedEditFor && !answerFor && !entryEditFor &&
-            view === roleIds.length + 1 && selectedEntry !== null) {
-            // Ctrl+E opens the title editor on the selected plan or bug (mnemonic: **E**dit); Enter
-            // 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.
-            try {
-                const entries = flat();
-                const sel = Math.min(selectedEntry, entries.length - 1);
-                const picked = entries[sel];
-                if (picked === undefined) {
-                    // an emptied list has nothing to edit
-                }
-                else if (picked.label === "question") {
-                    flashMessage("only a plan or open bug can be edited here");
-                }
-                else {
-                    const kind = picked.label === "plan" ? "plan" : "bug";
-                    const position = kind === "plan" ? sel + 1 : sel - entries.filter((e) => e.label === "plan").length + 1;
-                    const settled = settlePromptRecall(promptHistory, input, cursor);
-                    promptHistory = settled.history;
-                    entryEditSavedInput = settled.text;
-                    entryEditSavedCursor = settled.cursor;
-                    entryEditFor = { kind, position, title: picked.title };
-                    input = stripEntryStamp(picked.title);
-                    cursor = input.length;
-                    flashMessage(`editing ${kind} #${position} — Enter to save, Esc to cancel`);
-                }
-            }
-            catch (err) {
-                flashError(err);
-            }
-            deps.requestRender();
-            return;
-        }
-        if (key.ctrl && key.name === "e" && !budgetMode && !rolePromptFor && !deferMode && !pauseEditMode && !queuedEditFor && !answerFor && !entryEditFor) {
-            // Ctrl+E advances the Usage and Failures panes' trailing report window (mnemonic:
-            // **E**lapsed). Guarded out of the budget and role-prompt editors like the other
-            // mode-sensitive keys. The window is session state: advancing it off either report pane
-            // only changes the label, and the next Ctrl+T into one computes the cache with it; on a
-            // report pane this handler recomputes the cached Markdown from the newly windowed
-            // collector and re-enters the body at its head.
-            reportWindow = nextInCycle(REPORT_WINDOWS, reportWindow);
-            refreshPaneCache("report");
-            deps.requestRender();
-            return;
-        }
-        if (key.ctrl && key.name === "s" && !budgetMode && !rolePromptFor && !searchMode && !deferMode && !pauseEditMode && !queuedEditFor && !answerFor && !entryEditFor) {
-            // Ctrl+S advances the History pane's trailing window (mnemonic: **S**ince). Guarded out
-            // of budget-edit and role-prompt modes like the other mode-sensitive keys. The window is
-            // session state: advancing it off the History view only changes the label, and the next
-            // Ctrl+T into History computes the cache with it; on the History view this handler
-            // re-reads the rows now and resets the scroll so the changed body re-enters at its head.
-            historyWindow = nextInCycle(HISTORY_WINDOWS, historyWindow);
-            refreshPaneCache("history");
-            deps.requestRender();
-            return;
-        }
-        if (key.ctrl && key.name === "o" && !budgetMode && !rolePromptFor && !searchMode && !deferMode && !pauseEditMode && !queuedEditFor && !answerFor && !entryEditFor) {
-            // Ctrl+O advances the History pane's outcome filter (mnemonic: **O**utcome). Guarded out
-            // of budget-edit and role-prompt modes like Ctrl+S beside it. The class is session state:
-            // advancing it off the History view only changes the label, and the next Ctrl+T into
-            // History computes the cache with it; on the History view this handler re-reads and
-            // re-filters the rows now and resets the scroll so the changed body re-enters at its head.
-            historyResult = nextInCycle(HISTORY_RESULTS, historyResult);
-            refreshPaneCache("history");
-            deps.requestRender();
-            return;
-        }
-        if (key.ctrl && key.name === "x" && noteMode &&
-            !budgetMode && !rolePromptFor && !searchMode && !deferMode && !pauseEditMode && !queuedEditFor && !answerFor && !entryEditFor &&
-            view >= 1 && view <= roleIds.length) {
-            // Ctrl+X twice clears the viewed loop's notebook through the writer the CLI's
-            // `--clear-notes` and the dashboard drawer share, then re-renders the notebook view.
-            const role = roleIds[view - 1];
-            if (armedNotes === role) {
-                try {
-                    flashMessage(`${role}: ${saveRoleNote(roleNotesPath(root, role), "")}`);
-                    noteCache = roleInspectMarkdown(root, role);
-                    paneScroll = 0;
-                }
-                catch (err) {
-                    flashError(err);
-                }
-            }
-            else {
-                notesClearArmed = role;
-                flashMessage(`press Ctrl+X again to clear ${role}'s notebook — any other key keeps it`);
-            }
-            deps.requestRender();
-            return;
-        }
-        if (key.ctrl && key.name === "x" &&
-            !budgetMode && !rolePromptFor && !searchMode && !deferMode && !pauseEditMode && !queuedEditFor && !answerFor && !entryEditFor &&
-            view === roleIds.length + 6 && selectedQueued !== null) {
-            // Ctrl+X cancels the selected queued prompt through the CLI's own per-loop path
-            // (`tumwater prompt --cancel <n> --role <id>`): cancelRolePrompt removes that loop's
-            // Nth queue file and logs the prompt_cancelled event, so the pane, the CLI, and the
-            // dashboard cancel cannot drift. Then re-read the queue so the pane's list and rows
-            // reflect the removal and the selection clamps. A no-selection press (list mode), and
-            // every other view, leaves the queue untouched.
-            try {
-                const row = queuedRows[Math.min(selectedQueued, queuedRows.length - 1)];
-                if (row !== undefined) {
-                    const outcome = cancelRolePrompt(root, row.role, row.position);
-                    // A gone outcome is the concurrent-dequeue race (cancelRolePrompt's own contract),
-                    // not a failure: flash it honestly and still refresh the listing.
-                    flashMessage(outcome.status === "cancelled"
-                        ? `cancelled queued prompt #${row.position} for ${row.role}`
-                        : `queued prompt #${row.position} for ${row.role} was already gone`);
-                    refreshQueued();
-                }
-            }
-            catch (err) {
-                flashError(err);
-            }
-            deps.requestRender();
-            return;
-        }
-        if (key.ctrl && key.name === "x" &&
-            !budgetMode && !rolePromptFor && !searchMode && !deferMode && !pauseEditMode && !queuedEditFor && !answerFor && !entryEditFor &&
-            view === roleIds.length + 1) {
-            // Ctrl+X twice cancels the selected plan or bug through the non-exiting core the
-            // dashboard drawer uses; the title check inside tryCancelEntry refuses a stale selection.
-            if (selectedEntry !== null) {
-                const entries = flat();
-                const sel = Math.min(selectedEntry, entries.length - 1);
-                const picked = entries[sel];
-                if (picked === undefined) {
-                    // an emptied list has nothing to cancel
-                }
-                else if (picked.label === "question") {
-                    flashMessage("only a plan or open bug can be cancelled here");
-                }
-                else {
-                    const kind = picked.label === "plan" ? "plan" : "bug";
-                    const position = kind === "plan" ? sel + 1 : sel - entries.filter((e) => e.label === "plan").length + 1;
-                    const target = { kind, position, title: picked.title };
-                    if (armed !== null && armed.kind === kind && armed.position === position) {
-                        // The armed title (not the re-read one) goes to tryCancelEntry, so an entry that
-                        // changed since the arm reports `moved` instead of being cancelled.
-                        try {
-                            const outcome = tryCancelEntry(root, kind, position, armed.title);
-                            selectedEntry = null;
-                            entryScroll = 0;
-                            flashMessage(outcome.status === "cancelled"
-                                ? `cancelled ${kind} #${position}: ${target.title}`
-                                : `that ${kind} was already removed or moved — nothing cancelled`);
-                        }
-                        catch (err) {
-                            flashError(err);
-                        }
-                    }
-                    else {
-                        cancelArmed = target;
-                        flashMessage(`press Ctrl+X again to cancel ${kind} #${position} — any other key keeps it`);
-                    }
-                }
-            }
+        // The prompt-line editors own every arm that reads or writes the one prompt line — the
+        // toggles and per-loop controls that open them, the escape/Enter arms that close and
+        // commit them, and the `/` search. Route the key to them first; when they consumed it,
+        // the dispatch is done (they always render on a handled key).
+        if (editors.handleKey(str, key, panes.editorCtx())) {
             deps.requestRender();
             return;
         }
         if (key.ctrl && key.name === "t") {
-            // Ctrl+T exits budget-edit mode too — view cycling is orthogonal to it, so a cycle
-            // never strands the editor with its pre-filled cap in the prompt line. Role-prompt
-            // mode composes the same way: cycling away restores the saved director draft.
-            exitBudgetMode();
-            exitRolePromptMode();
-            exitDeferMode();
-            exitPauseEditMode();
-            exitHistorySearch();
-            exitQueuedEdit();
-            exitAnswerMode();
-            exitEntryEdit();
-            noteMode = false; // a cycle away leaves notebook and change modes and drops their snapshots
-            noteCache = null;
-            changeMode = false;
-            changeCache = null;
-            trailMode = false; // the tick trail is History-only; a cycle away drops its snapshot too
-            trailCache = null;
-            view = (view + 1) % (roleIds.length + 7); // events → each loop's transcript → project status → usage report → failures → history → pending → queued → events
-            selectedEntry = null; // leaving a view drops any entry selection…
-            selectedQueued = null; // …and any queued-row selection, so re-entering starts at the list
-            entryScroll = 0; // …and its within-body scroll, so re-entering starts at the list/head
-            paneScroll = 0; // the Markdown panes always re-enter at their head
-            activityScroll = null; // Activity always re-enters at the live tail
-            // Compute the pane's Markdown once per activation (this handler renders immediately), and
-            // drop it on leaving — a visit's first frame is fresh, later frames only re-window.
-            if (!refreshPaneCache("all")) {
-                if (view === roleIds.length + 5) {
-                    // Pending is the cycle's one async collector: collectFleetChanges awaits git plumbing,
-                    // so kick it off fire-and-forget, cache the rendered text when it resolves, and repaint.
-                    // The durable land queue needs no git plumbing, so read and render it through the CLI's
-                    // own pair (`tumwater queue`) UP FRONT: the queue paints on entry, and the git-backed
-                    // roster is appended below it when the collector resolves, so the three surfaces
-                    // (CLI, dashboard, TUI) cannot drift on order, age, skips, or wording.
-                    // Guard on the PENDING pane still being current — view === roleIds.length + 5 — not just
-                    // on the raw index: an operator who cycled away, or a roster change that shifted which
-                    // pane the same index names, must not have this resolution overwrite the pane now shown.
-                    // The default collector degrades rather than throws, so the rejection arm only covers an
-                    // injected seam (or an unexpected throw).
-                    const queueText = renderLandingQueue(readLandingQueue(root), now());
-                    paneCache = queueText;
-                    void collectPending(root).then((fleet) => {
-                        if (view !== roleIds.length + 5)
-                            return;
-                        paneCache = queueText + "\n\n" + renderFleetChange(fleet);
-                        deps.requestRender();
-                    }, (err) => {
-                        if (view !== roleIds.length + 5)
-                            return;
-                        // Keep the queue visible rather than replacing it with a loading note: it is
-                        // already known and unaffected by the git read that failed.
-                        flashError(err);
-                        deps.requestRender();
-                    });
-                }
-                else if (view === roleIds.length + 6) {
-                    // Queued is a synchronous read of the same queue list `tumwater prompt --list`
-                    // prints (renderQueuedList over queuedListRows), so it paints on entry with no
-                    // async collector. The now() clock keeps the age/countdown suffix testable.
-                    refreshQueued();
-                }
-                else {
-                    paneCache = null;
-                }
-            }
-            deps.requestRender();
+            // Ctrl+T exits every open editor too — view cycling is orthogonal to them, so a cycle
+            // never strands an editor's pre-filled text in the prompt line. Each editor restores its
+            // saved draft. Role-prompt mode composes the same way: cycling away restores the saved
+            // director draft.
+            editors.exitAll();
+            panes.cycleView();
             return;
         }
-        if (!key.ctrl && str === "/" && !searchMode && !budgetMode && !rolePromptFor && !deferMode && !pauseEditMode && !queuedEditFor && !answerFor && !entryEditFor &&
-            (view === 0 || view === roleIds.length + 4) && 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.
-            const settled = settlePromptRecall(promptHistory, input, cursor);
-            promptHistory = settled.history;
-            searchSavedInput = settled.text;
-            searchSavedCursor = settled.cursor;
-            searchFor = view === 0 ? "activity" : "history";
-            searchMode = true;
-            input = (searchFor === "activity" ? activityGrep : historyGrep) ?? "";
-            cursor = input.length;
-            flashMessage(searchFor === "activity" ? "search events: Enter to filter, Esc to cancel" : "search ticks: Enter to filter, Esc to cancel");
-            deps.requestRender();
+        if (panes.handleKey(key, editors.state()))
             return;
-        }
         const arrow = arrowDir(key.name);
-        const page = pageDir(key.name);
-        if (view === roleIds.length + 1 && arrow !== null) {
-            // In the project-status pane, up/down browse entries in full instead of editing the
-            // prompt; every other view keeps today's behavior (arrows are ignored by applyKey).
-            // An open answer editor pins the selection (its position was taken from it).
-            if (!answerFor && !entryEditFor) {
-                const count = flat().length;
-                selectedEntry = moveEntrySelection(count, selectedEntry, arrow);
-                entryScroll = 0; // a newly opened entry starts at its body's head
-            }
-            deps.requestRender();
-            return;
-        }
-        if (view === roleIds.length + 6 && arrow !== null) {
-            // In the Queued pane, up/down select a queued prompt row in full (wrapping, the backlog
-            // pane's rule) instead of editing the prompt; an empty queue has nothing to select, so
-            // moveEntrySelection clears the selection. Every other view keeps today's behavior.
-            // The selected body shares paneScroll with the list, so a newly opened row must start
-            // at its head (the status pane's entryScroll reset on the same move), or it renders
-            // scrolled into the middle of the previous row's body.
-            selectedQueued = moveEntrySelection(queuedRows.length, selectedQueued, arrow);
-            paneScroll = 0;
-            deps.requestRender();
-            return;
-        }
-        if (page !== null && view === 0) {
-            // The Activity pane keeps the live tail by default; PgUp pauses follow and pages back
-            // through the loaded event tail, PgDn returns toward it and re-enables follow once the
-            // window reaches the tail. Both directions clamp to [0, total - eventBudget], and a log
-            // with eventBudget or fewer events stays on the tail. The read is the pane's own fixed
-            // tail term (and active loop/text filter), so it hits readEvents' stat cache rather than
-            // rescanning the log.
-            const total = activityEvents(root, activityRole, activityGrep).length;
-            const maxStart = Math.max(0, total - eventBudget);
-            const current = activityScroll ?? maxStart;
-            const next = stepEntryScroll(current, total, eventBudget, page);
-            activityScroll = next >= maxStart ? null : next;
-            deps.requestRender();
-            return;
-        }
-        if (page !== null && (noteMode || changeMode || trailMode)) {
-            // Within-body scroll in the notebook, change, and tick-trail views: PgDn/PgUp page the
-            // cached inspection Markdown, clamped at both ends, exactly like the usage/failures
-            // panes below.
-            const total = (noteMode ? (noteCache ?? "") : trailMode ? (trailCache ?? "") : (changeCache ?? "")).split("\n").length;
-            paneScroll = stepEntryScroll(paneScroll, total, eventBudget, page);
+        if (arrow !== null && editors.onArrow(arrow)) {
             deps.requestRender();
             return;
         }
-        if (view >= roleIds.length + 2 && page !== null) {
-            // Within-body scroll in the Markdown panes (usage report, failures): PgDn/PgUp page the
-            // cached string, clamped at both ends. The total is derived from the cache, mirroring how
-            // entry mode derives it from e.body; every other view ignores these keys as today.
-            const total = (paneCache ?? "").split("\n").length;
-            paneScroll = stepEntryScroll(paneScroll, total, eventBudget, page);
-            deps.requestRender();
-            return;
-        }
-        if (view === roleIds.length + 1 && page !== null) {
-            // Within-body scroll in project-status ENTRY mode: PgDn/PgUp page the selected entry's
-            // body, clamped at both ends. No-op in list mode and for bodies that fit — every other
-            // view ignores these keys as today (applyKey drops them).
-            if (selectedEntry !== null && !answerFor && !entryEditFor) {
-                const entries = flat();
-                const sel = entries.length > 0 ? Math.min(selectedEntry, entries.length - 1) : null;
-                const body = sel === null ? "" : entries[sel].body;
-                entryScroll = stepEntryScroll(entryScroll, body ? body.split("\n").length : 0, entryBudget, page);
-            }
-            deps.requestRender();
-            return;
-        }
-        if (!budgetMode && !deferMode && !pauseEditMode && !searchMode && arrow !== null) {
-            // 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 and defer modes keep them out — recalling a
-            // prompt into the cap or delay field would be a paste, not a recall. No history in
-            // this direction: fall through to applyKey, which ignores arrows as before.
-            const recalled = recallPromptHistory(promptHistory, input, cursor, key.name === "up" ? "older" : "newer");
-            if (recalled) {
-                promptHistory = recalled.history;
-                input = recalled.text;
-                cursor = recalled.cursor;
-            }
-        }
-        if (key.name === "escape" && selectedQueued !== null && view === roleIds.length + 6 &&
-            !budgetMode && !deferMode && !pauseEditMode && !rolePromptFor && !searchMode && !queuedEditFor && !answerFor && !entryEditFor) {
-            // Esc on the Queued pane returns it to list mode; the cached list is untouched (nothing
-            // was cancelled), so the pane shows the same renderQueuedList it entered with. The
-            // shared paneScroll resets with the body switch, like a selection move.
-            selectedQueued = null;
-            paneScroll = 0;
-            deps.requestRender();
-            return;
-        }
-        if (key.name === "escape" && searchMode) {
-            // Esc cancels the History search without applying it; the applied pattern is unchanged.
-            exitHistorySearch();
-            deps.requestRender();
-            return;
-        }
-        if (key.name === "escape" && budgetMode) {
-            // Esc cancels budget-edit mode, restoring the previous prompt text.
-            exitBudgetMode();
-            deps.requestRender();
-            return;
-        }
-        if (key.name === "escape" && rolePromptFor) {
-            // Esc cancels role-prompt mode the same way, restoring the previous prompt text.
-            exitRolePromptMode();
-            deps.requestRender();
-            return;
-        }
-        if (key.name === "escape" && pauseEditMode) {
-            // Esc cancels the pause editor without writing, restoring the previous prompt text.
-            exitPauseEditMode();
-            deps.requestRender();
-            return;
-        }
-        if (key.name === "escape" && deferMode) {
-            // Esc cancels the defer editor, restoring the previous prompt text and leaving any
-            // already-saved pending delay untouched.
-            exitDeferMode();
-            deps.requestRender();
-            return;
-        }
-        if (key.name === "escape" && entryEditFor) {
-            // Esc cancels the title editor, restoring the previous prompt text; nothing is written.
-            const filing = entryEditFor.position === null;
-            exitEntryEdit();
-            flashMessage(filing ? "new entry cancelled" : "edit cancelled");
-            deps.requestRender();
-            return;
-        }
-        if (key.name === "escape" && answerFor) {
-            // Esc cancels the answer editor, restoring the previous prompt text; nothing is written.
-            exitAnswerMode();
-            flashMessage("answer cancelled");
-            deps.requestRender();
-            return;
-        }
-        if (key.name === "escape" && queuedEditFor) {
-            // Esc cancels the Queued pane's in-place editor, restoring the previous prompt text.
-            exitQueuedEdit();
-            deps.requestRender();
-            return;
-        }
-        if (key.name === "return") {
-            if (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 = input.trim();
-                if (searchFor === "activity") {
-                    activityGrep = pattern === "" ? null : pattern;
-                    exitHistorySearch();
-                    activityScroll = null;
-                    flashMessage(activityGrep === null ? "search cleared" : `search: "${activityGrep}"`);
-                }
-                else {
-                    historyGrep = pattern === "" ? null : pattern;
-                    exitHistorySearch();
-                    paneCache = historyPaneCache(root, historyWindow, historyResult, historyRole, historyGrep);
-                    paneScroll = 0;
-                    flashMessage(historyGrep === null ? "search cleared" : `search: "${historyGrep}"`);
-                }
-            }
-            else if (budgetMode) {
-                // Enter in budget mode parses + saves the cap through the shared setter (which
-                // writes tumwater.json atomically; the running orchestrator picks it up on its next
-                // ~2 s poll). An invalid value flashes and STAYS in edit mode so the operator can
-                // fix it; success restores the saved prompt text.
-                const parsed = parseBudgetInput(input);
-                if (!parsed.ok) {
-                    flashMessage(parsed.error);
-                }
-                else {
-                    const result = setDailyBudgetUsd(root, parsed.value);
-                    if (result.ok) {
-                        exitBudgetMode();
-                        currentCapUsd = parsed.value; // the next render's snapshot agrees within ~2 s
-                        flashMessage(parsed.value === 0
-                            ? "budget disabled"
-                            : `budget set to ${usdCap(parsed.value)}`);
-                    }
-                    else {
-                        flashMessage(result.error); // broken config or write failure — stay in edit mode
-                    }
-                }
-            }
-            else if (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 wakeParsed = pauseEditWake && target !== null ? parseRoleWakeInput(input) : null;
-                const parsed = target !== null ? parseRolePauseInput(input) : parsePauseInput(input);
-                if (wakeParsed) {
-                    if (!wakeParsed.ok) {
-                        flashMessage(wakeParsed.error);
-                    }
-                    else {
-                        try {
-                            const message = wakeParsed.cancel ? cancelWakes(root, target) : requestWake(root, [target], wakeParsed.inMs);
-                            exitPauseEditMode();
-                            flashMessage(message);
-                        }
-                        catch (err) {
-                            flashError(err);
-                        }
-                    }
-                }
-                else if (!parsed.ok) {
-                    flashMessage(parsed.error);
-                }
-                else if (target !== null) {
-                    try {
-                        const at = now();
-                        const until = parsed.forMs === undefined ? undefined : at + parsed.forMs;
-                        const changed = pauseRole(root, target, until);
-                        exitPauseEditMode();
-                        flashMessage(rolePauseMessage(root, target, changed, until === undefined ? undefined : { ms: parsed.forMs, untilMs: until }, at));
-                    }
-                    catch (err) {
-                        flashError(err);
-                    }
-                }
-                else {
-                    const fleet = parsed;
-                    try {
-                        const until = fleet.forMs === undefined ? undefined : now() + fleet.forMs;
-                        const changed = pauseFleet(root, until, fleet.reason);
-                        exitPauseEditMode();
-                        const forSuffix = fleet.forMs === undefined ? "" : ` for ${durationLabel(fleet.forMs)}`;
-                        flashMessage(changed || until !== undefined
-                            ? `${fleetPausePhrase()}${forSuffix}${changed && fleet.reason ? `: ${fleet.reason}` : ""}`
-                            : "fleet is already paused");
-                    }
-                    catch (err) {
-                        flashError(err);
-                    }
-                }
-            }
-            else if (deferMode) {
-                // Enter in defer mode parses the duration: empty clears the pending delay (deliver
-                // now), a valid value stores the session duration (applied as now() + deferMs at
-                // submit), and an invalid spelling or an over-cap value flashes and STAYS in the
-                // editor so the operator can fix it. Either way the saved draft is restored.
-                const parsed = parseDeferInput(input);
-                if (!parsed.ok) {
-                    flashMessage(parsed.error);
-                }
-                else {
-                    deferMs = parsed.ms;
-                    exitDeferMode();
-                    flashMessage(deferMs === null ? "defer cleared" : `next prompt delivers in ${durationLabel(deferMs)}`);
-                }
-            }
-            else if (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 fleet'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
-                // below honors; success restores the saved draft.
-                const parsed = parseRolePromptInput(input);
-                if (!parsed.ok) {
-                    flashMessage(parsed.error);
-                }
-                else {
-                    const role = rolePromptFor;
-                    try {
-                        const pending = deferMs;
-                        submitRolePromptAndWake(root, role, parsed.value, undefined, pending === null ? undefined : now() + pending);
-                        promptHistory = pushPromptHistory(promptHistory, parsed.value);
-                        deferMs = null;
-                        exitRolePromptMode();
-                        flashMessage(pending === null
-                            ? `queued for the ${role} loop`
-                            : `queued for the ${role} loop — delivers in ${durationLabel(pending)}`);
-                    }
-                    catch (err) {
-                        flashError(err);
-                    }
-                }
-            }
-            else if (entryEditFor) {
-                // Enter saves the new title through tryEditEntry with the body re-read now, so a
-                // concurrent body edit is not clobbered by a stale copy. The entry is matched by flat
-                // index and title; a mismatch is treated as moved without writing. A blank title and a
-                // throw flash and STAY in the editor so the text survives.
-                const target = entryEditFor;
-                if (!input.trim()) {
-                    flashMessage("an entry needs a title");
-                }
-                else if (target.position === null) {
-                    // New entry (Ctrl+N): file by title with an empty body and wake its loop, the same
-                    // steps handleBacklogFile takes; a length problem or a throw stays in the editor.
-                    try {
-                        const { role, wakeText } = OPERATOR_FILE_KINDS[target.kind];
-                        const problem = promptLengthProblem(wakeText(collapseWhitespace(input)), role);
-                        if (problem) {
-                            flashMessage(problem);
-                        }
-                        else {
-                            const filed = fileEntryWithBody(root, target.kind, input, "");
-                            submitRolePromptAndWake(root, role, wakeText(filed.title));
-                            exitEntryEdit();
-                            flashMessage(`filed ${target.kind}: ${filed.title} — woke ${role}`);
-                        }
-                    }
-                    catch (err) {
-                        flashError(err);
-                    }
-                }
-                else {
-                    try {
-                        const entries = flat();
-                        const plans = entries.filter((e) => e.label === "plan").length;
-                        const entry = entries[target.kind === "plan" ? target.position - 1 : plans + target.position - 1];
-                        const outcome = entry?.label === target.kind && entry.title === target.title
-                            ? tryEditEntry(root, target.kind, target.position, target.title, input, entry.body)
-                            : { status: "moved", title: "" };
-                        exitEntryEdit();
-                        if (outcome.status === "edited") {
-                            flashMessage(`edited ${target.kind} #${target.position}: ${outcome.title}`);
-                        }
-                        else {
-                            selectedEntry = null;
-                            entryScroll = 0;
-                            flashMessage(`that ${target.kind} was already removed or moved — nothing edited`);
-                        }
-                    }
-                    catch (err) {
-                        flashError(err);
-                    }
-                }
-            }
-            else if (answerFor) {
-                // Enter records the answer through tryAnswerQuestion, titled so a question that moved
-                // since Ctrl+A is refused. A whitespace-only line, an unclosed fence, and a throw all
-                // flash and STAY in the editor so the text survives; answered and missing/moved both
-                // leave the editor and return the pane to list mode (the entry left the list).
-                const target = answerFor;
-                if (!input.trim()) {
-                    flashMessage("questions answer needs a decision");
-                }
-                else {
-                    try {
-                        const outcome = tryAnswerQuestion(root, target.position, input, target.title);
-                        if (outcome.status === "fenced") {
-                            flashMessage(UNCLOSED_FENCE_MESSAGE);
-                        }
-                        else {
-                            exitAnswerMode();
-                            selectedEntry = null;
-                            flashMessage(outcome.status === "answered"
-                                ? `answered question #${target.position}: ${outcome.title}`
-                                : "that question was already answered or moved — nothing recorded");
-                        }
-                    }
-                    catch (err) {
-                        flashError(err);
-                    }
-                }
-            }
-            else if (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(input);
-                if (!parsed.ok) {
-                    flashMessage(parsed.error);
-                }
-                else {
-                    const target = queuedEditFor;
-                    try {
-                        const outcome = editQueuedFile(root, target.role, target.file, parsed.value);
-                        exitQueuedEdit();
-                        refreshQueued();
-                        flashMessage(outcome.status === "edited"
-                            ? `edited queued prompt for ${target.role}`
-                            : "queued prompt was already gone");
-                    }
-                    catch (err) {
-                        flashError(err);
-                    }
-                }
-            }
-            else {
-                const prompt = input.trim();
-                if (!prompt) {
-                    // Whitespace-only input queues nothing; drop it like an empty line.
-                    input = "";
-                    cursor = 0;
-                }
-                else {
-                    try {
-                        const pending = deferMs;
-                        submitPrompt(root, prompt, undefined, pending === null ? undefined : now() + pending);
-                        promptHistory = pushPromptHistory(promptHistory, prompt);
-                        deferMs = null;
-                        input = "";
-                        cursor = 0;
-                        flashMessage(pending === null
-                            ? "queued for the director loop"
-                            : `queued for the director loop — delivers in ${durationLabel(pending)}`);
-                    }
-                    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.
-                        flashError(err);
-                    }
-                }
-            }
-        }
-        else {
-            const next = applyKey(input, cursor, str, key);
-            input = next.text;
-            cursor = next.cursor;
-        }
+        editors.apply(str, key);
         deps.requestRender();
     };
     return {
         handleKey,
         syncSnapshot(capUsd, budgetFree, roles, directorRunning = false) {
-            currentCapUsd = capUsd;
-            currentBudgetFree = budgetFree;
-            const previousCount = roleIds.length;
-            roleIds = roles;
+            editors.sync(capUsd, budgetFree);
             directorInFlight = directorRunning;
-            // The panes from project status on are anchored at roleIds.length, so a roster-size
-            // change moves every one of their indices by the same delta: shift the view with them,
-            // or an unadjusted index silently renames to a different pane while its cached body
-            // stays, showing the wrong body under the tab now selected. A transcript view
-            // (1..previousCount) keeps its index — it does not depend on the roster size — and the
-            // clamp below handles one the shrunken roster no longer has.
-            if (roleIds.length !== previousCount && view > previousCount)
-                view += roleIds.length - previousCount;
-            view = Math.min(view, roleIds.length + 6); // clamp a stale index if roles changed
-            // A retired or renamed loop must not leave the report panes silently scoped to an
-            // absent role — drop the scope with the stale view index. The tab strip and hint then
-            // read "fleet", so a report pane still on screen must recompute its cached Markdown
-            // from the fleet-wide collector (and re-enter at the body's head) to match; the other
-            // views compute with the scope on their next Ctrl+T.
-            if (scopeRole !== null && !roleIds.includes(scopeRole)) {
-                scopeRole = null;
-                refreshPaneCache("report");
-            }
-            // The same drop for History's exact-loop scope: a retired or renamed loop must not keep
-            // labeling an empty pane. An on-screen History pane recomputes from the fleet-wide read
-            // so its rows and its `role:` header clear together.
-            if (historyRole !== null && !roleIds.includes(historyRole)) {
-                historyRole = null;
-                refreshPaneCache("history");
-                // The retired scope may have been feeding an on-screen trail: re-read it from the
-                // fleet so the pane and the tab strip cannot name a loop the roster no longer has.
-                if (trailMode)
-                    refreshTrail();
-            }
-            // The same drop for the Activity feed's exact-loop scope: a retired or renamed loop must
-            // not leave the pane filtering on an id the roster no longer names. The scroll resets
-            // with it — the offset indexed the old filtered list.
-            if (activityRole !== null && !roleIds.includes(activityRole)) {
-                activityRole = null;
-                activityScroll = null;
-            }
-        },
-        setLineBudgets(evBudget, enBudget) {
-            eventBudget = evBudget;
-            entryBudget = enBudget;
+            panes.syncRoster(roles);
         },
+        setLineBudgets: panes.setLineBudgets,
         state() {
             return {
-                input,
-                cursor,
-                budgetMode,
-                rolePromptFor,
-                deferMode,
-                pauseEditMode,
-                pauseEditRole,
-                pauseEditWake,
-                defer: deferMs === null ? null : durationLabel(deferMs),
-                view,
-                scopeRole,
-                historyRole,
-                selectedEntry,
-                cancelArmed,
-                entryScroll,
-                selectedQueued,
-                queuedEditFor,
-                answerFor,
-                entryEditFor,
-                queuedRows,
-                paneCache,
-                noteMode,
-                noteCache,
-                trailMode,
-                trailCache,
-                changeMode,
-                changeCache,
-                paneScroll,
-                activityScroll,
-                activityRole,
-                activityGrep,
-                historySince: historyWindow === null ? null : cycleLabel(HISTORY_WINDOWS, historyWindow),
-                reportSince: reportWindow === null ? null : cycleLabel(REPORT_WINDOWS, reportWindow),
-                historyResult: cycleLabel(HISTORY_RESULTS, historyResult),
-                historyGrep,
-                eventBudget,
-                entryBudget,
-                roleIds,
+                ...editors.state(),
+                ...panes.state(),
                 directorInFlight,
                 flash: flash && now() < flashUntil ? flash : null,
             };