tumwater 0.2.0 → 0.3.0

package/dist/src/ui/status-render.js

@@ -1,35 +1,35 @@
 import { dailyCost } from "../budget/budget.js";
 import { clipToWidth, displayWidth } from "../text/text-width.js";
 import { compactTokens, usd } from "../text/format.js";
-import { elapsedSeconds, formatTime, humanSeconds, nextRunPhrase, pad2, secondsUntil } from "../text/datetime.js";
+import { formatTime, humanAgo, nextRunPhrase, pad2, secondsUntil } from "../text/datetime.js";
 import { projectName } from "../project-name.js";
-import { bootstrapBadge, buildBadge, budgetBadge, claudeWindowTone, diskBadge, mergeBadge, mainCheckBadge, mainCheckVerdict, pauseBadge, loopWakeMarker, permitsBadge, quietBadge, runWindowBadge, wakeBadge } from "./badges.js";
-import { idleClaimText, isActivePhase, loopRowCells, onErrorStreak, sortLoopsByState } from "./status-model.js";
-import { tickProgress } from "./tick-progress-model.js";
+import { bootstrapBadge, buildBadge, budgetBadge, subscriptionWindowTone, diskBadge, mergeBadge, mainCheckBadge, mainCheckVerdict, pauseBadge, roleWakeMarker, permitsBadge, checksBadge, quietBadge, runWindowBadge, wakeBadge, workspacesBadge } from "./badges.js";
+import { idleClaimText, isActivePhase, roleRowCells, onErrorStreak, sortRolesByState } from "./status-model.js";
+import { runProgress } from "./run-progress-model.js";
 import { eventTypeLabel } from "../events/event-labels.js";
 import { roleLabel } from "../roles/role-labels.js";
 import { yieldMultiplierFor, yieldMultiplierSuffix } from "../scheduling/backoff.js";
 import { phaseTone, resultTone } from "./tone.js";
 import { teamAlerts } from "./team-alerts.js";
 import { openQuestions } from "../backlog/backlog.js";
-import { refusedEntryTitles } from "../backlog/backlog-eligibility.js";
+import { operatorHeldEntries, refusedEntries, stalledPlanEntries } from "../backlog/backlog-eligibility.js";
+import { planDependencyAlert, skippedMergeFiles, staleMerges, staleOpenBugs, stalePrompts, staleWaitingBugs } from "./status-payload.js";
 /** The status RENDER layer: time/token cell formatters and the width-aware table shared by
  * `tumwater status` and the TUI. The labels, badges, and metrics it draws come from the shared
  * display model (status-model.ts); this module decides column widths and layout. Depends on
  * status/status-data.ts one way — rendering reads the snapshot; it never collects team state
- * itself (live tick detail is display-only). */
+ * itself (live run detail is display-only). */
 function ago(ts) {
     if (!ts)
         return "-";
-    const s = elapsedSeconds(ts);
-    return `${humanSeconds(s)} ago`;
+    return humanAgo(ts, Date.now());
 }
-/** The table's `last tick` cell: the absolute local time of the last tick end alongside its
+/** The table's `last run` cell: the absolute local time of the last run end alongside its
  * relative age ("14:32:05 · 3m ago"). Zero-padded HH:MM:SS in local time, prefixed `MM-DD `
- * once older than a day so multi-day runs stay unambiguous; "-" for loops that never ticked.
+ * once older than a day so multi-day runs stay unambiguous; "-" for roles that never ran.
  * The GUI renders the same cell (absolute stamp plus relative age) from its own JS copy in
  * gui-client.ts — formatting at each surface, per the fmtTokens precedent. */
-export function lastTickCell(ts) {
+export function lastRunCell(ts) {
     if (!ts)
         return "-";
     const d = new Date(ts);
@@ -38,42 +38,42 @@ export function lastTickCell(ts) {
         s = `${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${s}`;
     return `${s} · ${ago(ts)}`;
 }
-/** The table's `last merged` cell: when the loop last merged a change on main, in the SAME
- * absolute-time-plus-relative-age shape as the `last tick` cell (lastTickCell), so the two
- * columns cannot drift on what "ago" means. A loop that has never merged shows the same dash
- * lastTickCell uses for a never-ticked loop. */
+/** The table's `last merged` cell: when the role last merged a change on main, in the SAME
+ * absolute-time-plus-relative-age shape as the `last run` cell (lastRunCell), so the two
+ * columns cannot drift on what "ago" means. A role that has never merged shows the same dash
+ * lastRunCell uses for a role that has never run. */
 export function lastMergedCell(ts) {
-    return lastTickCell(ts);
+    return lastRunCell(ts);
 }
-/** The table's `next run` cell: when the loop may tick again, or `-` when that is not the
- * operator's question — a loop in flight (an active rendered phase: working/reviewing/merge,
+/** The table's `next run` cell: when the role may run again, or `-` when that is not the
+ * operator's question — a role in flight (an active rendered phase: working/reviewing/merge,
  * or `s.running`) has no next run to speak of, and a stopped team renders no schedule at all
- * (its `nextRunAt`s are stale leftovers, not plans). A due idle loop reads `now`; a future one
+ * (its `nextRunAt`s are stale leftovers, not plans). A due idle role reads `now`; a future one
  * reads its remaining time through humanSeconds (the same bucketing the sleeping phase label
  * uses, so the two cannot drift), prefixed `backoff ` while `backoffSeconds > 0` — the wake
  * row-action clears exactly that, so the prefix is what makes waking meaningful. The GUI
  * renders the same rules from its own JS copy in gui-client.ts (fmtNextRun). The `phase` and
- * `teamRunning` arguments come from the caller because neither fact lives on LoopState: the
+ * `teamRunning` arguments come from the caller because neither fact lives on RunnerState: the
  * active-phase check needs the rendered label (a merge is visible only there), and the
- * team's running flag lives on the snapshot, not the loop. */
+ * team's running flag lives on the snapshot, not the role. */
 export function nextRunCell(s, phase, now, teamRunning) {
     if (!teamRunning || s.running || isActivePhase(phase))
         return "-";
     const remain = secondsUntil(s.nextRunAt, now);
     // The yield multiplier rides the cell as `×N` (yield-scaled clocks, PLANS.md): a scalable
-    // role whose recent ticks merged nothing keeps a longer effective gap than nextRunAt's
+    // role whose recent runs merged nothing keeps a longer effective gap than nextRunAt's
     // countdown shows, and the suffix is what makes that visible. The multiplier gates the
     // scheduled gap and the main-moved wake in isEligible, so a `now`-due cell at ×4 is a
     // role waiting out its stretched gap, not a broken clock.
     const suffix = yieldMultiplierSuffix(yieldMultiplierFor(s));
     return nextRunPhrase(remain, s.backoffSeconds > 0, "now", false) + suffix;
 }
-/** The table's state cell: a loop's phase label (loopPhase, computed once per row by
+/** The table's state cell: a role's phase label (rolePhase, computed once per row by
  * renderStatus so the same label drives the row order), with the current work item prepended
- * while a tick is in flight ("implement plan X · working 3m · turn 2"). Prepending — not
+ * while a run is in flight ("implement plan X · working 3m · turn 2"). Prepending — not
  * appending — so the item survives ellipsis clipping on narrow terminals; the live detail
- * after it is what gets clipped first. Idle loops are untouched: their log tail describes a
- * finished tick and must not leak its work item into the state cell. (The GUI shows the same
+ * after it is what gets clipped first. Idle roles are untouched: their log tail describes a
+ * finished run and must not leak its work item into the state cell. (The GUI shows the same
  * item in its own `current` column instead, so its state cell stays clean.) */
 function stateCell(root, s, phase, live) {
     // While under review the log tail's "current work" is the reviewer's own output, not the
@@ -88,18 +88,19 @@ function stateCell(root, s, phase, live) {
         const idle = idleClaimText(s, phase);
         return idle ? `${idle} · ${phase}` : phase;
     }
-    const p = tickProgress(root, s, live);
+    const p = runProgress(root, s, live);
     const work = p?.currentWork;
     return work ? `${work} · ${phase}` : phase;
 }
 /** Columns allowed to shrink when the table is wider than the terminal, widest offender
- * first: `last result` (holds the tick summary), then `state` (live working detail), then
- * `last tick` — it shrinks last so on a narrow terminal it loses " · 3m ago" before whole
- * lines clip; its minimum is a bare HH:MM:SS. `last merged` sits right of `last tick` and is
- * not flexible: it is a short sibling time cell whose width follows lastTickCell's, and the
+ * first: `last result` (holds the run summary), then `state` (live working detail), then
+ * `last run` — it shrinks last so on a narrow terminal it loses " · 3m ago" before whole
+ * lines clip; its minimum is a bare HH:MM:SS. `last merged` sits right of `last run` and is
+ * not flexible: it is a short sibling time cell whose width follows lastRunCell's, and the
  * whole-line clip that already protects the header also bounds it. Indices are positional in
  * the `cols` array below — renumber when columns change. (`today`, like `cost`, is a short
- * fixed-width cell: never flexible.) */
+ * fixed-width cell: never flexible.)
+ * The name column (index 0) gives way after all of these, down to the longest bare role label. */
 const FLEXIBLE_COLUMNS = [
     { index: 10, minWidth: 12 },
     { index: 1, minWidth: 12 },
@@ -173,8 +174,8 @@ function badgeSpans(badge, tone) {
 /** The daily budget badge's tone: yellow from 85% of the cap, red once it is spent; the
  * subscription window's own severity (amber near its limit, red when a rejected window holds
  * the seams) wins when it stands beside the daily spend. */
-function budgetTone(budget, claudeWindow) {
-    const window = claudeWindowTone(claudeWindow);
+function budgetTone(budget, windows) {
+    const window = subscriptionWindowTone(windows);
     if (window !== undefined)
         return window;
     if (budget.free || !(budget.capUsd > 0))
@@ -183,14 +184,14 @@ function budgetTone(budget, claudeWindow) {
     return share >= 1 ? "red" : share >= 0.85 ? "yellow" : undefined;
 }
 /** Render the status table shared by `tumwater status` and the TUI as lines of toned spans,
- * plus the per-loop facts it computed (see StatusLoopRow). When `maxWidth` is given, wide cells
+ * plus the per-role facts it computed (see StatusRoleRow). When `maxWidth` is given, wide cells
  * are clipped so no line exceeds it (terminal rows never wrap). */
-export function renderStatusSpans(root, snap, maxWidth) {
+export function renderStatusSpans(root, snap, maxWidth, scoped = false) {
     const name = projectName(root);
     const lines = [];
     // One clock read per render, shared by the timed-pause badge's countdown and every row's
-    // next-run cell — a per-site Date.now() could tick over between them and disagree with
-    // itself.
+    // next-run cell — a per-site Date.now() could tick over // retired-name-ok
+    // between them and disagree with itself.
     const now = Date.now();
     // The questions badge (like the inbox one) appears only when something needs an answer.
     // The budget badge is standing information for a money-spending system in EVERY cap state
@@ -212,7 +213,7 @@ export function renderStatusSpans(root, snap, maxWidth) {
         ...badgeSpans(mergeBadge(snap.mergeQueue), "blue"),
         ...(snap.inbox ? [{ text: ` · inbox: ${snap.inbox}` }] : []),
         ...(snap.questions ? badgeSpans(` · questions: ${snap.questions}`, "magenta") : []),
-        ...badgeSpans(budgetBadge(snap.budget, snap.claudeWindow, now, snap.chain), budgetTone(snap.budget, snap.claudeWindow)),
+        ...badgeSpans(budgetBadge(snap.budget, snap.subscriptionWindows, snap.subscriptionOnly, now, snap.chain), budgetTone(snap.budget, snap.subscriptionWindows)),
         // The disk floor (plans/disk-floor.md, part 4/4): `disk 8.2 GB free — holding new work`
         // while the hold is on, or the bare reading below the reclaim threshold. Empty in every
         // comfortable or unmeasured state, so an unaffected header stays byte-identical.
@@ -221,6 +222,10 @@ export function renderStatusSpans(root, snap, maxWidth) {
         // `slots 5/8 · omlx 3/3` only while the per-provider cap map is set (permitsBadge already
         // omits the providers on a map-less team, so the header stays byte-identical).
         ...badgeSpans(permitsBadge(snap.permits), "blue"),
+        // Checks running/waiting for a check permit; empty while the check pool is idle.
+        ...badgeSpans(checksBadge(snap.checkPermits), snap.checkPermits && snap.checkPermits.waiting > 0 ? "yellow" : "blue"),
+        // The workspace pool, only while it is full or a run waits for a slot.
+        ...badgeSpans(workspacesBadge(snap.slotPool), snap.slotPool && snap.slotPool.waiting > 0 ? "yellow" : "blue"),
         // New-project bootstrap (plans/work-ratio.md, part 2/2): the progress reading while the
         // hold is active. Empty in every normal project, so the header stays byte-identical.
         ...badgeSpans(bootstrapBadge(snap.bootstrap), "blue"),
@@ -238,31 +243,31 @@ export function renderStatusSpans(root, snap, maxWidth) {
         ...badgeSpans(quietBadge(snap.quietHours, snap.inQuietHours), snap.inQuietHours ? "yellow" : undefined),
     ]);
     lines.push([]);
-    // `today` is the loop's daily budget window (dailyCost): $0.00 while its stamp is stale
-    // or missing, so loops that never ticked — or last ticked yesterday — read zero without a
+    // `today` is the role's daily budget window (dailyCost): $0.00 while its stamp is stale
+    // or missing, so roles that never ran — or last ran yesterday — read zero without a
     // save. It renders whether or not the cap is enabled: spend observability does not depend
     // on it.
     // `next run` is a short fixed-width cell like `today`, never flexible: the columns that
     // give way when the table is wider than the terminal are `last result`, then `state`, then
-    // `last tick`, in FLEXIBLE_COLUMNS' order.
+    // `last run`, in FLEXIBLE_COLUMNS' order.
     const cols = ["role", "state", "runs", "commits", "output", "peak ctx", "cost", "today", "last run", "last merged", "last result", "next run"];
-    // One live tail read per running loop per frame, threaded through every cell that shows
+    // One live tail read per running role per frame, threaded through every cell that shows
     // in-flight detail (metrics, state, current work) — each helper used to re-read the log on
-    // its own, up to three stats + reads per loop per second. The phase is computed once per
-    // row (in loopRowCells, shared with the GUI payload) and carried on the row: the same
-    // label drives the state cell and the shared row order (sortLoopsByState).
-    // Per-role prompts 2/2 — a loop with queued prompts carries a small `p:N` marker on its
+    // its own, up to three stats + reads per role per second. The phase is computed once per
+    // row (in roleRowCells, shared with the GUI payload) and carried on the row: the same
+    // label drives the state cell and the shared row order (sortRolesByState).
+    // Per-role prompts 2/2 — a role with queued prompts carries a small `p:N` marker on its
     // state cell (appended, so the work-item prefix survives clipping ahead of it), telling the
-    // operator steering one loop that something is waiting for it. A pending scheduled wake
-    // naming the loop adds a blue ` · wake in …` marker after it.
+    // operator steering one role that something is waiting for it. A pending scheduled wake
+    // naming the role adds a blue ` · wake in …` marker after it.
     const roleQueued = (role) => {
         const n = snap.roleInbox[role] ?? 0;
         return n > 0 ? ` p:${n}` : "";
     };
-    const withMetrics = snap.loops.map((s) => {
-        // loopRowCells single-homes the per-loop tail read + metrics + phase derivation the GUI
+    const withMetrics = snap.roles.map((s) => {
+        // roleRowCells single-homes the per-role tail read + metrics + phase derivation the GUI
         // payload (status-payload.ts) repeats, so the two dashboards cannot drift apart.
-        const cells = loopRowCells(snap, root, s);
+        const cells = roleRowCells(snap, root, s);
         return {
             s,
             m: { generated: cells.generated, peakCtx: cells.peakCtx },
@@ -272,26 +277,32 @@ export function renderStatusSpans(root, snap, maxWidth) {
             lastRunEndedAt: s.lastRunEndedAt,
         };
     });
-    // User-defined loops (snapshot's `custom` flag) get an asterisk beside their name — the
-    // dashboards' at-a-glance marker. The name column (index 0) is not in FLEXIBLE_COLUMNS and
-    // its width derives from row content, so the extra character widens it automatically.
-    // Rows are ordered by the shared display rule (status-model's loopRank, then last tick most
-    // recent first) so the TUI/status table groups loops the way the GUI table does.
+    // User-defined roles (snapshot's `custom` flag) get an asterisk beside their name — the
+    // dashboards' at-a-glance marker. The name column (index 0) is not in FLEXIBLE_COLUMNS;
+    // its width derives from row content and it shrinks only after those,
+    // so the extra character widens it.
+    // Rows are ordered by the shared display rule (status-model's roleRank, then last run most
+    // recent first) so the TUI/status table groups roles the way the GUI table does.
     // Each cell is spans: the state cell takes its phase's tone (the p:N marker stays plain), the
     // last result tones its outcome word, a backoff countdown reads yellow.
     const cell = (text, tone) => [{ text, ...(tone ? { tone } : {}) }];
-    const rows = sortLoopsByState(withMetrics).map(({ s, m, live, phase }) => {
+    // A model every role shares prints once in a footnote instead of on each name cell.
+    const modelInner = (s) => s.modelTier
+        ? `${s.modelTier}${s.model ? ` · ${s.model}` : ""}`
+        : s.model
+            ? `${s.model}${s.modelFromPi ? ", pi default" : ""}`
+            : "";
+    const inners = snap.roles.map(modelInner);
+    const sharedModel = snap.roles.length >= 2 && inners[0] && inners.every((m) => m === inners[0]) ? inners[0] : undefined;
+    const rows = sortRolesByState(withMetrics).map(({ s, m, live, phase }) => {
         // The name cell appends the selector the role resolves to; with a top-level tier map
         // declared it additionally names the seam tier (model-tiers.md part 7a,
         // "Observability"). No model resolved and no tier keeps the name byte-identical to
         // today's.
-        const modelSuffix = s.modelTier
-            ? ` (${s.modelTier}${s.model ? ` · ${s.model}` : ""})`
-            : s.model
-                ? ` (${s.model}${s.modelFromPi ? ", pi default" : ""})`
-                : "";
-        // Model failure fallback, part 2/2: while the loop runs off-model its name cell says so,
-        // so the operator can see which loops the fallback pair is carrying without reading logs.
+        const inner = modelInner(s);
+        const modelSuffix = inner && !sharedModel ? ` (${inner})` : "";
+        // Model failure fallback, part 2/2: while the role runs off-model its name cell says so,
+        // so the operator can see which roles the fallback pair is carrying without reading logs.
         const fallbackSuffix = s.fallback ? " (over-cap model)" : "";
         const name = (s.custom ? `${roleLabel(s.role)}*` : roleLabel(s.role)) + modelSuffix + fallbackSuffix;
         const state = stateCell(root, s, phase, live);
@@ -300,12 +311,12 @@ export function renderStatusSpans(root, snap, maxWidth) {
         // survives clipping), and clipping often leaves only it — the color still tells the state.
         const stateSpans = [{ text: state, ...(tone ? { tone } : {}) }];
         const next = nextRunCell(s, phase, now, snap.running);
-        const wakeMark = loopWakeMarker(snap.scheduledWakes, s.role, s.instanceOf, now);
+        const wakeMark = roleWakeMarker(snap.scheduledWakes, s.role, s.instanceOf, now);
         const resultT = resultTone(s.lastResult);
         return [
             cell(name),
             // Merge queue 4/5 — the merge role's phase label (the marker-driven record, filtered to
-            // this role by loopPhase's `merge` argument above) rides this same phase string.
+            // this role by rolePhase's `merge` argument above) rides this same phase string.
             [...stateSpans, { text: roleQueued(s.role) }, ...(wakeMark ? [{ text: wakeMark, tone: "blue" }] : [])],
             cell(String(s.runs)),
             cell(String(s.commits)),
@@ -313,7 +324,7 @@ export function renderStatusSpans(root, snap, maxWidth) {
             cell(compactTokens(m.peakCtx)),
             cell(usd(s.totalCostUsd)),
             cell(usd(dailyCost(s))),
-            cell(lastTickCell(s.lastRunEndedAt)),
+            cell(lastRunCell(s.lastRunEndedAt)),
             cell(lastMergedCell(s.lastMergedAt)),
             s.lastResult
                 ? [{ text: eventTypeLabel(s.lastResult), ...(resultT ? { tone: resultT } : {}) }, { text: s.lastSummary ? ` — ${s.lastSummary}` : "" }]
@@ -328,15 +339,16 @@ export function renderStatusSpans(root, snap, maxWidth) {
         "",
         compactTokens(withMetrics.reduce((sum, { m }) => sum + m.generated, 0)),
         compactTokens(Math.max(0, ...withMetrics.map(({ m }) => m.peakCtx))),
-        usd(snap.loops.reduce((sum, s) => sum + s.totalCostUsd, 0)),
+        usd(snap.roles.reduce((sum, s) => sum + s.totalCostUsd, 0)),
         // The team's today-spend, from the snapshot's budget block — the same number the header
         // badge reads, so table and badge cannot drift. While the orchestrator runs that figure is
-        // the scheduler's live sum over its in-memory states, which can sit ABOVE the per-loop
-        // `today` cells above (each loop's persisted copy, written only at its saves): the gap is
+        // the scheduler's live sum over its in-memory states, which can sit ABOVE the per-role
+        // `today` cells above (each role's persisted copy, written only at its saves): the gap is
         // exactly the in-flight charge the budget gate has already counted, and displaying it is
         // the point (BUGS.md 2026-09-30). Not running, the snapshot derives the block from these
-        // same loops, so cells and total agree by construction.
-        usd(snap.budget.spentUsd),
+        // same roles, so cells and total agree by construction.
+        // A role-scoped table adds up the rows shown instead: the team figure would not match them.
+        usd(scoped ? snap.roles.reduce((sum, s) => sum + dailyCost(s), 0) : snap.budget.spentUsd),
         "",
         "",
         "",
@@ -357,6 +369,11 @@ export function renderStatusSpans(root, snap, maxWidth) {
             widths[index] = current - reduction;
             overflow -= reduction;
         }
+        // The name column gives way last, down to the longest bare role label.
+        if (overflow > 0) {
+            const floor = Math.max(displayWidth(cols[0] ?? ""), ...snap.roles.map((s) => displayWidth(s.custom ? `${roleLabel(s.role)}*` : roleLabel(s.role))));
+            widths[0] = Math.max(floor, (widths[0] ?? 0) - overflow);
+        }
     }
     // Each cell clipped and padded to its column (padding stays untoned), the columns joined by
     // the gap, and the line's trailing padding trimmed — the plain text is exactly the aligned
@@ -390,14 +407,14 @@ export function renderStatusSpans(root, snap, maxWidth) {
         }
         return out;
     };
-    const loops = withMetrics.map(({ s, phase, live }) => ({
+    const roles = withMetrics.map(({ s, phase, live }) => ({
         role: s.role,
         phase,
         errorStreak: onErrorStreak(s),
         inFlight: isActivePhase(phase),
         ...(live?.quietMs !== undefined ? { stuckMs: live.quietMs } : {}),
         ...(s.lastError ? { lastError: s.lastError } : {}),
-        // The loop's image-input surface (plans/image-input.md "Surfaces", part 5/5): always
+        // The role's image-input surface (plans/image-input.md "Surfaces", part 5/5): always
         // present, so the TUI's images attention line keys on it like the dashboard's.
         imageInput: s.imageInput,
         imageReroute: s.imageRerouteLabel,
@@ -409,19 +426,21 @@ export function renderStatusSpans(root, snap, maxWidth) {
         lines.push(fmt(r));
     lines.push(separator);
     lines.push(fmt(totalsRow, "bold"));
-    // One footnote under the table when any custom loop exists — explains the asterisk without
-    // taking a column. Absent (byte-identical table) on a team with no user-defined loops.
-    if (snap.loops.some((l) => l.custom))
+    // One footnote under the table when any custom role exists — explains the asterisk without
+    // taking a column. Absent (byte-identical table) on a team with no user-defined roles.
+    if (sharedModel)
+        lines.push([{ text: `model (every role): ${sharedModel}`, tone: "dim" }]);
+    if (snap.roles.some((l) => l.custom))
         lines.push([{ text: "* custom role", tone: "dim" }]);
     // The header line (and any residual overflow past the columns' minimums) is clipped too,
     // so no status line ever wraps in a terminal of `maxWidth` columns.
-    return { lines: maxWidth === undefined ? lines : lines.map((l) => clipSpans(l, maxWidth)), loops };
+    return { lines: maxWidth === undefined ? lines : lines.map((l) => clipSpans(l, maxWidth)), roles };
 }
 /** Render the status table shared by `tumwater status` and the TUI as plain text (see
  * renderStatusSpans). When `maxWidth` is given, wide cells are clipped so no line exceeds it
  * (terminal rows never wrap). */
-export function renderStatus(root, snap, maxWidth) {
-    const { lines, loops } = renderStatusSpans(root, snap, maxWidth);
+export function renderStatus(root, snap, maxWidth, scoped = false) {
+    const { lines, roles } = renderStatusSpans(root, snap, maxWidth, scoped);
     // The team-attention banners (team-alerts.ts) drop under the header's blank line here, on
     // the CLI-only plain-text surface — the same spelled-out banners the dashboard and TUI draw,
     // from the one shared source, so the CLI/GUI/TUI cannot drift on wording. One QUESTIONS.md
@@ -431,7 +450,7 @@ export function renderStatus(root, snap, maxWidth) {
     // Composed here, NOT inside renderStatusSpans: the TUI re-slices that function's shared
     // `lines` (lines[0], its own attention block, then lines.slice(1)), so a banner embedded
     // there would render twice in the TUI.
-    const alerts = teamAlerts(snap, openQuestions(root), loops, Date.now(), refusedEntryTitles(root)).filter((a) => a.key !== "stopped");
+    const alerts = teamAlerts(snap, openQuestions(root), roles, Date.now(), refusedEntries(root), operatorHeldEntries(root), staleOpenBugs(root), stalePrompts(root), staleMerges(root), planDependencyAlert(root), staleWaitingBugs(root), skippedMergeFiles(root), stalledPlanEntries(root)).filter((a) => a.key !== "stopped");
     const banner = alertLines(alerts, maxWidth ?? Number.MAX_SAFE_INTEGER, alerts.length).map(plainText);
     const text = lines.map(plainText);
     return [...text.slice(0, 2), ...banner, ...text.slice(2)].join("\n");