tumwater 0.2.0 → 0.3.0

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

@@ -1,30 +1,37 @@
-// vocabulary: plain
 import { setConfigKey, unsetConfigKey } from "../../config/config-write.js";
 import { loadConfigSafe } from "../../config/config.js";
 import { DIRECTOR_ROLE } from "../../roles/roles.js";
-import { baseRoleOf } from "../../roles/loop-ids.js";
-/** The Ctrl+O quiet-hours editor on the shared prompt line, the terminal twin of the dashboard
- * role drawer's `Quiet hours` row and `tumwater role <id> --quiet-hours`. It owns its mode
- * flag, its saved-draft pair, and the role pinned when it opened, so a roster shift cannot
- * redirect the write. Enter writes through the shared setConfigKey/unsetConfigKey family the
- * CLI and the drawer use — so checkQuietHours (naming `quietHoursPerRole.<id>`) and
- * validateConfig own the window's truth — and Esc, Ctrl+O again, and Ctrl+T cancel by
- * restoring the prompt draft. Mutually exclusive with the other editors on the one prompt
- * line via the session's held registry. */
+import { baseRoleOf } from "../../roles/runner-ids.js";
+/** The Ctrl+O per-role / Ctrl+S team-wide quiet-hours editor on the shared prompt line, the
+ * terminal twin of the dashboard's `Quiet hours` rows and `tumwater role <id> --quiet-hours`
+ * / `tumwater config set quietHours`. It owns its mode flags, its saved-draft pair, and the
+ * role pinned when it opened (per-role scope only), so a roster shift cannot redirect the
+ * write. Enter writes through the shared setConfigKey/unsetConfigKey family the CLI and the
+ * drawer use — so checkQuietHours (naming `quietHoursPerRole.<id>`) and validateConfig (naming
+ * `quietHours` for the team key) own the window's truth — and Esc, the matching Ctrl again,
+ * and Ctrl+T cancel by restoring the prompt draft. Mutually exclusive with the other editors
+ * on the one prompt line via the session's held registry. The two scopes never overlap: Ctrl+O
+ * opens only on a role's Transcript and toggles only the per-role scope, Ctrl+S only on the
+ * Activity view and toggles only the team scope, so a view change cannot leave a half-open
+ * editor pointing at the wrong window. */
 export function createQuietEditor(session) {
     let quietMode = false;
-    let savedInput = "";
-    let savedCursor = 0;
-    // The role scope pinned when the editor opened, so Enter writes the same role's window even
-    // if syncRoster shrinks or reorders the roster while the editor is open.
+    let quietTeam = false;
+    let restoreDraft = () => { };
+    // The role scope pinned when the editor opened (per-role scope only), so Enter writes the
+    // same role's window even if syncRoster shrinks or reorders the roster while the editor is
+    // open. The team scope pins no role: it writes the top-level `quietHours` key.
     let lockedRole = null;
-    // Leave quiet-edit mode (Esc, Ctrl+O again, or Ctrl+T): restore the saved prompt text.
+    // Leave quiet-edit mode (Esc, the matching Ctrl again, or Ctrl+T): restore the saved prompt
+    // text. Clears both scope flags; the caller's arm decides which scope to wake next.
     const exitQuietMode = () => {
         if (!quietMode)
             return;
         quietMode = false;
+        quietTeam = false;
         session.held.quiet = false;
-        session.restorePromptFrom(savedInput, savedCursor);
+        session.held.quietTeam = false;
+        restoreDraft();
         lockedRole = null;
     };
     const handleKey = (_str, key, ctx) => {
@@ -33,11 +40,19 @@ export function createQuietEditor(session) {
             // hours) on its Transcript view. Every non-transcript view keeps Ctrl+O — the guard
             // lets the key fall through to the pane arms (Activity's event-type cycle, History's
             // outcome cycle, Health's problems-only toggle) unless the quiet editor already holds
-            // the line, in which case Ctrl+O is the toggle-out arm below. Entering pre-fills the
-            // window from `quietHoursPerRole.<base>` (empty when unset — empty means "off" on
-            // save) and saves the prompt text; leaving restores it. The director is exempt — its
+            // the line. While a scope is open, Ctrl+O toggles only the per-role scope out; in the
+            // team scope it is consumed and does nothing. Entering pre-fills the window from
+            // `quietHoursPerRole.<base>` (empty when unset — empty means "off" on save) and saves
+            // the prompt text; leaving restores it. The director is exempt — its
             // quietHoursPerRole.director entry is inert (the gate and doctor both exempt it).
-            if (!quietMode && !(ctx.view >= 1 && ctx.view <= ctx.roleIds.length))
+            if (quietMode) {
+                // Consumed either way: in the per-role scope it toggles the editor out, in the team
+                // scope Ctrl+O leaves the team editor open.
+                if (!quietTeam)
+                    exitQuietMode();
+                return true;
+            }
+            if (!(ctx.view >= 1 && ctx.view <= ctx.roleIds.length))
                 return false;
             const role = ctx.roleIds[ctx.view - 1];
             const held = session.heldEditorFlash("quiet");
@@ -51,23 +66,62 @@ export function createQuietEditor(session) {
                 session.flashMessage("the director has no quiet hours");
                 return true;
             }
-            if (quietMode) {
-                exitQuietMode();
-                return true;
-            }
             // Pin the role first so the write below is safe against a mid-edit roster shift, then
             // pre-fill from the file's own entry — one fresh read per open is the smallest honest
             // source; a broken config degrades to no pre-fill and the write reports the error.
             lockedRole = role;
             const existing = loadConfigSafe(session.root).config?.quietHoursPerRole?.[baseRoleOf(role)] ?? "";
-            session.settleDraft((t) => (savedInput = t), (n) => (savedCursor = n));
+            restoreDraft = session.takeDraft();
             quietMode = true;
+            quietTeam = false;
             session.held.quiet = true;
+            session.held.quietTeam = false;
             session.input = existing;
             session.cursor = session.input.length;
             session.flashMessage(`edit ${role}'s quiet hours (e.g. 23:00-07:00, empty clears): Enter to save, Esc to cancel`);
             return true;
         }
+        if (key.ctrl && key.name === "s") {
+            // Ctrl+S edits the team-wide quiet-hours window on the Activity view (view 0) — the
+            // terminal twin of the dashboard Settings `quietHours` row and `tumwater config set
+            // quietHours`, so an operator can put the whole team to sleep for a nightly window. On
+            // every non-Activity view Ctrl+S keeps its other meaning — the guard lets the key fall
+            // through to the interval editor (a role's Transcript) and the pane arms (History's
+            // trailing-window cycle). While a scope is open, Ctrl+S toggles only the team scope out;
+            // in the per-role scope it is consumed and does nothing (so it never opens the interval
+            // editor over the quiet editor). Entering pre-fills the window from the FILE's top-level
+            // `quietHours` (empty when unset — empty means "off" on save) and saves the prompt text;
+            // leaving restores it. The team window owns no role, so lockedRole stays null.
+            if (quietMode) {
+                // In the team scope Ctrl+S toggles the editor out. In the per-role scope it must not
+                // touch the per-role editor, but it also must not silently vanish: fall through so the
+                // interval editor (the other Ctrl+S arm, which runs after this one) flashes the way out,
+                // naming the per-role quiet editor as the holder.
+                if (!quietTeam)
+                    return false;
+                exitQuietMode();
+                return true;
+            }
+            if (ctx.view !== 0)
+                return false;
+            const held = session.heldEditorFlash("quiet");
+            if (held) {
+                // Mutually exclusive with the other editors: all share one prompt line, so a mode may
+                // not enter while another holds it. Flash the way out first.
+                session.flashMessage(held);
+                return true;
+            }
+            const existing = loadConfigSafe(session.root).config?.quietHours ?? "";
+            restoreDraft = session.takeDraft();
+            quietMode = true;
+            quietTeam = true;
+            session.held.quiet = true;
+            session.held.quietTeam = true;
+            session.input = existing;
+            session.cursor = session.input.length;
+            session.flashMessage("edit the team's quiet hours (e.g. 23:00-07:00, empty clears): Enter to save, Esc to cancel");
+            return true;
+        }
         if (key.name === "escape" && quietMode) {
             // Esc cancels quiet-edit mode, restoring the previous prompt text.
             exitQuietMode();
@@ -75,22 +129,32 @@ export function createQuietEditor(session) {
         }
         if (key.name === "return" && quietMode) {
             // Enter commits the window through the shared setter family the CLI's `--quiet-hours`
-            // and the dashboard drawer use: an empty or whitespace-only line clears the key
-            // (`unsetConfigKey`), otherwise `setConfigKey` writes the dotted `quietHoursPerRole
-            // .<base>` entry as a JSON string. checkQuietHours (naming the dotted key) rejects a
-            // malformed window and validateConfig guards the write; both write tumwater.json
-            // atomically and the running orchestrator picks the change up on its next poll. An
-            // invalid window flashes and STAYS in edit mode so the operator can fix it; success
-            // restores the saved prompt text.
-            const role = lockedRole;
-            const cfgKey = `quietHoursPerRole.${baseRoleOf(role)}`;
+            // and `tumwater config set quietHours` / the dashboard rows use: an empty or
+            // whitespace-only line clears the key (`unsetConfigKey`), otherwise `setConfigKey` writes
+            // the dotted `quietHoursPerRole.<base>` entry (per-role scope) or the top-level
+            // `quietHours` (team scope) as a JSON string. checkQuietHours (naming the dotted key)
+            // rejects a malformed per-role window and validateConfig guards the team write; both
+            // write tumwater.json atomically and the running orchestrator picks the change up on its
+            // next poll. An invalid window flashes and STAYS in edit mode so the operator can fix
+            // it; success restores the saved prompt text.
+            const cfgKey = quietTeam ? "quietHours" : `quietHoursPerRole.${baseRoleOf(lockedRole)}`;
             const text = session.input.trim();
             const result = text === ""
                 ? unsetConfigKey(session.root, cfgKey)
                 : setConfigKey(session.root, cfgKey, JSON.stringify(text));
             if (result.ok) {
+                const team = quietTeam;
+                const role = lockedRole;
                 exitQuietMode();
-                session.flashMessage(text === "" ? `${role}: quiet hours cleared` : `${role}: quiet hours set to ${text}`);
+                const scope = team ? "team" : `${role}`;
+                const noop = text === "" ? result.oldValue === undefined : "unchanged" in result;
+                session.flashMessage(noop
+                    ? text === ""
+                        ? `${scope}: quiet hours is not set in tumwater.json, so nothing was cleared`
+                        : `${scope}: quiet hours is already ${text}, so tumwater.json was not written`
+                    : text === ""
+                        ? `${scope}: quiet hours cleared`
+                        : `${scope}: quiet hours set to ${text}`);
             }
             else {
                 session.flashMessage(result.error); // broken config or write failure — stay in edit mode

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

@@ -1,4 +1,3 @@
-// vocabulary: plain
 import { artifactPhrase, retireRole } from "../../operator/retire.js";
 /** The Health view's Ctrl+X retire editor on the shared prompt line, the terminal twin of
  * `tumwater retire --role <id>` and the dashboard Settings card's Retire button. It owns its
@@ -12,20 +11,19 @@ import { artifactPhrase, retireRole } from "../../operator/retire.js";
  * so the operator can fix the id, Esc cancels and restores the draft. */
 export function createRetireEditor(session) {
     let retireMode = false;
-    let retireSavedInput = "";
-    let retireSavedCursor = 0;
+    let restoreDraft = () => { };
     // Leave retire-edit mode (Esc, Enter's success path, or Ctrl+T): restore the saved prompt text.
     const exitRetireMode = () => {
         if (!retireMode)
             return;
         retireMode = false;
         session.held.retire = false;
-        session.restorePromptFrom(retireSavedInput, retireSavedCursor);
+        restoreDraft();
     };
     const handleKey = (_str, key, ctx) => {
         if (key.ctrl && key.name === "x" && ctx.view === ctx.roleIds.length + 7 && !retireMode) {
             // Ctrl+X toggles retire-edit mode on the Health view's prompt line (mnemonic: **x**
-            // remove — the same key the Transcript notebook-clear, Backlog cancel, and Inbox cancel
+            // remove — the same key the Transcript notes-clear, Backlog cancel, and Inbox cancel
             // arms use on their own views, guarded away here by the Health index). The line edits one
             // role id; Enter retires that role's leftovers through the same retireRole core the CLI
             // and the dashboard button use. Entering saves the prompt draft and blanks the line;
@@ -41,7 +39,7 @@ export function createRetireEditor(session) {
             // Mid-recall, hand the arrows' saved draft back before the retire editor takes the line —
             // the same settle the role editors do — so leaving restores the draft, not a
             // history entry, with no stale recall state riding along.
-            session.settleDraft((t) => (retireSavedInput = t), (n) => (retireSavedCursor = n));
+            restoreDraft = session.takeDraft();
             retireMode = true;
             session.held.retire = true;
             session.input = "";

package/dist/src/ui/tui/tui-editor-role-key.js

@@ -0,0 +1,76 @@
+import { baseRoleOf } from "../../roles/runner-ids.js";
+/** Build a role-pinned editor. It may take the line only on a role's Transcript view
+ * (view 1..roleIds.length) or when it already holds it (the toggle-out arm), and only while no
+ * other editor holds the line. An invalid value flashes and STAYS in edit mode so the operator
+ * can fix it; success restores the saved prompt text. */
+export function createRoleKeyEditor(session, spec) {
+    let mode = false;
+    let restoreDraft = () => { };
+    // The role pinned when the editor opened, so Enter writes the same role's key even if
+    // syncRoster shrinks or reorders the roster while the editor is open.
+    let lockedRole = null;
+    // Leave the editor (Esc, the key again, or Ctrl+T): restore the saved prompt text.
+    const exit = () => {
+        if (!mode)
+            return;
+        mode = false;
+        session.held[spec.mode] = false;
+        restoreDraft();
+        lockedRole = null;
+    };
+    const handleKey = (_str, key, ctx) => {
+        if (key.ctrl && key.name === spec.openCtrl) {
+            // While open the key toggles the editor out. Otherwise it opens only on a role's
+            // Transcript view; elsewhere it keeps its own meaning and falls through to the pane arms.
+            if (mode) {
+                exit();
+                return true;
+            }
+            if (!(ctx.view >= 1 && ctx.view <= ctx.roleIds.length) || spec.yieldsOn?.(ctx))
+                return false;
+            const role = ctx.roleIds[ctx.view - 1];
+            const held = session.heldEditorFlash(spec.mode);
+            if (held) {
+                // Mutually exclusive with the other editors: all share one prompt line, so a mode may
+                // not enter while another holds it. Flash the way out first.
+                session.flashMessage(held);
+                return true;
+            }
+            // Pin the role first so the write below is safe against a mid-edit roster shift, then
+            // pre-fill from the file's own entry — one fresh read per open is the smallest honest
+            // source; a broken config degrades to no pre-fill and the write reports the error.
+            lockedRole = role;
+            const existing = spec.prefill(session, baseRoleOf(role));
+            restoreDraft = session.takeDraft();
+            mode = true;
+            session.held[spec.mode] = true;
+            session.input = existing;
+            session.cursor = session.input.length;
+            session.flashMessage(spec.openFlash(role));
+            return true;
+        }
+        if (key.name === "escape" && mode) {
+            // Esc cancels the editor, restoring the previous prompt text.
+            exit();
+            return true;
+        }
+        if (key.name === "return" && mode) {
+            // Enter commits the whitespace-trimmed line through the spec's shared setter. A rejected
+            // value flashes and STAYS in edit mode so the operator can fix it; success restores the
+            // saved prompt text.
+            const role = lockedRole;
+            const text = session.input.trim();
+            const result = spec.commit(session, baseRoleOf(role), text);
+            if (result.ok) {
+                exit();
+                session.flashMessage(result.noop && spec.noopFlash ? spec.noopFlash(role, text) : spec.savedFlash(role, text));
+            }
+            else {
+                session.flashMessage(result.error); // broken config or write failure — stay in edit mode
+            }
+            return true;
+        }
+        return false;
+    };
+    return { handleKey, exit };
+}

package/dist/src/ui/tui/tui-editor-role-model.js

@@ -0,0 +1,28 @@
+import { setRoleModelFields } from "../../config/config-write.js";
+import { rawRoleField } from "../../roles/role-view.js";
+import { createRoleKeyEditor } from "./tui-editor-role-key.js";
+/** The Ctrl+X role-model editor on the Transcript view's shared prompt line, the terminal twin
+ * of `tumwater role <id> --model` / `--clear-model` and the dashboard role drawer's Model
+ * overrides editor. Enter writes the viewed base role's `roles.<base>.model` through the shared
+ * setRoleModelFields the CLI and the drawer use — so checkModelTripleField (a non-empty model id
+ * or a bare tier name like `strong`) owns the value's truth, and an empty line clears the
+ * override. Pre-fill reads the FILE's raw `roles.<base>.model`: overlayDefaults seeds every
+ * built-in role's model from the catalog, so the merged value cannot tell an operator override
+ * from a seeded default. On the notes view Ctrl+X keeps its clear-notes meaning, and on every
+ * non-Transcript view it falls through to its own pane arms (the backlog cancel, the queued
+ * cancel, the Health retire). The shape it shares with the instances editor lives in
+ * createRoleKeyEditor. */
+export function createRoleModelEditor(session) {
+    return createRoleKeyEditor(session, {
+        mode: "roleModel",
+        openCtrl: "x",
+        yieldsOn: (ctx) => ctx.noteMode,
+        prefill: (s, base) => {
+            const existing = rawRoleField(s.root, base, "model");
+            return typeof existing === "string" ? existing : "";
+        },
+        openFlash: (role) => `edit ${role}'s model override (a model id or tier name like strong; empty clears): Enter to save, Esc to cancel`,
+        commit: (s, base, text) => setRoleModelFields(s.root, base, { model: text }),
+        savedFlash: (role, text) => text === "" ? `${role}: model override cleared` : `${role}: model override set to ${text}`,
+    });
+}

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

@@ -1,14 +1,14 @@
-/** The shared `/` search editor on the prompt line: over the History pane's tick rows or the
+/** The shared `/` search editor on the prompt line: over the History pane's run rows or the
  * Activity feed's events. It owns its mode flag (`searchMode`), its target pane (`searchFor`),
  * its saved-draft pair, and the applyHistorySearch / applyActivitySearch leaves. Mutually
  * exclusive with the other editors via the session's held registry. */
 export function createSearchEditor(session) {
     let searchMode = false;
-    // Which pane the shared `/` editor feeds: History's tick search or Activity's event search.
-    // The target is captured when `/` opens so a roster change mid-edit cannot retarget Enter.
+    // Which pane the shared `/` editor feeds: History's run search, Activity's event search, the
+    // Backlog pane's entry search, or a role's live-transcript search. The target is captured when
+    // `/` opens so a roster change mid-edit cannot retarget Enter.
     let searchFor = "history";
-    let searchSavedInput = "";
-    let searchSavedCursor = 0;
+    let restoreDraft = () => { };
     // 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
@@ -18,27 +18,37 @@ export function createSearchEditor(session) {
             return;
         searchMode = false;
         session.held.search = false;
-        session.restorePromptFrom(searchSavedInput, searchSavedCursor);
+        restoreDraft();
     };
     const handleKey = (str, key, ctx) => {
-        if (!key.ctrl && str === "/" && !searchMode && !session.held.budget &&
-            !session.held.rolePromptFor && !session.held.pause &&
-            !session.held.queued && !session.held.answer && !session.held.entry &&
-            !session.held.attach && !session.held.retire &&
-            (ctx.view === 0 || ctx.view === ctx.roleIds.length + 4) && session.input === "") {
+        if (!key.ctrl && str === "/" && !searchMode && !session.anyEditorHeld() &&
+            (ctx.view === 0 || ctx.view === ctx.roleIds.length + 1 || ctx.view === ctx.roleIds.length + 4 || ctx.view === ctx.roleIds.length + 6 ||
+                (ctx.view >= 1 && ctx.view <= ctx.roleIds.length && !ctx.noteMode && !ctx.changeMode)) && session.input === "") {
             // `/` opens a free-text search on the prompt line (the pager's search key; this project
-            // already reserves `/` for a meta action): over the History pane's tick rows on History,
-            // over the Activity feed's events on Activity. Guarded to those two views and to an empty
-            // line, so elsewhere it types into the prompt as today and a director draft is never
-            // disturbed. Pre-fills the applied pattern so Enter re-submits it and the operator can
-            // edit it; Esc cancels without applying.
-            session.settleDraft((t) => (searchSavedInput = t), (n) => (searchSavedCursor = n));
-            searchFor = ctx.view === 0 ? "activity" : "history";
+            // already reserves `/` for a meta action): over the History pane's run rows on History,
+            // over the Activity feed's events on Activity, and over the Backlog pane's active entries
+            // on Backlog, over the Inbox pane's queued prompts, and over a role's live transcript.
+            // Guarded to those 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.
+            restoreDraft = session.takeDraft();
+            if (ctx.view === 0)
+                searchFor = "activity";
+            else if (ctx.view === ctx.roleIds.length + 1)
+                searchFor = "backlog";
+            else if (ctx.view === ctx.roleIds.length + 4)
+                searchFor = "history";
+            else if (ctx.view === ctx.roleIds.length + 6)
+                searchFor = "queued";
+            else
+                searchFor = "transcript";
             searchMode = true;
             session.held.search = true;
-            session.input = (searchFor === "activity" ? ctx.activityGrep : ctx.historyGrep) ?? "";
+            const applied = { activity: ctx.activityGrep, history: ctx.trailSearch ? ctx.trailGrep : ctx.historyGrep, backlog: ctx.backlogGrep, queued: ctx.queuedGrep, transcript: ctx.transcriptGrep }[searchFor];
+            const noun = { activity: "events", history: ctx.trailSearch ? "transcript" : "runs", backlog: "backlog", queued: "inbox", transcript: "transcript" }[searchFor];
+            session.input = applied ?? "";
             session.cursor = session.input.length;
-            session.flashMessage(searchFor === "activity" ? "search events: Enter to filter, Esc to cancel" : "search runs: Enter to filter, Esc to cancel");
+            session.flashMessage(`search ${noun}: Enter to filter, Esc to cancel`);
             return true;
         }
         if (key.name === "escape" && searchMode) {
@@ -50,21 +60,23 @@ export function createSearchEditor(session) {
             // Enter applies the trimmed line to the pane the editor opened over: Activity sets
             // activityGrep (an empty line clears it) and resets the scroll to the live tail — the
             // offset indexed the old filtered list; History recomputes its row cache now (the pane
-            // is showing) and re-enters at its head. A successful apply restores the saved prompt
-            // draft through exitHistorySearch, the shared editor's exit.
-            const pattern = session.input.trim();
-            if (searchFor === "activity") {
-                const applied = pattern === "" ? null : pattern;
+            // is showing) and re-enters at its head; Backlog sets backlogGrep and clears its entry
+            // selection so the next frame starts in list mode; Inbox sets queuedGrep, clears its row
+            // selection, and re-reads the filtered rows. A successful apply restores the saved
+            // prompt draft through exitHistorySearch, the shared editor's exit.
+            const applied = session.input.trim() === "" ? null : session.input.trim();
+            if (searchFor === "activity")
                 session.applyActivitySearch(applied);
-                exitHistorySearch();
-                session.flashMessage(applied === null ? "search cleared" : `search: "${applied}"`);
-            }
-            else {
-                const applied = pattern === "" ? null : pattern;
+            else if (searchFor === "history")
                 session.applyHistorySearch(applied);
-                exitHistorySearch();
-                session.flashMessage(applied === null ? "search cleared" : `search: "${applied}"`);
-            }
+            else if (searchFor === "backlog")
+                session.applyBacklogSearch(applied);
+            else if (searchFor === "queued")
+                session.applyQueuedSearch(applied);
+            else
+                session.applyTranscriptSearch(applied);
+            exitHistorySearch();
+            session.flashMessage(applied === null ? "search cleared" : `search: "${applied}"`);
             return true;
         }
         return false;

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

@@ -1,5 +1,26 @@
-// vocabulary: plain
 import { newPromptHistory, resetPromptRecall, settlePromptRecall, } from "./tui-prompt-history.js";
+/** The prompt-line editors a keypress can be refused for, each with its busy-guard subject, in
+ * the order `heldEditorFlash` reports them when more than one flag reads held. */
+const HOLDER_SUBJECTS = [
+    ["attach", "image attach"],
+    ["notes", "notes edit"],
+    ["brief", "brief edit"],
+    ["retire", "retire role"],
+    ["quiet", "quiet hours"],
+    ["model", "model edit"],
+    ["interval", "min run interval"],
+    ["instructions", "instructions edit"],
+    ["providerCaps", "provider caps"],
+    ["concurrency", "run cap edit"],
+    ["slots", "worktree slots"],
+    ["notify", "notify hook"],
+    ["backends", "agent backends"],
+    ["fallback", "fallback edit"],
+    ["roleModel", "role model edit"],
+    ["instances", "role instances"],
+    ["claudeReserve", "claude reserve"],
+    ["budget", "budget edit"],
+];
 /** Build the shared prompt-line session from the disk-side deps the aggregator received. The
  * editor modules then take this session plus each keypress's `TuiEditorCtx`. */
 export function createTuiEditorSession(deps) {
@@ -24,7 +45,19 @@ export function createTuiEditorSession(deps) {
             brief: false,
             retire: false,
             quiet: false,
+            quietTeam: false,
             interval: false,
+            instructions: null,
+            providerCaps: false,
+            concurrency: false,
+            slots: false,
+            notify: false,
+            backends: false,
+            fallback: false,
+            roleModel: false,
+            model: false,
+            instances: false,
+            claudeReserve: false,
         },
         root: deps.root,
         now: deps.now,
@@ -35,28 +68,41 @@ export function createTuiEditorSession(deps) {
         clearBacklogSelection: deps.clearBacklogSelection,
         applyHistorySearch: deps.applyHistorySearch,
         applyActivitySearch: deps.applyActivitySearch,
+        applyBacklogSearch: deps.applyBacklogSearch,
+        applyQueuedSearch: deps.applyQueuedSearch,
+        applyTranscriptSearch: deps.applyTranscriptSearch,
         flashMessage: deps.flashMessage,
         flashError: deps.flashError,
         commitBacklogEdit: deps.commitBacklogEdit,
-        restorePromptFrom(text, pos) {
-            session.input = text;
-            session.cursor = pos;
-            session.promptHistory = resetPromptRecall(session.promptHistory);
-        },
-        settleDraft(saveInput, saveCursor) {
+        takeDraft() {
             const settled = settlePromptRecall(session.promptHistory, session.input, session.cursor);
             session.promptHistory = settled.history;
-            saveInput(settled.text);
-            saveCursor(settled.cursor);
+            return () => {
+                session.input = settled.text;
+                session.cursor = settled.cursor;
+                session.promptHistory = resetPromptRecall(session.promptHistory);
+            };
         },
         busyFlash(subject) {
             return `finish or cancel the ${subject} first (Esc cancels)`;
         },
+        anyEditorHeld(...except) {
+            const h = session.held;
+            if (h.search && !except.includes("search"))
+                return true;
+            if (h.pause && !except.includes("pause"))
+                return true;
+            if (h.rolePromptFor && !except.includes("rolePromptFor"))
+                return true;
+            if (h.queued || h.answer || h.entry)
+                return true;
+            return HOLDER_SUBJECTS.some(([mode]) => h[mode]);
+        },
         heldEditorFlash(entering) {
             const h = session.held;
             if (h.search)
                 return session.busyFlash("search");
-            if (h.pause)
+            if (h.pause && entering !== "pause")
                 return session.busyFlash("pause");
             if (h.queued)
                 return session.busyFlash("inbox edit");
@@ -66,30 +112,10 @@ export function createTuiEditorSession(deps) {
                 return session.busyFlash("entry edit");
             if (h.rolePromptFor)
                 return session.busyFlash(`prompt for ${h.rolePromptFor}`);
-            if (h.attach && entering !== "attach")
-                return session.busyFlash("image attach");
-            if (h.notes && entering !== "notes")
-                return session.busyFlash("notes edit");
-            if (h.brief && entering !== "brief")
-                return session.busyFlash("brief edit");
-            if (h.retire && entering !== "retire")
-                return session.busyFlash("retire role");
-            if (h.quiet && entering !== "quiet")
-                return session.busyFlash("quiet hours");
-            if (h.interval && entering !== "interval")
-                return session.busyFlash("min run interval");
-            if (entering === "attach" && h.budget)
-                return session.busyFlash("budget edit");
-            if (entering === "notes" && (h.attach || h.budget))
-                return session.busyFlash(h.attach ? "image attach" : "budget edit");
-            if (entering === "brief" && h.budget)
-                return session.busyFlash("budget edit");
-            if (entering === "retire" && (h.attach || h.notes || h.budget))
-                return session.busyFlash(h.attach ? "image attach" : h.notes ? "notes edit" : "budget edit");
-            if (entering === "quiet" && (h.attach || h.notes || h.budget || h.brief || h.retire))
-                return session.busyFlash(h.attach ? "image attach" : h.notes ? "notes edit" : h.brief ? "brief edit" : h.retire ? "retire role" : "budget edit");
-            if (entering === "interval" && (h.attach || h.notes || h.budget || h.brief || h.retire || h.quiet))
-                return session.busyFlash(h.attach ? "image attach" : h.notes ? "notes edit" : h.brief ? "brief edit" : h.retire ? "retire role" : h.quiet ? "quiet hours" : "budget edit");
+            for (const [mode, subject] of HOLDER_SUBJECTS) {
+                if (h[mode] && entering !== mode)
+                    return session.busyFlash(subject);
+            }
             return null;
         },
     };

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

@@ -0,0 +1,23 @@
+import { loadConfigSafe } from "../../config/config.js";
+import { createTeamConfigKeyEditor } from "./tui-editor-config.js";
+/** The Ctrl+W worktree-pool editor on the shared prompt line, the terminal twin of the
+ * dashboard Settings `Worktree slots` field and `tumwater config set worktreeSlots`. It owns
+ * its mode flag and its saved-draft pair. Enter writes through the shared
+ * setConfigKey/unsetConfigKey family the CLI and the dashboard use — so validateConfig owns
+ * the value's truth (`worktreeSlots must be an integer of at least 1`) — and Esc, Ctrl+W
+ * again, and Ctrl+T cancel by restoring the prompt draft. On the Activity view (view 0) it
+ * opens pre-filled from the file's `worktreeSlots` (empty when unset — the default is
+ * `maxConcurrent + 1`); on a role's Transcript view (where the shared pause editor's wake arm
+ * pins Ctrl+W) it falls through so the wake editor keeps the key. Mutually exclusive with the
+ * other editors on the one prompt line via the session's held registry. */
+export function createSlotsEditor(session) {
+    return createTeamConfigKeyEditor(session, {
+        mode: "slots",
+        openCtrl: "w",
+        configKey: "worktreeSlots",
+        prefill: (s) => String(loadConfigSafe(s.root).config?.worktreeSlots ?? ""),
+        openFlash: "edit the team's worktree pool size (worktreeSlots, an integer ≥ 1; empty restores the default of maxConcurrent + 1): Enter to save, Esc to cancel",
+        clearedFlash: "worktree slots reset to the default",
+        setFlash: (text) => `worktree slots set to ${text}`,
+    });
+}