tumwater 0.4.0 → 0.4.2

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

@@ -1,35 +1,25 @@
 import { answeredQuestionSummaries } from "../backlog/question-answer.js";
-import { questionFilingDate } from "../backlog/question-answer.js";
-import { completionDate, donePlanEntries, DONE_DATE_RE, FIXED_DATE_RE, fixedBugEntries, openBugs, openQuestions, openQuestionEntries, plannedPlans, openBugEntries, filingDate, ageInDays } from "../backlog/backlog.js";
-import { backlogHolds, backlogInProgress, backlogMarks, operatorHeldEntries, refusedEntries, refusalNote, stalledEntries, waitingNote } from "../backlog/backlog-eligibility.js";
-import { finishedTitle, groupBlockedSeries, partsLabel, strandedPlanEntriesFor, stripEntryStamp } from "../backlog/backlog-structure.js";
+import { completionDate, donePlanEntries, DONE_DATE_RE, FIXED_DATE_RE, fixedBugEntries, openBugs, openQuestions, plannedPlans } from "../backlog/backlog.js";
+import { backlogHolds, backlogInProgress, backlogMarks, refusedEntries, stalledEntries } from "../backlog/backlog-eligibility.js";
+import { finishedTitle, strandedPlanEntriesFor } from "../backlog/backlog-structure.js";
+import { groupBlockedSeries, partsLabel } from "../backlog/backlog-index-data.js";
 import { fixClaimProblems, validationGapProblems } from "../doctor/doctor-backlog-plans.js";
-import { checkWaitContention, providerWaitContention, slotWaitContention, staleWorkspacePins, CHECK_WAIT_CHECK_WINDOW_MS, PROVIDER_WAIT_CHECK_WINDOW_MS, SLOT_WAIT_CHECK_WINDOW_MS } from "../doctor/doctor-contention-checks.js";
 import { readEvents } from "../events/event-read.js";
-import { eventsSince } from "../events/event-window.js";
-import { isNotifyFailure } from "../events/notify.js";
 import { eventFeedItem, formatEvent } from "../events/event-format.js";
 import { projectName } from "../project-name.js";
 import { dailyCost } from "../budget/budget.js";
+import { contextShareLabel } from "../text/format.js";
 import { queueEntryMergeLabel } from "../merge/merge-queue-render.js";
+import { piModelsPath } from "../pi/pi-models.js";
 import { scopeSnapshotToRoles, snapshot } from "../status/status-data.js";
 import { bootstrapBadge, buildBadge, budgetBadge, diskBadge, mergeBadge, mainCheckBadge, mainCountsFragment, ciParityBadge, ciParityTone, permitsBadge, checksBadge, quietBadge, runWindowBadge, workspacesBadge } from "./badges.js";
-import { readSlotsState } from "../git/slots-state.js";
-import { configForStatus } from "../status/status-polls.js";
 import { isActivePhase, roleRowCells, onErrorStreak } from "./status-model.js";
-import { byDaysThenIndex } from "../collections.js";
 import { yieldMultiplierFor } from "../scheduling/backoff.js";
 import { staleClaimEntries } from "../scheduling/claim-entries.js";
-import { readQaCoverage, qaCoverageStalled } from "../run/qa-coverage.js";
 import { teamAlerts } from "./team-alerts.js";
-import { duplicatedBacklogHeadings, liveFinishedEntriesFor, planDependencyProblem } from "../doctor/doctor-backlog-plans.js";
-import { quarantineWarning } from "../baseline/main-guardrails.js";
-import { KNOWN_FLAKE_WINDOW_MS, loadQuarantine, repeatedFlakeCounts } from "../review/known-flakes.js";
-import { flappedChecksPhrase } from "../doctor/doctor-project-checks.js";
-import { readPostReviews, postMergeChurn, POST_MERGE_REJECT_WINDOW_MS } from "../review/post-merge-review.js";
-import { staleQueuedMergeRows, STALE_BUG_DAYS, STALE_QUESTION_DAYS, staleQueuedPromptRows, skippedMergeQueueFiles, atRiskPostReviews, atRiskPostReviewsPhrase } from "../doctor/doctor-backlog.js";
-import { NOTIFY_CHECK_WINDOW_MS } from "../doctor/doctor-notify.js";
-import { matchedRegressedFixes, regressedFixCandidates, regressedFixesPhrase, staleWaitingBugRows } from "../doctor/doctor-backlog-bugs.js";
+import { duplicatedBacklogHeadings, liveFinishedEntriesFor } from "../doctor/doctor-backlog-plans.js";
+import { readPostReviews } from "../review/post-merge-review.js";
+import { capacityContention, instancePoolProblems, planDependencyAlert, providerCapProblems, regressedFixesAlert, staleOpenQuestions, staleWorkspacePins } from "./alert-feeds.js";
 /** How many recent events the payload carries — enough for the dashboard's activity feed to
  * still show a screenful of notable events (merges, failures, questions) after it filters
  * out the routine ones (run starts, wakes, passing checks). */
@@ -42,311 +32,11 @@ export const DASHBOARD_RECENT_FINISHED = 5;
 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 open bugs the doctor's 3-day rule (src/doctor/doctor-backlog-bugs.ts checkStaleBugs,
- * STALE_BUG_DAYS) calls stale: an unrefused, non-waiting open bug whose filing stamp is at
- * least STALE_BUG_DAYS old. This is the always-on feed for the stale-bugs team alert — the
- * doctor's check is the same rule at the same threshold, so the two cannot drift. An entry
- * carrying a Refused note or a Waiting-for-the-next-failure note is skipped (the refused and
- * waiting alerts name those), and so is an undated heading (like the doctor's check). The
- * returned objects carry the 0-based index (for the drawer address `bugs:<index>`), the
- * 1-based position (for `bug --cancel <position>`), the stamp-stripped title, and the whole-
- * day age. Returned oldest-first — most days waited, ties in file order — so a caller naming
- * the first element names the most-stale bug. */
-export function staleOpenBugs(root, now = Date.now()) {
-    return openBugEntries(root)
-        .flatMap((entry, index) => {
-        if (refusalNote(entry.body) !== null || waitingNote(entry.body) !== null)
-            return [];
-        const stamp = filingDate(entry.title);
-        if (stamp === null)
-            return [];
-        const days = ageInDays(stamp, now);
-        return days >= STALE_BUG_DAYS ? [{ index, position: index + 1, title: stripEntryStamp(entry.title), days }] : [];
-    })
-        .sort(byDaysThenIndex);
-}
-/** The open questions the doctor's 7-day rule (src/doctor/doctor-backlog-bugs.ts
- * checkStaleQuestions, STALE_QUESTION_DAYS) calls stale: an open QUESTIONS.md entry whose
- * `(asked by …)` stamp is at least 7 days old. This is the always-on feed for the stale-questions
- * team alert — the shared rule's twin on every observer surface, computed from the same threshold
- * and the same questionFilingDate parser the doctor's check uses, so the two cannot drift on which
- * questions are stale. An undated heading is skipped (like the doctor's check); questions carry no
- * refused or waiting note to filter. The returned objects carry the 1-based position (for
- * `tumwater questions answer <n>`), the 0-based index (kept only as the file-order tiebreak), the
- * stamp-stripped title, and the whole-day age. Returned oldest-first — most days waited, ties in
- * file order — so a caller naming the first element names the most-stale question. */
-export function staleOpenQuestions(root, now = Date.now()) {
-    return openQuestionEntries(root)
-        .flatMap((entry, index) => {
-        const stamp = questionFilingDate(entry.title);
-        if (stamp === null)
-            return [];
-        const days = ageInDays(stamp, now);
-        return days >= STALE_QUESTION_DAYS ? [{ index, position: index + 1, title: stripEntryStamp(entry.title), days }] : [];
-    })
-        .sort(byDaysThenIndex);
-}
-/** The notify pages the doctor's 1-day rule (src/doctor/doctor-notify.ts checkNotify,
- * NOTIFY_CHECK_WINDOW_MS) calls failed — warning events within the last day that isNotifyFailure
- * recognizes (a nonzero exit, a kill, or a failed start). This is the always-on feed for the
- * notify team alert, sharing the doctor's threshold, window and filter, so the alert and the
- * check cannot drift. null when the window holds no failed page. */
-export function notifyFailures(root, now = Date.now()) {
-    const failures = eventsSince(root, NOTIFY_CHECK_WINDOW_MS, now, isNotifyFailure);
-    const latest = failures[failures.length - 1];
-    return latest ? { count: failures.length, latestTs: latest.ts, message: String(latest.message) } : null;
-}
-/** The queued inbox prompts the doctor's stale-prompt rule (src/doctor/doctor-backlog.ts
- * `staleQueuedPromptRows`, STALE_PROMPT_MS) calls stale: a prompt due-but-undelivered for more
- * than a day. This is the always-on feed for the stale-prompts team alert — the doctor's check
- * reads the same shared traversal and threshold, so the two cannot drift. A deferred prompt
- * (its not-before time still in the future) is never stale, and neither is a prompt at or under
- * the threshold (strictly past STALE_PROMPT_MS). Each returned object carries the role, the
- * 1-based position (`prompt --cancel <n> --role <id>`), and the wait in ms. Returned
- * oldest-first (queuedAtMs ascending), so a caller naming the first element names the
- * longest-waiting prompt. */
-export function stalePrompts(root, now = Date.now()) {
-    return staleQueuedPromptRows(root, now).map((p) => ({ role: p.role, position: p.position, waitedMs: now - p.queuedAtMs }));
-}
-/** The queued merges the doctor's stale-merge rule (src/doctor/doctor-backlog.ts
- * `staleQueuedMergeRows`, MERGE_QUEUE_STALE_MS) calls stale: a change that has sat in the
- * merge queue more than 6 h without starting. This is the always-on feed for the stale-merges
- * team alert — the doctor's check reads the same shared traversal and threshold, so the two
- * cannot drift. Each returned object carries the role, the summary, and the wait in ms.
- * Returned oldest-first (queue-file order), so a caller naming the first element names the
- * longest-waiting merge. */
-export function staleMerges(root, now = Date.now()) {
-    return staleQueuedMergeRows(root, now).map((m) => ({ role: m.role, summary: m.summary, waitedMs: m.waitedMs }));
-}
-/** A broken plan-dependency clause, the always-on twin of the doctor's `plan dependencies` row
- * (src/doctor/doctor-backlog-plans.ts checkPlanDependencies): the same rule's problem set,
- * severity order, and exact message, so the alert and the doctor cannot drift. The reader owns
- * the rule — planDependencyAlert passes the doctor's planDependencyProblem through unchanged,
- * like staleOpenBugs and the other stale feeds do their doctor's rules. null when PLANS.md's
- * planned entries have no cycle, dangling ref, unparsed clause, or misworded dependency. */
-export function planDependencyAlert(root) {
-    return planDependencyProblem(root);
-}
-/** The open bugs a Waiting-for-the-next-failure note has held for STALE_WAIT_DAYS (7) or more —
- * the always-on feed for the waiting-bugs team alert, sharing the doctor's threshold, held-bug
- * selection and anchor through staleWaitingBugRows so the alert and `checkWaitingBugs` cannot
- * drift. The returned objects carry the 0-based index (drawer `bugs:<index>`), the 1-based
- * position (`bug --release <position>`), the stamp-stripped title, and the whole-day age.
- * Returned most-days-waited-first — ties in file order — so a caller naming the first element
- * names the longest-held bug. */
-export function staleWaitingBugs(root, now = Date.now()) {
-    return staleWaitingBugRows(root, now);
-}
-/** The merge-queue files `readMergeQueue` skips as checkout-relative paths — the always-on feed
- * for the `skipped-merges` team alert (src/ui/team-alerts.ts), sharing the doctor's one list
- * (doctor-backlog.ts skippedMergeQueueFiles), so the alert and the doctor's `merge-queue files`
- * row cannot drift on the selection or the named paths. */
-export function skippedMergeFiles(root) {
-    return skippedMergeQueueFiles(root);
-}
-/** @see CapacityBottleneck */
-export function capacityContention(root, now = Date.now()) {
-    const out = [];
-    /** Resolve one capacity verdict and push a "capacity bottleneck" row when it warns. Shared
-     * by the three capacity checks (workspace, provider, check slots) so the try/catch that keeps
-     * each one from crying wolf on an unreadable event log lives in one place, and the row's
-     * `name`/`detail` shape cannot drift between them. */
-    const maybeWarn = (name, windowMs, keep, resolve) => {
-        try {
-            const verdict = resolve(eventsSince(root, windowMs, now, keep));
-            if (verdict.warn)
-                out.push({ name, detail: verdict.detail });
-        }
-        catch {
-            // A read error skips this row, so the alert never cries wolf on an unreadable log.
-        }
-    };
-    maybeWarn("workspace slots", SLOT_WAIT_CHECK_WINDOW_MS, (ev) => ev.type === "slot_wait", (waits) => slotWaitContention(waits, readSlotsState(root).slots.length));
-    maybeWarn("provider slots", PROVIDER_WAIT_CHECK_WINDOW_MS, (ev) => ev.type === "provider_wait", (waits) => providerWaitContention(waits, configForStatus(root)));
-    maybeWarn("check slots", CHECK_WAIT_CHECK_WINDOW_MS, (e) => e.type === "check_wait", (waits) => checkWaitContention(waits, configForStatus(root)));
-    return out;
-}
-/** How far back the primary-overwrite alert looks — one day, so a team stuck retrying one
- * dirty primary file is a standing amber banner until the file is committed and the refusals
- * age out. */
-export const PRIMARY_OVERWRITE_WINDOW_MS = 24 * 60 * 60_000;
-/** How far back the dropped-post-review alert looks — one day, the 24 h event-window convention
- * every event-reading alert uses (PRIMARY_OVERWRITE_WINDOW_MS sorts beside it), so a review the
- * drain dropped stays a standing amber notice until a day passes. */
-export const DROPPED_POST_REVIEW_WINDOW_MS = 24 * 60 * 60_000;
-/** How far back the regressed-fixes alert looks — one day, so a recently Fixed test that failed
- * again is a standing amber alert until a day passes (or the failure is filed). The doctor's
- * own `regressed fixes` row keeps its since-the-fix read; this is the alert's daily trigger, the
- * same trailing day the primary-overwrite and notify alerts read. */
-export const REGRESSED_FIX_WINDOW_MS = 24 * 60 * 60_000;
-/** The always-on twin of the doctor's `regressed fixes` row (src/doctor/doctor-backlog-bugs.ts
- * checkRegressedFixes): the same candidate selection (regressedFixCandidates) and the same
- * failureMentions match (matchedRegressedFixes) and sentence (regressedFixesPhrase), read off the
- * trailing REGRESSED_FIX_WINDOW_MS of events (the doctor, whose window is since each fix, still
- * warns on an older recurrence). An unreadable event log yields none. */
-export function regressedFixesAlert(root, now = Date.now()) {
-    const candidates = regressedFixCandidates(root);
-    const rows = matchedRegressedFixes(candidates, eventsSince(root, REGRESSED_FIX_WINDOW_MS, now));
-    const detail = regressedFixesPhrase(rows);
-    return detail === null ? null : { count: rows.length, detail };
-}
-/** The exact substring merge-git.ts's overwrite blocker logs in its `warning` event, so this
- * feed matches the refusal and nothing the merge path does not say (see merge-git.ts
- * `overwriteBlockedReason`). */
-const PRIMARY_OVERWRITE_MARKER = "would overwrite files in the primary checkout";
-/** The merges the primary checkout refused in the trailing day (src/merge/merge-git.ts
- * `primaryCheckoutBlockers`, `overwriteBlockedReason`) — the always-on feed for the
- * `primary-overwrite` team alert (src/ui/team-alerts.ts). It reads only the `warning` event the
- * merge path already writes, so it reaches the status poll without a git read (the doctor's
- * `uncommitted backlog` check's git read is async and never gets there) and cannot drift from
- * the refusals. null when the window holds no such warning. */
-export function primaryOverwriteBlocks(root, now = Date.now()) {
-    const hits = eventsSince(root, PRIMARY_OVERWRITE_WINDOW_MS, now, (e) => e.type === "warning" && typeof e.message === "string" && e.message.includes(PRIMARY_OVERWRITE_MARKER));
-    const latest = hits[hits.length - 1];
-    return latest ? { count: hits.length, latestTs: latest.ts, message: String(latest.message) } : null;
-}
-/** Re-export so the always-on alert's threshold and window stay in their one home
- * (src/review/post-merge-review.ts) while existing imports (test/status-payload.test.ts) keep
- * working. */
-export { POST_MERGE_REJECT_WINDOW_MS };
-/** Re-export so the always-on alert's stale-pin selector stays in its one home
- * (src/doctor/doctor-contention-checks.ts) while tui.tsx keeps importing every alert feed from
- * this one module. */
-export { staleWorkspacePins };
-/** The always-on feed for the `post-merge-churn` team alert (src/ui/team-alerts.ts): a day in
- * which at least `POST_MERGE_REJECT_WARN` already-merged commits were turned back by post-merge
- * review, each rejection written by reviewMergedCommit as a `review_rejected` event with
- * `afterMerge: true`. Post-merge is the costly kind — the commit already reached main, so a
- * rejection is answered only by the reviewer's own fix — and it is the reviewer-fix signal for
- * the `review.afterMerge` tiering. Reads the same
- * events the report's `postMergeRejectionsByRole` fills, so the two cannot disagree; null when
- * the window holds fewer than `POST_MERGE_REJECT_WARN` post-merge rejections, or none. A read
- * error skips the row (the capacityContention precedent). */
-export function postMergeChurnAlert(root, now = Date.now()) {
-    try {
-        const events = eventsSince(root, POST_MERGE_REJECT_WINDOW_MS, now, (e) => e.type === "review_rejected");
-        return postMergeChurn(events);
-    }
-    catch {
-        // A read error skips the row, so the alert never cries wolf on an unreadable log.
-        return null;
-    }
-}
-/** A stale or oversized flake quarantine, the always-on twin of the doctor's `flaky checks` row
- * (src/doctor/doctor-project-checks.ts checkFlakyChecks): the same quarantineWarning the doctor
- * calls over the same loadQuarantine list, so the alert and the doctor cannot drift on when the
- * list is a problem. null when the list is fresh and small (or absent) — the rule fires only
- * over QUARANTINE_WARN_COUNT tests or one first seen more than QUARANTINE_AGE_MS ago. */
-export function quarantineAlert(root, now = Date.now()) {
-    const entries = loadQuarantine(root);
-    const warning = quarantineWarning(entries, now);
-    if (warning === null)
-        return null;
-    const oldest = entries.reduce((a, b) => (b.firstSeen < a.firstSeen ? b : a));
-    return { count: entries.length, oldestTest: oldest.test, oldestFirstSeen: oldest.firstSeen, warning };
-}
-/** Checks that flapped more than once in the doctor's window, the always-on twin of the doctor's
- * `flaky checks` row (src/doctor/doctor-project-checks.ts checkFlakyChecks): the same
- * repeatedFlakeCounts over the same KNOWN_FLAKE_WINDOW_MS event window and the same
- * flappedChecksPhrase the doctor shows, so the alert and the doctor cannot drift on the count or
- * the wording. null when no check flapped twice in the window (or the log is unreadable). */
-export function flappedChecksAlert(root, now = Date.now()) {
-    const events = eventsSince(root, KNOWN_FLAKE_WINDOW_MS, now, (e) => e.type === "warning");
-    const flapped = repeatedFlakeCounts(events);
-    const detail = flappedChecksPhrase(flapped);
-    return detail === null ? null : { count: flapped.length, detail };
-}
-export function qaCoverageAlert(root, now = Date.now()) {
-    const coverage = readQaCoverage(root);
-    if (!qaCoverageStalled(coverage, now))
-        return null;
-    const entries = Object.entries(coverage);
-    let newestFlow = entries[0][0];
-    let newestAt = entries[0][1].lastRunAt;
-    for (const [name, entry] of entries) {
-        if (entry.lastRunAt > newestAt) {
-            newestAt = entry.lastRunAt;
-            newestFlow = name;
-        }
-    }
-    return { newestFlow, newestAt, count: entries.length };
-}
-/** @see PostReviewRisk */
-export function postReviewRiskAlert(root) {
-    const rows = atRiskPostReviews(root);
-    const detail = atRiskPostReviewsPhrase(rows);
-    return detail === null ? null : { count: rows.length, detail };
-}
-/** The exact substring the drain's drop branch logs in its `warning` event (src/merge/
- * merge-post-review.ts at POST_REVIEW_FAILURE_LIMIT), so this feed matches a real drop and not
- * the per-run `the post-merge review of <sha> failed (…)` warning the at-risk alert already
- * covers — status-payload.ts's DROPPED_POST_REVIEW_MARKER is the same string, so the feed and
- * the drain cannot drift on what a drop is. */
-const DROPPED_POST_REVIEW_MARKER = "dropping the post-merge review of";
-/** The always-on feed for the `dropped-post-reviews` team alert (src/ui/team-alerts.ts): reads
- * only the `warning` event the drain's drop branch already writes, so it reaches the status
- * poll without touching the review state and cannot drift from the drop. null when the day
- * holds no such warning. eventsSince degrades an unreadable log, so one bounded event scan
- * needs no try/catch (the primaryOverwriteBlocks precedent). */
-export function droppedPostReviewsAlert(root, now = Date.now()) {
-    const hits = eventsSince(root, DROPPED_POST_REVIEW_WINDOW_MS, now, (e) => e.type === "warning" && typeof e.message === "string" && e.message.includes(DROPPED_POST_REVIEW_MARKER));
-    const latest = hits[hits.length - 1];
-    return latest ? { count: hits.length, latestTs: latest.ts, latestMessage: String(latest.message) } : null;
-}
-/** A main watch tip failing the review gate's five diff rules can sit on main for a day — this
- * is how far back the main-diff-rules alert looks, the same trailing-day convention every
- * event-reading alert uses. */
-export const MAIN_RULE_FAILURE_WINDOW_MS = 24 * 60 * 60_000;
-/** The exact substring main-watch.ts's `watchRules` logs in its warning, so this feed matches a
- * real rule failure and cannot drift from the wording the watch writes. */
-const MAIN_RULE_FAILURE_MARKER = "fails the diff rules";
-/** The always-on feed for the `main-diff-rules` team alert (src/ui/team-alerts.ts): reads only
- * the `warning` event the main watch already writes, so it reaches the status poll without a
- * git read or a rule re-run (the watch paid for the check) and cannot drift from the watch's
- * wording. null when the day holds no such warning. eventsSince degrades an unreadable log, so
- * one bounded event scan needs no try/catch (the primaryOverwriteBlocks precedent). */
-export function mainRuleFailures(root, now = Date.now()) {
-    const hits = eventsSince(root, MAIN_RULE_FAILURE_WINDOW_MS, now, (e) => e.type === "warning" && typeof e.message === "string" && e.message.includes(MAIN_RULE_FAILURE_MARKER));
-    const latest = hits[hits.length - 1];
-    return latest ? { count: hits.length, latestTs: latest.ts, latestMessage: String(latest.message) } : null;
-}
-/** 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 —
- * not in gui/gui-server.ts — because it is shared data collection for observers, not part of
- * serving HTTP: snapshot() supplies the core state, and the per-role phase/metrics fields come
- * from the same status-model helpers the TUI table uses.
- *
- * `now` pins the poll's clock for the time-derived fields (see snapshot's seam of the same
- * name) — spend stamp-check, burn-rate projection, disk badge, and the pause countdown — so a
- * test's expected value cannot race the payload's own Date.now(). */
-export function statusPayload(root, now = Date.now(), scope = null) {
-    const full = snapshot(root, undefined, now);
-    // `--role` scopes the role rows (and the alerts computed from them); budget stays team-wide.
-    const snap = scope ? scopeSnapshotToRoles(full, scope) : full;
-    // One event read feeds both feed shapes below, so `events[i]` and `eventItems[i]` always
-    // describe the same event.
-    const recent = readEvents(root, RECENT_EVENTS);
-    const questions = openQuestions(root);
-    // Why each plan/bug is held (src/backlog/backlog-eligibility.ts): the same hold decision
-    // 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 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.roles.map((s) => {
+/** The per-role rows (status-payload.ts's field-group split): roleRows assembles each role's
+ * fields from `snap.roles` — the same single-home roleRowCells/onErrorStreak/metrics reads the
+ * TUI table (status-render.ts's renderStatus) repeats, so the two dashboards cannot drift apart. */
+function roleRows(snap, root) {
+    return snap.roles.map((s) => {
         // roleRowCells single-homes the per-role tail read + metrics + phase derivation the
         // TUI table (status-render.ts's renderStatus) repeats, so the two dashboards cannot
         // drift apart.
@@ -406,6 +96,11 @@ export function statusPayload(root, now = Date.now(), scope = null) {
             commits: s.commits,
             generated,
             peakCtx,
+            // The preformatted peak-ctx share of the role's declared window (part 3c): shipped
+            // beside `peakCtx` so `status --json` and the GUI carry the label the TUI prints without
+            // re-resolving the window. Present only where a window is declared, so a window-less
+            // role's payload shape is unchanged.
+            ...(s.contextWindow !== undefined ? { peakCtxLabel: contextShareLabel(peakCtx, s.contextWindow) } : {}),
             costUsd: s.totalCostUsd,
             // The role's spend for the local day (the daily budget window): 0 while its stamp
             // is stale or missing — same helper and semantics as the TUI's `today` column.
@@ -435,8 +130,33 @@ export function statusPayload(root, now = Date.now(), scope = null) {
             // 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,
+            // The consecutive cut-off streak (run-apply.ts applyRunOutcome's cutOffStreak, an
+            // observational counter parallel to noChangeStreak): how many completed runs in a row
+            // hit the context ceiling. The GUI's phaseDetailBase re-derives the ` · cut off ×N`
+            // suffix from this number (preferred over noChangeStreak, since a cut-off run is also a
+            // no_change and its prose names the costly cause) without re-parsing the phase text.
+            cutOffStreak: s.cutOffStreak ?? 0,
         };
     });
+}
+/** Which blocked plans fold into a series row (status-payload.ts's field-group split): 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). */
+function planSeriesSlots(plans, holds, working) {
+    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;
+    }
+    return planSeries;
+}
+/** The header row (status-payload.ts's field-group split): the project identity, the running
+ * harness and its build/budget/disk/permit-pool/workspace badges, plus the `run --for`
+ * deadline and its badge. */
+function headerFields(root, snap, now) {
     return {
         // The project's display name (project-name.ts) — the dashboards' title.
         project: projectName(root),
@@ -473,6 +193,14 @@ export function statusPayload(root, now = Date.now(), scope = null) {
         ...(snap.runStopsAt !== undefined ? { runStopsAt: snap.runStopsAt } : {}),
         ...(snap.scheduledStopAt !== undefined ? { scheduledStopAt: snap.scheduledStopAt } : {}),
         runWindowBadge: runWindowBadge(snap.runStopsAt, now),
+    };
+}
+/** Merge-queue and main-check state (status-payload.ts's field-group split): the merge queue
+ * and its labels, the post-merge review queue, main's newest merge-scope check and its badge,
+ * the ci-parity badge/tone, and the raw twins of the no-check/no-brief/brief-truncated/
+ * role-notes/principles alerts for `status --json` scripts. */
+function mergeAndCheckFields(root, snap, now) {
+    return {
         // 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
@@ -506,12 +234,39 @@ export function statusPayload(root, now = Date.now(), scope = null) {
         // state before the dashboard/TUI render it as an alert). Omitted (absent) when a check is
         // declared, the same omit-undefined idiom as ciParity.
         ...(snap.noDeclaredCheck ? { noDeclaredCheck: true } : {}),
+        // The raw machine-readable twin of the amber `no-brief` alert (present only when a brief
+        // candidate exists without a resolvable prompt block, so `tumwater status --json` scripts
+        // can read the same state the alert renders). Omitted (absent) when the brief resolves or
+        // the repo is the bare pre-init state, the same omit-undefined idiom as noDeclaredCheck.
+        ...(snap.noBrief ? { noBrief: true } : {}),
+        // The raw machine-readable twin of the amber `brief-truncated` alert (present only when
+        // the resolved brief block exceeds the read cap, the state the doctor `brief` row's
+        // over-cap warn covers, so `tumwater status --json` scripts can read the same state the
+        // alert renders). Omitted (absent) at or under the cap, the same omit-undefined idiom as
+        // noBrief.
+        ...(snap.briefTruncated ? { briefTruncated: true } : {}),
+        // The raw machine-readable twin of the amber `role-notes-truncated` alert (present only
+        // when at least one role's notes file runs past the read bound — the array of `{ role,
+        // chars }`, the same array collectRoleNotesOverCap returns and the alert names). Omitted
+        // (absent) when every note is within the bound, the same omit-undefined idiom as noBrief.
+        ...(snap.roleNotesOverCap && snap.roleNotesOverCap.length > 0 ? { roleNotesOverCap: snap.roleNotesOverCap } : {}),
+        // The raw machine-readable twin of the amber `principles-truncated` alert (present only
+        // when PRINCIPLES.md is over its prompt cap, so `tumwater status --json` scripts can read
+        // the same state the alert renders). Omitted (absent) when the file is at or under the cap
+        // or missing, the same omit-undefined idiom as noDeclaredCheck.
+        ...(snap.principlesTruncated ? { principlesTruncated: true } : {}),
         ciParityTone: ciParityTone(snap.ciParity),
         // The check's counts fragment, preformatted through badges.ts's mainCountsFragment so
         // the page renders the pass/skip/fail breakdown verbatim and cannot re-derive (and
         // drift from) it — the sidebar's "Main green · …" row reads this field, not the raw
         // counts. Empty when no check has run or the check carries no counts.
         mainCounts: mainCountsFragment(snap.mainCheck?.counts),
+    };
+}
+/** The inbox (status-payload.ts's field-group split): the queued director prompts and the
+ * per-role queues, raw for the queued-prompts UI. */
+function inboxFields(snap) {
+    return {
         inbox: snap.inbox,
         // Previews of the queued director prompts in execution order (truncated server-side —
         // see StatusSnapshot.inboxPrompts); the page lists them in its project status panel.
@@ -536,6 +291,13 @@ export function statusPayload(root, now = Date.now(), scope = null) {
         // row with a cancel link, replacing the bare "r: N queued" count line. Raw data, like
         // inboxFiles.
         roleInboxPrompts: snap.roleInboxPrompts,
+    };
+}
+/** Budget and pause/scheduling state (status-payload.ts's field-group split): the daily
+ * budget, its subscription windows, the fallback chain, operator/per-role pauses, the
+ * cap/maintenance holds, scheduled wakes, quiet hours, and the quiet badge. */
+function budgetAndPauseFields(snap) {
+    return {
         // The raw daily-cost-budget data, unconditionally (capUsd 0 = disabled; spend still
         // reported) — machine-readable for `status --json`; the display-ready header badge is
         // the preformatted `budgetBadge`.
@@ -604,13 +366,25 @@ export function statusPayload(root, now = Date.now(), scope = null) {
         ...(snap.quietHours ? { quietHours: snap.quietHours } : {}),
         inQuietHours: snap.inQuietHours,
         quietBadge: quietBadge(snap.quietHours, snap.inQuietHours),
-        roles,
+    };
+}
+/** The event feed (status-payload.ts's field-group split): recent events as the one-line text
+ * `tumwater logs` prints and as data for the dashboard's activity feed. */
+function feedFields(recent) {
+    return {
         // 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 role, what
         // kind (the event type plus its result or check status, which decide the row's tone), and
         // the message without formatEvent's time/role columns — the page renders those itself.
         eventItems: recent.map(eventFeedItem),
+    };
+}
+/** Project-status backlog (status-payload.ts's field-group split): planned features, open
+ * bugs and questions, their holds and marks, the blocked-plan series, the newest answered
+ * questions, and the newest done plans / fixed bugs. */
+function backlogFields(root, plans, marks, holds, planSeries, questions) {
+    return {
         // Project status (planned features + open bugs + open questions), fresh per poll like
         // events — roles edit these files constantly, so there is no cache to go stale. The page
         // derives the header badge count from this list's length.
@@ -637,8 +411,57 @@ export function statusPayload(root, now = Date.now(), scope = null) {
         // 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 (status-payload.ts's field-group split): team-alerts.ts's
+ * teamAlerts, phrased once for the dashboard's alert banners and the TUI's attention lines. */
+function alertFields(root, snap, questions, roles, now) {
+    return {
         // What needs the operator (team-alerts.ts's teamAlerts): the dashboard's alert banners and
         // the TUI's attention lines, phrased once.
-        alerts: teamAlerts(snap, questions, roles, now, refusedEntries(root), operatorHeldEntries(root), staleOpenBugs(root, now), stalePrompts(root, now), staleMerges(root, now), planDependencyAlert(root), staleWaitingBugs(root, now), skippedMergeFiles(root), stalledEntries(root), quarantineAlert(root, now), strandedPlanEntriesFor(root), duplicatedBacklogHeadings(root), validationGapProblems(root), notifyFailures(root, now), primaryOverwriteBlocks(root, now), capacityContention(root, now), flappedChecksAlert(root, now), regressedFixesAlert(root, now), postMergeChurnAlert(root, now), postReviewRiskAlert(root), droppedPostReviewsAlert(root, now), mainRuleFailures(root, now), staleClaimEntries(root, roles.map((r) => r.role), now), staleOpenQuestions(root, now), fixClaimProblems(root), qaCoverageAlert(root, now), staleWorkspacePins(root, now), liveFinishedEntriesFor(root)),
+        alerts: teamAlerts(snap, questions, roles, now, refusedEntries(root), planDependencyAlert(root), stalledEntries(root), strandedPlanEntriesFor(root), duplicatedBacklogHeadings(root), validationGapProblems(root), capacityContention(root, now), regressedFixesAlert(root, now), staleClaimEntries(root, roles.map((r) => r.role), now), staleOpenQuestions(root, now), fixClaimProblems(root), staleWorkspacePins(root, now), liveFinishedEntriesFor(root), instancePoolProblems(root), providerCapProblems(root)),
+    };
+}
+/** 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 —
+ * not in gui/gui-server.ts — because it is shared data collection for observers, not part of
+ * serving HTTP: snapshot() supplies the core state, and the per-role phase/metrics fields come
+ * from the same status-model helpers the TUI table uses.
+ *
+ * `now` pins the poll's clock for the time-derived fields (see snapshot's seam of the same
+ * name) — spend stamp-check, burn-rate projection, disk badge, and the pause countdown — so a
+ * test's expected value cannot race the payload's own Date.now(). `modelsPath` mirrors
+ * snapshot's seam of the same name, so a test can resolve a role's declared context window
+ * against a fixture models catalog instead of the live ~/.pi one. */
+export function statusPayload(root, now = Date.now(), scope = null, modelsPath = piModelsPath()) {
+    const full = snapshot(root, modelsPath, now);
+    // `--role` scopes the role rows (and the alerts computed from them); budget stays team-wide.
+    const snap = scope ? scopeSnapshotToRoles(full, scope) : full;
+    // One event read feeds both feed shapes below, so `events[i]` and `eventItems[i]` always
+    // describe the same event.
+    const recent = readEvents(root, RECENT_EVENTS);
+    const questions = openQuestions(root);
+    // Why each plan/bug is held (src/backlog/backlog-eligibility.ts): the same hold decision
+    // 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 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 = planSeriesSlots(plans, holds, working);
+    const roles = roleRows(snap, root);
+    return {
+        ...headerFields(root, snap, now),
+        ...mergeAndCheckFields(root, snap, now),
+        ...inboxFields(snap),
+        ...budgetAndPauseFields(snap),
+        roles,
+        ...feedFields(recent),
+        ...backlogFields(root, plans, marks, holds, planSeries, questions),
+        ...alertFields(root, snap, questions, roles, now),
     };
 }