tumwater 0.4.0 → 0.4.2

package/dist/src/report/report-fold.js

@@ -1,239 +1,23 @@
-/** Event-log folding for the usage report: turn raw harness events (run_end/merged/…) into
- * per-day and whole-window `UsageFold` accumulators, memoizing the day-keyed read per
- * (root, fromKey) so a dashboard polling /api/report only folds appended lines instead of
- * re-reading the window. The two window collectors (collectReport / collectReportSince) in
- * src/report/report-data.ts fold through this one shared layer, so the aggregation rules the
- * --since and day windows present cannot drift apart; it lives here matching its own test
- * (test/report-fold-cache.test.ts). Zero incidental runtime dependencies: node built-ins and
- * the app's own modules only. */
+/** The windowed event-log fold backing the usage report: read the harness's event log over a
+ * local-day window, memoize the day-keyed read per (root, fromKey) so a dashboard polling
+ * /api/report only folds appended lines instead of re-reading the window, and group events
+ * into per-day `DayFold` accumulators plus the base-role scoping helpers the day and failure
+ * reports share. The two window collectors — collectReport (src/report/report-data.ts) and
+ * collectReportSince (src/report/report-since-data.ts) — fold through this layer, each parsed
+ * event through the shared single-event core in src/report/report-usage-fold.ts
+ * (`foldUsageEvent`), so the --since and day windows present cannot drift apart; it lives here
+ * matching its own test (test/report-fold-cache.test.ts). Zero incidental runtime
+ * dependencies: node built-ins and the app's own modules only. */
 import { sameStatIdentity, statIdentityOrZero, statOrNull } from "../files/files.js";
 import { readWindowEvents } from "../events/event-window.js";
-import { eventDayKey, eventRole, eventUsage, parseEventLine } from "../events/event-read.js";
+import { eventDayKey, parseEventLine } from "../events/event-read.js";
 import { readCompleteLines } from "../files/tail.js";
 import { eventsLogPath } from "../paths.js";
-import { isPassingFullCheck, isRedFullCheck } from "../build/build-check-events.js";
 import { isPassingMainCheck, isRedMain } from "../baseline/main-guardrails.js";
-import { addTo, memoSetLru } from "../collections.js";
+import { memoSetLru } from "../collections.js";
 import { asList } from "../text/text.js";
-import { finiteNumber } from "../files/json-object.js";
-import { OUTCOME_CLASS } from "../failure/time-spend.js";
 import { baseRoleOf } from "../roles/runner-ids.js";
-import { commitTier } from "../roles/roles.js";
-/** Fold one event's `providerCost` map (`Record<provider, {costUsd, notionalCostUsd}>` — the
- * shape run-finalize.ts's run_end and merge-slot.ts's merge_done/merge_failed emit) into the
- * per-provider tallies, one addTo per provider per nonzero figure so zero stays absent. A
- * missing, foreign, or empty map folds nothing, so old logs render byte-identically. */
-function foldProviderCost(target, providerCost) {
-    if (typeof providerCost !== "object" || providerCost === null)
-        return;
-    for (const [provider, c] of Object.entries(providerCost)) {
-        if (typeof c !== "object" || c === null)
-            continue;
-        const entry = c;
-        const costUsd = finiteNumber(entry.costUsd, 0);
-        const notionalCostUsd = finiteNumber(entry.notionalCostUsd, 0);
-        if (costUsd !== 0)
-            addTo(target.costByProvider, provider, costUsd);
-        if (notionalCostUsd !== 0)
-            addTo(target.notionalByProvider, provider, notionalCostUsd);
-    }
-}
-/** Push `ms` into the accumulator list a day median reads, when it is positive: the event
- * fields that feed these medians are missing or 0 for the same event kinds (short runs, build
- * pre-checks, precedent legacy events, probe-seam waits), and those contribute nothing — a
- * median over only real durations/wait times. Every median list folds through here, so the
- * "positive-only" rule cannot drift between fields. */
-function pushPositiveMs(list, ms) {
-    if (ms > 0)
-        list.push(ms);
-}
-/** Fold one event into a usage accumulator: run_end events add a run (per role and, when
- * the target counts runs, in total), their output tokens, and their cost — zero-cost runs
- * contribute nothing, so they leave no costByRole key, keeping the render's "$0 roles are
- * omitted" rule true on the aggregation itself, not just at display time; merged events add
- * a commit; merge_done/merge_failed events add a merge run and
- * accumulate their tokens/cost into the merge fields only — costByRole stays a runs-only
- * breakdown, and the merge line is how the reviewer's share is named. Both collectors fold
- * through this one place, so the two windows' aggregation rules cannot drift apart. */
-export function foldUsageEvent(target, ev) {
-    if (ev.type === "run_end") {
-        const role = eventRole(ev);
-        addTo(target.runsByRole, role, 1);
-        // Error-class runs get their own parallel tally — the day report's ``Failed runs by role``
-        // line — reusing the digest's OUTCOME_CLASS so "failed" cannot drift from the failure
-        // report's meaning. Never subtracted from runsByRole; the two are independent counts.
-        if (OUTCOME_CLASS[ev.result] === "error")
-            addTo(target.failedRunsByRole, role, 1);
-        // A refusal is its own deliberate outcome (src/verdict/refusal.ts), not error-class, so
-        // it needs an explicit result check: the one per-role rejection-without-review count a
-        // day report should surface beside rejections, revisions and falls. Never subtracted from
-        // runsByRole; a refused run still counts as a run.
-        if (ev.result === "refused")
-            addTo(target.refusalsByRole, role, 1);
-        if (target.runs !== undefined)
-            target.runs++;
-        const { tokens, costUsd, notionalCostUsd } = eventUsage(ev);
-        pushPositiveMs(target.runDurationsMs, finiteNumber(ev.durationMs, 0));
-        addTo(target.tokensByRole, role, tokens);
-        target.tokensOut += tokens;
-        target.costUsd += costUsd;
-        target.notionalCostUsd += notionalCostUsd;
-        if (costUsd !== 0)
-            addTo(target.costByRole, role, costUsd);
-        if (notionalCostUsd !== 0)
-            addTo(target.notionalByRole, role, notionalCostUsd);
-        // The notional spend's backend (plans/codex-backend.md part 3d/9): the subscription seam
-        // whose runs made the run's API-equivalent cost, from the run_end's `agent` (run-finalize
-        // carries it when the run reported billing/rate windows) — falling back to "claude" when
-        // a legacy window event (no agent, subscription billing) attributed its spend, so the old
-        // default stays the report's only backend. A run with no backend and no subscription
-        // billing is unattributed and adds no key, so the render keeps its generic line for it.
-        const notionalBackend = typeof ev.agent === "string" && ev.agent !== ""
-            ? ev.agent
-            : ev.billing === "subscription"
-                ? "claude"
-                : undefined;
-        if (notionalBackend !== undefined && notionalCostUsd !== 0)
-            addTo(target.notionalByBackend, notionalBackend, notionalCostUsd);
-        // The agent runs' per-provider spend (run-finalize.ts emits providerCost on run_end)
-        // — folded per provider beside the per-role maps, so a mixed team's `Cost by provider`
-        // line names the expensive seam.
-        foldProviderCost(target, ev.providerCost);
-    }
-    else if (ev.type === "review_rejected") {
-        // One rejection per event, on the day it happened, per role. Zero-means-absent: a role
-        // that never rejected stays absent, like costByRole.
-        addTo(target.rejectionsByRole, eventRole(ev), 1);
-        // A rejection that carried afterMerge: true is a post-merge one — the commit had already
-        // landed, so the reviewer's turn-back reaches the revert path off main. Kept as its own
-        // subset of rejectionsByRole because it is a different, costlier kind of rejection.
-        if (ev.afterMerge === true)
-            addTo(target.postMergeRejectionsByRole, eventRole(ev), 1);
-        // A rejection that carried a positive durationMs means a reviewer actually ran the gate
-        // and reached a verdict (post-merge rejections do; the build pre-check contributes no
-        // duration), so it joins the review-duration median beside approvals. durationMs: 0 and
-        // a duration-less event contribute nothing.
-        pushPositiveMs(target.reviewDurationsMs, finiteNumber(ev.durationMs, 0));
-    }
-    else if (ev.type === "review_verdict") {
-        // An approval that reached a verdict. Every reviewer run that reached a verdict, approval
-        // or rejection, is one entry in the review-duration median; review_failed stays out — it
-        // has no verdict. Mirrors the rejection branch above, on the same-day count.
-        pushPositiveMs(target.reviewDurationsMs, finiteNumber(ev.durationMs, 0));
-    }
-    else if (ev.type === "revision") {
-        // One rework round per event, on the day it happened, per role. Zero-means-absent: a role
-        // that never reworked a rejected change stays absent, like rejectionsByRole.
-        addTo(target.revisionsByRole, eventRole(ev), 1);
-    }
-    else if (isPassingFullCheck(ev)) {
-        // The merge slot's passing full-suite checks, for the day report's check-time median.
-        pushPositiveMs(target.checkDurationsMs, finiteNumber(ev.durationMs, 0));
-    }
-    else if (isRedFullCheck(ev)) {
-        // The merge slot's red full-suite checks, for the day report's red-check count.
-        target.checkFailures++;
-    }
-    else if (ev.type === "model_fallback_started") {
-        // One episode per start event; durations are not summed (an episode can span the window edge).
-        addTo(target.fallbacksByRole, eventRole(ev), 1);
-    }
-    else if (ev.type === "image_reroute") {
-        // One reroute per event, preflight or after a blind read.
-        addTo(target.imageReroutesByRole, eventRole(ev), 1);
-    }
-    else if (ev.type === "run_deferred") {
-        // One deferral per event, a due maintenance run that stood down. Bucket by the raw
-        // reason code ("backlog", "plans-full", else "no-work" for a missing/foreign/torn
-        // reason — the same fallback deferredReasonText applies in the feed), so the collector
-        // stays free of a presentation import and the render prints the code the event carried.
-        // Team-only: a reason is not a role.
-        const reason = ev.reason === "backlog" || ev.reason === "plans-full" ? ev.reason : "no-work";
-        addTo(target.deferredByReason, reason, 1);
-    }
-    else if (ev.type === "merged") {
-        target.commits++;
-        // Work ratio 4/4: split merged commits by base role and by tier. Instance suffixes fold
-        // into their role (`feature-2` counts as feature) so the split does not fragment.
-        const role = baseRoleOf(eventRole(ev));
-        addTo(target.commitsByRole, role, 1);
-        const tier = commitTier(role);
-        if (tier === "work")
-            target.workCommits++;
-        else if (tier === "maintenance")
-            target.maintenanceCommits++;
-    }
-    else if (ev.type === "run_start") {
-        // One tally per run start on a configured model: the same `model` field the CLI's
-        // `run #N started on <model>` line prints, and the only event that carries a model
-        // (run_end has none), so a run that started with no configured model contributes no key.
-        const model = typeof ev.model === "string" && ev.model.length > 0 ? ev.model : null;
-        if (model !== null)
-            addTo(target.runsByModel, model, 1);
-    }
-    else if (ev.type === "provider_wait") {
-        // The day report's provider-slot wait median, mirroring the slot_wait push: a wait only
-        // event-logged at or above the 30 s threshold counts, so a 0 ms wait (a probe seam) adds
-        // nothing and the median reflects real blocked admissions only.
-        pushPositiveMs(target.providerWaitsMs, finiteNumber(ev.waitedMs, 0));
-    }
-    else if (ev.type === "slot_wait") {
-        // The day report's workspace-slot wait median, mirroring the provider_wait push: a wait
-        // only event-logged at or above the 30 s threshold counts, so a 0 ms wait (a probe seam)
-        // or a pre-waitedMs event adds nothing.
-        pushPositiveMs(target.slotWaitsMs, finiteNumber(ev.waitedMs, 0));
-    }
-    else if (ev.type === "check_wait") {
-        // The day report's check-slot wait median, mirroring the slot_wait push: only waits logged
-        // at or above the 30 s threshold count, so a 0 ms or pre-waitedMs event adds nothing.
-        pushPositiveMs(target.checkWaitsMs, finiteNumber(ev.waitedMs, 0));
-    }
-    else if (ev.type === "merge_done" || ev.type === "merge_failed") {
-        target.mergeRuns = (target.mergeRuns ?? 0) + 1;
-        if (ev.type === "merge_failed")
-            target.mergeFailed = (target.mergeFailed ?? 0) + 1;
-        // Attribute the outcome to the authoring role (writeMergeOutcome logs role: entry.role)
-        // folded to base role, the same normalization the merged branch uses, so `feature-2`
-        // aggregates into `feature`. A parallel tally beside the team run counts, never
-        // subtracted from mergeRuns/mergeFailed.
-        const role = baseRoleOf(eventRole(ev));
-        if (ev.type === "merge_done") {
-            addTo(target.mergedByRole, role, 1);
-            // Events logged before queuedMs existed carry none: skipped, not counted as zero.
-            pushPositiveMs(target.mergeWaitsMs, finiteNumber(ev.queuedMs, 0));
-            // How long the merge slot itself held the change, from the verification's start to the
-            // outcome. Like mergeWaitsMs, only a landed merge feeds it, and a pre-durationMs event
-            // (or 0) contributes nothing.
-            pushPositiveMs(target.mergeDurationsMs, finiteNumber(ev.durationMs, 0));
-        }
-        else {
-            addTo(target.mergeFailedByRole, role, 1);
-            // The event's result (writeMergeOutcome's RunResult) names WHY the merge bounced
-            // off the gate — rejected/merge_conflict/merge_blocked/aborted. A legacy event with
-            // no result folds under `unknown`, so the reason buckets always sum to mergeFailed.
-            const reason = typeof ev.result === "string" && ev.result.length > 0 ? ev.result : "unknown";
-            addTo(target.mergeFailedByReason, reason, 1);
-        }
-        const { tokens, costUsd, notionalCostUsd } = eventUsage(ev);
-        target.mergeTokens = (target.mergeTokens ?? 0) + tokens;
-        target.mergeCostUsd = (target.mergeCostUsd ?? 0) + costUsd;
-        // A subscription merge's API-equivalent spend joins the notional line, never the
-        // budgeted cost totals (plans/agent-backends.md part 6a).
-        target.notionalCostUsd += notionalCostUsd;
-        // The merge's notional spend per backend (merge-slot.ts emits it on the event, keyed by
-        // each subscription run's agent) — folded beside the run-end per-backend map, so a codex
-        // merge's subscription spend names codex instead of falling back to the generic line.
-        for (const [backend, c] of Object.entries(ev.notionalByBackend ?? {})) {
-            const amt = finiteNumber(c, 0);
-            if (amt !== 0)
-                addTo(target.notionalByBackend, backend, amt);
-        }
-        // The merge's per-provider spend (merge-slot.ts keys it to its reviewer seam), so a
-        // merge's costs appear under the provider that ran the reviewer, matching the author
-        // side's foldMergeUsage charge.
-        foldProviderCost(target, ev.providerCost);
-    }
-}
+import { foldUsageEvent } from "./report-usage-fold.js";
 /** Bounded memo of window folds. Eight entries cover a dashboard flipping among a few day
  * counts plus the midnight rollover's new fromKey; oldest-insertion eviction (Map preserves
  * insertion order) keeps the memory bound to a handful of per-day accumulator maps. */
@@ -253,6 +37,13 @@ export function zeroCommitCounts() {
 export function zeroMergeCounts() {
     return { mergeRuns: 0, mergeTokens: 0, mergeCostUsd: 0 };
 }
+/** Build one object-literal spread cell for a per-slice role/product map only when the map has
+ * entries (`map` non-empty), so an entry-free window omits the field instead of carrying an
+ * empty map. The single home of that guard for both window collectors — the day report's and
+ * the trailing-window totals object-literal spreads all followed it inline before. */
+export function nonemptyObj(key, map) {
+    return Object.keys(map).length > 0 ? { [key]: map } : {};
+}
 /** The base roles a report scope names: undefined and an empty list mean no scope (the team
  * report); otherwise each id folded through `baseRoleOf`, deduplicated in first-seen order, so
  * `feature-2,feature` is one base. */
@@ -333,8 +124,9 @@ function dayFoldFor(entry, dayKey) {
             reviewDurationsMs: [],
             failedRunsByRole: {},
             fallbacksByRole: {},
-            imageReroutesByRole: {},
             tokensByRole: {},
+            promptTokensByRole: {},
+            cacheReadTokensByRole: {},
             costByRole: {},
             notionalByRole: {},
             ...zeroMergeCounts(),
@@ -363,7 +155,7 @@ function foldEventInto(entry, ev) {
         entry.hadEvents = true;
         entry.firstEventTs = typeof ev.ts === "number" ? ev.ts : undefined;
     }
-    if (isRedMain(ev) || isPassingMainCheck(ev))
+    if (isRedMain(ev) || isPassingMainCheck(ev) || ev.type === "main_culprit")
         entry.redEvents.push(ev);
     foldUsageEvent(dayFoldFor(entry, dayKey), ev);
 }

package/dist/src/report/report-main-red.js

@@ -6,6 +6,16 @@
  * only on the team scope. */
 import { dayKey } from "../text/datetime.js";
 import { isPassingMainCheck, isRedMain } from "../baseline/main-guardrails.js";
+import { addTo, getOrCreate } from "../collections.js";
+import { shortSha } from "../text/format.js";
+import { roleLabel } from "../roles/role-labels.js";
+/** The events whose `ts` is a number in `[fromMs, toMs)`, in log order. The three byDay walks
+ * (mainRedMinutesByDay, mainRedFailingTestsByDay, mainRedCulpritsByDay) each iterate these, so
+ * they cannot disagree about which events fall in the window; the `typeof e.ts === "number"`
+ * guard also drops a torn log line whose stamp never landed on the event. */
+function inWindowEvents(events, fromMs, toMs) {
+    return events.filter((e) => typeof e.ts === "number" && e.ts >= fromMs && e.ts < toMs);
+}
 /** Add a spell's ms, split across the local calendar days it spans, to `map` (a Map, so the
  * caller keeps the day-key order the walk produced). */
 function addSpell(map, start, end) {
@@ -32,9 +42,7 @@ function addSpell(map, start, end) {
  * window — the report measures main's own red time within the window it was asked for. */
 export function mainRedMinutesByDay(events, fromMs, toMs) {
     const map = new Map();
-    const inWindow = events
-        .filter((e) => typeof e.ts === "number" && e.ts >= fromMs && e.ts < toMs)
-        .sort((a, b) => a.ts - b.ts);
+    const inWindow = inWindowEvents(events, fromMs, toMs).sort((a, b) => a.ts - b.ts);
     let openStart;
     for (const e of inWindow) {
         const ts = e.ts;
@@ -53,3 +61,62 @@ export function mainRedMinutesByDay(events, fromMs, toMs) {
         addSpell(map, openStart, toMs);
     return map;
 }
+/** Count named items into per-calendar-day maps (`YYYY-MM-DD` → key → count) over the window
+ * `[fromMs, toMs)`: walk the events `inWindowEvents` admits and, for each one `keysOf` turns
+ * into a non-empty list, add each key once into that event's day (`dayKey`). The two byDay
+ * count walks (`mainRedFailingTestsByDay`, `mainRedCulpritsByDay`) share this shape so they
+ * cannot disagree about which events fall in the window (`inWindowEvents`) or which day an
+ * event lands on (`dayKey`); `keysOf` returns `undefined` (or an empty list) for the events a
+ * walk ignores, keeping their loose-event-log guards (a non-`failingTests` red, a
+ * commit-less `main_culprit`) in the walk where its own rule reads clearest. */
+function countByDayInWindow(events, fromMs, toMs, keysOf) {
+    const map = new Map();
+    for (const e of inWindowEvents(events, fromMs, toMs)) {
+        const keys = keysOf(e);
+        if (keys === undefined || keys.length === 0)
+            continue;
+        const record = getOrCreate(map, dayKey(e.ts), () => ({}));
+        for (const key of keys)
+            addTo(record, key, 1);
+    }
+    return map;
+}
+/** Main's red failing tests per local calendar day (`YYYY-MM-DD` → test → count), over the
+ * window `[fromMs, toMs)`: for each event `inWindowEvents` admits (numeric `ts` in `[fromMs,
+ * toMs)`) that G1 accepts as red (`isRedMain`) — a `main_check` that ran the full
+ * check and failed, or a `main_red_hold` — count each `failingTests` element that is a string
+ * once into that event's day (`dayKey`). A passing check is not red, and a red event that
+ * carries no `failingTests` (a hold whose red named none, or a torn non-array `failingTests`;
+ * a non-string element contributes nothing) records nothing, so the loose event log can never
+ * emit `undefined` as a key. Shares `isRedMain` and `dayKey` with
+ * `mainRedMinutesByDay`, so the two cannot disagree about which events are main's red ones.
+ * This is main's own failing tests, not any role's, so the report carries it only on the team
+ * scope. */
+export function mainRedFailingTestsByDay(events, fromMs, toMs) {
+    return countByDayInWindow(events, fromMs, toMs, (e) => isRedMain(e) && Array.isArray(e.failingTests)
+        ? e.failingTests.filter((t) => typeof t === "string")
+        : undefined);
+}
+/** Main's red culprits per local calendar day (`YYYY-MM-DD` → label → count), over the window
+ * `[fromMs, toMs)`: for each event `inWindowEvents` admits (numeric `ts` in `[fromMs, toMs)`)
+ * that is a `main_culprit` whose `commit` is a non-empty string, label it
+ * `<roleLabel(runner)> <shortSha(commit)>` when `runner` is a non-empty string, else
+ * `merge <shortSha(commit)>`, and count it once into that event's day (`dayKey`). This is the
+ * live `mainred` alert's own event (`src/status/status-polls.ts`'s `MainCheckStatus.red
+ * .culprit`), so the report names the very merge the watch blamed, not just the tests it
+ * named. A `main_culprit` with no `commit` or an empty/non-string one contributes nothing, so
+ * the loose event log can never emit `undefined` as a key. Shares `dayKey` with the sibling
+ * walks (`mainRedMinutesByDay`, `mainRedFailingTestsByDay`), so the three cannot disagree
+ * about which day an event lands on. This is main's own blame, not any role's, so the report
+ * carries it only on the team scope. */
+export function mainRedCulpritsByDay(events, fromMs, toMs) {
+    return countByDayInWindow(events, fromMs, toMs, (e) => e.type === "main_culprit" &&
+        typeof e.commit === "string" &&
+        e.commit.length > 0
+        ? [
+            typeof e.runner === "string" && e.runner.length > 0
+                ? `${roleLabel(e.runner)} ${shortSha(e.commit)}`
+                : `merge ${shortSha(e.commit)}`,
+        ]
+        : undefined);
+}