tinybeeai 0.0.0-stage → 0.16.1

package/dist/flows/change.js

@@ -0,0 +1,811 @@
+// pr_check and post_merge share this body (docs/PR-REVIEW-QA.md sections 2.1, 2.10, 5, 6.1).
+//
+// pr_check: the heuristic spec run starts in parallel with the QA review (prepare, reviewer,
+// verifier, merge), so test time and model time overlap. Specs the verified review adds run
+// as a second batch. analyze() then gets the review as a fenced <qa_review> block. Outputs:
+// check run with annotations, sticky comment with the checklist, and a templated push.
+// A new head first marks the old comment and older reviews as stale.
+//
+// post_merge: the review runs first (or is reused from the PR review at the same head), and
+// its regression scope drives the run. No sticky comment; release notes go to the digest.
+import { listMemory } from '../agent/memory.js';
+import { getLlmFor } from '../agent/llm.js';
+import { runStage } from '../stages/index.js';
+import { get, update } from '../db.js';
+import { gate, rulesForEvent } from '../agent/rules.js';
+import { supersedeOlderHeads } from '../agent/approvals.js';
+import { addStep, closeDeployRun, finishRun, isRunCancelled, setReport, setVerdict, startRun } from '../agent/runs.js';
+import { githubFor, githubWebUrl, GithubUnreachableError, previewFor } from '../integrations/github.js';
+import { fullName, repoForEvent, testsOffRepo } from '../repos.js';
+import { prepareReview } from '../review/index.js';
+import { renderCheckRun, renderStickyComment, commentHead, markStale, renderQaSection, reportConsistency, reviewEvidence, } from '../review/render.js';
+import { docsOnlyChange, FORK_NOT_RUN_REASON, forkNotRunReport, mergeShaOf, reusableMergeRun, runnerKey, skippedReport, specSuiteReport, testSavings, } from './testSavings.js';
+import { checkShaOf, closeUnrun, trackRun } from './checkStatus.js';
+import { prTestPlan, prTestTargetOf, sharedBuildNote } from './prTarget.js';
+import { joinTestRepoReport, runTestRepos, testRepoHold, testRepoSwitches, testReposFor } from './testRepo.js';
+import { draftDefects } from './defects.js';
+import { runMergeCases } from './mergeCases.js';
+import { draftIssueDefects } from './defectDraft.js';
+import { draftTicketQuestions } from './questions.js';
+import { environmentFactsFor } from './default-branch.js';
+import { intentsFor } from './intent-sources.js';
+import { refreshAfterRun } from './testStatus.js';
+import { pendingCiNote, readCi } from './ci.js';
+import { readabilityRubric } from '../review/readability.js';
+import { qaBackendForStage, runQaReview } from '../review/run.js';
+import { readLinkedTickets } from '../review/linked-tickets.js';
+import { planReport } from '../review/report-plan.js';
+import { ModelUnavailableError } from '../agent/model-errors.js';
+import { teamCasesIn } from '../lead.js';
+import { recordPrLinks } from '../links.js';
+import { scopeNote } from '../pr-scope.js';
+import { specNotesForPr } from '../impact/pr.js';
+import { applyAiVisionResults, planAiVisionCases } from '../runner/aivision/index.js';
+import { applyPwgenResults, engineOf, keptItemIds, planPwgenItems, pwgenOptions, runPwgen } from '../runner/pwgen/index.js';
+import { proposalAction } from '../runner/pwgen/propose.js';
+import { run as runTests, RunCancelledError } from '../runner/index.js';
+import { checkConclusion, diffSummary, discoverSpecs, eventOf, forkCodeWouldRun, getDiff, guardedGithub, loadWatch, pickSpecs, publicRunUrl, pushAction, recheckByReply, renderComment, repoTarget, runSuite, setDemoBug, specDirFor, withDemoShop, noteModelFallback, notRunVerdict, } from './common.js';
+import { applyManualTicks, applyQaToVerdict, applyTestResults, clearRunnerResults, combineReviews, differingFiles, findReviewedRun, manualTicks, markOlderReviewsStale, mergeReports, newerHead, reviewSettings, scopeSpecs, selectQaSpecs, storeDiff, } from './qa.js';
+import { bugRepoAlts, bugRepoOf, targetRepo } from '../repos.js';
+import { noteTestTotals } from '../monitor/self-health.js';
+/** The URL of a deployment of this PR's head, when one is known: the job payload names it, or a deployment_status delivery recorded it. */
+function previewOf(c, payload) {
+    const repo = c.ev.repo ?? targetRepo(c.watch, c.ev) ?? undefined;
+    return typeof payload.previewUrl === 'string' ? payload.previewUrl : repo && c.ev.pr?.headSha ? previewFor(repo, c.ev.pr.headSha) : undefined;
+}
+function baseUrlFor(c, demoUrl, payload) {
+    return demoUrl ?? (c.task === 'pr_check' ? previewOf(c, payload) : undefined) ?? (c.task === 'post_merge' ? c.deployUrl : undefined) ?? c.watch.baseUrl;
+}
+/** How often a PR check that waits for a preview looks for it. A test sets it low. */
+export const previewWait = { pollMs: 2000 };
+/**
+ * waitForPreviewSec (docs/SETUP.md section Waiting for a preview): a PR check whose dot sets it holds for up to that many seconds for a
+ * deployment of the PR head to be reported (a deployment_status delivery, which only a dot on webhooks gets), then tests what it has: the
+ * preview when it came, else the dot's base URL under the PR test target. The check keeps its queue slot while it waits. A cancelled
+ * run stops waiting.
+ */
+async function waitForPreview(c, payload) {
+    const sec = c.watch.waitForPreviewSec ?? 0;
+    const head = c.ev.pr?.headSha;
+    if (sec <= 0 || !head || c.watch.runner.mode === 'demo' || previewOf(c, payload))
+        return;
+    const short = head.slice(0, 7);
+    addStep(c.run.id, 'Waiting for the PR preview', `No preview of ${short} is known yet. localdost waits up to ${sec} s for one.`, 'info');
+    const until = Date.now() + sec * 1000;
+    while (Date.now() < until && !previewOf(c, payload) && !isRunCancelled(c.run.id)) {
+        await new Promise((r) => setTimeout(r, Math.max(1, Math.min(previewWait.pollMs, until - Date.now()))));
+    }
+    const url = previewOf(c, payload);
+    if (url)
+        addStep(c.run.id, 'PR preview found', `The tests run against ${url}.`, 'ok');
+    else if (!isRunCancelled(c.run.id))
+        addStep(c.run.id, 'No PR preview appeared', `Waited ${sec} s for a preview of ${short}. The tests run as the PR test target says.`, 'warn');
+}
+/** The Tests repo batch (KAT-86): runs after the app repo's own tests, against the same target, and joins its report to theirs. */
+async function testRepoBatch(c, payload, report, review, repos) {
+    const out = await withDemoShop(c.watch, async () => {
+        const demoUrl = await setDemoBug(c.watch, c.diff, c.run.id, true);
+        const baseUrl = baseUrlFor(c, demoUrl, payload);
+        return runTestRepos({ watch: c.watch, ev: c.ev, runId: c.run.id, task: c.task, ...(baseUrl ? { baseUrl } : {}), ...(review ? { review } : {}), repos });
+    });
+    return out ? joinTestRepoReport(report, out.report) : report;
+}
+/** The tickets the PR links, read for the reviewer (KAT-388). Never fails the run: without them the review reads the PR body alone. */
+async function linkedTicketsOf(c) {
+    try {
+        const res = await readLinkedTickets(c.watch, c.ev);
+        if (res.tickets.length)
+            addStep(c.run.id, 'Linked tickets', `Read ${res.tickets.map((t) => t.ref).join(', ')} for the review, ${res.tickets.reduce((n, t) => n + t.criteria.length, 0)} acceptance criteria.`, 'info');
+        for (const n of res.notRead)
+            addStep(c.run.id, 'Linked ticket not read', `${n.ref}: ${n.reason}. The review ran without it.`, 'warn');
+        return res;
+    }
+    catch (err) {
+        addStep(c.run.id, 'Linked tickets not read', err instanceof Error ? err.message : String(err), 'warn');
+        return { tickets: [], notRead: [] };
+    }
+}
+/** Stages 1 to 6 for `files`; null with a warn step when the review cannot run. */
+async function reviewChange(c, files, label = 'QA review') {
+    try {
+        const live = c.gh.mode !== 'demo';
+        const prep = await prepareReview({
+            watch: c.watch,
+            event: c.ev,
+            base: c.base,
+            head: c.head,
+            files,
+            runId: c.run.id,
+            // Owner files come from the base sha so a PR cannot steer its own review. Demo reads
+            // the local checkout, where prepareReview already ignores files the PR touches.
+            ...(live && c.base ? { readBaseFile: (p) => c.gh.readFile(p, c.base) } : {}),
+            ...(live && c.head ? { readHeadFile: (p) => c.gh.readFile(p, c.head) } : {}),
+            ...(live ? { fetchRawDiff: () => c.gh.rawDiff(c.ev.pr ? { pr: c.ev.pr.number } : { base: c.base, head: c.head }) } : {}),
+            ...(live ? { artifacts: c.gh.artifactSource() } : {}),
+        });
+        addStep(c.run.id, `Prepared the ${label.toLowerCase()}`, `${prep.hunks.length} changed range${prep.hunks.length === 1 ? '' : 's'}, ${prep.shownSignals.length} signal${prep.shownSignals.length === 1 ? '' : 's'}, ${prep.impactDrafts.length} impact area${prep.impactDrafts.length === 1 ? '' : 's'}, ${prep.specPaths.length} specs known.`);
+        const linked = await linkedTicketsOf(c);
+        const res = await runQaReview(prep, {
+            watch: c.watch,
+            event: c.ev,
+            prBody: c.ev.pr?.body,
+            linkedTickets: linked.tickets,
+            ticketsNotRead: linked.notRead,
+            memory: listMemory(c.watch.id),
+            backend: qaBackendForStage(c.watch, runStage(c.run)),
+        });
+        const r = res.review;
+        const pass = (role) => r.passes.find((p) => p.role === role);
+        const rev = pass('reviewer');
+        addStep(c.run.id, label, `${r.risks.length} risk${r.risks.length === 1 ? '' : 's'}, ${r.whatToTest.length} test${r.whatToTest.length === 1 ? '' : 's'} to run, regression scope ${r.regressionScope.level}. ${rev ? `${rev.model} (${rev.backend}), ${rev.rounds} round${rev.rounds === 1 ? '' : 's'}.` : ''}${res.fallback ? ' The model answer failed the checks, so the rule-based answer stands in.' : ''}`, r.coverage.status === 'complete' ? 'ok' : 'warn');
+        const ver = pass('verifier');
+        if (ver) {
+            const by = (s) => [...r.risks, ...r.whatToTest, ...r.testsAtRisk, ...r.testGaps].filter((x) => x.verifier.status === s).length;
+            addStep(c.run.id, 'Verifier', `${by('confirmed')} confirmed, ${by('uncertain')} uncertain, ${r.droppedByVerifier.length} refuted and dropped${by('unverified') ? `, ${by('unverified')} unverified` : ''}.`, by('unverified') ? 'warn' : 'ok');
+        }
+        if (r.coverage.status === 'incomplete')
+            addStep(c.run.id, 'Review incomplete', r.coverage.missing[0] ?? 'Not every change reached the reviewer.', 'warn');
+        return { prep, review: r };
+    }
+    catch (err) {
+        // No model works: the run stops with that reason (guarded() in common.ts) instead of testing on without a review.
+        if (err instanceof ModelUnavailableError)
+            throw err;
+        // GitHub could not be reached for the checkout: the run stops and the job retries, instead of a review on patches alone.
+        if (err instanceof GithubUnreachableError)
+            throw err;
+        addStep(c.run.id, `${label} unavailable`, err instanceof Error ? err.message : String(err), 'warn');
+        return null;
+    }
+}
+function inventoryFor(c, prep) {
+    const found = discoverSpecs(specDirFor(c.watch), c.watch.runner.smokeGrep ?? '@smoke');
+    const all = found.length ? found.map((s) => s.file) : (prep?.tests.filter((t) => t.kind === 'e2e').map((t) => t.path) ?? []);
+    const smoke = found.length ? found.filter((s) => s.smoke).map((s) => s.file) : (prep?.tests.filter((t) => t.smoke).map((t) => t.path) ?? []);
+    const byArea = { ...(prep?.specsByArea ?? {}) };
+    for (const a of prep?.impactDrafts ?? [])
+        if (prep?.specsByArea[a.id])
+            byArea[a.area] = prep.specsByArea[a.id];
+    return { all, smoke, byArea };
+}
+/**
+ * Drafts for an older head of the PR, defects and ticket comments included, are superseded once a run for a newer head
+ * reads that head (dogfood ledger). A run for an older head that ends late closes nothing. Returns how many it closed.
+ */
+export function supersedeOldHeadDrafts(watchId, ev, head, run) {
+    const pr = ev.pr;
+    if (!pr || !head)
+        return 0;
+    if (newerHead(watchId, pr.number, head, run.createdAt))
+        return 0;
+    const repo = ev.repo ? `${ev.repo.owner}/${ev.repo.name}` : undefined;
+    const gone = supersedeOlderHeads(watchId, pr.number, head, repo);
+    if (gone.length)
+        addStep(run.id, 'Superseded drafts for the older head', `${gone.length} draft${gone.length === 1 ? '' : 's'} (${[...new Set(gone.map((a) => a.action.kind.replace('_', ' ')))].join(', ')}) for an older head of PR #${pr.number} closed.`, 'info');
+    return gone.length;
+}
+/** Before a new review lands: older reviews and the old comment say they are out of date. */
+async function markStaleHead(c) {
+    const pr = c.ev.pr;
+    if (!pr || !c.head)
+        return;
+    const n = markOlderReviewsStale(c.watch.id, pr.number, c.head, c.run.id);
+    const previous = await c.gh.getStickyComment(pr.number).catch(() => null);
+    const old = commentHead(previous);
+    if (previous && old && !c.head.startsWith(old)) {
+        await gate({
+            kind: 'pr_comment',
+            target: `${repoTarget(c.watch, c.ev)}#${pr.number}`,
+            title: `QA review for PR #${pr.number} is out of date`,
+            body: markStale(previous, c.head, { recheckByReply: recheckByReply() }),
+            meta: { pr: pr.number, sticky: true, stale: true, head: c.head, evidence: reviewEvidence({ newerHead: c.head, runId: c.run.id }) },
+        }, c.watch, c.run.id);
+    }
+    if (n || (old && !c.head.startsWith(old)))
+        addStep(c.run.id, 'Marked the old review out of date', `New head ${c.head.slice(0, 12)}.`, 'info');
+}
+/**
+ * What a run's tests are for, so they run on that commit in a worktree (KAT-284): the pull request of a pr_check, or
+ * the default branch for a merge. The runner confirms the commit either way (src/runner/verify.ts, KAT-291): the event
+ * only says what it claims, and a merge is checked against the default branch GitHub reports, or the branch named here when the
+ * dot lists it in testBranches (KAT-292).
+ * A range a person asked for may name any commit, so it carries neither and keeps the default-branch check and the HEAD check.
+ */
+function commitOf(c) {
+    const { ev } = c;
+    if (c.task === 'pr_check')
+        return ev.pr ? { pr: { number: ev.pr.number, ...(ev.pr.fork ? { fork: true } : {}) } } : {};
+    if (ev.pr?.mergeSha)
+        return { merge: ev.pr.baseRef ? { branch: ev.pr.baseRef } : {} };
+    if (ev.push && !ev.requestedBy)
+        return { merge: { branch: ev.push.ref.replace(/^refs\/heads\//, '') } };
+    return {};
+}
+async function heuristicRun(c, payload) {
+    return withDemoShop(c.watch, async () => {
+        const demoUrl = await setDemoBug(c.watch, c.diff, c.run.id);
+        const baseUrl = baseUrlFor(c, demoUrl, payload);
+        const pick = pickSpecs(c.watch, c.diff);
+        addStep(c.run.id, 'Picked specs', pick.specs.length ? `${pick.specs.length} of ${pick.total}: ${pick.reason}` : pick.reason);
+        const { report } = await runSuite(c.watch, c.run.id, { baseUrl, sha: c.sha, specs: pick.specs, repo: c.ev.repo, ...commitOf(c) });
+        return { report, picked: pick.specs, baseUrl };
+    });
+}
+async function batchRun(c, payload, specs, grep) {
+    return withDemoShop(c.watch, async () => {
+        const demoUrl = await setDemoBug(c.watch, c.diff, c.run.id, true);
+        const baseUrl = baseUrlFor(c, demoUrl, payload);
+        const { report } = await runSuite(c.watch, c.run.id, { baseUrl, sha: c.sha, specs, grep, repo: c.ev.repo, ...commitOf(c) });
+        return report;
+    });
+}
+/** post_merge: reuse the PR review at the same head, or review the difference only, or review it all. */
+async function postMergeReview(c) {
+    const reviewedHead = c.ev.pr?.headSha || c.ev.push?.after;
+    const prior = findReviewedRun(c.watch.id, reviewedHead);
+    if (!prior?.verdict?.qa)
+        return reviewChange(c, c.diff);
+    const changed = differingFiles(prior.diff, c.diff);
+    if (!changed.length) {
+        addStep(c.run.id, 'Reused the PR review', `The PR was reviewed at ${prior.verdict.qa.head.slice(0, 12)} in run ${prior.id}; the merge changes nothing it did not read.`, 'ok');
+        // Prep (no model call) still gives the spec links the regression scope needs.
+        let prep;
+        try {
+            prep = await prepareReview({ watch: c.watch, event: c.ev, base: c.base, head: c.head, files: c.diff, runId: c.run.id });
+        }
+        catch (err) {
+            if (err instanceof GithubUnreachableError)
+                throw err;
+            prep = undefined;
+        }
+        return { prep, review: { ...prior.verdict.qa, head: c.head, staleFor: undefined } };
+    }
+    addStep(c.run.id, 'Reviewing the merge difference', `The PR review at ${prior.verdict.qa.head.slice(0, 12)} is reused; ${changed.length} file${changed.length === 1 ? '' : 's'} changed after it: ${changed
+        .slice(0, 5)
+        .map((f) => f.path)
+        .join(', ')}.`);
+    const part = await reviewChange(c, changed, 'Review of the difference');
+    if (!part)
+        return { review: { ...prior.verdict.qa, head: c.head, staleFor: undefined } };
+    return { prep: part.prep, review: combineReviews(prior.verdict.qa, part.review, c.head, c.diff) };
+}
+/** Writes the PR's links to issues and tickets (closing keywords, ticket keys, closingIssuesReferences). Never fails the run. */
+async function linkPr(watch, ev, runId) {
+    try {
+        const n = await recordPrLinks(watch, ev);
+        if (n)
+            addStep(runId, 'Linked issues', `${n} new link${n === 1 ? '' : 's'} from the PR`);
+    }
+    catch (err) {
+        addStep(runId, 'Issue links failed', String(err), 'warn');
+    }
+}
+/** Recomputes the test status of the issues this PR links to, and drafts the status labels when the dot asks for them. Never fails the run. */
+async function refreshStatus(watch, ev, runId) {
+    if (!ev.pr || !ev.repo)
+        return;
+    try {
+        await refreshAfterRun(watch, `${ev.repo.owner}/${ev.repo.name}#${ev.pr.number}`, runId);
+    }
+    catch (err) {
+        addStep(runId, 'Test status failed', String(err), 'warn');
+    }
+}
+export async function checkChange(job, task) {
+    const ev = eventOf(job);
+    // A review asked for without posting runs with the PR comment and the check run held in the Inbox (KAT-357).
+    const watch = rulesForEvent(loadWatch(job.watchId), ev);
+    if (watch.paused) {
+        // A merge job that waited for the deploy (KAT-368) leaves its run held: a pause that came as the wait ended must not leave it there.
+        const held = get('jobs', job.id)?.deployWait?.runId;
+        if (held)
+            closeDeployRun(held, { label: 'Stopped waiting for the deploy', detail: 'The dot is paused, so localdost did not run this check.', status: 'warn' }, 'dot paused');
+        await closeUnrun(job, watch, 'Skipped', 'The dot is paused, so localdost did not run this check.');
+        return;
+    }
+    const run = startRun(watch.id, task, ev);
+    // The queued check moves to in progress now, follows the run, and is closed in finally if no report replaced it.
+    const check = trackRun(job, watch, ev, run);
+    try {
+        await runChange(job, task, watch, ev, run, check);
+    }
+    finally {
+        await check.close();
+    }
+}
+async function runChange(job, task, watch, ev, run, check) {
+    await guardedGithub(run.id, ev.pr ? `PR #${ev.pr.number}` : 'this change', async () => {
+        if (ev.requestedBy)
+            addStep(run.id, 'Review requested', `${ev.title}. Asked ${ev.requestedBy === 'chat' ? 'in chat' : 'on demand'}.`, 'info');
+        // A merge run that waited for the deploy (src/deploy-wait.ts) opened with this step already.
+        else if (!(task === 'post_merge' && run.steps.some((s) => s.label === 'Merge detected')))
+            addStep(run.id, task === 'post_merge' ? 'Merge detected' : 'Pull request updated', ev.title);
+        // KAT-384: a fork PR is reviewed and never tested. Reading its files is safe; running its code is not (runner.trustForks lifts that).
+        const forkNoTests = task === 'pr_check' && forkCodeWouldRun(watch, ev);
+        if (forkNoTests)
+            addStep(run.id, 'Tests did not run: fork pull request', `PR #${ev.pr?.number} comes from a fork, so localdost did not run its code. The code review still runs. Ask a maintainer to check it again.`, 'warn');
+        // The dot filters this repo by path but the changed files were unknown at match time (KAT-160).
+        if (ev.pathFilterNote && repoForEvent(watch, ev)?.pathFilters?.length) {
+            addStep(run.id, 'Path filters not applied', `${ev.pathFilterNote} The repo's path filters were skipped, so this event reached the dot.`, 'warn');
+        }
+        // A PR scope rule that could not be read let this PR in: say so on the run (KAT-354).
+        const scopeNotice = scopeNote(watch, ev);
+        if (scopeNotice)
+            addStep(run.id, 'PR scope not applied', scopeNotice, 'warn');
+        const diff = await getDiff(watch, ev);
+        addStep(run.id, 'Read the diff', diffSummary(diff));
+        // Any event that carries a PR records its links, so a merged PR that had no pr_check still has them before the status is computed.
+        if (ev.pr && ev.repo)
+            await linkPr(watch, ev, run.id);
+        const sha = checkShaOf(ev);
+        const settings = reviewSettings(watch);
+        const reviewOn = settings.enabled && diff.length > 0;
+        const head = (task === 'pr_check' ? ev.pr?.headSha : (ev.pr?.mergeSha ?? ev.push?.after)) ?? sha ?? '';
+        const base = ev.push?.before ?? ev.pr?.baseSha ?? '';
+        // A merge that waited for its deploy tests the URL GitHub gave for that deployment (src/deploy-wait.ts), else the dot's base URL.
+        const deployUrl = task === 'post_merge' && !ev.requestedBy ? get('jobs', job.id)?.deployWait?.url : undefined;
+        const c = { watch, ev, run, task, diff, gh: githubFor(watch, ev), sha, base, head, ...(deployUrl ? { deployUrl } : {}) };
+        const payload = job.payload;
+        if (reviewOn)
+            storeDiff(run.id, diff);
+        // Self-health reads these to tell code changes from docs-only ones; storeDiff only runs when the review is on.
+        update('runs', run.id, { changedPaths: diff.map((f) => f.path) });
+        // KAT-361: a repo with Run tests off is reviewed and never tested, so there is no "Tests did not run" failure for it.
+        // KAT-344: a docs-only change skips the test run, and a merge of the same tree reuses the PR results.
+        const savings = testSavings(watch);
+        const DOCS_ONLY_REASON = 'only docs or the changelog changed';
+        const testsOff = testsOffRepo(watch, ev);
+        const docsOnly = savings.docsOnlySkip && docsOnlyChange(diff);
+        const skipReason = forkNoTests ? undefined : testsOff ? `Run tests is off for ${fullName(testsOff)}` : docsOnly ? DOCS_ONLY_REASON : undefined;
+        const skipTests = skipReason !== undefined;
+        // KAT-86: the Tests repos of the dot run after the app repo's own tests. The app repo's Run tests switch does not hold them back.
+        // A fork PR's Tests repo follows its own fork rule (src/runner/test-repo.ts): the suite is the team's code, the page is the fork's.
+        const testRepos = testReposFor(watch, ev, task);
+        if (testsOff && !forkNoTests)
+            addStep(run.id, `Tests skipped: ${skipReason}`, `The dot reviews ${fullName(testsOff)} and runs no tests for it. Turn Run tests on for the repo in the dot settings to test its pull requests.`, 'info');
+        else if (skipTests)
+            addStep(run.id, `Tests skipped: ${DOCS_ONLY_REASON}`, `${diff.length} file${diff.length === 1 ? '' : 's'}: ${diff
+                .slice(0, 5)
+                .map((f) => f.path)
+                .join(', ')}${diff.length > 5 ? ', ...' : ''}.`, 'info');
+        // waitForPreviewSec: a PR check whose tests will run holds for the preview of its head before it picks a target.
+        if (task === 'pr_check' &&
+            !docsOnly &&
+            prTestTargetOf(watch) !== 'none' &&
+            ((!testsOff && !forkNoTests) || (testRepos.length > 0 && testRepoSwitches(watch).onPr)))
+            await waitForPreview(c, payload);
+        // KAT-363: what this PR check tests against. No preview of the PR means the dot's base URL, a build of shared QA work.
+        const prPlan = task === 'pr_check' ? prTestPlan({ watch, preview: previewOf(c, payload) }) : undefined;
+        const prPlanSkip = prPlan && !prPlan.run ? prPlan.skip : undefined;
+        const prSkip = forkNoTests ? undefined : prPlanSkip;
+        const testRepoWhy = testRepos.length ? testRepoHold({ watch, task, docsOnly, prSkip: prPlanSkip, baseUrl: baseUrlFor(c, undefined, payload) }) : null;
+        const testReposRun = testRepos.length > 0 && !testRepoWhy;
+        if (testRepos.length && testRepoWhy)
+            addStep(run.id, `Tests repo skipped: ${testRepoWhy}`, `The dot does not run ${testRepos.map(fullName).join(', ')} for this ${task === 'pr_check' ? 'PR' : 'merge'}.`, 'info');
+        // Why the tests of a PR check do not run: Run tests is off for the repo, only docs changed, or the dot's PR test target says so.
+        const noTestsWhy = task === 'pr_check' ? (forkNoTests ? FORK_NOT_RUN_REASON : (skipReason ?? prSkip)) : undefined;
+        // A fork PR has no test result at all, which is no pass: its report says the tests did not run.
+        const noTestsReport = (why) => (forkNoTests ? forkNotRunReport() : skippedReport(why));
+        if (prSkip && !skipTests)
+            addStep(run.id, `Tests skipped: ${prSkip}`, `The dot's PR test target is ${watch.prTestTarget ?? 'base'}. The code review still runs.`, 'info');
+        const sharedBuild = prPlan?.shared === true && (!noTestsWhy || testReposRun);
+        if (sharedBuild)
+            addStep(run.id, 'Tests run against the shared QA build', `No preview of this PR is known, so the tests run against the dot's base URL (${watch.baseUrl}), not a build of this PR. A failure may be this PR's new or changed spec running against an older build, so none is drafted as a defect.`, 'warn');
+        let reuse = null;
+        // The spec suite a pr_check run ran, kept on the run so a merge reuses it only when it covers the merge's own selection.
+        let tested;
+        let report;
+        let review;
+        // Repo paths of known e2e specs: where proposed generated specs go.
+        let e2ePaths = [];
+        if (task === 'pr_check') {
+            // Stage 7 overlaps stages 4 and 5: the heuristic run starts with the review. Both settle before
+            // the run goes on or stops, so a failed read never leaves the other half running in the background.
+            const heurRun = noTestsWhy ? Promise.resolve({ report: noTestsReport(noTestsWhy), picked: [] }) : heuristicRun(c, payload);
+            const [heur, rvRes] = await Promise.allSettled([heurRun, reviewOn ? reviewChange(c, diff) : Promise.resolve(null)]);
+            if (heur.status === 'rejected')
+                throw heur.reason;
+            if (rvRes.status === 'rejected')
+                throw rvRes.reason;
+            const first = heur.value;
+            const rv = rvRes.value;
+            // No picked specs means the full suite ran.
+            if (!noTestsWhy) {
+                const url = first.baseUrl;
+                const at = url ? { baseUrl: url } : {};
+                tested = first.picked.length ? { full: false, specs: [...first.picked], ...at } : { full: true, specs: [], ...at };
+            }
+            // The old comment says it is out of date only once the head is known to be readable: a run that
+            // stops because GitHub is unreachable drafts nothing for the PR (KAT-283).
+            if (reviewOn)
+                await markStaleHead(c);
+            supersedeOldHeadDrafts(watch.id, ev, head, run);
+            report = first.report;
+            if (rv) {
+                if (!noTestsWhy) {
+                    const sel = selectQaSpecs({ heuristic: first.picked, review: rv.review, inv: inventoryFor(c, rv.prep) });
+                    addStep(run.id, 'Specs from the review', sel.added.length ? `${sel.added.length} more: ${sel.added.join(', ')} (${sel.reason})` : `No more specs: ${sel.reason}.`);
+                    if (sel.added.length)
+                        report = mergeReports(report, await batchRun(c, payload, sel.added, sel.grep));
+                    // Added specs run whole only without a title filter; a filtered batch ran part of each spec.
+                    // The added specs ran against the same base URL, so the record keeps it: merge reuse compares it (KAT-358).
+                    if (sel.added.length && !sel.grep && tested && !tested.full)
+                        tested = { ...tested, full: false, specs: [...new Set([...tested.specs, ...sel.added])] };
+                }
+                review = rv.review;
+                e2ePaths = rv.prep.tests.filter((t) => t.kind === 'e2e').map((t) => t.path);
+            }
+            if (testReposRun)
+                report = await testRepoBatch(c, payload, report, review, testRepos);
+        }
+        else {
+            const rv = reviewOn ? await postMergeReview(c) : null;
+            review = rv?.review;
+            e2ePaths = rv?.prep?.tests.filter((t) => t.kind === 'e2e').map((t) => t.path) ?? [];
+            let specs;
+            let why;
+            // The merge's selection, decided before reuse: a PR run reuses only when it ran every spec the merge would.
+            let mergeFull = true;
+            let mergeSpecs = [];
+            if (!skipTests) {
+                const pick = pickSpecs(watch, diff);
+                const s = review
+                    ? scopeSpecs(review, inventoryFor(c, rv?.prep), diff.map((f) => f.path))
+                    : undefined;
+                mergeFull = !!s?.full || !pick.specs.length;
+                mergeSpecs = mergeFull ? [] : [...new Set([...(s?.specs ?? []), ...pick.specs])];
+                if (review && !mergeFull && mergeSpecs.length) {
+                    specs = mergeSpecs;
+                    why = `${s.reason}; ${mergeSpecs.length} specs with today's pick.`;
+                }
+                else if (review && mergeFull) {
+                    specs = [];
+                    why = s.full ? s.reason : 'no spec matched the diff, so the full suite runs.';
+                }
+            }
+            if (!skipTests && savings.reuseMergeResults && !ev.requestedBy) {
+                const mergeUrl = baseUrlFor(c, undefined, payload);
+                reuse = await reusableMergeRun(watch, c.gh, ev, { full: mergeFull, specs: mergeSpecs, ...(mergeUrl ? { baseUrl: mergeUrl } : {}) });
+                if (reuse) {
+                    const url = publicRunUrl(reuse.run.id);
+                    addStep(run.id, `Same code as the tested PR head ${reuse.head.slice(0, 7)}: reusing its results`, `The merge commit ${mergeShaOf(ev).slice(0, 7)} and the PR head have tree ${reuse.tree.slice(0, 12)}. Results of run ${reuse.run.id}${url ? `: ${url}` : '.'}`, 'ok');
+                }
+            }
+            if (skipTests)
+                report = skippedReport(skipReason);
+            else if (reuse)
+                report = specSuiteReport(reuse.run.report);
+            else if (specs) {
+                report = await withDemoShop(watch, async () => {
+                    const demoUrl = await setDemoBug(watch, diff, run.id);
+                    addStep(run.id, 'Picked specs', `Regression scope drives the run. ${why ?? ''}`.trim());
+                    return (await runSuite(watch, run.id, { baseUrl: baseUrlFor(c, demoUrl, payload), sha, specs, repo: ev.repo, ...commitOf(c) })).report;
+                });
+            }
+            else
+                report = (await heuristicRun(c, payload)).report;
+            if (testReposRun)
+                report = await testRepoBatch(c, payload, report, review, testRepos);
+        }
+        // Generated Playwright specs (engine auto, playwright, or both) cover review items no existing
+        // spec covers; results land as pwgen/<id>.spec.ts.
+        const engine = engineOf(watch);
+        const testsSkipped = skipTests || !!noTestsWhy;
+        const pwOpts = review && !testsSkipped ? pwgenOptions(watch, task) : null;
+        let pw;
+        if (review && pwOpts) {
+            const items = planPwgenItems(review, pwOpts.maxSpecs);
+            const targetUrl = baseUrlFor(c, undefined, payload);
+            if (items.length && !targetUrl) {
+                addStep(run.id, 'Skipped Playwright e2e tests', 'No preview URL and no base URL to run them against. Set the dot base URL.', 'warn');
+            }
+            else if (items.length && targetUrl) {
+                addStep(run.id, 'Writing Playwright e2e tests', `${items.length} item${items.length === 1 ? '' : 's'} without a spec, against ${targetUrl}: ${items
+                    .slice(0, 3)
+                    .map((t) => t.scenario)
+                    .join(', ')}${items.length > 3 ? ', ...' : ''}`);
+                pw = await runPwgen({
+                    watch,
+                    review,
+                    items,
+                    targetUrl,
+                    ...(watch.baseUrl ? { baseUrl: watch.baseUrl } : {}),
+                    runId: run.id,
+                    step: (title, detail, level) => addStep(run.id, title, detail, level),
+                    isCancelled: () => isRunCancelled(run.id),
+                });
+                const kept = (pw.generated ?? []).filter((g) => g.status === 'kept').length;
+                addStep(run.id, 'Playwright e2e finished', `${kept} kept (${pw.passed} passed, ${pw.failed} failed), ${(pw.generated?.length ?? 0) - kept} discarded, in ${Math.round(pw.durationMs / 1000)} s`, pw.failed ? 'warn' : 'ok');
+                report = mergeReports(report, pw);
+                // A cancel during generation stops the run here, before anything goes outward.
+                if (isRunCancelled(run.id))
+                    throw new RunCancelledError(run.id);
+            }
+        }
+        // AI-Vision cases (review items and ticket test ideas) run after the specs; results land as aivision/<id>.yaml.
+        // auto: only items no generated spec covered. playwright: none.
+        const avCases = engine === 'playwright' || testsSkipped
+            ? []
+            : planAiVisionCases({ watch, kind: task, ...(review ? { review } : {}), event: ev, ...(engine === 'auto' ? { excludeItems: keptItemIds(pw) } : {}) });
+        // The cases another member of the team designed (Ticket Reviewer) are named in the report, by the dot that owns them (KAT-405).
+        for (const [owner, cases] of teamCasesIn(watch.id, avCases)) {
+            addStep(run.id, `Test cases from ${owner}`, `${cases.length} case${cases.length === 1 ? '' : 's'}: ${cases
+                .slice(0, 5)
+                .map((c) => `${c.key} ${c.title}`)
+                .join('; ')}${cases.length > 5 ? '; ...' : ''}`, 'info');
+        }
+        if (avCases.length) {
+            addStep(run.id, 'Running AI-Vision cases', `${avCases.length} case${avCases.length === 1 ? '' : 's'}: ${avCases
+                .slice(0, 3)
+                .map((x) => x.title)
+                .join(', ')}${avCases.length > 3 ? ', ...' : ''}`);
+            const av = await runTests({ watch, repo: ev.repo, sha, baseUrl: baseUrlFor(c, undefined, payload), aivision: { cases: avCases } }, { runId: run.id });
+            addStep(run.id, 'AI-Vision finished', `${av.passed} passed, ${av.failed} failed, ${av.skipped} skipped in ${Math.round(av.durationMs / 1000)} s`, av.failed ? 'warn' : 'ok');
+            report = mergeReports(report, av);
+        }
+        // A PR run against the shared build says nothing about the PR's code, so a merge never reuses it (KAT-363, prRunCovers).
+        if (task === 'pr_check')
+            update('runs', run.id, {
+                runnerKey: runnerKey(watch),
+                ...(tested && !sharedBuild ? { testedSpecs: tested } : {}),
+                // The ticket test status reads a failure of this run as not tested on this PR (src/flows/testStatus.ts).
+                ...(sharedBuild && !report.notRun ? { sharedBuild: true } : {}),
+            });
+        // Tests that ran against the shared build say so on the report, next to the counts (KAT-363).
+        if (sharedBuild && !report.notRun)
+            report = { ...report, hint: [report.hint, sharedBuildNote(report.failed)].filter(Boolean).join(' ') };
+        setReport(run.id, report);
+        const pr = ev.pr?.number;
+        if (review) {
+            review = clearRunnerResults(review);
+            const ci = await readCi(c.gh, head);
+            if (ci) {
+                const done = ci.jobs.filter((j) => j.check.status === 'completed').length;
+                addStep(run.id, 'Read CI results', `${ci.jobs.length} check run${ci.jobs.length === 1 ? '' : 's'} on ${head.slice(0, 7)}, ${done} finished.`);
+            }
+            else
+                addStep(run.id, 'No CI evidence', `No CI check runs could be read for ${head.slice(0, 7)}.`, 'info');
+            review = applyTestResults(review, report, ci);
+            // The own run was not for this commit, so its count is withheld. Say where the results will come from.
+            const pending = report.notRun?.stage === 'checkout' ? pendingCiNote(ci) : '';
+            if (report.notRun && pending) {
+                report = { ...report, notRun: { ...report.notRun, reason: `${report.notRun.reason} ${pending}` } };
+                setReport(run.id, report);
+            }
+            review = applyPwgenResults(review, report);
+            review = applyAiVisionResults(review, report);
+            if (pr && task === 'pr_check')
+                review = applyManualTicks(review, manualTicks(watch.id, pr, run.id));
+            if (pr && task === 'pr_check') {
+                const newer = newerHead(watch.id, pr, head, run.createdAt);
+                if (newer)
+                    review = { ...review, staleFor: newer };
+            }
+            // Decisions the PR body, its tickets and the docs state: a matching finding is a behavior change to confirm.
+            const intents = await intentsFor(watch, ev, diff, c.gh.mode !== 'demo' && c.base ? (p) => c.gh.readFile(p, c.base) : undefined);
+            if (intents.length) {
+                review = { ...review, intents };
+                addStep(run.id, 'Read the stated decisions', `${intents.length} statement${intents.length === 1 ? '' : 's'} of intent in the PR, its tickets and the docs.`, 'info');
+            }
+        }
+        // The cases of the tickets this merge closes or references: automated ones record their result, manual ones wait in a test run (KAT-169).
+        const mergeCases = task === 'post_merge' ? runMergeCases(watch, run, ev, report) : undefined;
+        // Tests that did not run get a fixed environment verdict; the model never reads a missing report as a failure.
+        const analyzed = report.notRun && report.failed === 0
+            ? notRunVerdict(report, pr ? `PR #${pr}` : 'this change')
+            : noteModelFallback(run.id, await getLlmFor(watch, runStage(run)).analyze({
+                task,
+                watch,
+                event: ev,
+                diff,
+                report,
+                memory: listMemory(watch.id),
+                ...(review ? { qaReview: review } : {}),
+            }));
+        // The report says what was tested and what was found (KAT-96); it never advises on the merge.
+        // Links and defects point at the repo the change is in, which for a two-repo dot is not always the first one.
+        const changeRepo = targetRepo(watch, ev);
+        const links = { repo: changeRepo ? { owner: changeRepo.owner, name: changeRepo.name } : undefined, serverUrl: githubWebUrl() };
+        const bugScope = task === 'pr_check' && pr ? `pr:${pr}` : `merge:${sha ?? run.id}`;
+        // The tests of this run ran against the shared build and have results: the report, the check and the push treat a failure as no bug of the PR (KAT-363).
+        const planShared = sharedBuild && !report.notRun;
+        // One step decides bugs, risks to test, the headline, and what may become a defect (dogfood ledger).
+        const plan = planReport({
+            task,
+            watchId: watch.id,
+            runId: run.id,
+            review,
+            report,
+            verdict: review ? applyQaToVerdict(analyzed, review, report, settings.showFrom) : analyzed,
+            prNumber: pr,
+            sha: sha ? (task === 'pr_check' ? head : sha) : undefined,
+            showFrom: settings.showFrom,
+            scope: bugScope,
+            ...(bugRepoOf(watch, changeRepo) ? { repo: bugRepoOf(watch, changeRepo) } : {}),
+            altRepos: bugRepoAlts(watch, changeRepo),
+            addedFiles: diff.filter((f) => f.status === 'added').map((f) => f.path),
+            sharedBuild: planShared,
+            environment: environmentFactsFor(watch, diff.map((f) => f.path), run.id, ev ?? undefined),
+        });
+        const verdict = plan.verdict;
+        const qaPush = plan.qaPush;
+        const bugs = plan.findings;
+        setVerdict(run.id, verdict);
+        addStep(run.id, 'Verdict', verdict.headline, verdict.outcome === 'pass' ? 'ok' : verdict.outcome === 'product_failure' ? 'error' : 'warn');
+        const target = repoTarget(watch, ev);
+        const runUrl = publicRunUrl(run.id);
+        // A stale review gets no defects: the newer head's run drafts them.
+        // A test that failed on every attempt drafts an issue_create (KAT-87). The other bugs keep the file_defect path.
+        let defects = {};
+        // A finding without a concrete Expected is a question on the linked ticket, never a defect.
+        // A criterion of a linked ticket that no changed line touches is a question on that ticket too (KAT-388).
+        const notCovered = review?.criteriaNotCovered ?? [];
+        if ((plan.questions.length || notCovered.length) && !review?.staleFor)
+            await draftTicketQuestions(watch, run.id, ev, plan.questions, head, notCovered, task);
+        // Reproduced failures become defects. A risk nothing reproduced stays a risk to test, unless it cites a line and the input
+        // that breaks it: that one is drafted too, labelled "found by reading the code" (dogfood ledger).
+        if (plan.defectBugs.length && !review?.staleFor && verdict.outcome !== 'environment_failure') {
+            const issues = await draftIssueDefects({
+                watch,
+                runId: run.id,
+                ev,
+                verdict,
+                report,
+                bugs: plan.defectBugs,
+                head,
+                task,
+                ...(mergeCases?.cases.length ? { cases: mergeCases.cases } : {}),
+            });
+            const rest = plan.defectBugs.filter((b) => !issues.handled.has(b.key));
+            defects = {
+                ...issues.links,
+                ...(rest.length
+                    ? await draftDefects(watch, run.id, rest, {
+                        prNumber: pr,
+                        head,
+                        task,
+                        runUrl,
+                        ...links,
+                        ...(report.testRepos?.length ? { testRepos: report.testRepos } : {}),
+                        ...(mergeCases?.cases.length ? { cases: mergeCases.cases } : {}),
+                        ...(c.gh.mode !== 'demo' && head ? { readFile: (p) => c.gh.readFile(p, head) } : {}),
+                    })
+                    : {}),
+            };
+        }
+        // Specs that a ticket of this PR says need an update, and the PR leaves alone (KAT-304).
+        const impactNotes = task === 'pr_check'
+            ? specNotesForPr(watch, ev, diff.map((f) => f.path))
+            : [];
+        if (impactNotes.length)
+            addStep(run.id, 'Specs not updated', `${impactNotes.length} spec${impactNotes.length === 1 ? '' : 's'} the ticket changes, not changed by this PR.`, 'info');
+        let reportRefused = [];
+        const testConclusion = checkConclusion(verdict);
+        const parts = sha && review
+            ? renderCheckRun(review, testConclusion, {
+                showFrom: settings.showFrom,
+                blockOn: settings.blockOn,
+                sharedBuild: planShared,
+                report,
+                task,
+                verdict,
+                bugs,
+                defects,
+                runUrl,
+                impactNotes,
+                ...links,
+            })
+            : null;
+        if (sha) {
+            if (parts?.blocked)
+                addStep(run.id, 'Check marked as failed', `A confirmed risk is at or above the block level (${settings.blockOn}).`, 'warn');
+            // Every number in the headline, the title and the text must match the one summary, or nothing is drafted.
+            const mismatch = parts ? reportConsistency(parts.counts, { headline: verdict.headline, checkTitle: parts.title, checks: [parts.summary] }) : [];
+            if (mismatch.length) {
+                reportRefused = mismatch;
+                addStep(run.id, 'Report not drafted: its counts disagree', mismatch.join(' '), 'error');
+            }
+        }
+        if (sha && !reportRefused.length) {
+            // Stops the progress updates and returns the id of the check run queued earlier, so the report completes that one.
+            const checkRef = await check.prepareFinal();
+            const written = await gate({
+                kind: 'check_run',
+                target: `${target}@${sha.slice(0, 7)}`,
+                title: parts?.title ?? verdict.headline,
+                body: parts?.summary ?? verdict.summary,
+                meta: {
+                    sha,
+                    // A post-merge check run belongs to the merge commit, not to the PR, so the PR state never expires it.
+                    ...(pr && task === 'pr_check' ? { pr } : {}),
+                    conclusion: parts?.conclusion ?? testConclusion,
+                    outcome: verdict.outcome,
+                    ...(parts ? { text: parts.text, annotations: parts.annotations } : {}),
+                    ...checkRef,
+                    evidence: reviewEvidence({ verdict, review, report }),
+                },
+            }, watch, run.id);
+            await check.finalWritten(written);
+        }
+        // post_merge with a review: no sticky comment (section 2.10). Without one, today's comment stays.
+        if (pr && (task === 'pr_check' || !review)) {
+            if (reportRefused.length) {
+                addStep(run.id, 'Skipped the PR comment', 'The report counts disagree, so no comment was drafted.', 'warn');
+            }
+            else if (review?.staleFor) {
+                addStep(run.id, 'Skipped the PR comment', `A newer head ${review.staleFor.slice(0, 12)} is under review; its comment replaces this one.`, 'info');
+            }
+            else {
+                const previous = review ? await c.gh.getStickyComment(pr).catch(() => null) : null;
+                const body = review
+                    ? renderStickyComment({
+                        verdict,
+                        review,
+                        previous,
+                        ticked: manualTicks(watch.id, pr),
+                        sharedBuild: planShared,
+                        report,
+                        runUrl,
+                        showFrom: settings.showFrom,
+                        blockOn: settings.blockOn,
+                        task,
+                        bugs,
+                        defects,
+                        impactNotes,
+                        recheckByReply: recheckByReply(),
+                        ...links,
+                    })
+                    : renderComment(verdict, run.id, undefined, task, { report, bugs, defects, impactNotes, ...(planShared ? { sharedBuild: true } : {}), ...links });
+                const counts = review ? renderQaSection(review, { report, showFrom: settings.showFrom, bugs, impactNotes }).summary : null;
+                const off = counts ? reportConsistency(counts, { headline: verdict.headline, comments: [body] }) : [];
+                // Every run, dogfood rounds included, scores the comment against the readability rubric (KAT-96).
+                const rubric = readabilityRubric(body);
+                addStep(run.id, 'Readability', `${Object.values(rubric.pass).filter(Boolean).length} of ${Object.keys(rubric.pass).length} checks pass${rubric.notes.length ? `: ${rubric.notes.join('; ')}` : ''}`, rubric.score === 1 ? 'ok' : 'info');
+                if (off.length)
+                    addStep(run.id, 'Report not drafted: its counts disagree', off.join(' '), 'error');
+                else
+                    await gate({
+                        kind: 'pr_comment',
+                        target: `${target}#${pr}`,
+                        title: `QA report for PR #${pr}`,
+                        body,
+                        meta: {
+                            pr,
+                            sticky: true,
+                            // The QA report summary comment: long by design, so no length limit applies (rules.ts lengthLimit).
+                            reportSummary: true,
+                            ...(review ? { head: review.head } : {}),
+                            ...(task === 'post_merge' ? { afterMerge: true } : {}),
+                            evidence: reviewEvidence({ verdict, review, report }),
+                        },
+                    }, watch, run.id);
+            }
+        }
+        // Kept passing specs go to the repo as a proposed PR, behind the open_pr rule. On a pull
+        // request it targets the PR branch, so the specs land with the change they test.
+        if (pw?.generated?.length && pwOpts?.proposePr !== false && watch.repo && !ev.pr?.fork) {
+            const repo = ev.repo ?? watch.repo;
+            // A merge on a test branch of the dot (KAT-292) proposes the specs against that branch, else the default branch.
+            const mergedInto = ev.pr?.baseRef || ev.push?.ref.replace(/^refs\/heads\//, '');
+            const mergeBase = mergedInto && (watch.testBranches ?? []).includes(mergedInto) ? mergedInto : watch.repo.defaultBranch;
+            const base = task === 'pr_check' ? ev.pr?.headRef : mergeBase;
+            const action = base
+                ? proposalAction({ generated: pw.generated, repo, base, runId: run.id, runUrl: publicRunUrl(run.id), e2ePaths, ...(pr ? { prNumber: pr } : {}) })
+                : null;
+            if (action)
+                await gate(action, watch, run.id);
+        }
+        if (verdict.outcome === 'product_failure') {
+            await gate(pushAction(verdict.headline, verdict.suspectedCause ?? 'Open the run for details.', 'high', `${task}:${watch.id}:${sha ?? run.id}`), watch, run.id);
+        }
+        else if (qaPush) {
+            const action = pushAction(qaPush.headline, qaPush.body, qaPush.urgency, qaPush.key);
+            await gate({ ...action, meta: { ...action.meta, url: qaPush.url, reason: qaPush.reason } }, watch, run.id);
+        }
+        await refreshStatus(watch, ev, run.id);
+        finishRun(run.id, 'done');
+        // Self-health: the same totals on three different commits mean the reports may be stale (dogfood ledger).
+        noteTestTotals(watch.id);
+    });
+}
+//# sourceMappingURL=change.js.map