tinybeeai 0.0.0-stage → 0.16.1

package/dist/monitor/pollers.js

@@ -0,0 +1,1606 @@
+// Poll mode (KAT-31): lets localdost work with no public webhook URL.
+// GitHub: new commits on the default branch and open PRs with a new head sha.
+// GitHub issues: issues opened, edited, or brought into scope in the tracker repos.
+// Linear: issues created in the watched teams.
+// Jira (KAT-98): issues created in the watched projects, and description or acceptance-criteria edits.
+// Each poll builds the same payload the webhook would carry, runs it through the
+// same normalizer, and hands the TriggerEvent to dispatchTrigger, so the events
+// row, job kind, and dedupe follow the webhook path exactly.
+import { existsSync, readFileSync } from 'node:fs';
+import { db, findOne, list } from '../db.js';
+import { liveEnv, log } from '../config.js';
+import { sandboxOn, sandboxSkips } from '../sandbox.js';
+import { dispatchTrigger, reviewedHead } from '../webhooks.js';
+import { hasInclusionRule, resolvePrScope } from '../pr-scope.js';
+import { gapText } from './catch-up.js';
+import { describeFetchError, githubMode, normalizeGithub, pullSummary } from '../integrations/github.js';
+import { reconcilePrApprovals } from '../agent/approvals.js';
+import { hasLegacyDefectMarker, hasValidBotMarker } from '../integrations/bot-marker.js';
+import { normalizeLinear } from '../integrations/linear.js';
+import { isOwnWrite, ownIds, rememberOwnId } from '../integrations/own-identity.js';
+import { handleNewComments, hasAnswerWork } from '../flows/answers.js';
+import { bodyHash, issueApi, issueInScope, issueState, normalizeGithubIssue, recordIssue, reviewedSameBody, scopeSig, trackerRepos, } from '../integrations/github-issues.js';
+import { findRepo, primaryRepo, watchRepos } from '../repos.js';
+import { jiraFor, normalizeJira } from '../integrations/jira.js';
+import { backfillLimitOf, explicitBackfillLimit } from './backfill.js';
+import { capState } from '../model-usage.js';
+/** Re-read a few seconds of history each poll so clock skew between us and the API never drops an item. Dedupe absorbs the repeats. */
+const OVERLAP_MS = 30_000;
+const TICK_MS = 5_000;
+const MAX_PR_SHAS = 500;
+/**
+ * A stored cursor older than this is treated as missing, so a long outage re-records the
+ * cursor instead of replaying hours of history. A short restart catches up from the cursor.
+ */
+export const STALE_CURSOR_MS = 60 * 60_000;
+const isFresh = (iso, now) => !!iso && now.getTime() - Date.parse(iso) <= STALE_CURSOR_MS;
+// liveEnv: tokens saved in Setup count, and a change applies on the next tick.
+const env = () => liveEnv;
+const flag = (v) => v === '1' || v === 'true' || v === 'yes';
+const ghApi = () => (env().GITHUB_API_URL ?? 'https://api.github.com').replace(/\/$/, '');
+const ghServer = () => (env().GITHUB_SERVER_URL ?? 'https://github.com').replace(/\/$/, '');
+const linearApi = () => env().LINEAR_API_URL ?? 'https://api.linear.app/graphql';
+export function githubPollSec() {
+    return Math.max(10, Number(env().POLL_GITHUB_SEC) || 60);
+}
+export function linearPollSec() {
+    return Math.max(10, Number(env().POLL_LINEAR_SEC) || 60);
+}
+export function jiraPollSec() {
+    return Math.max(10, Number(env().POLL_JIRA_SEC) || 60);
+}
+export function wantsJiraPoll(w) {
+    return !w.paused && !w.archived && w.tracker?.kind === 'jira' && !!w.tracker.projectKeys?.length && (flag(env().LOCALDOST_POLL) || w.pollJira === true);
+}
+export function wantsGithubPoll(w) {
+    return !w.paused && !w.archived && watchRepos(w).length > 0 && (flag(env().LOCALDOST_POLL) || w.pollGithub === true);
+}
+/** GitHub issue polls: a dot with a github tracker, under the same flags as GitHub polls. */
+export function wantsGithubIssuesPoll(w) {
+    return !w.paused && !w.archived && w.tracker?.kind === 'github' && trackerRepos(w).length > 0 && (flag(env().LOCALDOST_POLL) || w.pollGithub === true);
+}
+export function wantsLinearPoll(w) {
+    return !w.paused && !w.archived && w.tracker?.kind === 'linear' && !!w.tracker.teamKeys?.length && (flag(env().LOCALDOST_POLL) || w.pollLinear === true);
+}
+// Cursor store
+let cursorTableReady = false;
+function ensureCursorTable() {
+    if (cursorTableReady)
+        return;
+    db.exec('CREATE TABLE IF NOT EXISTS poll_cursors (id TEXT PRIMARY KEY, value TEXT NOT NULL, updatedAt TEXT NOT NULL)');
+    cursorTableReady = true;
+}
+export function getCursor(key) {
+    ensureCursorTable();
+    const row = db.prepare('SELECT value FROM poll_cursors WHERE id = ?').get(key);
+    if (!row)
+        return undefined;
+    try {
+        return JSON.parse(row.value);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Deletes the poll cursors a dot owns (Jira and Linear are per dot, and so is its first-poll mark and its ticket backfill; GitHub repo
+ * cursors belong to the repo and stay). Returns how many went.
+ */
+export function deleteWatchCursors(watchId) {
+    ensureCursorTable();
+    const seeds = `github-seed:${watchId}:`;
+    const backfills = `${BACKFILL_PREFIX}${watchId}:`;
+    const res = db
+        .prepare('DELETE FROM poll_cursors WHERE id IN (?, ?) OR substr(id, 1, ?) = ? OR substr(id, 1, ?) = ?')
+        .run(`jira:${watchId}`, `linear:${watchId}`, seeds.length, seeds, backfills.length, backfills);
+    return Number(res.changes);
+}
+export function setCursor(key, value) {
+    ensureCursorTable();
+    db.prepare('INSERT INTO poll_cursors (id, value, updatedAt) VALUES (?, ?, ?) ON CONFLICT(id) DO UPDATE SET value = excluded.value, updatedAt = excluded.updatedAt').run(key, JSON.stringify(value), new Date().toISOString());
+}
+// Poll health (KAT-363)
+/** Polls in a row that fail before a dot says it is not listening. */
+export const POLL_FAILURES_BEFORE_ALARM = 3;
+/** Per poll key (the cursor key of a repo or of a repo's issues). In memory: a restart starts with no failures and the next polls say again. */
+const pollHealth = new Map();
+/** A poll error in a few plain words: "HTTP 401: Bad credentials" instead of the request path and the JSON body. */
+export function pollErrorText(err) {
+    const raw = err instanceof Error ? err.message : String(err);
+    const http = /failed: HTTP (\d{3})\s*([\s\S]*)$/.exec(raw);
+    if (http) {
+        let why = '';
+        try {
+            const m = JSON.parse(http[2]).message;
+            if (typeof m === 'string')
+                why = m;
+        }
+        catch {
+            why = http[2].trim();
+        }
+        return `HTTP ${http[1]}${why ? `: ${why.slice(0, 100)}` : ''}`;
+    }
+    return raw.replace(/^GitHub GET \S+ failed: /, '').slice(0, 140);
+}
+/** Records how a poll ended: a failure adds to the run of failures, a success ends it. */
+export function recordPollResult(key, err, now = new Date()) {
+    if (err === undefined) {
+        pollHealth.delete(key);
+        return;
+    }
+    pollHealth.set(key, { failures: (pollHealth.get(key)?.failures ?? 0) + 1, error: pollErrorText(err), at: now.toISOString() });
+}
+/** Forgets every recorded poll result. Tests call it between cases. */
+export function clearPollHealth() {
+    pollHealth.clear();
+}
+/** The polls a dot depends on: the cursor key of each repo and of each tracker repo's issues, with the name to show. */
+function pollKeysOf(w) {
+    const out = [];
+    if (wantsGithubPoll(w))
+        for (const r of watchRepos(w))
+            out.push({ key: githubRepoCursorKey(r), label: `${r.owner}/${r.name}` });
+    if (wantsGithubIssuesPoll(w))
+        for (const full of trackerRepos(w))
+            out.push({ key: githubIssuesCursorKey(full), label: `${full} issues` });
+    return out;
+}
+/** The poll of this dot that has failed POLL_FAILURES_BEFORE_ALARM times or more in a row (the one with most failures), or null. */
+export function pollFailureFor(w) {
+    let worst = null;
+    for (const { key, label } of pollKeysOf(w)) {
+        const h = pollHealth.get(key);
+        if (h && h.failures >= POLL_FAILURES_BEFORE_ALARM && (!worst || h.failures > worst.failures))
+            worst = { label, ...h };
+    }
+    return worst;
+}
+let appAuth = null;
+const installationIds = new Map();
+function loadPrivateKey() {
+    const raw = env().GITHUB_PRIVATE_KEY ?? '';
+    if (!raw.includes('-----BEGIN') && existsSync(raw))
+        return readFileSync(raw, 'utf8');
+    return raw.replace(/\\n/g, '\n');
+}
+/** Same token logic as the live GitHub client: PAT, or an App installation token for the repo. */
+async function defaultGithubToken(full, f) {
+    if (githubMode() === 'pat')
+        return env().GITHUB_TOKEN;
+    appAuth ??= import('@octokit/auth-app').then(({ createAppAuth }) => createAppAuth({ appId: env().GITHUB_APP_ID, privateKey: loadPrivateKey() }));
+    const auth = await appAuth;
+    let id = installationIds.get(full);
+    if (!id) {
+        const { token: jwt } = await auth({ type: 'app' });
+        const res = await f(`${ghApi()}/repos/${full}/installation`, { headers: ghHeaders(jwt) });
+        if (!res.ok)
+            throw new Error(`GitHub App is not installed on ${full} (HTTP ${res.status})`);
+        id = (await res.json()).id;
+        installationIds.set(full, id);
+    }
+    return (await auth({ type: 'installation', installationId: id })).token;
+}
+function ghHeaders(token) {
+    return {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+        'User-Agent': 'localdost-poller',
+    };
+}
+async function ghGet(f, token, path) {
+    let res;
+    try {
+        res = await f(`${ghApi()}${path}`, { headers: ghHeaders(token) });
+    }
+    catch (err) {
+        // Node's fetch hides the reason (ENOTFOUND, ETIMEDOUT, ECONNRESET, a TLS error) in err.cause.
+        throw new Error(`GitHub GET ${path.split('?')[0]} failed: ${describeFetchError(err)}`, { cause: err });
+    }
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw Object.assign(new Error(`GitHub GET ${path.split('?')[0]} failed: HTTP ${res.status} ${text.slice(0, 200)}`), { status: res.status });
+    }
+    return (await res.json());
+}
+/** Cursor key of a repo and branch. Shared by every dot that holds the repo, so it is polled once. */
+export function githubRepoCursorKey(r) {
+    return `github:${r.owner}/${r.name}:${r.defaultBranch || 'main'}`.toLowerCase();
+}
+/** Cursor key of the watch's first app repo (the repo a single-repo dot watches). */
+export function githubCursorKey(w) {
+    const r = primaryRepo(w) ?? watchRepos(w)[0];
+    if (!r)
+        throw new Error(`${w.name} watches no repo`);
+    return githubRepoCursorKey(r);
+}
+/** Ids of every watch that holds the repo `full` (any role, any branch). */
+function watchIdsOnRepo(full) {
+    const ids = new Set();
+    try {
+        for (const o of list('watches')) {
+            if (watchRepos(o).some((r) => `${r.owner}/${r.name}`.toLowerCase() === full.toLowerCase()))
+                ids.add(o.id);
+        }
+    }
+    catch (err) {
+        log.warn(`cannot list watches for ${full}: ${String(err)}`);
+    }
+    return [...ids];
+}
+/**
+ * The union of repos to poll across these watches, one entry per repo and branch
+ * (docs/MULTI-REPO.md section 1.4): a repo shared by three dots is polled once.
+ */
+export function githubPollTargets(watches) {
+    const out = new Map();
+    for (const w of watches) {
+        if (!wantsGithubPoll(w))
+            continue;
+        for (const r of watchRepos(w)) {
+            const t = { owner: r.owner, name: r.name, defaultBranch: r.defaultBranch };
+            const key = githubRepoCursorKey(t);
+            // A full poll (commits and PRs) of a branch wins over a branch-only poll of the same key.
+            if (!out.has(key) || out.get(key).branchOnly)
+                out.set(key, t);
+            // The test branches of the dot (KAT-292) are polled for new commits too, once per repo and branch.
+            if (r.role !== 'app')
+                continue;
+            for (const b of w.testBranches ?? []) {
+                const bt = { owner: r.owner, name: r.name, defaultBranch: b, branchOnly: true };
+                const bkey = githubRepoCursorKey(bt);
+                if (!out.has(bkey))
+                    out.set(bkey, bt);
+            }
+        }
+    }
+    return out;
+}
+/** One GitHub poll of the watch's first app repo. See pollGithubRepoOnce. */
+export async function pollGithubOnce(w, deps = {}) {
+    const r = primaryRepo(w) ?? watchRepos(w)[0];
+    if (!r)
+        return { baseline: false, triggers: [], results: [] };
+    return pollGithubRepoOnce({ owner: r.owner, name: r.name, defaultBranch: r.defaultBranch }, deps);
+}
+/**
+ * One GitHub poll of a repo's default branch and open PRs. With no fresh cursor it only records one.
+ * Later calls dispatch one `push` for any new commits on the default branch (before = last seen sha)
+ * and one `pr_opened` per open PR whose head sha changed since the last poll. Dispatch matches the
+ * events to every dot that holds the repo.
+ * No inlineDiff is set, so the flows fetch the diff through githubFor.
+ */
+export async function pollGithubRepoOnce(target, deps = {}) {
+    const f = deps.fetch ?? fetch;
+    const now = (deps.now ?? (() => new Date()))();
+    const { owner, name } = target;
+    const branch = target.defaultBranch || 'main';
+    const full = `${owner}/${name}`;
+    const token = await (deps.githubToken ? deps.githubToken(full) : defaultGithubToken(full, f));
+    const key = githubRepoCursorKey(target);
+    const stored = getCursor(key) ?? {};
+    const baseline = !stored.sha || !isFresh(stored.prsSince, now);
+    // A cursor that went stale (KAT-363): the server did not poll since `stored.prsSince`. The commits are re-recorded as before,
+    // but the PRs updated since are caught up, told from the ones the dot saw by the PR map of that old cursor.
+    const gapSince = baseline && stored.sha && stored.prsSince ? stored.prsSince : undefined;
+    // On a baseline poll the PR map starts empty so closed PRs from an old cursor drop out.
+    const cur = gapSince
+        ? {
+            sha: stored.sha,
+            prsSince: stored.prsSince,
+            ...(stored.prShas ? { prShas: stored.prShas } : {}),
+            ...(stored.prDraft ? { prDraft: stored.prDraft } : {}),
+        }
+        : baseline
+            ? { sha: stored.sha }
+            : stored;
+    const repository = { owner: { login: owner }, name, full_name: full, default_branch: branch };
+    const triggers = [];
+    // Commits on the default branch, newest first.
+    // refs/heads/ pins the branch: a bare name could also resolve to a tag of the same name.
+    let commits;
+    try {
+        commits = await ghGet(f, token, `/repos/${full}/commits?sha=${encodeURIComponent(`refs/heads/${branch}`)}&per_page=50`);
+    }
+    catch (err) {
+        // A listed test branch (KAT-292) exists in some repos of a dot only. Its absence in this repo is no error:
+        // nothing to run, nothing to log every cycle. The repo's default branch poll is a separate target.
+        if (target.branchOnly && err.status === 404)
+            return { baseline: false, triggers: [], results: [] };
+        throw err;
+    }
+    const head = commits[0]?.sha;
+    if (!baseline && head && cur.sha && head !== cur.sha) {
+        const ev = normalizeGithub('push', {
+            ref: `refs/heads/${branch}`,
+            before: cur.sha,
+            after: head,
+            head_commit: { message: commits[0]?.commit?.message ?? '' },
+            compare: `${ghServer()}/${full}/compare/${cur.sha.slice(0, 12)}...${head.slice(0, 12)}`,
+            repository,
+        });
+        if (ev)
+            triggers.push(ev);
+    }
+    // A test branch of a dot is polled for commits only: its pull requests belong to the default branch's poll.
+    if (target.branchOnly) {
+        setCursor(key, { sha: head ?? cur.sha, prsSince: now.toISOString() });
+        if (baseline)
+            return { baseline, triggers: [], results: [] };
+        return { baseline, triggers, results: await dispatchResolved(triggers) };
+    }
+    // Open PRs, most recently updated first. Stop at the first one older than the last poll.
+    const since = cur.prsSince ? Date.parse(cur.prsSince) - OVERLAP_MS : 0;
+    const fresh = baseline && !gapSince;
+    const prShas = fresh ? {} : { ...(cur.prShas ?? {}) };
+    const drafts = fresh ? {} : { ...(cur.prDraft ?? {}) };
+    const listedAt = new Date().toISOString();
+    const pulls = await ghGet(f, token, `/repos/${full}/pulls?state=open&sort=updated&direction=desc&per_page=50`);
+    // After a gap every PR that changed since is a catch-up event, newest update first; dispatchCatchUp caps what each dot takes.
+    const take = (ev) => {
+        if (!ev)
+            return;
+        if (gapSince)
+            ev.catchUp = { since: gapSince, gapMs: now.getTime() - Date.parse(gapSince) };
+        triggers.push(ev);
+    };
+    for (const pr of pulls) {
+        const n = String(pr.number);
+        const sha = String(pr.head?.sha ?? '');
+        if (fresh) {
+            prShas[n] = sha;
+            if (pr.draft === true)
+                drafts[n] = true;
+            continue;
+        }
+        if (Date.parse(pr.updated_at) < since)
+            break;
+        const wasDraft = drafts[n] === true;
+        if (pr.draft === true)
+            drafts[n] = true;
+        else
+            delete drafts[n];
+        if (!sha)
+            continue;
+        if (prShas[n] === sha) {
+            // A draft turning ready keeps its head, so the head check alone would never see it (KAT-354).
+            if (wasDraft && pr.draft !== true)
+                take(normalizeGithub('pull_request', { action: 'ready_for_review', number: pr.number, pull_request: pr, repository }));
+            continue;
+        }
+        const isNew = !(n in prShas) && Date.parse(pr.created_at) >= since;
+        prShas[n] = sha;
+        take(normalizeGithub('pull_request', { action: isNew ? 'opened' : 'synchronize', number: pr.number, pull_request: pr, repository }));
+    }
+    // Pending approvals for a PR that merged, closed, or moved its head expire (KAT-94). Open PRs come
+    // from the list above; any other PR with a pending draft is looked up once. Polls are scheduled per
+    // repo and branch, so this poll reconciles every watch on the repo, not only the one passed in.
+    const open = new Map(pulls.map((p) => [Number(p.number), String(p.head?.sha ?? '')]));
+    const looked = new Map();
+    const lookup = async (n) => {
+        const sha = open.get(n);
+        if (sha !== undefined)
+            return { state: 'open', headSha: sha };
+        let p = looked.get(n);
+        if (!p) {
+            p = ghGet(f, token, `/repos/${full}/pulls/${n}`).then((raw) => {
+                const s = pullSummary(raw);
+                return { state: s.state, headSha: s.headSha, ...(s.mergeSha ? { mergeSha: s.mergeSha } : {}) };
+            });
+            looked.set(n, p);
+        }
+        return p;
+    };
+    for (const id of watchIdsOnRepo(full)) {
+        try {
+            await reconcilePrApprovals(id, lookup, listedAt, full);
+        }
+        catch (err) {
+            log.warn(`approval check for ${full} (watch ${id}) failed: ${String(err)}`);
+        }
+    }
+    const keep = Object.entries(prShas).slice(-MAX_PR_SHAS);
+    const keepDrafts = Object.entries(drafts).slice(-MAX_PR_SHAS);
+    setCursor(key, {
+        sha: head ?? cur.sha,
+        prsSince: now.toISOString(),
+        prShas: Object.fromEntries(keep),
+        ...(keepDrafts.length ? { prDraft: Object.fromEntries(keepDrafts) } : {}),
+    });
+    // A dot's first poll of the repo also takes the PRs that are already open (KAT-352), apart from the ones this poll sends to everyone.
+    const first = await seedFirstPoll(full, pulls, repository, now, triggers);
+    if (fresh)
+        return { baseline, triggers: first.triggers, results: first.results };
+    const results = gapSince ? await dispatchCatchUp(triggers, true) : await dispatchResolved(triggers);
+    if (gapSince)
+        logCatchUp(`poll ${full}`, 'open PR(s)', now.getTime() - Date.parse(gapSince), triggers.length, results);
+    return { baseline: baseline && !gapSince, triggers: [...triggers, ...first.triggers], results: [...results, ...first.results] };
+}
+/** Dispatches each event after reading what the dots' PR scope rules need from GitHub (src/pr-scope.ts). */
+async function dispatchResolved(events, opts) {
+    const out = [];
+    for (const ev of events)
+        out.push(dispatchTrigger(await resolvePrScope(ev), opts));
+    return out;
+}
+/** How many open PRs a dot takes on its first poll of a repo, most recently updated first. */
+export const FIRST_POLL_PRS = 5;
+/** How many PRs, and how many issues, a dot takes from a poll that catches up after a gap, newest first. The same as a first poll. */
+export const CATCH_UP_MAX = FIRST_POLL_PRS;
+/**
+ * Dispatches catch-up events (KAT-363), newest first. Each dot takes at most CATCH_UP_MAX of them, counted after its own scope
+ * and after the reviews it already has: on a repo shared by several teams the PRs of the others would otherwise fill the
+ * cap and leave this dot's own out. A dot that has taken its share gets no more events from this poll.
+ */
+async function dispatchCatchUp(events, scoped) {
+    const out = [];
+    const dots = list('watches')
+        .filter((w) => !w.paused && !w.archived)
+        .map((w) => w.id);
+    const taken = new Map();
+    for (const ev of events) {
+        const open = dots.filter((id) => (taken.get(id) ?? 0) < CATCH_UP_MAX);
+        if (!open.length)
+            break;
+        const res = dispatchTrigger(scoped ? await resolvePrScope(ev) : ev, { onlyWatchIds: open });
+        out.push(res);
+        for (const j of res.jobs)
+            taken.set(j.watchId, (taken.get(j.watchId) ?? 0) + 1);
+    }
+    return out;
+}
+function logCatchUp(what, noun, gapMs, found, results) {
+    const jobs = results.reduce((n, r) => n + r.jobs.length, 0);
+    log.info(`${what}: no poll for ${gapText(gapMs)}; ${found ? `${found} ${noun} changed since, ${jobs} queued` : `no ${noun} changed since`}`);
+}
+/**
+ * First poll of a dot (KAT-352): before this, the poller recorded a cursor and queued nothing, so a dot made in the app
+ * stayed quiet about the PRs already open. Each dot that polls the repo and has not had its first poll gets the
+ * FIRST_POLL_PRS most recently updated open PRs as `pr_opened` events, sent to that dot only. The mark is stored per
+ * dot and repo. A dot older than STALE_CURSOR_MS at its first poll was already running, so it gets the mark and no
+ * events (an upgrade or a re-enabled poller never replays PRs). A PR that this poll already sends to every dot, or
+ * that the dot reviewed at this head, is left out.
+ *
+ * A new dot has had no moment to say whose PRs it takes, and a shared repo holds the PRs of other teams. So the first
+ * look applies the repo's PR scope like any event, and, unless the scope names authors, a team or linked issue labels,
+ * marks each event `firstLook`: its PR comment and check wait for approval (src/agent/rules.ts).
+ */
+async function seedFirstPoll(full, pulls, repository, now, sent) {
+    const out = { triggers: [], results: [] };
+    const [owner, name] = full.split('/');
+    const already = new Set(sent.filter((e) => e.kind === 'pr_opened').map((e) => `${e.pr?.number}@${e.pr?.headSha}`));
+    for (const w of list('watches')) {
+        const entry = findRepo(w, { owner, name });
+        if (!wantsGithubPoll(w) || entry?.role !== 'app')
+            continue;
+        const mark = `github-seed:${w.id}:${full}`.toLowerCase();
+        if (getCursor(mark))
+            continue;
+        setCursor(mark, { at: now.toISOString() });
+        // A dot that was running long before its first poll is not new. A createdAt after the poll clock counts as new.
+        if (now.getTime() - Date.parse(w.createdAt) > STALE_CURSOR_MS)
+            continue;
+        const hold = !hasInclusionRule(entry.prScope);
+        let taken = 0;
+        for (const pr of pulls.slice(0, FIRST_POLL_PRS)) {
+            const ev = normalizeGithub('pull_request', { action: 'opened', number: pr.number, pull_request: pr, repository });
+            if (!ev || already.has(`${ev.pr?.number}@${ev.pr?.headSha}`) || reviewedHead(w.id, ev))
+                continue;
+            taken++;
+            const first = hold ? { ...ev, firstLook: true } : ev;
+            if (!out.triggers.some((t) => t.dedupeKey === ev.dedupeKey))
+                out.triggers.push(first);
+            out.results.push(...(await dispatchResolved([first], { onlyWatchIds: [w.id] })));
+        }
+        log.info(`${w.name}: first poll of ${full} looked at ${taken} open PR(s)`);
+    }
+    return out;
+}
+// GitHub issues
+/** Pages of 100 issues one poll reads at most; the rest waits for the next poll. */
+const ISSUE_PAGES = 5;
+export function githubIssuesCursorKey(full) {
+    return `github-issues:${full}`.toLowerCase();
+}
+/**
+ * A marker counts only on an issue the dot's own account wrote. With a PAT, ask who the token belongs to
+ * when an issue carries a valid marker; an App is recognized by the issue itself.
+ */
+async function rememberGithubIdentity(rows, f, token) {
+    if (githubMode() === 'pat' && !ownIds('github').length && rows.some((r) => hasValidBotMarker(r.body) || hasLegacyDefectMarker(r.body))) {
+        try {
+            rememberOwnId('github', ((await ghGet(f, token, '/user')).login ?? '').toLowerCase());
+        }
+        catch {
+            /* unknown identity: the issue is reviewed rather than skipped */
+        }
+    }
+}
+/**
+ * The events of issue rows read from `since` on (oldest first): `opened` for an issue created since, `edited` when the body or
+ * title hash differs from issue_state, a scope event when a label, type, or milestone was added. Every row is recorded in
+ * issue_state. Any issue seen for the first time that was created before `since` is recorded and queues nothing, since its
+ * old text is unknown.
+ */
+async function issueEvents(full, rows, since, f, token) {
+    const [owner, name] = full.split('/');
+    const repository = { owner: { login: owner }, name, full_name: full };
+    await rememberGithubIdentity(rows, f, token);
+    const triggers = [];
+    const emit = (action, issue, extra = {}) => {
+        const ev = normalizeGithubIssue('issues', { action, issue, repository, sender: issue.user, ...extra });
+        if (ev)
+            triggers.push(ev);
+    };
+    for (const issue of rows) {
+        if (issue.pull_request)
+            continue;
+        const prev = issueState(full, Number(issue.number));
+        if (!prev) {
+            if (Date.parse(issue.created_at) >= since)
+                emit('opened', issue);
+        }
+        else if (prev.bodyHash !== bodyHash(issue.title, issue.body)) {
+            emit('edited', issue, { changes: { body: { from: '' } } });
+        }
+        else if (prev.scopeSig !== scopeSig(issue)) {
+            const before = JSON.parse(prev.scopeSig);
+            const after = JSON.parse(scopeSig(issue));
+            for (const label of after.labels.filter((l) => !before.labels.includes(l)))
+                emit('labeled', issue, { label: { name: label } });
+            if (after.type && after.type !== before.type)
+                emit('typed', issue);
+            if (after.milestone && after.milestone !== before.milestone)
+                emit('milestoned', issue, { milestone: issue.milestone });
+        }
+        recordIssue(full, issue);
+    }
+    return triggers;
+}
+/**
+ * The poll after a stale cursor (KAT-363): the server did not poll `full` since `cur.polledAt`, so nothing updated in the gap
+ * was seen. It reads the 100 most recently updated issues since the cursor, tells what changed from issue_state like a normal poll,
+ * and dispatches the events newest first, each dot taking at most CATCH_UP_MAX after its tracker scope (dispatchCatchUp). Each
+ * event says so (`catchUp`).
+ */
+async function catchUpIssues(full, cur, now, f, token, key) {
+    const since = Date.parse(cur.since) - OVERLAP_MS;
+    const rows = await ghGet(f, token, `/repos/${full}/issues?state=all&sort=updated&direction=desc&since=${encodeURIComponent(new Date(since).toISOString())}&per_page=100`);
+    // Told from issue_state oldest first, as a normal poll does, then dispatched newest first.
+    const events = (await issueEvents(full, [...rows].reverse(), since, f, token)).reverse();
+    const gapSince = cur.polledAt ?? cur.since;
+    const gapMs = now.getTime() - Date.parse(gapSince);
+    for (const ev of events)
+        ev.catchUp = { since: gapSince, gapMs };
+    setCursor(key, { since: now.toISOString(), polledAt: now.toISOString() });
+    const results = await dispatchCatchUp(events, false);
+    logCatchUp(`poll ${full} issues`, 'issue event(s)', gapMs, events.length, results);
+    return { baseline: false, triggers: events, results };
+}
+/**
+ * One issue poll for a repo (shared by every dot whose tracker lists it). With no cursor it records one, and each dot starts its ticket
+ * backfill (seedGithubBackfills). Later calls
+ * read issues updated since the cursor, oldest first, and dispatch what issueEvents finds. The baseline records the 100 most
+ * recently updated open issues. A cursor older than STALE_CURSOR_MS is caught up instead (catchUpIssues).
+ */
+export async function pollGithubIssuesOnce(full, deps = {}) {
+    const out = await readGithubIssues(full, deps);
+    // A dot that has not picked its backfill yet picks it now, on the first poll of the tracker or on a poll after the dot was made (KAT-381).
+    try {
+        const started = await seedGithubBackfills(full, deps);
+        out.triggers.push(...started.triggers);
+        out.results.push(...started.results);
+    }
+    catch (err) {
+        log.warn(`poll ${full} issues: ticket backfill failed: ${pollErrorText(err)}`);
+    }
+    // New comments under tickets the dot reviewed that have open questions can start a second review (KAT-393). A failure only logs: the
+    // comment cursor stays where it was, so the next poll reads the same comments again.
+    try {
+        const t = await pollIssueAnswers(full, deps);
+        if (t.queued || t.joined || t.limit)
+            log.info(`poll ${full} issues: comments: ${t.queued} review(s) queued, ${t.joined} joined to a waiting review, ${t.limit} over the daily limit`);
+    }
+    catch (err) {
+        log.warn(`poll ${full} issues: could not read the comments: ${pollErrorText(err)}`);
+    }
+    return out;
+}
+// Answers under reviewed tickets (KAT-393)
+/** Pages of 100 comments one poll reads at most; the rest waits for the next poll. */
+const COMMENT_PAGES = 3;
+/** A comment that GitHub could not be asked about (the issue read or the write-access check failed) is read again by the next poll, for this long. After that the cursor moves on. */
+export const COMMENT_RETRY_MS = 60 * 60_000;
+export function githubCommentsCursorKey(full) {
+    return `github-issue-comments:${full}`.toLowerCase();
+}
+/**
+ * Reads the comments of a tracker repo written since the last poll (GET /repos/{full}/issues/comments, oldest first, one request per
+ * page for the whole repo) and hands them to src/flows/answers.ts, which decides which ones start a second review of a ticket.
+ * The first poll of a repo only records the cursor, and a repo where no dot has a reviewed ticket with open questions costs no request.
+ * A comment read twice (the overlap, or a poll that failed after the read) is absorbed by the job key of its comment.
+ */
+export async function pollIssueAnswers(full, deps = {}) {
+    const f = deps.fetch ?? fetch;
+    const now = (deps.now ?? (() => new Date()))();
+    const key = githubCommentsCursorKey(full);
+    const cur = getCursor(key);
+    const tally = { queued: 0, joined: 0, limit: 0, ignored: 0, retry: 0 };
+    if (!cur?.since || !hasAnswerWork(full)) {
+        setCursor(key, { since: now.toISOString() });
+        return tally;
+    }
+    const token = await (deps.githubToken ? deps.githubToken(full) : defaultGithubToken(full, f));
+    const since = Date.parse(cur.since) - OVERLAP_MS;
+    const rows = [];
+    let more = false;
+    for (let page = 1; page <= COMMENT_PAGES; page++) {
+        const batch = await ghGet(f, token, `/repos/${full}/issues/comments?sort=created&direction=asc&since=${encodeURIComponent(new Date(since).toISOString())}&per_page=100&page=${page}`);
+        rows.push(...batch);
+        more = batch.length === 100;
+        if (!more)
+            break;
+    }
+    // The list holds the comments updated since, so an old comment that was edited is in it. Only a comment written since counts.
+    const fresh = rows.filter((c) => Date.parse(String(c.created_at)) >= since);
+    const out = await handleNewComments(full, fresh, { api: issueApi(full, { fetch: f, token: async () => token }), ...(deps.now ? { now: deps.now } : {}) });
+    const lastRead = rows.at(-1)?.created_at;
+    let next = more && lastRead ? new Date(Date.parse(lastRead) + OVERLAP_MS).toISOString() : now.toISOString();
+    // A comment that GitHub could not judge keeps the cursor where it was, so the next poll reads it again. A comment already queued
+    // is absorbed by its job key. The hold ends after COMMENT_RETRY_MS, so a check that always fails cannot stop the poll for good.
+    if (out.retry > 0 && now.getTime() - Date.parse(cur.since) < COMMENT_RETRY_MS) {
+        next = cur.since;
+        log.warn(`poll ${full} issues: ${out.retry} comment(s) could not be checked on GitHub; the next poll reads them again`);
+    }
+    setCursor(key, { since: next });
+    return out;
+}
+async function readGithubIssues(full, deps) {
+    const f = deps.fetch ?? fetch;
+    const now = (deps.now ?? (() => new Date()))();
+    const key = githubIssuesCursorKey(full);
+    const cur = getCursor(key);
+    const token = await (deps.githubToken ? deps.githubToken(full) : defaultGithubToken(full, f));
+    if (cur?.since && !isFresh(cur.polledAt ?? cur.since, now))
+        return catchUpIssues(full, { ...cur, since: cur.since }, now, f, token, key);
+    if (!cur?.since) {
+        // Record the recently updated open issues, so a later label or edit on one of them is seen as a change.
+        const open = await ghGet(f, token, `/repos/${full}/issues?state=open&sort=updated&direction=desc&per_page=100`);
+        for (const issue of open)
+            if (!issue.pull_request && !issueState(full, Number(issue.number)))
+                recordIssue(full, issue);
+        setCursor(key, { since: now.toISOString(), polledAt: now.toISOString() });
+        return { baseline: true, triggers: [], results: [] };
+    }
+    const since = Date.parse(cur.since) - OVERLAP_MS;
+    const sinceIso = new Date(since).toISOString();
+    const rows = [];
+    let more = false;
+    for (let page = 1; page <= ISSUE_PAGES; page++) {
+        const batch = await ghGet(f, token, `/repos/${full}/issues?state=all&sort=updated&direction=asc&since=${encodeURIComponent(sinceIso)}&per_page=100&page=${page}`);
+        rows.push(...batch);
+        more = batch.length === 100;
+        if (!more)
+            break;
+    }
+    const triggers = await issueEvents(full, rows, since, f, token);
+    // Rows come oldest first. When the page cap cut the read short, the next poll starts at the last
+    // row read instead of now, so a burst of updates is read over several polls and none is skipped.
+    const lastRead = rows.at(-1)?.updated_at;
+    const next = more && lastRead ? new Date(Date.parse(lastRead) + OVERLAP_MS).toISOString() : now.toISOString();
+    setCursor(key, { since: next, polledAt: now.toISOString() });
+    const results = triggers.map((ev) => dispatchTrigger(ev));
+    return { baseline: false, triggers, results };
+}
+/** Pages of 50 issues one Linear poll reads at most; the rest waits for the next poll. */
+const LINEAR_PAGES = 5;
+const VIEWER_QUERY = `query LocaldostViewer { viewer { id } }`;
+/** The issue read of a poll (orderBy createdAt) or of a ticket backfill (orderBy updatedAt, the most recently updated first). */
+const issuesQuery = (orderBy) => `query LocaldostPoll($filter: IssueFilter, $after: String) {
+  issues(filter: $filter, first: 50, after: $after, orderBy: ${orderBy}) {
+    nodes {
+      id identifier title description url priorityLabel createdAt
+      creator { id name }
+      team { key }
+      project { name }
+      labels { nodes { name } }
+      state { type }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}`;
+const ISSUES_QUERY = issuesQuery('createdAt');
+/** Linear 5xx responses are retried this many times, waiting 1 s, 2 s, 4 s between tries. */
+const LINEAR_RETRIES = 3;
+const LINEAR_BACKOFF_MS = 1000;
+/**
+ * One Linear GraphQL call. A 5xx response is retried with exponential backoff; when every try fails
+ * the call throws, so the poll ends before it moves the cursor and the next poll reads the same window.
+ * Other failures (4xx, GraphQL errors, network) are not retried here.
+ */
+async function linearGql(f, apiKey, query, variables, sleep = (ms) => new Promise((r) => setTimeout(r, ms))) {
+    for (let attempt = 0;; attempt++) {
+        const res = await f(linearApi(), {
+            method: 'POST',
+            headers: { Authorization: apiKey, 'Content-Type': 'application/json', 'User-Agent': 'localdost-poller' },
+            body: JSON.stringify({ query, variables }),
+        });
+        if (res.status >= 500 && attempt < LINEAR_RETRIES) {
+            await res.text().catch(() => '');
+            await sleep(LINEAR_BACKOFF_MS * 2 ** attempt);
+            continue;
+        }
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            throw new Error(`Linear GraphQL failed: HTTP ${res.status} ${text.slice(0, 200)}`);
+        }
+        const body = (await res.json());
+        if (body.errors?.length)
+            throw new Error(`Linear GraphQL error: ${body.errors.map((e) => e.message).join('; ')}`);
+        return body.data;
+    }
+}
+export function linearCursorKey(w) {
+    return `linear:${w.id}`;
+}
+/**
+ * One Linear poll for a watch. With no fresh cursor it only records one.
+ * Later calls dispatch `ticket_created` (job ticket_review, dedupe linear:<identifier>:created,
+ * the same key the webhook uses) for each issue created in the watched teams since the last poll.
+ */
+export async function pollLinearOnce(w, deps = {}) {
+    const out = await readLinearTickets(w, deps);
+    // A dot with no backfill mark picks its open tickets now (KAT-381).
+    try {
+        const apiKey = env().LINEAR_API_KEY;
+        if (apiKey && w.tracker?.kind === 'linear' && w.tracker.teamKeys?.length) {
+            const started = await seedLinearBackfill(w, deps.fetch ?? fetch, apiKey, (deps.now ?? (() => new Date()))(), deps.sleep);
+            out.triggers.push(...started.triggers);
+            out.results.push(...started.results);
+        }
+    }
+    catch (err) {
+        log.warn(`poll linear ${w.name}: ticket backfill failed: ${pollErrorText(err)}`);
+    }
+    return out;
+}
+async function readLinearTickets(w, deps) {
+    const apiKey = env().LINEAR_API_KEY;
+    const tracker = w.tracker;
+    if (!apiKey || tracker?.kind !== 'linear' || !tracker.teamKeys?.length)
+        return { baseline: false, triggers: [], results: [] };
+    const f = deps.fetch ?? fetch;
+    const now = (deps.now ?? (() => new Date()))();
+    const key = linearCursorKey(w);
+    const cur = getCursor(key);
+    if (!isFresh(cur?.polledAt ?? cur?.since, now)) {
+        if (cur?.since)
+            return catchUpLinear(w.name, tracker, cur.since, cur.polledAt, now, f, apiKey, key, deps.sleep);
+        setCursor(key, { since: now.toISOString(), polledAt: now.toISOString() });
+        return { baseline: true, triggers: [], results: [] };
+    }
+    // A pending window is read on from its page cursor with the same filter; else a fresh read re-reads the overlap.
+    const pending = cur.pending;
+    const gt = pending?.gt ?? new Date(Date.parse(cur.since) - OVERLAP_MS).toISOString();
+    const { nodes, after, more } = await readLinearIssues(tracker, f, apiKey, gt, pending?.after, deps.sleep);
+    const triggers = await linearTriggers(nodes, f, apiKey, deps.sleep);
+    // Where the next poll starts. Cut short by the page cap, the cursor keeps the window and its page cursor, and
+    // `since` stays behind the unread issues; the window is drained before `since` moves on to the time the
+    // first cut read started.
+    const polledAt = now.toISOString();
+    let next;
+    if (more) {
+        next = { since: cur.since, polledAt, pending: { gt, after: after, resumeAt: pending?.resumeAt ?? polledAt } };
+    }
+    else if (pending) {
+        next = { since: pending.resumeAt, polledAt };
+    }
+    else {
+        next = { since: polledAt, polledAt };
+    }
+    setCursor(key, next);
+    const results = triggers.map((ev) => dispatchTrigger(ev));
+    return { baseline: false, triggers, results };
+}
+/** The issues of the dot's Linear teams (and project) created after `gt`, read from the page cursor `after`, at most LINEAR_PAGES pages. Oldest first. */
+async function readLinearIssues(tracker, f, apiKey, gt, start, sleep) {
+    const filter = { team: { key: { in: tracker.teamKeys } }, createdAt: { gt } };
+    if (tracker.projectName)
+        filter.project = { name: { eq: tracker.projectName } };
+    const nodes = [];
+    let after = start;
+    let more = false;
+    for (let page = 0; page < LINEAR_PAGES; page++) {
+        const data = await linearGql(f, apiKey, ISSUES_QUERY, { filter, after }, sleep);
+        nodes.push(...data.issues.nodes);
+        more = !!data.issues.pageInfo.hasNextPage && !!data.issues.pageInfo.endCursor;
+        if (!more)
+            break;
+        after = data.issues.pageInfo.endCursor;
+    }
+    // The API's order is not relied on: it is read from the rows, then the rows are processed oldest first.
+    nodes.sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
+    return { nodes, after, more };
+}
+/** `ticket_created` events for Linear issue rows, in the order given. The dot's own filings are skipped. */
+async function linearTriggers(nodes, f, apiKey, sleep) {
+    // A marker counts only on content the dot's own account wrote. Ask who the key belongs to just when a
+    // description carries a valid marker, so a poll without one makes no extra call.
+    if (!ownIds('linear').length && nodes.some((d) => hasValidBotMarker(d.description))) {
+        try {
+            const me = await linearGql(f, apiKey, VIEWER_QUERY, undefined, sleep);
+            rememberOwnId('linear', me.viewer?.id);
+        }
+        catch {
+            /* unknown identity: the issue is reviewed rather than skipped */
+        }
+    }
+    const triggers = [];
+    for (const d of nodes) {
+        const ev = normalizeLinear({ type: 'Issue', action: 'create', data: { ...d, creatorId: d.creator?.id } });
+        if (ev)
+            triggers.push(ev);
+    }
+    return triggers;
+}
+/**
+ * The poll after a stale cursor (KAT-363): the server did not poll Linear since `polledAt`, so the issues created in the gap were
+ * never seen. It reads the dot's teams from the old cursor (`since` stays behind a backlog, so a window left unread is part of it),
+ * and dispatches the newest issues first, each dot taking at most CATCH_UP_MAX (dispatchCatchUp). Each event says so (`catchUp`).
+ */
+async function catchUpLinear(dotName, tracker, since, polledAt, now, f, apiKey, key, sleep) {
+    const gt = new Date(Date.parse(since) - OVERLAP_MS).toISOString();
+    const { nodes } = await readLinearIssues(tracker, f, apiKey, gt, undefined, sleep);
+    const events = (await linearTriggers(nodes, f, apiKey, sleep)).reverse();
+    const gapSince = polledAt ?? since;
+    const gapMs = now.getTime() - Date.parse(gapSince);
+    for (const ev of events)
+        ev.catchUp = { since: gapSince, gapMs, source: 'Linear' };
+    setCursor(key, { since: now.toISOString(), polledAt: now.toISOString() });
+    const results = await dispatchCatchUp(events, false);
+    logCatchUp(`poll ${dotName} (Linear)`, 'issue(s)', gapMs, events.length, results);
+    return { baseline: false, triggers: events, results };
+}
+/** Issues one Jira poll reads at most (the search pages 100 at a time). A full read means more may be waiting. */
+export const JIRA_POLL_MAX = 1000;
+/** The most issues a poll reads while it works through a window that is larger than JIRA_POLL_MAX. */
+export const JIRA_POLL_HARD_MAX = 3000;
+const jiraSeenKey = (issue) => `${issue.key}|${String((issue.fields ?? {}).updated ?? '')}`;
+export function jiraCursorKey(w) {
+    return `jira:${w.id}`;
+}
+const JIRA_KEY = /^[A-Z][A-Z0-9_]{0,19}$/;
+/** True when a changelog item edits the description or the acceptance criteria field. */
+export function isJiraSpecItem(item) {
+    const ac = env().JIRA_AC_FIELD;
+    return (item.field === 'description' || item.fieldId === 'description' || (!!ac && item.fieldId === ac) || /acceptance criteria/i.test(String(item.field ?? '')));
+}
+/**
+ * One Jira poll for a watch, through the connected Jira client. With no fresh cursor it only
+ * records one. Later calls search `project in (...) AND updated >= <cursor>` and dispatch
+ * ticket_created for issues created since the cursor (dedupe jira:<key>:created, the webhook's key)
+ * and for description or acceptance-criteria edits since the cursor (dedupe by the edit time).
+ * Edits by the bot account (JIRA_BOT_ACCOUNT_ID, else the account that owns the token) are dropped,
+ * and an issue whose newest comment is the bot's and came after the change is skipped: the bot has
+ * already answered it. Issues come oldest first and are paged, up to JIRA_POLL_MAX per poll. When a window
+ * holds more than that (the search is rounded to the minute, so many issues can share one window), the
+ * cursor stays at the window start and remembers the issues it handled by key and updated time; the next
+ * poll reads that many issues deeper and skips them, so every issue is reached and reviewed once.
+ */
+export async function pollJiraOnce(w, deps = {}) {
+    const out = await readJiraTickets(w, deps);
+    // A dot with no backfill mark picks its open tickets now (KAT-381).
+    try {
+        const client = (deps.jira ?? jiraFor)(w);
+        if (client.mode === 'live' && client.search) {
+            const started = await seedJiraBackfill(w, client, (deps.now ?? (() => new Date()))());
+            out.triggers.push(...started.triggers);
+            out.results.push(...started.results);
+        }
+    }
+    catch (err) {
+        log.warn(`poll jira ${w.name}: ticket backfill failed: ${pollErrorText(err)}`);
+    }
+    return out;
+}
+async function readJiraTickets(w, deps) {
+    const tracker = w.tracker;
+    if (tracker?.kind !== 'jira' || !tracker.projectKeys?.length)
+        return { baseline: false, triggers: [], results: [] };
+    const client = (deps.jira ?? jiraFor)(w);
+    if (client.mode !== 'live' || !client.search)
+        return { baseline: false, triggers: [], results: [] };
+    const now = (deps.now ?? (() => new Date()))();
+    const key = jiraCursorKey(w);
+    const cur = getCursor(key);
+    if (!isFresh(cur?.polledAt ?? cur?.since, now)) {
+        if (cur?.since)
+            return catchUpJira(w.name, tracker.projectKeys, client, cur.since, cur.polledAt, now, key);
+        setCursor(key, { since: now.toISOString(), polledAt: now.toISOString() });
+        return { baseline: true, triggers: [], results: [] };
+    }
+    const sinceMs = Date.parse(cur.since) - OVERLAP_MS;
+    const seen = new Set(cur.seen ?? []);
+    const readMax = Math.min(JIRA_POLL_HARD_MAX, JIRA_POLL_MAX + seen.size);
+    const issues = await searchJira(client, tracker.projectKeys, sinceMs, now, 'ASC', readMax);
+    if (!issues)
+        return { baseline: false, triggers: [], results: [] };
+    const triggers = await jiraTriggers(client, issues, sinceMs, seen);
+    // A full read may have cut the window short. Keep the window start and the handled issues so the next
+    // poll reads deeper; the overlap and the dedupe keys make a repeat harmless.
+    const capped = issues.length >= readMax;
+    if (capped && readMax < JIRA_POLL_HARD_MAX) {
+        const handled = [...seen, ...issues.map(jiraSeenKey)];
+        setCursor(key, { since: cur.since, polledAt: now.toISOString(), seen: [...new Set(handled)] });
+    }
+    else {
+        if (capped)
+            log.warn(`poll jira ${w.name}: more than ${JIRA_POLL_HARD_MAX} issues changed in one window; the rest are not reviewed`);
+        setCursor(key, { since: now.toISOString(), polledAt: now.toISOString() });
+    }
+    const results = triggers.map((ev) => dispatchTrigger(ev));
+    return { baseline: false, triggers, results };
+}
+/**
+ * The issues of the given Jira projects updated since `sinceMs`, through the connected client, or null when no project key is valid.
+ * JQL dates are in the Jira user's time zone and have minute precision, so the search uses a relative window that covers the
+ * cursor and the exact cut happens on the returned timestamps.
+ */
+async function searchJira(client, projectKeys, sinceMs, now, order, max) {
+    const minutes = Math.max(1, Math.ceil((now.getTime() - sinceMs) / 60_000) + 1);
+    const keys = projectKeys.map((k) => k.trim().toUpperCase()).filter((k) => JIRA_KEY.test(k));
+    if (!keys.length)
+        return null;
+    const jql = `project in (${keys.map((k) => `"${k}"`).join(', ')}) AND updated >= "-${minutes}m" ORDER BY updated ${order}`;
+    const fields = ['summary', 'description', 'issuetype', 'priority', 'labels', 'reporter', 'creator', 'project', 'updated', 'created', 'comment'];
+    if (env().JIRA_AC_FIELD)
+        fields.push(env().JIRA_AC_FIELD);
+    return client.search(jql, { fields, expand: 'changelog', max });
+}
+/**
+ * The events of Jira issues read from `sinceMs` on, in the order given: `ticket_created` for an issue created since, and an update
+ * for a description or acceptance-criteria edit since. Edits by the bot account (JIRA_BOT_ACCOUNT_ID, else the account that owns the
+ * token) are dropped, and an issue whose newest comment is the bot's and came after the change is skipped: the bot has already
+ * answered it. `seen` holds `key|updated` of issues a window that is larger than one read has handled.
+ */
+async function jiraTriggers(client, issues, sinceMs, seen) {
+    const bot = env().JIRA_BOT_ACCOUNT_ID;
+    await client.myself().catch(() => null); // learn the dot's own account so its signed writes are recognized
+    const triggers = [];
+    for (const issue of issues) {
+        if (seen.has(jiraSeenKey(issue)))
+            continue;
+        const f = (issue.fields ?? {});
+        const created = Date.parse(String(f.created ?? ''));
+        let payload;
+        let changedAt = created;
+        if (Number.isFinite(created) && created >= sinceMs) {
+            payload = { webhookEvent: 'jira:issue_created', issue, user: f.creator ?? f.reporter };
+        }
+        else {
+            const histories = (issue.changelog?.histories ?? [])
+                .filter((h) => Date.parse(h.created) >= sinceMs && (h.items ?? []).some(isJiraSpecItem))
+                .filter((h) => !bot || h.author?.accountId !== bot)
+                .sort((a, b) => Date.parse(a.created) - Date.parse(b.created));
+            const h = histories.at(-1);
+            if (h) {
+                changedAt = Date.parse(h.created);
+                // The edit time stands in for fields.updated, so a later comment does not make a new dedupe key.
+                payload = {
+                    webhookEvent: 'jira:issue_updated',
+                    issue: { ...issue, fields: { ...f, updated: h.created } },
+                    user: h.author,
+                    changelog: { items: h.items },
+                };
+            }
+        }
+        if (!payload)
+            continue;
+        const comments = (f.comment?.comments ?? []).slice().sort((a, b) => Date.parse(a.created) - Date.parse(b.created));
+        const last = comments.at(-1);
+        if (last && Date.parse(last.created) >= changedAt && ((bot && last.author?.accountId === bot) || isOwnWrite('jira', last.author?.accountId, last.body)))
+            continue;
+        const ev = normalizeJira(payload);
+        if (ev)
+            triggers.push(ev);
+    }
+    return triggers;
+}
+/**
+ * The poll after a stale cursor (KAT-363): the server did not poll Jira since `polledAt`, so the tickets created or edited in the
+ * gap were never seen. It searches the dot's projects from the old cursor, the 1000 most recently updated first, and dispatches
+ * the events newest first, each dot taking at most CATCH_UP_MAX (dispatchCatchUp). Each event says so (`catchUp`).
+ */
+async function catchUpJira(dotName, projectKeys, client, since, polledAt, now, key) {
+    const sinceMs = Date.parse(since) - OVERLAP_MS;
+    const issues = await searchJira(client, projectKeys, sinceMs, now, 'DESC', JIRA_POLL_MAX);
+    setCursor(key, { since: now.toISOString(), polledAt: now.toISOString() });
+    if (!issues)
+        return { baseline: true, triggers: [], results: [] };
+    const events = await jiraTriggers(client, issues, sinceMs, new Set());
+    const gapSince = polledAt ?? since;
+    const gapMs = now.getTime() - Date.parse(gapSince);
+    for (const ev of events)
+        ev.catchUp = { since: gapSince, gapMs, source: 'Jira' };
+    const results = await dispatchCatchUp(events, false);
+    logCatchUp(`poll ${dotName} (Jira)`, 'ticket event(s)', gapMs, events.length, results);
+    return { baseline: false, triggers: events, results };
+}
+// Ticket review backfill (KAT-381)
+/**
+ * Before this, the first poll of a tracker only recorded a cursor, so the open tickets that were there before the dot started never got a
+ * review and day one looked empty. Now each dot that polls a tracker and has not picked its backfill takes the open tickets in its scope,
+ * the most recently updated ones up to the tracker's `backfillLimit` (default 25, 0 turns it off). The list goes in the poll cursor store
+ * under `ticket-backfill:<dot id>:<scope>` (the scope is the repo, `jira` or `linear`), which is also the mark that the dot picked: a restart,
+ * and a later poll, find the mark and pick nothing again.
+ *
+ * The reviews start one at a time, oldest update first: a dot starts the next one when the review before it is done (a ticket_review job
+ * that is not queued or running) and its daily model cap is not reached. So 25 tickets never fill the queue ahead of a PR check, and a dot
+ * at its cap holds no job and no "waiting" run for each of them. Each review is an ordinary ticket_created event marked `backfill`. Nobody
+ * asked for it, so its comment and status label wait in the Inbox under the Ask and Act rules (a dot set to hand off hands the review off, and a dot set to act when asked skips it; KAT-381). A limit lowered later, or set to 0,
+ * cuts the list that was picked; the tickets cut stay cut when the limit rises again. A review already queued when the limit drops to 0
+ * ends at once when its turn comes. Its dedupe key is the key of a new ticket, so a ticket the dot reviewed
+ * when it was opened is never reviewed twice.
+ *
+ * A dot that was already running long before its first poll (older than STALE_CURSOR_MS, as for PRs, KAT-352) is not new: an upgrade or a
+ * re-enabled poller never replays its tickets. A tracker that names `backfillLimit` itself asks for the backfill, so it runs for any dot age.
+ */
+const BACKFILL_PREFIX = 'ticket-backfill:';
+/** How often a dot looks at whether its next backfilled review can start. */
+const BACKFILL_EVERY_MS = 10_000;
+const backfillKey = (watchId, scope) => `${BACKFILL_PREFIX}${watchId}:${scope.toLowerCase()}`;
+/** The dot has a backfilled review that is queued or running. */
+function activeBackfillJobs(watchId) {
+    const jobs = list('jobs', { ...(watchId ? { watchId } : {}), kind: 'ticket_review', status: ['queued', 'running'] });
+    return jobs.filter((j) => j.payload?.backfill === true);
+}
+/** True when this dot already has a review of the ticket the event names. */
+function alreadyReviewed(w, ev) {
+    return !!findOne('jobs', { dedupeKey: `${ev.dedupeKey}:${w.id}:ticket_review` }) || reviewedSameBody(w.id, ev);
+}
+/** What a dot with no mark does now: picks a backfill, only marks (a dot that was running long ago), or stays out (limit 0). */
+function backfillMode(w, now) {
+    const named = explicitBackfillLimit(w);
+    if (named === 0)
+        return 'off';
+    if (named === undefined && now.getTime() - Date.parse(w.createdAt) > STALE_CURSOR_MS)
+        return 'mark';
+    return 'pick';
+}
+/**
+ * True when the dot has no backfill row in this scope, or only the mark of a dot that was running long before its first poll and its
+ * tracker now names a limit above 0 (the upgrade step: add `backfillLimit` to the tracker of an older dot and save it).
+ */
+function needsBackfillPick(w, scope) {
+    const row = getCursor(backfillKey(w.id, scope));
+    if (!row)
+        return true;
+    return row.marked === true && (explicitBackfillLimit(w) ?? 0) > 0;
+}
+/** The scopes the dot's tracker polls now: its repos, `jira` or `linear`. A backfill list in any other scope is left over from an edit. */
+function liveBackfillScopes(w) {
+    const t = w.tracker;
+    if (t?.kind === 'github')
+        return new Set(trackerRepos(w).map((r) => r.toLowerCase()));
+    if (t?.kind === 'jira')
+        return new Set(['jira']);
+    if (t?.kind === 'linear')
+        return new Set(['linear']);
+    return new Set();
+}
+/** Every stored backfill row, with the cursor id, the dot id and the scope. Rows that cannot be read are left out. */
+function storedBackfills() {
+    ensureCursorTable();
+    const rows = db.prepare('SELECT id, value FROM poll_cursors WHERE substr(id, 1, ?) = ?').all(BACKFILL_PREFIX.length, BACKFILL_PREFIX);
+    const out = [];
+    for (const r of rows) {
+        const rest = r.id.slice(BACKFILL_PREFIX.length);
+        const cut = rest.indexOf(':');
+        if (cut < 1)
+            continue;
+        try {
+            out.push({ id: r.id, watchId: rest.slice(0, cut), scope: rest.slice(cut + 1), state: JSON.parse(r.value) });
+        }
+        catch {
+            /* an unreadable row counts as nothing left */
+        }
+    }
+    return out;
+}
+/** True when the dot still polls the scope of the row. A row of a dot that is gone, or of a scope an edit took away, is not. */
+function inLiveScope(b, dots) {
+    let scopes = dots.get(b.watchId);
+    if (!scopes) {
+        const w = findOne('watches', { id: b.watchId });
+        scopes = w ? liveBackfillScopes(w) : new Set();
+        dots.set(b.watchId, scopes);
+    }
+    return scopes.has(b.scope);
+}
+/** The dots' backfills that still have a scope to drain, as dot id to the stored state. */
+function backfillStates() {
+    const dots = new Map();
+    return storedBackfills().filter((b) => inLiveScope(b, dots));
+}
+/**
+ * Deletes the backfill rows of scopes a dot no longer polls (a repo taken off its tracker, or a tracker of another kind). Without it the
+ * list would never drain: Activity would show "Reviewing N open tickets" for good and the 10 s tick would keep running for nothing. A row
+ * with no tickets left stays, because it is also the mark that the dot picked. Returns how many rows went.
+ */
+export function pruneOrphanBackfills() {
+    const dots = new Map();
+    const gone = storedBackfills().filter((b) => b.state.pending?.length && !inLiveScope(b, dots));
+    for (const b of gone)
+        db.prepare('DELETE FROM poll_cursors WHERE id = ?').run(b.id);
+    return gone.length;
+}
+/** Tickets each dot has still to review for its backfill: the ones not started plus the review queued or running. Dots with none are left out. */
+export function backfillRemaining() {
+    const out = new Map();
+    for (const b of backfillStates())
+        if (b.state.pending?.length)
+            out.set(b.watchId, (out.get(b.watchId) ?? 0) + b.state.pending.length);
+    const active = activeBackfillJobs();
+    // A dot's review in flight counts only while the dot has a backfill: a plain ticket review has no `backfill` mark.
+    for (const j of active)
+        out.set(j.watchId, (out.get(j.watchId) ?? 0) + 1);
+    return out;
+}
+/** True when the dot has backfilled tickets left, no review of them runs, and its daily model cap holds the next one back. */
+export function backfillHeld(w, now = new Date()) {
+    return !!capState(w, now)?.reached && activeBackfillJobs(w.id).length === 0;
+}
+function hasPendingBackfill(watchId) {
+    return backfillStates().some((b) => b.watchId === watchId && b.state.pending?.length > 0);
+}
+/**
+ * Picks the backfill of a dot for one tracker scope when it has no mark. `pick` returns the dot's open tickets in scope, most recently
+ * updated first, that the dot has no review of, at most `limit` of them. Returns true when it stored a list with tickets in it.
+ */
+async function seedBackfill(w, scope, now, pick) {
+    const key = backfillKey(w.id, scope);
+    if (!needsBackfillPick(w, scope))
+        return false;
+    const mode = backfillMode(w, now);
+    if (mode === 'off')
+        return false;
+    const at = now.toISOString();
+    if (mode === 'mark') {
+        setCursor(key, { at, total: 0, pending: [], marked: true });
+        return false;
+    }
+    // The limit is the dot's, not each scope's: what the dot's other scopes already picked counts against it.
+    const pickedElsewhere = backfillStates()
+        .filter((b) => b.watchId === w.id && b.scope !== scope.toLowerCase())
+        .reduce((n, b) => n + (b.state.total ?? 0), 0);
+    const limit = Math.max(0, backfillLimitOf(w) - pickedElsewhere);
+    const events = limit > 0 ? (await pick(limit, (ev) => !alreadyReviewed(w, ev))).slice(0, limit) : [];
+    // Oldest update first: the list is stored in the order the reviews start.
+    const pending = events.map((ev) => ev.ticket.key).reverse();
+    setCursor(key, { at, total: pending.length, pending });
+    log.info(`${w.name}: ticket backfill of ${scope}: ${pending.length} open ticket(s) to review, one at a time`);
+    return pending.length > 0;
+}
+/**
+ * Holds the stored backfill lists of a dot to the limit its tracker names now. The pick checks the limit once, so a limit lowered later (or
+ * set to 0, which turns the backfill off) would not stop a list that was already picked. The limit counts for the dot, across all its tracker
+ * scopes: the tickets already started count against the new limit, and what is left of the lists is cut to the rest, scope by scope. A row
+ * stays after it is cut, because it is also the mark that the dot picked. Returns how many tickets are left in all the lists.
+ */
+function trimBackfillToLimit(w) {
+    const rows = backfillStates()
+        .filter((b) => b.watchId === w.id)
+        .sort((a, b) => a.scope.localeCompare(b.scope));
+    const started = rows.reduce((n, b) => n + Math.max(0, b.state.total - (b.state.pending?.length ?? 0)), 0);
+    let budget = Math.max(0, backfillLimitOf(w) - started);
+    let left = 0;
+    for (const b of rows) {
+        const pending = b.state.pending ?? [];
+        const keep = Math.min(pending.length, budget);
+        budget -= keep;
+        left += keep;
+        if (keep < pending.length) {
+            const begun = Math.max(0, b.state.total - pending.length);
+            // The picked count follows the cut, so the tickets already started stay the same on the next read.
+            setCursor(backfillKey(b.watchId, b.scope), { ...b.state, pending: pending.slice(0, keep), total: begun + keep });
+        }
+    }
+    return left;
+}
+/**
+ * Starts the next review of a dot's backfill in one scope, when the review before it is done and the daily model cap is not reached. A
+ * ticket that is gone, closed or out of scope when its turn comes is dropped and the next one is tried. Returns what it queued (at most one).
+ */
+async function drainBackfill(w, source, now) {
+    const out = { triggers: [], results: [] };
+    const key = backfillKey(w.id, source.scope);
+    if (!getCursor(key)?.pending?.length)
+        return out;
+    if (trimBackfillToLimit(w) === 0)
+        return out;
+    if (!getCursor(key)?.pending?.length)
+        return out;
+    if (activeBackfillJobs(w.id).length || capState(w, now)?.reached)
+        return out;
+    for (;;) {
+        const next = getCursor(key)?.pending?.[0];
+        if (!next)
+            break;
+        // A failed read (network, rate limit) leaves the ticket in its place; the next try is in a few seconds.
+        const ev = await source.event(next).catch((err) => {
+            throw new Error(`could not read ${next}: ${pollErrorText(err)}`, { cause: err });
+        });
+        // The read took time: the scheduler may have cut the list to a lower limit meanwhile. Hold it to the limit again, and read the list
+        // fresh, so a stale copy is never written back and a ticket the cut dropped is not started.
+        trimBackfillToLimit(findOne('watches', { id: w.id }) ?? w);
+        const state = getCursor(key);
+        if (!state?.pending?.length || state.pending[0] !== next)
+            break;
+        let queued = false;
+        if (ev) {
+            const sent = { ...ev, backfill: true };
+            const res = dispatchTrigger(sent, { onlyWatchIds: [w.id] });
+            queued = res.jobs.length > 0;
+            if (queued) {
+                out.triggers.push(sent);
+                out.results.push(res);
+            }
+        }
+        // Stored after the dispatch: a crash in between repeats the ticket, and its dedupe key keeps that from being a second review.
+        state.pending.shift();
+        setCursor(key, state);
+        if (queued)
+            break;
+    }
+    return out;
+}
+// GitHub backfill
+const repoPayload = (full) => {
+    const [owner, name] = full.split('/');
+    return { owner: { login: owner }, name, full_name: full };
+};
+/** The ticket_created event of an issue row for a dot's backfill, or null for a PR, the dot's own issue, or an issue out of the dot's scope. */
+function githubBackfillEvent(w, full, issue) {
+    if (issue.pull_request || issue.state === 'closed')
+        return null;
+    const ev = normalizeGithubIssue('issues', { action: 'opened', issue, repository: repoPayload(full), sender: issue.user });
+    return ev && issueInScope(w, ev) ? ev : null;
+}
+function githubBackfillSource(w, full, deps) {
+    const f = deps.fetch ?? fetch;
+    return {
+        scope: full,
+        async event(key) {
+            const n = Number(key.split('#')[1]);
+            const token = await (deps.githubToken ? deps.githubToken(full) : defaultGithubToken(full, f));
+            let issue;
+            try {
+                issue = await ghGet(f, token, `/repos/${full}/issues/${n}`);
+            }
+            catch (err) {
+                // A deleted or moved issue is not coming back.
+                const status = err.status;
+                if (status === 404 || status === 410)
+                    return null;
+                throw err;
+            }
+            await rememberGithubIdentity([issue], f, token);
+            const ev = githubBackfillEvent(w, full, issue);
+            // Recorded now, so a later edit of the text the review read is seen as an edit.
+            if (ev && !issueState(full, n))
+                recordIssue(full, issue);
+            return ev;
+        },
+    };
+}
+/**
+ * Called after each poll of the issues of `full`: every dot that polls this tracker repo and has no backfill mark picks its backfill (a new
+ * dot, or a dot on a tracker that was already polled), reading the open issues most recently updated first, up to ISSUE_PAGES pages, and
+ * starts the first review. The open issues are read once for all the dots that need them.
+ */
+async function seedGithubBackfills(full, deps) {
+    const now = (deps.now ?? (() => new Date()))();
+    const f = deps.fetch ?? fetch;
+    const scope = full.toLowerCase();
+    const dots = list('watches').filter((w) => wantsGithubIssuesPoll(w) && trackerRepos(w).includes(scope) && needsBackfillPick(w, scope));
+    const out = { triggers: [], results: [] };
+    if (!dots.length)
+        return out;
+    const rows = [];
+    let page = 0;
+    let more = true;
+    let token;
+    const readMore = async () => {
+        if (!more || page >= ISSUE_PAGES) {
+            more = false;
+            return;
+        }
+        token ??= await (deps.githubToken ? deps.githubToken(full) : defaultGithubToken(full, f));
+        page++;
+        const batch = await ghGet(f, token, `/repos/${full}/issues?state=open&sort=updated&direction=desc&per_page=100&page=${page}`);
+        await rememberGithubIdentity(batch, f, token);
+        rows.push(...batch);
+        more = batch.length === 100;
+    };
+    for (const w of dots) {
+        const seeded = await seedBackfill(w, scope, now, async (limit, fresh) => {
+            for (;;) {
+                const events = [];
+                for (const issue of rows) {
+                    const ev = githubBackfillEvent(w, full, issue);
+                    if (ev && fresh(ev))
+                        events.push(ev);
+                }
+                if (events.length >= limit || !more)
+                    return events;
+                await readMore();
+            }
+        });
+        if (seeded) {
+            const started = await drainBackfill(w, githubBackfillSource(w, scope, deps), now);
+            out.triggers.push(...started.triggers);
+            out.results.push(...started.results);
+        }
+    }
+    return out;
+}
+// Jira backfill
+const jiraFields = () => {
+    const fields = ['status', 'summary', 'description', 'issuetype', 'priority', 'labels', 'reporter', 'creator', 'project', 'updated', 'created', 'comment'];
+    if (env().JIRA_AC_FIELD)
+        fields.push(env().JIRA_AC_FIELD);
+    return fields;
+};
+const jiraDone = (issue) => (issue.fields ?? {}).status?.statusCategory?.key === 'done';
+const jiraBackfillEvent = (issue) => jiraDone(issue) ? null : normalizeJira({ webhookEvent: 'jira:issue_created', issue, user: issue.fields?.creator ?? issue.fields?.reporter });
+function jiraBackfillSource(client) {
+    return {
+        scope: 'jira',
+        async event(key) {
+            if (!/^[A-Z][A-Z0-9_]*-\d+$/.test(key))
+                return null;
+            let issues;
+            try {
+                issues = await client.search(`key = "${key}"`, { fields: jiraFields(), max: 1 });
+            }
+            catch (err) {
+                // Jira answers a key that does not exist, or that the account cannot see, with HTTP 400 (a JQL error), not an empty result.
+                // The key passed the check above, so it is not a typo: the ticket is gone for this dot and is not coming back.
+                const status = err.status;
+                if (status === 400 || status === 404)
+                    return null;
+                throw err;
+            }
+            return issues[0] ? jiraBackfillEvent(issues[0]) : null;
+        },
+    };
+}
+/** The Jira dot picks its backfill: the open issues of its projects, most recently updated first. */
+async function seedJiraBackfill(w, client, now) {
+    const out = { triggers: [], results: [] };
+    const tracker = w.tracker;
+    if (tracker?.kind !== 'jira' || !client.search)
+        return out;
+    const seeded = await seedBackfill(w, 'jira', now, async (limit, fresh) => {
+        const keys = tracker.projectKeys.map((k) => k.trim().toUpperCase()).filter((k) => JIRA_KEY.test(k));
+        if (!keys.length)
+            return [];
+        const jql = `project in (${keys.map((k) => `"${k}"`).join(', ')}) AND statusCategory != Done ORDER BY updated DESC`;
+        // Twice the limit: the dot's own filings are dropped from the list.
+        const issues = await client.search(jql, { fields: jiraFields(), max: Math.min(200, limit * 2) });
+        return issues.map(jiraBackfillEvent).filter((ev) => !!ev && fresh(ev));
+    });
+    return seeded ? drainBackfill(w, jiraBackfillSource(client), now) : out;
+}
+// Linear backfill
+const OPEN_STATE = { type: { nin: ['completed', 'canceled'] } };
+/** The Linear teams, and the project, of a dot as an issue filter. */
+function linearScope(tracker) {
+    const filter = { team: { key: { in: tracker.teamKeys } } };
+    if (tracker.projectName)
+        filter.project = { name: { eq: tracker.projectName } };
+    return filter;
+}
+const linearBackfillEvent = (d) => normalizeLinear({ type: 'Issue', action: 'create', data: { ...d, creatorId: d.creator?.id } });
+function linearBackfillSource(tracker, f, apiKey, sleep) {
+    return {
+        scope: 'linear',
+        async event(key) {
+            const m = /^([A-Za-z0-9]+)-(\d+)$/.exec(key);
+            if (!m)
+                return null;
+            const filter = {
+                ...linearScope(tracker),
+                team: { key: { in: tracker.teamKeys.filter((k) => k.toLowerCase() === m[1].toLowerCase()) } },
+                number: { eq: Number(m[2]) },
+            };
+            const data = await linearGql(f, apiKey, issuesQuery('updatedAt'), { filter }, sleep);
+            const d = data.issues.nodes[0];
+            return d && !['completed', 'canceled'].includes(String(d.state?.type)) ? linearBackfillEvent(d) : null;
+        },
+    };
+}
+/** The Linear dot picks its backfill: the open issues of its teams (and project), most recently updated first. */
+async function seedLinearBackfill(w, f, apiKey, now, sleep) {
+    const out = { triggers: [], results: [] };
+    const tracker = w.tracker;
+    if (tracker?.kind !== 'linear' || !tracker.teamKeys?.length)
+        return out;
+    const seeded = await seedBackfill(w, 'linear', now, async (limit, fresh) => {
+        const events = [];
+        let after;
+        for (let page = 0; page < 4 && events.length < limit; page++) {
+            const data = await linearGql(f, apiKey, issuesQuery('updatedAt'), { filter: { ...linearScope(tracker), state: OPEN_STATE }, after }, sleep);
+            for (const d of data.issues.nodes) {
+                const ev = linearBackfillEvent(d);
+                if (ev && fresh(ev))
+                    events.push(ev);
+            }
+            if (!data.issues.pageInfo.hasNextPage || !data.issues.pageInfo.endCursor)
+                break;
+            after = data.issues.pageInfo.endCursor;
+        }
+        return events;
+    });
+    return seeded ? drainBackfill(w, linearBackfillSource(tracker, f, apiKey, sleep), now) : out;
+}
+/**
+ * The scheduler's step for one dot: starts the next review of each of its backfills that has tickets left (drainBackfill). Reads nothing
+ * when no backfill is waiting, so a dot without one costs a read of the cursor store.
+ */
+export async function drainBackfills(w, deps = {}) {
+    const out = { baseline: false, triggers: [], results: [] };
+    const now = (deps.now ?? (() => new Date()))();
+    const t = w.tracker;
+    const take = (s) => {
+        out.triggers.push(...s.triggers);
+        out.results.push(...s.results);
+    };
+    if (!t || !hasPendingBackfill(w.id))
+        return out;
+    // A limit lowered to 0 or below what already started clears the list, even when the tracker cannot be read right now.
+    trimBackfillToLimit(w);
+    if (!hasPendingBackfill(w.id))
+        return out;
+    if (t.kind === 'github') {
+        for (const full of trackerRepos(w))
+            take(await drainBackfill(w, githubBackfillSource(w, full, deps), now));
+    }
+    else if (t.kind === 'jira') {
+        const client = (deps.jira ?? jiraFor)(w);
+        if (client.mode === 'live' && client.search)
+            take(await drainBackfill(w, jiraBackfillSource(client), now));
+    }
+    else if (t.kind === 'linear') {
+        const apiKey = env().LINEAR_API_KEY;
+        if (apiKey)
+            take(await drainBackfill(w, linearBackfillSource(t, deps.fetch ?? fetch, apiKey, deps.sleep), now));
+    }
+    return out;
+}
+// Scheduler
+/**
+ * Starts GitHub, Linear, and Jira polling for every unpaused watch that opts in
+ * (LOCALDOST_POLL=1 for all, or watch.pollGithub / watch.pollLinear / watch.pollJira).
+ * GitHub polls need GITHUB_TOKEN or a GitHub App; Linear polls need LINEAR_API_KEY.
+ * Returns a stop function.
+ */
+export function startPollers(deps = {}) {
+    if (sandboxOn()) {
+        sandboxSkips('the pollers');
+        return () => undefined;
+    }
+    const lastRun = new Map();
+    const inflight = new Set();
+    let warnedGh = false;
+    const run = (key, everyMs, fn, label) => {
+        const now = Date.now();
+        if (inflight.has(key) || now - (lastRun.get(key) ?? 0) < everyMs)
+            return;
+        lastRun.set(key, now);
+        inflight.add(key);
+        fn()
+            .then((o) => {
+            recordPollResult(key);
+            if (o.baseline)
+                log.info(`poll ${label}: cursor recorded`);
+            else if (o.triggers.length)
+                log.info(`poll ${label}: ${o.triggers.length} new event(s)`);
+        })
+            .catch((err) => {
+            recordPollResult(key, err);
+            log.warn(`poll ${label} failed: ${err.message}`);
+        })
+            .finally(() => inflight.delete(key));
+    };
+    const tick = () => {
+        let watches;
+        try {
+            watches = list('watches');
+        }
+        catch (err) {
+            log.warn(`pollers cannot list watches: ${err.message}`);
+            return;
+        }
+        const ghEvery = githubPollSec() * 1000;
+        const linEvery = linearPollSec() * 1000;
+        let targets;
+        try {
+            targets = githubPollTargets(watches);
+        }
+        catch (err) {
+            log.warn(`pollers cannot read repos: ${err.message}`);
+            targets = new Map();
+        }
+        if (targets.size) {
+            if (!deps.githubToken && githubMode() === 'demo') {
+                if (!warnedGh)
+                    log.warn('GitHub poll mode needs GITHUB_TOKEN or a GitHub App; skipping GitHub polls');
+                warnedGh = true;
+            }
+            else {
+                // Keyed by repo and branch so every dot that holds a repo shares one poll.
+                for (const [key, t] of targets)
+                    run(key, ghEvery, () => pollGithubRepoOnce(t, deps), `${t.owner}/${t.name}`);
+            }
+        }
+        try {
+            // A backfill list in a scope the dot no longer polls (a repo taken off its tracker, a new tracker kind) would never drain.
+            const dropped = pruneOrphanBackfills();
+            if (dropped)
+                log.info(`ticket backfill: dropped ${dropped} list(s) of a scope no dot polls any more`);
+        }
+        catch (err) {
+            log.warn(`ticket backfill: cannot drop old lists: ${err.message}`);
+        }
+        for (const w of watches) {
+            // A limit lowered to 0 (or below what already started) clears the list even for a dot whose tracker polling is off, because that dot
+            // never reaches drainBackfills, and Activity would keep showing "Reviewing N open tickets" for a list nothing drains.
+            try {
+                if (hasPendingBackfill(w.id))
+                    trimBackfillToLimit(w);
+            }
+            catch (err) {
+                log.warn(`ticket backfill ${w.name}: cannot hold the list to its limit: ${err.message}`);
+            }
+            // The next review of a ticket backfill (KAT-381), when the one before it is done. One key per dot, whatever its tracker.
+            const githubReady = !!deps.githubToken || githubMode() !== 'demo';
+            if (!w.paused && !w.archived && ((wantsGithubIssuesPoll(w) && githubReady) || wantsJiraPoll(w) || wantsLinearPoll(w)) && hasPendingBackfill(w.id))
+                run(`backfill:${w.id}`, BACKFILL_EVERY_MS, () => drainBackfills(w, deps), `ticket backfill ${w.name}`);
+            if (wantsGithubIssuesPoll(w)) {
+                if (!deps.githubToken && githubMode() === 'demo') {
+                    if (!warnedGh)
+                        log.warn('GitHub poll mode needs GITHUB_TOKEN or a GitHub App; skipping GitHub polls');
+                    warnedGh = true;
+                }
+                else {
+                    // Keyed by repo, so a repo several dots review is polled once.
+                    for (const full of trackerRepos(w))
+                        run(githubIssuesCursorKey(full), ghEvery, () => pollGithubIssuesOnce(full, deps), `${full} issues`);
+                }
+            }
+            if (wantsJiraPoll(w)) {
+                const client = (deps.jira ?? jiraFor)(w);
+                if (client.mode !== 'live')
+                    log.warnOnce('jira-poll-key', 'Jira poll mode needs Jira connected (JIRA_BASE_URL, JIRA_EMAIL, JIRA_API_TOKEN); skipping Jira polls');
+                else
+                    run(jiraCursorKey(w), jiraPollSec() * 1000, () => pollJiraOnce(w, deps), `jira ${w.name}`);
+            }
+            if (wantsLinearPoll(w)) {
+                if (!env().LINEAR_API_KEY)
+                    log.warnOnce('linear-poll-key', 'Linear poll mode needs LINEAR_API_KEY; skipping Linear polls');
+                else
+                    run(linearCursorKey(w), linEvery, () => pollLinearOnce(w, deps), `linear ${w.name}`);
+            }
+        }
+    };
+    const timer = setInterval(tick, TICK_MS);
+    timer.unref?.();
+    const first = setTimeout(tick, 1000);
+    first.unref?.();
+    return () => {
+        clearInterval(timer);
+        clearTimeout(first);
+    };
+}
+//# sourceMappingURL=pollers.js.map