tumwater 0.4.0 → 0.4.2

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

@@ -1,168 +1,24 @@
-/** Collection half of the usage report: read the harness's event log (through the shared
- * event-folding layer in src/report/report-fold.ts) and the backlog history over a window of
- * local calendar days and distill it into a `ReportData` / `SinceReport` — per-day
+/** Collection half of the usage report's per-day series: read the harness's event log
+ * (through the shared event-folding core in src/report/report-usage-fold.ts) and the backlog
+ * history over a window of local calendar days and distill it into a `ReportData` — per-day
  * run/token/commit/cost counts plus features-done and bugs-fixed tallies from PLANS.md and
  * BUGS.md. The Markdown rendering of this data lives in src/report/report-render.ts, a pure
  * function of it; the split mirrors the failure report's (src/failure/failure-data.ts /
  * src/failure/failure-render.ts) and keeps "what happened" (window math, aggregation, bounds)
  * apart from "how it prints" (bars, cell wording), which change for different reasons — and
  * keeps core data collection out of the presentation layer, so a core consumer (as
- * /api/report already is) never forces a core→ui import. This file holds the two window
- * collectors; the report shapes they produce live in src/report/report-types.ts, and the
- * event-log folding and its memoized per-window cache in src/report/report-fold.ts (its own
- * test, report-fold-cache). */
-import { assertReportSinceMs, eventWindowCovers, readWindowEvents, sinceWindowTiming } from "../events/event-window.js";
+ * /api/report already is) never forces a core→ui import. The trailing-window `SinceReport`
+ * collector lives in src/report/report-since-data.ts beside it; both fold events through the
+ * shared one-event core in src/report/report-usage-fold.ts and its memoized per-window cache
+ * in src/report/report-fold.ts, and the report shapes they produce live in
+ * src/report/report-types.ts (report-fold has its own test, report-fold-cache). */
 import { DONE_DATE_RE, FIXED_DATE_RE, completionDate, finishedFiles, fixedBugEntries, sectionCompletionDates, sectionCompletionLags, sectionFilingDates, } from "../backlog/backlog.js";
 import { validationGapTag } from "../backlog/backlog-md.js";
-import { dayAt, dayKey, dayWindow, formatDate } from "../text/datetime.js";
+import { dayAt, dayWindow, formatDate } from "../text/datetime.js";
 import { addTo, lowerMedian } from "../collections.js";
 import { commitTier } from "../roles/roles.js";
-import { foldUsageEvent, foldWindowEvents, narrowToRole, roleSum, scopeBases, scopedByRole, zeroCommitCounts, zeroMergeCounts, } from "./report-fold.js";
-import { mainRedMinutesByDay } from "./report-main-red.js";
-/** Aggregate team usage over the trailing `sinceMs` window ending now (or `untilMs` ago, which
- * drops events at or after that end; `coversFullWindow` still judges the far edge
- * only), from the event log only (run_end/merged — see SinceReport for why the backlog files
- * are not read). Kept a
- * separate function rather than a `collectReport` variant flag: the day collector's
- * zero-filled series and backlog-file reads have no place in a window totals view. */
-export function collectReportSince(root, sinceMs, role, untilMs) {
-    assertReportSinceMs(sinceMs);
-    const { now, cutoff, end, slice } = sinceWindowTiming(sinceMs, untilMs);
-    // The window key is the cutoff's local calendar day, from the shared dayKey helper
-    // eventDayKey buckets events with, so the read's day keys cannot disagree with the ts
-    // filter below; the day-keyed read may include earlier hours of that day, which the ts
-    // filter removes (over-read is at most one day's events). Future-dated events are dropped
-    // here too, matching collectReport (its day map only holds the window's days).
-    const fromKey = dayKey(cutoff);
-    const raw = readWindowEvents(root, fromKey);
-    const acc = {
-        runs: 0,
-        runsByRole: {},
-        rejectionsByRole: {},
-        postMergeRejectionsByRole: {},
-        revisionsByRole: {},
-        refusalsByRole: {},
-        checkDurationsMs: [],
-        checkFailures: 0,
-        mergeWaitsMs: [],
-        mergeDurationsMs: [],
-        runDurationsMs: [],
-        providerWaitsMs: [],
-        slotWaitsMs: [],
-        checkWaitsMs: [],
-        reviewDurationsMs: [],
-        failedRunsByRole: {},
-        fallbacksByRole: {},
-        imageReroutesByRole: {},
-        tokensByRole: {},
-        costByRole: {},
-        tokensOut: 0,
-        ...zeroCommitCounts(),
-        costUsd: 0,
-        notionalCostUsd: 0,
-        notionalByRole: {},
-        ...zeroMergeCounts(),
-        mergedByRole: {},
-        mergeFailedByRole: {},
-        mergeFailedByReason: {},
-        costByProvider: {},
-        notionalByProvider: {},
-        notionalByBackend: {},
-        runsByModel: {},
-        deferredByReason: {},
-    };
-    for (const ev of raw.events) {
-        if (typeof ev.ts !== "number" || ev.ts < cutoff || ev.ts > now || (untilMs !== undefined && ev.ts >= end))
-            continue;
-        foldUsageEvent(acc, ev);
-    }
-    // The empty-window branch of the shared proof matters here: with no retained events nothing
-    // can have rotated away, and printing a rotation note over a fresh install would claim a
-    // history that never existed. When neither proof holds, the oldest retained event lies inside
-    // the window and the render notes the possible truncation.
-    const coversFullWindow = eventWindowCovers(raw, cutoff);
-    // Role scope: every total derives from the fold's per-role maps for the named base roles alone
-    // — merge usage (the merge slot's, not the role's) and the team-only fields stay out, so
-    // a scoped --since report sums exactly the same events the scoped day report would. The scope
-    // is the base roles, so instances (`feature-2`) aggregate into their group as the cap does.
-    const bases = scopeBases(role);
-    const scopedTotals = bases === undefined
-        ? {
-            tokensOut: acc.tokensOut + (acc.mergeTokens ?? 0),
-            runs: acc.runs ?? 0,
-            commits: acc.commits,
-            costUsd: acc.costUsd + (acc.mergeCostUsd ?? 0),
-            ...(acc.notionalCostUsd > 0 ? { notionalCostUsd: acc.notionalCostUsd } : {}),
-            ...nonemptyObj("notionalByBackend", acc.notionalByBackend),
-            mergeRuns: acc.mergeRuns ?? 0,
-            mergeTokens: acc.mergeTokens ?? 0,
-            mergeCostUsd: acc.mergeCostUsd ?? 0,
-            ...((acc.mergeFailed ?? 0) > 0 ? { mergeFailed: acc.mergeFailed } : {}),
-        }
-        : (() => {
-            // The role's own notional spend, from its run_end events; the merge slot's
-            // notional is team-wide and stays out like its cost.
-            const notional = roleSum(acc.notionalByRole, bases);
-            return {
-                tokensOut: roleSum(acc.tokensByRole, bases),
-                runs: roleSum(acc.runsByRole, bases),
-                commits: roleSum(acc.commitsByRole, bases),
-                costUsd: roleSum(acc.costByRole, bases),
-                ...(notional > 0 ? { notionalCostUsd: notional } : {}),
-                ...zeroMergeCounts(),
-            };
-        })();
-    // The --since render/JSON's Notional by role line is conditional on the window's own
-    // notional spend, scoped to base when a role is given — the same conditional the day
-    // collector applies to ReportDay.notionalByRole (line ~573), so a role-scoped window
-    // whose role spent no notional carries no notionalByRole instead of an empty map.
-    const notionalByRole = scopedByRole(acc.notionalByRole, bases);
-    // Deferred runs are bucketed by a reason code (not a role), so a role-scoped window
-    // carries no entries — the same team-only rule runsByModel follows. Only set when the
-    // window actually deferred (zero means absent), so a deferral-free --since JSON omits it.
-    const deferred = scopedByRole(acc.deferredByReason, bases);
-    return {
-        ...slice,
-        ...(bases === undefined ? {} : { role: bases.join(",") }),
-        totals: scopedTotals,
-        runsByRole: scopedByRole(acc.runsByRole, bases),
-        costByRole: scopedByRole(acc.costByRole, bases),
-        rejectionsByRole: scopedByRole(acc.rejectionsByRole, bases),
-        postMergeRejectionsByRole: scopedByRole(acc.postMergeRejectionsByRole, bases),
-        revisionsByRole: scopedByRole(acc.revisionsByRole, bases),
-        refusalsByRole: scopedByRole(acc.refusalsByRole, bases),
-        failedRunsByRole: scopedByRole(acc.failedRunsByRole, bases),
-        fallbacksByRole: scopedByRole(acc.fallbacksByRole, bases),
-        imageReroutesByRole: scopedByRole(acc.imageReroutesByRole, bases),
-        tokensByRole: scopedByRole(acc.tokensByRole, bases),
-        commitsByRole: scopedByRole(acc.commitsByRole, bases),
-        mergedByRole: scopedByRole(acc.mergedByRole, bases),
-        mergeFailedByRole: scopedByRole(acc.mergeFailedByRole, bases),
-        // A result code is not a role, so a role-scoped window carries an empty map (a code
-        // never baseRoleOf to the role) — the render gates the reason line to the team report.
-        mergeFailedByReason: scopedByRole(acc.mergeFailedByReason, bases),
-        ...nonemptyObj("notionalByRole", notionalByRole),
-        // Provider spend is a team attribution (a provider is not a role), so a role-scoped
-        // window carries empty maps — providers never baseRoleOf to the role — and the render
-        // gates the provider lines to the team report anyway. Always present, empty when none.
-        costByProvider: scopedByRole(acc.costByProvider, bases),
-        notionalByProvider: scopedByRole(acc.notionalByProvider, bases),
-        // Backend spend is a team attribution (a backend is not a role), so a role-scoped window
-        // omits it — the same absent-when-empty rule the day collector applies.
-        ...nonemptyObj("notionalByBackend", scopedByRole(acc.notionalByBackend, bases)),
-        // Model attribution is team-only (a model is not a role, so no model folds to the
-        // scoped role), the same full-map-for-team / empty-for-scoped rule costByProvider
-        // follows. Always present so the render can gate on the window's own events.
-        runsByModel: scopedByRole(acc.runsByModel, bases),
-        ...nonemptyObj("deferredByReason", deferred),
-        // Main's red time is main's own (G1's rule), not any role's, so a role-scoped window
-        // carries 0 — the type's always-present default for the team-only field.
-        mainRedMs: bases === undefined
-            ? [...mainRedMinutesByDay(raw.events, cutoff, end).values()].reduce((a, b) => a + b, 0)
-            : 0,
-        coversFullWindow,
-    };
-}
+import { foldWindowEvents, narrowToRole, nonemptyObj, roleSum, scopeBases, zeroCommitCounts, zeroMergeCounts, } from "./report-fold.js";
+import { mainRedCulpritsByDay, mainRedFailingTestsByDay, mainRedMinutesByDay } from "./report-main-red.js";
 /** Set one per-day median cell only when the day actually has samples (`ms` non-empty), so a
  * medians-free day keeps its exact pre-feature shape (the field stays absent). The single home
  * of that guard — the day collector's eight `…MedianMs` cells all followed it inline before. */
@@ -179,21 +35,9 @@ function setMapIfNonempty(day, key, map) {
         day[key] = map;
     }
 }
-/** 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 — the window and totals object-literal spreads all
- * followed it inline before. */
-function nonemptyObj(key, map) {
-    return Object.keys(map).length > 0 ? { [key]: map } : {};
-}
-/** Aggregate team usage over exactly `days` local calendar days ending today, from the event
- * log (run_end/merged) and the backlog history (`## Done` in PLANS.md and PLANS-DONE.md,
- * `## Fixed` in BUGS.md and BUGS-FIXED.md). */
-export function collectReport(root, days, role) {
-    const bases = scopeBases(role);
-    const now = new Date();
-    // One captured instant for the whole window, so every day key derives from the same day.
-    const { from, to } = dayWindow(days, now);
+/** Zero-fill the per-day series across `days` calendar days ending `now` and index it by
+ * date, so the fold's day keys can address their slots and the out-of-window keys drop out. */
+function buildEmptySeries(days, now) {
     const series = [];
     for (let i = days - 1; i >= 0; i--) {
         series.push({
@@ -210,138 +54,159 @@ export function collectReport(root, days, role) {
     const byDate = new Map();
     for (const d of series)
         byDate.set(d.date, d);
-    const foldEntry = foldWindowEvents(root, from);
-    for (const [dayKey, fold] of foldEntry.days) {
-        const day = byDate.get(dayKey);
-        if (!day)
-            continue; // Out-of-window day key (e.g. future-dated) — no series slot to fill.
-        if (bases === undefined) {
-            day.tokensOut = fold.tokensOut;
-            day.runsByRole = fold.runsByRole;
-            day.tokensByRole = fold.tokensByRole;
-            day.costByRole = fold.costByRole;
-            // Only set when nonzero, so a rejection-free day keeps its exact pre-feature shape.
-            setMapIfNonempty(day, "rejectionsByRole", fold.rejectionsByRole);
-            setMapIfNonempty(day, "postMergeRejectionsByRole", fold.postMergeRejectionsByRole);
-            setMapIfNonempty(day, "revisionsByRole", fold.revisionsByRole);
-            setMapIfNonempty(day, "refusalsByRole", fold.refusalsByRole);
-            // Checks belong to the merge slot, so only the team series carries the median.
-            setLowerMedian(day, "checkMedianMs", fold.checkDurationsMs);
-            if (fold.checkFailures > 0)
-                day.checkFailures = fold.checkFailures;
-            setLowerMedian(day, "mergeWaitMedianMs", fold.mergeWaitsMs);
-            setLowerMedian(day, "mergeSlotMedianMs", fold.mergeDurationsMs);
-            setLowerMedian(day, "runMedianMs", fold.runDurationsMs);
-            setLowerMedian(day, "providerWaitMedianMs", fold.providerWaitsMs);
-            // A workspace wait is the pool's, not a role's, so only the team series carries it.
-            setLowerMedian(day, "slotWaitMedianMs", fold.slotWaitsMs);
-            // A check permit is the team's, not a role's, so only the team series carries it.
-            setLowerMedian(day, "checkWaitMedianMs", fold.checkWaitsMs);
-            // A review belongs to the merge slot/reviewer, not the author role, so only the team
-            // series carries the median, mirroring checkMedianMs.
-            setLowerMedian(day, "reviewMedianMs", fold.reviewDurationsMs);
-            // Only set when nonzero, so a failure-free day keeps its exact pre-feature shape.
-            setMapIfNonempty(day, "failedRunsByRole", fold.failedRunsByRole);
-            setMapIfNonempty(day, "fallbacksByRole", fold.fallbacksByRole);
-            setMapIfNonempty(day, "imageReroutesByRole", fold.imageReroutesByRole);
-            day.commits = fold.commits;
-            day.commitsByRole = fold.commitsByRole;
-            day.workCommits = fold.workCommits;
-            day.maintenanceCommits = fold.maintenanceCommits;
-            day.costUsd = fold.costUsd;
-            // Only set when nonzero, so zero-notional days keep their exact pre-feature shape.
-            if (fold.notionalCostUsd > 0)
-                day.notionalCostUsd = fold.notionalCostUsd;
-            setMapIfNonempty(day, "notionalByRole", fold.notionalByRole);
-            // Only set when a provider actually spent (zero means absent), so a provider-free day
-            // keeps its exact pre-feature shape and `report --json` omits the maps when empty.
-            setMapIfNonempty(day, "costByProvider", fold.costByProvider);
-            setMapIfNonempty(day, "notionalByProvider", fold.notionalByProvider);
-            // Backends are a team attribution (a backend is not a role), so only the team series
-            // carries the map; only set when a backend actually spent (zero means absent), so a
-            // backend-free day keeps its exact pre-feature shape.
-            setMapIfNonempty(day, "notionalByBackend", fold.notionalByBackend);
-            // Models are a team attribution (a model is not a role), so only the team series
-            // carries the map; only set when a modelled start happened (zero means absent), so a
-            // model-less day keeps its exact pre-feature shape.
-            setMapIfNonempty(day, "runsByModel", fold.runsByModel);
-            // Deferred runs are a team attribution (a reason is not a role), so only the team
-            // series carries the map; only set when a day actually deferred (zero means absent),
-            // so a deferral-free day keeps its exact pre-feature shape.
-            setMapIfNonempty(day, "deferredByReason", fold.deferredByReason);
-            day.mergeRuns = fold.mergeRuns;
-            day.mergeTokens = fold.mergeTokens;
-            day.mergeCostUsd = fold.mergeCostUsd;
-            // Only set when nonzero, so a failure-free day keeps its exact pre-feature shape.
-            if ((fold.mergeFailed ?? 0) > 0)
-                day.mergeFailed = fold.mergeFailed;
-            // Only set when a role actually merged/failed that day (zero means absent), so a
-            // merge-free day keeps its exact pre-feature shape.
-            setMapIfNonempty(day, "mergedByRole", fold.mergedByRole);
-            setMapIfNonempty(day, "mergeFailedByRole", fold.mergeFailedByRole);
-            // Reason codes are a team attribution (a result is not a role), so only the team
-            // series carries the map; only set when nonzero, so a failure-free day keeps its
-            // exact pre-feature shape. The role branch below leaves it unset — merge runs are
-            // the merge slot's.
-            setMapIfNonempty(day, "mergeFailedByReason", fold.mergeFailedByReason);
-        }
-        else {
-            // Role scope: derive this day from the fold's per-role maps, so the series carries only
-            // the named role's runs/tokens/cost and (base-role-keyed) commits. The scope is the
-            // base role, so an instance id's usage and its siblings' commits fold into one group and
-            // the numbers match the per-role cap, which is base-role keyed too. The merge fields
-            // stay unset — merge runs are the merge slot's, not this role's — and the work /
-            // maintenance split follows the base role's own tier rather than the day's whole split.
-            const commits = roleSum(fold.commitsByRole, bases);
-            day.tokensOut = roleSum(fold.tokensByRole, bases);
-            day.runsByRole = narrowToRole(fold.runsByRole, bases);
-            day.tokensByRole = narrowToRole(fold.tokensByRole, bases);
-            day.costByRole = narrowToRole(fold.costByRole, bases);
-            setMapIfNonempty(day, "rejectionsByRole", narrowToRole(fold.rejectionsByRole, bases));
-            setMapIfNonempty(day, "postMergeRejectionsByRole", narrowToRole(fold.postMergeRejectionsByRole, bases));
-            setMapIfNonempty(day, "revisionsByRole", narrowToRole(fold.revisionsByRole, bases));
-            setMapIfNonempty(day, "refusalsByRole", narrowToRole(fold.refusalsByRole, bases));
-            setMapIfNonempty(day, "failedRunsByRole", narrowToRole(fold.failedRunsByRole, bases));
-            setMapIfNonempty(day, "fallbacksByRole", narrowToRole(fold.fallbacksByRole, bases));
-            setMapIfNonempty(day, "imageReroutesByRole", narrowToRole(fold.imageReroutesByRole, bases));
-            day.commits = commits;
-            day.commitsByRole = narrowToRole(fold.commitsByRole, bases);
-            const tierCommits = (tier) => bases.filter((b) => commitTier(b) === tier).reduce((n, b) => n + roleSum(fold.commitsByRole, b), 0);
-            day.workCommits = tierCommits("work");
-            day.maintenanceCommits = tierCommits("maintenance");
-            day.costUsd = roleSum(fold.costByRole, bases);
-            const notional = roleSum(fold.notionalByRole, bases);
-            if (notional > 0) {
-                day.notionalCostUsd = notional;
-                day.notionalByRole = narrowToRole(fold.notionalByRole, bases);
-            }
-            // Merge runs belong to the merge slot, not this role, so the role-scoped series
-            // keeps them unset (matching the merge-share fields) — the render omits the merge
-            // line for a scoped report, so these are carried only for shape consistency.
-            setMapIfNonempty(day, "mergedByRole", narrowToRole(fold.mergedByRole, bases));
-            setMapIfNonempty(day, "mergeFailedByRole", narrowToRole(fold.mergeFailedByRole, bases));
-        }
+    return { series, byDate };
+}
+/** Fill one team day from its folded events: every field the fold carries, with the
+ * nonzero-or-absent and median-guard rules the day's exact pre-feature shape relies on. */
+function applyTeamDay(day, fold) {
+    day.tokensOut = fold.tokensOut;
+    day.runsByRole = fold.runsByRole;
+    day.tokensByRole = fold.tokensByRole;
+    // Only set when nonempty, so a prompt-free day keeps its exact pre-feature shape.
+    setMapIfNonempty(day, "promptTokensByRole", fold.promptTokensByRole);
+    setMapIfNonempty(day, "cacheReadTokensByRole", fold.cacheReadTokensByRole);
+    day.costByRole = fold.costByRole;
+    // Only set when nonzero, so a rejection-free day keeps its exact pre-feature shape.
+    setMapIfNonempty(day, "rejectionsByRole", fold.rejectionsByRole);
+    setMapIfNonempty(day, "postMergeRejectionsByRole", fold.postMergeRejectionsByRole);
+    setMapIfNonempty(day, "revisionsByRole", fold.revisionsByRole);
+    setMapIfNonempty(day, "refusalsByRole", fold.refusalsByRole);
+    // Checks belong to the merge slot, so only the team series carries the median.
+    setLowerMedian(day, "checkMedianMs", fold.checkDurationsMs);
+    if (fold.checkFailures > 0)
+        day.checkFailures = fold.checkFailures;
+    setLowerMedian(day, "mergeWaitMedianMs", fold.mergeWaitsMs);
+    setLowerMedian(day, "mergeSlotMedianMs", fold.mergeDurationsMs);
+    setLowerMedian(day, "runMedianMs", fold.runDurationsMs);
+    setLowerMedian(day, "providerWaitMedianMs", fold.providerWaitsMs);
+    // A workspace wait is the pool's, not a role's, so only the team series carries it.
+    setLowerMedian(day, "slotWaitMedianMs", fold.slotWaitsMs);
+    // A check permit is the team's, not a role's, so only the team series carries it.
+    setLowerMedian(day, "checkWaitMedianMs", fold.checkWaitsMs);
+    // A review belongs to the merge slot/reviewer, not the author role, so only the team
+    // series carries the median, mirroring checkMedianMs.
+    setLowerMedian(day, "reviewMedianMs", fold.reviewDurationsMs);
+    // Only set when nonzero, so a failure-free day keeps its exact pre-feature shape.
+    setMapIfNonempty(day, "failedRunsByRole", fold.failedRunsByRole);
+    setMapIfNonempty(day, "fallbacksByRole", fold.fallbacksByRole);
+    day.commits = fold.commits;
+    day.commitsByRole = fold.commitsByRole;
+    day.workCommits = fold.workCommits;
+    day.maintenanceCommits = fold.maintenanceCommits;
+    day.costUsd = fold.costUsd;
+    // Only set when nonzero, so zero-notional days keep their exact pre-feature shape.
+    if (fold.notionalCostUsd > 0)
+        day.notionalCostUsd = fold.notionalCostUsd;
+    setMapIfNonempty(day, "notionalByRole", fold.notionalByRole);
+    // Only set when a provider actually spent (zero means absent), so a provider-free day
+    // keeps its exact pre-feature shape and `report --json` omits the maps when empty.
+    setMapIfNonempty(day, "costByProvider", fold.costByProvider);
+    setMapIfNonempty(day, "notionalByProvider", fold.notionalByProvider);
+    // Backends are a team attribution (a backend is not a role), so only the team series
+    // carries the map; only set when a backend actually spent (zero means absent), so a
+    // backend-free day keeps its exact pre-feature shape.
+    setMapIfNonempty(day, "notionalByBackend", fold.notionalByBackend);
+    // Models are a team attribution (a model is not a role), so only the team series
+    // carries the map; only set when a modelled start happened (zero means absent), so a
+    // model-less day keeps its exact pre-feature shape.
+    setMapIfNonempty(day, "runsByModel", fold.runsByModel);
+    // Deferred runs are a team attribution (a reason is not a role), so only the team
+    // series carries the map; only set when a day actually deferred (zero means absent),
+    // so a deferral-free day keeps its exact pre-feature shape.
+    setMapIfNonempty(day, "deferredByReason", fold.deferredByReason);
+    day.mergeRuns = fold.mergeRuns;
+    day.mergeTokens = fold.mergeTokens;
+    day.mergeCostUsd = fold.mergeCostUsd;
+    // Only set when nonzero, so a failure-free day keeps its exact pre-feature shape.
+    if ((fold.mergeFailed ?? 0) > 0)
+        day.mergeFailed = fold.mergeFailed;
+    // Only set when a role actually merged/failed that day (zero means absent), so a
+    // merge-free day keeps its exact pre-feature shape.
+    setMapIfNonempty(day, "mergedByRole", fold.mergedByRole);
+    setMapIfNonempty(day, "mergeFailedByRole", fold.mergeFailedByRole);
+    // Reason codes are a team attribution (a result is not a role), so only the team
+    // series carries the map; only set when nonzero, so a failure-free day keeps its
+    // exact pre-feature shape. The role branch below leaves it unset — merge runs are
+    // the merge slot's.
+    setMapIfNonempty(day, "mergeFailedByReason", fold.mergeFailedByReason);
+}
+/** Fill one role-scoped day from the fold's per-role maps, so the series carries only the
+ * named base role's usage, folded across an instance id's siblings, and keeps the merge
+ * fields and team-only maps unset. */
+function applyRoleDay(day, fold, bases) {
+    // Role scope: derive this day from the fold's per-role maps, so the series carries only
+    // the named role's runs/tokens/cost and (base-role-keyed) commits. The scope is the
+    // base role, so an instance id's usage and its siblings' commits fold into one group and
+    // the numbers match the per-role cap, which is base-role keyed too. The merge fields
+    // stay unset — merge runs are the merge slot's, not this role's — and the work /
+    // maintenance split follows the base role's own tier rather than the day's whole split.
+    const commits = roleSum(fold.commitsByRole, bases);
+    day.tokensOut = roleSum(fold.tokensByRole, bases);
+    day.runsByRole = narrowToRole(fold.runsByRole, bases);
+    day.tokensByRole = narrowToRole(fold.tokensByRole, bases);
+    setMapIfNonempty(day, "promptTokensByRole", narrowToRole(fold.promptTokensByRole, bases));
+    setMapIfNonempty(day, "cacheReadTokensByRole", narrowToRole(fold.cacheReadTokensByRole, bases));
+    day.costByRole = narrowToRole(fold.costByRole, bases);
+    setMapIfNonempty(day, "rejectionsByRole", narrowToRole(fold.rejectionsByRole, bases));
+    setMapIfNonempty(day, "postMergeRejectionsByRole", narrowToRole(fold.postMergeRejectionsByRole, bases));
+    setMapIfNonempty(day, "revisionsByRole", narrowToRole(fold.revisionsByRole, bases));
+    setMapIfNonempty(day, "refusalsByRole", narrowToRole(fold.refusalsByRole, bases));
+    setMapIfNonempty(day, "failedRunsByRole", narrowToRole(fold.failedRunsByRole, bases));
+    setMapIfNonempty(day, "fallbacksByRole", narrowToRole(fold.fallbacksByRole, bases));
+    day.commits = commits;
+    day.commitsByRole = narrowToRole(fold.commitsByRole, bases);
+    const tierCommits = (tier) => bases.filter((b) => commitTier(b) === tier).reduce((n, b) => n + roleSum(fold.commitsByRole, b), 0);
+    day.workCommits = tierCommits("work");
+    day.maintenanceCommits = tierCommits("maintenance");
+    day.costUsd = roleSum(fold.costByRole, bases);
+    const notional = roleSum(fold.notionalByRole, bases);
+    if (notional > 0) {
+        day.notionalCostUsd = notional;
+        day.notionalByRole = narrowToRole(fold.notionalByRole, bases);
     }
-    // The merge share joins its day's tokensOut/costUsd (the budget charges these same
-    // events, so the day series must sum to the totals the budget agrees with) while the
-    // merge fields keep the reviewer's part of it visible on its own.
+    // Merge runs belong to the merge slot, not this role, so the role-scoped series
+    // keeps them unset (matching the merge-share fields) — the render omits the merge
+    // line for a scoped report, so these are carried only for shape consistency.
+    setMapIfNonempty(day, "mergedByRole", narrowToRole(fold.mergedByRole, bases));
+    setMapIfNonempty(day, "mergeFailedByRole", narrowToRole(fold.mergeFailedByRole, bases));
+}
+/** Dispatch a day's fill on the role scope: team days read the fold whole, scoped days
+ * narrow to the named base roles. */
+function fillDayFromFold(day, fold, bases) {
+    if (bases === undefined)
+        applyTeamDay(day, fold);
+    else
+        applyRoleDay(day, fold, bases);
+}
+/** The merge share joins its day's tokensOut/costUsd (the budget charges these same
+ * events, so the day series must sum to the totals the budget agrees with) while the
+ * merge fields keep the reviewer's part of it visible on its own. */
+function addMergeShareToSeries(series) {
     for (const d of series) {
         d.tokensOut += d.mergeTokens ?? 0;
         d.costUsd += d.mergeCostUsd ?? 0;
     }
-    // Main's red wall-clock per day, from G1's rule (main_red_hold / failed ran main_check open a
-    // spell, a passing ran main_check closes it, an open spell runs to now). Team-only: main's
-    // red time is main's own, not any role's, so a role-scoped series leaves every day unset —
-    // exactly as checkFailures is team-only. Only set when a day actually was red (zero-absent,
-    // like checkMedianMs).
-    if (bases === undefined) {
-        const redByDay = mainRedMinutesByDay(foldEntry.redEvents, dayAt(days - 1, now).getTime(), now.getTime());
-        for (const d of series) {
-            const ms = redByDay.get(d.date);
-            if (ms !== undefined)
-                d.mainRedMs = ms;
-        }
+}
+/** Main's red wall-clock per day, from G1's rule (main_red_hold / failed ran main_check open a
+ * spell, a passing ran main_check closes it, an open spell runs to now). Team-only: main's
+ * red time is main's own, not any role's, so a role-scoped series leaves every day unset —
+ * exactly as checkFailures is team-only. Only set when a day actually was red (zero-absent,
+ * like checkMedianMs). */
+function applyMainRedToSeries(series, foldEntry, days, now) {
+    const redByDay = mainRedMinutesByDay(foldEntry.redEvents, dayAt(days - 1, now).getTime(), now.getTime());
+    const redTestsByDay = mainRedFailingTestsByDay(foldEntry.redEvents, dayAt(days - 1, now).getTime(), now.getTime());
+    const redCulpritsByDay = mainRedCulpritsByDay(foldEntry.redEvents, dayAt(days - 1, now).getTime(), now.getTime());
+    for (const d of series) {
+        const ms = redByDay.get(d.date);
+        if (ms !== undefined)
+            d.mainRedMs = ms;
+        setMapIfNonempty(d, "mainRedByTest", redTestsByDay.get(d.date));
+        setMapIfNonempty(d, "mainRedByCulprit", redCulpritsByDay.get(d.date));
     }
+}
+/** Count the window's backlog completions and filings onto their days. Day-granular, so a
+ * role-scoped report keeps these at zero (a date is file metadata with no role). */
+function applyCompletionAndFilingCounts(root, byDate, role) {
     const countOn = (date, field) => {
         const day = byDate.get(date);
         if (day)
@@ -377,12 +242,14 @@ export function collectReport(root, days, role) {
                 countOn(d, "bugsFiled");
         }
     }
-    // Tally the fixed bugs' `Validation gap` tags over the window, so the team can see where
-    // its own tests were weakest. An entry counts only when it is in the window (the same
-    // out-of-window drop countOn applies: its completion date must be a key of byDate), and
-    // only the team report carries the tally — a tag has no role (the render gates on the
-    // same `role === undefined`). Zero-means-absent: a window with no tagged fixed bug spreads
-    // no key, so the byte-for-byte assertions on pre-feature windows hold.
+}
+/** Tally the fixed bugs' `Validation gap` tags over the window, so the team can see where
+ * its own tests were weakest. An entry counts only when it is in the window (the same
+ * out-of-window drop countOn applies: its completion date must be a key of byDate), and
+ * only the team report carries the tally — a tag has no role (the render gates on the
+ * same `role === undefined`). Zero-means-absent: a window with no tagged fixed bug spreads
+ * no key, so the byte-for-byte assertions on pre-feature windows hold. */
+function applyValidationGaps(root, byDate, role) {
     const validationGaps = {};
     if (role === undefined) {
         for (const e of fixedBugEntries(root)) {
@@ -396,14 +263,17 @@ export function collectReport(root, days, role) {
             }
         }
     }
-    // The per-day backlog lag median: how long each finished plan or bug waited from its filing
-    // stamp to its done/fixed stamp, folded per completion day — the median backlog age at
-    // which the day's items closed. Team-only (a lag has no role, like the validation tally
-    // and the filing stamps above) and zero-means-absent: a day with no lag-carrying completion
-    // keeps its exact pre-feature shape, and an out-of-window completion date drops out (it
-    // must be a byDate key, the same drop countOn applies). The same entry detection and date
-    // rules (sectionCompletionLags / entryLags) the completion and filing reads use, so the
-    // spans pair the days `featuresDone`/`bugsFixed` count.
+    return validationGaps;
+}
+/** The per-day backlog lag median: how long each finished plan or bug waited from its filing
+ * stamp to its done/fixed stamp, folded per completion day — the median backlog age at
+ * which the day's items closed. Team-only (a lag has no role, like the validation tally
+ * and the filing stamps above) and zero-means-absent: a day with no lag-carrying completion
+ * keeps its exact pre-feature shape, and an out-of-window completion date drops out (it
+ * must be a byDate key, the same drop countOn applies). The same entry detection and date
+ * rules (sectionCompletionLags / entryLags) the completion and filing reads use, so the
+ * spans pair the days `featuresDone`/`bugsFixed` count. */
+function applyBacklogLags(root, byDate, role) {
     if (role === undefined) {
         const lagsByDay = new Map();
         const foldLag = (date, lagDays) => {
@@ -426,6 +296,11 @@ export function collectReport(root, days, role) {
         for (const [date, lags] of lagsByDay)
             byDate.get(date).backlogLagMedianDays = lowerMedian(lags);
     }
+}
+/** Reduce the filled day series to the report's totals, plus the nonzero-only fields the
+ * return literal folds into `ReportData.totals` (notional spend, merge failures, plans/bugs
+ * filings, backend attribution). */
+function foldSeriesTotals(series) {
     const totals = {
         tokensOut: 0,
         runs: 0,
@@ -466,18 +341,47 @@ export function collectReport(root, days, role) {
         totals.mergeCostUsd += d.mergeCostUsd ?? 0;
         mergeFailed += d.mergeFailed ?? 0;
     }
-    // The shared coverage proof (event-window.ts), rebuilt from the memoized read's pinned
-    // parts: the day-keyed proof (fileCovers — a property of the retained bytes and fromKey,
-    // both in the cache key), the vacuous empty-log arm, and the oldest retained event's ts.
-    // The window's first local midnight is the cutoff: an event at that instant is the
-    // earliest the window could contain, so the same-day arm degenerates harmlessly. Without
-    // this field the day report was the one windowed consumer that could undercount in
-    // silence — the --since report and the failure digest both carry the note, and a silent
-    // number invites an operator to trust a truncated window as an idle team.
+    return { totals, notionalCostUsd, mergeFailed, plansAdded, bugsFiled, notionalByBackend };
+}
+/** The shared coverage proof (event-window.ts), rebuilt from the memoized read's pinned
+ * parts: the day-keyed proof (fileCovers — a property of the retained bytes and fromKey,
+ * both in the cache key), the vacuous empty-log arm, and the oldest retained event's ts.
+ * The window's first local midnight is the cutoff: an event at that instant is the
+ * earliest the window could contain, so the same-day arm degenerates harmlessly. Without
+ * this field the day report was the one windowed consumer that could undercount in
+ * silence — the --since report and the failure digest both carry the note, and a silent
+ * number invites an operator to trust a truncated window as an idle team. */
+function windowCoverage(foldEntry, days, now) {
     const cutoffMs = dayAt(days - 1, now).getTime();
-    const coversFullWindow = foldEntry.fileCovers ||
+    return (foldEntry.fileCovers ||
         !foldEntry.hadEvents ||
-        (foldEntry.firstEventTs !== undefined && foldEntry.firstEventTs <= cutoffMs);
+        (foldEntry.firstEventTs !== undefined && foldEntry.firstEventTs <= cutoffMs));
+}
+/** Aggregate team usage over exactly `days` local calendar days ending today, from the event
+ * log (run_end/merged) and the backlog history (`## Done` in PLANS.md and PLANS-DONE.md,
+ * `## Fixed` in BUGS.md and BUGS-FIXED.md). */
+export function collectReport(root, days, role) {
+    const bases = scopeBases(role);
+    const now = new Date();
+    // One captured instant for the whole window, so every day key derives from the same day.
+    const { from, to } = dayWindow(days, now);
+    const { series, byDate } = buildEmptySeries(days, now);
+    const foldEntry = foldWindowEvents(root, from);
+    for (const [dayKey, fold] of foldEntry.days) {
+        const day = byDate.get(dayKey);
+        if (!day)
+            continue; // Out-of-window day key (e.g. future-dated) — no series slot to fill.
+        fillDayFromFold(day, fold, bases);
+    }
+    addMergeShareToSeries(series);
+    // Team-only: main's red time is main's own, not any role's (see applyMainRedToSeries).
+    if (bases === undefined)
+        applyMainRedToSeries(series, foldEntry, days, now);
+    applyCompletionAndFilingCounts(root, byDate, role);
+    const validationGaps = applyValidationGaps(root, byDate, role);
+    applyBacklogLags(root, byDate, role);
+    const { totals, notionalCostUsd, mergeFailed, plansAdded, bugsFiled, notionalByBackend } = foldSeriesTotals(series);
+    const coversFullWindow = windowCoverage(foldEntry, days, now);
     return {
         days,
         from,