tumwater 0.4.2 → 0.4.4

package/dist/src/text/text.js

@@ -12,6 +12,7 @@
  * depends on node built-ins alone, so any layer (harness or observer) can import it without
  * reaching into another module's internals — and the collapse/truncation/compaction/
  * abbreviation semantics live in exactly one place instead of drifting per consumer. */
+import { distinctOrdered } from "../collections.js";
 /** Collapse every run of whitespace to a single space and trim both ends — the shape every
  * one-line label takes before display (multi-line pi text, command strings, error messages). */
 export function collapseWhitespace(s) {
@@ -94,9 +95,9 @@ export function gotSuffix(v) {
  * and its legacy provider, exempt paths, custom-role tasks), pi-event-line.ts's tool-result content
  * test, quiet-hours.ts's per-role window lookup, and inbox-attachments.ts's image-name check, so
  * the blank-means-unset rule cannot drift per call site. Callers where a bare empty string means
- * unset rather than blank text (notify.ts, version.ts, inbox-cancel.ts) keep their own `=== ""`
- * check; typed-string callers (checkStringField's two-branch shape, checkStringArray's blank-index
- * report) spell the trim test inline. */
+ * unset rather than blank text (event-notify.ts, version.ts, inbox-cancel.ts) keep their own
+ * `=== ""` check; typed-string callers (checkStringField's two-branch shape,
+ * checkStringArray's blank-index report) spell the trim test inline. */
 export function isNonBlankString(v) {
     return typeof v === "string" && v.trim() !== "";
 }
@@ -112,7 +113,7 @@ export function splitCommaList(raw) {
  * filter and the GUI's `role` and `model` query parameters, each of which treats a repeat as
  * the same selector. */
 export function splitCommaListUnique(raw) {
-    return [...new Set(splitCommaList(raw))];
+    return distinctOrdered(splitCommaList(raw));
 }
 /** A value or list of `T` as a list: a bare `T` is one item, an array stays itself. The
  * single home of the string-or-list normalization (a `--role` selector is either one id or a
@@ -272,5 +273,5 @@ export function tooLongMessage(subject, n, max, tail) {
  * role-note missing-path scan (run/run-prompt.ts), so the two agree on what reads as a path. */
 export function pathTokens(text) {
     const tokenRe = /[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)+\.[A-Za-z0-9]+/g;
-    return [...new Set([...text.matchAll(tokenRe)].map((m) => m[0]))];
+    return distinctOrdered([...text.matchAll(tokenRe)].map((m) => m[0]));
 }

package/dist/src/ui/alert-feeds.js

@@ -1,115 +1,50 @@
-import { openQuestionEntries, ageInDays } from "../backlog/backlog.js";
-import { stripEntryStamp } from "../backlog/backlog-structure.js";
-import { questionFilingDate } from "../backlog/question-answer.js";
-import { byDaysThenIndex } from "../collections.js";
-import { eventsSince } from "../events/event-window.js";
-import { STALE_QUESTION_DAYS } from "../doctor/doctor-backlog.js";
-import { regressedFixCandidates, matchedRegressedFixes, regressedFixesPhrase } from "../doctor/doctor-backlog-bugs.js";
-import { planDependencyProblem } from "../doctor/doctor-backlog-plans.js";
-import { checkWaitContention, providerConcurrencyProblems, providerWaitContention, slotWaitContention, smallPoolProblems, staleWorkspacePins, CHECK_WAIT_CHECK_WINDOW_MS, PROVIDER_WAIT_CHECK_WINDOW_MS, SLOT_WAIT_CHECK_WINDOW_MS } from "../doctor/doctor-contention-checks.js";
-import { readSlotsState } from "../git/slots-state.js";
-import { configForStatus } from "../status/status-polls.js";
-import { piModelsPath } from "../pi/pi-models.js";
-import { piSettingsPath, readPiDefaultModel } from "../pi/pi-settings.js";
-/** This module is the alert-feed half of src/ui/status-payload.ts: each always-on team alert's
- * data-sourcing function (capacityContention, …) lives here, a
- * sibling of the src/ui/team-alert-*.ts builders that turn them into banners. status-payload.ts
- * stays the one status-document builder, importing these feeds and folding each feed's result
- * into the `alerts` field; status-render.ts reads the feeds directly for the TUI. */
-/** The open questions the doctor's 7-day rule (src/doctor/doctor-backlog-bugs.ts
- * checkStaleQuestions, STALE_QUESTION_DAYS) calls stale: an open QUESTIONS.md entry whose
- * `(asked by …)` stamp is at least 7 days old. This is the always-on feed for the stale-questions
- * team alert — the shared rule's twin on every observer surface, computed from the same threshold
- * and the same questionFilingDate parser the doctor's check uses, so the two cannot drift on which
- * questions are stale. An undated heading is skipped (like the doctor's check); questions carry no
- * refused note to filter. The returned objects carry the 1-based position (for
- * `tumwater questions answer <n>`), the 0-based index (kept only as the file-order tiebreak), the
- * stamp-stripped title, and the whole-day age. Returned oldest-first — most days waited, ties in
- * file order — so a caller naming the first element names the most-stale question. */
-export function staleOpenQuestions(root, now = Date.now()) {
-    return openQuestionEntries(root)
-        .flatMap((entry, index) => {
-        const stamp = questionFilingDate(entry.title);
-        if (stamp === null)
-            return [];
-        const days = ageInDays(stamp, now);
-        return days >= STALE_QUESTION_DAYS ? [{ index, position: index + 1, title: stripEntryStamp(entry.title), days }] : [];
-    })
-        .sort(byDaysThenIndex);
+import { findOrphans, orphanFailDetail } from "../doctor/doctor-orphans.js";
+import { systemProcessProbe } from "../process/process-table.js";
+/** The orphan scan's alert shape, given a scan it is handed — the pure feed, so a test stages a
+ * fake probe's scan and gets exactly the row's message without a real host (the shared
+ * findOrphans/orphanFailDetail the doctor row reads, so the two cannot drift). `root` trims this
+ * repo's path from the commands, like the doctor row. */
+export function orphanAlertFromScan(scan, root = "") {
+    if ("error" in scan || scan.orphans.length === 0)
+        return null;
+    const detail = orphanFailDetail(root, scan);
+    return detail === null ? null : { count: scan.orphans.length, detail };
 }
-/** A broken plan-dependency clause, the always-on twin of the doctor's `plan dependencies` row
- * (src/doctor/doctor-backlog-plans.ts checkPlanDependencies): the same rule's problem set,
- * severity order, and exact message, so the alert and the doctor cannot drift. The reader owns
- * the rule — planDependencyAlert passes the doctor's planDependencyProblem through unchanged,
- * like staleOpenQuestions and the other stale feeds do their doctor's rules. null when PLANS.md's
- * planned entries have no cycle, dangling ref, unparsed clause, or misworded dependency. */
-export function planDependencyAlert(root) {
-    return planDependencyProblem(root);
+/** Run the doctor's orphan scan and shape it into the standing alert. Async (it does the real
+ * process-table read); the always-on surfaces read it through getOrphanAlert's cache below, so
+ * a status frame never blocks on the host scan. */
+export async function refreshOrphanAlert(root, probe = systemProcessProbe) {
+    return orphanAlertFromScan(await findOrphans(root, probe), root);
 }
-/** @see CapacityBottleneck */
-export function capacityContention(root, now = Date.now()) {
-    const out = [];
-    /** Resolve one capacity verdict and push a "capacity bottleneck" row when it warns. Shared
-     * by the three capacity checks (workspace, provider, check slots) so the try/catch that keeps
-     * each one from crying wolf on an unreadable event log lives in one place, and the row's
-     * `name`/`detail` shape cannot drift between them. */
-    const maybeWarn = (name, windowMs, keep, resolve) => {
-        try {
-            const verdict = resolve(eventsSince(root, windowMs, now, keep));
-            if (verdict.warn)
-                out.push({ name, detail: verdict.detail });
+/** How stale a cached orphan scan may be before the next status read starts a fresh one:
+ * orphan leaks grow over days, so a sixty-second refresh is plenty and keeps the host scan
+ * (one `ps`, plus cwd reads only for the parentless candidates argv did not settle) off the
+ * hot render path. */
+const ORPHAN_ALERT_REFRESH_MS = 60_000;
+let orphanCache = null;
+let orphanLoading = false;
+/** The synchronous orphan feed the always-on surfaces (status-payload, status-render, the TUI)
+ * read each frame: the last scan's value while it is fresher than ORPHAN_ALERT_REFRESH_MS, else a
+ * background refresh is kicked (one at a time) and the previous value — null on the first ever
+ * read — is returned until that scan lands. The refresh runs off the render path, so a slow host
+ * scan never stalls a status frame. Per-process: each long-lived surface (the GUI server, the
+ * TUI) and the CLI each run their own throttled scan against the same doctor rule. */
+export function getOrphanAlert(root, probe = systemProcessProbe, now = Date.now()) {
+    if (orphanCache === null || now - orphanCache.at >= ORPHAN_ALERT_REFRESH_MS) {
+        if (!orphanLoading) {
+            orphanLoading = true;
+            void (async () => {
+                try {
+                    orphanCache = { value: await refreshOrphanAlert(root, probe), at: Date.now() };
+                }
+                catch {
+                    orphanCache = { value: null, at: Date.now() };
+                }
+                finally {
+                    orphanLoading = false;
+                }
+            })();
         }
-        catch {
-            // A read error skips this row, so the alert never cries wolf on an unreadable log.
-        }
-    };
-    maybeWarn("workspace slots", SLOT_WAIT_CHECK_WINDOW_MS, (ev) => ev.type === "slot_wait", (waits) => slotWaitContention(waits, readSlotsState(root).slots.length));
-    maybeWarn("provider slots", PROVIDER_WAIT_CHECK_WINDOW_MS, (ev) => ev.type === "provider_wait", (waits) => providerWaitContention(waits, configForStatus(root)));
-    maybeWarn("check slots", CHECK_WAIT_CHECK_WINDOW_MS, (e) => e.type === "check_wait", (waits) => checkWaitContention(waits, configForStatus(root)));
-    return out;
-}
-/** A `maxConcurrentPerProvider` map that cannot do its job — the always-on twin of the doctor's
- * `provider concurrency` row (src/doctor/doctor-contention-checks.ts checkProviderConcurrency):
- * a cap key no seam resolves to (a typo, or a provider the team never runs on), a cap at or
- * above `maxConcurrent` (it never binds), or a keyless seam in a capped team. The `contention`
- * and `provider-hold` alerts fire only once a too-small cap has already parked runs or a storm
- * has struck; this standing alert names the static misconfiguration itself, which the doctor
- * row is the only other surface that otherwise exposes. Reads the same last-known-good config
- * the snapshot uses (configForStatus) and audits it through the row's own
- * providerConcurrencyProblems, so the alert and the row cannot drift on the trigger or the
- * wording; `[]` when no cap is configured or the map is well-formed. */
-export function providerCapProblems(root) {
-    return providerConcurrencyProblems(configForStatus(root), readPiDefaultModel(piSettingsPath(piModelsPath()), root));
-}
-/** The always-on twin of the doctor `parallel instances` row's pool-mismatch clause
- * (doctor-contention-checks.ts smallPoolProblems): an enabled `feature`/`bugfix` running
- * more than one instance while slotCount(config) sits below maxConcurrent — the shared pool
- * is smaller than the run cap, so those instances contend for the same checkouts. Built from
- * the same smallPoolProblems selector the doctor row uses, so the alert and the row cannot
- * drift on the trigger, the role list, or the wording. configForStatus never returns
- * undefined (an unreadable tumwater.json falls back to defaultConfig(), whose pool is the
- * default maxConcurrent + 1 — never below maxConcurrent), so the [] is the only silent
- * outcome. */
-export function instancePoolProblems(root) {
-    return smallPoolProblems(configForStatus(root));
-}
-/** How far back the regressed-fixes alert looks — one day, so a recently Fixed test that failed
- * again is a standing amber alert until a day passes (or the failure is filed). The doctor's
- * own `regressed fixes` row keeps its since-the-fix read; this is the alert's daily trigger, the
- * same trailing day the regressed-fixes alert reads. */
-export const REGRESSED_FIX_WINDOW_MS = 24 * 60 * 60_000;
-/** The always-on twin of the doctor's `regressed fixes` row (src/doctor/doctor-backlog-bugs.ts
- * checkRegressedFixes): the same candidate selection (regressedFixCandidates) and the same
- * failureMentions match (matchedRegressedFixes) and sentence (regressedFixesPhrase), read off the
- * trailing REGRESSED_FIX_WINDOW_MS of events (the doctor, whose window is since each fix, still
- * warns on an older recurrence). An unreadable event log yields none. */
-export function regressedFixesAlert(root, now = Date.now()) {
-    const candidates = regressedFixCandidates(root);
-    const rows = matchedRegressedFixes(candidates, eventsSince(root, REGRESSED_FIX_WINDOW_MS, now));
-    const detail = regressedFixesPhrase(rows);
-    return detail === null ? null : { count: rows.length, detail };
+    }
+    return orphanCache === null ? null : orphanCache.value;
 }
-/** Re-export so the always-on alert's stale-pin selector stays in its one home
- * (src/doctor/doctor-contention-checks.ts) while tui.tsx keeps importing every alert feed from
- * this one module. */
-export { staleWorkspacePins };

package/dist/src/ui/badges.js

@@ -1,5 +1,3 @@
-import { sortEntriesByKey } from "../collections.js";
-import { utilizationPct, windowLabel } from "../agent/subscription-account.js";
 import { MODEL_TIERS } from "../config/config-schema.js";
 import { budgetGate, budgetReached, fallbackTierEntries } from "../budget/budget.js";
 import { fallbackDisplayPair } from "../config/config-views.js";
@@ -23,12 +21,21 @@ import { formatGB, shortSha, usd, usdCap } from "../text/format.js";
  * team keeps running the stale build, so the badge reads "work continues" and keeps the
  * deadline; `restart pending` (the drain that precedes the swap, which actually holds new runs
  * and merges) resolves itself; `restart BLOCKED` never will until main moves. Telling them apart
- * at a glance is the whole point (see BuildStatus.restartBlocked). Empty when the dist carries
- * no stamp. Shared by the TUI/status header and the GUI's. */
+ * at a glance is the whole point (see BuildStatus.restartBlocked). A build that is current against
+ * the newest commit that passed main's check, while main's tip has moved its code on, says the
+ * update waits for that check (BuildStatus.waitingForCheck) — otherwise nothing tells the
+ * operator why the team stays on an old build. Empty when the dist carries no stamp. Shared by
+ * the TUI/status header and the GUI's. */
 export function buildBadge(build) {
     if (!build)
         return "";
-    const stale = build.stale ? ` — update available (${plural(build.aheadCommits ?? 0, "commit")} behind)` : "";
+    const waiting = build.waitingForCheck;
+    const stale = build.stale
+        ? ` — update available (${plural(build.aheadCommits ?? 0, "commit")} behind)`
+        : waiting
+            ? ` — update waiting: main is ${plural(waiting.aheadCommits, "commit")} ahead at ` +
+                `${shortSha(waiting.head)}, and no newer commit has passed main's check yet`
+            : "";
     const restart = build.restartBlocked
         ? build.restartBlocked.startsWith("cooldown until ")
             ? ` — restarts after cooldown; work continues (${build.restartBlocked})`
@@ -103,55 +110,6 @@ export function bootstrapBadge(bootstrap) {
         return "";
     return ` · bootstrap: ${bootstrap.plansDone}/${bootstrap.untilPlansDone} plans done`;
 }
-/** One window status as its badge word when no utilization was reported. */
-function claudeWindowStatusWord(status) {
-    if (status === "allowed_warning")
-        return "near limit";
-    if (status === "rejected")
-        return "limited";
-    return status === "reset" ? "reset" : "ok";
-}
-/** How far off a window's reset is, two units wide: `4h 12m`, `5d 3h`, `37m`. A clock time
- * alone cannot tell a 7d window resetting Monday from one resetting tonight. */
-function untilReset(resetsAt, now) {
-    const minutes = Math.floor((resetsAt - now) / 60_000);
-    if (minutes < 60)
-        return `${minutes}m`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24)
-        return `${hours}h ${minutes % 60}m`;
-    return `${Math.floor(hours / 24)}d ${hours % 24}h`;
-}
-/** The subscription usage-window fragment (plans/agent-backends.md §8, PLANS.md part 6d/7):
- * `· Claude 5h · 64% · resets in 4h 12m` (`resets now` once the deadline has passed), with
- * the status word when no `utilization` was reported and an `overage` marker while the
- * account spends into overage. A rejected window reads
- * `<backend> model jobs wait until 14:30` in place of `resets` while a future deadline holds
- * the seams; a reset reading names neither. Reads the most-constrained block (`blocks[0]`,
- * already most-constrained-first), rendering under that backend's own display label. The
- * hold clause names the backend by its lowercase id (not the display label), so a claude-only
- * team keeps the byte-identical `claude model jobs wait` the pre-3b badge rendered. The one
- * home of the string, so the TUI header and the payload's preformatted badge cannot drift. */
-function subscriptionWindowBadge(blocks, now, moved = false) {
-    const block = blocks[0];
-    const w = block.primary;
-    const parts = [`${block.label} ${windowLabel(w.type)}`];
-    parts.push(typeof w.utilization === "number" ? `${utilizationPct(w.utilization)}%` : claudeWindowStatusWord(w.status));
-    if (w.isUsingOverage === true)
-        parts.push("overage");
-    if (w.status === "rejected" && block.heldUntil !== null) {
-        parts.push(`${moved ? "on fallback" : `${block.backend} model jobs wait`} until ${clockHm(block.heldUntil)}`);
-    }
-    else if (w.status !== "reset" && typeof w.resetsAt === "number") {
-        parts.push(w.resetsAt - now < 60_000 ? "resets now" : `resets in ${untilReset(w.resetsAt, now)}`);
-    }
-    return ` · ${parts.join(" · ")}`;
-}
-/** Whether any tier of a chain block runs on a fallback because the Claude window (or its
- * reserve) is used up. */
-function chainMovedByWindow(chain) {
-    return Object.values(chain ?? {}).some((t) => t.reason === "window" || t.reason === "reserve");
-}
 /** The tiers' fallback steps as badge text, ` · `-joined without a leading separator:
  * `default → DeepSeek-V4-Flash $3.10/$5 until 17:40`, one fragment per tier in MODEL_TIERS
  * order. Empty when the block is absent or empty. */
@@ -172,18 +130,6 @@ export function chainBadge(chain) {
     const text = chainFragments(chain);
     return text ? ` · ${text}` : "";
 }
-/** The window fragment's tone rank, for the header badge and the GUI meter: a rejected window
- * is red, an allowed_warning amber, anything else no tone. Reads the most-constrained block
- * (`blocks[0]`), so a multi-backend team's tone follows its tightest window. */
-export function subscriptionWindowTone(blocks) {
-    if (!blocks || blocks.length === 0)
-        return undefined;
-    if (blocks[0].primary.status === "rejected")
-        return "red";
-    if (blocks[0].primary.status === "allowed_warning")
-        return "yellow";
-    return undefined;
-}
 /** The header's daily-cost-budget fragment, standing in every cap state (the badge is also
  * the affordance for editing the cap, so a disabled team needs it too): `· budget: n/a`
  * for a team whose models are all free (spend can never accumulate against a cap that
@@ -204,16 +150,8 @@ export function subscriptionWindowTone(blocks) {
  * needs no forecast slot: a disabled cap never carries a capHitAt (projectCapHit returns null
  * for capUsd <= 0), and the fallback fragment only stands once the cap IS reached — the one
  * state where the forecast is itself null — so the fragments can never compete for the line. */
-export function budgetBadge(budget, windows, only = false, now = Date.now(), chain) {
-    const blocks = windows && windows.length > 0 ? windows : undefined;
-    const window = (blocks ? subscriptionWindowBadge(blocks, now, chainMovedByWindow(chain)) : "") + chainBadge(chain);
-    // Subscription-only: the window stands IN PLACE of the daily spend — there is no priced
-    // spend for a dollar figure to report. This holds only while a window block actually
-    // exists: an all-free subscription-only team (only and free, no windows) reads ` · budget: n/a`
-    // like any other all-free team, so the free branch below stays reachable. Mixed and none
-    // fall through to the daily spend.
-    if (only && blocks)
-        return window;
+export function budgetBadge(budget, chain) {
+    const window = chainBadge(chain);
     if (budget.free)
         return ` · budget: n/a${window}`;
     // Only while the fallback is actually carrying the team (plans/fallback-model.md): the cap
@@ -383,21 +321,12 @@ export function diskBadge(disk) {
             ? ` · disk ${free}`
             : "";
 }
-/** The permit pool's header fragment (plans/provider-concurrency.md §8): `slots 5/8 · omlx
- * 3/3 · claude 2/6` — the team total's in-use/cap followed by each capped provider key's own
- * in-use/cap. The WHOLE fragment appears only while at least one key carries a cap (the
- * `maxConcurrentPerProvider` map is set), so a team without it renders the header exactly
- * as before; uncapped keys that happen to be in the snapshot are dropped rather than shown
- * with a bare in-use that would read like a cap. */
+/** The permit pool's header fragment (plans/provider-concurrency.md §8): `slots 5/8` — the
+ * team total's in-use/cap. Empty when no snapshot was published. */
 export function permitsBadge(permits) {
     if (!permits)
         return "";
-    const providers = sortEntriesByKey(Object.entries(permits.byKey).filter(([, e]) => e.limit !== undefined))
-        .map(([k, e]) => `${k} ${e.inUse}/${e.limit}`)
-        .join(" · ");
-    if (providers.length === 0)
-        return "";
-    return ` · running ${permits.inUse} of ${permits.limit} · ${providers}`;
+    return ` · running ${permits.inUse} of ${permits.limit}`;
 }
 /** The check-permit pool's reading, ` · checks 1/2` plus `, 3 waiting` while checks queue. Empty
  * when no check runs or waits, so an idle check pool leaves the header byte-identical. */

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

@@ -73,13 +73,13 @@ export const GUI_CLIENT_BOOT_JS = String.raw `  // One tail for the "…written
   // submit listener saves the row's key (saveSetting, gui-client-settings). No per-row wiring,
   // so rows can repaint freely.
   document.addEventListener("submit", (ev) => {
-    const form = ev.target instanceof Element ? ev.target.closest("form.settings-row") : null;
+    const form = clickClosest(ev, "form.settings-row");
     if (form) { ev.preventDefault(); saveSetting(form); }
   });
   // The Brief card's Save: its own form class, so the settings listener above never
   // routes it to saveSetting.
   document.addEventListener("submit", (ev) => {
-    const form = ev.target instanceof Element ? ev.target.closest("form.brief-form") : null;
+    const form = clickClosest(ev, "form.brief-form");
     if (form) { ev.preventDefault(); saveBrief(form); }
   });
   // The Settings view's Clear buttons: one delegated click listener resolves the row's Clear
@@ -383,12 +383,6 @@ export const GUI_CLIENT_BOOT_JS = String.raw `  // One tail for the "…written
       const thinking = thinkingBox ? thinkingBox.value.trim() : "";
       const backend = backendBox ? backendBox.value.trim() : "";
       postAction("/api/role-model", { role: arg, provider, model, thinking, backend }, settingDone(() => { modelEditing = null; }, "Model overrides updated"));
-    } else if (act === "review-toggle") {
-      const after = drawerRole?.view?.reviewedAfterMerge === true;
-      postAction("/api/role-review-after-merge", { role: arg, afterMerge: !after }, (d) => {
-        loadDrawerRole(arg);
-        return d && d.message ? d.message : "Review tier updated";
-      });
     } else if (act === "mention") {
       const { file, index } = entryRef(arg);
       const title = entryTitleAt(file, index);

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

@@ -221,7 +221,7 @@ export const GUI_CLIENT_COMPOSER_JS = String.raw `  // ---- composer: one box fo
       "<button type='button' data-idx='" + i + "' title='Remove' aria-label='Remove " + esc(img.name) + "'>×</button></span>").join("");
   }
   $("promptimages").addEventListener("click", (ev) => {
-    const b = ev.target instanceof Element ? ev.target.closest("button[data-idx]") : null;
+    const b = clickClosest(ev, "button[data-idx]");
     if (!b) return;
     promptImages.splice(Number(b.dataset.idx), 1);
     renderPromptImages();

package/dist/src/ui/gui/gui-client-drawer-config.js

@@ -7,22 +7,20 @@
 export const GUI_CLIENT_DRAWER_CONFIG_JS = String.raw `
   // A Configuration section built from the same /api/role payload the CLI's tumwater role
   // <id> renders (rolePayload), so the drawer's and the terminal's rows read one document and
-  // cannot drift: what the role RUNS ON (model/tier, provider cap, image reading, the
+  // cannot drift: what the role RUNS ON (model/tier, image reading, the
   // fallback pairs, billing, min run interval) and CARRIES (queued prompts, the instructions
   // override, find text). Each row is guarded by a present/own check so an absent field
-  // renders no row — a cap-less team shows no Provider row, no fallback shows no fallback
-  // rows, and a notes-only payload adds an empty (omitted) section. Labels and wording mirror
+  // renders no row — no fallback shows no fallback rows, and a notes-only payload adds an
+  // empty (omitted) section. Labels and wording mirror
   // role-render.ts's family; no backticks allowed here (this whole script is one big
   // String.raw template).
   function drawerConfigHtml(view, role) {
     const pair = (p, m) => [p, m].filter(Boolean).join("/");
     // A fallback pair's label, mirroring role-render.ts's fallbackPairLabel so the drawer's
-    // Model fallback and Budget fallback rows name a non-pi backend's namespace the same way
-    // the CLI's fallback lines do: a non-pi backend with a model reads <backend>/<model>, else
-    // <provider>/<model>, else the model, else the provider, else the pair-less default. The
-    // pi provider/model cases and a budget pair (whose provider already holds the backend) stay
-    // byte-identical; only a model-fallback non-pi pair (modelFallbackView drops pi's provider
-    // for a non-pi backend) gains the namespace the CLI already shows.
+    // Budget fallback row names a non-pi backend's namespace the same way the CLI's fallback
+    // lines do: a non-pi backend with a model reads <backend>/<model>, else <provider>/<model>,
+    // else the model, else the provider, else the pair-less default. A budget pair's provider
+    // already holds the backend, so its row stays byte-identical.
     // Local wall-clock HH:MM for the role-cap forecast's ~cap at stamp — the drawer is browser
     // code and cannot import ../text/datetime.js (the quietWindowEnd precedent's own note), so
     // it routes through the bundle's shared clockHm in FORMAT_JS, the same helper the operator
@@ -92,40 +90,17 @@ export const GUI_CLIENT_DRAWER_CONFIG_JS = String.raw `
     if (view.contextWindow !== undefined) {
       rows.push(kvRow("Context window", view.contextWindow === null ? "unknown" : fmtTokens(view.contextWindow) + " tokens"));
     }
-    if (view.providerKey !== undefined && view.providerCap !== undefined) {
-      rows.push(kvRow("Provider", view.providerKey + " (cap " + view.providerCap + ")"));
-    }
     if (view.imageInput !== undefined) {
       const images = view.imageInput === true ? "yes"
         : view.imageInput === false ? (view.imageReroute ? "no — reruns on " + view.imageReroute : "no")
         : "unknown";
       rows.push(kvRow("Images", images));
     }
-    if (view.reviewEnabled === true && role !== "director") {
-      // The review tier, shown whenever the gate is on (rolePayload's reviewEnabled) so a
-      // before-merge-reviewed role still gets the control — the browser twin of the CLI's
-      // tumwater role <id> --review-after-merge. The director shows no row, like the cap and
-      // quiet-hours rows and the CLI render: its membership is refused by validateConfig's
-      // review.afterMerge rule, so a toggle it could never act on would only answer 400. The
-      // body names whether the role is reviewed after merge or before it, and the button posts
-      // the opposite membership through /api/role-review-after-merge; one click posts (no
-      // editor state), like the Settings view's Enable button.
-      const revAfter = view.reviewedAfterMerge === true;
-      const revBody = revAfter ? "after merge" : "before merge";
-      const revControl = "<button type='button' class='btn btn-sm' data-act='review-toggle' data-arg='" + esc(role) + "'>" + (revAfter ? "Review before merge" : "Review after merge") + "</button>";
-      rows.push("<div><dt>Review</dt><dd title='" + esc(revBody) + "'>" + esc(revBody) + revControl + "</dd></div>");
-    }
-    if (view.modelFallback && typeof view.modelFallback === "object" && view.modelFallback.model !== undefined) {
-      const fb = view.modelFallback;
-      const when = typeof fb.since === "number" ? " since " + fmtAgo(fb.since) : "";
-      rows.push(kvRow("Model fallback", fallbackLabel(fb, "") + " — on fallback" + when + " (primary failing: " + (fb.reason ?? "") + ")"));
-    }
     if (view.fallback && typeof view.fallback === "object" && view.fallback.model !== undefined) {
       rows.push(kvRow("Budget fallback", fallbackLabel(view.fallback, "") + " (" + (view.fallbackFree ? "free" : "priced") + ")"));
     }
     if (view.billing !== undefined) {
-      const window = view.billing === "subscription" && view.billingWindow ? " (" + view.billingWindow + " window)" : "";
-      rows.push(kvRow("Billing", (view.billing === "api" ? "API" : view.billing) + window));
+      rows.push(kvRow("Billing", view.billing === "api" ? "API" : view.billing));
     }
     // The min run interval (rolePayload's minRunIntervalSeconds), worded like role-render.ts's
     // Min run interval line, plus a control to set/clear the per-role override — the last

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

@@ -208,7 +208,7 @@ export const GUI_CLIENT_DRAWER_JS = String.raw `  let drawer = null; // { kind:
     const commits = Array.isArray(view.commits) ? view.commits : [];
     const dirty = Array.isArray(view.dirtyFiles) ? view.dirtyFiles : [];
     if (view.state === "absent") return "<p class='muted'>No workspace yet — this role has not run.</p>";
-    if (view.state === "no-base") return "<p class='muted'>Main branch " + esc(view.mainBranch) + " does not exist.</p>";
+    if (view.state === "no-base") return "<p class='muted'>" + mainBranchMissingPhrase(view.mainBranch) + ".</p>";
     const scoped = typeof view.path === "string";
     if (scoped && view.state === "ready" && commits.length === 0 && dirty.length === 0) {
       return "<p class='muted'>No pending change to " + esc(view.path) + ".</p>";

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

@@ -110,7 +110,7 @@ export const GUI_CLIENT_FEED_JS = String.raw `
   const emptyFeedRow = (head, body) => "<li class='empty'><strong>" + head + "</strong>" + body +
     "<button type='button' class='linkish' data-action='feedclear'>Clear filter</button></li>";
   // A per-type tally for the Activity feed, mirroring the CLI's logs --count display rule
-  // (read-only from src/cli/log-commands.ts's sayTally): one N × <type> chip per present event
+  // (read-only from src/cli/cli-log-commands.ts's sayTally): one N × <type> chip per present event
   // type, count-descending then type-name ascending. A pure function of the rows in hand, so the
   // chips and the <li> rows below cannot drift on which events count; "" for an empty array so
   // empty and empty-state feeds paint no stray chips. Each chip is a button: clicking the

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

@@ -71,13 +71,13 @@ export const GUI_CLIENT_HISTORY_JS = String.raw `  // The counts the "Runs to sh
       fetchHistory();
     });
     $("histfilter").addEventListener("click", (ev) => {
-      const b = ev.target.closest("button[data-hist]");
+      const b = clickClosest(ev, "button[data-hist]");
       if (!b) return;
       histFilter = b.dataset.hist;
       renderHistory();
     });
     $("histsum").addEventListener("click", (ev) => {
-      const b = ev.target.closest("button[data-histsum]");
+      const b = clickClosest(ev, "button[data-histsum]");
       if (!b) return;
       histMode = b.dataset.histsum;
       store("hist-mode", histMode);
@@ -98,7 +98,7 @@ export const GUI_CLIENT_HISTORY_JS = String.raw `  // The counts the "Runs to sh
     // data-rundetail button).
     // A By model row's label drills into that model's runs: the table, filtered to the selector.
     $("histbody").addEventListener("click", (ev) => {
-      const b = ev.target instanceof Element ? ev.target.closest("button[data-histmodel]") : null;
+      const b = clickClosest(ev, "button[data-histmodel]");
       if (!b) return;
       histModel = b.dataset.histmodel;
       histMode = "table";
@@ -106,43 +106,43 @@ export const GUI_CLIENT_HISTORY_JS = String.raw `  // The counts the "Runs to sh
       fetchHistory();
     });
     $("histbody").addEventListener("click", (ev) => {
-      const b = ev.target instanceof Element ? ev.target.closest("button[data-rundetail]") : null;
+      const b = clickClosest(ev, "button[data-rundetail]");
       if (!b) return;
       toggleHistDetail(b.dataset.role, b.dataset.run);
     });
     // The drill-down's revert buttons: the first click previews, the preview's own button commits.
     $("histbody").addEventListener("click", (ev) => {
-      const b = ev.target instanceof Element ? ev.target.closest("button[data-hist-revert], button[data-hist-revert-go]") : null;
+      const b = clickClosest(ev, "button[data-hist-revert], button[data-hist-revert-go]");
       if (!b) return;
       if (b.dataset.histRevertGo !== undefined) runHistRevert(b.dataset.histRevertGo);
       else previewHistRevert(b.dataset.histRevert);
     });
     // The drill-down's "Show patch" / "Hide patch" button.
     $("histbody").addEventListener("click", (ev) => {
-      const b = ev.target instanceof Element ? ev.target.closest("button[data-hist-patch]") : null;
+      const b = clickClosest(ev, "button[data-hist-patch]");
       if (!b) return;
       toggleHistPatch(b.dataset.histPatch);
     });
     // The drill-down's "Show transcript" / "Hide transcript" button.
     $("histbody").addEventListener("click", (ev) => {
-      const b = ev.target instanceof Element ? ev.target.closest("button[data-hist-transcript]") : null;
+      const b = clickClosest(ev, "button[data-hist-transcript]");
       if (!b) return;
       toggleHistTranscript(b.dataset.histTranscript);
     });
     // The open transcript's "Show prompts" / "Hide prompts" button.
     $("histbody").addEventListener("click", (ev) => {
-      const b = ev.target instanceof Element ? ev.target.closest("button[data-hist-transcript-prompts]") : null;
+      const b = clickClosest(ev, "button[data-hist-transcript-prompts]");
       if (!b) return;
       toggleHistTranscriptPrompts(b.dataset.histTranscriptPrompts);
     });
     // The open transcript's search box (applied on Enter or blur: the card re-renders each change).
     $("histbody").addEventListener("change", (ev) => {
-      const el = ev.target instanceof Element ? ev.target.closest("input[data-hist-transcript-grep]") : null;
+      const el = clickClosest(ev, "input[data-hist-transcript-grep]");
       if (el) searchHistTranscript(el.dataset.histTranscriptGrep, el.value);
     });
     // The pinned newest-failure card's × closes it.
     $("histbody").addEventListener("click", (ev) => {
-      const b = ev.target instanceof Element ? ev.target.closest("button[data-hist-newest-close]") : null;
+      const b = clickClosest(ev, "button[data-hist-newest-close]");
       if (!b) return;
       closeHistNewest();
     });
@@ -187,11 +187,16 @@ export const GUI_CLIENT_HISTORY_JS = String.raw `  // The counts the "Runs to sh
     renderHistory();
     try {
       const d = await getJson("/api/run?last=1&result=problems");
-      // Name the endpoint and the run it answered for: a 200 without a text or role field is a
-      // server too old (or too new) for this dashboard's client, not a lost run.
+      // Name the endpoint, the run it answered for, and the actually missing field: a 200
+      // without either text or role is a server too old (or too new) for this dashboard's
+      // client, not a lost run. text is the usual miss (the card would render nothing) and
+      // role decides the card's cache key, so name role when text is present but the role
+      // is not rather than blaming text for a field the reply did carry.
       if (!d || typeof d.text !== "string" || typeof d.role !== "string")
         throw new Error(
-          "/api/run answered the newest failing run without a text field — the running tumwater may not match this dashboard",
+          "/api/run answered the newest failing run without a " +
+            (!d || typeof d.text !== "string" ? "text" : "role") +
+            " field — the running tumwater may not match this dashboard",
         );
       const key = histDetailKey(d.role, d.run);
       histDetails.set(key, histDetailOk(d));
@@ -299,7 +304,16 @@ export const GUI_CLIENT_HISTORY_JS = String.raw `  // The counts the "Runs to sh
   // drift apart: every one fetches runApiUrl, then insists the reply carries its field.
   async function fetchRunField(key, query, field) {
     const d = await getJson(runApiUrl(key, query));
-    if (!d || typeof d[field] !== "string") throw new Error("/api/run answered without a " + field + " field");
+    if (!d || typeof d[field] !== "string") {
+      // Name the endpoint, the run it answered for, and the likely cause — the same
+      // ownership fetchHistDetail and openHistNewest give their /api/run errors: a 200
+      // without the promised field is a server too old (or too new) for this dashboard's
+      // client, not a silently dropped patch or transcript.
+      const at = key.lastIndexOf("#");
+      throw new Error(
+        "/api/run answered " + key.slice(0, at) + " run " + key.slice(at + 1) + " without a " + field + " field — the running tumwater may not match this dashboard",
+      );
+    }
     return d;
   }
   // Fetch or toggle one card add-on field (the patch or the transcript) at key ("role#run").

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

@@ -29,18 +29,6 @@ export const GUI_CLIENT_MODEL_JS = String.raw `  // view-model:start
     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: "change pinned until main goes green" };
     if (p.startsWith("paused")) return { key: "paused", label: "Paused", tone: "amber", live: false, detail: "starts no new runs" };