tumwater 0.4.2 → 0.4.4

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

@@ -1,4 +1,3 @@
-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";
@@ -50,6 +49,14 @@ function elapsed(ms) {
         return "";
     return ` (in ${shortSpanPhrase(n)})`;
 }
+/** The `waited <duration>` head of the three wait-family events (slot_wait, provider_wait,
+ * check_wait) — each rendered its own `waited ${shortSpanPhrase(finiteNumber(e.waitedMs, 0))}`
+ * inline, so the corrupt-field rule and the s/m bucketing cannot drift between them. Each
+ * caller keeps its own `to start`/`for a run slot`/`for a check slot` tail and its own
+ * parenthetical after it. */
+function waitedSpan(waitedMs) {
+    return `waited ${shortSpanPhrase(finiteNumber(waitedMs, 0))}`;
+}
 /** A disk event's GB field as "12.3 GB" text. A torn or hand-edited event whose value is
  * missing or non-numeric reads as "0.0 GB", never "NaN" — the same corrupt-field rule
  * budgetPhrase applies to spentUsd/capUsd, since HarnessEvent's index signature hands every
@@ -111,9 +118,16 @@ function providerScope(e) {
 export function backendLabel(e) {
     return typeof e.backend === "string" && e.backend !== "" ? e.backend : "claude";
 }
+/** A subscription-window event's window, as "<backend> subscription window <type>" — the head
+ * every `subscription_window_*` line names (windowType is a torn/older event's only nullable
+ * half, so `reset` and the shaped lines differ only in what follows this prefix). One home so
+ * the four lines cannot drift on the backend's label or the window-type word. */
+function subscriptionWindowPhrase(e) {
+    return `${backendLabel(e)} subscription window ${textOr(e.windowType)}`;
+}
 /** 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. */
+ * line so the pair's shape and defaults cannot drift. */
 function providerModelPair(e, providerDefault, modelDefault) {
     return `${textOr(e.provider, providerDefault)}/${textOr(e.model, modelDefault)}`;
 }
@@ -177,7 +191,7 @@ export function eventFeedItem(e) {
 }
 /** The feed's `--grep`/Search match rule: case-insensitive substring over the raw event type
  * prefixed to the rendered line — exactly the haystack the operator would otherwise read. One
- * home shared by the CLI's `tumwater logs --grep` (cli/log-commands.ts) and the dashboard's
+ * home shared by the CLI's `tumwater logs --grep` (cli/cli-log-commands.ts) and the dashboard's
  * /api/logs search, so the two surfaces cannot disagree about what a pattern matches. */
 export function eventMatchesGrep(e, patternLower) {
     return `${e.type} ${formatEvent(e)}`.toLowerCase().includes(patternLower);
@@ -213,9 +227,11 @@ function runEventMessage(e) {
                 ? "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 === "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);
+                    : e.cause === "image-reroute"
+                        ? "handing the blind-read run off to a fresh session on an image-capable model (same workspace, uncommitted edits kept)"
+                        : 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 "wake":
             return `woke (${textOr(e.reason)})`;
@@ -304,22 +320,19 @@ function mergeEventMessage(e) {
         default: return textOr(e.type);
     }
 }
-/** " after merge" when the review is a post-merge review (review.afterMerge), else "". */
+/** " after merge" when the review is a post-merge review, else "". */
 function afterMergeSuffix(e) {
     return e.afterMerge === true ? " after merge" : "";
 }
 function reviewEventMessage(e) {
     switch (e.type) {
         case "review_start": {
-            // A resumed review continues a timed-out reviewer's session (PLANS.md, review-retry part
-            // 3/3). The verb names that, because a bare "reviewing" line reads as a from-scratch run;
-            // the revision and model suffixes are unchanged and independent of the flag.
-            // afterMerge is the tier flag reviewMergedCommit writes for a review.afterMerge role; the
+            // afterMerge is the tier flag reviewMergedCommit writes for a post-merge review; the
             // lineage pins review_start/review_verdict/review_rejected to the same discriminator.
             const tier = e.afterMerge === true ? " after merge" : " before merge";
             const revision = e.revision !== undefined ? ` (revision ${textOr(e.revision)})` : "";
             const model = e.model !== undefined ? ` on ${textOr(e.model)}` : "";
-            return `${e.resumed ? "review resumed" : "reviewing"} ${shortSha(e.head)}${revision}${tier}${model}`;
+            return `reviewing ${shortSha(e.head)}${revision}${tier}${model}`;
         }
         case "review_verdict":
             return `review approved ${shortSha(e.head)}${afterMergeSuffix(e)}${e.reason ? ` — ${textOr(e.reason)}` : ""}${elapsed(e.durationMs)}`;
@@ -430,13 +443,6 @@ function budgetEventMessage(e) {
             });
             return `fallback: ${parts.join("; ")}`;
         }
-        case "model_fallback_started":
-            // Routine-with-explanation, like rate_limit_hold: the switch IS the harness handling the
-            // 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 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
             // catalog called free, so the team now prices that model as paid from here on. No warning
@@ -531,19 +537,6 @@ function resourceEventMessage(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 "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.
-            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 ? "?" : `${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 "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
@@ -554,9 +547,9 @@ function resourceEventMessage(e) {
             {
                 const moved = fallbackTierEntries(isJsonObject(e.tiers) ? e.tiers : undefined);
                 if (moved.length > 0)
-                    return `${backendLabel(e)} subscription window ${textOr(e.windowType)} rejected — ${backendLabel(e)} model jobs move to ${moved.join(", ")}${windowResetPhrase(e)} (director keeps waiting)`;
+                    return `${subscriptionWindowPhrase(e)} rejected — ${backendLabel(e)} model jobs move to ${moved.join(", ")}${windowResetPhrase(e)} (director keeps waiting)`;
             }
-            return `waiting: ${backendLabel(e)} subscription window ${textOr(e.windowType)} rejected — ${backendLabel(e)} model jobs wait${windowResetPhrase(e)} (director keeps running)`;
+            return `waiting: ${subscriptionWindowPhrase(e)} 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`;
         default: return textOr(e.type);
@@ -568,10 +561,6 @@ function configEventMessage(e) {
             // Routine state change, like counters_reset — no warning prefix.
             return `maxConcurrent changed: ${textOr(e.from)} → ${textOr(e.to)}`;
         }
-        case "provider_concurrency_changed": {
-            // Routine state change, its maxConcurrent sibling's per-provider form — no warning prefix.
-            return `concurrency for ${textOr(e.provider)} changed: ${textOr(e.from)} → ${textOr(e.to)}`;
-        }
         case "retention_changed": {
             // Routine state change, like its maxConcurrent sibling — no warning prefix.
             return `sessionRetentionDays changed: ${textOr(e.from)} → ${textOr(e.to)}`;
@@ -604,9 +593,9 @@ function configEventMessage(e) {
 function imageRestartEventMessage(e) {
     switch (e.type) {
         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 run failed on it or a gate run only logged it.
+            // Routine-with-explanation — 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 run failed on it or a gate run only logged it.
             const action = e.action === "logged"
                 ? " (gate run logged)"
                 : e.action === "fail"
@@ -614,6 +603,13 @@ function imageRestartEventMessage(e) {
                     : "";
             return `blind image read: ${textOr(e.path)} on ${textOr(e.model, "the model")}${action}`;
         }
+        case "image_reroute":
+            // 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 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")}`;
         case "build_stale":
             // 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
@@ -666,25 +662,13 @@ function checkWaitEventMessage(e) {
             // working as designed. Names the wait, the pool it waited on, and how many slots are
             // pinned, so the operator can raise worktreeSlots with the numbers in hand.
             const purpose = e.purpose === "verify" ? "check" : "run";
-            return `waited ${shortSpanPhrase(finiteNumber(e.waitedMs, 0))} to start (${textOr(e.role)} ${purpose}; ${textOr(e.slots)} workspaces, ${textOr(e.pinned)} pinned)`;
+            return `${waitedSpan(e.waitedMs)} to start (${textOr(e.role)} ${purpose}; ${textOr(e.slots)} workspaces, ${textOr(e.pinned)} pinned)`;
         }
         case "provider_wait": {
-            // 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. 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)})`;
+            // Routine-with-explanation, like slot_wait: waiting for the team slot is the cap
+            // working as designed, so no warning prefix. Names the wait, so the operator can size
+            // maxConcurrent with the number in hand.
+            return `${waitedSpan(e.waitedMs)} for a run slot (${textOr(e.role)})`;
         }
         case "check_wait":
             // Routine-with-explanation, like slot_wait: waiting for a check permit is the cap working
@@ -694,7 +678,7 @@ function checkWaitEventMessage(e) {
                 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})`;
+                return `${waitedSpan(e.waitedMs)} for a check slot (${textOr(e.role)} ${textOr(e.scope)} check${behind})`;
             }
         default: return textOr(e.type);
     }
@@ -754,8 +738,6 @@ export function eventMessage(e) {
         case "budget_resumed":
         case "budget_handback":
         case "fallback_switched":
-        case "model_fallback_started":
-        case "model_fallback_ended":
         case "opencode_free_model_billed": return budgetEventMessage(e);
         case "team_paused":
         case "team_resumed":
@@ -775,12 +757,9 @@ export function eventMessage(e) {
         case "quiet_hours_ended":
         case "rate_limit_hold":
         case "rate_limit_resumed":
-        case "subscription_window_warning":
-        case "subscription_window_reserved":
         case "subscription_window_limited":
         case "subscription_window_reset": return resourceEventMessage(e);
         case "max_concurrent_changed":
-        case "provider_concurrency_changed":
         case "retention_changed":
         case "config_changed":
         case "model_changed":
@@ -789,6 +768,7 @@ export function eventMessage(e) {
         case "orchestrator_start":
         case "orchestrator_stop": return configEventMessage(e);
         case "image_blind":
+        case "image_reroute":
         case "build_stale":
         case "restart_pending":
         case "restart":

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

@@ -70,20 +70,16 @@ export const EVENT_TYPE_LABELS = {
     check_wait: "waited for a check slot",
     rate_limit_hold: "waiting: provider limit",
     rate_limit_resumed: "provider limit lifted",
-    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",
     config_changed: "settings changed",
     model_changed: "model changed",
     backend_binary: "backend checked",
-    model_fallback_started: "fallback model started",
-    model_fallback_ended: "fallback model ended",
     opencode_free_model_billed: "free model billed",
     image_blind: "image not seen",
+    image_reroute: "image sent to another model",
     build_stale: "update available",
     restart_pending: "update waits for idle",
     restart: "restarted onto update",

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

@@ -25,8 +25,6 @@ const LEGACY_EVENT_TYPES = {
     land_failed: "merge_failed", // vocabulary-ok: legacy event name read from old logs
     // retired-name-ok:end
     // retired-name-ok:start old subscription-window event names
-    claude_window_reserved: "subscription_window_reserved", // vocabulary-ok: legacy event name read from old logs
-    claude_window_warning: "subscription_window_warning", // vocabulary-ok: legacy event name read from old logs
     claude_window_limited: "subscription_window_limited", // vocabulary-ok: legacy event name read from old logs
     claude_window_reset: "subscription_window_reset", // vocabulary-ok: legacy event name read from old logs
     // retired-name-ok:end
@@ -34,7 +32,7 @@ const LEGACY_EVENT_TYPES = {
 /** The ordered field rewrites; later parts of the series append here, and they run in order. */
 const LEGACY_EVENT_REWRITES = [
     {
-        // The run number rode `tick` on run_start, run_end, prompt_taken, image_blind.
+        // The run number rode `tick` on run_start, run_end, prompt_taken, image_blind, image_reroute.
         name: "tick-to-run", // retired-name-ok: legacy name
         apply(ev) {
             const e = ev;
@@ -110,8 +108,8 @@ const LEGACY_EVENT_REWRITES = [
         },
     },
     {
-        // A retired role id on an old line reads as the role's current id. The table is empty
-        // until a switch part adds a row, so this changes nothing yet.
+        // A retired role id on an old line reads as the role's current id. The table grows a row
+        // per retired role as future switch parts rename; a row already present applies here.
         name: "legacy-role-ids",
         apply(ev) {
             const e = ev;

package/dist/src/events/{notify.js → event-notify.js}

@@ -10,12 +10,12 @@ import { childEnv } from "../process/process.js";
  *
  * Scope, stated plainly: the notifier subscribes via subscribeEvents (src/events/events.ts), which
  * only sees events THIS process logs. Every allowlisted type but `supervisor_exit` is logged by
- * the orchestrator's own process (budget-gates.ts, gate-polls.ts → streak-gate.ts,
- * role-cap-gates.ts and disk-gate.ts, src/baseline/main-red.ts, src/team/team-polls.ts,
+ * the orchestrator's own process (budget-gates.ts, gate-polls.ts → streak-gates.ts,
+ * role-cap-gates.ts and disk-gates.ts, src/baseline/main-red.ts, src/team/team-polls.ts,
  * merge-slot.ts, merge-questions.ts,
  * src/redeploy/redeployer.ts). `supervisor_exit` is logged by the supervisor after the
- * orchestrator is gone, so src/cli/cli-start.ts pages it directly with notifyTeamDown; events
- * appended by
+ * orchestrator is gone, so src/cli/cli-start-supervisor.ts pages it directly with notifyTeamDown;
+ * events appended by
  * operator CLI commands go straight to the file and are out of scope by design.
  *
  * One knob, an opinionated fixed allowlist, no per-event selection — a command that can post
@@ -45,7 +45,7 @@ export const NOTIFY_EVENT_TYPES = [
 export const NOTIFY_MIN_GAP_MS = 60_000;
 /** The child environment the notify hook runs with: the three TUMWATER_EVENT_* variables over
  * the harness's own environment. One home for the variable names, shared by the notifier's
- * spawn and the `tumwater notify --test` diagnostic (src/cli/notify-command.ts), so the two
+ * spawn and the `tumwater notify --test` diagnostic (src/cli/cli-notify-command.ts), so the two
  * cannot drift on what a hook sees. */
 export function notifyCommandEnv(type, source, message) {
     return childEnv({
@@ -76,7 +76,7 @@ export function notifyExitWarning(type, code, signal) {
  * not found", 126 its "found but not executable" — most often the configured `notify` command
  * is a typo or an uninstalled/non-executable binary, so a bare "code 127" hides the fix the
  * gloss names. Shared by the notifier's warning (notifyExitWarning above) and `tumwater
- * notify --test`'s diagnostic (src/cli/notify-command.ts) so both surfaces name the same fix
+ * notify --test`'s diagnostic (src/cli/cli-notify-command.ts) so both surfaces name the same fix
  * for a hook that cannot launch. Any other code gets no gloss. */
 export function notifyExitGloss(code) {
     return code === 127 ? " (command not found)" : code === 126 ? " (found but not executable)" : "";

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

@@ -87,7 +87,7 @@ function runStartEvents(events) {
 }
 /** The run_start pairing's start epoch ms: `${role}#${run}` → start epoch ms, the projection
  * of runStartEvents onto each event's `ts` — shared by `tumwater history`'s row spans
- * (history-data.ts), the failure digest's time-and-spend fold (time-spend.ts), and the run
+ * (history-data.ts), the failure digest's time-and-spend fold (failure-time-spend.ts), and the run
  * drill-down's duration (run-detail-data.ts), so those consumers cannot drift into different
  * notions of a run's span. A run_end whose start is not in `events` (log rotation cut it, or
  * the run was skipped before any start logged) has no entry; callers decide what an unpaired

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

@@ -321,7 +321,7 @@ export function readEventsSinceJoined(root, sinceMs, joinBackslackMs) {
         (window.events[firstNarrowIdx]?.ts ?? Number.POSITIVE_INFINITY) <= cutoff;
     return { cutoff, events, join: { cutoff: joinCutoff, events: joinEvents }, covered };
 }
-/** The duration-shaped windowed read behind `logs --since` (log-commands.ts): the cutoff is
+/** The duration-shaped windowed read behind `logs --since` (cli-log-commands.ts): the cutoff is
  * now − sinceMs, the rotation-spanning read is keyed on the cutoff's local calendar day
  * (dayKey — the shared dayKey helper eventDayKey buckets events with, so the read's day keys
  * cannot disagree with the ts filter), the day-keyed read may include earlier hours of that

package/dist/src/events/events.js

@@ -97,6 +97,14 @@ export function logEventBestEffort(root, event) {
         process.stderr.write(`tumwater: ${stripTerminalControls(detail)}\n`);
     }
 }
+/** Log one `image_blind` event (plans/image-input.md "Detecting a blind read"): an agent read an
+ * image its model cannot see — the authoring run was killed (action "fail") or a gate run merely
+ * recorded the read (action "logged"). The runner and both review paths used to build this exact
+ * event object themselves (source + type + run + path + model + action); it lives here so the
+ * payload has one home and cannot drift between the three callers. */
+export function logBlindRead(root, source, run, path, model, action) {
+    logEventBestEffort(root, { source, type: "image_blind", run, path, model, action });
+}
 /** warnEvent's twin of logEventBestEffort: the "something is off but the loop continues"
  * warning must not be the thing that ends the role it warns about. The fallback keeps the
  * warning's own text on stderr — when the feed is the failure, this line is the only place the

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

@@ -1,6 +1,6 @@
 /** The cluster-key rules shared by everything that groups failure messages into causes: the
  * failure digest's collection (failure-data.ts) and the error-storm reducer
- * (src/team/error-storm.ts) both count by these keys, so the normalization, the two
+ * (src/team/team-error-storm.ts) both count by these keys, so the normalization, the two
  * run-timeout shapes and their pooling, and the grouping engine live here rather than
  * inside either consumer. Pure string
  * and grouping logic — no event reads, no clock. */
@@ -12,13 +12,13 @@ import { cutSplitsSurrogatePair } from "../text/text.js";
 export const EXAMPLE_MAX = 120;
 /** The example and cluster key every message-less failure takes: errorTextOrPlaceholder
  * returns it for the digest's error clusters (failure-data.ts) and its loss ranking
- * (time-spend.ts), so a broken `run_end` that skipped its error text reads the same on both
+ * (failure-time-spend.ts), so a broken `run_end` that skipped its error text reads the same on both
  * surfaces. */
 const NO_ERROR_TEXT = "(no error text recorded)";
 /** The error text a failure event carries, or NO_ERROR_TEXT when it carries none — the field
  * is a non-empty string or absent. The single home of the placeholder rule, shared by the
  * digest's error clusters (failure-data.ts) and the loss ranking's clustered and review_error
- * arms (time-spend.ts), so a message-less failure reads the same on every surface. */
+ * arms (failure-time-spend.ts), so a message-less failure reads the same on every surface. */
 export function errorTextOrPlaceholder(v) {
     return typeof v === "string" && v !== "" ? v : NO_ERROR_TEXT;
 }
@@ -49,7 +49,7 @@ export function truncateExample(message, max = EXAMPLE_MAX) {
  * array in ascending localeCompare order, so equal inputs always render identically no matter
  * the Set's insertion order. One home for the rule the failure digest's clusters
  * (clusterMessages) and loss causes (failure-data.ts) and the error-storm warning
- * (src/team/error-storm.ts) all share — an inline `.sort()` without the comparator would
+ * (src/team/team-error-storm.ts) all share — an inline `.sort()` without the comparator would
  * silently pick code-unit order instead and let the two rules drift. */
 export function sortedRoles(roles) {
     return [...roles].sort((a, b) => a.localeCompare(b));
@@ -76,7 +76,7 @@ export function normalizeClusterKey(message) {
         .replace(/(?<!exited\s)\b\d+\b/g, "<n>");
     return normalized.trim().slice(0, EXAMPLE_MAX);
 }
-/** normalizeClusterKey's rendering of the two run-timeout errors src/agent/run-agent.ts emits —
+/** normalizeClusterKey's rendering of the two run-timeout errors src/agent/agent-run.ts emits —
  * the plain kill and the still-making-progress variant (session and worktree edits preserved
  * for resume, BUGS.md 2026-09-29). Both are one cause pointing at one knob (runTimeoutSeconds),
  * so every consumer that counts by cluster key pools them under the plain one. */
@@ -86,24 +86,15 @@ const RUN_TIMEOUT_PROGRESSING_KEY = "timed out after <dur> while still making pr
 // resumes, so its timeout names what actually happens — the commit is kept, the next
 // attempt re-reviews from scratch. Same cause, same knob (review.timeoutSeconds), one row.
 const RUN_TIMEOUT_PROGRESSING_REVIEW_KEY = "timed out after <dur> while still making progress — the commit is kept; the next attempt reviews it from scratch";
-// The review run's wording when a resumable session remains:
-// the next attempt continues this review instead of re-reviewing. Continuing the timed-out
-// session is a different cause from a from-scratch re-review, so this wording is its own
-// cluster rather than joining the pooled plain run-timeout row. Exported for its unit tests
-// (like RUN_TIMEOUT_KEY), so a display or digest test can pin the mapping by name.
-export const RUN_TIMEOUT_PROGRESSING_REVIEW_RESUME_KEY = "timed out after <dur> while still making progress — the commit is kept; the next attempt continues this review";
-/** The known progressing-timeout wordings and the key each pools under. The two review
- * wordings name one cause on one knob (review.timeoutSeconds): a still-making-progress kill
+/** The known progressing-timeout wordings and the key each pools under. The review
+ * wording names one cause on one knob (review.timeoutSeconds): a still-making-progress kill
  * pools into the plain run-timeout row (a mixed team of plain and progressing kills is one
  * cause's agent-hours, not two half-size rows the top-N cut can drop — the same pooling the
- * error-storm reducer applies, src/team/error-storm.ts), and a resumed review's wording maps
- * to itself, because continuing the timed-out session is a different cause from a from-scratch
- * re-review. Enumerated so a future wording edit lands in
- * this table rather than silently changing which row its timeouts count under. */
+ * error-storm reducer applies, src/team/team-error-storm.ts). Enumerated so a future wording
+ * edit lands in this table rather than silently changing which row its timeouts count under. */
 const TIMEOUT_POOL = new Map([
     [RUN_TIMEOUT_PROGRESSING_KEY, RUN_TIMEOUT_KEY],
     [RUN_TIMEOUT_PROGRESSING_REVIEW_KEY, RUN_TIMEOUT_KEY],
-    [RUN_TIMEOUT_PROGRESSING_REVIEW_RESUME_KEY, RUN_TIMEOUT_PROGRESSING_REVIEW_RESUME_KEY],
 ]);
 /** The cluster key a normalized error clusters under: the pooled wordings above map to their
  * row, and every other cause stands as normalizeClusterKey rendered it. */

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

@@ -2,11 +2,11 @@ import { assertReportSinceMs, eventWindowCovers, readWindowEvents, sinceWindowTi
 import { eventDayKey, eventRole } from "../events/event-read.js";
 import { baseRoleOf } from "../roles/runner-ids.js";
 import { scopeBases } from "../report/report-fold.js";
-import { timeAndSpend } from "./time-spend.js";
-import { dayAt, dayKey, dayWindow, formatDate } from "../text/datetime.js";
+import { timeAndSpend } from "./failure-time-spend.js";
+import { dayAt, dayKey, dayWindow, DAY_MS, formatDate } from "../text/datetime.js";
 import { describeStateChange, STATE_CHANGE_TOP, STATE_CHANGE_TYPES } from "./failure-state-change.js";
 import { clusterMessages, errorTextOrPlaceholder, truncateExample } from "./failure-cluster.js";
-import { addTo, getOrCreate, memoSetLru, rankByCount } from "../collections.js";
+import { addTo, distinctOrdered, getOrCreate, memoSetLru, rankByCount } from "../collections.js";
 import { firstReason } from "../text/phrases.js";
 import { sameStatIdentity, statIdentityOrZero, statOrNull } from "../files/files.js";
 import { nonNegativeNumber } from "../files/json-object.js";
@@ -100,9 +100,13 @@ function mergeFailureSection(events) {
     }
     return section(clusterMessages(messages, MERGE_FAILURE_TOP), total);
 }
+/** A role with no counted outcomes — the zero baseline roleStats starts a role on (a fresh
+ * copy, since roleStats mutates it) and deltaRows hands a role missing from either window.
+ * One home for the zero shape so a future RoleStats field is added once. */
+const ZERO_ROLE_STATS = { runs: 0, errors: 0, quietKills: 0, rejections: 0 };
 function roleStats(events) {
     const byRole = new Map();
-    const statsFor = (role) => getOrCreate(byRole, role, () => ({ runs: 0, errors: 0, quietKills: 0, rejections: 0 }));
+    const statsFor = (role) => getOrCreate(byRole, role, () => ({ ...ZERO_ROLE_STATS }));
     for (const ev of events) {
         // Runs are run_end events; a rejection is now recorded by the merge slot, AFTER the
         // authoring run has already ended `queued` (plans/merge-queue.md 3/5). review_rejected is
@@ -196,7 +200,7 @@ export function collectFailureReportSince(root, sinceMs, role, untilMs) {
             prior.push(ev);
     }
     return assembleFailureReport(current, prior, raw.events, eventWindowCovers(raw, priorFrom), raw.logState, {
-        days: Math.ceil(length / 86_400_000),
+        days: Math.ceil(length / DAY_MS),
         from: dayKey(cutoff),
         to: dayKey(end),
         ...slice,
@@ -294,11 +298,11 @@ function outcomeRows(runEvents) {
 function deltaRows(current, prior) {
     const curStats = roleStats(current);
     const prevStats = roleStats(prior);
-    const roles = [...new Set([...curStats.keys(), ...prevStats.keys()])];
+    const roles = distinctOrdered([...curStats.keys(), ...prevStats.keys()]);
     return roles
         .map((role) => {
-        const c = curStats.get(role) ?? { runs: 0, errors: 0, quietKills: 0, rejections: 0 };
-        const p = prevStats.get(role) ?? { runs: 0, errors: 0, quietKills: 0, rejections: 0 };
+        const c = curStats.get(role) ?? ZERO_ROLE_STATS;
+        const p = prevStats.get(role) ?? ZERO_ROLE_STATS;
         return {
             role,
             prevRuns: p.runs,

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

@@ -1,6 +1,6 @@
 import { agree, plural } from "../text/phrases.js";
 import { shortSha, usd } from "../text/format.js";
-import { boundedWindowLine, clockHm, dayKey, dayLabel, monthDay, reportWindow, sinceWindowLine } from "../text/datetime.js";
+import { HOUR_MS, boundedWindowLine, clockHm, dayKey, dayLabel, 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";
@@ -99,7 +99,7 @@ function spendCell(cell) {
  * from shortSpanPhrase's minutes-or-seconds (an event-feed phrase), because a summed 8-hour
  * timeout episode must not read as "480m". */
 function hoursPhrase(ms) {
-    return `${(ms / 3_600_000).toFixed(1)} h`;
+    return `${(ms / HOUR_MS).toFixed(1)} h`;
 }
 /** 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
@@ -209,42 +209,52 @@ function pushTimeAndSpend(lines, data) {
     lines.push("## Time and spend by outcome");
     if (data.timeSpend.length === 0) {
         lines.push("_no finished runs in the window_");
+        return;
     }
-    else {
-        lines.push(...markdownTable(["role", "merged", "no change", "error or blocked"], data.timeSpend.map((row) => [
-            roleCell(row.role),
-            spendCell(row.classes.merged),
-            spendCell(row.classes.no_change),
-            spendCell(row.classes.error),
-        ])));
-        lines.push("");
-        lines.push("**Top loss causes by time:**");
-        if (data.lossCauses.length === 0) {
-            lines.push("_no loss to rank_");
-        }
-        else {
-            for (const c of data.lossCauses) {
-                const cause = c.kind === "no_change"
-                    ? `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 === "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.kind === "cutoff"
-                                    ? `context cut-off on ${roleCell(c.roles[0] ?? "?")}`
-                                    : `${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).
-            if (data.lossCausesHidden > 0) {
-                const noun = agree(data.lossCausesHidden, "cause", "causes");
-                lines.push(`_+${data.lossCausesHidden} more loss ${noun} by time not listed_`);
-            }
-        }
+    pushTimeSpendRows(lines, data);
+    pushLossCauses(lines, data);
+}
+/** The role × class table of hours and dollars. */
+function pushTimeSpendRows(lines, data) {
+    lines.push(...markdownTable(["role", "merged", "no change", "error or blocked"], data.timeSpend.map((row) => [
+        roleCell(row.role),
+        spendCell(row.classes.merged),
+        spendCell(row.classes.no_change),
+        spendCell(row.classes.error),
+    ])));
+}
+/** The top loss causes by time, capped at the LOSS_TOP cut; a refused cause's text (and the
+ * empty ranking's placeholder) lives in `lossCauseText`/`pushLossCauses` here. */
+function pushLossCauses(lines, data) {
+    lines.push("");
+    lines.push("**Top loss causes by time:**");
+    if (data.lossCauses.length === 0) {
+        lines.push("_no loss to rank_");
+        return;
+    }
+    for (const c of data.lossCauses) {
+        lines.push(`- ${hoursPhrase(c.ms)} · ${usd(c.costUsd)} — ${plural(c.runs, "run")}: ${lossCauseText(c)}`);
     }
+    // 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).
+    if (data.lossCausesHidden > 0) {
+        const noun = agree(data.lossCausesHidden, "cause", "causes");
+        lines.push(`_+${data.lossCausesHidden} more loss ${noun} by time not listed_`);
+    }
+}
+/** One loss cause's bullet text. */
+function lossCauseText(c) {
+    return c.kind === "no_change"
+        ? `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 === "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.kind === "cutoff"
+                        ? `context cut-off on ${roleCell(c.roles[0] ?? "?")}`
+                        : `${c.example} (${roleList(c.roles)})`;
 }
 /** Prompt-token telemetry: the per-role median prompt
  * send and how much of the prompt budget goes out before a run's first edit, plus each