tumwater 0.1.2 → 0.2.0

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

@@ -1,211 +1,26 @@
-/** Collection half of the usage report: read the harness's event log and backlog history over
- * a window of local calendar days and distill it into a `ReportData` — per-day tick/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 /
+// vocabulary: plain
+/** 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
+ * tick/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. */
-import { sameStatIdentity, statOrNull } from "../files/files.js";
+ * /api/report already is) never forces a core→ui import. This file holds the two window
+ * collectors and the report shapes they produce; the event-log folding and its memoized
+ * per-window cache live in src/report/report-fold.ts (its own test, report-fold-cache). */
 import { assertReportSinceMs, eventWindowCovers, readWindowEvents } from "../events/event-window.js";
-import { eventDayKey, eventRole, eventUsage, parseEventLine } from "../events/event-read.js";
-import { readCompleteLines } from "../files/tail.js";
-import { eventsLogPath } from "../paths.js";
-import { sectionCompletionDates } from "../backlog/backlog.js";
+import { DONE_DATE_RE, FIXED_DATE_RE, completionDate, finishedFiles, fixedBugEntries, sectionCompletionDates, sectionFilingDates, } from "../backlog/backlog.js";
+import { validationGapTag } from "../backlog/backlog-md.js";
 import { dayAt, dayKey, dayWindow, formatDate } from "../text/datetime.js";
-import { addTo } from "../collections.js";
+import { addTo, lowerMedian } from "../collections.js";
 import { baseRoleOf } from "../roles/loop-ids.js";
 import { commitTier } from "../roles/roles.js";
-/** Fold one event into a usage accumulator: tick_end events add a tick (per role and, when
- * the target counts ticks, in total), their output tokens, and their cost — zero-cost ticks
- * 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; landed/land_failed events add a landing run and
- * accumulate their tokens/cost into the landing fields only — costByRole stays a ticks-only
- * breakdown, and the landing 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. */
-function foldUsageEvent(target, ev) {
-    if (ev.type === "tick_end") {
-        const role = eventRole(ev);
-        addTo(target.ticksByRole, role, 1);
-        if (target.ticks !== undefined)
-            target.ticks++;
-        const { tokens, costUsd, notionalCostUsd } = eventUsage(ev);
-        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);
-    }
-    else if (ev.type === "merged") {
-        target.commits++;
-        // Work ratio 4/4: split landed 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 === "landed" || ev.type === "land_failed") {
-        target.landingRuns = (target.landingRuns ?? 0) + 1;
-        const { tokens, costUsd, notionalCostUsd } = eventUsage(ev);
-        target.landingTokens = (target.landingTokens ?? 0) + tokens;
-        target.landingCostUsd = (target.landingCostUsd ?? 0) + costUsd;
-        // A subscription landing's API-equivalent spend joins the notional line, never the
-        // budgeted cost totals (plans/agent-backends.md part 6a).
-        target.notionalCostUsd += notionalCostUsd;
-    }
-}
-/** 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. */
-const reportFoldCache = new Map();
-const REPORT_FOLD_CACHE_MAX = 8;
-/** The empty commit-family counters every accumulator starts from: the total and per-base-role
- * landed-commit count plus the work/maintenance split (Work ratio 4/4). Four shapes carry them —
- * DayFold, UsageFold, the ReportDay series slots, and the window totals — so the empty quartet
- * lives once here and a new commit counter is added in one place. */
-function zeroCommitCounts() {
-    return { commits: 0, commitsByRole: {}, workCommits: 0, maintenanceCommits: 0 };
-}
-/** The empty landing-run counters every accumulator starts from: the landing slot's run count
- * and its own token/cost share (foldUsageEvent's landed/land_failed branch). Four shapes carry
- * them — DayFold, UsageFold, the scoped window totals, and the window totals — so the empty
- * triple lives once here and a new landing counter is added in one place. */
-function zeroLandingCounts() {
-    return { landingRuns: 0, landingTokens: 0, landingCostUsd: 0 };
-}
-/** Sum a per-loop-id count/cost map over one base role: instance keys (`feature-2`) fold into
- * their base (`feature`), so a scoped report aggregates a whole role group exactly as the
- * per-role cap's group does. Ticks/tokens/cost are keyed by exact loop id while commits are
- * already base-role keyed; running every key through `baseRoleOf` reads both shapes the same
- * and returns 0 when nothing matches. */
-function roleSum(record, role) {
-    let sum = 0;
-    for (const [key, n] of Object.entries(record)) {
-        if (baseRoleOf(key) === role)
-            sum += n;
-    }
-    return sum;
-}
-/** Narrow a per-loop-id count/cost map to one base role, keyed by the base role; a role absent
- * from the map (no ticks, or no nonzero cost) yields an empty map, never a zero entry — the
- * same zero-means-absent rule the fleet render applies. Used by the role-scoped collectors so a
- * scoped series derives from the fold's per-role maps without inventing entries. */
-function narrowToRole(record, role) {
-    const n = roleSum(record, role);
-    return n === 0 ? {} : { [role]: n };
-}
-function dayFoldFor(entry, dayKey) {
-    let fold = entry.days.get(dayKey);
-    if (!fold) {
-        fold = {
-            tokensOut: 0,
-            ...zeroCommitCounts(),
-            costUsd: 0,
-            notionalCostUsd: 0,
-            ticksByRole: {},
-            tokensByRole: {},
-            costByRole: {},
-            notionalByRole: {},
-            ...zeroLandingCounts(),
-        };
-        entry.days.set(dayKey, fold);
-    }
-    return fold;
-}
-/** Fold one already-parsed event into a cache entry: only in-window events (a non-null day
- * on or after fromKey) count, matching readWindowEvents's event list; the first such event
- * seen takes firstEventTs. The one home of the fold body, shared by the incremental append
- * path (foldLineInto) and the full re-read path, so the two can never drift. */
-function foldEventInto(entry, ev) {
-    const dayKey = eventDayKey(ev);
-    if (dayKey === null || dayKey < entry.fromKey)
-        return;
-    if (!entry.hadEvents) {
-        entry.hadEvents = true;
-        entry.firstEventTs = typeof ev.ts === "number" ? ev.ts : undefined;
-    }
-    foldUsageEvent(dayFoldFor(entry, dayKey), ev);
-}
-/** Parse one appended log line and fold it; a torn or non-event line folds nothing. */
-function foldLineInto(entry, line) {
-    const ev = parseEventLine(line);
-    if (ev)
-        foldEventInto(entry, ev);
-}
-/** The event-log half of collectReport, memoized: a dashboard re-fetching /api/report every
- * poll re-read and re-parsed the whole window's log bytes each time (~6.8 MB and tens of ms
- * on this repo's own day log, growing toward the 16 MB rotation cap). Now a request whose
- * log has not changed costs one stat; growth folds only the appended complete lines
- * (readCompleteLines holds back a torn trailing write, so it is folded whole next call).
- * Same size with a changed mtime, a shrunken file (rotation or rewrite), or a new fromKey
- * falls back to the full readWindowEvents pass — the fallback re-derives everything, so a
- * mis-fold can only come from the append assumption, and rotation's whole-file replace
- * always hits the shrink arm. The entry's coverage parts are pinned by the cache key:
- * fromKey and file bytes decide them, so an advancing window re-derives fresh instead of
- * carrying yesterday's proof forward. */
-function foldWindowEvents(root, fromKey) {
-    const key = `${root}\0${fromKey}`;
-    const liveStat = statOrNull(eventsLogPath(root));
-    const size = liveStat?.size ?? 0;
-    const mtimeMs = liveStat?.mtimeMs ?? 0;
-    const dev = liveStat?.dev ?? 0;
-    const ino = liveStat?.ino ?? 0;
-    const cached = reportFoldCache.get(key);
-    if (cached &&
-        sameStatIdentity({ dev, ino, mtimeMs, size }, { dev: cached.dev, ino: cached.ino, mtimeMs: cached.mtimeMs, size: cached.offset })) {
-        reportFoldCache.delete(key); // Refresh LRU position.
-        reportFoldCache.set(key, cached);
-        return cached;
-    }
-    if (cached && size > cached.offset && dev === cached.dev && ino === cached.ino) {
-        const { lines, end } = readCompleteLines(eventsLogPath(root), cached.offset, size);
-        if (end > cached.offset) {
-            for (const line of lines)
-                foldLineInto(cached, line);
-            cached.offset = end;
-            cached.mtimeMs = mtimeMs;
-            return cached;
-        }
-        // Grown but no complete line yet (a torn write in flight): reuse the folds; the next
-        // request sees the completed line and folds it then.
-        return cached;
-    }
-    const raw = readWindowEvents(root, fromKey);
-    const entry = {
-        root,
-        fromKey,
-        // The scan's own end, not the outer `size`: an event appended between that stat and the
-        // read is already folded, and seeding the offset from the stale size would fold it again
-        // on the next append (readTailTextWithEnd's coveredEnd is exactly where the scan stopped).
-        offset: raw.liveEnd,
-        mtimeMs,
-        dev,
-        ino,
-        fileCovers: raw.coversFullWindow,
-        hadEvents: false,
-        days: new Map(),
-    };
-    for (const ev of raw.events)
-        foldEventInto(entry, ev);
-    if (reportFoldCache.size >= REPORT_FOLD_CACHE_MAX) {
-        const oldest = reportFoldCache.keys().next().value;
-        if (oldest !== undefined)
-            reportFoldCache.delete(oldest);
-    }
-    reportFoldCache.set(key, entry);
-    return entry;
-}
-/** Aggregate fleet usage over the trailing `sinceMs` window ending now, from the event log
- * only (tick_end/merged — see SinceReport for why the backlog files are not read). Kept a
+import { foldUsageEvent, foldWindowEvents, narrowToRole, roleSum, scopedByRole, zeroCommitCounts, zeroMergeCounts, } from "./report-fold.js";
+/** Aggregate team usage over the trailing `sinceMs` window ending now, 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) {
@@ -220,8 +35,19 @@ export function collectReportSince(root, sinceMs, role) {
     const fromKey = dayKey(cutoff);
     const raw = readWindowEvents(root, fromKey);
     const acc = {
-        ticks: 0,
-        ticksByRole: {},
+        runs: 0,
+        runsByRole: {},
+        rejectionsByRole: {},
+        revisionsByRole: {},
+        refusalsByRole: {},
+        checkDurationsMs: [],
+        checkFailures: 0,
+        mergeWaitsMs: [],
+        providerWaitsMs: [],
+        slotWaitsMs: [],
+        failedRunsByRole: {},
+        fallbacksByRole: {},
+        imageReroutesByRole: {},
         tokensByRole: {},
         costByRole: {},
         tokensOut: 0,
@@ -229,7 +55,14 @@ export function collectReportSince(root, sinceMs, role) {
         costUsd: 0,
         notionalCostUsd: 0,
         notionalByRole: {},
-        ...zeroLandingCounts(),
+        ...zeroMergeCounts(),
+        mergedByRole: {},
+        mergeFailedByRole: {},
+        mergeFailedByReason: {},
+        costByProvider: {},
+        notionalByProvider: {},
+        runsByModel: {},
+        deferredByReason: {},
     };
     for (const ev of raw.events) {
         if (typeof ev.ts !== "number" || ev.ts < cutoff || ev.ts > now)
@@ -242,46 +75,81 @@ export function collectReportSince(root, sinceMs, role) {
     // 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 role alone
-    // — landing usage (the landing slot's, not the role's) and the fleet-only fields stay out, so
+    // — 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 role, so instances (`feature-2`) aggregate into their group as the cap does.
     const base = role === undefined ? undefined : baseRoleOf(role);
     const scopedTotals = base === undefined
         ? {
-            tokensOut: acc.tokensOut + (acc.landingTokens ?? 0),
-            ticks: acc.ticks ?? 0,
+            tokensOut: acc.tokensOut + (acc.mergeTokens ?? 0),
+            runs: acc.runs ?? 0,
             commits: acc.commits,
-            costUsd: acc.costUsd + (acc.landingCostUsd ?? 0),
+            costUsd: acc.costUsd + (acc.mergeCostUsd ?? 0),
             ...(acc.notionalCostUsd > 0 ? { notionalCostUsd: acc.notionalCostUsd } : {}),
-            landingRuns: acc.landingRuns ?? 0,
-            landingTokens: acc.landingTokens ?? 0,
-            landingCostUsd: acc.landingCostUsd ?? 0,
+            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 tick_end events; the landing slot's
-            // notional is fleet-wide and stays out like its cost.
+            // 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, base);
             return {
                 tokensOut: roleSum(acc.tokensByRole, base),
-                ticks: roleSum(acc.ticksByRole, base),
+                runs: roleSum(acc.runsByRole, base),
                 commits: roleSum(acc.commitsByRole, base),
                 costUsd: roleSum(acc.costByRole, base),
                 ...(notional > 0 ? { notionalCostUsd: notional } : {}),
-                ...zeroLandingCounts(),
+                ...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, base);
+    // 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, base);
     return {
         sinceMs,
         fromIso: new Date(cutoff).toISOString(),
         ...(base === undefined ? {} : { role: base }),
         totals: scopedTotals,
-        ticksByRole: base === undefined ? acc.ticksByRole : narrowToRole(acc.ticksByRole, base),
-        costByRole: base === undefined ? acc.costByRole : narrowToRole(acc.costByRole, base),
+        runsByRole: scopedByRole(acc.runsByRole, base),
+        costByRole: scopedByRole(acc.costByRole, base),
+        rejectionsByRole: scopedByRole(acc.rejectionsByRole, base),
+        revisionsByRole: scopedByRole(acc.revisionsByRole, base),
+        refusalsByRole: scopedByRole(acc.refusalsByRole, base),
+        failedRunsByRole: scopedByRole(acc.failedRunsByRole, base),
+        fallbacksByRole: scopedByRole(acc.fallbacksByRole, base),
+        imageReroutesByRole: scopedByRole(acc.imageReroutesByRole, base),
+        tokensByRole: scopedByRole(acc.tokensByRole, base),
+        commitsByRole: scopedByRole(acc.commitsByRole, base),
+        mergedByRole: scopedByRole(acc.mergedByRole, base),
+        mergeFailedByRole: scopedByRole(acc.mergeFailedByRole, base),
+        // 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, base),
+        ...(Object.keys(notionalByRole).length > 0 ? { 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, base),
+        notionalByProvider: scopedByRole(acc.notionalByProvider, base),
+        // 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, base),
+        ...(Object.keys(deferred).length > 0 ? { deferredByReason: deferred } : {}),
         coversFullWindow,
     };
 }
-/** Aggregate fleet usage over exactly `days` local calendar days ending today, from the event
- * log (tick_end/merged) and the backlog history files (PLANS.md ## Done, BUGS.md ## Fixed). */
+/** 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 now = new Date();
     // One captured instant for the whole window, so every day key derives from the same day.
@@ -291,7 +159,7 @@ export function collectReport(root, days, role) {
         series.push({
             date: formatDate(dayAt(i, now)),
             tokensOut: 0,
-            ticksByRole: {},
+            runsByRole: {},
             costByRole: {},
             ...zeroCommitCounts(),
             costUsd: 0,
@@ -309,8 +177,36 @@ export function collectReport(root, days, role) {
             continue; // Out-of-window day key (e.g. future-dated) — no series slot to fill.
         if (role === undefined) {
             day.tokensOut = fold.tokensOut;
-            day.ticksByRole = fold.ticksByRole;
+            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.
+            if (Object.keys(fold.rejectionsByRole).length > 0)
+                day.rejectionsByRole = fold.rejectionsByRole;
+            if (Object.keys(fold.revisionsByRole).length > 0)
+                day.revisionsByRole = fold.revisionsByRole;
+            if (Object.keys(fold.refusalsByRole).length > 0)
+                day.refusalsByRole = fold.refusalsByRole;
+            // Checks belong to the merge slot, so only the team series carries the median.
+            if (fold.checkDurationsMs.length > 0) {
+                day.checkMedianMs = lowerMedian(fold.checkDurationsMs);
+            }
+            if (fold.checkFailures > 0)
+                day.checkFailures = fold.checkFailures;
+            if (fold.mergeWaitsMs.length > 0)
+                day.mergeWaitMedianMs = lowerMedian(fold.mergeWaitsMs);
+            if (fold.providerWaitsMs.length > 0)
+                day.providerWaitMedianMs = lowerMedian(fold.providerWaitsMs);
+            // A workspace wait is the pool's, not a role's, so only the team series carries it.
+            if (fold.slotWaitsMs.length > 0)
+                day.slotWaitMedianMs = lowerMedian(fold.slotWaitsMs);
+            // Only set when nonzero, so a failure-free day keeps its exact pre-feature shape.
+            if (Object.keys(fold.failedRunsByRole).length > 0)
+                day.failedRunsByRole = fold.failedRunsByRole;
+            if (Object.keys(fold.fallbacksByRole).length > 0)
+                day.fallbacksByRole = fold.fallbacksByRole;
+            if (Object.keys(fold.imageReroutesByRole).length > 0)
+                day.imageReroutesByRole = fold.imageReroutesByRole;
             day.commits = fold.commits;
             day.commitsByRole = fold.commitsByRole;
             day.workCommits = fold.workCommits;
@@ -319,75 +215,178 @@ export function collectReport(root, days, role) {
             // Only set when nonzero, so zero-notional days keep their exact pre-feature shape.
             if (fold.notionalCostUsd > 0)
                 day.notionalCostUsd = fold.notionalCostUsd;
-            day.landingRuns = fold.landingRuns;
-            day.landingTokens = fold.landingTokens;
-            day.landingCostUsd = fold.landingCostUsd;
+            if (Object.keys(fold.notionalByRole).length > 0)
+                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.
+            if (Object.keys(fold.costByProvider).length > 0)
+                day.costByProvider = fold.costByProvider;
+            if (Object.keys(fold.notionalByProvider).length > 0)
+                day.notionalByProvider = fold.notionalByProvider;
+            // 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.
+            if (Object.keys(fold.runsByModel).length > 0)
+                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.
+            if (Object.keys(fold.deferredByReason).length > 0)
+                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.
+            if (Object.keys(fold.mergedByRole).length > 0)
+                day.mergedByRole = fold.mergedByRole;
+            if (Object.keys(fold.mergeFailedByRole).length > 0)
+                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.
+            if (Object.keys(fold.mergeFailedByReason).length > 0)
+                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 ticks/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 landing fields
-            // stay unset — landing runs are the landing slot's, not this role's — and the work /
+            // 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 base = baseRoleOf(role);
             const commits = roleSum(fold.commitsByRole, base);
             const tier = commitTier(base);
             day.tokensOut = roleSum(fold.tokensByRole, base);
-            day.ticksByRole = narrowToRole(fold.ticksByRole, base);
+            day.runsByRole = narrowToRole(fold.runsByRole, base);
+            day.tokensByRole = narrowToRole(fold.tokensByRole, base);
             day.costByRole = narrowToRole(fold.costByRole, base);
+            const rejs = narrowToRole(fold.rejectionsByRole, base);
+            if (Object.keys(rejs).length > 0)
+                day.rejectionsByRole = rejs;
+            const revs = narrowToRole(fold.revisionsByRole, base);
+            if (Object.keys(revs).length > 0)
+                day.revisionsByRole = revs;
+            const refusals = narrowToRole(fold.refusalsByRole, base);
+            if (Object.keys(refusals).length > 0)
+                day.refusalsByRole = refusals;
+            const fails = narrowToRole(fold.failedRunsByRole, base);
+            if (Object.keys(fails).length > 0)
+                day.failedRunsByRole = fails;
+            const falls = narrowToRole(fold.fallbacksByRole, base);
+            if (Object.keys(falls).length > 0)
+                day.fallbacksByRole = falls;
+            const reroutes = narrowToRole(fold.imageReroutesByRole, base);
+            if (Object.keys(reroutes).length > 0)
+                day.imageReroutesByRole = reroutes;
             day.commits = commits;
             day.commitsByRole = narrowToRole(fold.commitsByRole, base);
             day.workCommits = tier === "work" ? commits : 0;
             day.maintenanceCommits = tier === "maintenance" ? commits : 0;
             day.costUsd = roleSum(fold.costByRole, base);
             const notional = roleSum(fold.notionalByRole, base);
-            if (notional > 0)
+            if (notional > 0) {
                 day.notionalCostUsd = notional;
+                day.notionalByRole = narrowToRole(fold.notionalByRole, base);
+            }
+            // 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.
+            const mergeDone = narrowToRole(fold.mergedByRole, base);
+            if (Object.keys(mergeDone).length > 0)
+                day.mergedByRole = mergeDone;
+            const mergeDoneFailed = narrowToRole(fold.mergeFailedByRole, base);
+            if (Object.keys(mergeDoneFailed).length > 0)
+                day.mergeFailedByRole = mergeDoneFailed;
         }
     }
-    // The landing share joins its day's tokensOut/costUsd (the budget charges these same
+    // 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
-    // landing fields keep the reviewer's part of it visible on its own.
+    // merge fields keep the reviewer's part of it visible on its own.
     for (const d of series) {
-        d.tokensOut += d.landingTokens ?? 0;
-        d.costUsd += d.landingCostUsd ?? 0;
+        d.tokensOut += d.mergeTokens ?? 0;
+        d.costUsd += d.mergeCostUsd ?? 0;
     }
     const countOn = (date, field) => {
         const day = byDate.get(date);
         if (day)
-            day[field] += 1; // Out-of-window dates drop out here.
+            day[field] = (day[field] ?? 0) + 1; // Out-of-window dates drop out here.
     };
-    // Role scope leaves both tallies at zero: their dates are day-granular file metadata with no
-    // role, so a scoped report cannot attribute a completion (the render states the omission).
+    // Role scope leaves the day-granular backlog tallies at zero: their dates are day-granular
+    // file metadata with no role, so a scoped report cannot attribute a completion or a filing
+    // (the render states the omission).
+    if (role === undefined) {
+        // Finished entries sit in the live file's finished section and in its archive file
+        // (plans/backlog-archive.md); each per-file read is stat-cached.
+        for (const file of finishedFiles("PLANS.md")) {
+            for (const d of sectionCompletionDates(root, file, "Done", DONE_DATE_RE))
+                countOn(d, "featuresDone");
+        }
+        for (const file of finishedFiles("BUGS.md")) {
+            for (const d of sectionCompletionDates(root, file, "Fixed", FIXED_DATE_RE))
+                countOn(d, "bugsFixed");
+        }
+        // Fold the filing stamps too: plans/bugs that opened this day, over the same entry
+        // detection `entryDates` applies to the completion reads, so an entry's opened and done
+        // days are read the same way.
+        for (const d of sectionFilingDates(root, "PLANS.md", "Planned"))
+            countOn(d, "plansAdded");
+        for (const file of finishedFiles("PLANS.md")) {
+            for (const d of sectionFilingDates(root, file, "Done"))
+                countOn(d, "plansAdded");
+        }
+        for (const d of sectionFilingDates(root, "BUGS.md", "Open"))
+            countOn(d, "bugsFiled");
+        for (const file of finishedFiles("BUGS.md")) {
+            for (const d of sectionFilingDates(root, file, "Fixed"))
+                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.
+    const validationGaps = {};
     if (role === undefined) {
-        for (const d of sectionCompletionDates(root, "PLANS.md", "Done", /done (\d{4}-\d{2}-\d{2})/))
-            countOn(d, "featuresDone");
-        // The completion verbs track the phrasing the harness's own loops actually write: the
-        // bugfix prompt pins the date, not the verb, and the re-land flow's own epitaph —
-        // "re-landed <date>" on an entry whose first landing was rejected in review — is a
-        // completion the report must count (a rejected landing is not a fix, the re-land is).
-        // Body verbs without a date ("was fixed;") match nothing, and a bare "landed <date>"
-        // stays out: headings mention sibling landings, and a sibling's date is not this entry's.
-        for (const d of sectionCompletionDates(root, "BUGS.md", "Fixed", /\b(?:re-landed|fixed|closed|resolved) (\d{4}-\d{2}-\d{2})/))
-            countOn(d, "bugsFixed");
+        for (const e of fixedBugEntries(root)) {
+            const date = completionDate(e.title, FIXED_DATE_RE);
+            if (date === null || !byDate.has(date))
+                continue;
+            const tag = validationGapTag(e.body);
+            if (tag !== null) {
+                addTo(validationGaps, tag, 1);
+                addTo((byDate.get(date).validationGapsByTag ??= {}), tag, 1);
+            }
+        }
     }
     const totals = {
         tokensOut: 0,
-        ticks: 0,
+        runs: 0,
         ...zeroCommitCounts(),
         costUsd: 0,
         featuresDone: 0,
         bugsFixed: 0,
-        ...zeroLandingCounts(),
+        ...zeroMergeCounts(),
     };
     // Notional spend is kept out of the totals object until it is nonzero, so a pre-feature
-    // window's totals keep their exact shape.
+    // 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;
     for (const d of series) {
         totals.tokensOut += d.tokensOut;
-        for (const n of Object.values(d.ticksByRole))
-            totals.ticks += n;
+        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);
@@ -397,9 +396,12 @@ export function collectReport(root, days, role) {
         notionalCostUsd += d.notionalCostUsd ?? 0;
         totals.featuresDone += d.featuresDone;
         totals.bugsFixed += d.bugsFixed;
-        totals.landingRuns += d.landingRuns ?? 0;
-        totals.landingTokens += d.landingTokens ?? 0;
-        totals.landingCostUsd += d.landingCostUsd ?? 0;
+        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;
     }
     // 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,
@@ -408,7 +410,7 @@ export function collectReport(root, days, role) {
     // 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 fleet.
+    // number invites an operator to trust a truncated window as an idle team.
     const cutoffMs = dayAt(days - 1, now).getTime();
     const coversFullWindow = foldEntry.fileCovers ||
         !foldEntry.hadEvents ||
@@ -419,7 +421,14 @@ export function collectReport(root, days, role) {
         to,
         ...(role === undefined ? {} : { role: baseRoleOf(role) }),
         series,
-        totals: { ...totals, ...(notionalCostUsd > 0 ? { notionalCostUsd } : {}) },
+        totals: {
+            ...totals,
+            ...(notionalCostUsd > 0 ? { notionalCostUsd } : {}),
+            ...(mergeFailed > 0 ? { mergeFailed } : {}),
+            ...(plansAdded > 0 ? { plansAdded } : {}),
+            ...(bugsFiled > 0 ? { bugsFiled } : {}),
+            ...(Object.keys(validationGaps).length > 0 ? { validationGapsByTag: validationGaps } : {}),
+        },
         coversFullWindow,
     };
 }