tinybeeai 0.0.0-stage → 0.16.1

package/dist/dot-health.js

@@ -0,0 +1,966 @@
+// The health panel of a dot (KAT-394). GET /api/dots/:id/health answers one question at a glance: does this dot need me?
+// Everything comes from rows the dot already stores, so the endpoint calls no model and no tracker.
+//
+// Two layers. `readHealthInput` reads the rows in one pass. `computeHealth` is pure over that input and a fixed clock, so every
+// status rule, every suggestion rule, and every Not set up path has a unit test that builds an input by hand.
+//
+// Status (first match wins):
+//   not_watching  the dot cannot watch: it is paused or archived (a person chose that), the AI sign-in it uses expired, GitHub does not
+//                 answer or turned the sign-in down, a poll alarm is up, or there is nothing to watch (no repo, tracker or QA site).
+//                 It says nothing else: a QA site that is down shows on its own tile. "No check in 24 hours" is not a status, because a
+//                 quiet repo on a weekend is normal; the strip carries it as a line ("Quiet: no check in 24 h").
+//   failing       a site check is down, or the latest merge found a bug (a verdict of product failure or test failure, or failed tests that
+//                 are not an environment failure or flaky). A merge whose verdict is "needs attention" is not a confirmed bug.
+//   needs_you     something waits for a person's OK, a ticket review left questions, or the latest merge needs a look.
+//   healthy       none of the above.
+// Suggestion (first rule that matches wins, ties inside a rule are listed in each function):
+//   1 a ticket in the nearest open release has no test cases   2 a bug came back after its fix
+//   3 a flaky test failed 3 times this week                    4 the latest merge needs a look
+//   5 the AI calls of the day are 80 percent used
+import { FAMILY_LABEL, listUnavailable } from './agent/model-availability.js';
+import { defaultFamily } from './agent/llm.js';
+import { isLive } from './agent/approvals.js';
+import { ruleFor } from './agent/rules.js';
+import { db, get, list } from './db.js';
+import { deliveryOf } from './delivery.js';
+import { finishedWithTests } from './chat-stats.js';
+import { defectTarget } from './flows/defects.js';
+import { isLead, leadHealth, leadOf, teamIds } from './lead.js';
+import { pollFailureFor } from './monitor/pollers.js';
+import { capState, clockText } from './model-usage.js';
+import { watchRepos } from './repos.js';
+import { buildAll } from './reports/traceability.js';
+import { sandboxOn } from './sandbox.js';
+import { SHADOW_DAYS, shadowExpired } from './shadow-week.js';
+import { stageOn } from './stages/config.js';
+import { NOTHING_TO_WATCH, NO_CHECK_SITE, NO_CHECK_YET, SITE_CHECKS_OFF, SITE_CHECKS_SANDBOX } from './types.js';
+const MIN_MS = 60_000;
+const HOUR_MS = 3_600_000;
+const DAY_MS = 86_400_000;
+const WEEK_MS = 7 * DAY_MS;
+/** A dot with no check in this long is quiet: the strip says so, and the status does not change. */
+export const QUIET_LIMIT_MS = DAY_MS;
+/** The share of the daily calls at which the dot suggests raising the limit. */
+export const AI_NEAR_LIMIT = 0.8;
+/** Results of one test in a week at which the dot suggests fixing it. */
+export const FLAKY_SUGGEST_AT = 3;
+/** The jobs that count as a check of the product. The digest, the repo scan and test design are not checks. */
+export const CHECK_KINDS = ['pr_check', 'post_merge', 'ci_failure', 'rerun', 'nightly_run', 'ticket_review', 'outage', 'recovery'];
+/** The checks of the product's tests, which the Checks tile counts. Ticket reviews have their own tile. */
+const TEST_CHECK_KINDS = new Set(['pr_check', 'post_merge', 'ci_failure', 'rerun', 'nightly_run']);
+/** The checks that read the default branch, which says whether a failing test needs a fix. */
+const MAIN_KINDS = new Set(['post_merge', 'ci_failure', 'rerun', 'nightly_run']);
+/** A verdict that confirms a bug. "needs attention" does not: nobody has said it is a bug, so it reads Needs you, never Failing. */
+const BUG_OUTCOMES = new Set(['product_failure', 'test_failure']);
+// ---------- words ----------
+/** "just now", "2 min ago", "5 h ago", "3 d ago". */
+export function ago(iso, now) {
+    const ms = Math.max(0, now - Date.parse(iso));
+    if (ms < 45_000)
+        return 'just now';
+    if (ms < HOUR_MS)
+        return `${Math.max(1, Math.round(ms / MIN_MS))} min ago`;
+    if (ms < DAY_MS)
+        return `${Math.round(ms / HOUR_MS)} h ago`;
+    return `${Math.round(ms / DAY_MS)} d ago`;
+}
+/** A wait in a few characters: "12 min", "5 h", "2 d". */
+export function span(ms) {
+    if (ms < HOUR_MS)
+        return `${Math.max(1, Math.round(ms / MIN_MS))} min`;
+    if (ms < DAY_MS)
+        return `${Math.round(ms / HOUR_MS)} h`;
+    return `${Math.round(ms / DAY_MS)} d`;
+}
+const NBSP = ' ';
+const n = (count, one, many = `${one}s`) => `${count}${NBSP}${count === 1 ? one : many}`;
+const at = (iso) => Date.parse(iso);
+// ---------- tiles ----------
+const link = (label, href) => ({ label, href });
+/** An app link to a page of the dot: `#/trace?dot=<id>&milestone=...`. */
+const page = (route, dotId, more = {}) => `#/${route}?${new URLSearchParams({ dot: dotId, ...more }).toString()}`;
+const setUp = (setup) => ({ label: 'Set up', setup });
+const NOT_SET_UP = 'Not set up';
+function tile(title, line, action, facts = {}) {
+    return { title, state: 'ready', line, action, facts };
+}
+const notSetUp = (title, setup) => ({
+    title,
+    state: 'not_set_up',
+    line: NOT_SET_UP,
+    action: setUp(setup),
+    facts: {},
+});
+const broken = (title) => ({ title, state: 'error', line: 'Could not read this right now.', action: null, facts: {} });
+function reviewTile(i) {
+    const title = 'To review';
+    const waiting = i.pending.length;
+    // Nothing waits, so there is nothing to open: no button.
+    if (!waiting)
+        return tile(title, 'Nothing is waiting', null, { waiting: 0 });
+    const oldest = Math.min(...i.pending.map((a) => at(a.createdAt)));
+    return tile(title, `${waiting} waiting, oldest ${span(i.now - oldest)}`, link('Review', '#/inbox'), {
+        waiting,
+        oldestMinutes: Math.round((i.now - oldest) / MIN_MS),
+    });
+}
+/**
+ * A draft that files a bug. The main defect path drafts a new bug as `issue_create` with a bug signature (src/flows/defectDraft.ts);
+ * `file_defect` is the older kind. An `issue_create` with no signature is a ticket someone asked for, not a bug.
+ */
+export function isBugDraft(action) {
+    if (action.kind === 'issue_create')
+        return typeof action.meta?.bugSig === 'string' && action.meta.bugSig !== '';
+    return action.kind === 'file_defect';
+}
+/** Every bug the dot filed: approved drafts, drafts that went out on their own, each once. */
+export function filedBugs(i) {
+    const out = new Map();
+    for (const a of i.bugDrafts) {
+        if (a.status !== 'executed')
+            continue;
+        const meta = a.action.meta ?? {};
+        const key = typeof meta.filedKey === 'string' && meta.filedKey ? meta.filedKey : a.id;
+        const url = typeof meta.filedUrl === 'string' && meta.filedUrl ? meta.filedUrl : undefined;
+        out.set(key.toLowerCase(), {
+            key,
+            title: a.action.title,
+            at: a.executedAt ?? a.createdAt,
+            ...(url ? { url } : {}),
+            closed: i.closedKeys.has(key.toLowerCase()),
+        });
+    }
+    for (const b of i.autoFiled)
+        if (!out.has(b.key.toLowerCase()))
+            out.set(b.key.toLowerCase(), { ...b, closed: b.closed || i.closedKeys.has(b.key.toLowerCase()) });
+    return [...out.values()];
+}
+function bugsTile(i) {
+    const title = 'Bugs';
+    if (!i.dot.canFileBugs)
+        return notSetUp(title, 'tracker');
+    const filed = filedBugs(i);
+    // A bug counts as open until the dot sees its issue closed. GitHub issues say so; Jira and Linear bugs stay open here.
+    const open = filed.filter((b) => !b.closed);
+    const fresh = open.filter((b) => i.now - at(b.at) <= WEEK_MS);
+    const action = link('See bugs', page('trace', i.dot.id));
+    // A bug the dot found and drafted waits in To review until a person files it. Without this line the Checks tile says "found a bug"
+    // next to a Bugs tile that says none, and the reader cannot tell where the bug went.
+    const waiting = i.pending.filter((a) => isBugDraft(a.action)).length;
+    const draft = waiting ? `${waiting}\u00a0${waiting === 1 ? 'draft waits' : 'drafts wait'} in To review` : '';
+    const facts = { open: open.length, new: fresh.length, waiting };
+    if (!open.length)
+        return tile(title, draft ? `None open, ${draft}` : 'None open', null, facts);
+    const tail = [fresh.length ? `${fresh.length} new this week` : '', draft].filter(Boolean).join(', ');
+    return tile(title, `${open.length}\u00a0open${tail ? `, ${tail}` : ''}`, action, facts);
+}
+/** How one check ended, in the words of a tester. A check still running is not counted. */
+function outcomeOf(run) {
+    if (run.status === 'running' || run.status === 'cancelled')
+        return null;
+    const o = run.verdict?.outcome;
+    if (o && BUG_OUTCOMES.has(o))
+        return 'bug';
+    if (o === 'needs_attention')
+        return 'look';
+    // A merge whose tests failed and which got no verdict still found a bug: the header says so, so the tile says so too.
+    if (run.kind === 'post_merge' && !run.verdict && run.status === 'failed' && (run.report?.failed ?? 0) > 0)
+        return 'bug';
+    // A check that skipped its tests on purpose (Run tests is off for the repo, a docs only change) still reviewed the change and ended
+    // with a pass: it finished. Every other way of not running the tests proved nothing.
+    const notRun = run.report?.notRun && run.report.notRun.stage !== 'skipped';
+    if (run.status === 'failed' || run.status === 'interrupted' || o === 'environment_failure' || notRun || run.report?.interrupted)
+        return 'unchecked';
+    if (o === 'pass' || o === 'info' || o === 'flaky')
+        return 'passed';
+    // Done with no verdict: it ran, and said nothing about the product.
+    return run.verdict ? 'passed' : 'unchecked';
+}
+/** Whether a finished check found a bug: a verdict of product or test failure, or a merge whose tests failed with no verdict. The lead's release call reads it. */
+export function foundBug(run) {
+    return outcomeOf(run) === 'bug';
+}
+/** Whether a run is one of the checks that test a change (a pull request, a merge, a CI failure, a rerun). */
+function isTestCheck(run) {
+    return TEST_CHECK_KINDS.has(run.kind);
+}
+/**
+ * A run that finished a check: it ended well and looked at the product. A run that failed, was interrupted, was cancelled, is still
+ * running, or could not run its tests (an environment failure, no tests run, a fork pull request it skipped) proved nothing about
+ * the dot. A check that tests a change counts only when the Checks tile counts it as passed, a bug or a look, so the status, the strip
+ * and the tile never disagree about one run.
+ */
+export function finishedCheck(run) {
+    if (isTestCheck(run)) {
+        const o = outcomeOf(run);
+        return o === 'passed' || o === 'bug' || o === 'look';
+    }
+    if (run.status !== 'done')
+        return false;
+    return run.verdict?.outcome !== 'environment_failure' && !run.report?.notRun && !run.report?.interrupted;
+}
+function checksTile(i) {
+    const title = 'Checks this week';
+    const action = link('Open', page('feed', i.dot.id));
+    const week = i.runs.filter((r) => isTestCheck(r) && i.now - at(r.createdAt) <= WEEK_MS);
+    const running = week.filter((r) => r.status === 'running').length;
+    const counts = { passed: 0, bug: 0, look: 0, unchecked: 0 };
+    // A merge that needs a look is named as one, and only the latest merge is: it is the one check that waits for a person on the default
+    // branch, the same run the status and the suggestion read. A CI failure or a rerun that needs a look says "needs a look" under its own
+    // words. An older merge that needs a look and that a newer merge replaced waits for no one: it still counts as a check of the week, under
+    // "replaced by a newer merge", so the total matches the checks that ran.
+    const latest = i.lastMerge;
+    let lookMerge = 0;
+    let replaced = 0;
+    for (const r of week) {
+        if (r.kind === 'post_merge' && latest && r.id !== latest.id && outcomeOf(r) === 'look') {
+            replaced++;
+            continue;
+        }
+        const o = outcomeOf(r);
+        if (o)
+            counts[o]++;
+        if (o === 'look' && latest && r.id === latest.id && mergeOutcome(i) === 'look')
+            lookMerge++;
+    }
+    const total = counts.passed + counts.bug + counts.look + counts.unchecked + replaced;
+    const facts = { total, ...counts, running, lookMerge, replaced };
+    // A dot with no repo cannot check a pull request, so a zero would say "quiet week" about something that cannot happen. A repo with
+    // Run tests off still gets a review of each pull request, and a review is a check.
+    if (!total && !running && !i.dot.hasRepo)
+        return notSetUp(title, 'repo');
+    if (!total && !running)
+        return tile(title, 'No checks this week', null, facts);
+    if (!total)
+        return tile(title, `${running} running now`, action, facts);
+    // Checks that all ended without an answer say what the strip says ("none of them finished"), not a count of checks the dot made.
+    if (!counts.passed && !counts.bug && !counts.look && !replaced)
+        return tile(title, `${n(counts.unchecked, 'check')} started, none finished${running ? `, ${running} running` : ''}`, action, facts);
+    const parts = [
+        counts.passed ? `${counts.passed} passed` : '',
+        counts.bug ? `${counts.bug} found a bug` : '',
+        lookMerge ? `${lookMerge} ${lookMerge === 1 ? 'merge needs' : 'merges need'} a look` : '',
+        counts.look - lookMerge ? `${counts.look - lookMerge} ${counts.look - lookMerge === 1 ? 'needs' : 'need'} a look` : '',
+        replaced ? `${replaced} replaced by a newer merge` : '',
+        counts.unchecked ? `${counts.unchecked} could not check` : '',
+        running ? `${running} running` : '',
+    ].filter(Boolean);
+    return tile(title, `${n(total, 'check')}: ${parts.join(', ')}`, action, facts);
+}
+// ---- release
+const DATE_IN_TITLE = /(\d{4})[-./](\d{1,2})(?:[-./](\d{1,2}))?/;
+/** The day a milestone title names ("2026-10-28", "2026.11"), or null. A month alone means the end of that month. */
+export function milestoneDate(title) {
+    const m = DATE_IN_TITLE.exec(title);
+    if (!m)
+        return null;
+    const y = Number(m[1]);
+    const mo = Number(m[2]);
+    if (mo < 1 || mo > 12)
+        return null;
+    const d = m[3] ? Number(m[3]) : new Date(y, mo, 0).getDate();
+    const out = new Date(y, mo - 1, d).getTime();
+    return Number.isFinite(out) ? out : null;
+}
+function startOfDay(t) {
+    const d = new Date(t);
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+}
+/**
+ * The release the panel talks about: the nearest milestone that still has a ticket not passing. A milestone with a date at or after
+ * today comes first, the soonest one. When every dated one is past, the latest. Milestones with no date follow in the tracker's
+ * order. null when no milestone has work left.
+ */
+export function nearestOpenMilestone(rows, now, scope) {
+    const allowed = scope?.length ? new Set(scope.map((s) => s.toLowerCase())) : null;
+    const open = [];
+    for (const r of rows) {
+        if (!r.milestone || (allowed && !allowed.has(r.milestone.toLowerCase())))
+            continue;
+        if (r.statusCode !== 'passing' && !open.includes(r.milestone))
+            open.push(r.milestone);
+    }
+    if (!open.length)
+        return null;
+    const today = startOfDay(now);
+    const dated = open.map((m) => ({ m, d: milestoneDate(m) })).filter((x) => x.d !== null);
+    const coming = dated.filter((x) => x.d >= today).sort((a, b) => a.d - b.d || a.m.localeCompare(b.m, undefined, { numeric: true }));
+    if (coming.length)
+        return coming[0].m;
+    const past = dated.sort((a, b) => b.d - a.d || a.m.localeCompare(b.m, undefined, { numeric: true }));
+    if (past.length)
+        return past[0].m;
+    return open[0];
+}
+const releaseTitle = (milestone) => (/^release\b/i.test(milestone) ? milestone : `Release ${milestone}`);
+function releaseTile(i) {
+    if (!i.trace || !i.trace.rows.some((r) => r.milestone))
+        return notSetUp('Release', 'tracker');
+    const milestone = nearestOpenMilestone(i.trace.rows, i.now, i.milestoneScope);
+    if (!milestone)
+        return tile('Release', 'No release is open', link('Open report', page('trace', i.dot.id)), { total: 0 });
+    const rows = i.trace.rows.filter((r) => r.milestone === milestone);
+    const tested = rows.filter((r) => r.statusCode !== 'not_tested').length;
+    return tile(releaseTitle(milestone), `${tested} of ${n(rows.length, 'ticket')} tested`, link('Open report', page('trace', i.dot.id, { milestone })), {
+        milestone,
+        tested,
+        total: rows.length,
+    });
+}
+// ---- site
+/**
+ * A dot whose only source is a QA site, when site checks cannot run for it: the watcher is off (`site_off`) or the server is in sandbox
+ * mode (`site_sandbox`). With a repo or a tracker the dot still watches, so this is null. The strip, the status and the QA site tile
+ * all read this one answer.
+ */
+function siteOnlyBlock(i) {
+    if (!i.dot.probes || i.dot.hasRepo || i.dot.hasTracker)
+        return null;
+    if (i.dot.siteChecks === 'sandbox')
+        return 'site_sandbox';
+    return i.dot.siteChecks === 'off' ? 'site_off' : null;
+}
+function siteTile(i) {
+    const title = 'QA site';
+    if (!i.dot.probes)
+        return notSetUp(title, 'site');
+    // No site check can run, so the tile says why, in the words of the strip, and offers no Check now.
+    const block = siteOnlyBlock(i);
+    if (block)
+        return tile(title, block === 'site_off' ? SITE_CHECKS_OFF : SITE_CHECKS_SANDBOX, null, { sites: i.dot.probes });
+    // The button shows only where the server would run it.
+    const action = i.dot.canSiteCheck ? { label: 'Check now', run: 'site_check' } : null;
+    const rows = i.probeRows;
+    if (!rows.length)
+        return tile(title, 'Waiting for the first check', action, { sites: i.dot.probes });
+    const total = Math.max(i.dot.probes, rows.length);
+    const down = rows.filter((r) => r.down || r.status === 'down');
+    const failing = rows.filter((r) => !r.down && r.status === 'failing');
+    const checked = rows.map((r) => r.lastCheckedAt).filter((x) => !!x);
+    const newest = checked.sort().at(-1);
+    const when = newest ? `, ${ago(newest, i.now)}` : '';
+    // After a time of "down for", a bare "6 min ago" reads as when it went down: a site that is not up says "checked".
+    const checkedAgo = newest ? `, checked ${ago(newest, i.now)}` : '';
+    const facts = { sites: total, down: down.length, failing: failing.length };
+    if (down.length) {
+        if (total === 1) {
+            const since = down[0].downSince;
+            return tile(title, `Down${since ? ` for ${span(Math.max(0, i.now - at(since)))}` : ''}${checkedAgo}`, action, facts);
+        }
+        return tile(title, `${down.length} of ${n(total, 'site')} down${checkedAgo}`, action, facts);
+    }
+    if (failing.length) {
+        const misses = Math.max(...failing.map((r) => r.consecutiveFailures));
+        return tile(title, total === 1
+            ? `Not answering, ${n(misses, 'miss', 'misses')} in a row${checkedAgo}`
+            : `${failing.length} of ${n(total, 'site')} not answering${checkedAgo}`, action, facts);
+    }
+    const slow = Math.max(0, ...rows.map((r) => r.lastLatencyMs ?? 0));
+    const speed = slow ? `, ${slow}${NBSP}ms` : '';
+    return tile(title, total === 1 ? `Up${speed}${when}` : `All ${total} up${slow ? `, slowest ${slow}${NBSP}ms` : ''}${when}`, action, {
+        ...facts,
+        latencyMs: slow || null,
+    });
+}
+/** Each test of the checks of the last 7 days, with how often it was flaky or failed. */
+export function testStats(runs, now) {
+    const stats = new Map();
+    const week = runs.filter((r) => now - at(r.createdAt) <= WEEK_MS);
+    for (const { run, report } of finishedWithTests(week)) {
+        const when = at(run.createdAt);
+        for (const c of report.cases) {
+            if (c.status === 'skipped')
+                continue;
+            const key = `${c.file}::${c.title}`;
+            let s = stats.get(key);
+            if (!s)
+                stats.set(key, (s = { file: c.file, title: c.title, flaky: 0, failed: 0, latestAt: 0, latestRunId: run.id, main: null, badRunId: '' }));
+            const failing = c.status === 'failed' || c.status === 'timedOut';
+            if (c.status === 'flaky')
+                s.flaky++;
+            if (failing)
+                s.failed++;
+            if (when >= s.latestAt) {
+                s.latestAt = when;
+                s.latestRunId = run.id;
+            }
+            if ((c.status === 'flaky' || failing) && (!s.badRunId || when >= s.latestAt))
+                s.badRunId = run.id;
+            if (MAIN_KINDS.has(run.kind) && (!s.main || when >= s.main.at))
+                s.main = { at: when, failing };
+        }
+    }
+    return [...stats.values()];
+}
+function testsTile(i) {
+    const title = 'Tests';
+    const stats = testStats(i.runs, i.now);
+    const needFix = stats.filter((s) => s.main?.failing);
+    const flaky = stats.filter((s) => s.flaky > 0 && !s.main?.failing);
+    const worst = [...needFix, ...flaky].sort((a, b) => b.latestAt - a.latestAt)[0];
+    const action = link('See tests', worst ? `#/runs/${encodeURIComponent(worst.badRunId || worst.latestRunId)}` : page('cases', i.dot.id));
+    const facts = { flaky: flaky.length, needsFix: needFix.length, tested: stats.length };
+    if (!stats.length && !i.dot.canRunTests)
+        return notSetUp(title, 'repo');
+    if (!stats.length)
+        return tile(title, 'No test results this week', null, facts);
+    if (!flaky.length && !needFix.length)
+        return tile(title, 'None flaky, none need a fix', action, facts);
+    const parts = [
+        flaky.length ? `${flaky.length} flaky` : '',
+        needFix.length ? `${needFix.length} ${needFix.length === 1 ? 'needs' : 'need'} a fix` : '',
+    ].filter(Boolean);
+    return tile(title, parts.join(', '), action, facts);
+}
+// ---- tickets
+const ticketKeyOf = (r) => r.trigger?.inlineTicket?.key ?? r.trigger?.ticket?.key ?? r.id;
+function ticketsTile(i) {
+    const title = 'Tickets';
+    const reviews = i.runs.filter((r) => r.kind === 'ticket_review' && r.status !== 'running' && i.now - at(r.createdAt) <= WEEK_MS);
+    if (!i.dot.hasTracker && !reviews.length)
+        return notSetUp(title, 'tracker');
+    const action = link('See tickets', page('trace', i.dot.id));
+    // The newest review of a ticket decides whether it still has questions.
+    const latest = new Map();
+    for (const r of reviews) {
+        const prev = latest.get(ticketKeyOf(r));
+        if (!prev || at(r.createdAt) > at(prev.createdAt))
+            latest.set(ticketKeyOf(r), r);
+    }
+    const reviewed = latest.size;
+    const asking = [...latest.values()].filter((r) => (r.verdict?.openQuestions?.length ?? 0) > 0).length;
+    const facts = { reviewed, needAnswers: asking };
+    if (!reviewed)
+        return tile(title, 'No tickets reviewed this week', null, facts);
+    return tile(title, `${reviewed} reviewed${asking ? `, ${asking} ${asking === 1 ? 'needs' : 'need'} answers` : ', none need answers'}`, action, facts);
+}
+// ---- AI use
+function aiTile(i) {
+    const title = 'AI use today';
+    // A dot with no daily limit still uses AI: "Not set up" would read as if no AI engine worked, so the tile says what is missing.
+    if (!i.cap)
+        return tile(title, 'No daily limit', { label: 'Set a limit', setup: 'cap' }, {});
+    const left = Math.max(0, i.cap.cap - i.cap.used);
+    const action = { label: 'Details', focus: 'model_usage' };
+    const facts = { cap: i.cap.cap, used: i.cap.used, left };
+    if (i.cap.reached)
+        return tile(title, `No AI calls left, back at ${clockText(new Date(i.cap.resetsAt))}`, action, facts);
+    return tile(title, `${i.cap.used} of ${i.cap.cap} AI calls used`, action, facts);
+}
+// ---------- status ----------
+const checkRef = (r) => {
+    const t = r.trigger;
+    if (r.kind === 'ticket_review')
+        return t?.inlineTicket?.key ?? t?.ticket?.key ?? null;
+    if (t?.pr)
+        return `PR #${t.pr.number}`;
+    if (t?.push?.ref)
+        return t.push.ref.replace(/^refs\/heads\//, '');
+    return null;
+};
+function hostOf(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return url;
+    }
+}
+/**
+ * The check the strip names, and the time of the newest check of any kind. A site check runs every minute, so it would hide the
+ * PR or the ticket the dot worked on: the strip names the newest run while it is under a day old, and the site check otherwise.
+ * The 24 hour rule reads the newest check of either kind.
+ */
+function lastCheckOf(i) {
+    const run = i.lastCheckRun;
+    const probe = i.probeRows.filter((r) => r.lastCheckedAt).sort((a, b) => b.lastCheckedAt.localeCompare(a.lastCheckedAt))[0];
+    const runAt = run ? at(run.createdAt) : null;
+    const probeAt = probe ? at(probe.lastCheckedAt) : null;
+    const newest = runAt === null && probeAt === null ? null : Math.max(runAt ?? 0, probeAt ?? 0);
+    const fromRun = (r) => ({
+        kind: r.kind,
+        ref: checkRef(r),
+        title: r.trigger?.title ?? r.kind,
+        at: r.createdAt,
+        runId: r.id,
+    });
+    const fromProbe = (p) => {
+        const host = hostOf(p.url);
+        return { kind: 'site', ref: host, title: `Site check of ${host}`, at: p.lastCheckedAt };
+    };
+    if (run && (i.now - runAt < QUIET_LIMIT_MS || !probe))
+        return { shown: fromRun(run), newest };
+    if (probe)
+        return { shown: fromProbe(probe), newest };
+    return { shown: null, newest };
+}
+export { NO_CHECK_YET };
+/**
+ * The line of a dot that never checked, in plain words and naming only what can start a check for this dot. A dot with a QA site whose
+ * checks run says the first site check comes within a minute, because that is the soonest check it will make. A dot whose only source
+ * is a site that no check runs for is Not watching and has no first-check line (see notWatchingReason). Without a site, a repository counts as "a PR" whether
+ * or not it runs tests (a review of the pull request is a check), and a ticket tracker as "a ticket".
+ */
+function noCheckYet(i) {
+    if (i.dot.probes && !i.dot.paused && i.dot.siteChecks === 'running')
+        return NO_CHECK_SITE;
+    const starters = [i.dot.hasRepo ? 'a PR' : '', i.dot.hasTracker ? 'a ticket' : ''].filter(Boolean);
+    if (starters.length)
+        return `No checks yet. The first one starts when ${starters.join(' or ')} comes in.`;
+    return NO_CHECK_YET;
+}
+/**
+ * A line for a dot that watches but has nothing recent to show: it never finished a check (why), or it has been quiet for 24 hours.
+ * A quiet repo on a weekend is normal, so this is a line and never a status.
+ */
+function watchNote(i, newestCheck) {
+    if (newestCheck === null) {
+        const tried = i.runs.filter((r) => CHECK_KINDS.includes(r.kind));
+        if (tried.length && tried.every((r) => r.status === 'running'))
+            return 'The first check is still running.';
+        if (tried.length)
+            return 'Checks started, but none of them finished.';
+        return noCheckYet(i);
+    }
+    if (i.now - newestCheck >= QUIET_LIMIT_MS)
+        return 'Quiet: no check in 24 h';
+    return null;
+}
+/**
+ * Why the dot cannot watch, or null. `fix` opens Setup when a person can repair it there. The sentence says what is wrong and never
+ * what to press: the panel adds the button for an admin and "ask your admin" for everyone else, so a member never reads an order
+ * they cannot follow.
+ */
+function notWatchingReason(i) {
+    if (i.dot.archived)
+        return { text: 'This dot is archived. Restore it to start watching again.', state: 'archived' };
+    if (i.dot.paused)
+        return { text: 'This dot is paused. Resume it to start watching again.', state: 'paused' };
+    if (i.blockers.signIn)
+        return { text: i.blockers.signIn, state: 'sign_in', fix: link('Open Setup', '#/setup') };
+    if (i.blockers.github)
+        return {
+            text: i.blockers.github,
+            state: 'github',
+            ...(i.blockers.fixable ? { fix: link('Open Setup', '#/setup') } : {}),
+            ...(i.blockers.detail ? { detail: i.blockers.detail } : {}),
+        };
+    // With no repo, no tracker and no site, no PR, ticket or site check can ever start: the sentence says what is missing and Setup is the way out.
+    if (!i.dot.hasRepo && !i.dot.hasTracker && !i.dot.probes)
+        return { text: NOTHING_TO_WATCH, state: 'nothing', fix: link('Open Setup', '#/setup') };
+    // A QA site as the only source, with no site check running: nothing can ever start a check. A sandbox is the server's doing, so it has
+    // no fix; the Prod watcher is a switch a person can turn on.
+    const block = siteOnlyBlock(i);
+    if (block === 'site_sandbox')
+        return { text: SITE_CHECKS_SANDBOX, state: 'site_sandbox' };
+    if (block === 'site_off')
+        return { text: SITE_CHECKS_OFF, state: 'site_off', fix: { label: 'Turn on site checks', setup: 'site' } };
+    return null;
+}
+/**
+ * A failed GitHub read in words a tester understands. The raw error ("HTTP 401: Bad credentials") goes to the Details fold. `fixable`
+ * says a person can repair it on Setup: a refused sign-in or a repo GitHub cannot find. A timeout or a rate limit mends itself.
+ */
+export function githubTrouble(label, error) {
+    if (/\b(401|403)\b|bad credentials|forbidden|unauthori[sz]ed|requires authentication/i.test(error))
+        return { text: `GitHub turned down the sign-in for ${label}.`, fixable: true };
+    if (/\b404\b|not found/i.test(error))
+        return { text: `GitHub cannot find ${label}.`, fixable: true };
+    if (/\b429\b|rate limit/i.test(error))
+        return { text: `GitHub is limiting requests for ${label}. localdost waits and tries again.`, fixable: false };
+    if (/timeout|timed out|etimedout|econn|enotfound|network|fetch failed|socket/i.test(error))
+        return { text: `GitHub did not answer in time for ${label}. localdost keeps trying.`, fixable: false };
+    return { text: `GitHub is not answering for ${label}. localdost keeps trying.`, fixable: false };
+}
+/** The latest merge, when it has finished with this outcome. The Checks tile counts the same run the same way. */
+const mergeOutcome = (i) => (i.lastMerge && i.lastMerge.status !== 'running' ? outcomeOf(i.lastMerge) : null);
+function failingReason(i) {
+    if (i.probeRows.some((r) => r.down || r.status === 'down'))
+        return 'The QA site is down.';
+    // Only a confirmed bug fails the dot. A merge that "needs attention" waits for a person (Needs you), and the Checks tile counts it as
+    // "needs a look", so the header and the tile never tell two stories about one merge.
+    if (mergeOutcome(i) === 'bug')
+        return 'The last merge found a bug.';
+    return null;
+}
+/** The part of a Needs you reason that names the latest merge. The Room finds the merge it means by this phrase. */
+export const MERGE_LOOK_WORDS = 'the last merge needs a look';
+function needsYouReason(i, tickets) {
+    const waiting = i.pending.length;
+    const asking = Number(tickets.facts.needAnswers ?? 0);
+    const look = mergeOutcome(i) === 'look';
+    if (!waiting && !asking && !look)
+        return null;
+    const parts = [waiting ? `${n(waiting, 'item')} to review` : '', asking ? `${n(asking, 'ticket')} with questions` : '', look ? MERGE_LOOK_WORDS : ''].filter(Boolean);
+    const said = parts.length > 1 ? `${parts.slice(0, -1).join(', ')} and ${parts.at(-1)}` : parts[0];
+    return `${said[0].toUpperCase()}${said.slice(1)}.`;
+}
+// ---------- suggestion ----------
+/**
+ * How the sentence names a ticket. A Jira or Linear key (PROD-1234) names it alone: a title next to it splits the sentence at its
+ * commas. A GitHub key reads as code (acme/shop-web#115), so the ticket is named by its issue number and its title in quotes
+ * (#115 "Checkout total"), or by the number alone when it has no title. The number is the key a person searches for.
+ */
+export function ticketName(hit) {
+    const gh = /^[^/\s]+\/[^#\s]+#(\d+)$/.exec(hit.key);
+    if (!gh)
+        return hit.key;
+    const title = hit.title?.trim();
+    return title ? `#${gh[1]} "${title}"` : `#${gh[1]}`;
+}
+/**
+ * Rule 1. Tickets of the nearest open release that nothing tests: no run, no spec, and no test case names them.
+ * Ties go to the first ticket in the tracker's order.
+ */
+export function releaseWithoutCases(i) {
+    if (!i.trace)
+        return null;
+    const milestone = nearestOpenMilestone(i.trace.rows, i.now, i.milestoneScope);
+    if (!milestone)
+        return null;
+    const hit = i.trace.rows.find((r) => r.milestone === milestone &&
+        r.statusCode === 'not_tested' &&
+        r.tests.total === 0 &&
+        !i.casedRefs.has(r.ref.toLowerCase()) &&
+        !i.casedRefs.has(r.key.toLowerCase()));
+    if (!hit)
+        return null;
+    return {
+        rule: 'release_without_cases',
+        text: `${ticketName(hit)} is in the release and has no test cases yet.`,
+        action: { label: 'Design tests', draft: `Design test cases for ${hit.key}${hit.title ? `: ${hit.title}` : ''}.` },
+    };
+}
+/**
+ * Rule 2. A bug filed earlier was drafted or filed again later: the tracker no longer showed the first issue as open, so the bug
+ * came back after its fix. Both ways to file count: a draft a person approves, and a check that files on its own. Only a filing
+ * from the last 7 days counts. Ties go to the newest.
+ */
+export function bugCameBack(i) {
+    const filings = [];
+    for (const a of i.bugDrafts) {
+        const sig = a.action.meta?.bugSig;
+        if (typeof sig !== 'string' || !['pending', 'approved', 'executed'].includes(a.status))
+            continue;
+        const url = a.status === 'executed' && typeof a.action.meta?.filedUrl === 'string' ? a.action.meta.filedUrl : undefined;
+        filings.push({ id: a.id, sig, at: a.createdAt, title: a.action.title, executed: a.status === 'executed', ...(url ? { url } : {}) });
+    }
+    // A draft a person approved can also show in the actions of its run, with the same issue key: it is one filing, not two.
+    const draftKeys = new Set(i.bugDrafts
+        .map((a) => a.action.meta?.filedKey)
+        .filter((k) => typeof k === 'string')
+        .map((k) => k.toLowerCase()));
+    for (const b of i.autoFiled)
+        if (b.sig && !draftKeys.has(b.key.toLowerCase()))
+            filings.push({ id: b.key, sig: b.sig, at: b.at, title: b.title, executed: true, ...(b.url ? { url: b.url } : {}) });
+    const first = new Map();
+    for (const f of filings) {
+        if (!f.executed)
+            continue;
+        const prev = first.get(f.sig);
+        if (!prev || f.at < prev)
+            first.set(f.sig, f.at);
+    }
+    const again = filings
+        .filter((f) => {
+        const earliest = first.get(f.sig);
+        return earliest !== undefined && f.at > earliest && i.now - at(f.at) <= WEEK_MS;
+    })
+        .sort((a, b) => b.at.localeCompare(a.at) || a.id.localeCompare(b.id))[0];
+    if (!again)
+        return null;
+    return {
+        rule: 'bug_came_back',
+        text: `The bug "${again.title}" came back after it was fixed.`,
+        action: again.url ? { label: 'Open the bug', href: again.url } : { label: 'Review the bug', href: '#/inbox' },
+    };
+}
+/**
+ * Rule 3. A flaky test with 3 or more flaky or failed results this week. Ties go to the test with the most results, then the
+ * newest, then the path and title in order.
+ */
+export function flakyTest(i) {
+    const hit = testStats(i.runs, i.now)
+        .filter((s) => s.flaky > 0 && s.flaky + s.failed >= FLAKY_SUGGEST_AT)
+        .sort((a, b) => b.flaky + b.failed - (a.flaky + a.failed) || b.latestAt - a.latestAt || `${a.file}::${a.title}`.localeCompare(`${b.file}::${b.title}`))[0];
+    if (!hit)
+        return null;
+    const times = hit.flaky + hit.failed;
+    // A flaky result is a test that failed and then passed on a retry, so the check around it still passed. Saying "failed" next to a
+    // Checks tile that says everything passed would read as a contradiction, so the sentence keeps the two apart.
+    const text = hit.failed === 0
+        ? `The test "${hit.title}" was flaky ${times} times this week: it failed, then passed on a retry.`
+        : `The test "${hit.title}" was flaky or failed ${times} times this week.`;
+    return {
+        rule: 'flaky_test',
+        text,
+        action: { label: 'See the test', href: `#/runs/${encodeURIComponent(hit.badRunId || hit.latestRunId)}` },
+    };
+}
+/** Rule 4. The latest merge ended "needs attention": nobody called it a bug, and a person must look. */
+export function mergeNeedsLook(i) {
+    if (mergeOutcome(i) !== 'look' || !i.lastMerge)
+        return null;
+    return {
+        rule: 'merge_look',
+        text: 'The last merge needs a look.',
+        action: { label: 'Open the merge', href: `#/runs/${encodeURIComponent(i.lastMerge.id)}` },
+    };
+}
+/** Rule 5. The dot used 80 percent or more of its daily calls. */
+export function aiCallsLow(i) {
+    const c = i.cap;
+    if (!c || c.used / c.cap < AI_NEAR_LIMIT)
+        return null;
+    const left = Math.max(0, c.cap - c.used);
+    return {
+        rule: 'ai_calls_low',
+        text: left ? `AI calls are almost used up: ${c.used} of ${c.cap} used today.` : `AI calls are used up for today: ${c.cap} of ${c.cap}.`,
+        action: { label: 'Raise the limit', setup: 'cap' },
+    };
+}
+export function suggestionOf(i) {
+    const rules = [releaseWithoutCases, bugCameBack, flakyTest, mergeNeedsLook, aiCallsLow];
+    for (const rule of rules) {
+        const hit = safely(() => rule(i));
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+function safely(fn) {
+    try {
+        return fn();
+    }
+    catch {
+        return null;
+    }
+}
+// ---------- the answer ----------
+export function computeHealth(i) {
+    const err = i.errors ?? {};
+    const build = (key, title, make) => {
+        if (err[key])
+            return broken(title);
+        try {
+            return make();
+        }
+        catch {
+            return broken(title);
+        }
+    };
+    const tiles = {
+        review: build('review', 'To review', () => reviewTile(i)),
+        bugs: build('bugs', 'Bugs', () => bugsTile(i)),
+        checks: build('checks', 'Checks this week', () => checksTile(i)),
+        release: build('release', 'Release', () => releaseTile(i)),
+        site: build('site', 'QA site', () => siteTile(i)),
+        tests: build('tests', 'Tests', () => testsTile(i)),
+        tickets: build('tickets', 'Tickets', () => ticketsTile(i)),
+        ai: build('ai', 'AI use today', () => aiTile(i)),
+    };
+    const { shown: lastCheck, newest } = lastCheckOf(i);
+    const away = notWatchingReason(i);
+    const failing = failingReason(i);
+    const needs = needsYouReason(i, tiles.tickets);
+    let status;
+    let statusReason;
+    // Not watching comes first: a dot that cannot watch says so, and what else is wrong (a QA site that is down, say) shows on its own tile.
+    if (away)
+        [status, statusReason] = ['not_watching', away.text];
+    else if (failing)
+        [status, statusReason] = ['failing', failing];
+    else if (needs)
+        [status, statusReason] = ['needs_you', needs];
+    else
+        [status, statusReason] = ['healthy', 'Nothing needs you.'];
+    const trialUntil = i.trialUntil && at(i.trialUntil) > i.now ? at(i.trialUntil) : null;
+    let trial = null;
+    if (trialUntil !== null) {
+        const left = Math.max(1, Math.ceil((trialUntil - i.now) / DAY_MS));
+        const days = Math.max(SHADOW_DAYS, left);
+        trial = { day: Math.min(days, Math.max(1, days - left + 1)), days };
+    }
+    return {
+        status,
+        statusReason,
+        ...(away?.fix ? { statusFix: away.fix } : {}),
+        ...(away?.detail ? { statusDetail: away.detail } : {}),
+        watching: { on: !away, state: away ? away.state : 'on', note: away ? null : watchNote(i, newest), lastCheck, trial, postsWait: i.postsWait },
+        tiles,
+        suggestion: suggestionOf(i),
+        builtAt: new Date(i.now).toISOString(),
+    };
+}
+// ---------- reading the rows ----------
+/** Bug drafts are read up to this many, newest first, whatever other drafts the dot has made since. */
+const BUG_DRAFT_LIMIT = 2000;
+const RUN_LIMIT = 400;
+/** Runs that filed a bug are read up to this many, newest first. */
+const FILER_LIMIT = 2000;
+/** Reads every row the panel needs. A piece that fails to read is left out and its tile says so; the others still answer. */
+export function readHealthInput(w, now = Date.now()) {
+    const errors = {};
+    const guard = (keys, fallback, read) => {
+        try {
+            return read();
+        }
+        catch {
+            for (const k of keys)
+                errors[k] = true;
+            return fallback;
+        }
+    };
+    const since = new Date(now - WEEK_MS).toISOString();
+    // The newest runs. The tiles read the last 7 days, and the 400 newest are enough for that.
+    const recent = guard(['checks', 'tests', 'tickets', 'bugs'], [], () => list('runs', { watchId: w.id }, { orderBy: 'createdAt DESC', limit: RUN_LIMIT }));
+    const runs = recent.filter((r) => r.createdAt >= since);
+    // The newest check that finished and said something. The newest 200 check runs are read so a long run of failed starts does not hide an older good check.
+    const lastCheckRun = safely(() => list('runs', { watchId: w.id, kind: [...CHECK_KINDS] }, { orderBy: 'createdAt DESC', limit: 200 }).find(finishedCheck) ?? null);
+    const lastMerge = safely(() => list('runs', { watchId: w.id, kind: 'post_merge' }, { orderBy: 'createdAt DESC', limit: 1 })[0] ?? null);
+    const pending = guard(['review'], [], () => list('approvals', { watchId: w.id, status: 'pending' }).filter((a) => isLive(a, now)));
+    // Only bug drafts are read, newest first, so a busy dot's newer drafts of other kinds (a PR comment, say) never push an older bug
+    // out of the count. The kind sits inside the stored action, so the ids come from one query and the rows from the next.
+    const bugDrafts = guard(['bugs'], [], () => {
+        const ids = db
+            .prepare(`SELECT id FROM approvals WHERE watchId = ? AND json_extract(action, '$.kind') IN ('file_defect', 'issue_create') ORDER BY createdAt DESC LIMIT ${BUG_DRAFT_LIMIT}`)
+            .all(w.id).map((r) => r.id);
+        if (!ids.length)
+            return [];
+        return list('approvals', { id: ids }, { orderBy: 'createdAt DESC' }).filter((a) => isBugDraft(a.action));
+    });
+    const closedKeys = new Set();
+    const autoFiled = [];
+    guard(['bugs'], null, () => {
+        // Every run of the dot that filed a bug, however old, found by its stored actions: a busy dot passes any run count in weeks, and a
+        // bug that is still open must stay counted.
+        const filers = db
+            .prepare(`SELECT createdAt, actions FROM runs WHERE watchId = ? AND actions LIKE '%filedKey%' ORDER BY createdAt DESC LIMIT ${FILER_LIMIT}`)
+            .all(w.id);
+        for (const r of filers) {
+            let acts;
+            try {
+                acts = r.actions ? JSON.parse(r.actions) : [];
+            }
+            catch {
+                continue;
+            }
+            for (const x of acts ?? []) {
+                if (!isBugDraft(x.action) || x.result !== 'executed')
+                    continue;
+                const key = typeof x.action.meta?.filedKey === 'string' ? x.action.meta.filedKey : '';
+                if (!key)
+                    continue;
+                const url = typeof x.action.meta?.filedUrl === 'string' ? x.action.meta.filedUrl : undefined;
+                const sig = typeof x.action.meta?.bugSig === 'string' ? x.action.meta.bugSig : undefined;
+                autoFiled.push({ key, title: x.action.title, at: r.createdAt, ...(url ? { url } : {}), closed: false, ...(sig ? { sig } : {}) });
+            }
+        }
+        const keys = new Set();
+        for (const a of bugDrafts)
+            if (typeof a.action.meta?.filedKey === 'string')
+                keys.add(a.action.meta.filedKey.toLowerCase());
+        for (const b of autoFiled)
+            keys.add(b.key.toLowerCase());
+        for (const key of keys) {
+            if (!/^[^/\s]+\/[^#\s]+#\d+$/.test(key))
+                continue;
+            if (get('issue_state', key)?.state === 'closed')
+                closedKeys.add(key);
+        }
+        return null;
+    });
+    const urls = new Set(w.probes.map((p) => p.url));
+    const probeRows = guard(['site'], [], () => list('probe_state', { watchId: w.id }).filter((r) => urls.has(r.url)));
+    let trace = null;
+    const casedRefs = new Set();
+    guard(['release'], null, () => {
+        // A member of a lead reads the tests of its whole team for its own tickets (KAT-405): a PR check of PR Reviewer and the cases of Ticket
+        // Reviewer test a ticket of Ticket Reviewer, so it is not "without test cases" while the release call of the lead says it passes.
+        const lead = leadOf(w.id);
+        const own = buildAll(w).all;
+        trace = { rows: lead ? withTeamEvidence(own, buildAll(lead).all) : own };
+        for (const c of list('test_cases', { dotId: lead ? teamIds(w.id) : w.id })) {
+            if (c.status === 'retired')
+                continue;
+            for (const ref of c.requirementRefs ?? [])
+                casedRefs.add(ref.toLowerCase());
+        }
+        return null;
+    });
+    const cap = guard(['ai'], null, () => capState(w) ?? null);
+    const delivery = safely(() => deliveryOf(w));
+    const alarm = safely(() => pollFailureFor(w));
+    // Only the default model can stop a dot. A stage whose own model is signed out falls back to the default and keeps running, and a
+    // model nobody uses is not the dot's problem. A default that another model already answers for (usingInstead) stops nothing either.
+    const mainFamily = safely(() => defaultFamily());
+    const down = safely(() => listUnavailable().find((u) => u.kind === 'auth_expired' && !u.usingInstead && !!mainFamily && u.family === mainFamily));
+    const blockers = {};
+    // The reason text of the model layer already says "sign-in expired", so the sentence names the model and stops: no stutter.
+    if (down)
+        blockers.signIn = `The ${FAMILY_LABEL[down.family] ?? 'AI'} sign-in expired or was rejected.`;
+    if (alarm) {
+        const t = githubTrouble(alarm.label, alarm.error);
+        blockers.github = t.text;
+        blockers.fixable = t.fixable;
+        blockers.detail = `${alarm.label}: ${alarm.error}`;
+    }
+    else if (delivery?.listening === 'none') {
+        blockers.github = delivery.listeningReason
+            ? `${delivery.listeningReason.replace(/[.\s]+$/, '')}.`
+            : `Nothing brings a PR to this dot${delivery.listeningMissing?.length ? ` (${delivery.listeningMissing.join(', ')} missing)` : ''}.`;
+        blockers.fixable = true;
+    }
+    const trialUntil = w.shadowWeek && !shadowExpired(w.shadowWeek, now) ? w.shadowWeek.until : null;
+    const postsWait = safely(() => ruleFor(w, 'pr_comment') === 'ask') ?? false;
+    return {
+        now,
+        dot: {
+            id: w.id,
+            paused: !!w.paused,
+            archived: !!w.archived,
+            createdAt: w.createdAt,
+            probes: w.probes.length,
+            hasTracker: !!w.tracker,
+            hasRepo: !!safely(() => watchRepos(w).length),
+            canFileBugs: !!safely(() => defectTarget(w)),
+            canRunTests: !!safely(() => watchRepos(w).some((r) => r.runTests !== false)),
+            canSiteCheck: !w.paused && !w.archived && !!w.probes.length && !sandboxOn(),
+            siteChecks: sandboxOn() ? 'sandbox' : stageOn(w, 'watcher') ? 'running' : 'off',
+        },
+        runs,
+        lastCheckRun,
+        lastMerge,
+        pending,
+        bugDrafts,
+        autoFiled,
+        closedKeys,
+        probeRows,
+        trace,
+        ...(w.tracker?.kind === 'github' && w.tracker.milestones?.length ? { milestoneScope: w.tracker.milestones } : {}),
+        casedRefs,
+        cap,
+        blockers,
+        trialUntil,
+        postsWait,
+        errors,
+    };
+}
+/** The rows of a member with the tests, PRs, bugs and status that its team's rows hold for the same ticket. A ticket the team does not know stays as it is. */
+export function withTeamEvidence(own, team) {
+    const byRef = new Map(team.map((r) => [r.ref, r]));
+    return own.map((r) => {
+        const t = byRef.get(r.ref);
+        return t ? { ...r, prs: t.prs, tests: t.tests, defects: t.defects, status: t.status, statusCode: t.statusCode } : r;
+    });
+}
+/**
+ * The health of a dot. A lead (KAT-405) answers for its team: `readMember` gives each member's answer, the kept one on the route and a
+ * fresh read here, so the lead's word is the worst of the members' words.
+ */
+export function healthOf(w, now = Date.now(), readMember = (m) => healthOf(m, now)) {
+    if (isLead(w))
+        return leadHealth(w, now, readMember);
+    return computeHealth(readHealthInput(w, now));
+}
+//# sourceMappingURL=dot-health.js.map