tinybeeai 0.0.0-stage → 0.16.1

package/demo/sample-app/server.ts

@@ -0,0 +1,163 @@
+// Tiny shop used by the demo. A seeded bug (checkout total ignores the discount) is toggled
+// with GET /__localdost/bug?on=1 so a simulated merge produces a real failing Playwright test.
+// Erasable TypeScript only, so Node 24 can run this file directly.
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
+import { pathToFileURL } from 'node:url';
+
+const PRODUCT = { sku: 'TRAIL-01', name: 'Trail Running Shoes', price: 120 };
+const CODES: Record<string, number> = { LOYAL10: 0.1, WELCOME5: 0.05 };
+
+let bugOn = false;
+let running: { server: Server; url: string } | undefined;
+
+interface Cart {
+  qty: number;
+  code: string;
+}
+
+function money(n: number): string {
+  return `$${n.toFixed(2)}`;
+}
+
+function readCart(req: IncomingMessage): Cart {
+  const raw = /(?:^|;\s*)cart=([^;]+)/.exec(req.headers.cookie ?? '')?.[1];
+  if (!raw) return { qty: 0, code: '' };
+  const [qty, code] = decodeURIComponent(raw).split(':');
+  return { qty: Math.max(0, Math.min(99, Number(qty) || 0)), code: (code ?? '').toUpperCase() };
+}
+
+/** The real pricing logic; the seeded bug skips the discount. */
+export function totals(cart: Cart, bug = bugOn) {
+  const subtotal = cart.qty * PRODUCT.price;
+  const rate = CODES[cart.code] ?? 0;
+  const discount = Math.round(subtotal * rate * 100) / 100;
+  const total = bug ? subtotal : subtotal - discount;
+  return { subtotal, discount, total };
+}
+
+function page(title: string, body: string): string {
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${title} | Demo Shop</title>
+<style>body{font-family:system-ui,sans-serif;max-width:480px;margin:24px auto;padding:0 16px;color:#1d1d29}
+button{background:#6059E4;color:#fff;border:0;border-radius:8px;padding:10px 16px;font-size:16px}
+input{padding:8px;font-size:16px;width:120px}label{display:block;margin:8px 0}
+dl{display:grid;grid-template-columns:1fr auto;gap:6px}dd{margin:0;text-align:right}</style>
+</head><body><header><a href="/">Demo Shop</a></header>${body}</body></html>`;
+}
+
+function send(res: ServerResponse, status: number, html: string, headers: Record<string, string> = {}): void {
+  res.writeHead(status, { 'content-type': 'text/html; charset=utf-8', ...headers });
+  res.end(html);
+}
+
+function json(res: ServerResponse, value: unknown): void {
+  res.writeHead(200, { 'content-type': 'application/json' });
+  res.end(JSON.stringify(value));
+}
+
+async function readBody(req: IncomingMessage): Promise<URLSearchParams> {
+  let data = '';
+  for await (const chunk of req) {
+    data += chunk;
+    if (data.length > 10_000) break;
+  }
+  return new URLSearchParams(data);
+}
+
+async function handle(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const url = new URL(req.url ?? '/', 'http://localhost');
+
+  if (url.pathname === '/health') return json(res, { ok: true, bug: bugOn });
+
+  if (url.pathname === '/__localdost/bug') {
+    bugOn = url.searchParams.get('on') === '1';
+    return json(res, { bug: bugOn });
+  }
+
+  if (url.pathname === '/' && req.method === 'GET') {
+    return send(
+      res,
+      200,
+      page(
+        PRODUCT.name,
+        `<main><h1>${PRODUCT.name}</h1><p data-testid="price">${money(PRODUCT.price)}</p>
+<form method="post" action="/cart">
+<label>Quantity <input name="qty" type="number" min="1" max="99" value="1"></label>
+<label>Discount code <input name="code" placeholder="LOYAL10"></label>
+<button type="submit">Add to cart</button></form></main>`,
+      ),
+    );
+  }
+
+  if (url.pathname === '/cart' && req.method === 'POST') {
+    const form = await readBody(req);
+    const qty = Math.max(1, Math.min(99, Number(form.get('qty')) || 1));
+    const code = (form.get('code') ?? '')
+      .trim()
+      .toUpperCase()
+      .replace(/[^A-Z0-9]/g, '');
+    res.writeHead(303, { location: '/checkout', 'set-cookie': `cart=${encodeURIComponent(`${qty}:${code}`)}; Path=/; HttpOnly; SameSite=Lax` });
+    res.end();
+    return;
+  }
+
+  if (url.pathname === '/checkout' && req.method === 'GET') {
+    const cart = readCart(req);
+    if (!cart.qty) return send(res, 200, page('Checkout', '<main><h1>Checkout</h1><p data-testid="empty">Your cart is empty.</p></main>'));
+    const t = totals(cart);
+    return send(
+      res,
+      200,
+      page(
+        'Checkout',
+        `<main><h1>Checkout</h1><dl>
+<dt>${cart.qty} x ${PRODUCT.name}</dt><dd data-testid="subtotal">${money(t.subtotal)}</dd>
+<dt>Discount${cart.code ? ` (${cart.code})` : ''}</dt><dd data-testid="discount">-${money(t.discount)}</dd>
+<dt><strong>Total</strong></dt><dd><strong data-testid="total">${money(t.total)}</strong></dd>
+</dl><button type="button">Pay now</button></main>`,
+      ),
+    );
+  }
+
+  send(res, 404, page('Not found', '<main><h1>Not found</h1></main>'));
+}
+
+async function stop(): Promise<void> {
+  const r = running;
+  running = undefined;
+  if (r) await new Promise<void>((resolve) => r.server.close(() => resolve()));
+}
+
+export async function startSampleApp(port = 4320): Promise<{ url: string; close: () => Promise<void> }> {
+  if (running) return { url: running.url, close: stop };
+  const server = createServer((req, res) => {
+    handle(req, res).catch((err) => {
+      res.writeHead(500);
+      res.end(String(err));
+    });
+  });
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject);
+    // no host: dual-stack, so both localhost (::1) and 127.0.0.1 reach it
+    server.listen(port, () => resolve());
+  });
+  // The shop never keeps a process alive on its own: a run or a test that started it in-process can still exit.
+  // The localdost server, when it runs, keeps the process up anyway.
+  server.unref();
+  running = { server, url: `http://localhost:${port}` };
+  return { url: running.url, close: stop };
+}
+
+export function setBug(on: boolean): void {
+  bugOn = on;
+}
+
+// `node server.ts` starts it standalone; the Playwright webServer uses this.
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const port = Number(process.argv[2] ?? 4320);
+  startSampleApp(port).then(({ url }) => {
+    // Standalone, the shop is the whole process, so it holds the process open.
+    running?.server.ref();
+    console.log(`demo shop on ${url}`);
+  });
+}

package/demo/sample-app/tests/checkout.spec.ts

@@ -0,0 +1,13 @@
+import { expect, test } from '@playwright/test';
+
+test('discount applied at checkout', async ({ page }) => {
+  await page.goto('/');
+  await page.getByLabel('Quantity').fill('1');
+  await page.getByLabel('Discount code').fill('LOYAL10');
+  await page.getByRole('button', { name: 'Add to cart' }).click();
+
+  await expect(page).toHaveURL(/\/checkout$/);
+  await expect(page.getByTestId('subtotal')).toHaveText('$120.00');
+  await expect(page.getByTestId('discount')).toHaveText('-$12.00');
+  await expect(page.getByTestId('total')).toHaveText('$108.00');
+});

package/demo/sample-app/tests/smoke.spec.ts

@@ -0,0 +1,8 @@
+import { expect, test } from '@playwright/test';
+
+test('home page loads @smoke', async ({ page }) => {
+  await page.goto('/');
+  await expect(page.getByRole('heading', { name: 'Trail Running Shoes' })).toBeVisible();
+  await expect(page.getByTestId('price')).toHaveText('$120.00');
+  await expect(page.getByRole('button', { name: 'Add to cart' })).toBeEnabled();
+});

package/dist/agent/approval-retries.js

@@ -0,0 +1,59 @@
+// Sends approved drafts again when their automatic retry is due (KAT-178). The schedule is the `retry` state on the
+// approval row (agent/send-retry.ts), so nothing lives only in memory: after a restart the first tick sends whatever
+// came due while the server was down.
+import { get, list, update } from '../db.js';
+import { publish } from '../events.js';
+import { log } from '../config.js';
+import { approveAction } from './rules.js';
+export const RETRY_TICK_MS = 15_000;
+const intervalSchedule = (fn, ms) => {
+    const t = setInterval(fn, ms);
+    t.unref?.();
+    return () => clearInterval(t);
+};
+/** Pending approvals whose retry is due at `now`. */
+export function dueRetries(now) {
+    return list('approvals', { status: 'pending' }).filter((a) => a.retry && Date.parse(a.retry.nextAt) <= now);
+}
+/**
+ * Sends every due retry once, one after the other. approveAction decides what comes next: a send that works
+ * ends the approval, a transient failure schedules the next retry, a permanent one puts the draft back in the Inbox.
+ * Returns how many it tried.
+ */
+export async function runDueRetries(opts = {}) {
+    const now = opts.now ?? Date.now;
+    const approve = opts.approve ?? approveAction;
+    const due = dueRetries(now());
+    for (const a of due) {
+        try {
+            await approve(a.id, undefined, { now, auto: true });
+        }
+        catch (err) {
+            log.warn(`approval ${a.id}: retry failed: ${String(err)}`);
+            // A failure that left the schedule untouched (the dot is gone, say) would repeat every tick: hand it back to a person.
+            const cur = get('approvals', a.id);
+            if (cur && cur.status === 'pending' && cur.retry?.nextAt === a.retry?.nextAt) {
+                update('approvals', a.id, { retry: null, error: err instanceof Error ? err.message : String(err) });
+                publish({ type: 'approval', approval: get('approvals', a.id) });
+            }
+        }
+    }
+    return due.length;
+}
+/** Starts the retry loop: one pass now, then one every `intervalMs`. Returns the function that stops it. */
+export function startApprovalRetries(opts = {}) {
+    let running = false;
+    const tick = () => {
+        if (running)
+            return;
+        running = true;
+        runDueRetries({ now: opts.now })
+            .catch((err) => log.warn(`approval retries: ${String(err)}`))
+            .finally(() => {
+            running = false;
+        });
+    };
+    tick();
+    return (opts.schedule ?? intervalSchedule)(tick, opts.intervalMs ?? RETRY_TICK_MS);
+}
+//# sourceMappingURL=approval-retries.js.map

package/dist/agent/approval-retries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-retries.js","sourceRoot":"","sources":["../../src/agent/approval-retries.ts"],"names":[],"mappings":"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"}

package/dist/agent/approvals.js

@@ -0,0 +1,390 @@
+// Approval queue hygiene (KAT-94): one pending approval per (action kind, target), and drafts whose
+// PR merged or closed, or whose commit is no longer the PR head, close on their own.
+import { db, get, list, update } from '../db.js';
+import { publish } from '../events.js';
+import { watchRepos } from '../repos.js';
+import { addStep, updateActionResult } from './runs.js';
+/**
+ * Drafts made for one head of a PR besides its comment and check: the defects found at that head, the new evidence
+ * for an existing defect, and the design questions on its ticket (dogfood ledger: defects for an older head of a PR).
+ */
+export function headScoped(action) {
+    const m = action.meta ?? {};
+    if (action.kind === 'file_defect' || action.kind === 'issue_create')
+        return typeof m.head === 'string' && !!m.head;
+    if (action.kind === 'ticket_comment')
+        return (m.defectComment === true || m.designQuestion === true || m.append === true) && typeof m.head === 'string' && !!m.head;
+    return false;
+}
+/** The PR an action belongs to: meta.pr, else the `#N` at the end of a `github:owner/repo#N` target. */
+export function prOf(action) {
+    // Only PR artifacts: a ticket comment on a GitHub issue has a `#N` target too, and it is not a PR.
+    const scoped = headScoped(action);
+    if (action.kind !== 'pr_comment' && action.kind !== 'check_run' && !scoped)
+        return undefined;
+    const n = Number(action.meta?.pr);
+    if (Number.isInteger(n) && n > 0)
+        return n;
+    if (scoped)
+        return undefined;
+    const m = /^github:[^#@\s]+#(\d+)$/.exec(action.target);
+    return m ? Number(m[1]) : undefined;
+}
+/**
+ * The repo a PR draft belongs to, lower case: from a `github:` target, else meta.repo ("owner/name"). A defect draft and
+ * its evidence comment name the repo the defect is filed in, which can be a tracker repo that holds no code (KAT-355),
+ * so for those meta.repo (the repo of the PR) wins.
+ */
+function repoOfAction(action) {
+    const metaRepo = typeof action.meta?.repo === 'string' ? action.meta.repo.toLowerCase() : undefined;
+    if (headScoped(action) && metaRepo)
+        return metaRepo;
+    return repoOfTarget(action.target) ?? metaRepo;
+}
+/**
+ * True when a PR-state change in `repo` may touch this draft. A PR number belongs to one repo, so in a dot with more than
+ * one repo a draft whose repo is unknown is left alone: it may be another repo's PR with the same number (KAT-323).
+ */
+function inRepoOf(a, repo, multiRepo) {
+    const target = repoOfAction(a.action);
+    if (!repo)
+        return true;
+    if (!target)
+        return !multiRepo;
+    return target === repo.toLowerCase();
+}
+function isMultiRepo(watchId) {
+    const w = get('watches', watchId);
+    return !!w && watchRepos(w).length > 1;
+}
+/** "owner/repo" of a `github:owner/repo#N` or `github:owner/repo@sha` target, lower case. */
+export function repoOfTarget(target) {
+    const m = /^github:([^#@\s]+)/.exec(target);
+    return m ? m[1].toLowerCase() : undefined;
+}
+/** A pending approval that has not passed its expiresAt. Only these count on the dot badge. */
+export function isLive(a, now = Date.now()) {
+    return a.status === 'pending' && !(a.expiresAt && Date.parse(a.expiresAt) <= now);
+}
+export function liveCount(watchId, now = Date.now()) {
+    const row = db
+        .prepare(`SELECT COUNT(*) AS n FROM approvals WHERE watchId = ? AND status = 'pending' AND (json_extract(extra, '$.expiresAt') IS NULL OR json_extract(extra, '$.expiresAt') > ?)`)
+        .get(watchId, new Date(now).toISOString());
+    return Number(row.n);
+}
+let checkCloseHook;
+/** rules.ts registers how an expired check_run draft closes its commit's check (KAT-285). */
+export function setCheckCloseHook(fn) {
+    checkCloseHook = fn;
+}
+/** Closes a pending approval without a decision. Its run records the action as blocked, with a step that says why. */
+export function closeApproval(a, status, closedReason, supersededBy) {
+    const decidedAt = new Date().toISOString();
+    const patch = { status, decidedAt, closedReason };
+    if (supersededBy)
+        patch.supersededBy = supersededBy;
+    update('approvals', a.id, patch);
+    const done = { ...a, status, decidedAt, closedReason, ...(supersededBy ? { supersededBy } : {}) };
+    publish({ type: 'approval', approval: done });
+    try {
+        updateActionResult(a.runId, a.id, 'blocked');
+        addStep(a.runId, `${status === 'superseded' ? 'Superseded' : 'Expired'}: ${a.action.title}`, closedReason, 'info');
+    }
+    catch {
+        /* run may be gone */
+    }
+    // An expired report no longer waits: its commit's check says so. A superseded one is replaced by a newer draft.
+    if (status === 'expired' && a.action.kind === 'check_run')
+        checkCloseHook?.(done, 'expired');
+    return done;
+}
+/**
+ * Kinds whose target names one outward artifact (the sticky PR comment, the check run for a sha, the defect
+ * with one signature), so a newer draft replaces an older one. An issue_create target ends in the defect
+ * signature, so two different failures never share a slot. Ticket comments append rather than upsert, and
+ * chat tool calls, Slack posts, pushes and report edits share targets across unrelated drafts, so they keep
+ * their own approvals.
+ */
+const ONE_PER_TARGET = new Set(['pr_comment', 'check_run', 'issue_create']);
+function sameSlot(a, b) {
+    // A comment a person wrote on an object card (meta.plain) is a new comment, not an edit of the sticky report: it replaces nothing.
+    if (a.meta?.plain === true || b.meta?.plain === true)
+        return false;
+    return ONE_PER_TARGET.has(a.kind) && a.kind === b.kind && a.target === b.target;
+}
+/**
+ * Keeps one pending draft per (action kind, target) for `fresh`. Run ids sort by start time, so the draft
+ * from the newer run wins even when an older run finishes later: then `fresh` itself is the one superseded.
+ */
+export function supersedeOlder(fresh) {
+    if (isTicketReviewDraft(fresh.action, fresh.runId))
+        return supersedeOlderTicketReviews(fresh);
+    if (!ONE_PER_TARGET.has(fresh.action.kind))
+        return [];
+    // A row with a failed send was approved by a person; it stays until they retry or reject it.
+    const same = list('approvals', { watchId: fresh.watchId, status: 'pending' }).filter((a) => a.id !== fresh.id && !a.error && sameSlot(a.action, fresh.action));
+    const newerRun = same.filter((a) => a.runId > fresh.runId).sort((x, y) => y.runId.localeCompare(x.runId))[0];
+    if (newerRun)
+        return [closeApproval(fresh, 'superseded', `A draft from a newer run for ${fresh.action.target} is already waiting.`, newerRun.id)];
+    return same.map((a) => closeApproval(a, 'superseded', `A newer draft for ${fresh.action.target} replaced this one.`, fresh.id));
+}
+/** Metadata that marks a ticket comment as some other flow's: a defect comment, a design question, a status label, a person's comment. */
+const NOT_A_REVIEW_META = ['defectComment', 'designQuestion', 'statusLabel', 'append', 'plain', 'askedBy'];
+const hasText = (v) => (typeof v === 'string' || typeof v === 'number') && String(v) !== '';
+/**
+ * The comment a ticket review run drafts on its ticket (src/flows/ticketReview.ts). Other ticket comments append and never replace.
+ * Drafts made before `meta.ticketReview` existed carry key, ticketId, tracker and url, and come from a ticket_review run or
+ * are titled "QA review for ...": those count too, so an upgrade still closes an older pending review (KAT-371).
+ */
+function isTicketReviewDraft(action, runId) {
+    if (action.kind !== 'ticket_comment')
+        return false;
+    const meta = action.meta ?? {};
+    if (meta.ticketReview === true)
+        return true;
+    if (NOT_A_REVIEW_META.some((k) => meta[k] !== undefined && meta[k] !== false))
+        return false;
+    if (!['key', 'ticketId', 'tracker', 'url'].every((k) => hasText(meta[k])))
+        return false;
+    if (action.title.startsWith('QA review for '))
+        return true;
+    return !!runId && get('runs', runId)?.kind === 'ticket_review';
+}
+/**
+ * A newer review run of the same ticket replaces the pending review draft of an older run, and the note names the newer
+ * run (KAT-371). Run ids sort by start time, so when the older run finishes last, its own draft is the one closed.
+ */
+function supersedeOlderTicketReviews(fresh) {
+    // A row with a failed send was approved by a person; it stays until they retry or reject it.
+    const same = list('approvals', { watchId: fresh.watchId, status: 'pending' }).filter((a) => a.id !== fresh.id && !a.error && a.runId !== fresh.runId && isTicketReviewDraft(a.action, a.runId) && a.action.target === fresh.action.target);
+    const newer = same.filter((a) => a.runId > fresh.runId).sort((x, y) => y.runId.localeCompare(x.runId))[0];
+    if (newer)
+        return [closeApproval(fresh, 'superseded', `A newer review of ${fresh.action.target} (run ${newer.runId}) is already waiting.`, newer.id)];
+    return same.map((a) => closeApproval(a, 'superseded', `A newer review of ${fresh.action.target} (run ${fresh.runId}) replaced this one.`, fresh.id));
+}
+/** A newer draft for the same slot went out without approval: the older pending drafts are stale. */
+export function supersedeBySent(watchId, action, runId) {
+    if (isTicketReviewDraft(action, runId)) {
+        // A review sent at once (rule act) closes the pending review drafts of older runs for the same ticket (KAT-371).
+        return list('approvals', { watchId, status: 'pending' })
+            .filter((a) => !a.error && a.runId < runId && isTicketReviewDraft(a.action, a.runId) && a.action.target === action.target)
+            .map((a) => closeApproval(a, 'superseded', `A newer review of ${action.target} (run ${runId}) was sent on its own.`));
+    }
+    if (!ONE_PER_TARGET.has(action.kind))
+        return [];
+    return list('approvals', { watchId, status: 'pending' })
+        .filter((a) => !a.error && sameSlot(a.action, action) && a.runId <= runId)
+        .map((a) => closeApproval(a, 'superseded', `A newer draft for ${action.target} was sent on its own.`));
+}
+/** Marks pending approvals past their expiresAt as expired. Returns how many it closed. */
+export function sweepTimeExpired(now = Date.now()) {
+    const due = list('approvals', { status: 'pending' }).filter((a) => a.expiresAt && Date.parse(a.expiresAt) <= now);
+    for (const a of due)
+        closeApproval(a, 'expired', 'Nobody decided before it expired.');
+    return due.length;
+}
+/** A defect draft (a new defect, or evidence for one): the bug outlives the PR that found it. */
+function isDefectDraft(action) {
+    // A new defect is drafted as issue_create (src/flows/defectDraft.ts) and carries the bug signature.
+    if (action.kind === 'issue_create')
+        return typeof action.meta?.bugSig === 'string' && action.meta.bugSig !== '';
+    return action.kind === 'file_defect' || (action.kind === 'ticket_comment' && action.meta?.defectComment === true);
+}
+function sameSha(a, b) {
+    return !!a && !!b && (a.startsWith(b) || b.startsWith(a));
+}
+/**
+ * Applies what is known about one PR to its pending approvals: a merged or closed PR expires them all (a merged PR keeps its pending defect drafts),
+ * and an open PR expires check-run and comment drafts written for a sha that is no longer its head.
+ * `before` (ISO) limits it to drafts created before the state was read, so a draft for a head that
+ * arrived after the lookup is never compared against the old state.
+ */
+export function applyPrState(watchId, pr, st, before, repo) {
+    const out = [];
+    const cutoff = before ? Date.parse(before) : NaN;
+    const multi = isMultiRepo(watchId);
+    for (const a of list('approvals', { watchId, status: 'pending' })) {
+        // A row with a failed send was approved by a person; it stays until they retry or reject it.
+        if (prOf(a.action) !== pr || a.error)
+            continue;
+        // The PR number is per repo: a draft for another repo's PR #N is not this one.
+        if (!inRepoOf(a, repo, multi))
+            continue;
+        // Compare as times: GitHub sends whole seconds, so a draft from that same second counts as newer.
+        if (Number.isFinite(cutoff) && Date.parse(a.createdAt) >= cutoff)
+            continue;
+        const meta = a.action.meta ?? {};
+        // A post-merge comment is written for a merged PR on purpose; only a closed PR ends it.
+        const afterMerge = meta.afterMerge === true;
+        // A merged PR keeps its pending defects: the bug now lives on the default branch (KAT-333). A closed PR expires them.
+        if (st.state === 'merged' && isDefectDraft(a.action)) {
+            if (st.mergeSha && meta.mergeSha !== st.mergeSha) {
+                update('approvals', a.id, { action: { ...a.action, meta: { ...meta, mergeSha: st.mergeSha } } });
+            }
+            continue;
+        }
+        if (st.state === 'closed' || (st.state === 'merged' && !afterMerge)) {
+            out.push(closeApproval(a, 'expired', `PR #${pr} is ${st.state}.`));
+            continue;
+        }
+        if (st.state !== 'open' || !st.headSha)
+            continue;
+        // A stale marker already names the new head; the other comment and check drafts name the head they reviewed.
+        const sha = String(a.action.kind === 'check_run' ? (meta.sha ?? '') : meta.stale === true ? '' : (meta.head ?? ''));
+        if (!sha || sameSha(sha, st.headSha))
+            continue;
+        if (a.action.kind === 'check_run' || a.action.kind === 'pr_comment') {
+            out.push(closeApproval(a, 'expired', `Commit ${sha.slice(0, 7)} is no longer the head of PR #${pr} (now ${st.headSha.slice(0, 7)}).`));
+        }
+        else if (headScoped(a.action)) {
+            // A defect found at an older head: the run for the new head drafts its own, if the bug is still there.
+            out.push(closeApproval(a, 'superseded', `It was drafted for ${sha.slice(0, 7)}, which is no longer the head of PR #${pr} (now ${st.headSha.slice(0, 7)}).`));
+        }
+    }
+    return out;
+}
+/**
+ * A run for a new head of a PR has started: every pending draft for an older head of that PR is superseded, defects and
+ * ticket comments included, without waiting for the Inbox to look the PR up. Drafts a person approved and whose send
+ * failed stay. Returns what it closed.
+ */
+export function supersedeOlderHeads(watchId, pr, head, repo, byRunId) {
+    if (!head)
+        return [];
+    const out = [];
+    const multi = isMultiRepo(watchId);
+    for (const a of list('approvals', { watchId, status: 'pending' })) {
+        if (a.error || prOf(a.action) !== pr)
+            continue;
+        if (!inRepoOf(a, repo, multi))
+            continue;
+        const meta = a.action.meta ?? {};
+        if (meta.afterMerge === true || meta.stale === true)
+            continue;
+        const sha = String(a.action.kind === 'check_run' ? (meta.sha ?? '') : (meta.head ?? ''));
+        if (!sha || sameSha(sha, head))
+            continue;
+        out.push(closeApproval(a, 'superseded', `PR #${pr} moved from ${sha.slice(0, 7)} to ${head.slice(0, 7)}; the run for the new head drafts its own.`, byRunId));
+    }
+    return out;
+}
+/** The PRs that pending approvals of a watch point at. With `repo` ("owner/repo"), only the PRs of that repo. */
+export function pendingPrs(watchId, repo) {
+    const prs = new Set();
+    for (const a of list('approvals', { watchId, status: 'pending' })) {
+        if (repo) {
+            const target = repoOfAction(a.action);
+            if (target && target !== repo.toLowerCase())
+                continue;
+        }
+        const pr = prOf(a.action);
+        if (pr)
+            prs.add(pr);
+    }
+    return [...prs];
+}
+/** Looks up each PR that has pending approvals and applies its state. A failed lookup leaves that PR alone. */
+export async function reconcilePrApprovals(watchId, lookup, 
+/** When the caller read the state it passes to lookup; drafts created later are left alone. */
+readAt, 
+/** "owner/repo" the lookup reads; drafts for other repos are left alone. */
+repo) {
+    const out = [];
+    for (const pr of pendingPrs(watchId, repo)) {
+        const before = readAt ?? new Date().toISOString();
+        let st;
+        try {
+            st = await lookup(pr);
+        }
+        catch {
+            continue;
+        }
+        if (st)
+            out.push(...applyPrState(watchId, pr, st, before, repo));
+    }
+    return out;
+}
+const lastInboxCheck = new Map();
+export const INBOX_CHECK_MS = 60_000;
+/** Inbox load: reconcile a watch at most once a minute. Returns false when the throttle skipped it. */
+export async function reconcileThrottled(watchId, lookup, now = Date.now(), repo) {
+    // The throttle is per dot and repo: a check of one repo must not skip the dot's other repos.
+    const key = repo ? `${watchId}|${repo.toLowerCase()}` : watchId;
+    const last = lastInboxCheck.get(key) ?? 0;
+    if (now - last < INBOX_CHECK_MS)
+        return false;
+    lastInboxCheck.set(key, now);
+    await reconcilePrApprovals(watchId, lookup, undefined, repo);
+    return true;
+}
+export function resetInboxThrottle() {
+    lastInboxCheck.clear();
+}
+// ---------- escalation categories and stats ----------
+const CATEGORY_RULES = [
+    ['reviewer_unavailable', /\b(review was unavailable|returned no decision)\b/i],
+    [
+        'secret_or_personal_data',
+        /\b(contains?|exposes?|includes?|leaks?|reveals?|shows?)\b[^.]*\b(credential|token|secret|password|api key|personal|username|email address)/i,
+    ],
+    ['untrusted_instruction', /\b(untrusted|injection)\b|\brepeats?\b[^.]*\binstruction/i],
+    ['must_not_rule', /\bmust not\b|must-not|owner's rule/i],
+    ['destructive', /\b(revert|force push|delet|destructive|changes the codebase)/i],
+    ['tone', /\b(hostile|blame|tone|rude)\b/i],
+    ['unsupported_claim', /\b(unsupported|evidence|substantiat|contradict|conflict|claim|exceed|inconsistent|unverified)/i],
+];
+/** Sorts a reviewer's one-sentence reason into a category. */
+export function classifyEscalation(reason) {
+    for (const [cat, re] of CATEGORY_RULES)
+        if (re.test(reason))
+            return cat;
+    return 'other';
+}
+/** The stored escalation, or one derived from the reason for rows written before KAT-94. */
+export function escalationOf(a) {
+    if (a.escalation)
+        return a.escalation;
+    const m = /^Auto-review escalated:\s*(.*)$/s.exec(a.reason ?? '');
+    if (m)
+        return { by: 'auto_review', category: classifyEscalation(m[1]) };
+    return { by: 'rule', category: 'rule_ask' };
+}
+/** Escalation stats per action kind over approvals and run actions created since `sinceIso`. */
+export function approvalStats(opts = {}) {
+    const since = opts.sinceIso ?? null;
+    const byKind = new Map();
+    const row = (kind) => {
+        let k = byKind.get(kind);
+        if (!k) {
+            k = { kind: kind, autoSent: 0, approvals: 0, byStatus: {}, escalatedByReview: 0, heldByRule: 0, escalationRate: null, categories: {} };
+            byKind.set(kind, k);
+        }
+        return k;
+    };
+    const inRange = (createdAt) => !since || createdAt >= since;
+    const approvals = list('approvals', opts.watchId ? { watchId: opts.watchId } : undefined).filter((a) => inRange(a.createdAt));
+    for (const a of approvals) {
+        const k = row(a.action.kind);
+        k.approvals++;
+        k.byStatus[a.status] = (k.byStatus[a.status] ?? 0) + 1;
+        const e = escalationOf(a);
+        if (e.by === 'auto_review')
+            k.escalatedByReview++;
+        else
+            k.heldByRule++;
+        k.categories[e.category] = (k.categories[e.category] ?? 0) + 1;
+    }
+    const runs = list('runs', opts.watchId ? { watchId: opts.watchId } : undefined).filter((r) => inRange(r.createdAt));
+    for (const r of runs) {
+        for (const x of r.actions ?? []) {
+            if (x.result === 'executed' && !x.approvalId)
+                row(x.action.kind).autoSent++;
+        }
+    }
+    for (const k of byKind.values()) {
+        const d = k.escalatedByReview + k.autoSent;
+        k.escalationRate = d ? Math.round((k.escalatedByReview / d) * 1000) / 1000 : null;
+    }
+    return { since, kinds: [...byKind.values()].sort((a, b) => a.kind.localeCompare(b.kind)) };
+}
+//# sourceMappingURL=approvals.js.map