tumwater 0.1.2 → 0.2.0

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

@@ -1,3 +1,4 @@
+// vocabulary: plain
 /** The dashboard's view model, browser-side — the pure layer between the status payload and
  * what the page shows, with no DOM of its own: each loop's phase pill (label, tone, live
  * detail), its last result in words with the tone of its outcome, the loop sort order and
@@ -17,53 +18,71 @@ export const GUI_CLIENT_MODEL_JS = String.raw `  // view-model:start
   // How a loop's phase label (status-model.ts loopPhase) reads here: a status word and tone for
   // its pill, whether it is live work, and the detail the label carried after its first word.
   function phaseInfo(phase) {
-    const p = String(phase || "");
+    // status-model.ts loopPhase appends a " · no change ×N" streak suffix to a resting idle
+    // cell's label. Strip it so the exact/startsWith matches and the parsed detail see the
+    // plain phase; phaseDetailBase re-appends the streak once itself from the payload's
+    // noChangeStreak, so the GUI renders it exactly once.
+    const p = String(phase || "").replace(/ · no change ×\d+$/, "");
     const after = (n) => p.slice(n).replace(/^[\s·,]+/, "");
     if (p.startsWith("director working")) return { key: "working", label: "Working (director)", tone: "blue", live: true, detail: after(16) };
     if (p.startsWith("working")) return { key: "working", label: "Working", tone: "blue", live: true, detail: after(7) };
     if (p.startsWith("reviewing")) return { key: "reviewing", label: "Reviewing", tone: "violet", live: true, detail: after(9) };
-    if (p.startsWith("landing")) return { key: "landing", label: "Landing", tone: "orange", live: true, detail: after(7) };
-    if (p.startsWith("vetted")) return { key: "vetted", label: "Approved", tone: "indigo", live: false, detail: "waiting for the merge slot" };
-    if (p.startsWith("awaiting slot")) return { key: "awaiting", label: "Waiting for a slot", tone: "gray", live: false, detail: after(13) ? "for " + after(13) : "" };
-    if (p === "failing") return { key: "failing", label: "Failing", tone: "red", live: false, detail: "the same error, tick after tick" };
-    if (p === "main red") return { key: "mainred", label: "Main red", tone: "red", live: false, detail: "blocked until main's suite passes" };
-    if (p === "paused") return { key: "paused", label: "Paused", tone: "amber", live: false, detail: "starts no new ticks" };
-    if (p === "budget paused") return { key: "budget", label: "Budget paused", tone: "amber", live: false, detail: "today's cap is spent" };
-    if (p === "cap paused") return { key: "cap", label: "Cap paused", tone: "amber", live: false, detail: "its own daily cap is spent" };
-    if (p === "disk hold") return { key: "disk", label: "Disk hold", tone: "amber", live: false, detail: "free space is below the floor" };
-    if (p === "held: bootstrap") return { key: "bootstrap", label: "Bootstrap hold", tone: "amber", live: false, detail: "waiting for enough plans to be done" };
-    if (p.startsWith("held: maintenance quota")) return { key: "quota", label: "Maintenance hold", tone: "amber", live: false, detail: after(24) };
+    if (p.startsWith("merging")) return { key: "landing", label: "Merging", tone: "orange", live: true, detail: after(7) }; // vocabulary-ok: internal key the row classes and filters match
+    if (p.startsWith("approved")) return { key: "vetted", label: "Approved", tone: "indigo", live: false, detail: "waiting to merge" }; // vocabulary-ok: internal key the row classes and filters match
+    if (p.startsWith("waiting to start")) return { key: "awaiting", label: "Waiting to start", tone: "gray", live: false, detail: after(16) ? "for " + after(16) : "" };
+    // A waiter parked on a full provider key (provider-concurrency part 5/5): the phase reads
+    // waiting for <key> 2m, and this chip names the provider alongside the wait, so the
+    // operator sees which cap is full — the same chip and tone as a team-total waiter.
+    if (p.startsWith("waiting for ")) {
+      const m = after(12).match(/^(\S+)(?:\s+(.*))?$/);
+      const prov = m ? m[1] : "";
+      const dur = m && m[2] ? m[2].trim() : "";
+      return {
+        key: "awaiting", label: "Waiting to start", tone: "gray", live: false,
+        detail: (prov ? "on " + prov : "") + (dur ? " for " + dur : ""),
+      };
+    }
+    if (p === "failing") return { key: "failing", label: "Failing", tone: "red", live: false, detail: "failed runs in a row" };
+    if (p === "main's check is failing") return { key: "mainred", label: "Main's check failing", tone: "red", live: false, detail: "blocked until main's check passes" };
+    if (p.startsWith("paused")) return { key: "paused", label: "Paused", tone: "amber", live: false, detail: "starts no new runs" };
+    if (p === "waiting: budget spent") return { key: "budget", label: "Waiting", tone: "amber", live: false, detail: "budget" };
+    if (p === "waiting: daily cap spent") return { key: "cap", label: "Waiting", tone: "amber", live: false, detail: "daily cap" };
+    if (p === "waiting: low disk") return { key: "disk", label: "Waiting", tone: "amber", live: false, detail: "low disk" };
+    if (p === "waiting: bootstrap") return { key: "bootstrap", label: "Waiting", tone: "amber", live: false, detail: "bootstrap" };
+    if (p.startsWith("waiting: maintenance allowance used")) return { key: "quota", label: "Waiting", tone: "amber", live: false, detail: "maintenance " + after(35) };
     if (p.startsWith("sleeping")) return { key: "sleeping", label: "Sleeping", tone: "gray", live: false, detail: "" };
-    if (p === "queued") return { key: "queued", label: "Queued", tone: "gray", live: false, detail: "due — not running: no work to claim, deferred, or starting on the next poll" };
-    if (p === "waiting for prompts") return { key: "waiting", label: "Waiting", tone: "gray", live: false, detail: "runs when you send it a prompt" };
-    if (p === "stopped") return { key: "stopped", label: "Stopped", tone: "gray", live: false, detail: "the fleet is not running" };
+    if (p.startsWith("idle: ")) return { key: "idle", label: "Idle", tone: "gray", live: false, detail: p.slice(6) };
+    if (p.startsWith("deferred (")) return { key: "deferred", label: "Deferred", tone: "gray", live: false, detail: p.slice(10, -1) };
+    if (p === "due") return { key: "queued", label: "Due", tone: "gray", live: false, detail: "starts on the next poll" };
+    if (p === "ready for messages") return { key: "waiting", label: "Ready", tone: "gray", live: false, detail: "runs when you send it a message" };
+    if (p === "stopped") return { key: "stopped", label: "Stopped", tone: "gray", live: false, detail: "the team is not running" };
     return { key: "other", label: p || "unknown", tone: "gray", live: false, detail: "" };
   }
   // A stalled tool call or a long silence, as the phase label names them (tick-progress-model.ts's
   // inFlightDetail) — the cue that a working loop may be stuck. The pattern is that module's
-  // STALL_SOURCE (interpolated at module build), shared with fleet-alerts.ts's server-side
+  // STALL_SOURCE (interpolated at module build), shared with team-alerts.ts's server-side
   // matcher so the two cannot drift from the wording the cell renders.
   const STALL = new RegExp(${JSON.stringify(STALL_SOURCE)});
   // A tick result (tick-outcome.ts TickResult) in words, with the tone of its outcome.
-  const RESULTS = {
-    changed: ["Landed", "green"],
-    queued: ["Queued to land", "indigo"],
-    no_change: ["No change", "gray"],
-    skipped: ["Skipped", "gray"],
-    refused: ["Refused", "amber"],
-    rejected: ["Rejected in review", "amber"],
-    review_error: ["Review failed", "red"],
-    merge_conflict: ["Merge conflict", "red"],
-    merge_blocked: ["Merge blocked", "red"],
-    error: ["Error", "red"],
-    aborted: ["Interrupted", "amber"],
-    quiet_killed: ["Stalled, resumed", "amber"],
-    user_aborted: ["Aborted by you", "gray"],
-    main_red: ["Main red", "red"],
+  const RESULT_TONES = {
+    changed: "green",
+    queued: "indigo",
+    no_change: "gray",
+    skipped: "gray",
+    refused: "amber",
+    rejected: "amber",
+    review_error: "red",
+    merge_conflict: "red",
+    merge_blocked: "red",
+    error: "red",
+    aborted: "amber",
+    quiet_killed: "amber",
+    user_aborted: "gray",
+    main_red: "red",
   };
   function resultInfo(result) {
-    const r = RESULTS[result];
-    return r ? { label: r[0], tone: r[1] } : { label: String(result || "—").replace(/_/g, " "), tone: "gray" };
+    const words = result ? eventTypeLabel(result) : "—";
+    return { label: words.charAt(0).toUpperCase() + words.slice(1), tone: hasOwn(RESULT_TONES, result) ? RESULT_TONES[result] : "gray" };
   }
   // The problem results and the named event sets are tone.ts's lists, interpolated at module
   // build (like STALL above) so the page cannot drift from the server's eventKind.
@@ -75,7 +94,7 @@ export const GUI_CLIENT_MODEL_JS = String.raw `  // view-model:start
   // loop-sort:start
   // Loop order — status-model.ts's loopRank/sortLoopsByState, the TUI's order too: the running
   // director first (its own live work, outside the maxConcurrent cap it bypasses — BUGS.md
-  // 2026-10-06), then live work (working, reviewing, landing), then work waiting in the pipe
+  // 2026-10-06), then live work (working, reviewing, merge), then work waiting in the pipe
   // line (approved, awaiting a slot), then loops that need attention (failing, main red), then
   // paused, then idle; within a rank the most recent tick first, a never-ticked loop last, ties
   // by name. The phase → rank rules are status-model.ts's LOOP_RANK_RULES (interpolated at
@@ -95,19 +114,19 @@ export const GUI_CLIENT_MODEL_JS = String.raw `  // view-model:start
       const ra = loopRank(a.phase);
       const rb = loopRank(b.phase);
       if (ra !== rb) return ra - rb;
-      const ta = a.lastTickEndedAt ?? 0;
-      const tb = b.lastTickEndedAt ?? 0;
+      const ta = a.lastRunEndedAt ?? 0;
+      const tb = b.lastRunEndedAt ?? 0;
       if (ta !== tb) return tb - ta;
       return a.role.localeCompare(b.role);
     });
   }
   // loop-sort:end
-  // The fleet table's section for each rank. The running director has its own section so it
+  // The team table's section for each rank. The running director has its own section so it
   // does not join the In-progress rows an operator scans against maxConcurrent; the permit
-  // holders (rank 0) and the pipeline waiters (rank 1, labeled "Waiting for a slot") keep
+  // holders (rank 0) and the pipeline waiters (rank 1, labeled "Waiting to start") keep
   // sharing In progress (BUGS.md 2026-10-06).
   const LOOP_GROUPS = [["Director", -1], ["In progress", 0, 1], ["Needs attention", 2], ["Paused", 3], ["Idle", 4]];
-  // The payload's alerts (fleet-alerts.ts fleetAlerts — the TUI's attention lines use the same
+  // The payload's alerts (team-alerts.ts teamAlerts — the TUI's attention lines use the same
   // list), plus the one only the page can know: that its server stopped answering.
   const OFFLINE_ALERT = { key: "offline", tone: "red", title: "Lost contact with the dashboard server",
     detail: "Retrying every second. Everything below is the last state it reported.", actions: [] };
@@ -125,7 +144,7 @@ export const GUI_CLIENT_MODEL_JS = String.raw `  // view-model:start
   const needsYouKeys = (alerts) => alerts.filter(NEEDS_YOU).map((a) => a.key);
   // The needs-you keys of the given alerts that prevKeys (the previous poll's set, or null on
   // the first poll) lacks — exactly the alerts a new cue should announce. A null prev yields
-  // every needs-you key, so a page opened onto an already-alerting fleet cues once.
+  // every needs-you key, so a page opened onto an already-alerting team cues once.
   const newNeedsYouKeys = (prevKeys, alerts) => {
     const prior = new Set(prevKeys || []);
     return needsYouKeys(alerts).filter((k) => !prior.has(k));
@@ -135,9 +154,10 @@ export const GUI_CLIENT_MODEL_JS = String.raw `  // view-model:start
   const ROUTINE_EVENTS = ${JSON.stringify(ROUTINE_EVENTS)};
   const PROBLEM_EVENTS = ${JSON.stringify(PROBLEM_EVENTS)};
   function eventKind(item) {
-    if (item.type === "merged") return "landing";
+    if (item.type === "merged") return "landing"; // vocabulary-ok: internal key the row classes and filters match
     if (item.type === "question_posted") return "attention";
-    if (item.type === "tick_end") return PROBLEM_RESULTS.includes(item.result) ? "problem" : "routine";
+    if (item.type === "entry_refused") return "attention";
+    if (item.type === "run_end") return PROBLEM_RESULTS.includes(item.result) ? "problem" : "routine";
     if (item.type === "build_check") return ROUTINE_BUILD_RESULTS.includes(item.result) ? "routine" : "problem";
     if (PROBLEM_EVENTS.includes(item.type)) return "problem";
     if (ROUTINE_EVENTS.includes(item.type)) return "routine";
@@ -145,7 +165,7 @@ export const GUI_CLIENT_MODEL_JS = String.raw `  // view-model:start
   }
   // A backlog title's trailing "(planned 2026-09-29)"-style note, split off as metadata —
   // the pattern is backlog-structure.ts's ENTRY_STAMP_META_SOURCE (interpolated at module
-  // load, compiled once here), the same regex fleet-alerts.ts strips through via
+  // load, compiled once here), the same regex team-alerts.ts strips through via
   // stripEntryStamp, so a new stamp verb reaches both dashboards from one edit.
   const ENTRY_STAMP_RE = new RegExp(${JSON.stringify(ENTRY_STAMP_META_SOURCE)}, "i");
   function splitTitle(t) {

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

@@ -1,11 +1,13 @@
-import { PAUSE_REASON_MAX } from "../../fleet/fleet-state.js";
-/** The dashboard's fleet-wide operator controls, browser-side, all living in the sidebar so
+// vocabulary: plain
+import { PAUSE_REASON_MAX } from "../../team/team-state.js";
+/** The dashboard's team-wide operator controls, browser-side, all living in the sidebar so
  * they are in reach from every view: the daily spend badge — today's spend against the cap
  * with a meter, a button that opens a small editor for the cap (POST /api/budget, the same
  * setter as the TUI's Ctrl+B) — the pause control, a menu of timed pauses with an
- * optional reason (POST /api/pause with `forSeconds` and `reason`, the CLI's `pause --for`/`--reason`) that turns into a Resume button with
- * the countdown while the fleet is paused, and the sound toggle that mutes the alert cue (a
- * per-browser preference, no server call). Neither keeps optimistic state: after a successful
+ * optional reason (POST /api/pause with `forSeconds` and `reason`, the CLI's
+ * `pause --for`/`--reason`) that turns into a Resume button with the countdown while the
+ * team is paused, and the sound toggle that mutes the alert cue (a per-browser preference,
+ * no server call). Neither keeps optimistic state: after a successful
  * POST the next status poll re-renders them from the server's answer, and a failed one toasts
  * the error and leaves the editor open. Spliced into gui-client.ts's script, where it reaches
  * the other sections' shared plumbing through that concatenation: the DOM and HTML helpers
@@ -55,9 +57,17 @@ export const GUI_CLIENT_OPERATOR_JS = String.raw `  // shared-operator:start
     const pct = (b.spentUsd / b.capUsd) * 100;
     return pct >= 100 ? " t-red" : pct >= 85 ? " t-amber" : "";
   }
+  // The bar under a spend/window readout: a span class='meter{tone}' wrapping a fill whose
+  // width is the spent share. The one home of the markup both the claude-window line
+  // (windowLinesHtml) and the budget card (budgetCardHtml) render, so the class/nesting
+  // cannot drift between them; each call site shapes its own percent (an integer round for
+  // the window, one decimal for the card).
+  function meterBar(tone, pct) {
+    return "<span class='meter" + tone + "'><span style='width:" + pct + "%'></span></span>";
+  }
   // The subscription usage window (plans/agent-backends.md §8, PLANS.md part 6d/7): the
   // sidebar's spend card renders it beside the daily spend, or in its place for a
-  // subscription-only fleet. The label/status/clock rules mirror badges.ts's
+  // subscription-only team. The label/status/clock rules mirror badges.ts's
   // claudeWindowBadge — the preformatted header fragment the TUI uses cannot be reused here
   // because the card lists EVERY window, not just the most constrained one.
   function windowLabel(type) {
@@ -76,13 +86,33 @@ export const GUI_CLIENT_OPERATOR_JS = String.raw `  // shared-operator:start
     const d = new Date(ms);
     return String(d.getHours()).padStart(2, "0") + ":" + String(d.getMinutes()).padStart(2, "0");
   }
-  function windowLine(w, cw) {
+  function windowResets(ms) {
+    const minutes = Math.floor((ms - Date.now()) / 60000);
+    if (minutes < 1) return "resets now";
+    if (minutes < 60) return "resets in " + minutes + "m";
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24) return "resets in " + hours + "h " + (minutes % 60) + "m";
+    return "resets in " + Math.floor(hours / 24) + "d " + (hours % 24) + "h";
+  }
+  function chainMoved(chain) {
+    return Object.values(chain || {}).some((t) => t.reason === "window" || t.reason === "reserve");
+  }
+  // One line per tier off its primary, the same text as badges.ts's chainFragments.
+  function chainLinesHtml(chain) {
+    return ["small", "default", "strong"].filter((tier) => chain && chain[tier]).map((tier) => {
+      const t = chain[tier];
+      const money = t.spentUsd !== undefined && t.capUsd !== undefined ? " " + fmtUsd(t.spentUsd) + "/" + fmtCap(t.capUsd) : "";
+      const until = t.returnsAt !== undefined ? " until " + windowClock(t.returnsAt) : "";
+      return "<span class='side-card-value window-line'>" + esc(tier + " → " + t.pair + money + until) + "</span>";
+    }).join("");
+  }
+  function windowLine(w, cw, chain) {
     const parts = ["Claude " + windowLabel(w.type)];
     const word = windowWord(w.status);
     parts.push(typeof w.utilization === "number" ? Math.round(w.utilization * 100) + "%" : word === "ok" ? "ok · usage not reported" : word);
     if (w.isUsingOverage) parts.push("overage");
-    if (w.status === "rejected" && cw.heldUntil != null) parts.push("held until " + windowClock(cw.heldUntil));
-    else if (w.status !== "reset" && typeof w.resetsAt === "number") parts.push("resets " + windowClock(w.resetsAt));
+    if (w.status === "rejected" && cw.heldUntil != null) parts.push((chainMoved(chain) ? "on fallback until " : "held until ") + windowClock(cw.heldUntil));
+    else if (w.status !== "reset" && typeof w.resetsAt === "number") parts.push(windowResets(w.resetsAt));
     return parts.join(" · ");
   }
   function windowLineTone(w) {
@@ -90,28 +120,35 @@ export const GUI_CLIENT_OPERATOR_JS = String.raw `  // shared-operator:start
     if (w.status === "allowed_warning") return " t-amber";
     return "";
   }
-  function windowLinesHtml(cw) {
-    if (!cw) return "";
-    return cw.windows.map((w) => {
-      const line = "<span class='side-card-value window-line" + windowLineTone(w) + "'>" + esc(windowLine(w, cw)) + "</span>";
+  function windowLinesHtml(cw, chain) {
+    if (!cw) return chainLinesHtml(chain);
+    // Shortest window first (5h above 7d), whatever order the server ranks severity in; an
+    // unlabelled type sorts last, then by type name. A copy, so cw.windows keeps its order.
+    const hours = (w) => {
+      const m = /^(\d+)([hdw])$/.exec(windowLabel(w.type));
+      return m ? Number(m[1]) * (m[2] === "h" ? 1 : m[2] === "d" ? 24 : 168) : Infinity;
+    };
+    const shortestFirst = cw.windows.slice().sort((a, b) => (hours(a) === hours(b) ? (a.type < b.type ? -1 : a.type > b.type ? 1 : 0) : hours(a) < hours(b) ? -1 : 1));
+    return shortestFirst.map((w) => {
+      const line = "<span class='side-card-value window-line" + windowLineTone(w) + "'>" + esc(windowLine(w, cw, chain)) + "</span>";
       if (typeof w.utilization !== "number") return line;
       const pct = Math.min(100, Math.round(w.utilization * 100));
-      return line + "<span class='meter" + windowLineTone(w) + "'><span style='width:" + pct + "%'></span></span>";
-    }).join("");
+      return line + meterBar(windowLineTone(w), pct);
+    }).join("") + chainLinesHtml(chain);
   }
-  // The sidebar's spend card for a payload's budget block: a plain card for an all-free fleet
+  // The sidebar's spend card for a payload's budget block: a plain card for an all-free team
   // (no spend a cap could bind, so no editor), otherwise the button that opens the cap editor,
   // with a meter while a cap is set.
-  function budgetCardHtml(b, cw) {
-    // A subscription-only fleet has no priced spend for a cap to bind, so the window card
+  function budgetCardHtml(b, cw, chain) {
+    // A subscription-only team has no priced spend for a cap to bind, so the window card
     // stands in place of the spend card and carries no editor.
     if (cw && cw.only) {
-      return "<div class='side-card' title='Claude.ai subscription usage windows — a rejected window holds the claude seams until it resets'>" +
-        "<span class='side-card-label'>" + icon("clock") + "Claude window</span>" + windowLinesHtml(cw) + "</div>";
+      return "<div class='side-card' title='Claude.ai subscription usage windows — a rejected window pauses claude model jobs until it resets'>" +
+        "<span class='side-card-label'>" + icon("clock") + "Claude window</span>" + windowLinesHtml(cw, chain) + "</div>";
     }
     if (b.free) {
-      return "<div class='side-card' title='Every model the fleet can use is cost n/a, so there is nothing to cap'>" +
-        "<span class='side-card-label'>" + icon("dollar") + "Spend</span><span class='side-card-value'>Free models</span>" + windowLinesHtml(cw) + "</div>";
+      return "<div class='side-card' title='Every model the team can use is cost n/a, so there is nothing to cap'>" +
+        "<span class='side-card-label'>" + icon("dollar") + "Spend</span><span class='side-card-value'>Free models</span>" + windowLinesHtml(cw, chain) + "</div>";
     }
     const capped = b.capUsd > 0;
     const pct = capped ? Math.min(100, (b.spentUsd / b.capUsd) * 100) : 0;
@@ -120,12 +157,12 @@ export const GUI_CLIENT_OPERATOR_JS = String.raw `  // shared-operator:start
       esc(capped ? "Today's spend against the daily cap — click to change the cap" : "No daily cap — click to set one") + "'>" +
       "<span class='side-card-label'>" + icon("dollar") + "Spent today<span class='edit'>" + (capped ? "Edit cap" : "Set a cap") + "</span></span>" +
       "<span class='side-card-value'>" + esc(fmtUsd(b.spentUsd)) + " <small>" + esc(capped ? "of " + fmtCap(b.capUsd) : "no daily cap") + "</small></span>" +
-      (capped ? "<span class='meter" + tone + "'><span style='width:" + pct.toFixed(1) + "%'></span></span>" : "") + windowLinesHtml(cw) + "</button>";
+      (capped ? meterBar(tone, pct.toFixed(1)) : "") + windowLinesHtml(cw, chain) + "</button>";
   }
   function renderBudgetBadge(d) {
     if (budgetEditing) return; // the open editor owns the slot until save or cancel
     const b = d && d.budget;
-    paintPanel("budgetwrap", b ? budgetCardHtml(b, d && d.claudeWindow) : "");
+    paintPanel("budgetwrap", b ? budgetCardHtml(b, d && d.claudeWindow, d && d.chain) : "");
   }
   function openBudgetEditor() {
     const b = lastStatus && lastStatus.budget;
@@ -137,7 +174,7 @@ export const GUI_CLIENT_OPERATOR_JS = String.raw `  // shared-operator:start
       html: "<label for='budgetinput'>Daily spend cap</label>" +
         "<div class='input-prefix'><span>$</span><input type='number' min='0' step='0.01' id='budgetinput' value='" +
         esc(b.capUsd > 0 ? String(b.capUsd) : "") + "' placeholder='no cap'></div>" +
-        "<p class='hint'>" + esc("Spent today: " + fmtUsd(b.spentUsd) + ". At the cap the loops " +
+        "<p class='hint'>" + esc("Spent today: " + fmtUsd(b.spentUsd) + ". At the cap the roles " +
           (b.fallback ? "switch to the free fallback model" : "pause") + " until midnight. Leave it empty for no cap.") + "</p>" +
         "<div class='popover-actions'><button type='button' class='btn btn-sm' id='budgetcancel'>Cancel</button>" +
         "<button type='button' class='btn btn-sm btn-primary' id='budgetset'>Save</button></div>",
@@ -211,20 +248,20 @@ export const GUI_CLIENT_OPERATOR_JS = String.raw `  // shared-operator:start
   let pauseMenuOpen = false;
   // The timed pauses the menu offers; 0 is a standing pause that lasts until Resume.
   const PAUSE_CHOICES = [[1800, "For 30 minutes"], [3600, "For 1 hour"], [7200, "For 2 hours"], [28800, "For 8 hours"], [0, "Until I resume it"]];
-  // How long a timed fleet pause has left (humanSeconds), or "" for a standing one.
+  // How long a timed team pause has left (humanSeconds), or "" for a standing one.
   function pauseLeft(d) {
     return d.pausedUntil ? humanSeconds(Math.max(0, Math.round((d.pausedUntil - Date.now()) / 1000))) : "";
   }
-  // The sidebar's pause control: Resume (with a timed pause's countdown) while the fleet is
+  // The sidebar's pause control: Resume (with a timed pause's countdown) while the team is
   // paused, otherwise the button that opens the menu of timed pauses.
   function pauseControlHtml(d) {
     if (d.paused) {
       const left = pauseLeft(d);
-      return "<button type='button' class='btn btn-warn' id='pausebadge' title='" + esc("The fleet is paused — click to resume it" + (d.pauseReason ? " (" + d.pauseReason + ")" : "")) + "'>" +
-        icon("play") + "<span>Resume the fleet</span><span class='btn-note' id='pausenote'>" + (left ? esc(left) + " left" : "") + "</span></button>";
+      return "<button type='button' class='btn btn-warn' id='pausebadge' title='" + esc("The team is paused — click to resume it" + (d.pauseReason ? " (" + d.pauseReason + ")" : "")) + "'>" +
+        icon("play") + "<span>Resume the team</span><span class='btn-note' id='pausenote'>" + (left ? esc(left) + " left" : "") + "</span></button>";
     }
-    return "<button type='button' class='btn' id='pausebadge' aria-haspopup='menu' title='Pause the fleet — loops start no new ticks'>" +
-      icon("pause") + "<span>Pause the fleet</span><span class='btn-note'>" + icon("chev") + "</span></button>";
+    return "<button type='button' class='btn' id='pausebadge' aria-haspopup='menu' title='Pause the team — roles start no new runs'>" +
+      icon("pause") + "<span>Pause the team</span><span class='btn-note'>" + icon("chev") + "</span></button>";
   }
   function renderPauseBadge(d) {
     if (pauseMenuOpen) return;
@@ -241,11 +278,11 @@ export const GUI_CLIENT_OPERATOR_JS = String.raw `  // shared-operator:start
     const pop = openPopover("pausewrap", {
       menu: true,
       role: "menu",
-      html: "<div class='menu-title'>Pause the fleet</div>" +
+      html: "<div class='menu-title'>Pause the team</div>" +
         "<input type='text' id='pausereason' class='menu-input' maxlength=${PAUSE_REASON_MAX} placeholder='Reason (optional)' aria-label='Pause reason' style='margin:2px 10px 4px;width:calc(100% - 20px)'>" +
         PAUSE_CHOICES.map((c) => "<button type='button' class='menu-item' role='menuitem' data-pause='" + c[0] + "'>" +
           icon(c[0] ? "clock" : "pause") + esc(c[1]) + "</button>").join("") +
-        "<p class='hint' style='margin:4px 10px 4px'>In-flight ticks finish, and the director keeps running your prompts.</p>",
+        "<p class='hint' style='margin:4px 10px 4px'>Current runs finish, and the director keeps running your messages.</p>",
       onClosed: () => {
         pauseMenuOpen = false;
         renderPauseBadge(lastStatus);
@@ -255,20 +292,20 @@ export const GUI_CLIENT_OPERATOR_JS = String.raw `  // shared-operator:start
     const first = pop.querySelector("button");
     if (first) first.focus({ preventScroll: true });
   }
-  async function setFleetPause(paused, forSeconds, reason) {
+  async function setTeamPause(paused, forSeconds, reason) {
     const body = { paused: paused };
     if (paused && forSeconds > 0) body.forSeconds = forSeconds;
     const why = paused && reason ? String(reason).trim() : "";
     if (why) body.reason = why;
     // A failure changes nothing; the control still shows the real state.
     await postAction("/api/pause", body, paused
-      ? "Fleet paused" + (forSeconds > 0 ? " for " + humanSeconds(forSeconds) : "") + " — in-flight ticks finish"
-      : "Fleet resumed");
+      ? "Team paused" + (forSeconds > 0 ? " for " + humanSeconds(forSeconds) : "") + " — current runs finish"
+      : "Team resumed");
   }
   onClick((t, ev) => {
     if (t.closest("#pausebadge")) {
       ev.preventDefault();
-      if (lastStatus && lastStatus.paused) setFleetPause(false);
+      if (lastStatus && lastStatus.paused) setTeamPause(false);
       else if (pauseMenuOpen) closeMenus();
       else openPauseMenu();
       return;
@@ -276,14 +313,67 @@ export const GUI_CLIENT_OPERATOR_JS = String.raw `  // shared-operator:start
     const choice = t.closest("[data-pause]");
     if (choice) {
       const input = $("pausereason");
-      setFleetPause(true, Number(choice.dataset.pause), input ? input.value : "");
+      setTeamPause(true, Number(choice.dataset.pause), input ? input.value : "");
     }
   });
   // pause-control:end
 
+  // stop-control:start
+  let stopMenuOpen = false;
+  // The delays the menu offers for a scheduled graceful stop.
+  const STOP_CHOICES = [[3600, "In 1 hour"], [7200, "In 2 hours"], [14400, "In 4 hours"], [28800, "In 8 hours"]];
+  // The sidebar's scheduled-stop control: nothing while the team is stopped; Cancel while a
+  // stop is scheduled; otherwise the button that opens the menu of delays. No immediate stop:
+  // under run --gui it would take the page down mid-click.
+  function stopControlHtml(d) {
+    if (!d || !d.running) return "";
+    if (d.scheduledStopAt) {
+      return "<button type='button' class='btn btn-warn' id='stopbadge' title='A stop is scheduled — click to cancel it'>" +
+        icon("stop") + "<span>Cancel scheduled stop</span></button>";
+    }
+    return "<button type='button' class='btn' id='stopbadge' aria-haspopup='menu' title='Stop the team later — current runs finish, then it stops'>" +
+      icon("stop") + "<span>Stop the team later</span><span class='btn-note'>" + icon("chev") + "</span></button>";
+  }
+  function renderStopControl(d) {
+    if (stopMenuOpen) return;
+    paintPanel("stopwrap", stopControlHtml(d));
+  }
+  function openStopMenu() {
+    const pop = openPopover("stopwrap", {
+      menu: true,
+      role: "menu",
+      html: "<div class='menu-title'>Stop the team later</div>" +
+        STOP_CHOICES.map((c) => "<button type='button' class='menu-item' role='menuitem' data-stopin='" + c[0] + "'>" +
+          icon("clock") + esc(c[1]) + "</button>").join("") +
+        "<p class='hint' style='margin:4px 10px 4px'>Current runs finish, then the team stops.</p>",
+      onClosed: () => {
+        stopMenuOpen = false;
+        renderStopControl(lastStatus);
+      },
+    });
+    stopMenuOpen = true;
+    const first = pop.querySelector("button");
+    if (first) first.focus({ preventScroll: true });
+  }
+  function postStopSchedule(body) {
+    return postAction("/api/stop-schedule", body, (d) => d && typeof d.message === "string" ? d.message : "Stop schedule updated");
+  }
+  onClick((t, ev) => {
+    if (t.closest("#stopbadge")) {
+      ev.preventDefault();
+      if (lastStatus && lastStatus.scheduledStopAt) postStopSchedule({ cancel: true });
+      else if (stopMenuOpen) closeMenus();
+      else openStopMenu();
+      return;
+    }
+    const choice = t.closest("[data-stopin]");
+    if (choice) postStopSchedule({ inSeconds: Number(choice.dataset.stopin) });
+  });
+  // stop-control:end
+
   // sound-control:start
   // The sidebar's sound control, beside the theme toggle: a speaker icon that flips between
-  // the unmuted and muted glyph. A per-browser preference (setSoundMuted stores it), not fleet
+  // the unmuted and muted glyph. A per-browser preference (setSoundMuted stores it), not team
   // state — no server call; the choice takes effect on the next cue.
   function soundControlHtml() {
     return "<button type='button' class='icon-btn' id='soundtoggle' title='" +

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

@@ -1,11 +1,12 @@
-/** The dashboard's Pending view, browser-side: every loop's unlanded change as /api/diff
+// vocabulary: plain
+/** The dashboard's Pending view, browser-side: every loop's unmerged change as /api/diff
  * serves it (the same document `tumwater diff` prints from the shared change collectors). The
  * roster shows each role's branch, state, commits ahead of main with their subjects, and its
  * uncommitted-file count; a row opens that loop's drawer, whose Pending change section fetches
  * the full patch (`/api/diff?role=<id>`). It refetches when the view opens and when its
  * Refresh button is pressed — never on a timer of its own. Spliced into gui-client.ts's
  * script, reaching its helpers (esc, getJson, icon, errorPanel) through that concatenation. */
-export const GUI_CLIENT_PENDING_JS = String.raw `  let pendingFleet = null;
+export const GUI_CLIENT_PENDING_JS = String.raw `  let pendingTeam = null;
   // pending-table:start
   // One role's state cell: the collector's three states, with "ready" split into pending vs
   // idle work. Never colors a degraded state as an active one.
@@ -13,10 +14,10 @@ export const GUI_CLIENT_PENDING_JS = String.raw `  let pendingFleet = null;
     if (r.state === "absent") return "<span class='muted'>no worktree</span>";
     if (r.state === "no-base") return "<span class='muted'>no base</span>";
     if (r.state !== "ready") return "<span class='muted'>unknown</span>";
-    if (r.ahead === 0 && (!r.dirtyFiles || r.dirtyFiles.length === 0)) return "<span class='muted'>no unlanded work</span>";
+    if (r.ahead === 0 && (!r.dirtyFiles || r.dirtyFiles.length === 0)) return "<span class='muted'>no unmerged work</span>";
     return "<span class='res t-indigo'>pending</span>";
   }
-  // One role's ahead cell: the commit count plus each unlanded commit's sha and subject, or a
+  // One role's ahead cell: the commit count plus each unmerged commit's sha and subject, or a
   // dash for a degraded/empty role.
   function pendingAheadHtml(r) {
     if (r.state !== "ready" || !r.ahead) return "<span class='muted'>—</span>";
@@ -30,69 +31,72 @@ export const GUI_CLIENT_PENDING_JS = String.raw `  let pendingFleet = null;
   }
   // The Pending roster: one clickable row per known role (the collector's config order), each
   // opening that loop's drawer. Pure — the view paints what this returns.
-  function pendingTableHtml(fleet) {
-    if (!fleet || !Array.isArray(fleet.roles) || fleet.roles.length === 0)
-      return "<div class='empty'><strong>No loops yet</strong>Loops appear here once the fleet is configured.</div>";
-    if (fleet.roles.every((r) => r.state === "no-base"))
-      return "<div class='empty'><strong>Main branch " + esc(fleet.mainBranch) + " does not exist</strong>There is no base to compare unlanded work against.</div>";
-    const rows = fleet.roles.map((r) =>
+  function pendingTableHtml(team) {
+    if (!team || !Array.isArray(team.roles) || team.roles.length === 0)
+      return "<div class='empty'><strong>No roles yet</strong>Roles appear here once the team is configured.</div>";
+    if (team.roles.every((r) => r.state === "no-base"))
+      return "<div class='empty'><strong>Main branch " + esc(team.mainBranch) + " does not exist</strong>There is no base to compare unmerged work against.</div>";
+    const rows = team.roles.map((r) =>
       "<tr class='clickable' data-open='" + esc(r.role) + "'>" +
-      "<td class='mono'>" + esc(r.role) + "</td>" +
+      "<td class='mono'>" + esc(roleLabel(r.role)) + "</td>" +
       "<td class='mono muted'>" + esc(r.branch) + "</td>" +
       "<td>" + pendingStateHtml(r) + "</td>" +
       "<td>" + pendingAheadHtml(r) + "</td>" +
       "<td class='num'>" + pendingDirtyHtml(r) + "</td></tr>",
     ).join("");
-    return "<div class='table-wrap'><table class='table pending'><thead><tr><th class='c-loop'>Loop</th><th>Branch</th>" +
-      "<th>State</th><th>Ahead of " + esc(fleet.mainBranch) + "</th><th class='c-dirty num'>Uncommitted</th></tr></thead><tbody>" + rows + "</tbody></table></div>";
+    return "<div class='table-wrap'><table class='table pending'><thead><tr><th class='c-loop'>Role</th><th>Branch</th>" + // vocabulary-ok: CSS class the stylesheet matches
+      "<th>State</th><th>Ahead of " + esc(team.mainBranch) + "</th><th class='c-dirty num'>Uncommitted</th></tr></thead><tbody>" + rows + "</tbody></table></div>";
   }
-  // The Land queue card's body: every queued landing in execution order (oldest first), one
-  // line each mirroring tumwater queue's renderLandingQueue — 1-based position, loop, tick,
+  // The Merge queue card's body: every queued merge in execution order (oldest first), one
+  // line each mirroring tumwater queue's renderMergeQueue — 1-based position, loop, tick,
   // short sha, age, summary — so the page and the CLI cannot drift. Painted from the status
   // payload the page already polls; depth counts the unreadable queue files the status reader
   // skips, so a positive depth with no readable list states the count instead of inventing rows.
   // Pure: the age comes from the passed now, and a malformed entry renders a stand-in rather
   // than undefined/NaN. Null/absent/zero-depth reads as empty.
-  function pendingQueueHtml(landQueue, now) {
-    const depth = landQueue && Number.isFinite(landQueue.depth) ? landQueue.depth : 0;
-    const entries = landQueue && Array.isArray(landQueue.entries) ? landQueue.entries : [];
+  function pendingQueueHtml(mergeQueue, now, labels) {
+    const depth = mergeQueue && Number.isFinite(mergeQueue.depth) ? mergeQueue.depth : 0;
+    const entries = mergeQueue && Array.isArray(mergeQueue.entries) ? mergeQueue.entries : [];
     let body;
     if (depth === 0) {
-      body = "<div class='empty'>Land queue empty</div>";
+      body = "<div class='empty'>Merge queue empty</div>";
     } else if (entries.length === 0) {
-      body = "<div class='empty'>land queue: " + esc(depth) + " waiting</div>";
+      body = "<div class='empty'>merge queue: " + esc(depth) + " waiting</div>";
     } else {
       body = "<div style='padding:10px 16px 12px'>" + entries.map((e, i) => {
         const sec = Number.isFinite(e.enqueuedAt) ? Math.max(0, Math.round((now - e.enqueuedAt) / 1000)) : 0;
-        const tick = Number.isFinite(e.tick) ? e.tick : "?";
-        return "<div class='mono clamp1' style='padding:3px 0'>" + (i + 1) + ". " + esc(e.role || "?") +
-          " tick #" + esc(tick) + " · " + esc(shortSha(e.sha)) + " · " + esc(humanSeconds(sec)) +
-          " ago · " + esc(e.summary || "—") + "</div>";
+        const run = Number.isFinite(e.run) ? e.run : "?";
+        const note = Number.isFinite(e.revisionRound) ? " · revision " + e.revisionRound + (Number.isFinite(e.priorObjections) && e.priorObjections > 0 ? " · " + plural(e.priorObjections, "prior objection") : "") : "";
+        return "<div class='mono clamp1' style='padding:3px 0'>" + (i + 1) + ". " + esc(e.role ? roleLabel(e.role) : "?") +
+          " run #" + esc(run) + " · " + esc(shortSha(e.sha)) + " · " + esc(humanSeconds(sec)) +
+          " ago" + (Array.isArray(labels) && labels[i] && typeof labels[i] === "string" ? " · [" + esc(labels[i]) + "]" : "") +
+          note +
+          " · " + esc(e.summary || "—") + "</div>";
       }).join("") + "</div>";
     }
-    return "<div class='card-head'><h2>Land queue</h2></div>" + body;
+    return "<div class='card-head'><h2>Merge queue</h2></div>" + body;
   }
   // pending-table:end
-  // Paint the Land queue card from the polled status payload, at paint-time age; no fetch of
+  // Paint the Merge queue card from the polled status payload, at paint-time age; no fetch of
   // its own (the entries ride /api/status, unlike the roster's /api/diff).
   function renderPendingQueue(status) {
     const card = $("pendingqueue");
     if (!card) return;
-    card.innerHTML = pendingQueueHtml(status && status.landQueue, Date.now());
+    card.innerHTML = pendingQueueHtml(status && status.mergeQueue, Date.now(), status && status.mergeQueueLabels);
   }
   function buildPendingView() {
-    if (!buildOnce("pending", "<div class='view-head'><div><h1>Pending</h1><p>Every loop's unlanded change — its branch, commits ahead of main, and uncommitted files. Open a row for the full diff.</p></div>" +
+    if (!buildOnce("pending", "<div class='view-head'><div><h1>Pending</h1><p>Every role's unmerged change — its branch, commits ahead of main, and uncommitted files. Open a row for the full diff.</p></div>" +
       "<div class='toolbar'><button type='button' class='btn btn-sm' id='pendingrefresh'>" + icon("refresh") + "Refresh</button></div></div>" +
       "<div class='card' id='pendingqueue'><div class='empty'>Loading…</div></div>" +
       "<div class='card' id='pendingbody'><div class='empty'>Loading…</div></div>")) return;
     $("pendingrefresh").addEventListener("click", () => fetchPending());
   }
-  // Load the fleet-wide change roster. Called when the view opens and by the Refresh button;
-  // no timer of its own, and the roster only changes when a loop lands or edits its worktree.
+  // Load the team-wide change roster. Called when the view opens and by the Refresh button;
+  // no timer of its own, and the roster only changes when a loop merges or edits its worktree.
   async function fetchPending() {
     buildPendingView();
     try {
-      pendingFleet = await getJson("/api/diff");
+      pendingTeam = await getJson("/api/diff");
     } catch (err) {
       const body = $("pendingbody");
       if (body) body.innerHTML = errorPanel("Pending unavailable", err);
@@ -104,6 +108,6 @@ export const GUI_CLIENT_PENDING_JS = String.raw `  let pendingFleet = null;
   function renderPending() {
     const body = $("pendingbody");
     if (!body) return;
-    body.innerHTML = pendingTableHtml(pendingFleet);
+    body.innerHTML = pendingTableHtml(pendingTeam);
   }
 `;