tumwater 0.4.2 → 0.4.3

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

@@ -4,6 +4,8 @@ import { movePromptToTop } from "../../inbox/inbox-top.js";
 import { moveEntrySelection } from "./tui-backlog.js";
 import { arrowDir } from "./tui-keymap.js";
 import { promptLineFree } from "./tui-pane-ctx.js";
+import { guardError } from "./tui-guard.js";
+import { paneAtHead } from "./tui-pane-session.js";
 /** The Queued pane (view roleIds.length + 6) of the TUI (src/ui/tui/tui.tsx): the prompt row
  * selection, the up/down select and Esc-to-list arms, and the Ctrl+X cancel and Ctrl+V
  * move-to-top arms. Split out of the pane-navigation monolith; it owns the pane's
@@ -41,11 +43,11 @@ export function createQueuedPane(session) {
     // (`tumwater prompt --cancel <n> --role <id>`): cancelRolePrompt removes that role's Nth
     // queue file and logs the prompt_cancelled event, so the pane, the CLI, and the dashboard
     // cancel cannot drift. It then re-reads the queue so the pane's list and rows reflect the
-    // removal and the selection clamps. Its write and flash stay under one try/catch; the
-    // caller guards on the row being defined (a no-selection list-mode press, or any other
-    // view, leaves the queue untouched).
+    // removal and the selection clamps. Its write and flash stay under one guard; the caller
+    // guards on the row being defined (a no-selection list-mode press, or any other view,
+    // leaves the queue untouched).
     const cancelQueuedRow = (row) => {
-        try {
+        guardError(session, () => {
             const outcome = cancelRolePrompt(session.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.
@@ -53,21 +55,18 @@ export function createQueuedPane(session) {
                 ? `cancelled inbox message #${row.position} for ${row.role}`
                 : `inbox message #${row.position} for ${row.role} was already gone`);
             refreshQueued();
-        }
-        catch (err) {
-            session.flashError(err);
-        }
+        });
     };
     // Ctrl+V moves the selected queued prompt to the head of its role's queue through the
     // CLI's own per-role path (`tumwater prompt --top <n>`): movePromptToTop renames that
     // role's Nth queue file to the head and logs the prompt_topped event, so the pane, the
     // CLI, and the dashboard cannot drift. A position-1 row is already the head (a no-op); a
     // gone outcome is the concurrent-dequeue race (movePromptToTop's own contract), not a
-    // failure, so flash it honestly. Its write and flash stay under one try/catch; the caller
+    // failure, so flash it honestly. Its write and flash stay under one guard; the caller
     // guards on the row being defined (a no-selection list-mode press, or any other view,
     // leaves the queues untouched).
     const moveQueuedRow = (row) => {
-        try {
+        guardError(session, () => {
             if (row.position === 1) {
                 // A head row is a no-op, not movePromptToTop's throw: it is already where the
                 // reorder would put it, and throwing would flash an error for a press that
@@ -81,30 +80,30 @@ export function createQueuedPane(session) {
             session.flashMessage(outcome.status === "topped"
                 ? `moved inbox message #${row.position} for ${row.role} to the top: ${outcome.preview}`
                 : `inbox message #${row.position} for ${row.role} was already gone`);
-        }
-        catch (err) {
-            session.flashError(err);
-        }
+        });
     };
-    const handleKey = (key, ctx) => {
-        if (key.ctrl && key.name === "x" &&
+    // Ctrl+X cancels the selected queued prompt and Ctrl+V moves it to its role queue's head,
+    // each through the CLI's own per-role path (cancelRolePrompt / movePromptToTop). The two
+    // arms share one shape — a guarded ctrl-keypress that resolves the clamped selected row,
+    // runs cancel or move, and repaints — differing only in the key and the action, so one
+    // helper owns the guard, the clamp, and the render.
+    const handleQueuedRowAction = (key, ctx, keyName, action) => {
+        if (key.ctrl && key.name === keyName &&
             promptLineFree(ctx.es) &&
             session.view === session.roleIds.length + 6 && selectedQueued !== null) {
             const row = queuedRows[Math.min(selectedQueued, queuedRows.length - 1)];
             if (row !== undefined)
-                cancelQueuedRow(row);
+                action(row);
             session.requestRender();
             return true;
         }
-        if (key.ctrl && key.name === "v" &&
-            promptLineFree(ctx.es) &&
-            session.view === session.roleIds.length + 6 && selectedQueued !== null) {
-            const row = queuedRows[Math.min(selectedQueued, queuedRows.length - 1)];
-            if (row !== undefined)
-                moveQueuedRow(row);
-            session.requestRender();
+        return false;
+    };
+    const handleKey = (key, ctx) => {
+        if (handleQueuedRowAction(key, ctx, "x", cancelQueuedRow))
+            return true;
+        if (handleQueuedRowAction(key, ctx, "v", moveQueuedRow))
             return true;
-        }
         const arrow = arrowDir(key.name);
         if (session.view === session.roleIds.length + 6 && arrow !== null) {
             // In the Queued pane, up/down select a queued prompt row in full (wrapping, the backlog
@@ -129,8 +128,7 @@ export function createQueuedPane(session) {
             // 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;
-            session.paneScroll = 0;
-            session.requestRender();
+            paneAtHead(session);
             return true;
         }
         return false;

package/dist/src/ui/tui/tui-pane-report.js

@@ -1,6 +1,7 @@
 import { collectReport } from "../../report/report-data.js";
 import { collectReportSince } from "../../report/report-since-data.js";
-import { renderReportMarkdown, renderSinceReportMarkdown } from "../../report/report-render.js";
+import { renderReportMarkdown } from "../../report/report-render.js";
+import { renderSinceReportMarkdown } from "../../report/report-since-render.js";
 import { REPORT_DEFAULT_DAYS, REPORT_SINCE_MAX_MS } from "../../events/event-window.js";
 import { collectFailureReport, collectFailureReportSince } from "../../failure/failure-data.js";
 import { renderFailureMarkdown } from "../../failure/failure-render.js";

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

@@ -1,6 +1,7 @@
 import { REPORT_SINCE_MAX_MS } from "../../events/event-window.js";
 import { HISTORY_RESULT_CLASSES, HISTORY_RESULT_FLAG_NAMES } from "../../history/history-data.js";
 import { baseRoleOf } from "../../roles/runner-ids.js";
+import { distinctOrdered } from "../../collections.js";
 /** 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. */
@@ -40,13 +41,7 @@ export const HISTORY_WINDOWS = [
  * 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. */
 export function scopeCycle(roleIds) {
-    const bases = [];
-    for (const id of roleIds) {
-        const base = baseRoleOf(id);
-        if (!bases.includes(base))
-            bases.push(base);
-    }
-    return [null, ...bases];
+    return [null, ...distinctOrdered(roleIds.map((id) => baseRoleOf(id)))];
 }
 /** The History pane's session outcome cycle, Ctrl+O: all runs, then the canonical classes
  * `tumwater history --result` and the dashboard's History filter speak. The class list comes
@@ -131,3 +126,12 @@ export function createTuiPaneSession(deps) {
         runPatch: deps.runPatch,
     };
 }
+/** Re-enter the active pane at its head: reset the shared within-body scroll offset to the top
+ * and repaint. The panes' key-handler and refresh arms reset the scroll and request a render
+ * together every time they return a view to its start, so this single helper keeps that pair
+ * from drifting — and names the intent (the pane starts at its head) once instead of at each
+ * call site. A key-handler caller that consumed the key follows with its own `return true`. */
+export function paneAtHead(session) {
+    session.paneScroll = 0;
+    session.requestRender();
+}

package/dist/src/ui/tui/tui-pane-transcript.js

@@ -3,17 +3,19 @@ import { roleNotesPath } from "../../paths.js";
 import { renderRoleChange } from "../../change/change-render.js";
 import { readMergeQueue } from "../../merge/merge-queue.js";
 import { renderMergeQueue, scopeMergeQueue } from "../../merge/merge-queue-render.js";
-import { orchestratorAlive } from "../../team/orchestrator-info.js";
+import { orchestratorAlive } from "../../team/team-orchestrator-info.js";
 import { queueInFlight } from "../../status/status-polls.js";
 import { roleInspectMarkdown } from "./tui-pane.js";
 import { pageMarkdownBody } from "./tui-backlog.js";
 import { pageDir } from "./tui-keymap.js";
 import { promptLineFree } from "./tui-pane-ctx.js";
+import { guardError } from "./tui-guard.js";
+import { paneAtHead } from "./tui-pane-session.js";
 /** The per-role transcript panes (views 1..roleIds.length) of the TUI: the Ctrl+N
- * transcript→notes→change cycle and its two-step Ctrl+X notes-clear arm, plus the
- * notes/change PgUp/PgDn body window, and the `/` search over the live transcript step. Split
- * out of the pane-navigation monolith; it owns the notes/change mode state and the arms that
- * touch them. */
+ * transcript→notes→change cycle and its two-step Ctrl+X notes-clear arm, the Ctrl+Y
+ * change-diff toggle, plus the notes/change PgUp/PgDn body window, and the `/` search over
+ * the live transcript step. Split out of the pane-navigation monolith; it owns the
+ * notes/change mode state and the arms that touch them. */
 export function createTranscriptPane(session) {
     // Ctrl+N toggles the viewed role's pane between its live transcript and a read-only
     // notes view (its note and next run's prompt). Like paneCache, noteCache is computed
@@ -53,17 +55,13 @@ export function createTranscriptPane(session) {
         const target = role;
         // The role's waiting merges head the change, exact-matching this one runner id.
         let queueText = "";
-        try {
+        guardError(session, () => {
             const { view, scope } = scopeMergeQueue(readMergeQueue(session.root), [role], (r) => r === role);
             if (view.entries.length > 0) {
                 const inFlight = queueInFlight(session.root, view.entries, orchestratorAlive(session.root));
                 queueText = renderMergeQueue(view, session.now(), inFlight, scope) + "\n\n";
             }
-        }
-        catch (err) {
-            queueText = "";
-            session.flashError(err);
-        }
+        });
         void session.collectChange(session.root, target, changeStat ? { stat: true } : undefined).then((change) => {
             // changeGen drops a load superseded by a re-load or a leave; the role match drops one
             // a roster change (syncRoster mutates session.roleIds without resetting this pane)
@@ -83,9 +81,8 @@ export function createTranscriptPane(session) {
     // because routeCtrlN in tui-panes.ts routes it last and relies on this pane consuming
     // Ctrl+N as the fallback.
     const transcriptCycle = (ctx) => {
-        // Ctrl+N cycles the viewed role's pane live transcript → notes → 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
+        // Ctrl+N cycles the viewed role's pane live transcript → notes → change → transcript.
+        // 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-role controls below are; the History view's
@@ -123,17 +120,13 @@ export function createTranscriptPane(session) {
             // rolePayload reads the notes and assembles the next run'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 = null;
+            guardError(session, () => {
                 noteCache = roleInspectMarkdown(session.root, role);
                 noteMode = true;
-            }
-            catch (err) {
-                noteCache = null;
-                session.flashError(err);
-            }
+            });
         }
-        session.paneScroll = 0; // either way the pane starts at its head
-        session.requestRender();
+        paneAtHead(session);
         return true;
     };
     // The Ctrl+Y diffstat toggle, live only on the change step (mnemonic: summarY). Returns
@@ -166,14 +159,11 @@ export function createTranscriptPane(session) {
         }
         const role = viewedRole();
         if (session.armedNotes === role) {
-            try {
+            guardError(session, () => {
                 session.flashMessage(`${role}: ${saveRoleNote(roleNotesPath(session.root, role), "")}`);
                 noteCache = roleInspectMarkdown(session.root, role);
                 session.paneScroll = 0;
-            }
-            catch (err) {
-                session.flashError(err);
-            }
+            });
         }
         else {
             session.notesClearArmed = role;
@@ -216,8 +206,7 @@ export function createTranscriptPane(session) {
             if (!noteMode || viewedRole() !== role)
                 return;
             noteCache = roleInspectMarkdown(session.root, role);
-            session.paneScroll = 0;
-            session.requestRender();
+            paneAtHead(session);
         },
         reset() {
             // A cycle away leaves notes and change modes and drops their snapshots; changeGen
@@ -238,8 +227,7 @@ export function createTranscriptPane(session) {
             if (session.view < 1 || session.view > session.roleIds.length)
                 return;
             transcriptSearch = pattern === null ? null : { role: viewedRole(), pattern };
-            session.paneScroll = 0;
-            session.requestRender();
+            paneAtHead(session);
         },
         state() {
             const transcriptGrep = transcriptSearch !== null && viewedRole() === transcriptSearch.role

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

@@ -11,7 +11,7 @@ import { eventMatchesGrep, eventResult, formatEvent } from "../../events/event-f
 import { eventTypeLabel } from "../../events/event-labels.js";
 import { eventTypeTally } from "../../events/event-tally.js";
 import { backlogLines, entryBodyWindow, browsableBacklogEntries, isOpenBacklogLabel, planListLines } from "./tui-backlog.js";
-import { answeredQuestionSummaries } from "../../backlog/question-answer.js";
+import { answeredQuestionSummaries } from "../../backlog/backlog-question-answer.js";
 import { DASHBOARD_ANSWERED_QUESTIONS, recentFinished } from "../status-payload.js";
 import { donePlanEntries, DONE_DATE_RE, entryMatches, FIXED_DATE_RE, fixedBugEntries } from "../../backlog/backlog.js";
 import { isNotableEvent } from "../tone.js";
@@ -42,6 +42,14 @@ export function activityEvents(root, role, grep, type, notable = false) {
 export function roleInspectMarkdown(root, role) {
     return inspectMarkdownLines(rolePayload(root, role), Date.now()).join("\n");
 }
+/** The pane's cached body windowed to its clipped lines, or no lines while the cache is still
+ * null (the async collector has not resolved yet) — so the frame prints the pane's own
+ * loading/empty note rather than entryBodyWindow's "(no details for this entry)" placeholder.
+ * Shared by the history, pending, health, brief, and queued panes, whose bodies differ only in
+ * that note, so the null-cache shape cannot drift between them. */
+function paneCacheLines(state, budget, width) {
+    return state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, budget, width).lines : [];
+}
 /** Compose the body lines for one pane at this frame's width and budgets. Same rules
  * tui.tsx's inline builder followed: transcripts keep the tail, the backlog list keeps
  * the head with the selected entry's full body in entry mode, usage/failures re-window
@@ -187,9 +195,8 @@ function historyBody(pane, opts) {
     // historyPaneText returns "" when the log holds no completed runs; return no lines
     // (rather than windowing an empty string, which entryBodyWindow replaces with its
     // "no details" placeholder) so the frame prints the pane's own empty note instead.
-    const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, eventBudget, width) : { lines: [] };
     return {
-        body: win.lines.map((l) => toneLine(l, width)),
+        body: paneCacheLines(state, eventBudget, width).map((l) => toneLine(l, width)),
         emptyNote: "(no runs yet)",
     };
 }
@@ -207,25 +214,22 @@ function pendingBody(_pane, opts) {
             emptyNote: "(loading pending changes…)",
         };
     }
-    const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, eventBudget, width) : { lines: [] };
     return {
-        body: win.lines.map((l) => toneLine(l, width)),
+        body: paneCacheLines(state, eventBudget, width).map((l) => toneLine(l, width)),
         emptyNote: "(loading pending changes…)",
     };
 }
 function healthBody(_pane, opts) {
     const { width, eventBudget, state } = opts;
-    const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, eventBudget, width) : { lines: [] };
     return {
-        body: win.lines.map((l) => toneLine(l, width)),
+        body: paneCacheLines(state, eventBudget, width).map((l) => toneLine(l, width)),
         emptyNote: "(running health checks…)",
     };
 }
 function briefBody(_pane, opts) {
     const { width, eventBudget, state } = opts;
-    const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, eventBudget, width) : { lines: [] };
     return {
-        body: win.lines.map((l) => toneLine(l, width)),
+        body: paneCacheLines(state, eventBudget, width).map((l) => toneLine(l, width)),
         emptyNote: "(no project brief with a prompt block — run `tumwater init` first)",
     };
 }
@@ -257,9 +261,8 @@ function queuedBody(pane, opts) {
         return { body: [...searchLine, toneLine(`(no queued prompt matches "${pane.grep}")`, width)], emptyNote: "(inbox empty)" };
     }
     const listBudget = Math.max(1, eventBudget - searchLine.length);
-    const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, listBudget, width) : { lines: [] };
     return {
-        body: [...searchLine, ...win.lines.map((l) => toneLine(l, width))],
+        body: [...searchLine, ...paneCacheLines(state, listBudget, width).map((l) => toneLine(l, width))],
         emptyNote: "(inbox empty)",
     };
 }

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

@@ -318,6 +318,32 @@ export function createTuiPanes(deps) {
             return true;
         return queued.handleKey?.(key, ctx) ?? false;
     };
+    /** The ordered Ctrl dispatch table: each letter a pane router serves maps to its handler. */
+    const ctrlRoutes = {
+        n: routeCtrlN,
+        g: routeCtrlG,
+        e: routeCtrlE,
+        k: routeCtrlK,
+        w: routeCtrlW,
+        s: routeCtrlS,
+        p: routeCtrlP,
+        a: routeCtrlA,
+        u: routeCtrlU,
+        b: routeCtrlB,
+        l: routeCtrlL,
+        y: routeCtrlY,
+        o: routeCtrlO,
+        x: routeCtrlX,
+        r: routeCtrlR,
+        v: routeCtrlV,
+    };
+    /** Look up one bound Ctrl key in `ctrlRoutes`; null when the key is not a bound Ctrl chord. */
+    const ctrlRoute = (key, ctx) => {
+        if (!key.ctrl || key.name === undefined)
+            return null;
+        const route = ctrlRoutes[key.name];
+        return route === undefined ? null : route(key, ctx);
+    };
     /** Run the pane arms of the key dispatch; true when one consumed the key. `es` is the
      * editors' state, so the exclusion guards read the flags the editors hold. Each pane module
      * checks its own view/guard and returns true only when it consumed the key; this router keeps
@@ -327,38 +353,9 @@ export function createTuiPanes(deps) {
         // writes the line and return true whenever one is open — but each module restates its
         // mutual-exclusion guard so it reads on its own instead of leaning on the routing order.
         const ctx = { es };
-        if (key.ctrl && key.name === "n")
-            return routeCtrlN(key, ctx);
-        if (key.ctrl && key.name === "g")
-            return routeCtrlG(key, ctx);
-        if (key.ctrl && key.name === "e")
-            return routeCtrlE(key, ctx);
-        if (key.ctrl && key.name === "k")
-            return routeCtrlK(key, ctx);
-        if (key.ctrl && key.name === "w")
-            return routeCtrlW(key, ctx);
-        if (key.ctrl && key.name === "s")
-            return routeCtrlS(key, ctx);
-        if (key.ctrl && key.name === "p")
-            return routeCtrlP(key, ctx);
-        if (key.ctrl && key.name === "a")
-            return routeCtrlA(key, ctx);
-        if (key.ctrl && key.name === "u")
-            return routeCtrlU(key, ctx);
-        if (key.ctrl && key.name === "b")
-            return routeCtrlB(key, ctx);
-        if (key.ctrl && key.name === "l")
-            return routeCtrlL(key, ctx);
-        if (key.ctrl && key.name === "y")
-            return routeCtrlY(key, ctx);
-        if (key.ctrl && key.name === "o")
-            return routeCtrlO(key, ctx);
-        if (key.ctrl && key.name === "x")
-            return routeCtrlX(key, ctx);
-        if (key.ctrl && key.name === "r")
-            return routeCtrlR(key, ctx);
-        if (key.ctrl && key.name === "v")
-            return routeCtrlV(key, ctx);
+        const ctrl = ctrlRoute(key, ctx);
+        if (ctrl !== null)
+            return ctrl;
         const arrow = arrowDir(key.name);
         if (arrow !== null)
             return routeArrow(key, ctx);

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

@@ -3,12 +3,11 @@ import { render as inkRender } from "ink";
 import { TuiApp } from "./tui-app.js";
 import { openQuestions } from "../../backlog/backlog.js";
 import { refusedEntries, stalledEntries } from "../../backlog/backlog-eligibility.js";
-import { capacityContention, instancePoolProblems, planDependencyAlert, providerCapProblems, regressedFixesAlert, staleOpenQuestions, staleWorkspacePins } from "../alert-feeds.js";
+import { getOrphanAlert, planDependencyAlert, staleOpenQuestions } from "../alert-feeds.js";
 import { strandedPlanEntriesFor } from "../../backlog/backlog-structure.js";
 import { duplicatedBacklogHeadings, fixClaimProblems, liveFinishedEntriesFor, validationGapProblems } from "../../doctor/doctor-backlog-plans.js";
 import { snapshot } from "../../status/status-data.js";
 import { renderStatusSpans } from "../status-render.js";
-import { staleClaimEntries } from "../../scheduling/claim-entries.js";
 import { teamAlerts } from "../team-alerts.js";
 import { captureStartupBuild, createReloadWatch, reexecSelf, watchReloadSupervisor, } from "../../redeploy/self-reload.js";
 import { renderInputView, tuiTerminalError, } from "./tui-input.js";
@@ -93,7 +92,7 @@ export async function runTui(root, seams = {}) {
         const view = s.view;
         // What needs the operator — the dashboard's alert banners (team-alerts.ts's teamAlerts), as
         // attention lines under the header. Each consumes one line of the height budget.
-        const attention = alertLines(teamAlerts(snap, openQuestions(root), status.roles, Date.now(), refusedEntries(root), planDependencyAlert(root), stalledEntries(root), strandedPlanEntriesFor(root), duplicatedBacklogHeadings(root), validationGapProblems(root), capacityContention(root), regressedFixesAlert(root, Date.now()), staleClaimEntries(root, status.roles.map((r) => r.role), Date.now()), staleOpenQuestions(root), fixClaimProblems(root), staleWorkspacePins(root, Date.now()), liveFinishedEntriesFor(root), instancePoolProblems(root), providerCapProblems(root)), width);
+        const attention = alertLines(teamAlerts(snap, openQuestions(root), status.roles, Date.now(), refusedEntries(root), planDependencyAlert(root), stalledEntries(root), strandedPlanEntriesFor(root), duplicatedBacklogHeadings(root), validationGapProblems(root), staleOpenQuestions(root), fixClaimProblems(root), liveFinishedEntriesFor(root), getOrphanAlert(root)), width);
         const statusLines = [status.lines[0] ?? [], ...attention, ...status.lines.slice(1)];
         // Numbered previews of prompts queued for the director, between the table and the
         // activity pane: what will run next, in execution order. Each line consumes exactly
@@ -124,7 +123,7 @@ export async function runTui(root, seams = {}) {
         // The frame as the ink tree draws it (tui-app.tsx): the same composed lines the
         // hand-painted string frame joined, as clipped StatusLines — one column row per line,
         // one styled Text per span, colors through tui-app.tsx's toneColor.
-        const mode = { budget: s.budgetMode, concurrencyMode: s.concurrencyMode, checksMode: s.checksMode, checkMode: s.checkMode, fallbackMode: s.fallbackMode, modelMode: s.modelMode, rolePromptFor: s.rolePromptFor, attachMode: s.attachMode, pauseEditMode: s.pauseEditMode, pauseEditRole: s.pauseEditRole, pauseEditWake: s.pauseEditWake, pauseEditStop: s.pauseEditStop, queuedEditFor: s.queuedEditFor, answerFor: s.answerFor, entryEditFor: s.entryEditFor, notesEditFor: s.notesEditFor, briefEditMode: s.briefEditMode, retireMode: s.retireMode, releaseMode: s.releaseMode, roleEnabledMode: s.roleEnabledMode, quietMode: s.quietMode, quietTeam: s.quietTeam, providerCapsMode: s.providerCapsMode, claudeReserveMode: s.claudeReserveMode, intervalMode: s.intervalMode, roleModelMode: s.roleModelMode, instructionsEditFor: s.instructionsEditFor, slotsMode: s.slotsMode, images: s.images, notifyMode: s.notifyMode, backendsMode: s.backendsMode, instancesMode: s.instancesMode };
+        const mode = { budget: s.budgetMode, concurrencyMode: s.concurrencyMode, checksMode: s.checksMode, checkMode: s.checkMode, fallbackMode: s.fallbackMode, modelMode: s.modelMode, rolePromptFor: s.rolePromptFor, attachMode: s.attachMode, pauseEditMode: s.pauseEditMode, pauseEditRole: s.pauseEditRole, pauseEditWake: s.pauseEditWake, pauseEditStop: s.pauseEditStop, queuedEditFor: s.queuedEditFor, answerFor: s.answerFor, entryEditFor: s.entryEditFor, notesEditFor: s.notesEditFor, briefEditMode: s.briefEditMode, retireMode: s.retireMode, releaseMode: s.releaseMode, roleEnabledMode: s.roleEnabledMode, quietMode: s.quietMode, quietTeam: s.quietTeam, intervalMode: s.intervalMode, roleModelMode: s.roleModelMode, instructionsEditFor: s.instructionsEditFor, slotsMode: s.slotsMode, images: s.images, notifyMode: s.notifyMode, backendsMode: s.backendsMode, instancesMode: s.instancesMode };
         const lines = [...statusLines, []]; // a blank row below the header
         for (const [i, preview] of queued.entries())
             lines.push(toneLine(`${i + 1}. ${preview}`, width));