tumwater 0.1.2 → 0.2.0

package/dist/src/failure/failure-render.js

@@ -3,6 +3,7 @@ import { shortSha, usd } from "../text/format.js";
 import { dayKey, dayLabel, formatTime, monthDay, reportWindow, sinceWindowLine } from "../text/datetime.js";
 import { durationLabel } from "../cli/cli-args.js";
 import { eventsRotationLabel } from "../events/events.js";
+import { eventTypeLabel } from "../events/event-labels.js";
 import { markdownTable } from "../text/markdown.js";
 /** A cluster's role list shows at most this many names before a "+N more" remainder. */
 const ROLES_SHOWN = 4;
@@ -28,7 +29,7 @@ const RESULT_ORDER = {
 };
 /** The digest table's columns: every TickResult that at least one role logged in the window, ranked
  * by RESULT_ORDER (ties alphabetical), so the table's shape follows the window's evidence instead
- * of the whole fixed vocabulary — a fleet with no errors gets no error column. */
+ * of the whole fixed vocabulary — a team with no errors gets no error column. */
 function columns(outcomes) {
     const present = new Set();
     for (const row of outcomes) {
@@ -37,20 +38,20 @@ function columns(outcomes) {
     }
     return [...present].sort((a, b) => RESULT_ORDER[a] - RESULT_ORDER[b] || a.localeCompare(b));
 }
-/** A delta cell: `prev → cur`, with "—" on a side where the role had no ticks (the "new role"
+/** A delta cell: `prev → cur`, with "—" on a side where the role had no runs (the "new role"
  * case for the preceding window), so an absence is never rendered as an infinite increase.
  * The displayed halves may be raw counts (stringified here) or pre-rendered rate strings —
  * the tick-count halves exist only to decide the "—", not to be printed. */
-function deltaCell(prevTicks, prev, ticks, cur) {
-    return `${prevTicks === 0 ? "—" : prev} → ${ticks === 0 ? "—" : cur}`;
+function deltaCell(prevRuns, prev, runs, cur) {
+    return `${prevRuns === 0 ? "—" : prev} → ${runs === 0 ? "—" : cur}`;
 }
 /** The rejections column's cell. It cannot reuse deltaCell: a rejection is logged by the
- * landing slot, so its authoring tick_end can fall in the other window — a role with a
+ * merge slot, so its authoring run_end can fall in the other window — a role with a
  * rejection must show it even when its tick count is 0. Presence is judged on the rejection
- * count itself (the role is "absent" from the column only with neither ticks nor rejections). */
-function rejectionCell(prevTicks, prevRejections, ticks, rejections) {
-    const prev = prevTicks === 0 && prevRejections === 0 ? "—" : String(prevRejections);
-    const cur = ticks === 0 && rejections === 0 ? "—" : String(rejections);
+ * count itself (the role is "absent" from the column only with neither runs nor rejections). */
+function rejectionCell(prevRuns, prevRejections, runs, rejections) {
+    const prev = prevRuns === 0 && prevRejections === 0 ? "—" : String(prevRejections);
+    const cur = runs === 0 && rejections === 0 ? "—" : String(rejections);
     return `${prev} → ${cur}`;
 }
 /** A ratio as a whole percent — but whole-percent rounding must not erase a real
@@ -62,29 +63,35 @@ function rejectionCell(prevTicks, prevRejections, ticks, rejections) {
 function percent(part, whole) {
     const pct = (100 * part) / whole;
     const rounded = Math.round(pct);
-    if (rounded === 0 && part > 0) {
-        const oneDecimal = pct.toFixed(1);
-        return oneDecimal === "0.0" ? "<0.1%" : `${oneDecimal}%`;
-    }
-    if (rounded === 100 && part < whole) {
-        const oneDecimal = pct.toFixed(1);
-        return oneDecimal === "100.0" ? ">99.9%" : `${oneDecimal}%`;
-    }
+    // A nonzero ratio at the 0/100 edges must not round away to "0%"/"100%": both arms keep
+    // one decimal the same way, so they share one helper — the two calls differ only in the
+    // edge they guard ("0.0"/"<0.1%" vs "100.0"/">99.9%").
+    if (rounded === 0 && part > 0)
+        return edgePercent(pct, "0.0", "<0.1%");
+    if (rounded === 100 && part < whole)
+        return edgePercent(pct, "100.0", ">99.9%");
     return `${rounded}%`;
 }
-/** An error rate as a whole percent, or "—" when the role ran no ticks (an absence is not
+/** A near-edge one-decimal percent: `${n.d}%`, or the `edge` literal when even one decimal
+ * rounds back to the edge (`"0.0"` → "<0.1%", `"100.0"` → ">99.9%"). Shared by percent's two
+ * boundary windows so the formula cannot drift between them. */
+function edgePercent(pct, edgeWhole, edge) {
+    const oneDecimal = pct.toFixed(1);
+    return oneDecimal === edgeWhole ? edge : `${oneDecimal}%`;
+}
+/** An error rate as a whole percent, or "—" when the role ran no runs (an absence is not
  * a 0% rate, for the same reason deltaCell says "—"). */
-function rate(errors, ticks) {
-    if (ticks === 0)
+function rate(errors, runs) {
+    if (runs === 0)
         return "—";
-    return percent(errors, ticks);
+    return percent(errors, runs);
 }
 /** One time-and-spend cell: `x.x h · $y.yy`, or "—" when the role ended no tick on that
  * class — an absence is not a zero cost, for the same reason the Deltas cells say "—".
  * Hours carry one decimal: the digest prices agent-hours, and whole-hour rounding would
  * erase the difference between ten 200-ms errors and one 30-minute timeout. */
 function spendCell(cell) {
-    if (cell.ticks === 0)
+    if (cell.runs === 0)
         return "—";
     return `${hoursPhrase(cell.ms)} · ${usd(cell.costUsd)}`;
 }
@@ -94,19 +101,20 @@ function spendCell(cell) {
 function hoursPhrase(ms) {
     return `${(ms / 3_600_000).toFixed(1)} h`;
 }
-/** Render the digest as bounded Markdown. Byte bound: for a given fleet the tables grow only with
+/** Render the digest as bounded Markdown. Byte bound: for a given team the tables grow only with
  * the number of configured roles (fixed by config), the RESULT_ORDER vocabulary (fixed by
  * src/tick/tick-outcome.ts), and the time-and-spend section's LOSS_TOP loss-cause lines (fixed by
- * the cut), and every free string is capped — cluster examples at 120 chars (plus a `… (+N
+ * the cut), the merge-failure section's MERGE_FAILURE_TOP clusters (src/failure/failure-data.ts),
+ * and every free string is capped — cluster examples at 120 chars (plus a `… (+N
  * chars)` cut marker when truncated, so a marked cut can never read as a complete message —
- * BUGS.md 2026-09-30), landed summaries at 100 under the same rule, a cluster's role list at 4
+ * BUGS.md 2026-09-30), merged summaries at 100 under the same rule, a cluster's role list at 4
  * names plus a remainder count, and any loop id sliced to 32 chars (config validation already
  * refuses longer custom-loop ids, so the slice is a guard rather than the real bound). Cluster
- * counts are capped at top-N, and the Fleet state changes section is capped at STATE_CHANGE_TOP
+ * counts are capped at top-N, and the Team state changes section is capped at STATE_CHANGE_TOP
  * lines with each payload at STATE_CHANGE_MAX and each free field at STATE_CHANGE_FIELD_MAX; the
- * landed list at LANDED_TOP lines, each capped section closing with one remainder line when its cut
+ * merged list at MERGED_TOP lines, each capped section closing with one remainder line when its cut
  * dropped anything. Nothing here grows with how bad the window was: measured 6,017 bytes at the
- * CLI's default 14 days on the live fleet, and the worst-case byte-bound fixture in
+ * CLI's default 14 days on the live team, and the worst-case byte-bound fixture in
  * test/failure-render.test.ts covers transition events too. Pure function of FailureReportData: no
  * I/O, no clock reads. */
 export function renderFailureMarkdown(data) {
@@ -117,8 +125,8 @@ export function renderFailureMarkdown(data) {
     // instant span (the wording renderSinceReportMarkdown uses); the day shape keeps its
     // day-window line. The empty branch follows the same split so neither claims the other's unit.
     lines.push(data.sinceMs !== undefined
-        ? `${sinceWindowLine(durationLabel(data.sinceMs), data.fromIso)} · ${data.ticks} ticks`
-        : `${reportWindow(data.from, data.to, data.days, eventsRotationLabel())} · ${data.ticks} ticks`);
+        ? `${sinceWindowLine(durationLabel(data.sinceMs), data.fromIso)} · ${data.runs} runs`
+        : `${reportWindow(data.from, data.to, data.days, eventsRotationLabel())} · ${data.runs} runs`);
     if (data.role !== undefined)
         lines.push(`role: ${data.role}`);
     if (data.logState === "unreadable")
@@ -132,15 +140,15 @@ export function renderFailureMarkdown(data) {
     }
     else if (data.partial)
         lines.push(`partial: retained log starts ${data.oldestEventDate ?? "?"}`);
-    // The causal frame before the counts: what the fleet DID in the window, so the reader can ask
+    // The causal frame before the counts: what the team DID in the window, so the reader can ask
     // whether the harness's response was right. Omitted entirely when the window held none. When
     // the newest-N cap cut the window's transitions, the remainder is named — a quiet window (no
     // line) and a truncated one must not look the same.
     if (data.stateChanges.length > 0) {
         lines.push("");
         // A scoped digest retitles the section: its transitions are the named role's, so the
-        // fleet-wide "Fleet" claim would overreach.
-        lines.push(data.role !== undefined ? "## State changes" : "## Fleet state changes");
+        // team-wide "Team" claim would overreach.
+        lines.push(data.role !== undefined ? "## State changes" : "## Team state changes");
         for (const s of data.stateChanges) {
             lines.push(`- ${stateChangeStamp(s.ts)} ${roleCell(s.role)} — ${s.description}`);
         }
@@ -152,18 +160,18 @@ export function renderFailureMarkdown(data) {
     lines.push("");
     lines.push("## Outcome by role");
     if (data.outcomes.length === 0) {
-        lines.push("_no tick_end events in the window_");
+        lines.push("_no finished runs in the window_");
     }
     else {
         // markdownTable derives the separator from the header, so the two rows cannot disagree on
         // their cell count (the BUGS.md 2026-09-21 plain-text collapse). `---:` right-aligns the
         // counts.
-        lines.push(...markdownTable(["role", ...cols], data.outcomes.map((row) => [
+        lines.push(...markdownTable(["role", ...cols.map(eventTypeLabel)], data.outcomes.map((row) => [
             roleCell(row.role),
             ...cols.map((c) => String(row.counts[c] ?? 0)),
         ]), ["left", ...cols.map(() => "right")]));
     }
-    // The same ticks priced by what they cost, so a 30-minute timeout outranks ten 200-ms
+    // The same runs priced by what they cost, so a 30-minute timeout outranks ten 200-ms
     // errors that the Outcome table above weighs equally. Two parts: the role × class table of
     // hours and dollars, then the top loss causes by time (an error cluster, a role's
     // no_change total — the quiet loss no cluster names, a review-rejected authoring span, or a
@@ -172,12 +180,12 @@ export function renderFailureMarkdown(data) {
     lines.push("");
     lines.push("## Time and spend by outcome");
     if (data.timeSpend.length === 0) {
-        lines.push("_no tick_end events in the window_");
+        lines.push("_no finished runs in the window_");
     }
     else {
-        lines.push(...markdownTable(["role", "landed", "no_change", "error-class"], data.timeSpend.map((row) => [
+        lines.push(...markdownTable(["role", "merged", "no change", "error or blocked"], data.timeSpend.map((row) => [
             roleCell(row.role),
-            spendCell(row.classes.landed),
+            spendCell(row.classes.merged),
             spendCell(row.classes.no_change),
             spendCell(row.classes.error),
         ])));
@@ -189,13 +197,15 @@ export function renderFailureMarkdown(data) {
         else {
             for (const c of data.lossCauses) {
                 const cause = c.kind === "no_change"
-                    ? `no_change on ${roleCell(c.roles[0] ?? "?")}`
+                    ? `no change on ${roleCell(c.roles[0] ?? "?")}`
                     : c.kind === "review-rejected"
                         ? `review-rejected authoring on ${roleCell(c.roles[0] ?? "?")}${c.example ? ` — ${c.example}` : ""}`
-                        : c.kind === "merge-conflict" || c.kind === "merge-blocked"
-                            ? `${c.kind} authoring on ${roleCell(c.roles[0] ?? "?")}${c.example ? ` — ${c.example}` : ""}`
-                            : `${c.example} (${roleList(c.roles)})`;
-                lines.push(`- ${hoursPhrase(c.ms)} · ${usd(c.costUsd)} — ${plural(c.ticks, "tick")}: ${cause}`);
+                        : c.kind === "refused"
+                            ? `refused on ${roleCell(c.roles[0] ?? "?")}${c.example ? ` — ${c.example}` : ""}`
+                            : c.kind === "merge-conflict" || c.kind === "merge-blocked"
+                                ? `${c.kind} authoring on ${roleCell(c.roles[0] ?? "?")}${c.example ? ` — ${c.example}` : ""}`
+                                : `${c.example} (${roleList(c.roles)})`;
+                lines.push(`- ${hoursPhrase(c.ms)} · ${usd(c.costUsd)} — ${plural(c.runs, "run")}: ${cause}`);
             }
             // Mark the top-5 cut the way the cluster sections mark theirs: a capped ranking that
             // stays silent reads as a complete itemization of the window's loss (BUGS.md 2026-10-01).
@@ -207,49 +217,50 @@ export function renderFailureMarkdown(data) {
     }
     // Prompt-token telemetry: the per-role median prompt
     // send and how much of the prompt budget goes out before a tick's first edit. Omitted
-    // entirely when no tick_end in the window carries the fields, so old logs and their golden
+    // entirely when no run_end in the window carries the fields, so old logs and their golden
     // digests render unchanged.
     if (data.promptStats.length > 0) {
         lines.push("");
         lines.push("## Prompt tokens by role");
         for (const row of data.promptStats) {
             const share = percent(row.preEditShare, 1);
-            lines.push(`- ${roleCell(row.role)}: median ${row.medianPromptTokens} prompt tokens/tick · ${share} before first edit`);
+            lines.push(`- ${roleCell(row.role)}: median ${row.medianPromptTokens} prompt tokens/run · ${share} before first edit`);
         }
     }
     lines.push("");
     lines.push(`## Deltas vs the preceding ${data.sinceMs !== undefined ? durationLabel(data.sinceMs) : dayLabel(data.days)}`);
     if (data.deltas.length === 0) {
-        lines.push("_no ticks in either window_");
+        lines.push("_no runs in either window_");
     }
     else {
-        lines.push(...markdownTable(["role", "ticks", "error rate", "quiet kills", "rejections"], data.deltas.map((d) => [
+        lines.push(...markdownTable(["role", "runs", "error rate", "stalls", "rejections"], data.deltas.map((d) => [
             roleCell(d.role),
-            deltaCell(d.prevTicks, d.prevTicks, d.ticks, d.ticks),
-            deltaCell(d.prevTicks, rate(d.prevErrors, d.prevTicks), d.ticks, rate(d.errors, d.ticks)),
-            deltaCell(d.prevTicks, d.prevQuietKills, d.ticks, d.quietKills),
-            rejectionCell(d.prevTicks, d.prevRejections, d.ticks, d.rejections),
+            deltaCell(d.prevRuns, d.prevRuns, d.runs, d.runs),
+            deltaCell(d.prevRuns, rate(d.prevErrors, d.prevRuns), d.runs, rate(d.errors, d.runs)),
+            deltaCell(d.prevRuns, d.prevQuietKills, d.runs, d.quietKills),
+            rejectionCell(d.prevRuns, d.prevRejections, d.runs, d.rejections),
         ])));
     }
     // The title restates the section's contract: its total now covers the Outcome table's error
     // column AND its main_red cells (the baseline gate's own cause rides the tick, BUGS.md
     // 2026-09-28), so an operator cross-checking counts against the tables above is not misled
     // by a title that reads as the error column alone.
-    renderClusters(lines, "Top error clusters (red-main causes included)", data.errors, "tick errors");
+    renderClusters(lines, "Top error clusters (red-main causes included)", data.errors, "run errors");
     renderClusters(lines, "Top warning clusters", data.warnings, "warnings");
     renderClusters(lines, "Top review failure clusters", data.reviewFailures, "review failures");
     renderClusters(lines, "Top rejection clusters", data.rejections, "rejections");
+    renderClusters(lines, "Merge failures", data.mergeFailures, "merge failures");
     lines.push("");
-    lines.push("## Landed in the window");
-    if (data.landed.length === 0) {
+    lines.push("## Merged in the window");
+    if (data.merged.length === 0) {
         lines.push("_nothing merged in the window_");
     }
     else {
-        for (const c of data.landed)
+        for (const c of data.merged)
             lines.push(`- ${shortSha(c.commit)} — ${c.summary}`);
         // Like the transitions' remainder line: a cut list says so, so a busy window's newest ten
         // are not mistaken for everything that merged.
-        const hidden = data.landedTotal - data.landed.length;
+        const hidden = data.mergedTotal - data.merged.length;
         if (hidden > 0)
             lines.push(`+${hidden} older merges not listed`);
     }
@@ -279,7 +290,7 @@ function renderClusters(lines, title, section, noun) {
         lines.push(`_+${section.hiddenClusters} more ${clusters} holding ${remaining} ${noun1}_`);
     }
 }
-/** The cluster's roles, capped so a fleet-wide cluster cannot blow the byte bound; the count of
+/** The cluster's roles, capped so a team-wide cluster cannot blow the byte bound; the count of
  * the omitted remainder is kept so the cluster's reach stays legible. */
 function roleList(roles) {
     const shown = roles.slice(0, ROLES_SHOWN).map(roleCell).join(", ");

package/dist/src/failure/failure-state-change.js

@@ -1,4 +1,5 @@
-/** Wording half of the failure digest's Fleet state changes section: which transition event types
+// vocabulary: plain
+/** Wording half of the failure digest's Team state changes section: which transition event types
  * the digest replays and the bounded one-liner describing each. Split out of failure-data.ts (the
  * same seam build/build-check-events.ts split from build/build-check.ts) so the per-event-type
  * wording — which changes whenever the harness grows a new self-decision — stays apart from the
@@ -8,11 +9,11 @@
 import { truncateExample } from "./failure-cluster.js";
 import { cutSplitsSurrogatePair } from "../text/text.js";
 import { finiteNumber, stringList } from "../files/json-object.js";
-import { ORCHESTRATOR_STOPPED, backendKindPhrase, budgetPhrase, fleetPausePhrase, fleetResumePhrase, holdPhrase, plural, rolePausePhrase, roleResumePhrase, rolesPhrase, shortSpanPhrase } from "../text/phrases.js";
+import { ORCHESTRATOR_STOPPED, backendKindPhrase, budgetPhrase, teamPausePhrase, teamResumePhrase, holdPhrase, plural, rolePausePhrase, roleResumePhrase, rolesPhrase, shortSpanPhrase } from "../text/phrases.js";
 import { shortSha } from "../text/format.js";
 import { deferredReasonText } from "../events/event-format.js";
 /** The transition events the digest replays: the decisions the harness made about itself (the
- * cap/fleet gates and the fleet hold, the error-streak breaker's pause, the role's own daily
+ * cap/team gates and the team hold, the error-streak breaker's pause, the role's own daily
  * cap, model fallbacks, live-config edits, self-hosted redeploys, need-based deferrals,
  * orchestrator lifecycle). They are the evidence the telemetry role's load-bearing
  * rule asks it to judge — whether the harness's RESPONSE to a failure was wrong
@@ -21,8 +22,8 @@ export const STATE_CHANGE_TYPES = new Set([
     "budget_paused",
     "budget_fallback",
     "budget_resumed",
-    "fleet_paused",
-    "fleet_resumed",
+    "team_paused",
+    "team_resumed",
     "role_paused",
     "role_resumed",
     "role_streak_paused",
@@ -40,12 +41,12 @@ export const STATE_CHANGE_TYPES = new Set([
     "restart",
     "restart_refused",
     "restart_blocked",
-    "tick_deferred",
+    "run_deferred",
     "orchestrator_start",
     "orchestrator_stop",
     "supervisor_exit",
 ]);
-/** The Fleet state changes section's caps: newest N transitions, each line's payload capped at
+/** The Team state changes section's caps: newest N transitions, each line's payload capped at
  * STATE_CHANGE_MAX (a marked word-boundary cut per truncateExample), each free field within it
  * at STATE_CHANGE_FIELD_MAX. Together with the fixed timestamp/role cells these make the
  * section's bytes a constant-plus-marker, so the digest's ~6 KB bound holds no matter how many
@@ -65,7 +66,13 @@ function field(v) {
         cut -= 1; // Never emit a lone high surrogate.
     return s.slice(0, cut);
 }
-/** A compact, bounded one-liner for one harness decision event, for the Fleet state changes
+/** The backend a fallback-ish decision line names, as "provider/model", defaulting each half
+ * to pi's own default when the event omits it and slicing both through field. Shared by the
+ * budget_fallback and model_fallback lines so the default and its slice rule stay in one place. */
+function providerModel(ev) {
+    return `${field(ev.provider ?? "pi default")}/${field(ev.model ?? "pi default")}`;
+}
+/** A compact, bounded one-liner for one harness decision event, for the Team state changes
  * section. Every free string is sliced (field) and the whole line is capped again at
  * STATE_CHANGE_MAX so the digest's byte bound holds for any event shape — the cap cut falls on
  * a word boundary and carries truncateExample's `… (+N chars)` marker, so a cut line can never
@@ -78,7 +85,7 @@ export function describeStateChange(ev) {
             // A breaker demotion (BUGS.md 2026-09-20) leads with its cause instead of the spend: the
             // spend line is the budget_fallback just before it, and the line cap would cut the pair.
             if (ev.fallbackDemoted) {
-                text = `budget paused — ${field(ev.failures ?? "?")} ticks failed on fallback ${field(ev.fallbackDemoted)}`;
+                text = `budget paused — ${field(ev.failures ?? "?")} runs failed on over-cap model ${field(ev.fallbackDemoted)}`;
                 break;
             }
             const refused = ev.fallbackRejected
@@ -88,16 +95,16 @@ export function describeStateChange(ev) {
             break;
         }
         case "budget_fallback":
-            text = `budget fallback — ${budgetPhrase(ev.spentUsd, ev.capUsd)} daily cost reached; on ${field(ev.provider ?? "pi default")}/${field(ev.model ?? "pi default")} (cost n/a)`;
+            text = `over-cap model — ${budgetPhrase(ev.spentUsd, ev.capUsd)} daily cost reached; roles continue on ${providerModel(ev)} (cost n/a)`;
             break;
         case "budget_resumed":
             text = `budget resumed (${budgetPhrase(ev.spentUsd, ev.capUsd)} today)`;
             break;
-        case "fleet_paused":
-            text = fleetPausePhrase();
+        case "team_paused":
+            text = teamPausePhrase();
             break;
-        case "fleet_resumed":
-            text = fleetResumePhrase();
+        case "team_resumed":
+            text = teamResumePhrase();
             break;
         case "role_paused":
             text = rolePausePhrase(field(ev.role ?? "?"));
@@ -108,10 +115,10 @@ export function describeStateChange(ev) {
         case "role_streak_paused":
             // The error-streak breaker auto-paused the role; the digest names the depth so the
             // operator can connect the pause to the failing ticks the clusters above show.
-            text = `role ${field(ev.role ?? "?")} paused — ${field(ev.streak ?? "?")} ticks failed in a row`;
+            text = `role ${field(ev.role ?? "?")} paused — ${field(ev.streak ?? "?")} runs failed in a row`;
             break;
         case "role_cap_paused":
-            // The role reached its own daily spend cap and stopped starting ticks.
+            // The role reached its own daily spend cap and stopped starting runs.
             text = `role ${field(ev.role ?? "?")} paused — ${budgetPhrase(ev.spentUsd, ev.capUsd)} of its daily cap spent`;
             break;
         case "role_cap_resumed":
@@ -119,12 +126,12 @@ export function describeStateChange(ev) {
             break;
         case "model_fallback_started":
             // The role tripped off its primary onto its fallback after provider-class failures.
-            text = `model fallback — ${field(ev.provider ?? "pi default")}/${field(ev.model ?? "pi default")} engaged (${field(ev.reason ?? "backend failure")})`;
+            text = `model fallback — ${providerModel(ev)} engaged (${field(ev.reason ?? "backend failure")})`;
             break;
         case "model_fallback_ended":
             // The return counterpart: names the primary the role resumed on and how long the
             // off-model episode ran.
-            text = `model fallback ended — back on ${field(ev.provider ?? "pi default")}/${field(ev.model ?? "pi default")} after ${shortSpanPhrase(finiteNumber(ev.durationMs, 0))}`;
+            text = `model fallback ended — back on ${providerModel(ev)} after ${shortSpanPhrase(finiteNumber(ev.durationMs, 0))}`;
             break;
         case "rate_limit_hold": {
             // Same split as the event feed's rendering (event-format.ts): a rate-limit hold keeps
@@ -142,8 +149,8 @@ export function describeStateChange(ev) {
             // carries the ended hold's kind, so a backend hold's lift names itself.
             text =
                 ev.kind && ev.kind !== "rate-limit"
-                    ? `backend hold lifted (${backendKindPhrase(ev.kind)}) — role loops tick again`
-                    : "429 hold lifted — role loops tick again";
+                    ? `backend hold lifted (${backendKindPhrase(ev.kind)}) — roles run again`
+                    : "429 hold lifted — roles run again";
             break;
         case "max_concurrent_changed":
             text = `maxConcurrent ${field(ev.from)} → ${field(ev.to)}`;
@@ -171,13 +178,13 @@ export function describeStateChange(ev) {
             break;
         }
         case "build_stale":
-            text = `build ${shortSha(ev.build)} stale — main ${shortSha(ev.head)} ${plural(finiteNumber(ev.aheadCommits, 0), "commit")} ahead`;
+            text = `update available (${plural(finiteNumber(ev.aheadCommits, 0), "commit")} behind) — restarts when idle`;
             break;
         case "restart_pending":
-            text = `restart pending — main ${shortSha(ev.head)} green; compiling`;
+            text = `restart pending — main ${shortSha(ev.head)} green`;
             break;
         case "restart":
-            text = `restarting onto build ${shortSha(ev.to)}`;
+            text = `restarting onto update ${shortSha(ev.to)}`;
             break;
         case "restart_refused":
             text = `restart onto ${shortSha(ev.to)} refused: ${field(ev.reason)}`;
@@ -185,17 +192,17 @@ export function describeStateChange(ev) {
         case "restart_blocked":
             text = `restart blocked — ${field(ev.reason)}; staying on build ${shortSha(ev.from)}`;
             break;
-        case "tick_deferred":
+        case "run_deferred":
             text = `deferred — ${deferredReasonText(ev)}`;
             break;
         case "orchestrator_start":
-            text = `orchestrator started (pid ${field(ev.pid)}${ev.build ? `, build ${shortSha(ev.build)}` : ""})`;
+            text = `tumwater started (pid ${field(ev.pid)}${ev.build ? `, build ${shortSha(ev.build)}` : ""})`;
             break;
         case "orchestrator_stop":
             text = ORCHESTRATOR_STOPPED;
             break;
         case "supervisor_exit":
-            text = `fleet down — generation ${field(ev.generation)} ${ev.signal ? `killed by ${field(ev.signal)}` : `exited ${field(ev.code)}`}${ev.reason ? `: ${field(ev.reason)}` : ""}`;
+            text = `tumwater down — restart ${field(ev.generation)} ${ev.signal ? `killed by ${field(ev.signal)}` : `exited ${field(ev.code)}`}${ev.reason ? `: ${field(ev.reason)}` : ""}`;
             break;
         default:
             text = ev.type;