tumwater 0.4.2 → 0.4.3

package/dist/src/doctor/doctor-project-checks.js

@@ -17,7 +17,7 @@ import { buildStaleness, isSelfHosted, readBuildInfo, STALE_INPUTS_LABEL } from
 import { dirEntryNames, statOrNull } from "../files/files.js";
 import { refSha } from "../git/git.js";
 import { STATE_DIR, eventsArchivePath, eventsLogPath } from "../paths.js";
-import { BYTES_PER_GB, diskVolumePath, sampleFreeBytes } from "../gates/disk-gate.js";
+import { BYTES_PER_GB, diskVolumePath, sampleFreeBytes } from "../gates/disk-gates.js";
 import { DAY_MS, dayKey } from "../text/datetime.js";
 import { errorMessage } from "../text/text.js";
 import { lowerMedian } from "../collections.js";
@@ -33,7 +33,7 @@ import { roleLabel } from "../roles/role-labels.js";
 import { quarantineWarning } from "../baseline/main-guardrails.js";
 import { readCiParity, currentCiParityState, parityIsCurrent, ciParityStalled, CI_PARITY_STALE_MS } from "../run/ci-parity.js";
 import { readQaCoverage, qaCoverageStalled, QA_COVERAGE_STALE_MS } from "../run/qa-coverage.js";
-import { failOutcome, okOutcome, warnOutcome } from "./outcome.js";
+import { failOutcome, okOutcome, warnOutcome } from "./doctor-outcome.js";
 /** .tumwater writable — absent is fine (created on first run); present, prove it by writing
  * and deleting a temp file inside. The probe leaves the dir's listing unchanged after the run.
  * The write is the property under test: only a write that fails is "not writable", so the
@@ -251,7 +251,7 @@ export function checkBuildCheck(root, config) {
  * once, so a routine one-off flake stays quiet. ok/warn only — never a fail — so a flaky suite
  * cannot fail a scripted doctor pre-flight (the checkStalledEntries precedent; the exit-code
  * rule is
- * outcome.ts's). */
+ * doctor-outcome.ts's). */
 export function checkFlakyChecks(root, now = Date.now()) {
     const { events } = readEventsSince(root, KNOWN_FLAKE_WINDOW_MS);
     const flapped = repeatedFlakeCounts(events);

package/dist/src/doctor/doctor-role-notes.js

@@ -1,7 +1,7 @@
 import { readRoleNotesOverCap } from "../status/status-role-notes.js";
 import { ROLE_NOTES_MAX_BYTES } from "../agent/role-notes-write.js";
 import { agree, plural } from "../text/phrases.js";
-import { okOutcome, warnOutcome } from "./outcome.js";
+import { okOutcome, warnOutcome } from "./doctor-outcome.js";
 /** How many oversized notes the `role notes` row names before appending "and N more", the
  * cap the other multi-role observer rows (e.g. workspaces) use so a long tail does not drown
  * the report. */

package/dist/src/doctor/doctor.js

@@ -1,23 +1,23 @@
 import { loadConfigSafe } from "../config/config.js";
 import { envPath } from "../files/files.js";
-import { orchestratorAlive, readOrchestratorInfo } from "../team/orchestrator-info.js";
+import { orchestratorAlive, readOrchestratorInfo } from "../team/team-orchestrator-info.js";
 import { systemProcessProbe } from "../process/process-table.js";
 import { checkOrphans } from "./doctor-orphans.js";
-import { checkBudget, checkErrorStreaks, checkMainRed, checkMaintenanceQuota, checkPause, checkProviderHolds, checkQuietHours, checkSubscriptionWindow } from "./doctor-holds.js";
+import { checkBudget, checkErrorStreaks, checkMainRed, checkMaintenanceQuota, checkPause, checkProviderHolds, checkQuietHours } from "./doctor-holds.js";
 import { checkRootInstall } from "./doctor-install.js";
 import { checkNotify } from "./doctor-notify.js";
 import { checkRoleNotes } from "./doctor-role-notes.js";
 import { checkLaunchServicesPorts } from "./doctor-launch-services.js";
 import { plural } from "../text/phrases.js";
 import { shortSha } from "../text/format.js";
-import { failOutcome } from "./outcome.js";
+import { failOutcome } from "./doctor-outcome.js";
 import { errorMessage } from "../text/text.js";
 import { checkBackendBinary, checkBrief, checkBootstrap, checkClaudeTranscripts, checkExecPath, checkFunes, checkGitBinary, checkConfigKeyNames, checkInit, checkOpencodeVersion, checkNodeVersion, checkPiExtensions, checkRepo, } from "./doctor-checks.js";
 import { checkPrinciples } from "./doctor-principles.js";
 import { checkBuild, checkBuildCheck, checkCiParity, checkDiskSpace, checkDroppedPostMergeReviews, checkEventLog, checkFlakyChecks, checkMainDiffRules, checkPostMergeChurn, checkQaCoverage, checkStateDir, } from "./doctor-project-checks.js";
-import { sampleFreeBytes } from "../gates/disk-gate.js";
-import { checkCheckContention, checkLeftoverRoleBranches, checkMergeLock, checkProviderConcurrency, checkProviderContention, checkTumwaterPins, checkWorkInstances, checkWorktreePool, } from "./doctor-contention-checks.js";
-import { checkFeedbackFiling, checkTierModels } from "./doctor-model-checks.js";
+import { sampleFreeBytes } from "../gates/disk-gates.js";
+import { checkCheckContention, checkLeftoverRoleBranches, checkMergeLock, checkProviderContention, checkTumwaterPins, checkWorkInstances, checkWorktreePool, } from "./doctor-contention-checks.js";
+import { checkFeedbackFiling, checkImageInput, checkTierModels } from "./doctor-model-checks.js";
 import { checkFallbackChain, checkFallbackModel } from "./doctor-fallback-checks.js";
 import { checkAnthroApiKey, checkClaudeAuth, checkClaudeVersion } from "./doctor-claude-checks.js";
 import { checkOpencode } from "./doctor-opencode-checks.js";
@@ -95,11 +95,8 @@ export async function runDoctor(root, pathEnv = envPath(), probe = systemProcess
         { name: "pause", run: () => checkPause(root) },
         { name: "quiet hours", run: () => checkQuietHours(config) },
         { name: "budget", run: () => checkBudget(root, config, (orchestratorAlive(root, info) && info?.budget) || null) },
-        { name: "claude window", run: () => checkSubscriptionWindow("claude", root, undefined, (orchestratorAlive(root, info) && info?.chain) || undefined, config) },
-        { name: "codex window", run: () => checkSubscriptionWindow("codex", root, undefined, (orchestratorAlive(root, info) && info?.chain) || undefined, config) },
         { name: "provider waits", run: () => checkProviderHolds(root) },
         { name: "maintenance allowance", run: () => checkMaintenanceQuota(root, config, orchestratorAlive(root, info)) },
-        { name: "provider concurrency", run: () => checkProviderConcurrency(config, root) },
         { name: "provider contention", run: () => checkProviderContention(root, config) },
         { name: "check contention", run: () => checkCheckContention(root, config) },
         { name: "repeated failures", run: () => checkErrorStreaks(root, config) },
@@ -107,6 +104,7 @@ export async function runDoctor(root, pathEnv = envPath(), probe = systemProcess
         { name: "over-cap model", run: () => checkFallbackModel(root, undefined, (orchestratorAlive(root, info) && info?.fallbackDemoted) || null) },
         { name: "fallback chain", run: () => checkFallbackChain(root) },
         { name: "models for each tier", run: () => checkTierModels(root) },
+        { name: "image input", run: () => checkImageInput(root) },
         { name: "claude auth", run: () => checkClaudeAuth(root, pathEnv) },
         { name: "claude api key", run: () => checkAnthroApiKey(root, undefined, pathEnv) },
         { name: "claude version", run: () => checkClaudeVersion(root, pathEnv) },
@@ -127,8 +125,7 @@ export async function runDoctor(root, pathEnv = envPath(), probe = systemProcess
         // The receive-side guards name what a running team skips, so an operator tool meant for the
         // team (a pi package, an extension file, an mcp.json server, or funes) does not vanish
         // silently. Each check returns null to omit its row: the pi row for a team with no pi seam,
-        // the funes row when funes is not on PATH, and the claude/codex window rows when that backend
-        // has no subscription account.
+        // the funes row when funes is not on PATH.
         { name: "pi extensions", run: () => checkPiExtensions(config, undefined, pathEnv) },
         { name: "funes", run: () => checkFunes(config, pathEnv) },
         { name: "state dir", run: () => checkStateDir(root) },

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";
@@ -111,9 +110,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)}`;
 }
@@ -213,9 +219,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)})`;
@@ -430,13 +438,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 +532,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 +542,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 +556,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 +588,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 +598,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
@@ -669,22 +660,11 @@ function checkWaitEventMessage(e) {
             return `waited ${shortSpanPhrase(finiteNumber(e.waitedMs, 0))} 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.
+            // 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.
             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)})`;
+            return `waited ${span} 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
@@ -754,8 +734,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 +753,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 +764,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;

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

@@ -10,8 +10,8 @@ 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

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/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. */
@@ -96,7 +96,7 @@ export const RUN_TIMEOUT_PROGRESSING_REVIEW_RESUME_KEY = "timed out after <dur>
  * wordings name 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
+ * error-storm reducer applies, src/team/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. */

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

@@ -2,7 +2,7 @@ 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 { timeAndSpend } from "./failure-time-spend.js";
 import { dayAt, dayKey, dayWindow, 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";
@@ -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
@@ -297,8 +301,8 @@ function deltaRows(current, prior) {
     const roles = [...new Set([...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

@@ -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