tumwater 0.2.0 → 0.4.0

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

@@ -1,10 +1,11 @@
-// vocabulary: plain
 import { bodyStructureProblem, fileEntryWithBody, OPERATOR_FILE_KINDS, splitEntryFile, tryEditEntry } from "../../backlog/backlog-write.js";
+import { backlogHolds, stillHeldNote } from "../../backlog/backlog-eligibility.js";
 import { stripEntryStamp } from "../../backlog/backlog-structure.js";
-import { readTextIfExists } from "../../files/files.js";
 import { submitRolePromptAndWake } from "../../operator/operator-intent.js";
 import { promptLengthProblem } from "../../inbox/inbox-submit.js";
 import { collapseWhitespace } from "../../text/text.js";
+import { selectedEditableEntry } from "./tui-pane-backlog.js";
+import { readEditorPath } from "./tui-editor-session.js";
 /** The backlog pane's title editor (Ctrl+N new entry, Ctrl+E on a selected plan or bug) on the
  * shared prompt line. It owns its target (`entryEditFor`), its plan↔bug flip, its saved-draft
  * pair, its exit helper, and the fileEntryWithBody / tryEditEntry / commit arms, plus the
@@ -12,8 +13,7 @@ import { collapseWhitespace } from "../../text/text.js";
  * the session's held registry. */
 export function createEntryEditor(session) {
     let entryEditFor = null;
-    let entryEditSavedInput = "";
-    let entryEditSavedCursor = 0;
+    let restoreDraft = () => { };
     // The triple state of the entry editor's prompt line: false (the title field), true (the
     // file-path field whose contents replace the whole entry), and the draft the toggle parks
     // when it hands the line to a different field.
@@ -29,7 +29,7 @@ export function createEntryEditor(session) {
         entryEditFor = null;
         entryBodyFile = false;
         session.held.entry = null;
-        session.restorePromptFrom(entryEditSavedInput, entryEditSavedCursor);
+        restoreDraft();
     };
     const handleKey = (_str, key, ctx) => {
         if (key.ctrl && key.name === "n") {
@@ -43,13 +43,11 @@ export function createEntryEditor(session) {
                 return true;
             }
             // A Ctrl+N on any other state (not the Backlog view's new-entry slot, or an editor
-            // already holding the line) is the notebook/change/trail cycle, a pane arm the outer
+            // already holding the line) is the notes/change/trail cycle, a pane arm the outer
             // dispatch handles — this factory returns false so it runs.
             if (ctx.view === ctx.roleIds.length + 1 &&
-                !session.held.budget && !session.held.rolePromptFor && !session.held.search &&
-                !session.held.pause && !session.held.queued &&
-                !session.held.answer && !entryEditFor && !session.held.retire) {
-                session.settleDraft((t) => (entryEditSavedInput = t), (n) => (entryEditSavedCursor = n));
+                !session.anyEditorHeld()) {
+                restoreDraft = session.takeDraft();
                 entryEditFor = { kind: "plan", position: null, title: "" };
                 session.held.entry = entryEditFor;
                 session.input = "";
@@ -80,33 +78,20 @@ export function createEntryEditor(session) {
             return true;
         }
         if (key.ctrl && key.name === "e" &&
-            !session.held.budget && !session.held.rolePromptFor && !session.held.search &&
-            !session.held.pause && !session.held.queued &&
-            !session.held.answer && !entryEditFor && !session.held.retire &&
+            !session.anyEditorHeld() &&
             ctx.view === ctx.roleIds.length + 1 && ctx.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 = session.flat();
-                const sel = Math.min(ctx.selectedEntry, entries.length - 1);
-                const picked = entries[sel];
-                if (picked === undefined) {
-                    // an emptied list has nothing to edit
-                }
-                else if (picked.label === "done" || picked.label === "fixed" || picked.label === "answered") {
-                    session.flashMessage("a done plan, fixed bug or answered question is read-only");
-                }
-                else if (picked.label === "question") {
-                    session.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;
-                    session.settleDraft((t) => (entryEditSavedInput = t), (n) => (entryEditSavedCursor = n));
-                    entryEditFor = { kind, position, title: picked.title };
+                const selected = selectedEditableEntry(session, ctx.selectedEntry, "edited");
+                if (selected !== null) {
+                    const kind = selected.kind;
+                    const position = selected.position;
+                    restoreDraft = session.takeDraft();
+                    entryEditFor = { kind, position, title: selected.picked.title };
                     session.held.entry = entryEditFor;
-                    session.input = stripEntryStamp(picked.title);
+                    session.input = stripEntryStamp(selected.picked.title);
                     session.cursor = session.input.length;
                     session.flashMessage(`editing ${kind} #${position} — Enter to save, Esc to cancel`);
                 }
@@ -148,7 +133,12 @@ export function createEntryEditor(session) {
                     exitEntryEdit();
                     if (outcome.status === "edited") {
                         session.commitBacklogEdit(outcome.file, `Edit ${target.kind}: ${outcome.title}`);
-                        session.flashMessage(`edited ${target.kind} #${target.position}: ${outcome.title}`);
+                        const holds = backlogHolds(session.root);
+                        const hold = (target.kind === "bug" ? holds.bugs : holds.plans)[position - 1] ?? null;
+                        session.flashMessage(`edited ${target.kind} #${target.position}: ${outcome.title}${hold === null ? "" : ` — ${stillHeldNote(hold)}`}`);
+                    }
+                    else if (outcome.status === "unchanged") {
+                        session.flashMessage(`unchanged ${target.kind} #${target.position}: ${outcome.title}`);
                     }
                     else {
                         session.clearBacklogSelection();
@@ -159,28 +149,14 @@ export function createEntryEditor(session) {
                     session.flashError(err);
                 }
             };
+            // File mode: the line holds a path whose contents replace title and body through the
+            // same title-checked tryEditEntry core the title edit uses, keeping the entry's
+            // position and its (planned …)/(found by …) stamp. A missing file, an empty path, a
+            // file with no title line, and a structurally unsound body all flash and stay here.
             if (entryBodyFile && target.position !== null) {
-                // File mode: the line holds a path whose contents replace title and body through the
-                // same title-checked tryEditEntry core the title edit uses, keeping the entry's
-                // position and its (planned …)/(found by …) stamp. A missing file, an empty path, a
-                // file with no title line, and a structurally unsound body all flash and stay here.
-                const p = session.input.trim();
-                if (!p) {
-                    session.flashMessage("a file path is required");
-                    return true;
-                }
-                let text;
-                try {
-                    text = readTextIfExists(p);
-                }
-                catch (err) {
-                    session.flashError(err);
+                const text = readEditorPath(session);
+                if (text === null)
                     return true;
-                }
-                if (text === null) {
-                    session.flashMessage(`no such file: ${p}`);
-                    return true;
-                }
                 const { title: rawTitle, body } = splitEntryFile(text);
                 const newTitle = stripEntryStamp(rawTitle);
                 if (!newTitle) {
@@ -197,31 +173,30 @@ export function createEntryEditor(session) {
             }
             if (!session.input.trim()) {
                 session.flashMessage("an entry needs a title");
+                return true;
             }
-            else if (target.position === null) {
-                // New entry (Ctrl+N): file by title with an empty body and wake its loop, the same
+            if (target.position === null) {
+                // New entry (Ctrl+N): file by title with an empty body and wake its role, the same
                 // steps handleBacklogFile takes; a length problem or a throw stays in the editor.
                 try {
                     const { role, wakeText } = OPERATOR_FILE_KINDS[target.kind];
                     const problem = promptLengthProblem(wakeText(collapseWhitespace(session.input)), role);
                     if (problem) {
                         session.flashMessage(problem);
+                        return true;
                     }
-                    else {
-                        const filed = fileEntryWithBody(session.root, target.kind, session.input, "");
-                        session.commitBacklogEdit(filed.file, `File ${target.kind}: ${filed.title}`);
-                        submitRolePromptAndWake(session.root, role, wakeText(filed.title));
-                        exitEntryEdit();
-                        session.flashMessage(`filed ${target.kind}: ${filed.title} — woke ${role}`);
-                    }
+                    const filed = fileEntryWithBody(session.root, target.kind, session.input, "");
+                    session.commitBacklogEdit(filed.file, `File ${target.kind}: ${filed.title}`);
+                    submitRolePromptAndWake(session.root, role, wakeText(filed.title));
+                    exitEntryEdit();
+                    session.flashMessage(`filed ${target.kind}: ${filed.title} — woke ${role}`);
                 }
                 catch (err) {
                     session.flashError(err);
                 }
+                return true;
             }
-            else {
-                applyEntryEdit(session.input);
-            }
+            applyEntryEdit(session.input);
             return true;
         }
         return false;

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

@@ -0,0 +1,31 @@
+import { loadConfigSafe } from "../../config/config.js";
+import { createTeamConfigKeyEditor } from "./tui-editor-config.js";
+/** The Ctrl+L fallback editor on the Activity view's shared prompt line — the terminal twin of
+ * the dashboard Settings `Fallback (free at the spend cap)` field and `tumwater config set
+ * fallback`, completing the team-config knob set the model field and the budget gate point at.
+ * On the Activity view (view 0, the team scope) Ctrl+L opens it pre-filled from the file's
+ * top-level `fallback` (a bare selector string as-is, an array or map as compact JSON, empty
+ * when unset — empty means "no fallback" on save); a role's Transcript keeps Ctrl+L for its
+ * instructions editor, which runs after this arm. Enter writes through the shared
+ * setConfigKey/unsetConfigKey family — so setConfigKey JSON-parses the typed text (a
+ * `["omlx/..."]` becomes the step list, `omlx/...` the literal selector) and validateConfig
+ * owns the value's truth. The skeleton (mode flag, held registry, Esc/Ctrl+L/Ctrl+T exit) is
+ * createTeamConfigKeyEditor's. */
+export function createFallbackEditor(session) {
+    return createTeamConfigKeyEditor(session, {
+        mode: "fallback",
+        openCtrl: "l",
+        configKey: "fallback",
+        prefill: (s) => {
+            const existing = loadConfigSafe(s.root).config?.fallback;
+            return typeof existing === "string"
+                ? existing
+                : existing && typeof existing === "object"
+                    ? JSON.stringify(existing)
+                    : "";
+        },
+        openFlash: "edit the team's fallback model (fallback, a model id or a JSON map by tier; empty clears): Enter to save, Esc to cancel",
+        clearedFlash: "team fallback cleared",
+        setFlash: (text) => `team fallback set to ${text}`,
+    });
+}

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

@@ -0,0 +1,46 @@
+import { setConfigKey, unsetConfigKey } from "../../config/config-write.js";
+import { rawRoleField } from "../../roles/role-view.js";
+import { createRoleKeyEditor } from "./tui-editor-role-key.js";
+/** The Ctrl+G parallel-runner-count editor on the shared prompt line, the terminal twin of
+ * `tumwater role <id> --instances` and the dashboard role drawer's instance-count editor. Enter
+ * writes `roles.<base>.instances` through the shared setConfigKey/unsetConfigKey family the CLI
+ * and the drawer use — an empty line clears the key (a no-op success when the file never set
+ * it), otherwise the raw text is written — so validateConfig's INSTANCE_COUNT (an integer 1–8)
+ * and INSTANCE_ROLES (feature and bugfix) own the value's truth, exactly as the CLI documents.
+ * Pre-fill reads the FILE's raw `roles.<base>.instances` (empty when unset), since the merged
+ * count may default. Ctrl+G keeps its scope-cycle meaning on every other view: the arm consumes
+ * the key only on a role's Transcript. The shape it shares with the role-model editor lives in
+ * createRoleKeyEditor. */
+export function createInstancesEditor(session) {
+    return createRoleKeyEditor(session, {
+        mode: "instances",
+        openCtrl: "g",
+        prefill: (s, base) => {
+            const existing = rawRoleField(s.root, base, "instances");
+            return typeof existing === "number" ? String(existing) : "";
+        },
+        openFlash: (role) => `edit ${role}'s parallel-runner count (an integer 1-8; feature and bugfix only; empty clears): Enter to save, Esc to cancel`,
+        commit: (s, base, text) => {
+            const cfgKey = `roles.${base}.instances`;
+            if (text === "") {
+                const r = unsetConfigKey(s.root, cfgKey);
+                return r.ok && r.oldValue === undefined ? { ok: true, noop: true } : r;
+            }
+            // Shape, before the write: an exponent spelling like "2e0" is itself a JSON number (2),
+            // so setConfigKey's JSON.parse would read it past validateConfig's INSTANCE_COUNT integer
+            // check and silently write 2 — the same silent misread the CLI's --instances guard
+            // refuses (and the dashboard drawer's instance editor), so this refuses it too, naming
+            // the key and staying in edit mode. A non-exponent spelling falls through to
+            // validateConfig, whose message names the key.
+            if (!/^\d*\.?\d+$/.test(text) && /^\d+(\.\d+)?[eE][+-]?\d+$/.test(text)) {
+                return { ok: false, error: `${cfgKey} must be a plain integer from 1 to 8 — no exponent notation` };
+            }
+            const r = setConfigKey(s.root, cfgKey, text);
+            return r.ok && r.unchanged ? { ok: true, noop: true } : r;
+        },
+        savedFlash: (role, text) => text === "" ? `${role}: instances cleared` : `${role}: instances set to ${text}`,
+        noopFlash: (role, text) => text === ""
+            ? `${role}: instances is not set in tumwater.json, so nothing was cleared`
+            : `${role}: instances is already ${text}, so tumwater.json was not written`,
+    });
+}

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

@@ -0,0 +1,117 @@
+import { setConfigKey, unsetConfigKey } from "../../config/config-write.js";
+import { baseRoleOf } from "../../roles/runner-ids.js";
+import { readEditorPath } from "./tui-editor-session.js";
+/** The Transcript view's Ctrl+L replace-standing-instructions editor on the shared prompt line,
+ * the terminal twin of `tumwater role <id> --instructions-file` and the dashboard role drawer's
+ * `Instructions override` row. It owns its `instructionsFor` flag, its saved-draft pair, and the
+ * role pinned when it opened, so a roster shift cannot redirect the write. Ctrl+L opens it on a
+ * role transcript (the same in-range guard every transcript editor arm carries — the
+ * instructions row is reachable from the plain transcript, not only the notes mode), flashes the
+ * held-editor busy message when another prompt-line editor owns the line, settles the recall
+ * draft, blanks the line, and flashes the enter/Esc framing. Enter trims the line as a file
+ * path, reads it verbatim with the same readTextIfExists the CLI's non-interactive replacement
+ * uses, and writes the BASE role's `roles.<base>.instructions` through the same
+ * setConfigKey/unsetConfigKey family the CLI and dashboard drawer use — so validateConfig
+ * (naming the dotted key and its ROLE_INSTRUCTIONS_MAX_CHARS cap) owns the value's truth. An
+ * empty or whitespace-only file clears the key (unsetConfigKey, the dashboard's empty-clears
+ * convention, giving the terminal a way to clear); an over-cap or unknown-role write flashes
+ * the returned error and STAYS open. Esc, Ctrl+L again, and Ctrl+T cancel by restoring the
+ * prompt draft. On success the notes repaints through the session's refreshNotes seam (the
+ * notes view's cached Markdown recomputes the same role-inspection body the `Instructions
+ * override` row renders). Unlike quiet hours' director refusal there is none here: the
+ * dashboard editor and `--instructions-file` both accept the director, so it edits too. */
+export function createInstructionsEditor(session) {
+    let instructionsFor = null;
+    let restoreDraft = () => { };
+    // Leave the instructions editor (Esc, Ctrl+L again, or Ctrl+T): restore the saved prompt
+    // text with no override written.
+    const exitInstructionsMode = () => {
+        if (instructionsFor === null)
+            return;
+        instructionsFor = null;
+        session.held.instructions = null;
+        restoreDraft();
+    };
+    const handleKey = (_str, key, ctx) => {
+        if (key.ctrl && key.name === "l" &&
+            ctx.roleIds.length > 0 && ctx.view >= 1 && ctx.view <= ctx.roleIds.length) {
+            // Ctrl+L toggles the replace-instructions editor on a role's Transcript view (mnemonic:
+            // the instructions **l**ine, bound on no other TUI view except the Activity view's
+            // fallback editor and the Health view's retire-leftovers arm — the in-range role check
+            // keeps the arm from firing off a role transcript, and those other arms (which run before
+            // this one) keep Ctrl+L on Activity and Health).
+            // The line edits one file path that becomes the viewed role's whole
+            // `roles.<base>.instructions` override through the same setConfigKey write the CLI and
+            // the dashboard drawer use. Entering saves the prompt draft and blanks the line; leaving
+            // restores it.
+            if (session.editorEntryDenied("instructions"))
+                return true;
+            if (instructionsFor !== null) {
+                exitInstructionsMode();
+            }
+            else {
+                // Mid-recall, hand the arrows' saved draft back before the instructions 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.
+                const role = ctx.roleIds[ctx.view - 1]; // defined: the open-arm range guard above pins the view into roleIds
+                restoreDraft = session.takeDraft();
+                instructionsFor = role;
+                session.held.instructions = role;
+                session.input = "";
+                session.cursor = 0;
+                session.flashMessage(`replace ${role}'s instructions from a file — Enter to save, Esc to cancel`);
+            }
+            return true;
+        }
+        if (key.name === "escape" && instructionsFor !== null) {
+            // Esc cancels the instructions editor, restoring the previous prompt text and writing
+            // nothing.
+            exitInstructionsMode();
+            session.flashMessage("instructions edit cancelled");
+            return true;
+        }
+        if (key.name === "return" && instructionsFor !== null) {
+            // Enter reads the typed path whole and writes it through the shared
+            // setConfigKey/unsetConfigKey family the CLI's `--instructions-file`/`--clear-instructions`
+            // and the dashboard drawer use, so ROLE_INSTRUCTIONS_MAX_CHARS and the unknown-role check
+            // (enforced by validateConfig inside writeConfigMutation) and their wording cannot drift.
+            // An empty path, a missing file, an unreadable file, an over-cap text, and an unknown id
+            // all flash and STAY in the editor so the operator can fix the path; an empty or
+            // whitespace-only file clears the override (the dashboard's empty-clears convention). On
+            // success the notes repaints the updated `Instructions override` row and the editor
+            // exits with the shared success wording.
+            const role = instructionsFor;
+            const text = readEditorPath(session);
+            if (text === null)
+                return true;
+            const base = baseRoleOf(role);
+            const cfgKey = `roles.${base}.instructions`;
+            if (text.trim() === "") {
+                const result = unsetConfigKey(session.root, cfgKey);
+                if (!result.ok) {
+                    session.flashMessage(result.error); // broken config or write failure — stay in edit mode
+                    return true;
+                }
+                session.refreshNotes(role);
+                exitInstructionsMode();
+                session.flashMessage(result.oldValue === undefined
+                    ? `${role}: instructions is not set in tumwater.json, so nothing was cleared`
+                    : `${role}: instructions cleared`);
+                return true;
+            }
+            const result = setConfigKey(session.root, cfgKey, JSON.stringify(text));
+            if (!result.ok) {
+                session.flashMessage(result.error); // over the cap, unknown id, or write failure — stay in edit mode
+                return true;
+            }
+            session.refreshNotes(role);
+            exitInstructionsMode();
+            session.flashMessage(result.unchanged
+                ? `${role}: instructions unchanged, so tumwater.json was not written`
+                : `${role}: instructions saved (${text.length} chars)`);
+            return true;
+        }
+        return false;
+    };
+    return { handleKey, exit: exitInstructionsMode };
+}

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

@@ -1,22 +1,23 @@
-// vocabulary: plain
 import { setConfigKey, unsetConfigKey } from "../../config/config-write.js";
 import { checkMinRunInterval } from "../../config/config-keys.js";
-import { baseRoleOf } from "../../roles/loop-ids.js";
+import { baseRoleOf } from "../../roles/runner-ids.js";
 import { rawRoleField } from "../../roles/role-view.js";
+import { gotSuffix } from "../../text/text.js";
 /** The Ctrl+S min-run-interval editor on the shared prompt line, the terminal twin of
  * `tumwater role <id> --min-run-interval` and the dashboard role drawer's `Min run interval`
  * row. 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 checkMinRunInterval
- * (naming `roles.<base>.minRunIntervalSeconds`) and validateConfig own the value's truth — and
+ * (naming `roles.<base>.minRunIntervalSeconds`) and validateConfig own the value's truth — a
+ * non-plain-decimal spelling (hex/exponent, negative, or non-numeric) flashes the editor's own
+ * shape message first, mirroring the budget editor's plain-decimal rule, and stays open — and
  * Esc, Ctrl+S again, and Ctrl+T cancel by restoring the prompt draft. Unlike the quiet editor
  * there is no director refusal: `tumwater role director --min-run-interval` is accepted, so the
  * director edits too. Mutually exclusive with the other editors on the one prompt line via the
  * session's held registry. */
 export function createIntervalEditor(session) {
     let intervalMode = false;
-    let savedInput = "";
-    let savedCursor = 0;
+    let restoreDraft = () => { };
     // The role pinned when the editor opened, so Enter writes the same role's override even if
     // syncRoster shrinks or reorders the roster while the editor is open.
     let lockedRole = null;
@@ -26,7 +27,7 @@ export function createIntervalEditor(session) {
             return;
         intervalMode = false;
         session.held.interval = false;
-        session.restorePromptFrom(savedInput, savedCursor);
+        restoreDraft();
         lockedRole = null;
     };
     const handleKey = (_str, key, ctx) => {
@@ -37,18 +38,13 @@ export function createIntervalEditor(session) {
             // holds the line, in which case Ctrl+S is the toggle-out arm. Entering pre-fills the
             // override from the FILE's raw `roles.<base>.minRunIntervalSeconds` (empty when unset —
             // empty means "clear it, fall back to the team-wide interval" on save) and saves the
-            // prompt text; leaving restores it. There is no director exemption: the director ticks
+            // prompt text; leaving restores it. There is no director exemption: the director runs
             // on the same clock, so `--min-run-interval` is accepted for it too.
             if (!intervalMode && !(ctx.view >= 1 && ctx.view <= ctx.roleIds.length))
                 return false;
             const role = ctx.roleIds[ctx.view - 1];
-            const held = session.heldEditorFlash("interval");
-            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);
+            if (session.editorEntryDenied("interval"))
                 return true;
-            }
             if (intervalMode) {
                 exitIntervalMode();
                 return true;
@@ -63,7 +59,7 @@ export function createIntervalEditor(session) {
             lockedRole = role;
             const base = baseRoleOf(role);
             const existing = rawRoleField(session.root, base, "minRunIntervalSeconds");
-            session.settleDraft((t) => (savedInput = t), (n) => (savedCursor = n));
+            restoreDraft = session.takeDraft();
             intervalMode = true;
             session.held.interval = true;
             session.input = typeof existing === "number" ? String(existing) : "";
@@ -90,13 +86,28 @@ export function createIntervalEditor(session) {
                 const result = unsetConfigKey(session.root, cfgKey);
                 if (result.ok) {
                     exitIntervalMode();
-                    session.flashMessage(`${role}: min run interval cleared`);
+                    session.flashMessage(result.oldValue === undefined
+                        ? `${role}: min run interval is not set in tumwater.json, so nothing was cleared`
+                        : `${role}: min run interval cleared`);
                 }
                 else {
                     session.flashMessage(result.error); // broken config or write failure — stay in edit mode
                 }
                 return true;
             }
+            // Plain decimal seconds only — bare Number() would also read hex ("0x10" → 16) and
+            // exponent ("1e2" → 100) as an interval, neither of which an operator means when
+            // typing a second count; the budget editor's parseBudgetInput applies the same
+            // plain-decimal rule in the TUI, the CLI's --min-run-interval uses plainDecimalToJson,
+            // and the GUI drawer's interval-save arm applies the same shape guard.
+            // Non-plain spellings flash their own shape message — which, like checkMinRunInterval's
+            // bounds wording below, names cfgKey so a rejected entry tells which per-role key the
+            // editor was about to write — and STAY in edit mode (negative and non-numeric text hit
+            // this shape arm too, so the operator sees one consistent message).
+            if (!/^\d*\.?\d+$/.test(text)) {
+                session.flashMessage(`${cfgKey} must be a plain second count like 300, 0.5, or .5 — no +/-, exponent, or hex notation${gotSuffix(text)}`);
+                return true;
+            }
             const value = Number(text);
             const invalid = checkMinRunInterval(value, cfgKey);
             if (invalid) {
@@ -106,7 +117,9 @@ export function createIntervalEditor(session) {
             const result = setConfigKey(session.root, cfgKey, JSON.stringify(value));
             if (result.ok) {
                 exitIntervalMode();
-                session.flashMessage(`${role}: min run interval set to ${text}s`);
+                session.flashMessage(result.unchanged
+                    ? `${role}: min run interval is already ${text}s, so tumwater.json was not written`
+                    : `${role}: min run interval set to ${text}s`);
             }
             else {
                 session.flashMessage(result.error); // broken config or write failure — stay in edit mode

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

@@ -0,0 +1,29 @@
+import { loadConfigSafe } from "../../config/config.js";
+import { createTeamConfigKeyEditor } from "./tui-editor-config.js";
+/** The Ctrl+A team-model editor on the Activity view's shared prompt line, the terminal twin
+ * of the dashboard Settings `Model` field and `tumwater config set model`. Enter writes the
+ * top-level `model` through the shared setConfigKey/unsetConfigKey family — setConfigKey
+ * JSON-parses the text, so a bare model id stays a literal string while a `{"strong":"..."}`
+ * map becomes the map, and validateConfig owns the value's truth (a number like `42` flashes
+ * the model validator's message and stays open). The editor opens only on view 0: on a role's
+ * Transcript Ctrl+A keeps its per-role abort meaning, and on Backlog it keeps the answer
+ * editor's key. */
+export function createModelEditor(session) {
+    return createTeamConfigKeyEditor(session, {
+        mode: "model",
+        openCtrl: "a",
+        configKey: "model",
+        // A selector string as-is, a tier map as compact JSON, empty when unset.
+        prefill: (s) => {
+            const existing = loadConfigSafe(s.root).config?.model;
+            return existing === undefined
+                ? ""
+                : typeof existing === "string"
+                    ? existing
+                    : JSON.stringify(existing);
+        },
+        openFlash: "edit the team's model (model, a model id or a JSON map by tier like {\"strong\":\"...\"}; empty clears): Enter to save, Esc to cancel",
+        clearedFlash: "team model cleared",
+        setFlash: (text) => `team model set to ${text}`,
+    });
+}

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

@@ -1,7 +1,6 @@
-// vocabulary: plain
 import { saveRoleNote } from "../../agent/role-notes-write.js";
-import { readTextIfExists } from "../../files/files.js";
 import { roleNotesPath } from "../../paths.js";
+import { readEditorPath } from "./tui-editor-session.js";
 /** The notes view's Ctrl+E replace-notes-from-a-file editor on the shared prompt line, the
  * terminal twin of `tumwater role <id> --notes-file <path>` and the dashboard drawer's
  * textarea. It owns its `notesEditFor` flag, its saved-draft pair, and the handleKey arms for
@@ -16,8 +15,7 @@ import { roleNotesPath } from "../../paths.js";
  * session's refreshNotes seam. */
 export function createNotesEditor(session) {
     let notesEditFor = null;
-    let notesSavedInput = "";
-    let notesSavedCursor = 0;
+    let restoreDraft = () => { };
     // Leave the notes editor (Esc, Ctrl+E again, or Ctrl+T): restore the saved prompt text with
     // no note written.
     const exitNotesMode = () => {
@@ -25,7 +23,7 @@ export function createNotesEditor(session) {
             return;
         notesEditFor = null;
         session.held.notes = null;
-        session.restorePromptFrom(notesSavedInput, notesSavedCursor);
+        restoreDraft();
     };
     const handleKey = (_str, key, ctx) => {
         if (key.ctrl && key.name === "e" && ctx.noteMode &&
@@ -39,14 +37,8 @@ export function createNotesEditor(session) {
             // line edits one file path that becomes the role's whole note through the same
             // saveRoleNote write the CLI and the dashboard drawer use. Entering saves the prompt
             // draft and blanks the line; leaving restores it.
-            const held = session.heldEditorFlash("notes");
-            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 instead of silently dropping
-                // the held mode's saved draft.
-                session.flashMessage(held);
+            if (session.editorEntryDenied("notes"))
                 return true;
-            }
             if (notesEditFor !== null) {
                 exitNotesMode();
             }
@@ -55,7 +47,7 @@ export function createNotesEditor(session) {
                 // line — the same settle the role editors do — so leaving restores the
                 // draft, not a history entry, with no stale recall state riding along.
                 const role = ctx.roleIds[ctx.view - 1]; // defined: the open-arm range guard above pins the view into roleIds
-                session.settleDraft((t) => (notesSavedInput = t), (n) => (notesSavedCursor = n));
+                restoreDraft = session.takeDraft();
                 notesEditFor = role;
                 session.held.notes = role;
                 session.input = "";
@@ -78,23 +70,11 @@ export function createNotesEditor(session) {
             // clears the note. On success the notes view repaints the new note without leaving and
             // re-entering, and the editor exits with the shared success wording.
             const role = notesEditFor;
-            const p = session.input.trim();
-            if (p === "") {
-                session.flashMessage("a file path is required");
-                return true;
-            }
-            let text;
-            try {
-                text = readTextIfExists(p);
-            }
-            catch (err) {
-                session.flashError(err);
+            // The trim/read/refuse prologue is shared with the brief, instructions and backlog-entry
+            // editors (readEditorPath), which read one typed path the same way.
+            const text = readEditorPath(session);
+            if (text === null)
                 return true;
-            }
-            if (text === null) {
-                session.flashMessage(`no such file: ${p}`);
-                return true;
-            }
             try {
                 const message = saveRoleNote(roleNotesPath(session.root, role), text);
                 session.refreshNotes(role);

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

@@ -0,0 +1,25 @@
+import { loadConfigSafe } from "../../config/config.js";
+import { createTeamConfigKeyEditor } from "./tui-editor-config.js";
+/** The Ctrl+E notify-hook editor on the Activity view's shared prompt line — the terminal
+ * twin of the dashboard Settings `Notify hook` field and `tumwater config set notify`, so an
+ * operator can point the orchestrator's notable-event command at a new shell command without
+ * leaving the terminal (or test it without guessing). Enter writes the top-level `notify`
+ * through the shared setConfigKey/unsetConfigKey family: setConfigKey JSON-parses the typed
+ * text (a bare command stays the literal string, while a typed number or object becomes a
+ * non-string and validateConfig's notify block rejects it with nothing written). The Team
+ * scope is the only scope, so the editor takes the line on the Activity view (view 0) alone;
+ * on every other view Ctrl+E keeps its own meaning (the Report window cycle, the Health
+ * reclaim, and the notes/Brief file replace). Esc, Ctrl+E 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. */
+export function createNotifyEditor(session) {
+    return createTeamConfigKeyEditor(session, {
+        mode: "notify",
+        openCtrl: "e",
+        configKey: "notify",
+        prefill: (s) => String(loadConfigSafe(s.root).config?.notify ?? ""),
+        openFlash: "edit the team's notify hook (notify, the shell command run on notable events; empty clears): Enter to save, Esc to cancel",
+        clearedFlash: "notify hook cleared",
+        setFlash: (text) => `notify hook set to ${text}`,
+    });
+}