tumwater 0.2.0 → 0.3.0

package/dist/src/events/event-format.js

@@ -1,19 +1,28 @@
-// vocabulary: plain
-import { eventRole, eventTick, eventUsage } from "./event-read.js";
+import { claudeUtilizationPct } from "../agent/claude/claude-account.js";
+import { eventRole, eventRun, eventUsage } from "./event-read.js";
 import { eventTypeLabel } from "./event-labels.js";
 import { roleLabel } from "../roles/role-labels.js";
 import { TUMWATER_SOURCE } from "./events.js";
-import { ORCHESTRATOR_STOPPED, backendKindPhrase, budgetPhrase, firstReason, teamPausePhrase, teamResumePhrase, holdPhrase, plural, rolePausePhrase, roleResumePhrase, rolesPhrase, shortSpanPhrase } from "../text/phrases.js";
+import { orchestratorStopPhrase, backendKindPhrase, budgetPhrase, firstReason, teamPausePhrase, teamResumePhrase, holdPhrase, plural, rolePausePhrase, roleResumePhrase, rolesPhrase, shortSpanPhrase, PAUSE_EXPIRED_SUFFIX } from "../text/phrases.js";
 import { compactTokens, formatGB, shortSha, usd } from "../text/format.js";
 import { padToWidth } from "../text/text-width.js";
-import { squash, textOr, truncate } from "../text/text.js";
-import { formatTimestamp, formatTime } from "../text/datetime.js";
+import { isNonBlankString, joinWithMore, squash, textOr, truncate } from "../text/text.js";
+import { formatClock, formatTimestamp } from "../text/datetime.js";
 import { finiteNumber, isJsonObject, stringList } from "../files/json-object.js";
 import { fallbackTierEntries } from "../budget/budget.js";
+/** The " (most by feature $30.00, plan $10.01)" phrase for `topRoles`; "" if none is usable. */
+function mostByPhrase(value) {
+    const top = Array.isArray(value)
+        ? value.flatMap((r) => isJsonObject(r) && typeof r.role === "string" && Number.isFinite(r.spentUsd)
+            ? [`${r.role} ${usd(r.spentUsd)}`]
+            : [])
+        : [];
+    return top.length > 0 ? ` (most by ${top.join(", ")})` : "";
+}
 /** The `<N> tok · $<spent>` usage fragment every event that records a run's cost shares (run_end,
  * merge_done): the usage numbers arrive via eventUsage (the loose-typing coercion every usage
  * consumer shares), rendered through the shared token/money formats (compactTokens, usd) in one
- * place. Either part is omitted when zero or absent, so skipped ticks and zero-usage merges render
+ * place. Either part is omitted when zero or absent, so skipped runs and zero-usage merges render
  * byte-identical to a pre-feature line — no leading or trailing separator. "·" is the separator
  * the budget badge already uses. Sentence contexts prepend their own " · " via usagePhrase;
  * table-cell contexts (history's usage column) use the bare text. */
@@ -54,19 +63,34 @@ function gigabytes(v) {
 function minutes(ms) {
     return Math.round(Number(finiteNumber(ms, 0)) / 60_000);
 }
+/** ` until HH:MM:SS` for a timestamped pause event (team_paused/role_paused) whose until time is
+ * present, or "" when it is missing or non-numeric — the same corrupt-field rule windowResetPhrase
+ * applies (a torn or hand-edited line must not coerce Number("…") into a fabricated clock). Shared
+ * by the event feed's pauseSuffix and the failure digest's pause lines so the three cannot drift on
+ * the spacing or the clock format. */
+export function untilClockSuffix(until) {
+    const ms = finiteNumber(until, null);
+    return ms === null ? "" : ` until ${formatClock(ms)}`;
+}
+/** ` until HH:MM:SS` and `: reason` for a paused event, each "" when its field is absent or
+ * the wrong type (the corrupt-field rule windowResetPhrase applies). The until half is
+ * untilClockSuffix, so the feed and digest aggregators share it. */
+function pauseSuffix(until, reason) {
+    return `${untilClockSuffix(until)}${isNonBlankString(reason) ? `: ${reason}` : ""}`;
+}
 /** `, resets HH:MM` for a subscription-window event carrying resetsAt, or "" when the field is
  * absent or non-numeric (a torn line, or a window the account did not stamp) — the same
  * corrupt-field rule the other optional-field renderers apply. */
 function windowResetPhrase(e) {
     const at = finiteNumber(e.resetsAt, null);
-    return at === null ? "" : `, resets ${formatTime(new Date(at))}`;
+    return at === null ? "" : `, resets ${formatClock(at)}`;
 }
 /** The parenthesized ` (<window>)` a quiet-hours event names when it carries one, or "" when
  * the field is absent or blank (pollQuietHoursGate may send no window, so a routine hold must
  * not fabricate a pair). Shared by the started and ended lines so the two cannot drift on the
  * window's presence or format. */
 function windowSuffix(e) {
-    return typeof e.window === "string" && e.window.trim() ? ` (${textOr(e.window)})` : "";
+    return isNonBlankString(e.window) ? ` (${textOr(e.window)})` : "";
 }
 /** The backend a hold event names, rendered as " at <provider>" when one is configured
  * (pollTeamHold omits it for pi's default) and "" otherwise, so a multi-provider team can
@@ -80,13 +104,20 @@ function providerAt(e) {
 function providerScope(e) {
     return typeof e.provider === "string" ? "that provider" : "every provider";
 }
+/** A subscription-window event's backend, rendered as the id the event names ("claude", or a
+ * later backend's own id), falling back to "claude" for an event written before the window
+ * events carried a `backend`. A claude-only team's lines read exactly as the older
+ * `claude_window_*` lines did. */
+function backendLabel(e) {
+    return typeof e.backend === "string" && e.backend !== "" ? e.backend : "claude";
+}
 /** The provider/model pair a fallback-ish line names, as "provider/model", defaulting each
  * half when the event omits it (a bare pi run carries neither). Shared by the budget_fallback
  * and model_fallback lines so the pair's shape and defaults cannot drift between them. */
 function providerModelPair(e, providerDefault, modelDefault) {
     return `${textOr(e.provider, providerDefault)}/${textOr(e.model, modelDefault)}`;
 }
-/** An event's outcome string — a tick's `result`, or a merge's or build check's `status`,
+/** An event's outcome string — a run's `result`, or a merge's or build check's `status`,
  * whichever the event carries; undefined when neither does. The activity feeds' tone and
  * filter key (tone.ts's eventKind takes it beside the event type), also shipped as the
  * status payload's per-event `result` field, so the two surfaces cannot disagree on what a
@@ -96,9 +127,9 @@ export function eventResult(e) {
 }
 /** eventResult as a display cell: the outcome text when the event carries one, else "?". A
  * torn or hand-edited event whose result/status is missing or non-string — the loose payload
- * HarnessEvent's index signature hands over unvalidated — reads "?" like eventRole's loop and
- * eventTick's tick, never String(undefined)'s literal "undefined". The display surfaces — the
- * event line, the history row, the tick drill-down — use this; eventResult stays undefined
+ * HarnessEvent's index signature hands over unvalidated — reads "?" like eventRole's role and
+ * eventRun's run, never String(undefined)'s literal "undefined". The display surfaces — the
+ * event line, the history row, the run drill-down — use this; eventResult stays undefined
  * for the tone and filter keys, which must tell "no outcome" apart from a real one. */
 export function outcomeText(e) {
     return eventResult(e) ?? "?";
@@ -117,31 +148,31 @@ export function deferredReasonText(e) {
 /** Human one-liner for an event, shared by `logs`, `run` output, and the TUI activity pane:
  * the local `YYYY-MM-DD HH:MM:SS` stamp (formatTimestamp — the same zero-padded, locale-
  * independent phrasing the history table and transcript run separators print, not
- * toLocaleTimeString's locale-dependent "3:05:12 PM"), the loop padded to a column, then the
+ * toLocaleTimeString's locale-dependent "3:05:12 PM"), the role padded to a column, then the
  * event's message (eventMessage).
  * Presentation only: depends on the event shape (events.ts's HarnessEvent), not on its log
  * I/O — so display surfaces never import formatting from the logging module. */
 export function formatEvent(e) {
     const time = formatTimestamp(e.ts);
     // Padded in terminal display columns (padToWidth), not String#padEnd's UTF-16 code units:
-    // a custom loop name holding a wide character (CJK, emoji) counts one code unit but two
+    // a custom role name holding a wide character (CJK, emoji) counts one code unit but two
     // display columns, so a padEnd cell rendered wider than its column and the message column
-    // sat right of every ASCII row's (the same unit mistake the aligned tables shed). The loop
-    // itself goes through eventRole, so a torn or hand-edited event with no loop shows "?" like
+    // sat right of every ASCII row's (the same unit mistake the aligned tables shed). The role
+    // itself goes through eventRole, so a torn or hand-edited event with no role shows "?" like
     // the usage report and failure digest, never String(undefined)'s literal "undefined".
     const source = eventRole(e);
-    const loop = padToWidth(source === TUMWATER_SOURCE ? "tumwater" : roleLabel(source), 10);
-    return `${time} ${loop} ${eventMessage(e)}`;
+    const roleCell = padToWidth(source === TUMWATER_SOURCE ? "tumwater" : roleLabel(source), 10);
+    return `${time} ${roleCell} ${eventMessage(e)}`;
 }
-/** One event as the dashboard's activity feed consumes it: `result` is a tick's outcome, a
+/** One event as the dashboard's activity feed consumes it: `result` is a run's outcome, a
  * merge's result, or a build check's status — whichever string the event carries. The event
  * layer owns the event shape's projection, so both the status poll (ui/status-payload.ts) and
- * the slice endpoint (gui/gui-endpoints.ts's handleLogs) read the same fields, and a feed row's
- * shape cannot drift between them. */
+ * the slice endpoint (gui/gui-history-endpoints.ts's handleLogs) read the same fields, and a feed
+ * row's shape cannot drift between them. */
 export function eventFeedItem(e) {
     const result = eventResult(e);
-    // eventRole renders a missing/empty loop as "?" like the reports, so a torn or hand-edited
-    // event never shows a literal "undefined" loop chip in the dashboard's activity feed.
+    // eventRole renders a missing/empty role as "?" like the reports, so a torn or hand-edited
+    // event never shows a literal "undefined" role chip in the dashboard's activity feed.
     return { ts: e.ts, source: eventRole(e), type: e.type, ...(result === undefined ? {} : { result }), message: eventMessage(e) };
 }
 /** The feed's `--grep`/Search match rule: case-insensitive substring over the raw event type
@@ -151,39 +182,52 @@ export function eventFeedItem(e) {
 export function eventMatchesGrep(e, patternLower) {
     return `${e.type} ${formatEvent(e)}`.toLowerCase().includes(patternLower);
 }
-/** An event's message alone — formatEvent's line without the time and loop columns. The GUI's
- * activity feed renders the time and loop itself (relative ages, loop chips), so the payload
- * ships this beside the event's type and loop instead of making the page re-parse a line. */
+/** An event's message alone — formatEvent's line without the time and role columns. The GUI's
+ * activity feed renders the time and role itself (relative ages, role chips), so the payload
+ * ships this beside the event's type and role instead of making the page re-parse a line. */
 export function eventMessage(e) {
     switch (e.type) {
         case "run_start":
-            return `run #${eventTick(e)} started${e.model !== undefined ? ` on ${textOr(e.model)}` : ""}`;
+            return `run #${eventRun(e)} started${e.model !== undefined ? ` on ${textOr(e.model)}` : ""}`;
         case "run_end": {
             // The payload that explains the outcome: summary for changed/refused/rejected/
-            // review_error ticks, error (lastError) for error and merge-failed ones. Showing it
+            // review_error runs, error (lastError) for error and merge-failed ones. Showing it
             // for every result that carries one keeps the event feed self-explanatory — a bare
-            // "tick #N refused" would force operators to open the transcript for the reason.
+            // "run #N refused" would force operators to open the transcript for the reason.
             const extra = e.summary ? ` — ${textOr(e.summary)}` : e.error ? ` — ${textOr(e.error)}` : "";
-            // Per-tick usage: where the day's spend went.
-            return `run #${eventTick(e)} ${eventTypeLabel(outcomeText(e))}${extra}${usagePhrase(e)}`;
+            // Per-run usage: where the day's spend went.
+            return `run #${eventRun(e)} ${eventTypeLabel(outcomeText(e))}${extra}${usagePhrase(e)}`;
         }
         case "merged":
             return `merged ${shortSha(e.commit)} to main — ${textOr(e.summary)}`;
         case "merge_queued":
-            // Merge queue 3/5: routine state change (the tick committed and the merge slot is
-            // ahead) — no warning prefix. The merge's own events follow it.
-            return `waiting to merge ${shortSha(e.commit)} — ${textOr(e.summary)}`;
+            // Merge queue 3/5: routine state change (the run committed and the merge slot is
+            // ahead) — no warning prefix. The merge's own events follow it. A retry-bearing event
+            // (a re-queued entry) appends its why-it-is-back suffix; a
+            // fresh enqueue's line stays byte-identical.
+            {
+                const base = `waiting to merge ${shortSha(e.commit)} — ${textOr(e.summary)}`;
+                return `${base}${typeof e.retry === "string" && e.retry ? ` (re-queued after ${textOr(e.retry)})` : ""}`;
+            }
+        case "merge_cancelled":
+            // Routine operation (the user removed a waiting merge), not a warning — like
+            // prompt_cancelled. The merge_cancelled event name carries the payload (commit + summary).
+            return `cancelled the merge of ${shortSha(e.commit)} — ${textOr(e.summary)}`;
+        case "merge_topped":
+            // Routine operation (the user reordered a waiting merge), not a warning — like
+            // prompt_topped. The merge_topped event name carries the payload (commit + summary).
+            return `moved the merge of ${shortSha(e.commit)} to the front — ${textOr(e.summary)}`;
         case "merge_done":
             // The merge slot finished with the change on main; the usage is the merge's own
             // spend (reviewer + conflict resolution), omitted when zero so review-exempt merges
             // render bare — the same phrase run_end carries for its run.
             return `merge of ${shortSha(e.commit)} done${elapsed(e.durationMs)}${usagePhrase(e)}`;
         case "merge_failed":
-            // Routine failure detail: the review events themselves (review_rejected/review_failed)
-            // or the merged/build_check lines carry the reason in the feed.
-            return `merge of ${shortSha(e.commit)} failed (${eventTypeLabel(outcomeText(e))})${elapsed(e.durationMs)}${typeof e.summary === "string" && e.summary.trim() ? ` — ${truncate(e.summary, 80)}` : ""}`;
+            // The event names its reason itself (writeMergeOutcome); the review/check events still
+            // carry the full text. An old event without `reason` renders the bare outcome.
+            return `merge of ${shortSha(e.commit)} failed (${eventTypeLabel(outcomeText(e))}${isNonBlankString(e.reason) ? `: ${truncate(e.reason.trim(), 120)}` : ""})${elapsed(e.durationMs)}${isNonBlankString(e.summary) ? ` — ${truncate(e.summary, 80)}` : ""}`;
         case "question_posted":
-            // Routine operation (a loop asked the user something), not a warning.
+            // Routine operation (a role asked the user something), not a warning.
             // The position is the `<n>` `questions answer` takes, so the notify page is actionable.
             return `question posted: ${textOr(e.question)}${typeof e.position === "number" && Number.isInteger(e.position) && e.position >= 1 ? ` — question ${e.position} in \`tumwater questions\`; answer it with \`tumwater questions answer ${e.position} "<decision>"\`` : ""}`;
         case "entry_refused":
@@ -194,16 +238,21 @@ export function eventMessage(e) {
                 return `entry refused: ${textOr(e.reason)} (${files})`;
             const more = titles.length > 1 ? ` (and ${titles.length - 1} more)` : "";
             return `entry refused: "${truncate(titles[0], 80)}"${more}: ${textOr(e.reason)} (${files})`;
+        case "issue_filed":
+            // The feedback observer's filing (plans/feedback-role.md 2/2) is a visible, auditable
+            // result — routine operation like question_posted, not a warning. The number is the
+            // issue the operator can open; a torn event without it reads "?" never "undefined".
+            return `filed issue #${typeof e.issue === "number" ? e.issue : "?"} ${textOr(e.title)} on znation/tumwater`;
         case "wake":
             return `woke (${textOr(e.reason)})`;
         case "run_deferred":
             // Routine state change (need-based prioritization), like counters_reset — no warning
-            // prefix. One per deferral episode; the tick's own events cover the episode's end.
+            // prefix. One per deferral episode; the run's own events cover the episode's end.
             return `deferred — ${deferredReasonText(e)}`;
         case "orchestrator_start":
             return `tumwater started (pid ${textOr(e.pid)}${e.build ? `, version ${shortSha(e.build)}` : ""})`;
         case "orchestrator_stop":
-            return ORCHESTRATOR_STOPPED;
+            return orchestratorStopPhrase(e.cause);
         case "prompt_enqueued":
             return `message added to the inbox: ${textOr(e.preview)}`;
         case "prompt_cancelled":
@@ -216,17 +265,17 @@ export function eventMessage(e) {
             // Routine operation (the user reordered a queued prompt), not a warning.
             return `inbox message moved to the front: ${textOr(e.preview)}`;
         case "prompt_taken":
-            // Routine: a tick dequeued the operator's request to run it.
-            return `inbox message taken by run #${eventTick(e)}: ${textOr(e.preview)}`;
+            // Routine: a run dequeued the operator's request to run it.
+            return `inbox message taken by run #${eventRun(e)}: ${textOr(e.preview)}`;
         case "counters_reset": {
-            // One role → the event is filed under that loop; several → one harness-level event
+            // One role → the event is filed under that role; several → one harness-level event
             // listing them.
             const roles = rolesPhrase(e.roles, "");
             const scope = roles ? ` for ${roles}` : "";
             return `counters reset${scope} (runs, merges, tokens, cost)`;
         }
         case "run_aborted":
-            // Routine state change (the user stopped one loop's tick), like counters_reset — no
+            // Routine state change (the user stopped one role's run), like counters_reset — no
             // warning prefix. The resulting run_end line carries the user_aborted outcome.
             return `run stopped by you`;
         case "review_start": {
@@ -243,7 +292,7 @@ export function eventMessage(e) {
             const reasons = stringList(e.reasons);
             // Only the first reason renders; when more exist, say so instead of letting the
             // one-liner read as the complete verdict — the full list rides in state.lastReview
-            // into the author's next tick prompt, and this line is the operator's pointer to it.
+            // into the author's next run prompt, and this line is the operator's pointer to it.
             const more = reasons.length > 1
                 ? ` (+${reasons.length - 1} more — the author's next run carries every reason)`
                 : "";
@@ -280,12 +329,12 @@ export function eventMessage(e) {
         case "budget_warning":
             // The early page beside budget_paused: the cap is not reached yet, so say so — the
             // operator still has room to raise it or fix the fallback before the team stops.
-            return `budget warning — ${budgetPhrase(e.spentUsd, e.capUsd)} of the daily cap spent; runs still start`;
+            return `budget warning — ${budgetPhrase(e.spentUsd, e.capUsd)} of the daily cap spent${mostByPhrase(e.topRoles)}; runs still start`;
         case "budget_paused": {
             // Routine state change, like counters_reset — no warning prefix. A configured fallback
             // the gate refused is named here: it is the whole reason the team stopped instead of
             // switching over, and an operator reading the feed must be able to act on it. So is a
-            // free fallback the breaker demoted because its ticks kept failing (BUGS.md 2026-09-20):
+            // free fallback the breaker demoted because its runs kept failing (BUGS.md 2026-09-20):
             // the backend, not the price, is what to fix, and the team retries it on its own.
             // Like role_cap_paused, the line names the lift paths: a raised or removed cap, or the
             // local day rolling over (the demoted branch's cool-down retry is the automatic third).
@@ -294,7 +343,7 @@ export function eventMessage(e) {
                 : e.fallbackDemoted
                     ? ` (over-cap model ${textOr(e.fallbackDemoted)} is not serving — ${textOr(e.failures)} runs failed in a row on it; one trial run retries it after a cool-down)`
                     : "";
-            return `budget paused — ${budgetPhrase(e.spentUsd, e.capUsd)} daily cost reached${refused}; roles start no new runs until maxDailyCostUsd is raised or removed in tumwater.json or the local day rolls over`;
+            return `budget paused — ${budgetPhrase(e.spentUsd, e.capUsd)} daily cost reached${mostByPhrase(e.topRoles)}${refused}; roles start no new runs until maxDailyCostUsd is raised or removed in tumwater.json or the local day rolls over`;
         }
         case "budget_fallback": {
             // The cap is spent but the team keeps working: name the free model it switched to, the
@@ -304,15 +353,15 @@ export function eventMessage(e) {
             // strong-tier borrow at a glance; a tier-free event keeps today's single-pair text.
             const tierEntries = fallbackTierEntries(isJsonObject(e.tiers) ? e.tiers : undefined);
             if (tierEntries.length >= 2)
-                return `over-cap model — ${budgetPhrase(e.spentUsd, e.capUsd)} daily cost reached; roles continue on ${tierEntries.join(", ")} (cost n/a)`;
-            return `over-cap model — ${budgetPhrase(e.spentUsd, e.capUsd)} daily cost reached; roles continue on ${providerModelPair(e, "pi's default provider", "pi's default model")} (cost n/a)`;
+                return `over-cap model — ${budgetPhrase(e.spentUsd, e.capUsd)} daily cost reached${mostByPhrase(e.topRoles)}; roles continue on ${tierEntries.join(", ")} (cost n/a)`;
+            return `over-cap model — ${budgetPhrase(e.spentUsd, e.capUsd)} daily cost reached${mostByPhrase(e.topRoles)}; roles continue on ${providerModelPair(e, "pi's default provider", "pi's default model")} (cost n/a)`;
         }
         case "budget_resumed":
             return `budget resumed (${budgetPhrase(e.spentUsd, e.capUsd)} today)`;
         case "budget_handback": {
-            // Which ticks were handed back: the roles still running on the fallback when the budget
-            // reopened. Their ticks end `aborted` and resume promptly on the primary, so an operator
-            // reading the feed can connect the aborted ticks to this one line.
+            // Which runs were handed back: the roles still running on the fallback when the budget
+            // reopened. Their runs end `aborted` and resume promptly on the primary, so an operator
+            // reading the feed can connect the aborted runs to this one line.
             const roles = rolesPhrase(e.roles, "?");
             if (e.reason === "window")
                 return `claude subscription window reset: handed ${roles} back to claude`;
@@ -329,33 +378,50 @@ export function eventMessage(e) {
         }
         case "team_paused":
             // Routine state change, like counters_reset — no warning prefix.
-            return `${teamPausePhrase()} (director keeps running)`;
+            return `${teamPausePhrase()}${pauseSuffix(e.until, e.reason)} (director keeps running)`;
         case "state_migrated":
             return `state migrated — ${textOr(e.detail)}`;
         case "team_resumed":
-            return teamResumePhrase();
+            return teamResumePhrase() + (e.expired === true ? PAUSE_EXPIRED_SUFFIX : "");
         case "role_paused":
             // Routine state change, like team_paused — no warning prefix.
-            return `${rolePausePhrase(textOr(e.role))} (the rest of the team keeps running)`;
+            return `${rolePausePhrase(textOr(e.role))}${pauseSuffix(e.until, undefined)} (the rest of the team keeps running)`;
         case "role_resumed":
-            return roleResumePhrase(textOr(e.role));
+            return roleResumePhrase(textOr(e.role)) + (e.expired === true ? PAUSE_EXPIRED_SUFFIX : "");
         case "role_streak_paused":
             // Routine-with-explanation, like rate_limit_hold — no warning prefix: the pause IS the
             // harness handling the failure. Names the streak depth and the lift command, so the
-            // operator knows why the loop stopped and what to do about it; names the last error
+            // operator knows why the role stopped and what to do about it; names the last error
             // when one is recorded.
-            return `role ${textOr(e.role)} paused — ${textOr(e.streak)} runs failed in a row${typeof e.lastError === "string" && e.lastError.trim() ? ` — last error: ${squash(e.lastError, 120)}` : ""}; fix the cause and resume it (tumwater resume --role <id>)`;
+            return `role ${textOr(e.role)} paused — ${textOr(e.streak)} runs failed in a row${isNonBlankString(e.lastError) ? ` — last error: ${squash(e.lastError, 120)}` : ""}; fix the cause and resume it (tumwater resume --role <id>)`;
         case "role_cap_warning":
             // The per-role early page beside role_cap_paused: the cap is not reached yet, so say so —
-            // the operator still has room to raise it before the loop stops.
+            // the operator still has room to raise it before the role stops.
             return `role ${textOr(e.role)} at ${budgetPhrase(e.spentUsd, e.capUsd)} of its daily cap — it keeps running; raise or remove the cap in tumwater.json before it pauses`;
         case "role_cap_paused":
             // Routine state change, like budget_paused — no warning prefix: the pause IS the harness
             // holding the role's own spend line. Names the role, its spend vs its cap, and the two
-            // lift paths, so the operator knows why the loop stopped and what to do about it.
+            // lift paths, so the operator knows why the role stopped and what to do about it.
             return `role ${textOr(e.role)} paused — ${budgetPhrase(e.spentUsd, e.capUsd)} of its daily cap spent; it starts no new runs until the cap is raised or removed in tumwater.json or the local day rolls over`;
         case "role_cap_resumed":
             return `role ${textOr(e.role)} resumed — it is under its daily cap again and runs again`;
+        case "main_check": {
+            const failing = Array.isArray(e.failingTests) ? e.failingTests.map(String) : [];
+            const covered = Number(e.covered) > 1 ? ` (${textOr(e.covered)} commits)` : "";
+            const verdict = e.status === "failed" ? "failed" : "passed";
+            const names = failing.length > 0 ? `: ${joinWithMore(failing, 3, "; ")}` : "";
+            return `main ${shortSha(String(e.sha ?? ""))}${covered} full check ${verdict}${names}`;
+        }
+        case "main_culprit": {
+            const by = typeof e.runner === "string" && e.runner !== "" ? ` (merged by ${e.runner})` : "";
+            return `main turned red at ${shortSha(String(e.commit ?? ""))}${by}; last green ${shortSha(String(e.green ?? ""))}`;
+        }
+        case "main_revert":
+            return `reverted ${shortSha(String(e.commit ?? ""))} (merged by ${textOr(e.runner)}) as ${shortSha(String(e.revert ?? ""))}`;
+        case "operator_revert": {
+            const undid = typeof e.runner === "string" && e.runner !== "" ? `, undid ${e.runner}` : "";
+            return `reverted ${shortSha(String(e.commit ?? ""))} (by operator) as ${shortSha(String(e.revert ?? ""))}${undid}`; // vocabulary-ok: the deliberate-revert writer is the operator role
+        }
         case "main_red_hold":
             // The message already names the SHA, script, and consequence; the problem tone comes
             // from PROBLEM_EVENTS.
@@ -363,13 +429,13 @@ export function eventMessage(e) {
         case "maintenance_quota_hold":
             // Routine state change, like role_cap_paused — no warning prefix: the hold IS the harness
             // keeping maintenance merges in proportion to work. Names the window's counts so the
-            // operator can see why the hygiene loops stopped and what would re-open them.
+            // operator can see why the hygiene roles stopped and what would re-open them.
             return `waiting: maintenance allowance used — ${textOr(e.maint)} maintenance merges against an allowance of ${textOr(e.allowance)} in the last 24h (${textOr(e.work)} work); the maintenance roles wait until the window rolls over`;
         case "maintenance_quota_resumed":
             return `maintenance allowance reopened — ${textOr(e.maint)} maintenance merges against an allowance of ${textOr(e.allowance)} in the last 24h; the maintenance roles run again`;
         case "bootstrap_complete":
             // Routine state change, like counters_reset — no warning prefix: the team just finished
-            // its bootstrap and the maintenance loops are admitted.
+            // its bootstrap and the maintenance roles are admitted.
             return `bootstrap complete — ${textOr(e.plansDone)}/${textOr(e.untilPlansDone)} plans done; the maintenance roles now run`;
         case "disk_low":
             // Routine state change, like team_paused — no warning prefix: the hold IS the harness
@@ -411,31 +477,34 @@ export function eventMessage(e) {
                 return `backend recovered (${backendKindPhrase(e.kind)})${providerAt(e)} — roles on ${providerScope(e)} run again`;
             return `provider limit lifted${providerAt(e)} — roles on ${providerScope(e)} run again`;
         }
-        case "claude_window_warning":
+        case "subscription_window_warning": {
             // Routine-with-explanation, like rate_limit_hold — no warning prefix: the account is
             // telling us the window is filling, not failing. It names the window and when it resets.
-            return `claude subscription window ${textOr(e.windowType)} near its limit${windowResetPhrase(e)} — subscription claude model jobs keep running`;
-        case "claude_window_reserved": {
+            const used = finiteNumber(e.utilization, null);
+            const fill = used === null ? "" : ` (at ${claudeUtilizationPct(used)}% used)`;
+            return `${backendLabel(e)} subscription window ${textOr(e.windowType)} near its limit${fill}${windowResetPhrase(e)} — subscription ${backendLabel(e)} model jobs keep running`;
+        }
+        case "subscription_window_reserved": {
             const used = finiteNumber(e.utilization, null);
             const line = finiteNumber(e.reserve, null);
-            const pct = (f) => (f === null ? "?" : `${Math.round(f * 100)}%`);
-            return `claude subscription window ${textOr(e.windowType)} at ${pct(used)}, past its ${pct(line)} reserve${windowResetPhrase(e)} — the team leaves it to you (director keeps running)`;
+            const pct = (f) => (f === null ? "?" : `${claudeUtilizationPct(f)}%`);
+            return `${backendLabel(e)} subscription window ${textOr(e.windowType)} at ${pct(used)}, past its ${pct(line)} reserve${windowResetPhrase(e)} — the team leaves it to you (director keeps running)`;
         }
-        case "claude_window_limited":
+        case "subscription_window_limited":
             // Routine-with-explanation, like rate_limit_hold — no warning prefix: waiting is the
             // harness handling the account's own throttle. Names the window, the reset, and which
-            // seams stop, so the operator knows why claude held and what keeps running.
+            // seams stop, so the operator knows why the backend held and what keeps running.
             // With a fallback the work moves rather than waits: `tiers` names where each moved tier's
             // work went (the budget poll's window move), the director and any tier with no fallback
             // still wait.
             {
                 const moved = fallbackTierEntries(isJsonObject(e.tiers) ? e.tiers : undefined);
                 if (moved.length > 0)
-                    return `claude subscription window ${textOr(e.windowType)} rejected — claude model jobs move to ${moved.join(", ")}${windowResetPhrase(e)} (director keeps waiting)`;
+                    return `${backendLabel(e)} subscription window ${textOr(e.windowType)} rejected — ${backendLabel(e)} model jobs move to ${moved.join(", ")}${windowResetPhrase(e)} (director keeps waiting)`;
             }
-            return `waiting: claude subscription window ${textOr(e.windowType)} rejected — claude model jobs wait${windowResetPhrase(e)} (director keeps running)`;
-        case "claude_window_reset":
-            return `claude subscription window reset — claude model jobs run again`;
+            return `waiting: ${backendLabel(e)} subscription window ${textOr(e.windowType)} rejected — ${backendLabel(e)} model jobs wait${windowResetPhrase(e)} (director keeps running)`;
+        case "subscription_window_reset":
+            return `${backendLabel(e)} subscription window reset — ${backendLabel(e)} model jobs run again`;
         case "max_concurrent_changed": {
             // Routine state change, like counters_reset — no warning prefix.
             return `maxConcurrent changed: ${textOr(e.from)} → ${textOr(e.to)}`;
@@ -469,7 +538,7 @@ export function eventMessage(e) {
             // failure. Names the pair the role now runs on and why the primary was abandoned.
             return `model fallback — ${providerModelPair(e, "pi's default", "pi's default")} engaged (primary failing: ${textOr(e.reason, "backend failure")})`;
         case "model_fallback_ended":
-            // The return counterpart: names the pair ticks resume on and how long the episode ran.
+            // The return counterpart: names the pair runs resume on and how long the episode ran.
             return `model fallback ended — back on ${providerModelPair(e, "pi's default", "pi's default")} after ${minutes(e.durationMs)}m`;
         case "opencode_free_model_billed":
             // The promotion ended (plans/opencode-backend.md §7, part 6c/7): a run billed what the
@@ -480,7 +549,7 @@ export function eventMessage(e) {
         case "image_blind": {
             // Routine-with-explanation like the model-fallback events — no warning prefix: the
             // run was stopped (or a gate run noted) because the model cannot see the image. Names
-            // the file, the model, and whether the tick failed on it or a gate run only logged it.
+            // the file, the model, and whether the run failed on it or a gate run only logged it.
             const action = e.action === "logged"
                 ? " (gate run logged)"
                 : e.action === "fail"
@@ -489,9 +558,9 @@ export function eventMessage(e) {
             return `blind image read: ${textOr(e.path)} on ${textOr(e.model, "the model")}${action}`;
         }
         case "image_reroute":
-            // The tick's work moves to a model that can read the image (plans/image-input.md part
+            // The run's work moves to a model that can read the image (plans/image-input.md part
             // 4/5). Routine-with-explanation — no warning prefix: names the hop the way the
-            // handoff reads, and whether the traits-of-attachment preflight avoided a failed tick.
+            // handoff reads, and whether the traits-of-attachment preflight avoided a failed run.
             return e.preflight === true
                 ? `image attachment routed to ${textOr(e.to, "the target")} (${textOr(e.tier, "a peer tier")}) to read its image — no failed run`
                 : `image rerouted to ${textOr(e.to, "the target")} (${textOr(e.tier, "a peer tier")}) — next run goes there after a blind read on ${textOr(e.from, "the prior model")}`;
@@ -499,7 +568,7 @@ export function eventMessage(e) {
             // Self-hosting teams only (src/redeploy/redeploy.ts): the code main describes is not the
             // code running. Not a warning prefix — a stale build is a state, and auto-restart resolves
             // it.
-            return `update available (${plural(finiteNumber(e.aheadCommits, 0), "commit")} behind) — restarts when idle`;
+            return `update available (${plural(finiteNumber(e.aheadCommits, 0), "commit")} behind) — restarts after cooldown; work continues`;
         case "restart_pending":
             return `restart pending — main ${shortSha(e.head)} is green; finishing current runs (no new runs start)`;
         case "restart": {
@@ -523,17 +592,22 @@ export function eventMessage(e) {
             const how = e.signal ? `was killed by ${textOr(e.signal)}` : `exited ${textOr(e.code)}`;
             return `tumwater is down — restart ${textOr(e.generation)} ${how}${e.reason ? `: ${textOr(e.reason)}` : ""}; start it again with \`tumwater start\``;
         }
-        case "resume":
+        case "resume": {
             // Two causes share the resume machinery; the line names the real one so an operator
-            // reading the feed can tell a restart from a loop fighting the context ceiling, and a
-            // cross-agent handoff from either — the handoff keeps the worktree but starts fresh.
-            return e.cause === "cut-off"
+            // reading the feed can tell a restart from a role fighting the context ceiling, and a
+            // cross-agent handoff from either — the handoff keeps the worktree but starts fresh. A
+            // run that got a salvaged patch back (src/git/slot-salvage.ts) names the patch.
+            const restored = e.restored === undefined ? "" : ` — uncommitted edits restored from ${textOr(e.restored)}`;
+            return ((e.cause === "cut-off"
                 ? "resuming the run cut off at the context ceiling (compacted pi session, same workspace)"
                 : e.cause === "handoff"
                     ? "handing the interrupted run off to a fresh session on another agent (same workspace, uncommitted edits kept)"
                     : e.cause === "image-reroute"
                         ? "handing the blind-read run off to a fresh session on an image-capable model (same workspace, uncommitted edits kept)"
-                        : "resuming the run a shutdown interrupted (same agent session and workspace)";
+                        : e.cause === "salvaged"
+                            ? "handing the work an earlier run left unsaved to a fresh session"
+                            : "resuming the run a shutdown interrupted (same agent session and workspace)") + restored);
+        }
         case "slot_wait": {
             // Routine-with-explanation, like rate_limit_hold — no warning prefix: waiting is the pool
             // working as designed. Names the wait, the pool it waited on, and how many slots are
@@ -545,9 +619,30 @@ export function eventMessage(e) {
             // Routine-with-explanation, like slot_wait: waiting for a provider/team slot is the cap
             // working as designed, so no warning prefix. Names the wait and the key (or the run cap
             // when the seam has none), so the operator can raise maxConcurrentPerProvider with the
-            // numbers in hand.
-            return `waited ${shortSpanPhrase(finiteNumber(e.waitedMs, 0))} for a ${typeof e.key === "string" && e.key.length > 0 ? `${e.key} slot` : "run slot"} (${textOr(e.role)})`;
+            // numbers in hand. An event carrying `cap` names the cap that held the run and its limit
+            // (a team-cap wait names no key); one without `cap` (logged before it existed) renders
+            // the key-or-run-slot line alone.
+            const span = shortSpanPhrase(finiteNumber(e.waitedMs, 0));
+            const limit = finiteNumber(e.limit, Number.NaN);
+            const hasKey = typeof e.key === "string" && e.key.length > 0;
+            if (e.cap === "provider" && hasKey) {
+                return `waited ${span} for a ${e.key} slot (${textOr(e.role)}${Number.isFinite(limit) ? `; maxConcurrentPerProvider.${e.key} is ${limit}` : ""})`;
+            }
+            if (e.cap === "team") {
+                return `waited ${span} for a run slot (${textOr(e.role)}${Number.isFinite(limit) ? `; maxConcurrent is ${limit}` : ""})`;
+            }
+            return `waited ${span} for a ${hasKey ? `${e.key} slot` : "run slot"} (${textOr(e.role)})`;
         }
+        case "check_wait":
+            // Routine-with-explanation, like slot_wait: waiting for a check permit is the cap working
+            // as designed, so no warning prefix. Newer events also name the holders and the cap at park
+            // time; older or malformed ones render the bare line.
+            {
+                const heldBy = stringList(e.heldBy);
+                const limit = finiteNumber(e.limit, null);
+                const behind = heldBy.length > 0 ? `; held by ${heldBy.join(", ")}${limit === null ? "" : ` of maxConcurrentChecks ${limit}`}` : "";
+                return `waited ${shortSpanPhrase(finiteNumber(e.waitedMs, 0))} for a check slot (${textOr(e.role)} ${textOr(e.scope)} check${behind})`;
+            }
         case "claim":
             // Parallel work instances (plans/parallel-work-instances.md "Observability", part 6/7):
             // the assignment/release is the harness working as designed, so no warning prefix.

package/dist/src/events/event-labels.js

@@ -1,4 +1,3 @@
-// vocabulary: plain
 /** Words for the two code families the dashboards show: event types (the activity chips) and run
  * result codes (the result cells). Pure, no I/O, so core modules and the UI may both import it. */
 /** The words for each event type. The `Record` type makes the compiler demand a label for every
@@ -9,10 +8,13 @@ export const EVENT_TYPE_LABELS = {
     run_start: "run started",
     run_end: "run finished",
     merge_queued: "waiting to merge",
+    merge_cancelled: "merge cancelled",
+    merge_topped: "merge moved to front",
     merge_done: "merge finished",
     merge_failed: "merge failed",
     merged: "merged",
     question_posted: "question posted",
+    issue_filed: "issue filed",
     entry_refused: "plan refused",
     wake: "woke up",
     run_deferred: "run deferred",
@@ -49,6 +51,10 @@ export const EVENT_TYPE_LABELS = {
     role_cap_warning: "role budget warning",
     role_cap_paused: "role budget paused",
     role_cap_resumed: "role budget resumed",
+    main_check: "main checked",
+    main_culprit: "main red culprit",
+    main_revert: "main red reverted",
+    operator_revert: "operator revert", // vocabulary-ok: "operator" is the operator-role name this label's plan chose
     main_red_hold: "main's check is failing",
     maintenance_quota_hold: "waiting: maintenance allowance used",
     maintenance_quota_resumed: "maintenance allowance reopened",
@@ -62,12 +68,13 @@ export const EVENT_TYPE_LABELS = {
     permit_reserve: "permits reserved",
     slot_wait: "waited to start",
     provider_wait: "waited for a provider slot",
+    check_wait: "waited for a check slot",
     rate_limit_hold: "waiting: provider limit",
     rate_limit_resumed: "provider limit lifted",
-    claude_window_reserved: "claude usage window reserved",
-    claude_window_warning: "claude usage window warning",
-    claude_window_limited: "waiting: claude usage window",
-    claude_window_reset: "claude usage window reset",
+    subscription_window_reserved: "usage window reserved",
+    subscription_window_warning: "usage window warning",
+    subscription_window_limited: "waiting: usage window",
+    subscription_window_reset: "usage window reset",
     max_concurrent_changed: "concurrency changed",
     provider_concurrency_changed: "provider concurrency changed",
     retention_changed: "retention changed",