tumwater 0.4.2 → 0.4.3

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

@@ -88,7 +88,7 @@ function applyTeamDay(day, fold) {
     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;
@@ -152,7 +152,7 @@ function applyRoleDay(day, fold, 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);
@@ -297,51 +297,67 @@ function applyBacklogLags(root, byDate, role) {
             byDate.get(date).backlogLagMedianDays = lowerMedian(lags);
     }
 }
+/** Fold one day's run, token, commit, cost and per-role commit counts into `acc.totals`. */
+function foldRunAndCommitCounts(acc, d) {
+    acc.totals.tokensOut += d.tokensOut;
+    for (const n of Object.values(d.runsByRole))
+        acc.totals.runs += n;
+    acc.totals.commits += d.commits;
+    for (const [role, n] of Object.entries(d.commitsByRole ?? {}))
+        addTo(acc.totals.commitsByRole, role, n);
+    acc.totals.workCommits += d.workCommits ?? 0;
+    acc.totals.maintenanceCommits += d.maintenanceCommits ?? 0;
+    acc.totals.costUsd += d.costUsd;
+}
+/** Fold one day's notional spend and its per-backend attribution into `acc`. */
+function foldNotionalSpend(acc, d) {
+    acc.notionalCostUsd += d.notionalCostUsd ?? 0;
+    for (const [backend, c] of Object.entries(d.notionalByBackend ?? {}))
+        addTo(acc.notionalByBackend, backend, c);
+}
+/** Fold one day's features-done, bugs-fixed, plan/bug filing and merge counts into `acc`. */
+function foldOutcomeCounts(acc, d) {
+    acc.totals.featuresDone += d.featuresDone;
+    acc.totals.bugsFixed += d.bugsFixed;
+    acc.plansAdded += d.plansAdded ?? 0;
+    acc.bugsFiled += d.bugsFiled ?? 0;
+    acc.totals.mergeRuns += d.mergeRuns ?? 0;
+    acc.totals.mergeTokens += d.mergeTokens ?? 0;
+    acc.totals.mergeCostUsd += d.mergeCostUsd ?? 0;
+    acc.mergeFailed += d.mergeFailed ?? 0;
+}
 /** 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). */
+ * filings, backend attribution). One named helper per accumulator phase folds each day:
+ * `foldRunAndCommitCounts` for the run/commit counts, `foldNotionalSpend` for the notional
+ * spend and its backend attribution, and `foldOutcomeCounts` for the outcome/merge counts. */
 function foldSeriesTotals(series) {
-    const totals = {
-        tokensOut: 0,
-        runs: 0,
-        ...zeroCommitCounts(),
-        costUsd: 0,
-        featuresDone: 0,
-        bugsFixed: 0,
-        ...zeroMergeCounts(),
+    const acc = {
+        totals: {
+            tokensOut: 0,
+            runs: 0,
+            ...zeroCommitCounts(),
+            costUsd: 0,
+            featuresDone: 0,
+            bugsFixed: 0,
+            ...zeroMergeCounts(),
+        },
+        notionalCostUsd: 0,
+        mergeFailed: 0,
+        plansAdded: 0,
+        bugsFiled: 0,
+        notionalByBackend: {},
     };
     // Notional spend is kept out of the totals object until it is nonzero, so a pre-feature
     // window's totals keep their exact shape. Merge failures likewise: a failure-free window
     // carries no mergeFailed (zero means absent, like the merge-share line's other fields
     // are folded in below).
-    let notionalCostUsd = 0;
-    let mergeFailed = 0;
-    let plansAdded = 0;
-    let bugsFiled = 0;
-    const notionalByBackend = {};
     for (const d of series) {
-        totals.tokensOut += d.tokensOut;
-        for (const n of Object.values(d.runsByRole))
-            totals.runs += n;
-        totals.commits += d.commits;
-        for (const [role, n] of Object.entries(d.commitsByRole ?? {}))
-            addTo(totals.commitsByRole, role, n);
-        totals.workCommits += d.workCommits ?? 0;
-        totals.maintenanceCommits += d.maintenanceCommits ?? 0;
-        totals.costUsd += d.costUsd;
-        notionalCostUsd += d.notionalCostUsd ?? 0;
-        for (const [backend, c] of Object.entries(d.notionalByBackend ?? {}))
-            addTo(notionalByBackend, backend, c);
-        totals.featuresDone += d.featuresDone;
-        totals.bugsFixed += d.bugsFixed;
-        plansAdded += d.plansAdded ?? 0;
-        bugsFiled += d.bugsFiled ?? 0;
-        totals.mergeRuns += d.mergeRuns ?? 0;
-        totals.mergeTokens += d.mergeTokens ?? 0;
-        totals.mergeCostUsd += d.mergeCostUsd ?? 0;
-        mergeFailed += d.mergeFailed ?? 0;
+        foldRunAndCommitCounts(acc, d);
+        foldNotionalSpend(acc, d);
+        foldOutcomeCounts(acc, d);
     }
-    return { totals, notionalCostUsd, mergeFailed, plansAdded, bugsFiled, notionalByBackend };
+    return acc;
 }
 /** 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,

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

@@ -14,7 +14,7 @@ import { eventDayKey, parseEventLine } from "../events/event-read.js";
 import { readCompleteLines } from "../files/tail.js";
 import { eventsLogPath } from "../paths.js";
 import { isPassingMainCheck, isRedMain } from "../baseline/main-guardrails.js";
-import { memoSetLru } from "../collections.js";
+import { addTo, distinctOrdered, memoSetLru } from "../collections.js";
 import { asList } from "../text/text.js";
 import { baseRoleOf } from "../roles/runner-ids.js";
 import { foldUsageEvent } from "./report-usage-fold.js";
@@ -53,13 +53,20 @@ export function scopeBases(role) {
     const ids = asList(role);
     if (ids.length === 0)
         return undefined;
-    const out = [];
-    for (const id of ids) {
-        const base = baseRoleOf(id);
-        if (!out.includes(base))
-            out.push(base);
-    }
-    return out;
+    return distinctOrdered(ids.map((id) => baseRoleOf(id)));
+}
+/** Fold every key of a per-role-id count/cost map through its base role, so `feature-2` joins
+ * `feature` and the map is keyed by base role. The single home of the fold — the day
+ * renderer's cost-per-commit path folds each day's raw map and then folds it once (previously
+ * inline per entry), and the --since renderer folds an already-aggregated window map — so the
+ * two cannot drift on what an instance key joins into. Addition is associative and
+ * `baseRoleOf` is deterministic, so accumulating per-id then folding once (or per entry) is
+ * identical; the helper takes an already-aggregated map either way. */
+export function foldBaseRoles(map) {
+    const folded = {};
+    for (const [id, c] of Object.entries(map))
+        addTo(folded, baseRoleOf(id), c);
+    return folded;
 }
 /** Sum a per-role-id count/cost map over the scoped base roles: instance keys (`feature-2`)
  * fold into their base (`feature`), so a scoped report aggregates a whole role group exactly
@@ -123,7 +130,7 @@ function dayFoldFor(entry, dayKey) {
             checkWaitsMs: [],
             reviewDurationsMs: [],
             failedRunsByRole: {},
-            fallbacksByRole: {},
+            imageReroutesByRole: {},
             tokensByRole: {},
             promptTokensByRole: {},
             cacheReadTokensByRole: {},

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

@@ -1,12 +1,12 @@
 import { addTo, rankCountEntries, sortByValueDesc } from "../collections.js";
+import { foldBaseRoles } from "./report-fold.js";
 import { compactTokens, usd } from "../text/format.js";
 import { durationLabel } from "../cli/cli-args.js";
-import { boundedWindowLine, monthDay, reportWindow, sinceWindowLine } from "../text/datetime.js";
+import { monthDay, reportWindow } from "../text/datetime.js";
 import { eventsRotationLabel } from "../events/events.js";
 import { SPARSE_WINDOW_NOTE } from "../events/event-window.js";
 import { shortSpanPhrase } from "../text/phrases.js";
 import { markdownTable } from "../text/markdown.js";
-import { baseRoleOf } from "../roles/runner-ids.js";
 import { backendDisplayName } from "../agent/backend-traits.js";
 /** Bar width for one day: up to 20 blocks scaled to the window's max tokensOut —
  * round(20·v/max), min 1 when v > 0. */
@@ -19,7 +19,7 @@ function barWidth(v, max) {
  * collections.ts's rank rule, so the report cannot drift from the other counters that rank the
  * same way.
  * Callers filter/format the ranked pairs. */
-function rankedRoleMap(totals) {
+export function rankedRoleMap(totals) {
     return rankCountEntries(Object.entries(totals));
 }
 /** Window totals per role: fold the per-day role maps (any `Record<string, number>` day field,
@@ -35,7 +35,7 @@ function rankedRoleTotals(series, pick) {
 }
 /** One "**Label:** role — n · role — n" Markdown line from already-ranked pairs; an empty
  * pair list (an all-zero window) renders "-". fmt formats each role's number. */
-function rankedRoleLine(label, pairs, fmt) {
+export function rankedRoleLine(label, pairs, fmt) {
     return `**${label}:** ${pairs.length === 0 ? "-" : pairs.map(([r, n]) => `${r} — ${fmt(n)}`).join(" · ")}`;
 }
 /** The "**Prompt tokens by role:**" line — each role's prompt-token total and, when its
@@ -43,7 +43,7 @@ function rankedRoleLine(label, pairs, fmt) {
  * — with zero-total roles omitted (the same zero-means-absent rule the sibling lines apply)
  * and "-" when no role sent a prompt. `prompt` arrives already ranked (prompt desc then
  * name asc). The one home of the share format, so the day and `--since` lines cannot drift. */
-function promptTokensLine(prompt, cache) {
+export function promptTokensLine(prompt, cache) {
     const cacheByRole = new Map(cache);
     const cells = prompt
         .filter(([, n]) => n > 0)
@@ -58,7 +58,7 @@ function promptTokensLine(prompt, cache) {
  * unfiltered lines. fmt formats each role's number (default String for count lines; pass
  * usd/compactTokens for spend/token lines). All the "X by role" lines share this filter-rule
  * home so the zero-means-render-dash guard cannot drift between the --since and day renders. */
-function pushRankedRoleLine(lines, label, pairs, fmt = String) {
+export function pushRankedRoleLine(lines, label, pairs, fmt = String) {
     lines.push(rankedRoleLine(label, pairs.filter(([, n]) => n > 0), fmt));
 }
 /** Push a "**Label:** …" ranked-role line only when some role carries a positive value — the
@@ -68,7 +68,7 @@ function pushRankedRoleLine(lines, label, pairs, fmt = String) {
  * formats each role's number (default String for count lines). Shared by the since and day
  * renders so the filter-and-if-present guard cannot drift between them — a field that flipped
  * one render to always-print would show an absent "-" line in one report but not the other. */
-function pushPresentRankedLine(lines, label, pairs, fmt = String) {
+export function pushPresentRankedLine(lines, label, pairs, fmt = String) {
     const present = pairs.filter(([, n]) => n > 0);
     if (present.length > 0)
         lines.push(rankedRoleLine(label, present, fmt));
@@ -102,7 +102,7 @@ function pushDayCameoLine(lines, series, title, pick, fmt = shortSpanPhrase) {
  * renders. Zero-means-absent: a provider with no spend prints no line, and both lanes format
  * with usd so the day and --since windows cannot drift (the --since path ranks via rankedRoleMap,
  * the day path via rankedRoleTotals). */
-function pushProviderCostLines(lines, rankCost, rankNotional) {
+export function pushProviderCostLines(lines, rankCost, rankNotional) {
     const providers = rankCost().filter(([, c]) => c > 0);
     if (providers.length > 0)
         lines.push(rankedRoleLine("Cost by provider", providers, usd));
@@ -171,7 +171,7 @@ const ROLE_SCOPE_NOTE = "role scope: merge runs and backlog tallies (features do
  * nonzero (zero means absent, so an API-only or merge-free window renders as before), and the
  * role-scope note when the report is scoped. One home so the day report and the --since window
  * cannot drift on the order, the omission predicates, or the scope note. */
-function pushReportSummary(lines, t, tail = "", scoped = false) {
+export function pushReportSummary(lines, t, tail = "", scoped = false) {
     lines.push(totalsLine(t, tail));
     if (t.mergeRuns > 0)
         lines.push(mergeShareLine(t));
@@ -180,188 +180,13 @@ function pushReportSummary(lines, t, tail = "", scoped = false) {
     if (scoped)
         lines.push(ROLE_SCOPE_NOTE);
 }
-/** Render a trailing-window totals report as Markdown — the aggregate sibling of the
- * `logs --since` raw stream ("how much" here, "what exactly" there). Pure function of
- * SinceReport: no I/O, no clock reads (the window line's local time is rendered from the
- * collector's captured cutoff, so the printed window matches the aggregated one). */
-export function renderSinceReportMarkdown(data) {
-    const lines = [];
-    pushSinceWindowHeader(lines, data);
-    pushSinceSummary(lines, data);
-    pushSinceRoleLines(lines, data);
-    pushSinceProviderModelLines(lines, data);
-    pushSinceMainRedLines(lines, data);
-    pushSinceFrictionLines(lines, data);
-    pushSinceDeferralLines(lines, data);
-    pushSinceCommitLines(lines, data);
-    pushSinceCostLines(lines, data);
-    pushSinceCoverageLines(lines, data);
-    return lines.join("\n");
-}
-/** The window header: the title, the bounded-or-since window line and the role scope line. */
-function pushSinceWindowHeader(lines, data) {
-    lines.push("# tumwater usage report");
-    lines.push("");
-    lines.push(data.untilMs !== undefined && data.toIso !== undefined
-        ? boundedWindowLine(durationLabel(data.sinceMs), durationLabel(data.untilMs), data.fromIso, data.toIso)
-        : sinceWindowLine(durationLabel(data.sinceMs), data.fromIso));
-    if (data.role !== undefined)
-        lines.push(`role: ${data.role}`);
-    lines.push("");
-}
-/** The shared totals voice (minus features/bugs/filing cells, stated at the tail), gated
- * to the team report like the day sibling's. */
-function pushSinceSummary(lines, data) {
-    const t = data.totals;
-    // Same totals voice as the day report, minus the features/bugs and filing cells: those tallies
-    // come from day-granular backlog-file dates that cannot subdivide a sub-day window, so the
-    // final line below states the omission instead of showing a day-rounded number.
-    pushReportSummary(lines, t, "", data.role !== undefined);
-    lines.push("");
-}
-/** Runs / tokens / prompt-tokens / cost breakdowns by role. */
-function pushSinceRoleLines(lines, data) {
-    lines.push(rankedRoleLine("Runs by role", rankedRoleMap(data.runsByRole), String));
-    // Same breakdown for token spend: ranked by tokens desc then name asc, zero-token roles
-    // omitted — an all-zero window renders "-" like the other lines. Output tokens are the
-    // resource the budget charges, so this is the line an operator reads to find which role's
-    // prompt loop burned the window's tokens.
-    pushRankedRoleLine(lines, "Tokens by role", rankedRoleMap(data.tokensByRole), compactTokens);
-    // The prompt side of the same breakdown, straight after the output-token line: how many
-    // prompt tokens each role sent and the share of them its backend served from cache — the
-    // input side of the bill an operator cannot see from Tokens by role. Zero-prompt roles are
-    // omitted, and an all-zero window renders "-" like the sibling lines.
-    lines.push(promptTokensLine(rankedRoleMap(data.promptTokensByRole ?? {}), rankedRoleMap(data.cacheReadTokensByRole ?? {})));
-    // Same breakdown for spend: ranked by spend desc then name asc, zero-spend roles omitted —
-    // an all-zero window renders "-" like the runs line.
-    pushRankedRoleLine(lines, "Cost by role", rankedRoleMap(data.costByRole), usd);
-}
-/** The provider cost lines and the per-model line, gated to the team report. */
-function pushSinceProviderModelLines(lines, data) {
-    // The same breakdown per PROVIDER (plans: per-provider spend), gated to the team report
-    // like its day sibling. SinceReport.costByProvider is always present (empty when none), so
-    // the zero-means-absent gate prints no line for a window with no provider spend.
-    if (data.role === undefined) {
-        pushProviderCostLines(lines, () => rankedRoleMap(data.costByProvider), () => rankedRoleMap(data.notionalByProvider));
-        // The same breakdown per MODEL (each run_start's agent-qualified selector — the model a
-        // team mixing providers, per-role overrides and fallbacks actually ran on), gated to the
-        // team report like the provider lines: a model is not a role, so a role-scoped window
-        // omits it. SinceReport.runsByModel is always present, so a window with no modelled
-        // start prints no line (keeping a model-less day's output unchanged), exactly as the
-        // provider lines stay absent when no provider spent.
-        pushPresentRankedLine(lines, "Runs by model", rankedRoleMap(data.runsByModel));
-    }
-}
-/** Main's red time and the test/merge culprits behind it, gated like the day sibling. */
-function pushSinceMainRedLines(lines, data) {
-    // Main's red wall-clock over the window (main's own, not any role's — a role-scoped
-    // collector carries 0, so this never prints for a scoped window). Zero-absent: no line for
-    // a window main was never red.
-    if (data.mainRedMs > 0)
-        lines.push(`**Main red:** ${durationLabel(data.mainRedMs)}`);
-    // The same "what kept main red" detail named by failing test — which tests main's own red
-    // checks named over the window. Team-only like main's red time, so a role-scoped window
-    // omits it; zero-absent: no line when the window's red checks named no test.
-    if (data.role === undefined) {
-        pushPresentRankedLine(lines, "Main red by test", rankedRoleMap(data.mainRedByTest ?? {}));
-        // The same "what kept main red" detail named by merge — the landed merges the watch's
-        // own main_culprit events blamed, mirroring the failing-test line right above. Team-only
-        // like main's red time and zero-absent: no line when the window blamed no merge.
-        pushPresentRankedLine(lines, "Main red by merge", rankedRoleMap(data.mainRedByCulprit ?? {}));
-    }
-}
-/** The review-friction and failed-run breakdowns by role. */
-function pushSinceFrictionLines(lines, data) {
-    // The same breakdown for review friction: rejections per role from review_rejected events;
-    // a window with none renders "-" like the other lines. The post-merge line is the
-    // afterMerge: true subset — rejections that reached an already-merged commit.
-    pushRankedRoleLine(lines, "Rejections by role", rankedRoleMap(data.rejectionsByRole));
-    pushRankedRoleLine(lines, "Post-merge rejections by role", rankedRoleMap(data.postMergeRejectionsByRole));
-    pushRankedRoleLine(lines, "Revisions by role", rankedRoleMap(data.revisionsByRole));
-    pushRankedRoleLine(lines, "Refusals by role", rankedRoleMap(data.refusalsByRole));
-    // The same breakdown for outright failures: error-class run_ends per role under the
-    // digest's OUTCOME_CLASS — the runs that burned agent time and merged nothing without
-    // going through review, which rejections/revisions would miss entirely. A window with
-    // none renders "-" like the other lines.
-    pushRankedRoleLine(lines, "Failed runs by role", rankedRoleMap(data.failedRunsByRole));
-    pushRankedRoleLine(lines, "Fallbacks by role", rankedRoleMap(data.fallbacksByRole));
-}
-/** Deferred maintenance runs by reason code, gated to the team report. */
-function pushSinceDeferralLines(lines, data) {
-    // Deferred maintenance runs per reason code, the --since twin of the day render's line:
-    // how many due maintenance runs stood down and why (backlog / no-work / plans-full).
-    // Gated to the team report — a reason is not a role, so a role-scoped window omits it.
-    // Zero-means-absent: a window with no deferral prints no line.
-    if (data.role === undefined) {
-        pushPresentRankedLine(lines, "Deferred runs by reason", rankedRoleMap(data.deferredByReason ?? {}));
-    }
-}
-/** Commits by role and the merged/merge-failure split, gated to the team report. */
-function pushSinceCommitLines(lines, data) {
-    // The merged-commits split by base role, matching the day render's unfiltered line: the
-    // window's totals.commits carries the count; this line says which role's commits it was.
-    lines.push(rankedRoleLine("Commits by role", rankedRoleMap(data.commitsByRole), String));
-    // The merged-outcomes split by base role, mirroring the day render's line: which roles'
-    // changes reach main and which bounce off the gate (merge_failed). Gated to the team
-    // report — a role-scoped window omits merge (ROLE_SCOPE_NOTE), so the per-role
-    // attribution would contradict it. Zero-means-absent: the failures line prints only when
-    // some role has one; a merge-free window renders `-` like the other lines.
-    if (data.role === undefined) {
-        lines.push(rankedRoleLine("Merged by role", rankedRoleMap(data.mergedByRole), String));
-        pushPresentRankedLine(lines, "Merge failures by role", rankedRoleMap(data.mergeFailedByRole));
-        // WHY the window's merges failed, from each merge_failed's result code — the day
-        // report's reason twin of the role line above, so an operator can tell a review
-        // rejection (fix the change) from a conflict/block (rebase) from a shutdown abort
-        // (capacity). Ranked the same way (count desc then code asc), reason-free only.
-        pushPresentRankedLine(lines, "Merge failures by reason", rankedRoleMap(data.mergeFailedByReason ?? {}));
-    }
-}
-/** Cost/estimated per commit and the notional Estimated by role lines. */
-function pushSinceCostLines(lines, data) {
-    // Spend per merged commit, the --since twin of the day render's `Cost per commit:` line:
-    // costByRole is keyed by role id (instances not folded, so `feature-2` joins `feature`),
-    // commitsByRole is already base-role keyed. Prints for a spend-free window as `-` and for a
-    // role-scoped window from its scoped maps, matching the day render.
-    lines.push(costPerCommitLine("Cost per commit", costPerCommitPairsFrom(foldBaseRoles(data.costByRole), data.commitsByRole)));
-    // Subscription spend is notional: its own line, only when the window has any — the same
-    // conditional/filtered `usd` form the day render's "Estimated by role" uses.
-    if (data.notionalByRole !== undefined) {
-        pushRankedRoleLine(lines, "Estimated by role", rankedRoleMap(data.notionalByRole), usd);
-        // The day render's `Estimated per commit:` twin, after `Estimated by role`, from the same
-        // notionalByRole source folded to base roles and the base-keyed commitsByRole.
-        lines.push(costPerCommitLine("Estimated per commit", costPerCommitPairsFrom(foldBaseRoles(data.notionalByRole), data.commitsByRole)));
-    }
-}
-/** The trailing blank and the exactly-one coverage/backlog-omission note. */
-function pushSinceCoverageLines(lines, data) {
-    lines.push("");
-    // Exactly one final line, chosen by the collector's coverage proof: either a hedged note
-    // that stays true whenever it prints (the oldest retained event lies inside the window —
-    // whether from rotation or a log born inside the window), or the one-time statement of the
-    // backlog-tally omission. A flat "rotated out" claim would be false for a log that never
-    // had the older events, so the wording names only what is provably the case. A role-scoped
-    // report already states the omission in ROLE_SCOPE_NOTE, so it does not repeat the --days
-    // pointer, which would imply a scoped day report shows the tallies it too omits.
-    if (!data.coversFullWindow)
-        lines.push(SPARSE_WINDOW_NOTE);
-    else if (data.role === undefined)
-        lines.push("backlog tallies (features done / bugs fixed / plans added / bugs filed) need the day report (--days)");
-}
-/** Fold every key of a per-role-id map through its base role, so `feature-2` joins `feature`.
- * The same fold the day caller does per day, applied to an already-aggregated window map. */
-function foldBaseRoles(map) {
-    const folded = {};
-    for (const [id, c] of Object.entries(map))
-        addTo(folded, baseRoleOf(id), c);
-    return folded;
-}
 /** Rank one cost map against a base-keyed commits map into cost-per-commit output: the shared
  * core of the day and --since cost-per-commit lines. `cost` is expected base-role keyed (the
  * day caller folds per day, the --since caller via `foldBaseRoles`); commits are base-role
  * keyed. `merged` is [role, cost per commit, commits] for roles with both, ranked by cost per
  * commit desc then name asc; `idle` is roles that spent and merged nothing, ranked by spend.
  * A role with commits but no spend appears in neither list. */
-function costPerCommitPairsFrom(cost, commits) {
+export function costPerCommitPairsFrom(cost, commits) {
     const mergeDone = [];
     const idleCost = [];
     for (const [role, c] of Object.entries(cost)) {
@@ -376,24 +201,26 @@ function costPerCommitPairsFrom(cost, commits) {
     sortByValueDesc(mergeDone);
     return { mergeDone, idle: rankCountEntries(idleCost) };
 }
-/** The day caller of the cost-per-commit core: fold each day's role-id-keyed spend map through
- * its base role (so `feature-2` joins `feature`) and aggregate the base-keyed commitsByRole,
- * then hand both to `costPerCommitPairsFrom`. `pick` selects the per-role-id spend map; merge
- * spend (the reviewer's) and notional subscription spend stay out by default, matching
- * `**Cost by role:**`. */
+/** The day caller of the cost-per-commit core: aggregate each day's role-id-keyed spend map
+ * under its raw role id, then fold the whole map through its base role (so `feature-2` joins
+ * `feature`) once via the shared foldBaseRoles — addition is associative and the fold is
+ * deterministic, so this is the same total the --since caller's single fold reaches — and
+ * aggregate the base-keyed commitsByRole, then hand both to `costPerCommitPairsFrom`. `pick`
+ * selects the per-role-id spend map; merge spend (the reviewer's) and notional subscription
+ * spend stay out by default, matching `**Cost by role:**`. */
 function costPerCommitPairs(series, pick = (d) => d.costByRole) {
     const cost = {};
     const commits = {};
     for (const d of series) {
         for (const [id, c] of Object.entries(pick(d)))
-            addTo(cost, baseRoleOf(id), c);
+            addTo(cost, id, c);
         for (const [role, n] of Object.entries(d.commitsByRole ?? {}))
             addTo(commits, role, n);
     }
-    return costPerCommitPairsFrom(cost, commits);
+    return costPerCommitPairsFrom(foldBaseRoles(cost), commits);
 }
 /** One `**<label>:** …` line from costPerCommitPairs output; `-` when there is nothing. */
-function costPerCommitLine(label, pairs) {
+export function costPerCommitLine(label, pairs) {
     const parts = [
         ...pairs.mergeDone.map(([r, per, n]) => `${r} — ${usd(per)} (${n})`),
         ...pairs.idle.map(([r, c]) => `${r} — ${usd(c)}, no commits`),
@@ -481,7 +308,7 @@ function pushReportFrictionLines(lines, data) {
     // through review, which rejections/revisions would miss entirely. Zero-means-absent, so a
     // failure-free window renders no line and an all-zero window renders "-" like the others.
     pushRankedRoleLine(lines, "Failed runs by role", rankedRoleTotals(data.series, (d) => d.failedRunsByRole ?? {}));
-    pushRankedRoleLine(lines, "Fallbacks by role", rankedRoleTotals(data.series, (d) => d.fallbacksByRole ?? {}));
+    pushRankedRoleLine(lines, "Image reroutes by role", rankedRoleTotals(data.series, (d) => d.imageReroutesByRole ?? {}));
 }
 /** The team-only deferred-runs-by-reason line. */
 function pushReportDeferralLines(lines, data) {

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

@@ -7,7 +7,8 @@
  * for different reasons. The event-log folding both collectors share lives in
  * src/report/report-usage-fold.ts (foldUsageEvent) and src/report/report-fold.ts (the windowed
  * cache and scope helpers), the shapes they produce in src/report/report-types.ts, and the
- * Markdown rendering in src/report/report-render.ts. */
+ * Markdown rendering in src/report/report-since-render.ts (which imports the shared formatting
+ * voice from src/report/report-render.ts). */
 import { assertReportSinceMs, eventWindowCovers, readWindowEvents, sinceWindowTiming } from "../events/event-window.js";
 import { dayKey } from "../text/datetime.js";
 import { addTo } from "../collections.js";
@@ -80,7 +81,7 @@ function foldSinceWindow(root, cutoff, now, end, untilMs) {
         checkWaitsMs: [],
         reviewDurationsMs: [],
         failedRunsByRole: {},
-        fallbacksByRole: {},
+        imageReroutesByRole: {},
         tokensByRole: {},
         promptTokensByRole: {},
         cacheReadTokensByRole: {},
@@ -190,7 +191,7 @@ function sinceRoleMaps(acc, 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),
         ...nonemptyObj("promptTokensByRole", scopedByRole(acc.promptTokensByRole, bases)),
         ...nonemptyObj("cacheReadTokensByRole", scopedByRole(acc.cacheReadTokensByRole, bases)),