tumwater 0.1.2 → 0.2.0

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

@@ -1,19 +1,31 @@
-import { openBugs, openQuestions, plannedPlans } from "../backlog/backlog.js";
-import { backlogMarks } from "../backlog/backlog-eligibility.js";
+// vocabulary: plain
+import { answeredQuestionSummaries } from "../backlog/question-answer.js";
+import { completionDate, donePlanEntries, DONE_DATE_RE, FIXED_DATE_RE, fixedBugEntries, openBugs, openQuestions, plannedPlans } from "../backlog/backlog.js";
+import { backlogHolds, backlogInProgress, backlogMarks, refusedEntryTitles } from "../backlog/backlog-eligibility.js";
+import { finishedTitle, groupBlockedSeries, partsLabel } from "../backlog/backlog-structure.js";
 import { readEvents } from "../events/event-read.js";
 import { eventFeedItem, formatEvent } from "../events/event-format.js";
 import { projectName } from "../project-name.js";
 import { dailyCost } from "../budget/budget.js";
+import { queueEntryMergeLabel } from "../merge/merge-queue-render.js";
 import { snapshot } from "../status/status-data.js";
-import { bootstrapBadge, buildBadge, budgetBadge, diskBadge, landingBadge, mainCheckBadge, mainCountsFragment, quietBadge } from "./badges.js";
-import { isActivePhase, loopRowCells } from "./status-model.js";
+import { bootstrapBadge, buildBadge, budgetBadge, diskBadge, mergeBadge, mainCheckBadge, mainCountsFragment, permitsBadge, quietBadge, runWindowBadge } from "./badges.js";
+import { isActivePhase, loopRowCells, onErrorStreak } from "./status-model.js";
 import { yieldMultiplierFor } from "../scheduling/backoff.js";
-import { fleetAlerts } from "./fleet-alerts.js";
+import { teamAlerts } from "./team-alerts.js";
 /** How many recent events the payload carries — enough for the dashboard's activity feed to
- * still show a screenful of notable events (landings, failures, questions) after it filters
+ * still show a screenful of notable events (merges, failures, questions) after it filters
  * out the routine ones (tick starts, wakes, passing checks). */
 const RECENT_EVENTS = 80;
-/** The one fleet-state document both observer surfaces carry: `GET /api/status` (gui/gui-server.ts)
+/** How many answered questions the dashboard lists under the open ones (a default, not a knob). */
+export const DASHBOARD_ANSWERED_QUESTIONS = 5;
+/** How many done plans / fixed bugs the dashboard lists under the open ones (a default). */
+export const DASHBOARD_RECENT_FINISHED = 5;
+/** The newest finished entries (sections are newest first), titles cleaned of their stamp. */
+export function recentFinished(entries, dateRe) {
+    return entries.slice(0, DASHBOARD_RECENT_FINISHED).map((e) => ({ title: finishedTitle(e.title, dateRe), completedOn: completionDate(e.title, dateRe) }));
+}
+/** The one team-state document both observer surfaces carry: `GET /api/status` (gui/gui-server.ts)
  * spreads it and adds the serving process's own `serverBuildSha` (the page's cue to notice a
  * newer build and reload), while `tumwater status --json` (cli.ts) prints it verbatim — every
  * other field is shared, so the dashboard and the CLI can never drift apart. Assembled here —
@@ -34,13 +46,31 @@ export function statusPayload(root, now = Date.now()) {
     // the prompt's backlog index and `tumwater backlog` render, projected to the mark each
     // surface appends. Read once here, consumed as the parallel planHolds/bugHolds arrays below.
     const marks = backlogMarks(root);
-    const loops = snap.loops.map((s) => {
+    const holds = backlogHolds(root);
+    const plans = plannedPlans(root);
+    // Which blocked plans fold into a series row: the grouping `plan --list` and the prompt's
+    // backlog index use, as a slot per plan (null for a plan that stays an ordinary row).
+    const working = backlogInProgress(root);
+    const planSeries = plans.map(() => null);
+    for (const g of groupBlockedSeries(holds.plans.map((hold, i) => ({ i, title: plans[i], hold, claimer: working.plans[i] ?? undefined })))) {
+        if (g.kind !== "series")
+            continue;
+        const slot = { name: g.series, label: `${g.series}, ${g.rows.length} blocked parts (${partsLabel(g.rows)})` };
+        for (const r of g.rows)
+            planSeries[r.i] = slot;
+    }
+    const roles = snap.loops.map((s) => {
         // loopRowCells single-homes the per-loop tail read + metrics + phase derivation the
         // TUI table (status-render.ts's renderStatus) repeats, so the two dashboards cannot
         // drift apart.
         const { live, generated, peakCtx, phase } = loopRowCells(snap, root, s);
         return {
             role: s.role,
+            // The loop's own failure-streak tell (onErrorStreak, status-model.ts): the red
+            // "failing tick after tick" alert keys on this rather than the rendered phase, so it
+            // stays up while the loop's next tick runs (phase reads "working") and clears only
+            // when the streak resets (BUGS.md 2026-10-14).
+            errorStreak: onErrorStreak(s),
             // User-defined-loop marker (computed in snapshot — see StatusSnapshot.loops): the GUI
             // renders it as an asterisk beside the loop name.
             custom: s.custom,
@@ -50,28 +80,42 @@ export function statusPayload(root, now = Date.now()) {
             // the loop name and the selector in the sub line.
             ...(s.modelTier ? { modelTier: s.modelTier } : {}),
             ...(s.model ? { model: s.model } : {}),
+            // pi's own saved default (see StatusSnapshot.loops.modelFromPi): ships beside `model` so
+            // the dashboard can mark a row whose model tumwater.json did not name. Same conditional
+            // spread as `model`, present on exactly the rows that carry the flag.
+            ...(s.modelFromPi ? { modelFromPi: true } : {}),
             // Model failure fallback (PLANS.md "Model failure fallback, part 2/2"): present only
             // while the loop's ticks run off-model, so the common row shape is unchanged.
             ...(s.fallback ? { fallback: s.fallback } : {}),
             ...(s.slot ? { slot: s.slot, slotPinned: s.slotPinned === true } : {}),
             // Parallel work instances (plans/parallel-work-instances.md "Observability", part
             // 6/7): the backlog entry this instance claimed, shown by the dashboards while it is
-            // idle or landing, and the base role it belongs to (`feature-2` → `feature`). `claim`
+            // idle or merge, and the base role it belongs to (`feature-2` → `feature`). `claim`
             // is the claimed heading text, not the persisted record; both are absent on a bare,
             // unclaimed row so the common payload shape is unchanged.
             ...(s.claim ? { claim: s.claim.title } : {}),
             ...(s.instanceOf ? { instanceOf: s.instanceOf } : {}),
+            // The loop's image-input surface (plans/image-input.md "Surfaces", part 5/5), always
+            // present: whether its own model reads images and where a blind prompt reroutes — the
+            // GUI's images alert and composer notice read them (the JSON field is `imageReroute`, the
+            // display label, not the persisted handoff state).
+            ...(s.imageInput !== undefined ? { imageInput: s.imageInput } : {}),
+            ...(s.imageRerouteLabel !== undefined ? { imageReroute: s.imageRerouteLabel } : {}),
             phase,
             // In-flight flag derived from the same rendered phase (isActivePhase's
-            // permit-holder prefixes: working/reviewing/landing). The running director is excluded
+            // permit-holder prefixes: working/reviewing/merge). The running director is excluded
             // (it holds no maxConcurrent permit), so this is the cap count, not the abort set — the
             // GUI's row actions derive their own live flag from the phase instead (BUGS.md
             // 2026-10-06).
             inFlight: isActivePhase(phase),
+            // The stuck alert's silence span (ms since the last pi log write, capped to the tick by
+            // progressOfTick) — the dashboards render it as "for <duration>" on a tool-call stall.
+            // Present only while the loop holds a live tail, so the common payload shape is unchanged.
+            ...(live?.quietMs !== undefined ? { stuckMs: live.quietMs } : {}),
             // What a working loop is doing right now (first assistant text of the in-flight run).
             // Null when idle — never show a stale item from a finished tick.
             currentWork: live?.currentWork ?? null,
-            ticks: s.ticks,
+            runs: s.runs,
             commits: s.commits,
             generated,
             peakCtx,
@@ -81,12 +125,16 @@ export function statusPayload(root, now = Date.now()) {
             todayUsd: dailyCost(s),
             lastResult: s.lastResult ?? null,
             lastSummary: s.lastSummary ?? null,
-            // The last failure's text (a tick error, a failed landing's reason); the dashboard shows it
+            // The last failure's text (a tick error, a failed merge's reason); the dashboard shows it
             // beside a problem result that carries no summary of its own.
             lastError: s.lastError ?? null,
-            lastTickEndedAt: s.lastTickEndedAt ?? null,
+            lastRunEndedAt: s.lastRunEndedAt ?? null,
+            // When the loop last actually merged a change on main (epoch ms; null until it ever
+            // does) — the direct answer to "how long has the dry spell been", the productivity
+            // complement to lastError/lastRunEndedAt.
+            lastMergedAt: s.lastMergedAt ?? null,
             // The scheduling facts behind the `next run` column: raw epoch ms and seconds, formatted
-            // client-side like lastTickEndedAt/costUsd — the GUI's fmtNextRun twin applies the same
+            // client-side like lastRunEndedAt/costUsd — the GUI's fmtNextRun twin applies the same
             // rules nextRunCell does (see status-render.ts).
             nextRunAt: s.nextRunAt,
             backoffSeconds: s.backoffSeconds,
@@ -94,6 +142,12 @@ export function statusPayload(root, now = Date.now()) {
             // clocks, PLANS.md): the payload carries the computed number, not the ring, so the
             // GUI's JS twin applies the same display rule without re-deriving the role sets.
             yieldMultiplier: yieldMultiplierFor(s),
+            // The consecutive no-change streak (tick-apply.ts applyTickOutcome's noChangeStreak, an
+            // observational counter): how many completed ticks in a row returned nothing to do. The
+            // TUI reads it off the rendered label; the GUI's phaseDetailBase re-derives the ` · no
+            // change ×N` suffix from this number (its row and drawer share noChangeStreak) so its
+            // JS twin applies the same display rule without re-parsing the phase text.
+            noChangeStreak: s.noChangeStreak ?? 0,
         };
     });
     return {
@@ -110,21 +164,34 @@ export function statusPayload(root, now = Date.now()) {
         // not be re-derived client-side where it could drift from the TUI header.
         buildBadge: buildBadge(snap.build),
         // The header's daily-cost-budget badge preformatted through badges.ts's budgetBadge —
-        // the same string the TUI/status table renders (n/a for an all-free fleet; `· no cap`
+        // the same string the TUI/status table renders (n/a for an all-free team; `· no cap`
         // when disabled). Sent display-ready like buildBadge so the page cannot re-derive it.
-        budgetBadge: budgetBadge(snap.budget, snap.claudeWindow),
+        budgetBadge: budgetBadge(snap.budget, snap.claudeWindow, now, snap.chain),
         // The disk floor (plans/disk-floor.md, part 4/4): the raw block is machine-readable for
         // `status --json`, and the header badge is preformatted through badges.ts's diskBadge —
         // the same string the TUI/status header renders. Omitted (not null) when no orchestrator
         // has published one — the same omit-undefined idiom as pausedUntil.
         ...(snap.disk ? { disk: snap.disk } : {}),
-        diskBadge: diskBadge(snap.disk, now),
-        // The land queue (plans/merge-queue.md 4/5): depth always (machine-readable for
-        // `status --json`; 0 when idle) plus the in-flight landing's identity only while one is
+        diskBadge: diskBadge(snap.disk),
+        // The permit pool (plans/provider-concurrency.md §8): raw block machine-readable for
+        // `status --json`, plus the display-ready header badge — the same `slots 5/8 · omlx 3/3`
+        // string the TUI/status header renders. Omitted when no orchestrator has published one.
+        ...(snap.permits ? { permits: snap.permits } : {}),
+        permitsBadge: permitsBadge(snap.permits),
+        // The `run --for` deadline: raw epoch ms (only when windowed) plus the display-ready badge.
+        ...(snap.runStopsAt !== undefined ? { runStopsAt: snap.runStopsAt } : {}),
+        ...(snap.scheduledStopAt !== undefined ? { scheduledStopAt: snap.scheduledStopAt } : {}),
+        runWindowBadge: runWindowBadge(snap.runStopsAt, now),
+        // The merge queue (plans/merge-queue.md 4/5): depth always (machine-readable for
+        // `status --json`; 0 when idle) plus the in-flight merge's identity only while one is
         // actually running. Raw data here, like budget — and the display-ready header badge
-        // preformatted through badges.ts's landingBadge, so the page cannot re-derive it.
-        landQueue: snap.landQueue,
-        landingBadge: landingBadge(snap.landQueue),
+        // preformatted through badges.ts's mergeBadge, so the page cannot re-derive it.
+        mergeQueue: snap.mergeQueue,
+        mergeBadge: mergeBadge(snap.mergeQueue),
+        // One bracketed merge label per merge queue entry (queueEntryMergeLabel, "" for none),
+        // parallel to mergeQueue.entries — display-ready like mergeBadge, since browser JS cannot
+        // import the TypeScript stage labels.
+        mergeQueueLabels: (snap.mergeQueue.entries ?? []).map((e) => queueEntryMergeLabel(e.sha, snap.mergeQueue.inFlight, now)),
         // Main's newest merge-scope check: the
         // raw block is machine-readable for `status --json`, and the header badge is
         // preformatted through badges.ts's mainCheckBadge — the same string the TUI/status
@@ -167,14 +234,18 @@ export function statusPayload(root, now = Date.now()) {
         // the preformatted `budgetBadge`.
         budget: snap.budget,
         // The subscription usage-window block (part 6d/7), absent on a pi-only or API-claude
-        // fleet — the same raw shape `status --json` carries, which the GUI's spend card reads
+        // team — the same raw shape `status --json` carries, which the GUI's spend card reads
         // to render the window (the preformatted budgetBadge above already folds it into the
         // header for the TUI/status). Raw data, like budget.
         ...(snap.claudeWindow ? { claudeWindow: snap.claudeWindow } : {}),
+        // Each tier's fallback step (fallback chain part 7c/7), raw for the GUI side card.
+        ...(snap.chain ? { chain: snap.chain } : {}),
         // Operator pause (`tumwater pause` marker present): every idle role loop's phase reads
         // `paused` ahead of budget/main-red — one flag covers both dashboards through loopPhase.
         paused: snap.paused,
         pausedRoles: snap.pausedRoles,
+        // The loop ids the scheduler treats as paused by the marker; the dashboards read this.
+        pausedLoops: snap.pausedLoops,
         // The per-role cap's held roles (part 2/2): an idle
         // loop in this set reads `cap paused` — the loopPhase ladder names it, and `status
         // --json` carries the raw set beside pausedRoles so scripts read the same verdict.
@@ -194,12 +265,13 @@ export function statusPayload(root, now = Date.now()) {
         // window, machine-readable for `status --json` beside capPaused; the dashboards render
         // the loop's own `quiet until <end>` from it through loopPhase.
         roleQuietPaused: snap.roleQuietPaused,
-        // The fleet marker's standing timed-pause deadline (ms epoch), absent when the fleet is
+        // The team marker's standing timed-pause deadline (ms epoch), absent when the team is
         // not timed-paused (undefined drops from the JSON). Raw data, like paused/pausedRoles —
         // machine-readable for `status --json`; the planned GUI pause-badge countdown reads it
         // client-side.
         pausedUntil: snap.pausedUntil,
-        // The paused-roles marker's shared `until` while a timed per-role pause stands (omitted otherwise).
+        // The paused-roles marker's shared `until` while a timed per-role pause stands (omitted
+        // otherwise).
         pausedRolesUntil: snap.pausedRolesUntil,
         // A pending scheduled wake ({ roles, atMs }); omitted when none stands.
         scheduledWake: snap.scheduledWake,
@@ -217,7 +289,7 @@ export function statusPayload(root, now = Date.now()) {
         ...(snap.quietHours ? { quietHours: snap.quietHours } : {}),
         inQuietHours: snap.inQuietHours,
         quietBadge: quietBadge(snap.quietHours, snap.inQuietHours),
-        loops,
+        roles,
         // The recent event feed as the one-line text `tumwater logs` prints…
         events: recent.map((e) => formatEvent(e)),
         // …and the same events as data for the dashboard's activity feed: when, which loop, what
@@ -227,16 +299,31 @@ export function statusPayload(root, now = Date.now()) {
         // Project status (planned features + open bugs + open questions), fresh per poll like
         // events — loops edit these files constantly, so there is no cache to go stale. The page
         // derives the header badge count from this list's length.
-        plans: plannedPlans(root),
+        plans,
         bugs: openBugs(root),
-        // The holds beside those titles, index-for-index parallel (backlogMarks and plannedPlans/
-        // openBugs walk the same sectionEntries file order): holdMark renders an eligible entry as
-        // the empty string, so a client can append the mark without a separate eligibility check.
+        // The holds and working-on-it marks beside those titles, index-for-index parallel
+        // (backlogMarks and plannedPlans/openBugs walk the same sectionEntries file order): an
+        // eligible entry nobody is working on is the empty string, so a client can append the
+        // mark without a separate eligibility check.
         planHolds: marks.plans,
         bugHolds: marks.bugs,
+        // Whether each entry carries any eligibility hold (parallel to plans/bugs): the dashboard
+        // lists unblocked rows first and gathers the rest under a Blocked divider.
+        planBlocked: holds.plans.map((h) => h !== null),
+        bugBlocked: holds.bugs.map((h) => h !== null),
+        // The series each blocked plan folds into (parallel to plans): the Plans tab shows one
+        // expandable row per series instead of every waiting part; null for an ordinary row.
+        planSeries,
         questions,
-        // What needs the operator (fleet-alerts.ts's fleetAlerts): the dashboard's alert banners and
+        // The newest answered questions, newest first, read fresh each poll like the other backlog
+        // lists. Alerts and badges keep counting open questions only.
+        answeredQuestions: answeredQuestionSummaries(root, DASHBOARD_ANSWERED_QUESTIONS),
+        // The newest done plans and fixed bugs, newest first: cleaned titles only, no bodies, read
+        // fresh each poll. Badges and alerts keep counting open entries only.
+        donePlans: recentFinished(donePlanEntries(root), DONE_DATE_RE),
+        fixedBugs: recentFinished(fixedBugEntries(root), FIXED_DATE_RE),
+        // What needs the operator (team-alerts.ts's teamAlerts): the dashboard's alert banners and
         // the TUI's attention lines, phrased once.
-        alerts: fleetAlerts(snap, questions, loops, now),
+        alerts: teamAlerts(snap, questions, roles, now, refusedEntryTitles(root)),
     };
 }

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

@@ -1,17 +1,22 @@
 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, pad2, secondsUntil } from "../text/datetime.js";
+import { elapsedSeconds, formatTime, humanSeconds, nextRunPhrase, pad2, secondsUntil } from "../text/datetime.js";
 import { projectName } from "../project-name.js";
-import { bootstrapBadge, buildBadge, budgetBadge, claudeWindowTone, diskBadge, landingBadge, mainCheckBadge, mainCheckVerdict, pauseBadge, loopWakeMarker, quietBadge, wakeBadge } from "./badges.js";
-import { idleClaimText, isActivePhase, loopRowCells, sortLoopsByState } from "./status-model.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 { yieldMultiplierFor } from "../scheduling/backoff.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";
 /** 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 fleet state
+ * status/status-data.ts one way — rendering reads the snapshot; it never collects team state
  * itself (live tick detail is display-only). */
 function ago(ts) {
     if (!ts)
@@ -33,32 +38,35 @@ 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. */
+export function lastMergedCell(ts) {
+    return lastTickCell(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/landing,
- * or `s.running`) has no next run to speak of, and a stopped fleet renders no schedule at all
+ * operator's question — a loop 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
  * 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
- * `fleetRunning` arguments come from the caller because neither fact lives on LoopState: the
- * active-phase check needs the rendered label (a landing is visible only there), and the
- * fleet's running flag lives on the snapshot, not the loop. */
-export function nextRunCell(s, phase, now, fleetRunning) {
-    if (!fleetRunning || s.running || isActivePhase(phase))
+ * `teamRunning` arguments come from the caller because neither fact lives on LoopState: 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. */
+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 landed nothing keeps a longer effective gap than nextRunAt's
+    // role whose recent ticks 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 mult = yieldMultiplierFor(s);
-    const suffix = mult > 1 ? ` ×${mult}` : "";
-    if (remain <= 0)
-        return `now${suffix}`;
-    const label = humanSeconds(remain);
-    return (s.backoffSeconds > 0 ? `backoff ${label}` : label) + suffix;
+    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
  * renderStatus so the same label drives the row order), with the current work item prepended
@@ -70,11 +78,11 @@ export function nextRunCell(s, phase, now, fleetRunning) {
 function stateCell(root, s, phase, live) {
     // While under review the log tail's "current work" is the reviewer's own output, not the
     // author's task — don't prepend it; the phase cell already carries the reviewer's live
-    // detail. The landing label rides the same guard: the landing role is not running, so its
-    // phase ("landing <elapsed> · <stage>", with the reviewer's live detail while it reviews)
+    // detail. The merge label rides the same guard: the merge role is not running, so its
+    // phase ("merge <elapsed> · <stage>", with the reviewer's live detail while it reviews)
     // is returned without a work-item prefix.
     if (!s.running || s.parkedSince || s.phase === "review") {
-        // Parallel work instances, part 6/7: an idle or landing instance leads with the entry it
+        // Parallel work instances, part 6/7: an idle or merge instance leads with the entry it
         // claimed (or, for an idle extra with none, the no-unclaimed note), so the operator can
         // see WHAT it is parked on without opening its drawer.
         const idle = idleClaimText(s, phase);
@@ -87,11 +95,13 @@ function stateCell(root, s, phase, live) {
 /** 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. Indices are positional in the `cols` array
- * below — renumber when columns change. (`today`, like `cost`, is a short fixed-width cell:
- * never flexible.) */
+ * 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
+ * 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.) */
 const FLEXIBLE_COLUMNS = [
-    { index: 9, minWidth: 12 },
+    { index: 10, minWidth: 12 },
     { index: 1, minWidth: 12 },
     { index: 8, minWidth: 10 },
 ];
@@ -124,7 +134,35 @@ export function clipSpans(line, width) {
     }
     return out;
 }
-/** A header badge (" · land queue: 2", ", build abc…") as a plain separator plus its toned
+/** The attention line's mark and tone, per alert tone — shared by the TUI and `tumwater
+ * status` (status-render.ts alertLines), so the two surfaces draw the same banner glyphs. */
+const ALERT_MARKS = {
+    red: { mark: "!", tone: "red" },
+    amber: { mark: "!", tone: "yellow" },
+    indigo: { mark: "?", tone: "magenta" },
+    blue: { mark: "i", tone: "blue" },
+    gray: { mark: "i", tone: "dim" },
+};
+/** A plain line clipped to a width, in one tone. */
+export function toneLine(text, width, tone) {
+    return clipSpans([{ text, ...(tone ? { tone } : {}) }], width);
+}
+/** The attention lines under a header: one per alert — its mark and title in its tone, then
+ * the detail — at most `max` of them, the rest counted on a last line. This is the banner
+ * block the TUI draws under its header and `tumwater status` pushes under its own, so the two
+ * surfaces render the same wording from the one shared alert source (team-alerts.ts). */
+export function alertLines(alerts, width, max = 3) {
+    const shown = alerts.length > max ? alerts.slice(0, max - 1) : alerts;
+    const lines = shown.map((a) => {
+        const { mark, tone } = ALERT_MARKS[a.tone];
+        const t = tone ? { tone } : {};
+        return clipSpans([{ text: `${mark} `, ...t }, { text: a.title, ...t }, { text: a.detail ? ` — ${a.detail}` : "" }], width);
+    });
+    if (shown.length < alerts.length)
+        lines.push(toneLine(`  +${alerts.length - shown.length} more — the dashboard lists them all`, width, "dim"));
+    return lines;
+}
+/** A header badge (" · merge queue: 2", ", build abc…") as a plain separator plus its toned
  * words, so the TUI colors the words and not the dots. Empty badges add nothing. */
 function badgeSpans(badge, tone) {
     if (!badge)
@@ -157,27 +195,32 @@ export function renderStatusSpans(root, snap, maxWidth) {
     // 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
     // (disabled reads `· no cap` — and it is the affordance for editing the cap); on narrow
-    // terminals the header's existing last-resort whole-line clipping applies. A fleet whose
+    // terminals the header's existing last-resort whole-line clipping applies. A team whose
     // models are all free reads n/a — spend can never accumulate against a cap that cannot be
     // reached, so a dollar figure would mislead. The timed-pause badge (plans/pause-countdown
-    // wording) rides last so a fleet under a timed pause reads how long until it comes back —
-    // empty unless the fleet marker's deadline stands in the future, so a role-only or
+    // wording) rides last so a team under a timed pause reads how long until it comes back —
+    // empty unless the team marker's deadline stands in the future, so a role-only or
     // indefinite pause keeps today's header byte-identical.
     const running = snap.running
         ? [{ text: "running", tone: "green" }, { text: ` (pid ${snap.pid}` }, ...badgeSpans(buildBadge(snap.build), snap.build?.stale ? "yellow" : undefined), { text: ")" }]
-        : [{ text: "not running — start with `tumwater run`", tone: "dim" }];
+        : [{ text: "not running — start with `tumwater start`", tone: "dim" }];
     lines.push([
         { text: "tumwater", tone: "brand" },
         { text: ` · ${name} · ` },
         ...running,
-        ...badgeSpans(landingBadge(snap.landQueue), "blue"),
+        ...(snap.running ? badgeSpans(runWindowBadge(snap.runStopsAt, now), "blue") : []),
+        ...badgeSpans(mergeBadge(snap.mergeQueue), "blue"),
         ...(snap.inbox ? [{ text: ` · inbox: ${snap.inbox}` }] : []),
         ...(snap.questions ? badgeSpans(` · questions: ${snap.questions}`, "magenta") : []),
-        ...badgeSpans(budgetBadge(snap.budget, snap.claudeWindow), budgetTone(snap.budget, snap.claudeWindow)),
+        ...badgeSpans(budgetBadge(snap.budget, snap.claudeWindow, now, snap.chain), budgetTone(snap.budget, snap.claudeWindow)),
         // 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.
-        ...badgeSpans(diskBadge(snap.disk, now), snap.disk?.held ? "yellow" : "blue"),
+        ...badgeSpans(diskBadge(snap.disk), snap.disk?.held ? "yellow" : "blue"),
+        // The permit pool's live state (plans/provider-concurrency.md §8): the team line reads
+        // `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"),
         // 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"),
@@ -199,9 +242,10 @@ export function renderStatusSpans(root, snap, maxWidth) {
     // or missing, so loops that never ticked — or last ticked 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 appended last and never flexible (a short fixed-width cell like `today`):
-    // FLEXIBLE_COLUMNS' positional indices above stay untouched when columns change.
-    const cols = ["loop", "state", "ticks", "commits", "gen", "peak ctx", "cost", "today", "last tick", "last result", "next run"];
+    // `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.
+    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
     // 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
@@ -225,7 +269,7 @@ export function renderStatusSpans(root, snap, maxWidth) {
             live: cells.live,
             phase: cells.phase,
             role: s.role,
-            lastTickEndedAt: s.lastTickEndedAt,
+            lastRunEndedAt: s.lastRunEndedAt,
         };
     });
     // User-defined loops (snapshot's `custom` flag) get an asterisk beside their name — the
@@ -244,12 +288,12 @@ export function renderStatusSpans(root, snap, maxWidth) {
         const modelSuffix = s.modelTier
             ? ` (${s.modelTier}${s.model ? ` · ${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 fallbackSuffix = s.fallback ? " (on fallback)" : "";
-        const name = (s.custom ? `${s.role}*` : s.role) + modelSuffix + fallbackSuffix;
+        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);
         const tone = phaseTone(phase);
         // The whole state cell carries the phase's tone: a work item leads the cell (so it
@@ -260,20 +304,21 @@ export function renderStatusSpans(root, snap, maxWidth) {
         const resultT = resultTone(s.lastResult);
         return [
             cell(name),
-            // Merge queue 4/5 — the landing role's phase label (the marker-driven record, filtered to
-            // this role by loopPhase's `landing` argument above) rides this same phase string.
+            // 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.
             [...stateSpans, { text: roleQueued(s.role) }, ...(wakeMark ? [{ text: wakeMark, tone: "blue" }] : [])],
-            cell(String(s.ticks)),
+            cell(String(s.runs)),
             cell(String(s.commits)),
             cell(compactTokens(m.generated)),
             cell(compactTokens(m.peakCtx)),
             cell(usd(s.totalCostUsd)),
             cell(usd(dailyCost(s))),
-            cell(lastTickCell(s.lastTickEndedAt)),
+            cell(lastTickCell(s.lastRunEndedAt)),
+            cell(lastMergedCell(s.lastMergedAt)),
             s.lastResult
-                ? [{ text: s.lastResult, ...(resultT ? { tone: resultT } : {}) }, { text: s.lastSummary ? ` — ${s.lastSummary}` : "" }]
+                ? [{ text: eventTypeLabel(s.lastResult), ...(resultT ? { tone: resultT } : {}) }, { text: s.lastSummary ? ` — ${s.lastSummary}` : "" }]
                 : cell("-"),
-            cell(next, next.startsWith("backoff") ? "yellow" : undefined),
+            cell(next, next.startsWith("sleeping") ? "yellow" : undefined),
         ];
     });
     const totalsRow = [
@@ -284,7 +329,7 @@ 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)),
-        // The fleet's today-spend, from the snapshot's budget block — the same number the header
+        // 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
@@ -295,6 +340,7 @@ export function renderStatusSpans(root, snap, maxWidth) {
         "",
         "",
         "",
+        "",
     ].map((text) => cell(text));
     const allRows = [...rows, totalsRow];
     // Widths are measured in terminal display columns (displayWidth), not UTF-16 code units:
@@ -344,6 +390,18 @@ export function renderStatusSpans(root, snap, maxWidth) {
         }
         return out;
     };
+    const loops = 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
+        // present, so the TUI's images attention line keys on it like the dashboard's.
+        imageInput: s.imageInput,
+        imageReroute: s.imageRerouteLabel,
+    }));
     const separator = [{ text: widths.map((w) => "-".repeat(w)).join("  "), tone: "dim" }];
     lines.push(fmt(cols.map((c) => cell(c)), "dim"));
     lines.push(separator);
@@ -352,10 +410,9 @@ export function renderStatusSpans(root, snap, maxWidth) {
     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 fleet with no user-defined loops.
+    // taking a column. Absent (byte-identical table) on a team with no user-defined loops.
     if (snap.loops.some((l) => l.custom))
-        lines.push([{ text: "* user-defined loop", tone: "dim" }]);
-    const loops = withMetrics.map(({ s, phase }) => ({ role: s.role, phase, inFlight: isActivePhase(phase), ...(s.lastError ? { lastError: s.lastError } : {}) }));
+        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 };
@@ -364,5 +421,18 @@ export function renderStatusSpans(root, snap, maxWidth) {
  * renderStatusSpans). When `maxWidth` is given, wide cells are clipped so no line exceeds it
  * (terminal rows never wrap). */
 export function renderStatus(root, snap, maxWidth) {
-    return renderStatusSpans(root, snap, maxWidth).lines.map(plainText).join("\n");
+    const { lines, loops } = renderStatusSpans(root, snap, maxWidth);
+    // 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
+    // read (openQuestions) for the pending-questions alert — the dashboard's cadence. The CLI
+    // omits the not-running banner: the header's first line already spells out the team's state,
+    // so a `status` run on a stopped team does not lead with a banner that duplicates it.
+    // 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 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");
 }