@detergent-software/conductor 1.0.0-dev.12 → 1.0.0-dev.13

package/build/history.js

@@ -0,0 +1,630 @@
+import { z } from 'zod';
+import { ConductorError } from "./errors.js";
+import { formatTokens, localDay } from "./spend.js";
+import { ACTIVE_STATUSES } from "./store.js";
+// History and metrics (design note, build step 10): what a window of the log says about a run, as
+// `GET /history`, `conduct history` and `conduct retro`. It reads only what the daemon records
+// already (phase notes, waits, worker events, inbox items, rule events, spend) and writes nothing.
+// The notes that start a phase of work-issue's lifecycle. A phase lasts until the item's next one;
+// Handoff, Progress and Resumed notes fall inside a phase. Landed ends the item.
+export const LIFECYCLE_PHASES = ['Started', 'Done when', 'Repro', 'Plan', 'Plan approved', 'Verified', 'PR opened', 'Landed'];
+const LANDED = 'Landed';
+const FAILURE_KINDS = [
+    'worker.launch-failed',
+    'worker.resume-failed',
+    'worker.park-failed',
+    'worker.stopped-unexpectedly',
+    'worker.retire-refused',
+    'worker.retire-partial',
+    'worker.tab-failed',
+    'rule.failed',
+    'watcher.failed',
+    'wait.check-failed',
+    'notify.failed',
+    'scheduler.read-failed',
+];
+// A slot is held as the scheduler counts it (queue.ts): an active worker that isn't parked.
+const SLOT_EVENTS = {
+    'worker.attached': 'slot',
+    'worker.launch-failed': 'gone',
+    'worker.launched': 'slot',
+    'worker.launching': 'slot',
+    'worker.parked': 'parked',
+    'worker.resumed': 'slot',
+    'worker.retired': 'gone',
+    'worker.revived': 'slot',
+    'worker.running-again': 'slot',
+    'worker.stopped-unexpectedly': 'slot',
+};
+// What the manager writes when it ends a worker's waits itself (closeWaits): not a wait that held.
+const CLOSED_RESOLUTIONS = new Set(['launch failed', 'worker retired']);
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+// Text that names a whole day: as a range's end it runs through that day.
+const isDay = (t) => DATE.test(t) || t === 'today' || t === 'yesterday';
+const MINUTE_MS = 60_000;
+const DAY_MS = 24 * 60 * MINUTE_MS;
+const SPAN_UNITS = { d: DAY_MS, h: 60 * MINUTE_MS, m: MINUTE_MS };
+const durations = z.object({ count: z.number(), maxMinutes: z.number(), medianMinutes: z.number(), totalMinutes: z.number() });
+const counted = z.object({ count: z.number(), items: z.array(z.string()), kind: z.string() });
+export const historySchema = z.object({
+    failures: z.array(counted),
+    // Handoff notes by their kind (jason, npm-otp, merge, blocked …).
+    handoffs: z.array(counted),
+    inbox: z.array(z.object({ kind: z.string(), open: z.number(), raised: z.number(), resolve: durations, resolvedBy: z.record(z.string(), z.number()) })),
+    // Time in each phase, per item, by the item's plan tier ("?" without one).
+    phases: z.array(durations.extend({ phase: z.string(), tier: z.string() })),
+    // Each plan approved in the window, or still waiting at its end: from its newest Plan note.
+    plans: z.array(z.object({ approvedAt: z.string().nullable(), item: z.string(), minutes: z.number(), planAt: z.string(), project: z.string(), revisions: z.number(), tier: z.string() })),
+    range: z.object({ project: z.string().nullable(), since: z.string(), until: z.string() }),
+    // Items launched more than once in the window, and rule retries (worker.revived).
+    retries: z.object({ items: z.array(z.object({ item: z.string(), launches: z.number() })), revived: z.number() }),
+    rules: z.array(z.object({ done: z.number(), failed: z.number(), fired: z.number(), ref: z.string() })),
+    shipped: z.array(z.object({ item: z.string(), landedAt: z.string(), leadMinutes: z.number().nullable(), project: z.string(), title: z.string().nullable() })),
+    slots: z.object({
+        average: z.number(),
+        // Most running time first: a worker left attached and idle holds its slot all the while.
+        byItem: z.array(z.object({ item: z.string(), parkedHours: z.number(), project: z.string(), runningHours: z.number() })),
+        byProject: z.array(z.object({ parkedHours: z.number(), project: z.string(), runningHours: z.number() })),
+        parkedHours: z.number(),
+        peak: z.number(),
+        runningHours: z.number(),
+    }),
+    // Spend is kept per local day, so it covers the whole days the window touches.
+    spend: z.object({
+        byItem: z.array(z.object({ cacheRead: z.number(), item: z.string(), project: z.string(), tokens: z.number() })),
+        byProject: z.array(z.object({ cacheRead: z.number(), project: z.string(), tokens: z.number() })),
+        cacheRead: z.number(),
+        fromDay: z.string(),
+        toDay: z.string(),
+        tokens: z.number(),
+    }),
+    stalls: z.array(counted.extend({ maxMinutes: z.number() })),
+    totals: z.object({ daemonStarts: z.number(), items: z.number(), launches: z.number(), notes: z.number() }),
+    // Items whose newest lifecycle note at the window's end isn't Landed.
+    unfinished: z.array(z.object({ item: z.string(), phase: z.string(), project: z.string(), since: z.string(), title: z.string().nullable() })),
+    // Waits registered in the window by kind; open ones count up to the window's end.
+    waits: z.array(durations.extend({ closed: z.number(), kind: z.string(), open: z.number() })),
+});
+const noteData = z.looseObject({ kind: z.string().nullish(), phase: z.string(), tier: z.string().nullish() });
+const stallData = z.looseObject({ kind: z.string(), minutes: z.number().optional() });
+const workerData = z.looseObject({ probe: z.boolean().optional(), worker: z.number() });
+// `--since` and `--until`: each a time as parseWhen reads it, and `--until` a day runs through it.
+// Without --since, the window is the 24 hours before its end.
+export function flagWindow(since, until, now) {
+    const end = until === undefined ? now : rangeEnd(until, now);
+    const start = since === undefined ? new Date(Math.min(end.getTime(), now.getTime()) - DAY_MS) : parseWhen(since, now);
+    return checkedWindow({ since: start, until: end }, now, `--since ${since ?? '(24h before the end)'} --until ${until ?? 'now'}`);
+}
+// `conduct history`: the report in a screenful.
+export function historyLines(r) {
+    const lines = [
+        `history ${windowText(r)}`,
+        `items ${r.totals.items} · notes ${r.totals.notes} · launches ${r.totals.launches} · daemon starts ${r.totals.daemonStarts}`,
+        `shipped ${r.shipped.length}${r.shipped.length > 0 ? `: ${r.shipped.map((s) => s.item).join(', ')}` : ''}`,
+    ];
+    const approved = r.plans.filter((p) => p.approvedAt !== null);
+    const pending = r.plans.filter((p) => p.approvedAt === null);
+    const planStats = summarize(approved.map((p) => p.minutes));
+    lines.push(`plans: ${approved.length} approved${approved.length > 0 ? `, median ${minutesText(planStats.medianMinutes)}, max ${minutesText(planStats.maxMinutes)}` : ''}` +
+        (pending.length > 0 ? `; waiting: ${pending.map((p) => `${p.item} ${minutesText(p.minutes)}`).join(', ')}` : ''));
+    lines.push(r.waits.length === 0 ? 'waits: none' : 'waits:');
+    r.waits.forEach((w) => lines.push(`  ${w.kind.padEnd(8)} ${w.count} · median ${minutesText(w.medianMinutes)} · max ${minutesText(w.maxMinutes)} · total ${minutesText(w.totalMinutes)}${w.open > 0 ? ` · ${w.open} open` : ''}`));
+    for (const tier of unique(r.phases.map((p) => p.tier))) {
+        lines.push(`phases (tier ${tier}): ${r.phases.filter((p) => p.tier === tier).map((p) => `${p.phase} ${minutesText(p.medianMinutes)}`).join(' · ')} (median per item)`);
+    }
+    lines.push(`stalls: ${r.stalls.length === 0 ? 'none' : r.stalls.map((s) => `${s.kind} ${s.count} (max ${minutesText(s.maxMinutes)})`).join(', ')}`);
+    lines.push(`handoffs: ${r.handoffs.length === 0 ? 'none' : r.handoffs.map((h) => `${h.kind} ${h.count}`).join(', ')}`);
+    lines.push(`failures: ${r.failures.length === 0 ? 'none' : r.failures.map((f) => `${f.kind} ${f.count}`).join(', ')}`);
+    if (r.retries.items.length > 0 || r.retries.revived > 0) {
+        lines.push(`retries: ${[...r.retries.items.map((i) => `${i.item} launched ${i.launches}×`), ...(r.retries.revived > 0 ? [`${r.retries.revived} revived`] : [])].join(', ')}`);
+    }
+    lines.push(`inbox: ${r.inbox.length === 0 ? 'none' : r.inbox.map((i) => `${i.kind} ${i.raised}${i.open > 0 ? ` (${i.open} open)` : ''}`).join(', ')}`);
+    lines.push(`slots: peak ${r.slots.peak}, average ${r.slots.average.toFixed(1)}, running ${r.slots.runningHours.toFixed(1)} h, parked ${r.slots.parkedHours.toFixed(1)} h` +
+        (r.slots.byItem.length > 0 ? `; longest held: ${r.slots.byItem.slice(0, 3).map((s) => `${s.item} ${s.runningHours.toFixed(1)} h`).join(', ')}` : ''));
+    lines.push(`spend (${r.spend.fromDay}..${r.spend.toDay}): ${formatTokens(r.spend.tokens)} tokens + ${formatTokens(r.spend.cacheRead)} cache reads` +
+        (r.spend.byItem.length > 0 ? `; most: ${r.spend.byItem.slice(0, 5).map((s) => `${s.item} ${formatTokens(s.tokens)}`).join(', ')}` : ''));
+    lines.push(`rules: ${r.rules.length === 0 ? 'none fired' : r.rules.slice(0, 5).map((x) => `${x.ref} ${x.fired}`).join(', ')}`);
+    if (r.unfinished.length > 0)
+        lines.push(`unfinished: ${r.unfinished.map((u) => `${u.item} (${u.phase})`).join(', ')}`);
+    return lines;
+}
+export function historyReport(store, { project = null, since, until }) {
+    const sinceMs = Date.parse(since);
+    const untilMs = Date.parse(until);
+    const inProject = (p) => project === null || p === project;
+    const scope = project === null ? {} : { project };
+    const events = store.eventsBetween({ since, until }, scope);
+    const titles = store.itemTitles();
+    const titleOf = (p, item) => titles.get(key(p, item)) ?? null;
+    const workers = store.workersBetween(since, until).filter((w) => !w.probe && inProject(w.project));
+    // Every note of the items worked in the window, from the start, so phases and plans that began
+    // before it are seen whole.
+    const subjects = unique([
+        ...events.flatMap((e) => (e.kind === 'note.posted' && e.subject ? [e.subject.toUpperCase()] : [])),
+        ...workers.map((w) => w.item.toUpperCase()),
+    ]);
+    const notes = subjects.length === 0 ? [] : store.eventsBetween({ since: null, until }, { ...scope, kinds: ['note.posted'], subjects }).flatMap(toNote);
+    const byItem = groupBy(notes, (n) => key(n.project, n.item));
+    const inWindow = (at) => at >= since && at < until;
+    const phaseMinutes = new Map();
+    const plans = [];
+    const shipped = [];
+    const unfinished = [];
+    // Work on an item stops when its last worker does: an abandoned item's open phase ends there,
+    // not at the window's end.
+    const endOf = (k) => {
+        const own = workers.filter((w) => key(w.project, w.item) === k);
+        if (own.length === 0 || own.some((w) => ACTIVE_STATUSES.includes(w.status)))
+            return untilMs;
+        return Math.min(untilMs, Math.max(...own.map((w) => Date.parse(w.stoppedAt ?? w.updatedAt))));
+    };
+    for (const [k, itemNotes] of byItem) {
+        const lifecycle = itemNotes.filter((n) => LIFECYCLE_PHASES.includes(n.phase));
+        const tier = itemNotes.findLast((n) => n.phase === 'Plan' && n.tier)?.tier ?? '?';
+        // A note after the last worker stopped means someone carried on: the phase stays open.
+        const lastAt = Date.parse(lifecycle.at(-1)?.at ?? since);
+        const stopped = endOf(k);
+        const end = stopped >= lastAt ? stopped : untilMs;
+        const spent = new Map();
+        lifecycle.forEach((n, i) => {
+            if (n.phase === LANDED)
+                return;
+            const next = lifecycle[i + 1];
+            const minutes = overlapMinutes(Date.parse(n.at), next ? Date.parse(next.at) : end, sinceMs, untilMs);
+            if (minutes > 0)
+                spent.set(n.phase, (spent.get(n.phase) ?? 0) + minutes);
+        });
+        for (const [phase, minutes] of spent)
+            push(phaseMinutes, `${tier}|${phase}`, minutes);
+        let plan = null;
+        let revisions = 0;
+        for (const n of lifecycle) {
+            if (n.phase === 'Plan') {
+                if (plan)
+                    revisions++;
+                plan = n;
+            }
+            else if (n.phase === 'Plan approved' && plan) {
+                if (inWindow(n.at))
+                    plans.push({ approvedAt: n.at, item: n.item, minutes: minutesBetween(plan.at, n.at), planAt: plan.at, project: n.project, revisions, tier });
+                plan = null;
+                revisions = 0;
+            }
+            else if (plan) {
+                // Any other lifecycle note leaves the plan behind: past it with no Plan approved note (the
+                // approval wasn't recorded), or a fresh start (Started, Repro) that abandoned it.
+                plan = null;
+                revisions = 0;
+            }
+        }
+        if (plan && end === untilMs) {
+            plans.push({ approvedAt: null, item: plan.item, minutes: minutesBetween(plan.at, until), planAt: plan.at, project: plan.project, revisions, tier });
+        }
+        const last = lifecycle.at(-1);
+        const landed = lifecycle.findLast((n) => n.phase === LANDED);
+        if (landed && inWindow(landed.at)) {
+            const started = lifecycle.find((n) => n.phase === 'Started');
+            shipped.push({
+                item: landed.item,
+                landedAt: landed.at,
+                leadMinutes: started ? minutesBetween(started.at, landed.at) : null,
+                project: landed.project,
+                title: titleOf(landed.project, landed.item),
+            });
+        }
+        if (last && last.phase !== LANDED) {
+            unfinished.push({ item: last.item, phase: last.phase, project: last.project, since: last.at, title: titleOf(last.project, last.item) });
+        }
+    }
+    const phases = [...phaseMinutes].map(([k, minutes]) => {
+        const [tier = '?', phase = ''] = k.split('|');
+        return { phase, tier, ...summarize(minutes) };
+    });
+    phases.sort((a, b) => a.tier.localeCompare(b.tier) || phaseOrder(a.phase) - phaseOrder(b.phase));
+    const windowNotes = events.flatMap((e) => (e.kind === 'note.posted' && inWindow(e.at) ? toNote(e) : []));
+    const launches = events.filter((e) => e.kind === 'worker.launching' && workerData.safeParse(e.data).data?.probe !== true);
+    return {
+        failures: countBy(events.filter((e) => FAILURE_KINDS.includes(e.kind)), (e) => e.kind),
+        handoffs: countBy(windowNotes.filter((n) => n.phase === 'Handoff').map((n) => ({ kind: n.kind ?? 'other', subject: n.item })), (n) => n.kind),
+        inbox: inboxStats(store, since, until, inProject),
+        phases,
+        plans: plans.sort((a, b) => a.planAt.localeCompare(b.planAt)),
+        range: { project, since, until },
+        retries: {
+            items: [...groupBy(launches, (e) => (e.subject ?? '').toUpperCase())]
+                .filter(([, list]) => list.length > 1)
+                .map(([item, list]) => ({ item, launches: list.length })),
+            revived: events.filter((e) => e.kind === 'worker.revived').length,
+        },
+        rules: ruleStats(events),
+        shipped: shipped.sort((a, b) => a.landedAt.localeCompare(b.landedAt)),
+        slots: slotUse(store, workers, sinceMs, untilMs, until),
+        spend: spendStats(store, since, until, inProject),
+        stalls: stallStats(events),
+        totals: {
+            daemonStarts: store.eventsBetween({ since, until }, { kinds: ['daemon.started'] }).length,
+            items: unique(windowNotes.map((n) => key(n.project, n.item))).length,
+            launches: launches.length,
+            notes: windowNotes.length,
+        },
+        unfinished: unfinished.sort((a, b) => a.since.localeCompare(b.since)),
+        waits: waitStats(store.waitsRegisteredBetween(since, until).filter((w) => !w.probe && inProject(w.project)), until),
+    };
+}
+// 0.5 → <1m, 42 → 42m, 125 → 2h 05m, 1600 → 1d 2h.
+export function minutesText(minutes) {
+    if (minutes < 1)
+        return '<1m';
+    const m = Math.round(minutes);
+    if (m < 60)
+        return `${m}m`;
+    if (m < 24 * 60)
+        return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, '0')}m`;
+    return `${Math.floor(m / (24 * 60))}d ${Math.floor((m % (24 * 60)) / 60)}h`;
+}
+// A window for `conduct history` and `retro`: none (the last 24 hours), `today`, `yesterday`, a date
+// (that day), `A..B` (B a date: through that day), a span such as `24h` or `7d` (up to now), or a
+// date and time (up to now).
+export function parseRange(text, now) {
+    return checkedWindow(rangeOf(text?.trim() || '24h', now), now, `"${text ?? ''}"`);
+}
+// One point in time: `now`, `today`, `yesterday`, a date (its start), a date and time (local), or a
+// span back from now such as `90m`, `24h` or `7d`.
+export function parseWhen(text, now) {
+    const t = text.trim();
+    if (t === 'now')
+        return now;
+    if (t === 'today')
+        return dayStart(now);
+    if (t === 'yesterday')
+        return addDays(dayStart(now), -1);
+    const span = /^(\d+)([mhd])$/.exec(t);
+    const unit = SPAN_UNITS[span?.[2] ?? ''];
+    if (span && unit !== undefined)
+        return new Date(now.getTime() - Number(span[1]) * unit);
+    const date = /^(\d{4})-(\d{2})-(\d{2})$/.exec(t);
+    if (date)
+        return new Date(Number(date[1]), Number(date[2]) - 1, Number(date[3]));
+    const at = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(t) ? new Date(t) : null;
+    if (!at || Number.isNaN(at.getTime())) {
+        throw new ConductorError(`"${text}" is not a time`, ['use today, yesterday, a date (2026-10-10), a date and time (2026-10-10T09:00), or a span such as 24h or 7d']);
+    }
+    return at;
+}
+// How an inbox item was resolved, from its `resolved_by`.
+export function resolvedHow(by) {
+    const command = /\(conduct (\w+)/.exec(by)?.[1];
+    if (command)
+        return `conduct ${command}`;
+    if (/ note$/.test(by))
+        return 'a later note';
+    if (/ retired$/.test(by))
+        return 'worker retired';
+    return 'condition seen';
+}
+// `conduct retro`: the report as Markdown, for the console to read or post.
+export function retroMarkdown(r) {
+    const out = [`# Conductor retro: ${windowText(r)}`, ''];
+    const approved = r.plans.filter((p) => p.approvedAt !== null);
+    const planStats = summarize(approved.map((p) => p.minutes));
+    const waitTotal = r.waits.reduce((n, w) => n + w.totalMinutes, 0);
+    out.push(`- **Shipped:** ${r.shipped.length} of ${r.totals.items} items worked (${r.totals.launches} launches, ${r.totals.notes} phase notes, ${r.totals.daemonStarts} daemon starts).`, `- **Plan latency:** ${approved.length === 0 ? 'no plan approved' : `median ${minutesText(planStats.medianMinutes)}, max ${minutesText(planStats.maxMinutes)} over ${approved.length} plans`}${r.plans.some((p) => p.approvedAt === null) ? `; ${r.plans.filter((p) => p.approvedAt === null).length} still waiting` : ''}.`, `- **Waiting:** ${minutesText(waitTotal)} across ${r.waits.reduce((n, w) => n + w.count, 0)} waits${r.waits[0] ? `, most on ${r.waits[0].kind} (${minutesText(r.waits[0].totalMinutes)})` : ''}.`, `- **Stalls:** ${r.stalls.reduce((n, s) => n + s.count, 0)} stall events, ${r.handoffs.reduce((n, h) => n + h.count, 0)} handoffs, ${r.failures.reduce((n, f) => n + f.count, 0)} failures.`, `- **Spend:** ${formatTokens(r.spend.tokens)} tokens (input, output and cache writes) and ${formatTokens(r.spend.cacheRead)} cache reads, ${r.spend.fromDay} to ${r.spend.toDay}.`, `- **Slots:** peak ${r.slots.peak} running, average ${r.slots.average.toFixed(1)}; ${r.slots.runningHours.toFixed(1)} h running, ${r.slots.parkedHours.toFixed(1)} h parked${r.slots.byItem[0] ? `; longest held by ${r.slots.byItem[0].item} (${r.slots.byItem[0].runningHours.toFixed(1)} h)` : ''}.`, '');
+    section(out, 'What shipped', r.shipped.length === 0 ? ['Nothing landed in this window.'] : table(['Item', 'Title', 'Landed', 'Started → Landed'], r.shipped.map((s) => [s.item, s.title ?? '', localTime(s.landedAt), s.leadMinutes === null ? '' : minutesText(s.leadMinutes)])));
+    section(out, 'Where time went', r.phases.length === 0 ? ['No lifecycle notes in this window.'] : [
+        'Time from each lifecycle note to the item\'s next one, inside the window, per item. A phase is named by the note that starts it: *Plan* is waiting for approval, *Plan approved* is implementing, *Verified* is opening the PR, *PR opened* is review through merge.',
+        '',
+        ...table(['Tier', 'Phase', 'Items', 'Median', 'Max', 'Total'], r.phases.map((p) => [p.tier, p.phase, String(p.count), minutesText(p.medianMinutes), minutesText(p.maxMinutes), minutesText(p.totalMinutes)])),
+    ]);
+    section(out, 'Plan latency', r.plans.length === 0 ? ['No plans in this window.'] : [
+        'From the newest Plan note to Plan approved (a revision restarts it).',
+        '',
+        ...table(['Item', 'Tier', 'Plan', 'Approved', 'Waited', 'Revisions'], r.plans.map((p) => [p.item, p.tier, localTime(p.planAt), p.approvedAt === null ? 'still waiting' : localTime(p.approvedAt), minutesText(p.minutes), String(p.revisions)])),
+    ]);
+    section(out, 'Waits', r.waits.length === 0 ? ['No waits registered in this window.'] : [
+        'Waits registered in the window, by what they held up. A PR event that resolves several waits counts once.',
+        '',
+        ...table(['Kind', 'Waits', 'Median', 'Max', 'Total', 'Open', 'Closed'], r.waits.map((w) => [w.kind, String(w.count), minutesText(w.medianMinutes), minutesText(w.maxMinutes), minutesText(w.totalMinutes), String(w.open), String(w.closed)])),
+    ]);
+    const stalled = [
+        ...r.stalls.map((s) => `- Stalled (${s.kind}): ${s.count}× on ${s.items.join(', ')}, longest ${minutesText(s.maxMinutes)}.`),
+        ...r.handoffs.map((h) => `- Handoff · ${h.kind}: ${h.count}× on ${h.items.join(', ')}.`),
+        ...r.failures.map((f) => `- ${f.kind}: ${f.count}×${f.items.length > 0 ? ` on ${f.items.join(', ')}` : ''}.`),
+        ...r.retries.items.map((i) => `- ${i.item} launched ${i.launches} times.`),
+        ...(r.retries.revived > 0 ? [`- ${r.retries.revived} worker(s) revived by a rule.`] : []),
+        ...r.unfinished.map((u) => `- Unfinished: ${u.item} in ${u.phase} since ${localTime(u.since)}${u.title ? ` (${u.title})` : ''}.`),
+    ];
+    section(out, 'What stalled', stalled.length === 0 ? ['Nothing stalled, failed or was left unfinished.'] : stalled);
+    section(out, 'Inbox', r.inbox.length === 0 ? ['Nothing was raised for Jason.'] : table(['Kind', 'Raised', 'Open', 'Median to resolve', 'Max', 'Resolved by'], r.inbox.map((i) => [
+        i.kind,
+        String(i.raised),
+        String(i.open),
+        i.resolve.count === 0 ? '' : minutesText(i.resolve.medianMinutes),
+        i.resolve.count === 0 ? '' : minutesText(i.resolve.maxMinutes),
+        Object.entries(i.resolvedBy).map(([how, n]) => `${how} ${n}`).join(', '),
+    ])));
+    section(out, 'Rules', r.rules.length === 0 ? ['No rule fired.'] : table(['Rule', 'Fired', 'Done', 'Failed'], r.rules.map((x) => [x.ref, String(x.fired), String(x.done), String(x.failed)])));
+    section(out, 'Spend', [
+        `Kept per local day, so this covers ${r.spend.fromDay} to ${r.spend.toDay}. Tokens are input, output and cache writes; cache reads (about a tenth of the price) are their own column.`,
+        '',
+        ...table(['Project', 'Tokens', 'Cache reads'], r.spend.byProject.map((p) => [p.project, formatTokens(p.tokens), formatTokens(p.cacheRead)])),
+        '',
+        ...table(['Item', 'Tokens', 'Cache reads'], r.spend.byItem.slice(0, 15).map((s) => [s.item, formatTokens(s.tokens), formatTokens(s.cacheRead)])),
+    ]);
+    section(out, 'Slots', [
+        'A slot is held as the scheduler counts it: an active worker that isn\'t parked, including one attached and idle, or stopped unexpectedly and not yet retired.',
+        '',
+        ...table(['Project', 'Running', 'Parked'], r.slots.byProject.map((p) => [p.project, `${p.runningHours.toFixed(1)} h`, `${p.parkedHours.toFixed(1)} h`])),
+        '',
+        ...table(['Item', 'Running', 'Parked'], r.slots.byItem.slice(0, 10).map((s) => [s.item, `${s.runningHours.toFixed(1)} h`, `${s.parkedHours.toFixed(1)} h`])),
+    ]);
+    return `${out.join('\n').trimEnd()}\n`;
+}
+// What a wait held up, from its condition, or for a PR from what resolved it: one PR event often
+// resolves the merged, checks and comment waits together.
+export function waitKind(condition, resolution) {
+    const [type = 'other'] = condition.split(':');
+    switch (type) {
+        case 'approval':
+            return 'plan';
+        case 'npm':
+            return 'npm-otp';
+        case 'pr': {
+            const outcome = resolution ?? condition;
+            if (/\bmerged\b/.test(outcome))
+                return 'merge';
+            if (/\bchecks\b/.test(outcome))
+                return 'checks';
+            if (/\bcomment\b/.test(outcome))
+                return 'review';
+            return 'pr';
+        }
+        case 'run':
+            return 'ci';
+        default:
+            return type;
+    }
+}
+function addDays(date, days) {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate() + days, date.getHours(), date.getMinutes());
+}
+// A window can't reach past now (`..today` ends now, not at midnight), and must not be empty.
+function checkedWindow(found, now, what) {
+    const range = { since: found.since, until: found.until > now ? now : found.until };
+    if (range.since.getTime() >= range.until.getTime())
+        throw new ConductorError(`${what} is an empty window: its start is not before its end`);
+    return range;
+}
+function countBy(list, kindOf) {
+    return [...groupBy(list, kindOf)]
+        .map(([kind, all]) => ({ count: all.length, items: unique(all.flatMap((e) => (e.subject ? [e.subject.toUpperCase()] : []))), kind }))
+        .sort((a, b) => b.count - a.count || a.kind.localeCompare(b.kind));
+}
+function dayStart(date) {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+function groupBy(list, keyOf) {
+    const groups = new Map();
+    for (const t of list)
+        push(groups, keyOf(t), t);
+    return groups;
+}
+function inboxStats(store, since, until, inProject) {
+    const items = store.inboxRaisedBetween(since, until).filter((i) => inProject(i.project));
+    return [...groupBy(items, (i) => i.kind)]
+        .map(([kind, list]) => {
+        const resolvedBy = {};
+        for (const i of list)
+            if (i.resolvedBy)
+                resolvedBy[resolvedHow(i.resolvedBy)] = (resolvedBy[resolvedHow(i.resolvedBy)] ?? 0) + 1;
+        return {
+            kind,
+            open: list.filter((i) => i.resolvedAt === null).length,
+            raised: list.length,
+            resolve: summarize(list.flatMap((i) => (i.resolvedAt ? [minutesBetween(i.raisedAt, i.resolvedAt)] : []))),
+            resolvedBy,
+        };
+    })
+        .sort((a, b) => b.raised - a.raised || a.kind.localeCompare(b.kind));
+}
+function key(project, item) {
+    return `${project}|${item.toUpperCase()}`;
+}
+function localTime(at) {
+    const d = new Date(at);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${localDay(d)} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function minutesBetween(from, to) {
+    return Math.max(0, (Date.parse(to) - Date.parse(from)) / MINUTE_MS);
+}
+// The minutes of [from, to) that fall inside [since, until).
+function overlapMinutes(from, to, since, until) {
+    return Math.max(0, Math.min(to, until) - Math.max(from, since)) / MINUTE_MS;
+}
+function phaseOrder(phase) {
+    return LIFECYCLE_PHASES.indexOf(phase);
+}
+function push(map, k, value) {
+    const list = map.get(k);
+    if (list)
+        list.push(value);
+    else
+        map.set(k, [value]);
+}
+// The end of a range: a day (a date, today, yesterday) runs through that day; a time is itself.
+function rangeEnd(text, now) {
+    const t = text.trim();
+    const end = parseWhen(t, now);
+    return isDay(t) ? addDays(end, 1) : end;
+}
+function rangeOf(t, now) {
+    if (t.includes('..')) {
+        const [from = '', to = ''] = t.split('..');
+        return { since: parseWhen(from, now), until: to.trim() === '' ? now : rangeEnd(to, now) };
+    }
+    if (t === 'today')
+        return { since: dayStart(now), until: now };
+    if (t === 'yesterday')
+        return { since: addDays(dayStart(now), -1), until: dayStart(now) };
+    if (DATE.test(t)) {
+        const since = parseWhen(t, now);
+        return { since, until: addDays(since, 1) };
+    }
+    return { since: parseWhen(t, now), until: now };
+}
+function ruleStats(events) {
+    const rules = new Map();
+    for (const e of events) {
+        if (!e.rule || !['rule.done', 'rule.failed', 'rule.fired'].includes(e.kind))
+            continue;
+        const entry = rules.get(e.rule) ?? { done: 0, failed: 0, fired: 0, ref: e.rule };
+        if (e.kind === 'rule.fired')
+            entry.fired++;
+        else if (e.kind === 'rule.done')
+            entry.done++;
+        else
+            entry.failed++;
+        rules.set(e.rule, entry);
+    }
+    return [...rules.values()].sort((a, b) => b.fired - a.fired || a.ref.localeCompare(b.ref));
+}
+function section(out, title, body) {
+    out.push(`## ${title}`, '', ...body, '');
+}
+// Running and parked time, as the scheduler counts slots, integrated over the window.
+function slotUse(store, workers, sinceMs, untilMs, until) {
+    const workerOf = new Map(workers.map((w) => [w.id, w]));
+    const events = workers.length === 0 ? [] : store.eventsBetween({ since: null, until }, { kinds: Object.keys(SLOT_EVENTS), workers: workers.map((w) => w.id) });
+    const state = new Map();
+    const byProject = new Map();
+    const byItem = new Map();
+    const add = (map, k, s, ms) => {
+        const entry = map.get(k) ?? { parked: 0, running: 0 };
+        if (s === 'slot')
+            entry.running += ms;
+        else
+            entry.parked += ms;
+        map.set(k, entry);
+    };
+    let peak = 0;
+    let runningMs = 0;
+    let parkedMs = 0;
+    let t = sinceMs;
+    const advance = (to) => {
+        if (to <= t)
+            return;
+        const running = [...state.values()].filter((s) => s === 'slot').length;
+        peak = Math.max(peak, running);
+        runningMs += running * (to - t);
+        parkedMs += (state.size - running) * (to - t);
+        for (const [id, s] of state) {
+            const w = workerOf.get(id);
+            add(byProject, w?.project ?? '?', s, to - t);
+            add(byItem, key(w?.project ?? '?', w?.item ?? '?'), s, to - t);
+        }
+        t = to;
+    };
+    for (const e of events) {
+        advance(Math.max(Date.parse(e.at), sinceMs));
+        const worker = workerData.safeParse(e.data).data?.worker;
+        const next = SLOT_EVENTS[e.kind];
+        if (worker === undefined || next === undefined)
+            continue;
+        if (next === 'gone')
+            state.delete(worker);
+        else
+            state.set(worker, next);
+    }
+    advance(untilMs);
+    const toHours = (ms) => Math.round((ms / 3_600_000) * 10) / 10;
+    return {
+        average: untilMs > sinceMs ? Math.round((runningMs / (untilMs - sinceMs)) * 100) / 100 : 0,
+        byItem: [...byItem]
+            .map(([k, h]) => {
+            const [project = '?', item = '?'] = k.split('|');
+            return { item, parkedHours: toHours(h.parked), project, runningHours: toHours(h.running) };
+        })
+            .sort((a, b) => b.runningHours - a.runningHours || a.item.localeCompare(b.item)),
+        byProject: [...byProject].map(([project, h]) => ({ parkedHours: toHours(h.parked), project, runningHours: toHours(h.running) })).sort((a, b) => a.project.localeCompare(b.project)),
+        parkedHours: toHours(parkedMs),
+        peak,
+        runningHours: toHours(runningMs),
+    };
+}
+function spendStats(store, since, until, inProject) {
+    const fromDay = localDay(new Date(since));
+    const toDay = localDay(new Date(Date.parse(until) - 1));
+    const rows = store.spendBetween(fromDay, toDay).filter((r) => inProject(r.project));
+    const tokensOf = (r) => r.input + r.output + r.cacheWrite;
+    const sum = (list) => ({
+        cacheRead: list.reduce((n, r) => n + r.cacheRead, 0),
+        tokens: list.reduce((n, r) => n + tokensOf(r), 0),
+    });
+    return {
+        byItem: [...groupBy(rows, (r) => key(r.project, r.item))]
+            .map(([, list]) => ({ item: list[0]?.item.toUpperCase() ?? '', project: list[0]?.project ?? '', ...sum(list) }))
+            .sort((a, b) => b.tokens - a.tokens),
+        byProject: [...groupBy(rows, (r) => r.project)].map(([p, list]) => ({ project: p, ...sum(list) })).sort((a, b) => b.tokens - a.tokens),
+        ...sum(rows),
+        fromDay,
+        toDay,
+    };
+}
+function stallStats(events) {
+    const stalls = events.flatMap((e) => {
+        const data = e.kind === 'worker.stalled' ? stallData.safeParse(e.data).data : undefined;
+        return data ? [{ kind: data.kind, minutes: data.minutes ?? 0, subject: e.subject }] : [];
+    });
+    return countBy(stalls, (s) => s.kind).map((c) => ({ ...c, maxMinutes: Math.max(0, ...stalls.filter((s) => s.kind === c.kind).map((s) => s.minutes)) }));
+}
+function summarize(minutes) {
+    const sorted = [...minutes].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    const median = sorted.length === 0 ? 0 : sorted.length % 2 === 1 ? (sorted[mid] ?? 0) : ((sorted[mid - 1] ?? 0) + (sorted[mid] ?? 0)) / 2;
+    const round = (n) => Math.round(n * 10) / 10;
+    return { count: sorted.length, maxMinutes: round(sorted.at(-1) ?? 0), medianMinutes: round(median), totalMinutes: round(sorted.reduce((n, m) => n + m, 0)) };
+}
+function table(head, rows) {
+    const cell = (s) => s.replaceAll('|', '\\|');
+    return [`| ${head.join(' | ')} |`, `| ${head.map(() => '---').join(' | ')} |`, ...rows.map((r) => `| ${r.map(cell).join(' | ')} |`)];
+}
+function toNote(e) {
+    const data = noteData.safeParse(e.data).data;
+    if (!data || !e.subject || !e.project)
+        return [];
+    return [{ at: e.at, item: e.subject.toUpperCase(), kind: data.kind ?? null, phase: data.phase, project: e.project, tier: data.tier ?? null }];
+}
+function unique(list) {
+    return [...new Set(list)];
+}
+function waitStats(waits, until) {
+    const seen = new Set();
+    const kept = waits.filter((w) => {
+        if (w.resolution === null || CLOSED_RESOLUTIONS.has(w.resolution))
+            return true;
+        const k = `${w.worker}|${w.resolution}`;
+        if (seen.has(k))
+            return false;
+        seen.add(k);
+        return true;
+    });
+    // A closed wait's resolution says nothing about what it waited on: its condition does.
+    return [...groupBy(kept, (w) => waitKind(w.condition, w.resolution !== null && CLOSED_RESOLUTIONS.has(w.resolution) ? null : w.resolution))]
+        .map(([kind, list]) => {
+        // A wait resolved (or closed) after the window was still open at its end, and counts up to it.
+        const endOf = (w) => (w.resolvedAt !== null && w.resolvedAt < until ? w.resolvedAt : until);
+        const closed = list.filter((w) => w.resolution !== null && CLOSED_RESOLUTIONS.has(w.resolution) && endOf(w) !== until);
+        const timed = list.filter((w) => !closed.includes(w));
+        return {
+            closed: closed.length,
+            kind,
+            open: timed.filter((w) => endOf(w) === until).length,
+            ...summarize(timed.map((w) => minutesBetween(w.createdAt, endOf(w)))),
+        };
+    })
+        .sort((a, b) => b.totalMinutes - a.totalMinutes || a.kind.localeCompare(b.kind));
+}
+function windowText(r) {
+    return `${localTime(r.range.since)} → ${localTime(r.range.until)}${r.range.project ? ` (${r.range.project})` : ' (all projects)'}`;
+}
+//# sourceMappingURL=history.js.map