tumwater 0.1.2 → 0.2.0

package/dist/src/ui/gui/gui-client-history.js

@@ -1,3 +1,4 @@
+// vocabulary: plain
 /** The dashboard's History view, browser-side: every completed tick, newest first, as
  * /api/history serves them (the rows `tumwater history` prints). A toolbar narrows it to one
  * loop (server-side, so a quiet loop still gets its full count), searches the rendered row text
@@ -16,16 +17,20 @@ export const GUI_CLIENT_HISTORY_JS = String.raw `  // The counts the "Ticks to s
   let histSinceKey = recall("hist-since") || "";
   let histNote = "";
   let histFilter = "all";
+  let histMode = recall("hist-mode") === "summary" ? "summary" : "table";
   let histRows = null;
+  let histSummary = null;
   let histFetchedAt = 0;
-  const HIST_FILTERS = [["all", "All"], ["changes", "Changes"], ["none", "No change"], ["problems", "Problems"]];
+  const HIST_FILTERS = [["all", "All"], ["changes", "Changes"], ["none", "No change"], ["refused", "Refused"], ["problems", "Problems"]];
+  const HIST_MODES = [["table", "Table"], ["summary", "Summary"]];
   function buildHistoryView() {
-    if (!buildOnce("history", "<div class='view-head'><div><h1>History</h1><p>Every completed tick, newest first.</p></div>" +
+    if (!buildOnce("history", "<div class='view-head'><div><h1>History</h1><p>Every completed run, newest first.</p></div>" +
       "<div class='toolbar'>" +
-      "<label><span class='sr-only'>Loop</span><select class='field' id='histrole'><option value=''>All loops</option></select></label>" +
+      "<label><span class='sr-only'>Role</span><select class='field' id='histrole'><option value=''>All roles</option></select></label>" +
       "<div class='seg' id='histfilter'>" + HIST_FILTERS.map((f) => "<button type='button' data-hist='" + f[0] + "'>" + f[1] + "</button>").join("") + "</div>" +
-      "<label><span class='sr-only'>Search</span><input class='field' id='histgrep' type='search' placeholder='Search ticks…' autocomplete='off'></label>" +
-      "<label><span class='sr-only'>Ticks to show</span><select class='field' id='histcount'>" +
+      "<div class='seg' id='histsum'>" + HIST_MODES.map((m) => "<button type='button' data-histsum='" + m[0] + "'>" + m[1] + "</button>").join("") + "</div>" +
+      "<label><span class='sr-only'>Search</span><input class='field' id='histgrep' type='search' placeholder='Search runs…' autocomplete='off'></label>" +
+      "<label><span class='sr-only'>Runs to show</span><select class='field' id='histcount'>" +
       HIST_COUNTS.map((n) => "<option value='" + n + "'>Last " + n + "</option>").join("") +
       histWindowOptions() + "</select></label>" +
       "<button type='button' class='btn btn-sm' id='histrefresh'>" + icon("refresh") + "Refresh</button>" +
@@ -60,6 +65,13 @@ export const GUI_CLIENT_HISTORY_JS = String.raw `  // The counts the "Ticks to s
       histFilter = b.dataset.hist;
       renderHistory();
     });
+    $("histsum").addEventListener("click", (ev) => {
+      const b = ev.target.closest("button[data-histsum]");
+      if (!b) return;
+      histMode = b.dataset.histsum;
+      store("hist-mode", histMode);
+      renderHistory();
+    });
     $("histrefresh").addEventListener("click", () => fetchHistory());
     // The drill-down's details toggle: the button alone expands or collapses (the row's own
     // click still opens the drawer — gui-client-boot's data-open handler skips clicks on a
@@ -73,7 +85,7 @@ export const GUI_CLIENT_HISTORY_JS = String.raw `  // The counts the "Ticks to s
   // history-detail:start
   // Tick drill-down state: one open card at a time, keyed "role#tick", with each key's cache
   // entry — { state: "loading" } while its fetch is in flight, { state: "error", message }
-  // when one failed, { state: "ok", text } once /api/tick answered. Cached until the view
+  // when one failed, { state: "ok", text } once /api/run answered. Cached until the view
   // refetches (fetchHistory clears the map), so collapsing and re-expanding reuses the card.
   const histDetails = new Map();
   let histDetailOpen = "";
@@ -88,13 +100,14 @@ export const GUI_CLIENT_HISTORY_JS = String.raw `  // The counts the "Ticks to s
   // the tumwater tick rendering).
   function histDetailCardHtml(entry) {
     const state = entry && entry.state;
-    if (!state || state === "loading") return "<div class='empty'>Loading tick detail…</div>";
-    if (state === "error") return "<div class='empty'><strong>" + esc(entry.message || "Tick detail unavailable") + "</strong></div>";
+    if (!state || state === "loading") return "<div class='empty'>Loading run detail…</div>";
+    if (state === "error") return "<div class='empty'><strong>" + esc(entry.message || "Run detail unavailable") + "</strong></div>";
     const lines = String(entry.text || "").split("\n");
     const head = lines.shift() || "";
     const trail = lines.join("\n");
     return "<div class='hist-detail'><div class='hist-detail-head mono'>" + esc(head) + "</div>" +
-      (trail ? "<pre class='mono'>" + esc(trail) + "</pre>" : "<div class='empty'>No events in this tick's block.</div>") +
+      (trail ? "<pre class='mono'>" + esc(trail) + "</pre>" : "<div class='empty'>No events in this run's block.</div>") +
+      (entry.stat ? "<pre class='mono hist-detail-stat'>" + esc(entry.stat) + "</pre>" : "") +
       "</div>";
   }
   // Expand or collapse one row's card. Opening fetches the trail on first expand only — an
@@ -116,27 +129,27 @@ export const GUI_CLIENT_HISTORY_JS = String.raw `  // The counts the "Ticks to s
     // (and a re-expand during flight sees it and lets the first fetch finish).
     histDetails.set(key, { state: "loading" });
     try {
-      const d = await getJson("/api/tick?role=" + encodeURIComponent(role) + "&tick=" + encodeURIComponent(String(tick)));
+      const d = await getJson("/api/run?role=" + encodeURIComponent(role) + "&run=" + encodeURIComponent(String(tick)));
       // Name the endpoint, the tick it answered for, and the likely cause: a 200 without
       // text is a server too old (or too new) for this dashboard's client, not a lost tick —
       // a 404 already answers that shape with the CLI's own not-found wording.
       if (!d || typeof d.text !== "string")
         throw new Error(
-          "/api/tick answered " + role + " tick " + tick + " without a text field — the running server's build may not match this dashboard",
+          "/api/run answered " + role + " run " + tick + " without a text field — the running tumwater may not match this dashboard",
         );
-      histDetails.set(key, { state: "ok", text: d.text });
+      histDetails.set(key, { state: "ok", text: d.text, stat: typeof d.stat === "string" ? d.stat : "" });
     } catch (err) {
-      histDetails.set(key, { state: "error", message: err && err.message ? err.message : "Tick detail unavailable" });
+      histDetails.set(key, { state: "error", message: err && err.message ? err.message : "Run detail unavailable" });
     }
     renderHistory();
   }
   // history-detail:end
-  // The loop picker's options follow the fleet's role list (custom loops included), keyed so a
-  // poll with no roster change repaints nothing. A role the fleet dropped falls back to All
+  // The loop picker's options follow the team's role list (custom loops included), keyed so a
+  // poll with no roster change repaints nothing. A role the team dropped falls back to All
   // loops and persists, exactly as syncRolePicker does for the report and Activity pickers.
   function syncHistoryRoles(d) {
     if (!d) return;
-    histRole = syncRolePicker("histrole", (d.loops || []).map((l) => l.role), histRole, "hist-role");
+    histRole = syncRolePicker("histrole", (d.roles || []).map((l) => l.role), histRole, "hist-role");
   }
   async function fetchHistory(throttled) {
     if (throttled && Date.now() - histFetchedAt < 4000) return;
@@ -146,6 +159,10 @@ export const GUI_CLIENT_HISTORY_JS = String.raw `  // The counts the "Ticks to s
     try {
       const d = await getJson(historyQuery(histCount, histRole, histSinceKey, histGrep));
       histRows = d && Array.isArray(d.rows) ? d.rows : [];
+      // The summary rides the same fetch (the endpoint folds the exact rows it served into
+      // its additive summary), so toggling to Summary never refetches; a server too old to
+      // include it leaves histSummary null and the toggle falls back to the table.
+      histSummary = d && d.summary && Array.isArray(d.summary.roles) ? d.summary : null;
       // The trailing-window shape carries the server's coverage; the count shape has no note.
       histNote = d && typeof d.note === "string" ? d.note : "";
       // A refetch invalidates the drill-down cache: cached trails could disagree with the new
@@ -166,10 +183,12 @@ export const GUI_CLIENT_HISTORY_JS = String.raw `  // The counts the "Ticks to s
   // names the window in the empty state.
   const HIST_WINDOWS = { "1h": [3_600_000, "the last hour"], "6h": [21_600_000, "the last 6 hours"], "1d": [86_400_000, "the last day"], "7d": [604_800_000, "the last 7 days"] };
   // The /api/history URL for the current toolbar: the trailing-window shape when a window key
-  // is set, the count shape otherwise, role and grep appended only when chosen. Pure.
+  // is set, the count shape otherwise, role and grep appended only when chosen. summary=1 rides
+  // every ask — the endpoint's additive summary folds the exact served rows, so the Summary
+  // mode renders from already-fetched data and the toggle swaps only the body.
   function historyQuery(count, role, sinceKey, grep) {
     const w = HIST_WINDOWS[sinceKey];
-    return (w ? "/api/history?sinceMs=" + w[0] : "/api/history?n=" + count) + (role ? "&role=" + encodeURIComponent(role) : "") + (grep ? "&grep=" + encodeURIComponent(grep) : "");
+    return (w ? "/api/history?sinceMs=" + w[0] : "/api/history?n=" + count) + (role ? "&role=" + encodeURIComponent(role) : "") + (grep ? "&grep=" + encodeURIComponent(grep) : "") + "&summary=1";
   }
   // The window options, the phrase capitalized for the select ("The last day").
   function histWindowOptions() {
@@ -186,58 +205,97 @@ export const GUI_CLIENT_HISTORY_JS = String.raw `  // The counts the "Ticks to s
   function historyClass(result) {
     if (result === "changed" || result === "queued") return "changes";
     if (result === "no_change" || result === "skipped" || result === "user_aborted") return "none";
+    if (result === "refused") return "refused";
     return "problems";
   }
   // The History table for rows (/api/history's, newest first) under a grep (already applied
   // server-side) and an outcome filter; known is
-  // the set of the fleet's loop ids, whose rows open that loop's drawer. Pure — the view's
+  // the set of the team's loop ids, whose rows open that loop's drawer. Pure — the view's
   // render paints what this returns.
   function historyTableHtml(rows, filter, known, grep, sinceKey) {
     const shown = (rows || []).filter((r) => filter === "all" || historyClass(r.result) === filter);
     if (!shown.length) {
       const hasRows = Boolean(rows && rows.length);
       if (hasRows)
-        return "<div class='empty'><strong>No ticks match this filter</strong>Try another outcome or loop.</div>";
+        return "<div class='empty'><strong>No runs match this filter</strong>Try another outcome or role.</div>";
       if (grep)
-        return "<div class='empty'><strong>No ticks match this search</strong>Try another search.</div>";
+        return "<div class='empty'><strong>No runs match this search</strong>Try another search.</div>";
       const w = HIST_WINDOWS[sinceKey];
       return w
-        ? "<div class='empty'><strong>No ticks in " + w[1] + "</strong>The window may be quiet, or its older events may have rotated out.</div>"
-        : "<div class='empty'><strong>No ticks yet</strong>Completed ticks show up here as the loops work.</div>";
+        ? "<div class='empty'><strong>No runs in " + w[1] + "</strong>The window may have had nothing to do, or its older events may have rotated out.</div>"
+        : "<div class='empty'><strong>No runs yet</strong>Completed runs show up here as the roles work.</div>";
     }
-    return "<div class='table-wrap'><table class='table history'><thead><tr><th class='c-x'></th><th>When</th><th>Loop</th><th class='c-tick num'>Tick</th>" +
-      "<th>Result</th><th class='c-detail'>Detail</th><th class='num c-dur'>Took</th><th class='num c-usage'>Usage</th></tr></thead><tbody>" +
+    return "<div class='table-wrap'><table class='table history'><thead><tr><th class='c-x'></th><th>When</th><th>Role</th><th class='c-tick num'>Run</th>" + // vocabulary-ok: the c-tick class stays
+      "<th>Result</th><th class='c-model'>Model</th><th class='c-detail'>Detail</th><th class='num c-dur'>Took</th><th class='num c-usage'>Usage</th></tr></thead><tbody>" +
       shown.map((r) => {
         const res = resultInfo(r.result);
         // The drill-down toggle rides the drawer's button style and lives in its own leading
-        // cell; only a fleet loop's row carries one, the same rows that open the drawer (the
-        // /api/tick endpoint validates the role, so an id the config no longer knows would
+        // cell; only a team loop's row carries one, the same rows that open the drawer (the
+        // /api/run endpoint validates the role, so an id the config no longer knows would
         // only ever answer 400).
-        const key = histDetailKey(r.loop, r.tick);
+        const key = histDetailKey(r.role, r.run);
         const open = histDetailOpen === key;
-        const toggle = known.has(r.loop)
-          ? "<button type='button' class='btn btn-sm hist-x' data-tickdetail='1' data-role='" + esc(r.loop) +
-            "' data-tick='" + esc(r.tick) + "' aria-expanded='" + open + "' title='" + (open ? "Hide tick detail" : "Show tick detail") + "'>" + icon("chev") + "</button>"
+        const toggle = known.has(r.role)
+          ? "<button type='button' class='btn btn-sm hist-x' data-tickdetail='1' data-role='" + esc(r.role) +
+            "' data-tick='" + esc(r.run) + "' aria-expanded='" + open + "' title='" + (open ? "Hide run detail" : "Show run detail") + "'>" + icon("chev") + "</button>" // vocabulary-ok: the data-tick name stays
           : "";
-        const row = "<tr" + (known.has(r.loop) ? " class='clickable' data-open='" + esc(r.loop) + "'" : "") + ">" +
+        const row = "<tr" + (known.has(r.role) ? " class='clickable' data-open='" + esc(r.role) + "'" : "") + ">" +
           "<td class='c-x'>" + toggle + "</td>" +
           "<td title='" + esc(r.time) + "'><span class='clamp1'>" + esc(fmtAgo(r.ts)) + "</span></td>" +
-          "<td class='mono'>" + esc(r.loop) + "</td>" +
-          "<td class='c-tick num muted'>#" + esc(r.tick) + "</td>" +
+          "<td class='mono'>" + esc(roleLabel(r.role)) + "</td>" +
+          "<td class='c-tick num muted'>#" + esc(r.run) + "</td>" + // vocabulary-ok: the c-tick class stays
           "<td><span class='res t-" + res.tone + "'>" + esc(res.label) + "</span></td>" +
+          "<td class='c-model'><span class='clamp1' title='" + esc(r.model || "") + "'>" + (r.model ? esc(r.model) : "<span class='muted'>—</span>") + "</span></td>" +
           "<td class='c-detail'><span class='clamp2' title='" + esc(r.detail) + "'>" + (r.detail ? esc(r.detail) : "<span class='muted'>—</span>") + "</span></td>" +
-          "<td class='num c-dur'>" + (r.durationMs === null || r.durationMs === undefined ? "—" : esc(fmtSpan(Number(r.durationMs)))) + "</td>" +
+          "<td class='num c-dur'>" + durCell(r.durationMs) + "</td>" +
           "<td class='num c-usage muted'>" + esc(r.usage || "—") + "</td></tr>";
         // The expanded card rides directly beneath its row, full width.
-        return open ? row + "<tr class='detail-row'><td colspan='8'>" + histDetailCardHtml(histDetails.get(key)) + "</td></tr>" : row;
+        return open ? row + "<tr class='detail-row'><td colspan='9'>" + histDetailCardHtml(histDetails.get(key)) + "</td></tr>" : row;
       }).join("") + "</tbody></table></div>";
   }
   // history-table:end
+  // history-summary:start
+  // The Summary table: one row per loop plus the total, in the same column set the CLI's
+  // history --summary prints (ticks, changes, none, refused, problems, tokens, cost, time,
+  // last change), so the dashboard and the CLI cannot drift column for column. Every number
+  // comes from the
+  // server's summary (built on the shared summarizeTickRows) — nothing here re-derives a
+  // tally — and the cost/token cells reuse the page's report formatters. The time cell is the
+  // sum of the loop's run spans via fmtSpan, a dash when none of its rows carried a span. The
+  // last-change cell is the newest changes-class tick's age via fmtAgo, a dash when the loop had
+  // none. Pure — the view's render paints what this returns.
+  function histSummaryHtml(summary) {
+    const all = summary.roles.concat(summary.total ? [summary.total] : []);
+    const cell = (r, key, fmt) => "<td class='num'>" + esc(fmt ? fmt(r[key]) : r[key]) + "</td>";
+    const rowsHtml = all.map((r) =>
+      "<tr" + (r.role === "total" ? " class='hist-total'" : "") + ">" +
+      "<td class='mono'>" + esc(r.role === "total" ? r.role : roleLabel(r.role)) + "</td>" +
+      cell(r, "runs") + cell(r, "changes") + cell(r, "none") + cell(r, "refused") + cell(r, "problems") +
+      cell(r, "tokens", (n) => fmtTokens(Number(n))) + cell(r, "costUsd", (n) => fmtUsd(Number(n))) +
+      "<td class='num'>" + durCell(r.durationMs) + "</td>" +
+      "<td>" + esc(r.lastChangeTs === null || r.lastChangeTs === undefined ? "—" : fmtAgo(Number(r.lastChangeTs))) + "</td></tr>").join("");
+    return "<div class='table-wrap'><table class='table history'><thead><tr><th>Role</th><th class='num'>Runs</th><th class='num'>Merged</th><th class='num'>None</th><th class='num'>Refused</th><th class='num'>Problems</th><th class='num'>Tokens</th><th class='num'>Cost</th><th class='num'>Time</th><th>Last change</th></tr></thead><tbody>" +
+      rowsHtml + "</tbody></table></div>";
+  }
+  // history-summary:end
   function renderHistory() {
     const body = $("histbody");
     if (!body) return;
     markActive($("histfilter"), "hist", histFilter);
-    body.innerHTML = historyNoteHtml(histNote) +
-      historyTableHtml(histRows, histFilter, new Set(((lastStatus && lastStatus.loops) || []).map((l) => l.role)), histGrep, histSinceKey);
+    const sum = $("histsum");
+    if (sum) sum.style.display = "";
+    markActive(sum, "histsum", histMode);
+    // The outcome filter is meaningless in Summary mode (the summary already folds every class),
+    // so it is hidden there; only the body changes, keeping the same fetch path.
+    const filterEl = $("histfilter");
+    if (filterEl) filterEl.style.display = histMode === "summary" ? "none" : "";
+    // Summary mode shows the per-loop table when the fetch carried a summary over actual rows;
+    // otherwise (no rows, or a too-old server that answered without a summary) it falls back to
+    // the same empty state the table shows.
+    const showSummary = histMode === "summary" && histSummary && histRows && histRows.length > 0;
+    const bodyHtml = showSummary
+      ? histSummaryHtml(histSummary)
+      : historyTableHtml(histRows, histFilter, new Set(((lastStatus && lastStatus.roles) || []).map((l) => l.role)), histGrep, histSinceKey);
+    body.innerHTML = historyNoteHtml(histNote) + bodyHtml;
   }
 `;

package/dist/src/ui/gui/gui-client-labels.js

@@ -0,0 +1,24 @@
+// vocabulary: plain
+/** The dashboard's browser-side twins of roleLabel and eventTypeLabel. The script is
+ * String.raw text and cannot import server modules, so the data is interpolated at module build
+ * and the few lines of logic are hand-kept copies, pinned against their TypeScript originals by
+ * test/gui-client-labels.test.ts. Spliced into gui-client.ts's script right after the format
+ * helpers, so every later client module can call the two functions. */
+import { EVENT_TYPE_LABELS, RUN_RESULT_LABELS } from "../../events/event-labels.js";
+import { INSTANCE_ID_SOURCE } from "../../roles/loop-ids.js";
+export const GUI_CLIENT_LABELS_JS = String.raw `  // labels:start
+  const INSTANCE_ID = new RegExp(${JSON.stringify(INSTANCE_ID_SOURCE)});
+  const EVENT_TYPE_LABELS = ${JSON.stringify(EVENT_TYPE_LABELS)};
+  const RUN_RESULT_LABELS = ${JSON.stringify(RUN_RESULT_LABELS)};
+  const hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+  function roleLabel(id) {
+    const m = INSTANCE_ID.exec(id);
+    return m ? m[1] + " #" + Number(m[2]) : id;
+  }
+  function eventTypeLabel(code) {
+    if (hasOwn(EVENT_TYPE_LABELS, code)) return EVENT_TYPE_LABELS[code];
+    if (hasOwn(RUN_RESULT_LABELS, code)) return RUN_RESULT_LABELS[code];
+    return String(code).replace(/_/g, " ");
+  }
+  // labels:end
+`;

package/dist/src/ui/gui/gui-client-loops.js

@@ -1,15 +1,40 @@
-/** The dashboard's loops table, browser-side — the fleet's rows grouped by what the loops are
- * doing (working, landing, needs-attention, paused, idle), each with its status pill, current
+// vocabulary: plain
+/** The dashboard's loops table, browser-side — the team's rows grouped by what the loops are
+ * doing (working, merge, needs-attention, paused, idle), each with its status pill, current
  * work, spend, and per-row operator controls (prompt, wake, pause/resume, and the two-click
  * abort), patched cell by cell so a ticking row keeps focus and hover. renderLoops repaints it
- * from each /api/status poll; renderFleet (gui-client-fleet.ts) calls it. Spliced into
+ * from each /api/status poll; renderTeam (gui-client-team.ts) calls it. Spliced into
  * gui-client.ts's script, reaching its helpers (esc, icon, phaseInfo, sortLoops, postAction,
  * setTarget, focusComposer, rerender, …) through that concatenation. */
 export const GUI_CLIENT_LOOPS_JS = String.raw `
   // ---- loops ----
   // row-actions:start
-  let confirmAbort = null; // { role, until } while an abort waits for its confirming click
-  const abortConfirming = (role) => Boolean(confirmAbort && confirmAbort.role === role && confirmAbort.until > Date.now());
+  // A two-click confirm, the confirmSlot shape the drawer's note-clear/entry-cancel also use:
+  // the first click stores a { id, title?, until } record and repaints; armed() fires a second
+  // click inside the 5 s window; a 5100 ms auto-disarm drops an unconfirmed record past its
+  // expiry. Defined here (the earliest consumer splice) so the loops' abort in this file, an
+  // earlier splice, and the drawer's notebook-clear/entry-cancel in a later splice all share
+  // one arm, guard, and disarm instead of three copies.
+  function confirmSlot(repaint) {
+    let confirm = null; // { id, title?, until }
+    return {
+      armed: (id, title) => Boolean(confirm && confirm.id === id && (title === undefined || confirm.title === title) && confirm.until > Date.now()),
+      disarm: () => { confirm = null; },
+      arm(id, title) {
+        confirm = { id, title, until: Date.now() + 5000 };
+        repaint();
+        setTimeout(() => { if (confirm && confirm.id === id && confirm.until <= Date.now()) { confirm = null; repaint(); } }, 5100);
+      },
+    };
+  }
+  // The abort slot: keyed by role, so arming is per loop — a second click on the same loop's
+  // abort fires, while a first click on another loop's abort re-arms instead of posting.
+  const confirmAbortSlot = confirmSlot(rerender);
+  const abortConfirming = (role) => confirmAbortSlot.armed(role);
+  // The drawer's Disable slot: a second click on the same role's Disable fires, a first click
+  // on another role's re-arms — the same per-role keying as the abort slot it sits beside.
+  const confirmDisableSlot = confirmSlot(rerender);
+  const disableConfirming = (role) => confirmDisableSlot.armed(role);
   let roleChooser = null; // { role, action, until }: the one open duration chooser ("pause-for" or "wake-in")
   const roleChooserOpen = (role, action) => Boolean(roleChooser && roleChooser.role === role && roleChooser.action === action && roleChooser.until > Date.now());
   const rolePauseMenuOpen = (role) => roleChooserOpen(role, "pause-for");
@@ -26,9 +51,11 @@ export const GUI_CLIENT_LOOPS_JS = String.raw `
       return;
     }
     if (action === "abort" && !abortConfirming(role)) {
-      confirmAbort = { role, until: Date.now() + 5000 };
-      rerender();
-      setTimeout(() => { if (confirmAbort && confirmAbort.role === role && confirmAbort.until <= Date.now()) { confirmAbort = null; rerender(); } }, 5100);
+      confirmAbortSlot.arm(role);
+      return;
+    }
+    if (action === "disable" && !disableConfirming(role)) {
+      confirmDisableSlot.arm(role);
       return;
     }
     if ((action === "pause-for" || action === "wake-in") && forSeconds === undefined) {
@@ -36,20 +63,27 @@ export const GUI_CLIENT_LOOPS_JS = String.raw `
       rerender();
       return;
     }
-    confirmAbort = null;
+    confirmAbortSlot.disarm();
+    confirmDisableSlot.disarm();
     roleChooser = null;
     const pausing = action === "pause" || action === "pause-for";
     const timed = action === "pause-for" && forSeconds > 0;
-    const path = action === "abort" ? "/api/abort" : action === "reset-counters" ? "/api/reset-counters" : action === "wake-cancel" ? "/api/wake-cancel" : pausing || action === "resume" ? "/api/pause-role" : "/api/wake";
+    const path = action === "abort" ? "/api/abort" : action === "disable" ? "/api/role-disable" : action === "reset-counters" ? "/api/reset-counters" : action === "wake-cancel" ? "/api/wake-cancel" : pausing || action === "resume" ? "/api/pause-role" : "/api/wake";
     const wakeIn = action === "wake-in";
     const body = pausing || action === "resume" ? { role, paused: pausing, ...(timed ? { forSeconds } : {}) } : wakeIn ? { role, inSeconds: forSeconds } : { role };
     await postAction(path, body, (d) => {
+      if (action === "disable") {
+        // The role drops out of d.roles on the next poll, so without closing it the open
+        // drawer would fall to its "no longer part of the team" head.
+        closeDrawer();
+        return d && typeof d.message === "string" ? d.message : role + ": done";
+      }
       let msg = d && typeof d.message === "string" ? d.message : action === "wake-cancel" ? role + ": scheduled wake cancelled" : role + ": done";
       if (wakeIn && !(d && typeof d.message === "string")) msg = role + " wakes in " + humanSeconds(forSeconds);
       else if (timed) msg = role + " paused for " + humanSeconds(forSeconds);
       else if (pausing || action === "resume") {
         msg = role + (d && d.changed
-          ? (pausing ? " paused — it starts no new ticks" : " resumed")
+          ? (pausing ? " paused — it starts no new runs" : " resumed")
           : (pausing ? " was already paused" : " was not paused"));
       }
       return msg;
@@ -72,77 +106,85 @@ export const GUI_CLIENT_LOOPS_JS = String.raw `
     const detail = phaseDetailBase(l, info, d);
     const w = scheduledWakeFor(l, d);
     if (!w) return detail;
-    return (detail ? detail + " · " : "") + "operator wake in " + humanSeconds(Math.max(0, Math.round((w.atMs - Date.now()) / 1000)));
+    return (detail ? detail + " · " : "") + "your wake in " + humanSeconds(Math.max(0, Math.round((w.atMs - Date.now()) / 1000)));
   }
   function phaseDetailBase(l, info, d) {
     const raw = fmtNextRun(l, d.running);
     const slowed = / ×(\d+)$/.exec(raw);
     const next = slowed ? raw.slice(0, slowed.index) : raw;
-    const backoff = next.startsWith("backoff ") ? "backing off — retries in " + next.slice(8) : "";
-    // A yield-scaled clock: the loop's recent ticks landed nothing, so it ticks less often.
-    const note = slowed ? " · slowed ×" + slowed[1] + ", nothing landed lately" : "";
-    if (info.key === "sleeping") return (backoff || (next === "-" ? "" : next === "now" ? "wakes now" : "wakes in " + next)) + note;
-    if (info.key === "queued") return (backoff || info.detail) + note;
-    if (info.key === "paused" && d.pausedRolesUntil && !d.paused && (d.pausedRoles || []).includes(l.role)) return info.detail + " · resumes in " + humanSeconds(Math.max(0, Math.round((d.pausedRolesUntil - Date.now()) / 1000)));
-    return info.detail;
+    const backoff = next.startsWith("sleeping ") ? "sleeping — next check in " + next.slice(9) : "";
+    // A yield-scaled clock: the loop's recent ticks merged nothing, so it ticks less often.
+    const note = slowed ? " · slowed ×" + slowed[1] + ", nothing merged lately" : "";
+    // The consecutive no-change streak (status-payload noChangeStreak, mirrored from
+    // status-model loopPhase's · no change ×N suffix): how many completed ticks in a row
+    // returned nothing to do. Shown only on a resting idle cell (sleeping/queued/idle/
+    // deferred) — never on live work, a pause, a failure, or main-red, which the status
+    // label likewise leaves bare. Observational only: a legitimately idle maintenance loop
+    // can hold a long streak.
+    const noChange = ["sleeping", "queued", "idle", "deferred"].includes(info.key) && (l.noChangeStreak || 0) >= 2
+      ? " · no change ×" + l.noChangeStreak : "";
+    if (info.key === "sleeping") return (backoff || (next === "-" ? "" : next === "now" ? "wakes now" : "wakes in " + next)) + note + noChange;
+    if (info.key === "queued") return (backoff || info.detail) + note + noChange;
+    if (info.key === "paused" && d.pausedRolesUntil && !d.paused && (d.pausedLoops || []).includes(l.role)) return info.detail + " · resumes in " + humanSeconds(Math.max(0, Math.round((d.pausedRolesUntil - Date.now()) / 1000)));
+    return info.detail + noChange;
   }
   function loopCells(l, d) {
     const info = phaseInfo(l.phase);
-    const paused = (d.pausedRoles || []).includes(l.role);
+    const paused = (d.pausedLoops || []).includes(l.role);
     const queued = (d.roleInbox || {})[l.role] || 0;
     const detail = phaseDetail(l, info, d);
     const stalled = info.live && STALL.test(l.phase);
-    const name = "<div class='loop-name'><button type='button' class='linkish role' data-open='" + esc(l.role) + "' title='Open " + esc(l.role) + "'>" + esc(l.role) + "</button>" +
-      (l.custom ? "<span class='tag' title='A user-defined loop from tumwater.json'>custom</span>" : "") +
-      (l.modelTier ? "<span class='tag' title='The tier of the top-level model map this loop resolves at'>" + esc(l.modelTier) + "</span>" : "") +
+    const name = "<div class='loop-name'><button type='button' class='linkish role' data-open='" + esc(l.role) + "' title='Open " + esc(roleLabel(l.role)) + "'>" + esc(roleLabel(l.role)) + "</button>" + // vocabulary-ok: CSS class the stylesheet and tests match
+      (l.custom ? "<span class='tag' title='A custom role from tumwater.json'>custom</span>" : "") +
+      (l.modelTier ? "<span class='tag' title='The model tier this role resolves at'>" + esc(l.modelTier) + "</span>" : "") +
       (l.fallback ? "<span class='tag t-amber' title='Running on the model fallback while its primary keeps failing provider-class errors'>fallback</span>" : "") +
-      (queued ? "<span class='tag t-indigo' title='" + esc(plural(queued, "prompt") + " queued for this loop") + "'>" + icon("chat") + queued + "</span>" : "") +
-      "</div><div class='sub'>" + esc(plural(l.commits, "commit") + " · " + plural(l.ticks, "tick")) + (l.model ? " · " + esc(l.model) : "") + "</div>";
+      (queued ? "<span class='tag t-indigo' title='" + esc(plural(queued, "message") + " in this role's inbox") + "'>" + icon("chat") + queued + "</span>" : "") +
+      "</div><div class='sub'>" + esc(plural(l.commits, "commit") + " · " + plural(l.runs, "run") + " · merged " + (l.lastMergedAt ? fmtAgo(l.lastMergedAt) : "never")) + (l.model ? " · " + esc(l.model) : "") +
+      (l.modelFromPi ? " <span class='tag' title='pi&#39;s own default model, from its settings.json: tumwater.json names no model'>(pi default)</span>" : "") + "</div>";
     const status = pill(info) + (detail ? "<div class='sub" + (stalled ? " t-red" : "") + "' title='" + esc(l.phase) + "'>" + esc(detail) + "</div>" : "");
     let activity;
-    if (info.live || info.key === "vetted") {
-      // Parallel work instances, part 6/7: while idle or landing, show the entry the instance
-      // claimed before the landing summary placeholder.
-      const text = l.currentWork || l.claim || landingSummary(d, l.role);
-      const pending = info.key === "working" ? "Starting up…" : info.key === "reviewing" ? "Reviewing the change…" : "Landing the change…";
+    if (info.live || info.key === "vetted") { // vocabulary-ok: internal phase key
+      // Parallel work instances, part 6/7: while idle or merge, show the entry the instance
+      // claimed before the merge summary placeholder.
+      const text = l.currentWork || l.claim || mergeSummary(d, l.role);
+      const pending = info.key === "working" ? "Starting up…" : info.key === "reviewing" ? "Reviewing the change…" : "Merging the change…";
       activity = text ? "<div class='now clamp2' title='" + esc(text) + "'>" + esc(text) + "</div>" : "<div class='muted'>" + pending + "</div>";
-    } else if (l.claim || (l.instanceOf && info.key === "queued")) {
-      // An idle instance holding a claim names its entry; an idle extra with none (skipped for
-      // want of a free entry) says why. The queued key is the tell that the skip, not a
-      // sleep or a gate, left it idle.
-      const text = l.claim || ("idle — no unclaimed " + (l.instanceOf === "bugfix" ? "bugs" : "plans"));
+    } else if (l.claim) {
+      // An idle instance holding a claim names its entry; the pill detail carries why an
+      // idle loop with none is idle.
+      const text = l.claim;
       activity = "<div class='now clamp2' title='" + esc(text) + "'>" + esc(text) + "</div>";
     } else if (l.lastResult) {
       const r = resultInfo(l.lastResult);
       const why = resultWhy(l);
       activity = "<div class='clamp2' title='" + esc(why || r.label) + "'><span class='res t-" + r.tone + "'>" + esc(r.label) + "</span>" +
-        (why ? " <span class='now'>" + esc(why) + "</span>" : "") + "</div><div class='sub'>" + esc(fmtAgo(l.lastTickEndedAt)) + "</div>";
-    } else activity = "<div class='muted'>No ticks yet</div>";
+        (why ? " <span class='now'>" + esc(why) + "</span>" : "") + "</div><div class='sub'>" + esc(fmtAgo(l.lastRunEndedAt)) + "</div>";
+    } else activity = "<div class='muted'>No runs yet</div>";
     const spent = "<div>" + esc(fmtUsd(l.todayUsd)) + "</div><div class='sub'>" + esc(fmtUsd(l.costUsd)) + " total</div>";
     const b = (action, ic, title, cls) => "<button type='button' class='icon-btn rowaction" + (cls ? " " + cls : "") + "' data-action='" + action +
       "' data-role='" + esc(l.role) + "' title='" + esc(title) + "' aria-label='" + esc(title) + "'>" + icon(ic) + "</button>";
-    let actions = b("prompt", "chat", "Prompt " + l.role);
+    let actions = b("prompt", "chat", "Message " + roleLabel(l.role));
     // The running set (info.live), not the permit-holder inFlight: the exempt running director
     // has an abortable tick without holding a maxConcurrent permit (BUGS.md 2026-10-06).
     if (info.live) {
       actions += abortConfirming(l.role)
-        ? "<button type='button' class='icon-btn rowaction confirming' data-action='abort' data-role='" + esc(l.role) + "' title='Click again to abort the running tick'>" + icon("stop") + "Abort?</button>"
-        : b("abort", "stop", "Abort " + l.role + "'s running tick", "danger");
-    } else actions += b("wake", "bolt", "Wake " + l.role + " now");
-    if (paused) actions += b("resume", "play", "Resume " + l.role);
+        ? "<button type='button' class='icon-btn rowaction confirming' data-action='abort' data-role='" + esc(l.role) + "' title='Click again to stop this run'>" + icon("stop") + "Stop?</button>"
+        : b("abort", "stop", "Stop " + roleLabel(l.role) + "'s run", "danger");
+    } else actions += b("wake", "bolt", "Wake " + roleLabel(l.role) + " now");
+    if (paused) actions += b("resume", "play", "Resume " + roleLabel(l.role));
     else if (rolePauseMenuOpen(l.role)) {
       actions += ROLE_PAUSE_CHOICES.map((c) => "<button type='button' class='icon-btn rowaction' data-action='pause-for' data-for='" + c[0] +
-        "' data-role='" + esc(l.role) + "' title='Pause " + esc(l.role) + " " + (c[0] ? "for " + c[1] : "until resumed") + "'>" + esc(c[1]) + "</button>").join("");
-    } else actions += b("pause", "pause", "Pause " + l.role) + b("pause-for", "clock", "Pause " + l.role + " for a duration");
+        "' data-role='" + esc(l.role) + "' title='Pause " + esc(roleLabel(l.role)) + " " + (c[0] ? "for " + c[1] : "until resumed") + "'>" + esc(c[1]) + "</button>").join("");
+    } else actions += b("pause", "pause", "Pause " + roleLabel(l.role)) + b("pause-for", "clock", "Pause " + roleLabel(l.role) + " for a duration");
     return { info, cells: [name, status, activity, spent, "<div class='actions'>" + actions + "</div>"] };
   }
   // loops-table:end
-  const LOOP_TDS = ["c-loop", "c-status", "c-activity", "c-today num", "c-actions"];
+  const LOOP_TDS = ["c-loop", "c-status", "c-activity", "c-today num", "c-actions"]; // vocabulary-ok: CSS class the stylesheet and tests match
   let loopKeys = "";
   // Rows are patched cell by cell: a working loop's elapsed time changes every second, and
   // rewriting only that cell keeps focus and hover on the row's buttons.
   function patchLoops(rows) {
-    const tbody = $("loops");
+    const tbody = $("rolerows");
     const keys = rows.map((r) => r.key).join("|");
     if (keys !== loopKeys) {
       loopKeys = keys;
@@ -163,7 +205,7 @@ export const GUI_CLIENT_LOOPS_JS = String.raw `
   function renderLoops(d) {
     $("loopstable").classList.toggle("free", Boolean(d.budget && d.budget.free));
     const byGroup = LOOP_GROUPS.map(() => []);
-    for (const l of sortLoops(d.loops || [])) {
+    for (const l of sortLoops(d.roles || [])) {
       const rank = loopRank(l.phase);
       byGroup[LOOP_GROUPS.findIndex((g) => g.slice(1).includes(rank))].push(l);
     }
@@ -174,13 +216,13 @@ export const GUI_CLIENT_LOOPS_JS = String.raw `
       rows.push({ key: "g" + gi, cls: "group", group: true, cells: [esc(g[0]) + "<span class='badge'>" + byGroup[gi].length + "</span>"] });
       for (const l of byGroup[gi]) {
         const { info, cells } = loopCells(l, d);
-        rows.push({ key: "l:" + l.role, role: l.role, cls: "loop clickable" + (info.live ? " live" : "") + (selected === l.role ? " selected" : ""), cells });
+        rows.push({ key: "l:" + l.role, role: l.role, cls: "loop clickable" + (info.live ? " live" : "") + (selected === l.role ? " selected" : ""), cells }); // vocabulary-ok: CSS class the stylesheet and tests match
       }
     });
-    if (!rows.length) rows.push({ key: "empty", cls: "group", group: true, cells: ["No loops are enabled in tumwater.json"] });
+    if (!rows.length) rows.push({ key: "empty", cls: "group", group: true, cells: ["No roles are enabled in tumwater.json"] });
     patchLoops(rows);
   }
-  $("loops").addEventListener("click", (ev) => {
+  $("rolerows").addEventListener("click", (ev) => {
     const b = clickClosest(ev, "button.rowaction");
     if (b) { ev.preventDefault(); rowAction(b.dataset.action, b.dataset.role, b.dataset.for === undefined ? undefined : Number(b.dataset.for)); return; }
     const tr = clickClosest(ev, "tr[data-role]");
@@ -189,14 +231,14 @@ export const GUI_CLIENT_LOOPS_JS = String.raw `
   $("resetall").addEventListener("click", () =>
     postAction("/api/reset-counters", {}, (d) => (d && typeof d.message === "string" ? d.message : "counters reset")));
   $("wakeall").addEventListener("click", () =>
-    postAction("/api/wake", {}, (d) => (d && typeof d.message === "string" ? d.message : "every loop woken")));
+    postAction("/api/wake", {}, (d) => (d && typeof d.message === "string" ? d.message : "every role woken")));
   // wake-later:start
   const WAKE_LATER_CHOICES = [[1800, "In 30 minutes"], [3600, "In 1 hour"], [7200, "In 2 hours"], [28800, "In 8 hours"]];
   function openWakeLaterMenu() {
     openPopover("wakelaterwrap", {
       menu: true,
       role: "menu",
-      html: "<div class='menu-title'>Wake every loop</div>" +
+      html: "<div class='menu-title'>Wake every role</div>" +
         WAKE_LATER_CHOICES.map((c) => "<button type='button' class='menu-item' role='menuitem' data-wakein='" + c[0] + "'>" +
           icon("clock") + esc(c[1]) + "</button>").join("") +
         "<button type='button' class='menu-item' role='menuitem' data-wakecancel='1'>" + icon("x") + "Cancel scheduled wakes</button>",

package/dist/src/ui/gui/gui-client-markdown.js

@@ -1,3 +1,4 @@
+// vocabulary: plain
 /** A small, safe Markdown renderer for the dashboard, browser-side: the failure digest and the
  * backlog entries (PLANS/BUGS/QUESTIONS.md bodies) are Markdown the loops write, and reading
  * them as rendered headings, lists, and tables beats a pre-formatted text blob. It covers what