tumwater 0.1.2 → 0.2.0

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

@@ -1,8 +1,10 @@
+// vocabulary: plain
 /** The dashboard's Usage and Failures views, browser-side. Usage renders /api/report as six
- * totals (each with its per-day average) over four daily bar charts — landed commits, ticks by
- * loop, output tokens, spend by loop — with gridlines, a scale, and one shared color per loop;
- * a window picker switches between 7, 14, 30, and 90 days and a Loop picker scopes the report
- * to one loop group (`?role=`, the browser twin of `tumwater report --role`). Both pickers also
+ * totals (each with its per-day average) over five daily bar charts — merged commits, ticks by
+ * loop, output tokens, spend by loop, rejections by loop — with gridlines, a scale, and one
+ * shared color per loop; a window picker switches between 7, 14, 30, and 90 days and a
+ * Loop picker scopes the report to one loop group (`?role=`, the browser twin of
+ * `tumwater report --role`). Both pickers also
  * carry trailing-window buttons (1h/6h/1d, `?sinceMs=`, the browser twin of `tumwater report
  * --since`), so the day and sub-day shapes read through the same collectors and renders as the
  * CLI; the since shape draws the returned Markdown instead of the charts. Failures renders
@@ -21,18 +23,35 @@ export const GUI_CLIENT_REPORT_JS = String.raw `// report-chart:start
   const REPORT_PALETTE = ["#6366f1", "#f59e0b", "#10b981", "#ef4444", "#0ea5e9", "#a855f7", "#f97316", "#14b8a6",
     "#ec4899", "#84cc16", "#06b6d4", "#eab308", "#64748b", "#d946ef"];
 
+  // One [key, total][] for a day series, ordered by total desc then name asc — the shared
+  // shape of the role/provider/model orderings. sumFields are the fields that contribute a
+  // running total (runsByRole, costByProvider, runsByModel); seedFields are fields whose
+  // PRESENCE alone earns a category a 0 row (a loop that only merged or only spent, a
+  // provider that only spent notionally) without adding to its total — the split that lets
+  // the real-spend charts read 0 for a notional-only provider while still listing it. Every
+  // field's keys also seed a 0 when absent, so a category some day carried keeps its row on
+  // days (and in fields) that lack it. Keys are dynamic (roles, providers, models), so reads
+  // and seeds use Object.hasOwn as each ordering did.
+  function tallyAcross(series, sumFields, seedFields) {
+    const by = {};
+    for (const d of series) {
+      for (const field of sumFields) {
+        for (const [k, n] of Object.entries(d[field] || {})) by[k] = (Object.hasOwn(by, k) ? by[k] : 0) + n;
+      }
+      for (const field of [...sumFields, ...seedFields]) {
+        for (const k of Object.keys(d[field] || {})) if (!Object.hasOwn(by, k)) by[k] = 0;
+      }
+    }
+    return Object.entries(by).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  }
+
   // Window totals per role — ticks desc, then name — so the legend and the stack order match
   // the Markdown report's "Ticks by role" line. Roles that only spent (no ticks) still count.
   // Reads and seeds use Object.hasOwn: the custom-loop name charset admits "constructor", an
   // Object.prototype key whose inherited value would otherwise seed the counter and satisfy
   // the membership test (the browser twin of addTo's fix; BUGS.md 2026-10-10).
   function reportRoleOrder(data) {
-    const byRole = {};
-    for (const d of data.series) {
-      for (const [role, n] of Object.entries(d.ticksByRole)) byRole[role] = (Object.hasOwn(byRole, role) ? byRole[role] : 0) + n;
-      for (const role of Object.keys(d.costByRole || {})) if (!Object.hasOwn(byRole, role)) byRole[role] = 0;
-    }
-    return Object.entries(byRole).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+    return tallyAcross(data.series, ["runsByRole"], ["costByRole", "notionalByRole", "rejectionsByRole", "revisionsByRole", "refusalsByRole", "fallbacksByRole", "imageReroutesByRole", "failedRunsByRole", "mergeFailedByRole", "commitsByRole", "mergedByRole"]);
   }
 
   // X-axis labels: MM-DD, thinned to at most seven, counted back from the newest day so today
@@ -102,38 +121,290 @@ export const GUI_CLIENT_REPORT_JS = String.raw `// report-chart:start
   }
 
   function chartCommits(data) {
-    return reportSvg(data.series, (d) => [{ value: d.commits, color: "#10b981", title: d.date + ": " + plural(d.commits, "commit") + " landed" }],
+    return reportSvg(data.series, (d) => [{ value: d.commits, color: "#10b981", title: d.date + ": " + plural(d.commits, "commit") + " merged" }],
       countAxis, true);
   }
 
-  // Stacked bars, one color per role in reportRoleOrder's order (the first role at the bottom),
-  // with a legend in the same order. Role names are dynamic (custom loops): escaped everywhere.
-  function roleStackChart(data, field, fmt, fmtAxis, integer) {
-    const roles = reportRoleOrder(data);
+  // The day's merged commits per base role, the per-role split of the Merged commits total
+  // it sits beside (same roleStackChart shape, palette, legend order and integer count axis
+  // as the other role charts). Counts merged events, one per change in a stacked fast-forward.
+  function chartCommitsByRole(data) {
+    return roleStackChart(data, "commitsByRole", (n) => plural(n, "commit"), countAxis, true);
+  }
+
+  // The day's work vs maintenance commits, from workCommits/maintenanceCommits (the same split
+  // foldUsageEvent's totals carry): work (feature/bugfix/director) at the bottom, maintenance
+  // (code-maintenance/readme) above. This shows only the tiered counts — plan, steward,
+  // observer and custom/legacy roles are untiered and count toward the total commits chart
+  // alone, so the two tiers need not sum to chartCommits. The Number(...) || 0 guard covers
+  // older or hand-built report rows that omit the fields.
+  function chartCommitTiers(data) {
+    return reportSvg(data.series, (d) => [
+      { value: Number(d.workCommits) || 0, color: "#10b981", title: d.date + ": " + plural(Number(d.workCommits) || 0, "work commit") },
+      { value: Number(d.maintenanceCommits) || 0, color: "#94a3b8", title: d.date + ": " + plural(Number(d.maintenanceCommits) || 0, "maintenance commit") },
+    ], countAxis, true);
+  }
+
+  // The lower-median bar for a duration field (check/merge-wait/provider-wait/slot-wait): one
+  // bar per day from that day's median ms, its hover chip in the bar's color. Shared by the four
+  // duration-median charts so the field/color/label triple cannot drift when a fifth median
+  // joins.
+  function medianBarChart(data, field, color, label) {
+    return reportSvg(data.series, (d) => [{ value: Number(d[field]) || 0, color, title: d.date + ": " + fmtSpan(Number(d[field]) || 0) + " median " + label }],
+      (v) => fmtSpan(v), false);
+  }
+
+  // The lower median of the day's passing full-suite merge checks, from checkMedianMs.
+  function chartCheckMedian(data) {
+    return medianBarChart(data, "checkMedianMs", "#0ea5e9", "merge check");
+  }
+
+  // The day's failed full-suite checks, from checkFailures; a day without one keeps its empty
+  // slot, as chartCheckMedian does.
+  function chartCheckFailures(data) {
+    return reportSvg(data.series, (d) => [{ value: Number(d.checkFailures) || 0, color: "#ef4444", title: d.date + ": " + plural(Number(d.checkFailures) || 0, "red merge check") }],
+      countAxis, true);
+  }
+
+  // The lower median of the day's merge waits, enqueue to merged on main, from mergeWaitMedianMs.
+  function chartMergeWaitMedian(data) {
+    return medianBarChart(data, "mergeWaitMedianMs", "#f59e0b", "merge wait");
+  }
+
+  // The lower median of the day's provider-slot waits, from providerWaitMedianMs.
+  function chartProviderWaitMedian(data) {
+    return medianBarChart(data, "providerWaitMedianMs", "#a855f7", "provider wait");
+  }
+
+  // The lower median of the day's workspace-slot waits, from slotWaitMedianMs.
+  function chartSlotWaitMedian(data) {
+    return medianBarChart(data, "slotWaitMedianMs", "#22c55e", "workspace wait");
+  }
+
+  // Window totals per provider — spend desc, then name — so both provider charts share one
+  // color and one legend position, the dashboard twin of the day report's "Cost by provider".
+  // Provider keys are dynamic seams, so reads and seeds use Object.hasOwn as reportRoleOrder
+  // does; a provider that only spent notionally still counts.
+  function reportProviderOrder(data) {
+    return tallyAcross(data.series, ["costByProvider"], ["notionalByProvider"]);
+  }
+
+  // Window tallies per model — run count desc, then name — so the "Runs by model" chart
+  // matches the day report's line ordering. Model keys are dynamic selectors, so reads and
+  // seeds use Object.hasOwn as reportProviderOrder does; a model a day series never started
+  // on still gets a row only if some day carries it.
+  function reportModelOrder(data) {
+    return tallyAcross(data.series, ["runsByModel"], []);
+  }
+
+  // Window tallies per merge-failure reason code, count desc then code asc — the reason
+  // twin of reportModelOrder, so the "Merge failures by reason" chart matches the day
+  // report's line ordering. Reason keys are dynamic (result strings), so reads and seeds go
+  // through tallyAcross's Object.hasOwn checks as reportModelOrder does; a code a day series
+  // never failed with still gets a row only if some day carries it.
+  function reportMergeFailureOrder(data) {
+    return tallyAcross(data.series, ["mergeFailedByReason"], []);
+  }
+
+  // Window tallies per deferred-reason code, count desc then code asc — the reason twin of
+  // reportModelOrder and reportMergeFailureOrder, so the "Deferred runs by reason" chart
+  // matches the day report's line ordering, reusing the shared tallyAcross these dynamic-
+  // keyed orders are built from.
+  function reportDeferredOrder(data) {
+    return tallyAcross(data.series, ["deferredByReason"], []);
+  }
+
+  // Stacked bars, one color per entry in the caller's order (the first at the bottom), with a
+  // legend in the same order. entries is the ordered [key, total][] list that drives the
+  // colors, stack order, and legend; keys are dynamic (roles, providers): escaped everywhere.
+  function stackChart(data, entries, field, fmt, fmtAxis, integer) {
     const colorOf = (i) => REPORT_PALETTE[i % REPORT_PALETTE.length];
     const svg = reportSvg(
       data.series,
-      (d) => roles.map(([role], i) => {
-        // hasOwn again: an absent role must read 0, not Object.prototype's inherited value.
-        const value = Object.hasOwn(d[field], role) ? d[field][role] : 0;
-        return { value, color: colorOf(i), title: d.date + " · " + role + ": " + fmt(value) };
+      (d) => entries.map(([key], i) => {
+        // hasOwn again: an absent key must read 0, not Object.prototype's inherited value.
+        const m = d[field] || {};
+        const value = Object.hasOwn(m, key) ? m[key] : 0;
+        return { value, color: colorOf(i), title: d.date + " · " + key + ": " + fmt(value) };
       }),
       fmtAxis,
       integer,
     );
-    const legend = roles.length
-      ? "<div class='legend'>" + roles.map(([role], i) => "<span><span class='swatch' style='background:" + colorOf(i) + "'></span>" + esc(role) + "</span>").join("") + "</div>"
+    const legend = entries.length
+      ? "<div class='legend'>" + entries.map(([key], i) => "<span><span class='swatch' style='background:" + colorOf(i) + "'></span>" + esc(key) + "</span>").join("") + "</div>"
       : "";
     return svg + legend;
   }
 
+  // Stacked bars, one color per role in reportRoleOrder's order (the first role at the
+  // bottom), with a legend in the same order. Role names are dynamic (custom loops): escaped
+  // everywhere. The role-keyed form of stackChart.
+  function roleStackChart(data, field, fmt, fmtAxis, integer) {
+    return stackChart(data, reportRoleOrder(data), field, fmt, fmtAxis, integer);
+  }
+
   function chartTicksByRole(data) {
-    return roleStackChart(data, "ticksByRole", (n) => plural(n, "tick"), countAxis, true);
+    return roleStackChart(data, "runsByRole", (n) => plural(n, "run"), countAxis, true);
   }
 
   function chartCostByRole(data) {
     return roleStackChart(data, "costByRole", fmtUsd, (v) => (v === 0 ? "$0" : fmtUsd(v)), false);
   }
+
+  // The day's output tokens, per loop, the dashboard twin of the CLI "Tokens by role" line.
+  function chartTokensByRole(data) {
+    return roleStackChart(data, "tokensByRole", (n) => fmtTokens(Number(n) || 0) + " output tokens", (v) => fmtTokens(Math.round(v)), true);
+  }
+
+  // The API-equivalent (notional) spend of subscription runs, per loop, on the same axis as
+  // the cap spend.
+  function chartNotionalByRole(data) {
+    return roleStackChart(data, "notionalByRole", fmtUsd, (v) => (v === 0 ? "$0" : fmtUsd(v)), false);
+  }
+
+  // The team's real spend, per day, stacked by provider: each segment one (day, provider), on
+  // the same axis as the role spend. Both provider maps are sparse, so a day with none keeps
+  // its empty slot, as the role charts do.
+  function chartCostByProvider(data) {
+    return stackChart(data, reportProviderOrder(data), "costByProvider", fmtUsd, (v) => (v === 0 ? "$0" : fmtUsd(v)), false);
+  }
+
+  // The team's run starts, per day, stacked by model: each segment one (day, model), the
+  // dashboard twin of the day report's "Runs by model" line. Sparse like the provider charts.
+  function chartRunsByModel(data) {
+    return stackChart(data, reportModelOrder(data), "runsByModel", (n) => plural(n, "run"), countAxis, true);
+  }
+
+  // The team's deferred maintenance ticks, per day, stacked by reason: each segment one
+  // (day, reason code), the dashboard twin of the day report's "Deferred runs by reason"
+  // line. Sparse like the model chart; the reason codes are the legend labels.
+  function chartDeferredByReason(data) {
+    return stackChart(data, reportDeferredOrder(data), "deferredByReason", (n) => plural(n, "deferral"), countAxis, true);
+  }
+
+  // The API-equivalent (notional) spend of subscription runs, per provider, on the same axis
+  // as the estimated role spend; the provider twin of chartNotionalByRole.
+  function chartNotionalByProvider(data) {
+    return stackChart(data, reportProviderOrder(data), "notionalByProvider", fmtUsd, (v) => (v === 0 ? "$0" : fmtUsd(v)), false);
+  }
+
+  // The team's review friction, per loop, on a tick-like count axis: one segment per
+  // (day, loop) with a rejection, empty when the report has none.
+  function chartRejectionsByRole(data) {
+    return roleStackChart(data, "rejectionsByRole", (n) => plural(n, "rejection"), countAxis, true);
+  }
+  // Revisions (rework rounds after a rejection), per loop, drawn the same way.
+  function chartRevisionsByRole(data) {
+    return roleStackChart(data, "revisionsByRole", (n) => plural(n, "revision"), countAxis, true);
+  }
+  // Runs that deliberately declined their entry (result "refused"), per loop, drawn the same
+  // way as its rejection/revision siblings.
+  function chartRefusalsByRole(data) {
+    return roleStackChart(data, "refusalsByRole", (n) => plural(n, "refusal"), countAxis, true);
+  }
+  // The team's model-fallback episodes, per loop, on the same count axis: one segment per
+  // (day, loop) with a fallback.
+  function chartFallbacksByRole(data) {
+    return roleStackChart(data, "fallbacksByRole", (n) => plural(n, "fallback"), countAxis, true);
+  }
+  // Image reroutes per loop, drawn the same way: one segment per (day, loop) with a reroute.
+  function chartImageReroutesByRole(data) {
+    return roleStackChart(data, "imageReroutesByRole", (n) => plural(n, "image reroute"), countAxis, true);
+  }
+  // Runs that ended in an error, per loop, drawn the same way.
+  function chartFailedRunsByRole(data) {
+    return roleStackChart(data, "failedRunsByRole", (n) => plural(n, "failed run"), countAxis, true);
+  }
+  // Merges that were blocked or conflicted, per loop, drawn the same way.
+  function chartMergeFailuresByRole(data) {
+    return roleStackChart(data, "mergeFailedByRole", (n) => plural(n, "merge failure"), countAxis, true);
+  }
+  // WHY merges failed, per reason code (each merge_failed's result), drawn the same way as
+  // the by-role chart so the two read as a pair; the reason codes' own ordering comes from
+  // reportMergeFailureOrder.
+  function chartMergeFailuresByReason(data) {
+    return stackChart(data, reportMergeFailureOrder(data), "mergeFailedByReason", (n) => plural(n, "merge failure"), countAxis, true);
+  }
+  // Window tallies per fixed-bug Validation gap tag, count desc then tag asc — the tag twin
+  // of reportMergeFailureOrder, so the "Validation gaps" chart matches the day report's
+  // line ordering. Tag keys are dynamic, so reads and seeds go through tallyAcross's
+  // Object.hasOwn checks as its siblings do; a tag no day recorded still gets a row only if
+  // some day carries it.
+  function reportValidationGapOrder(data) {
+    return tallyAcross(data.series, ["validationGapsByTag"], []);
+  }
+  // The team's fixed-bug Validation gap tags, per day, stacked by tag: each segment one
+  // (day, tag), the dashboard twin of the day report's "Validation gaps" line. Sparse like
+  // the model chart; tag names are the legend labels.
+  function chartValidationGaps(data) {
+    return stackChart(data, reportValidationGapOrder(data), "validationGapsByTag", (n) => plural(n, "validation gap"), countAxis, true);
+  }
+  // The day's merged outcomes per loop, the success sibling of chartMergeFailuresByRole,
+  // drawn exactly like it (same roleStackChart shape, palette, legend order and integer count
+  // axis) so the two read as one pair.
+  function chartMergedByRole(data) {
+    return roleStackChart(data, "mergedByRole", (n) => plural(n, "merge"), countAxis, true);
+  }
+  // The day's backlog items: features done stacked at the bottom and bugs fixed above them,
+  // from featuresDone/bugsFixed (day-granular backlog-file done dates, so a role scope zeroes
+  // them); a day with neither keeps its empty slot.
+  function chartBacklogItems(data) {
+    return reportSvg(data.series, (d) => [
+      { value: Number(d.featuresDone) || 0, color: "#6366f1", title: d.date + ": " + plural(Number(d.featuresDone) || 0, "feature") + " done" },
+      { value: Number(d.bugsFixed) || 0, color: "#ef4444", title: d.date + ": " + plural(Number(d.bugsFixed) || 0, "bug") + " fixed" },
+    ], countAxis, true);
+  }
+  // True when some day carries a map under field with an own value above zero; both counts
+  // are rare, so their elements render only then.
+  function seriesHasAny(data, field) {
+    return data.series.some((d) => Object.values(d[field] || {}).some((n) => n > 0));
+  }
+  // The per-day filing-stamp twin of chartBacklogItems: plans added and bugs filed, the same
+  // two colors as the done chart so the opened and done charts read as a pair. A day with
+  // neither carries an empty slot, and zero segments draw no rect.
+  function chartBacklogItemsOpened(data) {
+    return reportSvg(data.series, (d) => [
+      { value: Number(d.plansAdded) || 0, color: "#6366f1", title: d.date + ": " + plural(Number(d.plansAdded) || 0, "plan") + " added" },
+      { value: Number(d.bugsFiled) || 0, color: "#ef4444", title: d.date + ": " + plural(Number(d.bugsFiled) || 0, "bug") + " filed" },
+    ], countAxis, true);
+  }
+  // True when some day carries a feature or bug count; the gate for the backlog chart, whose
+  // tally a role-scoped report zeroes, so the element stays out exactly where the two tiles are.
+  function seriesHasBacklogItems(data) {
+    return data.series.some((d) => Number(d.featuresDone) > 0 || Number(d.bugsFixed) > 0);
+  }
+  // True when some day carries a filing count; the gate for the opened chart, the sibling of
+  // seriesHasBacklogItems, hidden the same way on a role-scoped series.
+  function seriesHasBacklogAdded(data) {
+    return data.series.some((d) => Number(d.plansAdded) > 0 || Number(d.bugsFiled) > 0);
+  }
+  // True when some day carries a positive value for the named scalar series field; the shared
+  // guard behind the per-scalar seriesHas* helpers below, so each chart's element renders only
+  // when its series has data. Backlog items/added take two fields and stay separate.
+  function seriesHasScalar(data, field) {
+    return data.series.some((d) => Number(d[field]) > 0);
+  }
+  // True when some day carries a passing-check median; the element renders only then.
+  function seriesHasCheckMedian(data) {
+    return seriesHasScalar(data, "checkMedianMs");
+  }
+  // True when some day carries a count of failed full-suite checks; the red sibling of
+  // seriesHasCheckMedian, the element renders only then.
+  function seriesHasCheckFailures(data) {
+    return seriesHasScalar(data, "checkFailures");
+  }
+  // True when some day carries a merge-wait median; the element renders only then.
+  function seriesHasMergeWaitMedian(data) {
+    return seriesHasScalar(data, "mergeWaitMedianMs");
+  }
+  // True when some day carries a provider-wait median; the element renders only then.
+  function seriesHasProviderWaitMedian(data) {
+    return seriesHasScalar(data, "providerWaitMedianMs");
+  }
+  // True when some day carries a workspace-wait median; the element renders only then.
+  function seriesHasSlotWaitMedian(data) {
+    return seriesHasScalar(data, "slotWaitMedianMs");
+  }
   // report-chart:end
 
   // report-tip:start
@@ -187,7 +458,7 @@ export const GUI_CLIENT_REPORT_JS = String.raw `// report-chart:start
     const tile = (label, ic, value, avg, extra) => "<div class='stat'><span class='stat-label'>" + icon(ic) + esc(label) +
       "</span><span class='stat-value'>" + esc(value) + "</span><span class='stat-sub'>" + esc(avg + " a day" + (extra || "")) + "</span></div>";
     return [
-      tile("Commits landed", "merge", String(t.commits), perDay(t.commits, (v) => v.toFixed(1)),
+      tile("Commits merged", "merge", String(t.commits), perDay(t.commits, (v) => v.toFixed(1)),
         " · " + workSplit(t)),
       // A role scope has no backlog tallies: features/bugs come from day-granular backlog-file
       // dates that carry no role, so the scoped collector zeroes them and the tiles stay out —
@@ -196,26 +467,27 @@ export const GUI_CLIENT_REPORT_JS = String.raw `// report-chart:start
         tile("Features done", "plan", String(t.featuresDone), perDay(t.featuresDone, (v) => v.toFixed(1))),
         tile("Bugs fixed", "bug", String(t.bugsFixed), perDay(t.bugsFixed, (v) => v.toFixed(1))),
       ]),
-      tile("Ticks", "refresh", String(t.ticks), perDay(t.ticks, Math.round)),
+      tile("Runs", "refresh", String(t.runs), perDay(t.runs, Math.round)),
       tile("Output tokens", "bars", fmtTokens(t.tokensOut), perDay(t.tokensOut, (v) => fmtTokens(Math.round(v)))),
-      tile("Spent", "dollar", fmtUsd(t.costUsd), perDay(t.costUsd, fmtUsd)),
+      tile("Spent", "dollar", fmtUsd(t.costUsd), perDay(t.costUsd, fmtUsd),
+        t.notionalCostUsd > 0 ? " · " + fmtUsd(t.notionalCostUsd) + " estimated" : undefined),
     ].join("");
   }
 
   // report-role:start
-  // The Loop picker's options: the fleet-wide "All loops" empty option plus one option per
-  // role, in the fleet's own order. syncRolePicker escapes every role through it, so the three
+  // The Loop picker's options: the team-wide "All loops" empty option plus one option per
+  // role, in the team's own order. syncRolePicker escapes every role through it, so the three
   // Loop pickers (the report views', History's, and the Activity feed's) render role names the
   // same way — role names are dynamic (custom loops) and the custom-loop charset admits HTML
   // metacharacters. Pure, so a test can drive it without a DOM.
   function rolePickerOptions(roles) {
-    return "<option value=''>All loops</option>" +
+    return "<option value=''>All roles</option>" +
       (roles || []).map((r) => "<option value='" + esc(r) + "'>" + esc(r) + "</option>").join("");
   }
-  // Repaint one Loop picker from the fleet's role list, returning the scope to keep filtering
+  // Repaint one Loop picker from the team's role list, returning the scope to keep filtering
   // with. Every picker (the report views' syncRoles, History's syncHistoryRoles, the Activity
   // feed's syncFeedRoles) does the same thing: rebuild only when the roster changes, keep the
-  // persisted choice while the fleet still lists it, and fall back to All loops — persisting
+  // persisted choice while the team still lists it, and fall back to All loops — persisting
   // that fallback — when it does not, so a dimmed picker never scopes the request to a ghost
   // loop. The last-painted roster is tracked per select id, so the pickers never share a key.
   const rolePickerKeys = {};
@@ -239,7 +511,7 @@ export const GUI_CLIENT_REPORT_JS = String.raw `// report-chart:start
   // GUI twin of the TUI's Ctrl+G scope cycle (src/ui/tui/tui-keys.ts scopeCycle). The status
   // payload already carries the base role as instanceOf on an instance row (src/status/
   // status-data.ts), so this borrows the server's own fold rather than re-deriving it. History's
-  // picker (gui-client-history.ts) filters by exact loop id and keeps the raw fleet list. Pure,
+  // picker (gui-client-history.ts) filters by exact loop id and keeps the raw team list. Pure,
   // so a test can drive it without a DOM.
   function reportBaseRoles(loops) {
     const bases = [];
@@ -250,7 +522,7 @@ export const GUI_CLIENT_REPORT_JS = String.raw `// report-chart:start
     return bases;
   }
   // Repaint both report views' Loop pickers from a status payload: each view's persisted
-  // choice is kept while the fleet still lists it and falls back to All loops otherwise. The
+  // choice is kept while the team still lists it and falls back to All loops otherwise. The
   // views are defined below; the boot poll and each fetch call this once they exist.
   function syncReportRoles(d) {
     for (const view of [usage, failures]) view.syncRoles(d);
@@ -262,11 +534,11 @@ export const GUI_CLIENT_REPORT_JS = String.raw `// report-chart:start
   function viewHead(title, blurb, pickerId, choices, current, refreshId, rolePickerId, sinceChoices) {
     // A dropped blurb renders as no subtitle at all, never the string "undefined". The Loop
     // picker rides the toolbar when the view has one (the shared Usage/Failures shape); the
-    // options are filled by syncRoles from the fleet's role list. The trailing-window buttons
+    // options are filled by syncRoles from the team's role list. The trailing-window buttons
     // (a view that configured sinceChoices) sit in the same segmented control after the day
     // buttons; each carries its length as data-since so windowView can mark exactly one active.
     const rolePicker = rolePickerId
-      ? "<label><span class='sr-only'>Loop</span><select class='field' id='" + rolePickerId + "' data-role='1'><option value=''>All loops</option></select></label>"
+      ? "<label><span class='sr-only'>Role</span><select class='field' id='" + rolePickerId + "' data-role='1'><option value=''>All roles</option></select></label>"
       : "";
     const sinceButtons = (sinceChoices || []).map(([ms, label]) =>
       "<button type='button' data-since='" + ms + "'>" + esc(String(label)) + "</button>").join("");
@@ -297,14 +569,14 @@ export const GUI_CLIENT_REPORT_JS = String.raw `// report-chart:start
     // fetch still uses it.
     const sinceChoice = o.sinceChoices ? Number(recall(o.sinceKey)) : NaN;
     let sinceMs = (o.sinceChoices || []).some(([ms]) => ms === sinceChoice) ? sinceChoice : null;
-    // The persisted Loop scope for this view: "" is the fleet-wide report. Only a view that
+    // The persisted Loop scope for this view: "" is the team-wide report. Only a view that
     // configured a rolePickerId reads it, so a view without a picker never touches storage.
     let role = o.roleKey ? recall(o.roleKey) || "" : "";
     let fetchedAt = 0;
-    // Keep this view's Loop picker in step with the fleet's role list (custom loops included).
+    // Keep this view's Loop picker in step with the team's role list (custom loops included).
     function syncRoles(d) {
       if (!o.rolePickerId || !d) return;
-      role = syncRolePicker(o.rolePickerId, reportBaseRoles(d.loops), role, o.roleKey);
+      role = syncRolePicker(o.rolePickerId, reportBaseRoles(d.roles), role, o.roleKey);
     }
     async function fetchView(throttled) {
       if (throttled && Date.now() - fetchedAt < 60000) return;
@@ -362,7 +634,7 @@ export const GUI_CLIENT_REPORT_JS = String.raw `// report-chart:start
 
   const usage = windowView({
     panelId: "report", title: "Usage", bodyId: "usagebody",
-    blurb: "What the fleet produced and what it cost, per day and per loop.",
+    blurb: "What the team produced and what it cost, per day and per role.",
     pickerId: "usagewindow", choices: [7, 14, 30, 90], refreshId: "usagerefresh",
     key: "usage-days", defaultDays: 14, roleKey: "usage-role", rolePickerId: "usagerole",
     sinceKey: "usage-since", sinceChoices: REPORT_SINCE_CHOICES,
@@ -377,15 +649,36 @@ export const GUI_CLIENT_REPORT_JS = String.raw `// report-chart:start
         const md = String(d.markdown).replace(/^# .*\n+/, "");
         return "<article class='card md'>" + renderMarkdown(md, true) + "</article>";
       }
-      const block = (title, svg) => "<section class='card chart-card'><header class='card-head'><h2>" + esc(title) +
-        "</h2><span class='muted'>per day</span></header><div class='chart'>" + svg + "</div></section>";
+      const block = (title, svg, sub) => "<section class='card chart-card'><header class='card-head'><h2>" + esc(title) +
+        "</h2><span class='muted'>" + esc(sub || "per day") + "</span></header><div class='chart'>" + svg + "</div></section>";
       // A scoped report drops to the four scoped tiles and says what it left out, mirroring the
-      // CLI's --role report. The fleet-wide render is unchanged.
+      // CLI's --role report. The team-wide render is unchanged.
       return "<div class='stats" + (d.role ? "" : " six") + "'>" + reportSummary(d) + "</div><div class='grid-2 even'>" +
-        block("Landed commits", chartCommits(d)) + block("Ticks by loop", chartTicksByRole(d)) +
-        block("Output tokens", chartTokens(d)) + block("Spend by loop", chartCostByRole(d)) + "</div>" +
-        (d.role ? "<p class='muted scope-note'>Loop scope: " + esc(d.role) +
-          " · landing runs and backlog tallies (features done / bugs fixed) are fleet-wide and omitted.</p>" : "") +
+        block("Work vs maintenance commits", chartCommitTiers(d), "per day · work + maintenance") + block("Merged commits", chartCommits(d)) + block("Commits by role", chartCommitsByRole(d)) + (seriesHasBacklogAdded(d) ? block("Backlog items opened", chartBacklogItemsOpened(d), "per day · plans added + bugs filed") : "") + (seriesHasBacklogItems(d) ? block("Backlog items done", chartBacklogItems(d), "per day · features done + bugs fixed") : "") + block("Runs by role", chartTicksByRole(d)) +
+        block("Output tokens", chartTokens(d)) + block("Tokens by role", chartTokensByRole(d)) + block("Spend by role", chartCostByRole(d)) +
+        (!d.role && seriesHasAny(d, "costByProvider") ? block("Spend by provider", chartCostByProvider(d)) : "") +
+        block("Rejections by role", chartRejectionsByRole(d)) +
+        (seriesHasAny(d, "revisionsByRole") ? block("Revisions by role", chartRevisionsByRole(d)) : "") +
+        (seriesHasAny(d, "refusalsByRole") ? block("Refusals by role", chartRefusalsByRole(d)) : "") +
+        (seriesHasAny(d, "fallbacksByRole") ? block("Fallbacks by role", chartFallbacksByRole(d)) : "") +
+        (seriesHasAny(d, "imageReroutesByRole") ? block("Image reroutes by role", chartImageReroutesByRole(d)) : "") +
+        (seriesHasAny(d, "failedRunsByRole") ? block("Failed runs by role", chartFailedRunsByRole(d)) : "") +
+        (seriesHasAny(d, "mergedByRole") ? block("Merged by role", chartMergedByRole(d)) : "") +
+        (!d.role && seriesHasAny(d, "runsByModel") ? block("Runs by model", chartRunsByModel(d)) : "") +
+        (!d.role && seriesHasAny(d, "deferredByReason") ? block("Deferred runs by reason", chartDeferredByReason(d), "per day · backlog, no-work, plans-full") : "") +
+        (seriesHasAny(d, "mergeFailedByRole") ? block("Merge failures by role", chartMergeFailuresByRole(d)) : "") +
+        (seriesHasAny(d, "mergeFailedByReason") ? block("Merge failures by reason", chartMergeFailuresByReason(d)) : "") +
+        (!d.role && seriesHasAny(d, "validationGapsByTag") ? block("Validation gaps", chartValidationGaps(d), "per day · what made fixed bugs hard to confirm") : "") +
+        (seriesHasCheckMedian(d) ? block("Merge check median", chartCheckMedian(d), "per day · passing full-suite checks") : "") +
+        (seriesHasCheckFailures(d) ? block("Red merge checks", chartCheckFailures(d), "per day · failed full-suite checks") : "") +
+        (seriesHasMergeWaitMedian(d) ? block("Merge wait median", chartMergeWaitMedian(d), "per day · enqueue to merged on main") : "") +
+        (seriesHasProviderWaitMedian(d) ? block("Provider wait median", chartProviderWaitMedian(d), "per day · waits of 30s or more for a provider slot") : "") +
+        (seriesHasSlotWaitMedian(d) ? block("Workspace wait median", chartSlotWaitMedian(d), "per day · waits of 30s or more for a workspace") : "") +
+        (d.totals.notionalCostUsd > 0
+          ? block("Estimated spend by role", chartNotionalByRole(d), "per day · API-equivalent, not in the cap") : "") +
+        (!d.role && seriesHasAny(d, "notionalByProvider") ? block("Estimated spend by provider", chartNotionalByProvider(d), "per day · API-equivalent, not in the cap") : "") + "</div>" +
+        (d.role ? "<p class='muted scope-note'>Role scope: " + esc(d.role) +
+          " · merge runs and backlog tallies (features done / bugs fixed / plans added / bugs filed) are team-wide and omitted.</p>" : "") +
         (d.from ? "<p class='muted window-note'>" + esc(d.from + " → " + d.to) +
           (!d.coversFullWindow ? " · " + ${JSON.stringify(SPARSE_WINDOW_NOTE)} : "") + "</p>" : "");
     },
@@ -393,7 +686,7 @@ export const GUI_CLIENT_REPORT_JS = String.raw `// report-chart:start
 
   const failures = windowView({
     panelId: "failures", title: "Failures", bodyId: "failbody",
-    blurb: "What went wrong, where, and how often — the digest the telemetry loop reads.",
+    blurb: "What went wrong, where, and how often — the digest the selfcheck role reads.",
     pickerId: "failwindow", choices: [7, 14, 30], refreshId: "failrefresh",
     key: "fail-days", defaultDays: 14, roleKey: "fail-role", rolePickerId: "failrole",
     sinceKey: "fail-since", sinceChoices: REPORT_SINCE_CHOICES,