tinybeeai 0.0.0-stage → 0.16.1

package/dist/flows/defects.js

@@ -0,0 +1,623 @@
+// Defects for bugs the dot found (KAT-96). Each bug becomes one `file_defect` action in the dot's
+// tracker (Jira, Linear, or GitHub issues on the repo), sent through the rules gate, so the
+// default "ask" rule puts every draft in the Inbox. A bug is drafted once per PR: a later push finds
+// the earlier draft or the filed issue by its bug key and links that instead of drafting again.
+// Before it drafts, the dot looks for an open issue about the same bug (KAT-121). It then adds the new
+// evidence as a comment on that issue (once per head sha, through the rules gate) and links it.
+import { createHash } from 'node:crypto';
+import { config } from '../config.js';
+import { list } from '../db.js';
+import { gate } from '../agent/rules.js';
+import { issueRef, requiredLabel, trackerDefectLabel, trackerDefectType, trackerRepos } from '../integrations/github-issues.js';
+import { githubFor, githubForIssues, isDefectLabel } from '../integrations/github.js';
+import { jiraFor } from '../integrations/jira.js';
+import { linearFor } from '../integrations/linear.js';
+import { joinTeamDraft, sourcesOf, teamDraftFor } from '../lead-defects.js';
+import { teamIds, teamTracker, trackerOwner } from '../lead.js';
+import { linksFor } from '../links.js';
+import { bugRepoAlts, bugRepoOf, parseRepoId, sameRepo as sameRepoRef } from '../repos.js';
+import { bugSignature, bugSignatureAlts, NEEDS_MANUAL_STEPS_LABEL, prRefIn, READING_LABEL, foldsDefect, renderDefect, } from '../review/render.js';
+import { caseDetail, caseForTest, caseMeta } from './mergeCases.js';
+export const MAX_DEFECTS = 6;
+function inboxUrl() {
+    const base = config.publicUrl;
+    return base ? `${base.replace(/\/$/, '')}/#/inbox` : undefined;
+}
+/**
+ * Where a defect will land, in words for the Inbox card and the PR report: `acme/shop` for a GitHub repo,
+ * `Jira SHOP` or `Linear KAT` for the others.
+ */
+export function defectWhere(where) {
+    return where.tracker === 'github' ? where.project : `${where.tracker === 'jira' ? 'Jira' : 'Linear'} ${where.project}`;
+}
+/**
+ * Tracker and project for defects: the dot's tracker when it has one, else the repo's issues. A GitHub tracker that
+ * names its repos files in the first of them: a team that tracks bugs in one repo has Issues turned off or shared with
+ * other pods in its code repos (KAT-355). A bug found in a repo the tracker itself names stays there, because that repo
+ * has Issues on and the dot reads them. A GitHub tracker with no repos of its own tracks the dot's app repos, so a
+ * defect goes to the repo the bug was found in.
+ */
+export function defectTarget(watch, repo) {
+    // A member with a lead and no tracker of its own files into the team's tracker (KAT-405): PR Reviewer and Regression Runner bugs go to
+    // katalon-studio/product with Ticket Reviewer's access. A member with its own tracker keeps it, and a dot with no lead files as before.
+    if (!watch.tracker) {
+        const team = teamTracker(watch.id);
+        if (team && team.id !== watch.id)
+            return defectTarget(team, repo);
+    }
+    const t = watch.tracker;
+    if (t?.kind === 'jira' && t.projectKeys[0])
+        return { tracker: 'jira', project: t.projectKeys[0], target: `jira:${t.projectKeys[0]}` };
+    if (t?.kind === 'linear' && t.teamKeys[0])
+        return { tracker: 'linear', project: t.teamKeys[0], target: `linear:${t.teamKeys[0]}`, ...(t.projectName ? { projectName: t.projectName } : {}) };
+    if (t?.kind === 'github' && t.repos?.some((x) => x.trim())) {
+        const repos = trackerRepos(watch);
+        const into = (repo && repos.find((r) => sameRepoRef(parseRepoId(r), repo))) || repos[0];
+        if (into)
+            return { tracker: 'github', project: into, target: `github:${into}` };
+    }
+    // The repo the bug was found in; a single-repo dot's `repo` when the caller names none.
+    const r = repo ?? watch.repo;
+    if (r) {
+        const full = `${r.owner}/${r.name}`;
+        return { tracker: 'github', project: full, target: `github:${full}` };
+    }
+    // A dot with no app repo but a GitHub tracker files into the first tracker repo.
+    const first = trackerRepos(watch)[0];
+    return first ? { tracker: 'github', project: first, target: `github:${first}` } : null;
+}
+/**
+ * The earlier draft or filed defect for this bug, from approvals and from runs that filed under "act". `sig` (bugSignature)
+ * finds it from any run, PR or merge; the bug key alone only finds it within one PR. A superseded or expired draft does
+ * not count: nobody decided on it.
+ */
+export function priorDefect(watchId, key, sig) {
+    // A lead's members share what any of them drafted or filed (KAT-405): pass `teamIds(dot.id)`.
+    const ids = Array.isArray(watchId) ? watchId : [watchId];
+    // Every shape of the key and signature counts: a dot that gained or lost a repo keeps its defects (KAT-326).
+    const keys = (Array.isArray(key) ? key : [key]).map(String);
+    const sigs = (Array.isArray(sig) ? sig : sig ? [sig] : []).map(String);
+    // A merged draft also answers for the bug keys and signatures of its other sources.
+    const sameAction = (a) => a.kind === 'file_defect' && (keys.includes(String(a.meta?.bugKey)) || sigs.includes(String(a.meta?.bugSig)));
+    const same = (a) => sameAction(a.action) || (a.action.kind === 'file_defect' && sourcesOf(a).some((s) => keys.includes(s.bugKey) || (!!s.bugSig && sigs.includes(s.bugSig))));
+    const approvals = list('approvals', { watchId: ids }, { orderBy: 'createdAt DESC', limit: 500 }).filter(same);
+    for (const a of approvals) {
+        if (a.status === 'executed')
+            return { state: 'filed', url: strOrUndefined(a.action.meta?.filedUrl) };
+        if (a.status === 'pending' || a.status === 'approved')
+            return { state: 'drafted', url: inboxUrl(), ...whereOf(a.action) };
+        // A rejection holds for the PR it was made on. The same bug failing again on a later PR is drafted again (KAT-307). A draft closed by
+        // archiving a dot is no rejection: nobody said no to the bug (KAT-405).
+        if (a.status === 'rejected') {
+            if (a.action.meta?.closedBy === 'archive')
+                continue;
+            if (keys.includes(String(a.action.meta?.bugKey)) || sourcesOf(a).some((s) => keys.includes(s.bugKey)))
+                return { state: 'rejected' };
+            continue;
+        }
+    }
+    const runs = list('runs', { watchId: ids }, { orderBy: 'createdAt DESC', limit: 200 });
+    for (const r of runs) {
+        const hit = r.actions?.find((x) => sameAction(x.action) && x.result === 'executed');
+        if (hit)
+            return { state: 'filed', url: strOrUndefined(hit.action.meta?.filedUrl) };
+    }
+    return null;
+}
+const citeOf = (bug) => bug.source === 'review' && bug.ref?.file
+    ? { file: bug.ref.file, ...(bug.ref.line ? { line: bug.ref.line, lineEnd: bug.ref.lineEnd ?? bug.ref.line } : {}) }
+    : undefined;
+/** The text of lines `from` to `to` of a file, hashed after trimming each line, so a re-indent is not a change. */
+async function hashLines(readFile, c) {
+    if (!readFile || !c.line)
+        return undefined;
+    try {
+        const text = await readFile(c.file);
+        if (text === null)
+            return undefined;
+        const lines = text.split('\n').slice(c.line - 1, c.lineEnd ?? c.line);
+        return createHash('sha256')
+            .update(lines.map((l) => l.trim()).join('\n'))
+            .digest('hex')
+            .slice(0, 16);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Two cited ranges overlap. A range with no line numbers overlaps any range of the same file. */
+function overlaps(a, b) {
+    if (!a.line || !b.line)
+        return true;
+    return a.line <= (b.lineEnd ?? b.line) && b.line <= (a.lineEnd ?? a.line);
+}
+/**
+ * A person rejected a review finding of this PR (any head, so also its merge) that cites the same file and an
+ * overlapping range. A finding read from the code is worded again on each run, so neither its key nor its signature
+ * matches. The rejection holds until the cited lines change: their text at the rejected head (a hash stored on the
+ * draft) is compared with their text at the current head. When either cannot be read, the rejection holds.
+ */
+async function rejectedOnSameLines(watchId, bug, prNumber, readFile) {
+    const cite = citeOf(bug);
+    if (!cite || !prNumber)
+        return false;
+    const rejected = list('approvals', { watchId, status: 'rejected' }, { orderBy: 'createdAt DESC', limit: 300 }).filter((a) => a.action.kind === 'file_defect' && a.action.meta?.bugSource === 'review' && a.action.meta?.pr === prNumber);
+    for (const a of rejected) {
+        const was = a.action.meta?.cite;
+        if (!was || was.file !== cite.file || !overlaps(was, cite))
+            continue;
+        if (was.hash) {
+            const now = await hashLines(readFile, was);
+            if (now && now !== was.hash)
+                continue;
+        }
+        return true;
+    }
+    return false;
+}
+/** The key of the issue an earlier run filed for this signature, so new evidence goes on it. */
+function filedKeyFor(watchId, sig) {
+    const sigs = (Array.isArray(sig) ? sig : [sig]).map(String);
+    const hit = (a) => a.kind === 'file_defect' && sigs.includes(String(a.meta?.bugSig)) && typeof a.meta?.filedKey === 'string' && a.meta.filedKey
+        ? { key: String(a.meta.filedKey), ...(strOrUndefined(a.meta.filedUrl) ? { url: strOrUndefined(a.meta.filedUrl) } : {}) }
+        : null;
+    for (const a of list('approvals', { watchId, status: 'executed' }, { orderBy: 'createdAt DESC', limit: 300 })) {
+        const k = hit(a.action);
+        if (k)
+            return k;
+    }
+    for (const r of list('runs', { watchId }, { orderBy: 'createdAt DESC', limit: 200 }))
+        for (const x of r.actions ?? []) {
+            const k = x.result === 'executed' ? hit(x.action) : null;
+            if (k)
+                return k;
+        }
+    return null;
+}
+function strOrUndefined(v) {
+    return typeof v === 'string' && v ? v : undefined;
+}
+/** `{ where }` for a draft's link: the repo or project its meta says it will be filed in, or nothing for an older draft. */
+function whereOf(action) {
+    const tracker = action.meta?.tracker;
+    const project = strOrUndefined(action.meta?.project);
+    if (!project || (tracker !== 'github' && tracker !== 'jira' && tracker !== 'linear'))
+        return {};
+    return { where: defectWhere({ tracker, project }) };
+}
+/** Below this word-set overlap two titles are not the same bug. */
+export const TITLE_SIMILARITY = 0.6;
+/** Lowercase word set of a title, without the "Bug:" prefix every filed defect starts with. */
+function titleWords(title) {
+    return new Set(title
+        .toLowerCase()
+        .replace(/^\s*bug\s*:/, '')
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean));
+}
+/** Jaccard similarity of the normalized word sets of two titles, 0 to 1. */
+export function titleSimilarity(a, b) {
+    const x = titleWords(a);
+    const y = titleWords(b);
+    if (!x.size || !y.size)
+        return 0;
+    let both = 0;
+    for (const w of x)
+        if (y.has(w))
+            both++;
+    return both / (x.size + y.size - both);
+}
+function decoded(text) {
+    try {
+        return decodeURIComponent(text);
+    }
+    catch {
+        return text;
+    }
+}
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** The issue text mentions this pull request ("PR #4", "pull request #4", or a /pull/4 link). */
+function mentionsPr(text, pr) {
+    if (!pr)
+        return false;
+    // "PR #4", or "PR owner/name#4" in a defect filed in another repo than the PR's.
+    return new RegExp(`(?:\\bPR|pull request)\\s*(?:[\\w.-]+/[\\w.-]+)?#${pr}\\b|/pull/${pr}\\b`, 'i').test(text);
+}
+/** Directory names and words that look like `owner/name` but are paths or prose, not repositories. */
+const NOT_AN_OWNER = new Set([
+    'src',
+    'lib',
+    'test',
+    'tests',
+    'spec',
+    'e2e',
+    'docs',
+    'doc',
+    'app',
+    'apps',
+    'packages',
+    'client',
+    'server',
+    'dist',
+    'build',
+    'public',
+    'scripts',
+    'config',
+    'components',
+    'utils',
+    'node_modules',
+    'and',
+    'or',
+    'pass',
+    'input',
+    'output',
+    'read',
+    'write',
+    'yes',
+    'on',
+    'true',
+    'ci',
+    'tcp',
+    'w',
+    'n',
+    'i',
+    'up',
+    'start',
+    'add',
+    'enable',
+    'create',
+    'get',
+    'before',
+    'open',
+    'show',
+    'login',
+    'http',
+    'https',
+    'application',
+    'text',
+    'image',
+    'audio',
+    'video',
+]);
+const FILE_EXT = /\.(?:[cm]?[jt]sx?|json|md|ya?ml|html?|css|scss|py|rb|go|rs|java|kt|swift|sh|txt|log|png|jpe?g|gif|svg|lock|toml|xml|sql)$/i;
+/**
+ * The repositories an issue explicitly names, lowercase `owner/name`: a github.com/owner/name link, or a plain
+ * `owner/name` token that is not part of a longer path (`src/cart/discount.ts`), not a file (`docs/README.md`),
+ * and not a common directory or slash word (`and/or`).
+ */
+export function namedRepos(text) {
+    const found = new Set();
+    const add = (owner, name) => {
+        const n = name.replace(/\.git$/i, '').replace(/\.+$/, '');
+        if (owner && n)
+            found.add(`${owner}/${n}`.toLowerCase());
+    };
+    for (const m of text.matchAll(/github\.com\/([A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)\/([\w.-]+)/gi))
+        add(m[1], m[2]);
+    for (const m of text.matchAll(/(?<![\w./:@-])([A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)\/([\w.-]*[A-Za-z0-9])/g)) {
+        const [whole, owner, name] = [m[0], m[1], m[2]];
+        if (text[(m.index ?? 0) + whole.length] === '/')
+            continue; // part of a longer path
+        if (!/[a-z]/i.test(owner) || !/[a-z]/i.test(name))
+            continue;
+        if (NOT_AN_OWNER.has(owner.toLowerCase()) || FILE_EXT.test(name))
+            continue;
+        add(owner, name);
+    }
+    return found;
+}
+/** The code or test the bug points at: file path and, for code, the line. */
+function bugCite(bug) {
+    if (bug.test?.file)
+        return { file: bug.test.file };
+    if (bug.ref?.file && bug.ref.file !== 'PR_BODY')
+        return { file: bug.ref.file, ...(bug.ref.line ? { line: bug.ref.line } : {}) };
+    return null;
+}
+/** The issue cites `file:line` or `file#Lline` (also the link text `base:line` a filed defect shows). */
+function citesFileLine(text, file, line) {
+    const base = file.split('/').pop() ?? file;
+    return new RegExp(`(?:${escapeRe(file)}|${escapeRe(base)})(?::|#L)${line}\\b`, 'i').test(text);
+}
+/**
+ * The open defect that is the same bug, or null. Pure: the tracker clients only list issues, this one
+ * function decides for Linear, Jira, and GitHub. An issue is in scope when it names this PR, names
+ * this repo, carries the localdost label, or lives in the repo's own GitHub issues. An issue that explicitly names a
+ * different repo (`owner/name` or a github.com link) and not this one is never in scope, whatever its label. In scope, it matches when
+ * - its title has a Jaccard word overlap of at least 0.6 with the new title, or
+ * - it cites the same file and line as the bug, or
+ * - it cites the same file path and names this PR (the line moves between pushes).
+ */
+export function pickOpenDefect(bug, rendered, open, o = {}) {
+    const cite = bugCite(bug);
+    const repoName = o.repo ? `${o.repo.owner}/${o.repo.name}`.toLowerCase() : '';
+    let best = null;
+    for (const issue of open) {
+        const text = decoded(`${issue.title}\n${issue.body}`);
+        // Two repos can share one tracker project: an issue that names only another repo is not this PR's.
+        if (repoName && !text.toLowerCase().includes(repoName)) {
+            const named = namedRepos(text);
+            if (named.size && !named.has(repoName))
+                continue;
+        }
+        // The signature names this bug whatever PR or merge filed it.
+        if (o.sig && text.includes(o.sig)) {
+            if (!best || best.score < 2)
+                best = { issue, score: 2 };
+            continue;
+        }
+        const samePr = mentionsPr(text, o.prNumber);
+        const sameRepo = o.githubIssues === true || (!!repoName && text.toLowerCase().includes(repoName)) || issue.labels.some(isDefectLabel);
+        if (!samePr && !sameRepo)
+            continue;
+        const sim = titleSimilarity(issue.title, rendered.title);
+        const sameLine = !!cite?.line && citesFileLine(text, cite.file, cite.line);
+        const sameFileAndPr = !!cite && samePr && text.toLowerCase().includes(cite.file.toLowerCase());
+        if (sim < TITLE_SIMILARITY && !sameLine && !sameFileAndPr)
+            continue;
+        // The closest title wins; a file and line citation counts as a full match.
+        const score = Math.max(sim, sameLine ? 1 : 0, sameFileAndPr ? TITLE_SIMILARITY : 0);
+        if (!best || score > best.score)
+            best = { issue, score };
+    }
+    return best?.issue ?? null;
+}
+/** The dot's tracker as an OpenDefectSource; null in demo mode. Linear also searches all open issues by term. */
+export function trackerDefectSource(watch, repo) {
+    const where = defectTarget(watch, repo);
+    if (!where)
+        return null;
+    if (where.tracker === 'jira') {
+        const c = jiraFor(trackerOwner(watch));
+        return c.mode === 'demo' ? null : { list: () => c.listOpenDefects(where.project), githubIssues: false };
+    }
+    if (where.tracker === 'linear') {
+        const c = linearFor(trackerOwner(watch));
+        if (c.mode === 'demo')
+            return null;
+        const search = c.searchOpenDefects?.bind(c);
+        return {
+            list: () => c.listOpenDefects(where.project, where.projectName),
+            ...(search ? { search: (term) => search(where.project, term, where.projectName) } : {}),
+            githubIssues: false,
+        };
+    }
+    // Duplicates are looked up where the draft will be filed: the repo the change is in, or the tracker repo when the
+    // dot files elsewhere (KAT-355). The tracker repo may be none of the dot's own repos.
+    const into = parseRepoId(where.project);
+    const c = into && !sameRepoRef(into, repo ?? watch.repo) ? githubForIssues(watch, where.project) : githubFor(watch, repo ? { repo } : undefined);
+    return c.mode === 'demo' ? null : { list: () => c.listOpenDefects(), githubIssues: true };
+}
+/** Open defects of the dot's tracker project; null in demo mode and on any API error (the caller drafts as before). */
+async function openDefectsFor(watch, repo, source) {
+    const src = source === undefined ? trackerDefectSource(watch, repo) : source;
+    if (!src)
+        return null;
+    try {
+        return { open: await src.list(), githubIssues: src.githubIssues };
+    }
+    catch (err) {
+        console.warn(`[defects] could not list open defects: ${err.message}`);
+        return null;
+    }
+}
+/** Tracker search for one bug: its signature, then its title. Issues older than the listed 100 are found this way. */
+async function searchFor(src, bug, sig) {
+    if (!src?.search)
+        return [];
+    const out = new Map();
+    for (const term of [sig, bug.title.replace(/["\\]/g, ' ').slice(0, 120)]) {
+        try {
+            for (const i of await src.search(term))
+                out.set(i.key, i);
+        }
+        catch (err) {
+            console.warn(`[defects] tracker search failed: ${err.message}`);
+        }
+    }
+    return [...out.values()];
+}
+/**
+ * The single choke point that finds an open issue for a bug about to be drafted, for every tracker.
+ * `open` lets a caller that checks several bugs read the tracker once.
+ */
+export async function matchOpenDefect(watch, bug, rendered, o = {}, open) {
+    const found = open === undefined ? await openDefectsFor(watch, o.repo) : open;
+    return found ? pickOpenDefect(bug, rendered, found.open, { ...o, githubIssues: found.githubIssues }) : null;
+}
+/** A person or an earlier run already handled new evidence for this issue at this head (any draft counts, even a rejected one). */
+export function evidenceHandled(watchId, issueKey, head) {
+    const same = (a) => a.kind === 'ticket_comment' && a.meta?.defectComment === true && a.meta?.defectIssue === issueKey && (a.meta?.head ?? '') === head;
+    const approvals = list('approvals', { watchId }, { orderBy: 'createdAt DESC', limit: 500 });
+    if (approvals.some((a) => same(a.action) && ['pending', 'approved', 'executed', 'rejected'].includes(a.status)))
+        return true;
+    const runs = list('runs', { watchId }, { orderBy: 'createdAt DESC', limit: 200 });
+    return runs.some((r) => r.actions?.some((x) => same(x.action) && x.result === 'executed'));
+}
+/** The comment for an existing issue: the new evidence, minus the intro line a fresh ticket opens with. */
+function evidenceComment(rendered, o) {
+    // The commit is in the For developers fold below; the line a tester reads names the PR only.
+    const intro = `localdost found this bug again${o.prNumber ? ` while testing PR ${prRefIn(o.prNumber, o.repo, o.filedIn)}` : ''}. New evidence:`;
+    const rest = rendered.body.split('\n\n').slice(1).join('\n\n').trim();
+    return rest ? `${intro}\n\n${rest}` : intro;
+}
+/** The requirement refs the PR links in the rows of the team, lower case: its closing keywords and ticket keys. Reads no network. */
+function prTicketRefs(team, o) {
+    if (!o.prNumber || !o.repo)
+        return [];
+    const pr = issueRef(`${o.repo.owner}/${o.repo.name}`, o.prNumber);
+    const out = new Set();
+    for (const id of team)
+        for (const l of linksFor(pr, id))
+            if (l.fromRef === pr && (l.kind === 'closes' || l.kind === 'references'))
+                out.add(l.toRef);
+    return [...out];
+}
+/** Drafts (or links) one defect per bug and returns the links for the comment. */
+export async function draftDefects(watch, runId, bugs, o) {
+    const where = defectTarget(watch, o.repo);
+    const links = {};
+    if (!where)
+        return links;
+    const place = defectWhere(where);
+    // A defect filed in another repo than the code names that repo and the PR, so the PR timeline links back to it.
+    const away = where.tracker === 'github' && !!o.repo && !sameRepoRef(parseRepoId(where.project), o.repo);
+    const required = requiredLabel(watch);
+    const src = o.source === undefined ? trackerDefectSource(watch, o.repo) : o.source;
+    let open;
+    for (const bug of bugs.slice(0, MAX_DEFECTS)) {
+        const bugRepo = bug.repo ?? bugRepoOf(watch, o.repo);
+        const sig = bugSignature({ ...bug, ...(bugRepo ? { repo: bugRepo } : {}) });
+        // The other repo shapes of the key and signature (KAT-326): a repo added or removed must not hide an earlier defect.
+        const keys = [bug.key, ...(bug.altKeys ?? [])];
+        const sigs = [sig, ...bugSignatureAlts(bug, bugRepoAlts(watch, o.repo))];
+        const mapped = caseForTest(o.cases, bug.test?.file);
+        // The same body the new draft would get, so a comment of new evidence reads like the issue it lands on: the linked case's
+        // steps, and the For developers fold only where the tracker shows one (GitHub, Jira), never as raw tags.
+        const d = renderDefect(bug, {
+            ...o,
+            ...(where.tracker === 'github' ? { filedIn: where.project } : {}),
+            ...(mapped ? { testCase: caseDetail(watch.id, mapped) } : {}),
+            collapse: foldsDefect(where.tracker),
+        });
+        // A dot in a team shares what its members drafted, rejected and filed (KAT-405); a dot with no lead reads its own rows only.
+        const team = teamIds(watch.id);
+        // 1. This PR already drafted or filed it: link that.
+        const samePr = priorDefect(watch.id, keys);
+        if (samePr) {
+            links[bug.key] = samePr;
+            continue;
+        }
+        // 2. Another run, PR or merge drafted it, or a person rejected it: no second draft (dogfood ledger).
+        const elsewhere = priorDefect(watch.id, keys, sigs);
+        if (elsewhere && elsewhere.state !== 'filed') {
+            links[bug.key] = elsewhere;
+            continue;
+        }
+        // 2b. Another member of the team has the same bug waiting in its Inbox: this member joins that draft and drafts nothing (KAT-405).
+        const testTitle = bug.test?.title ?? bug.title;
+        const teamRefs = team.length > 1 ? prTicketRefs(team, o) : [];
+        const sibling = team.length > 1 ? teamDraftFor(watch, { sigs: [], bugSigs: sigs, testTitle, relates: teamRefs }) : null;
+        if (sibling) {
+            joinTeamDraft(sibling, watch, {
+                runId,
+                bugKey: bug.key,
+                bugSig: sig,
+                ...(o.prNumber ? { pr: o.prNumber } : {}),
+                ...(o.head ? { head: o.head } : {}),
+                ...(o.task ? { task: o.task } : {}),
+                runLink: o.runUrl ?? `run ${runId}`,
+                inboxLink: inboxUrl() ?? '#/inbox',
+            });
+            links[bug.key] = { state: 'drafted', url: inboxUrl(), where: place };
+            continue;
+        }
+        // A person's no counts for every member: a rejected draft of a sibling, or a merged draft that named this bug among its sources.
+        if (team.length > 1) {
+            const theirs = priorDefect(team, keys, sigs);
+            if (theirs?.state === 'rejected') {
+                links[bug.key] = theirs;
+                continue;
+            }
+        }
+        // 3. An issue filed earlier for this signature, or an open tracker issue about it, takes the new evidence.
+        const filed = filedKeyFor(team, sigs);
+        // Read the tracker once per call, and only when a bug has no draft or issue of its own yet.
+        if (open === undefined)
+            open = await openDefectsFor(watch, o.repo, src);
+        const searched = await searchFor(src, bug, sig);
+        const pool = open || searched.length ? { open: [...(open?.open ?? []), ...searched], githubIssues: open?.githubIssues ?? src?.githubIssues ?? false } : null;
+        const listed = await matchOpenDefect(watch, bug, d, { prNumber: o.prNumber, repo: o.repo, sig }, pool);
+        // The tracker lists only open issues, so a filed issue it no longer shows was closed: a regression drafts anew.
+        // When the tracker cannot be read, the issue filed for this signature is the best guess.
+        const match = listed ?? (filed && !pool ? { key: filed.key, title: d.title, body: '', labels: [], ...(filed.url ? { url: filed.url } : {}) } : null);
+        if (match) {
+            links[bug.key] = { state: 'filed', ...(match.url ? { url: match.url } : {}) };
+            const head = o.head ?? '';
+            if (!evidenceHandled(watch.id, match.key, head)) {
+                await gate({
+                    kind: 'ticket_comment',
+                    target: `${where.tracker}:${match.key}`,
+                    title: `New evidence for ${match.key}`,
+                    body: evidenceComment(d, { ...o, ...(where.tracker === 'github' ? { filedIn: where.project } : {}) }),
+                    meta: {
+                        tracker: where.tracker,
+                        key: match.key,
+                        ...(match.id ? { ticketId: match.id } : {}),
+                        ...(match.url ? { url: match.url } : {}),
+                        defectComment: true,
+                        defectIssue: match.key,
+                        bugKey: bug.key,
+                        bugSig: sig,
+                        head,
+                        ...(o.prNumber ? { pr: o.prNumber } : {}),
+                        ...(o.repo ? { repo: `${o.repo.owner}/${o.repo.name}` } : {}),
+                    },
+                }, watch, runId);
+            }
+            continue;
+        }
+        // 4. A person rejected a finding of this PR that cites the same lines: the new wording is not a new finding (KAT-312).
+        if (await rejectedOnSameLines(watch.id, bug, o.prNumber, o.readFile)) {
+            links[bug.key] = { state: 'rejected' };
+            continue;
+        }
+        const cite = citeOf(bug);
+        const citeHash = cite ? await hashLines(o.readFile, cite) : undefined;
+        const codeRepo = o.repo ? `${o.repo.owner}/${o.repo.name}` : '';
+        const relates = away && codeRepo ? [o.prNumber ? `Relates to ${prRefIn(o.prNumber, o.repo, where.project)}` : `Found in ${codeRepo}`] : [];
+        const full = renderDefect(bug, {
+            ...o,
+            ...(where.tracker === 'github' ? { filedIn: where.project } : {}),
+            ...(mapped ? { testCase: caseDetail(watch.id, mapped) } : {}),
+            relates,
+            signature: sig,
+            collapse: foldsDefect(where.tracker),
+        });
+        // A tracker that requires a label classes an untyped issue that carries it as a requirement, so a defect there says
+        // it is one: the defect label and type. The required label goes on every defect, so the team's board picks it up;
+        // a bug found by reading adds its own.
+        const labels = [
+            ...(bug.foundByReading ? [READING_LABEL] : []),
+            ...(full.needsManualSteps ? [NEEDS_MANUAL_STEPS_LABEL] : []),
+            ...(required ? [trackerDefectLabel(watch), required] : []),
+        ].filter((l, k, all) => all.findIndex((x) => x.toLowerCase() === l.toLowerCase()) === k);
+        const action = {
+            kind: 'file_defect',
+            target: where.target,
+            title: d.title,
+            body: full.body,
+            meta: {
+                tracker: where.tracker,
+                project: where.project,
+                ...(where.projectName ? { projectName: where.projectName } : {}),
+                bugKey: bug.key,
+                bugSig: sig,
+                bugSource: bug.source,
+                // The failing test, so a member of the team that finds the same test with another signature can join this draft (KAT-405).
+                testTitle,
+                ...(teamRefs.length ? { relates: teamRefs } : {}),
+                ...caseMeta(mapped),
+                ...(cite ? { cite: { ...cite, ...(citeHash ? { hash: citeHash } : {}) } } : {}),
+                ...(o.prNumber ? { pr: o.prNumber } : {}),
+                // The PR head the defect was found at: a newer head supersedes the draft (dogfood ledger).
+                ...(o.head ? { head: o.head } : {}),
+                ...(o.repo ? { repo: `${o.repo.owner}/${o.repo.name}` } : {}),
+                severity: bug.severity,
+                // A bug found by reading the code is labelled so in the tracker and the Inbox card, with lower confidence.
+                ...(bug.foundByReading ? { foundBy: 'reading', confidence: 'lower' } : {}),
+                ...(labels.length ? { labels } : {}),
+                ...(required ? { issueType: trackerDefectType(watch) } : {}),
+                // A person pressed Draft defect (chat triage): the act_when_asked rule counts it as asked.
+                ...(o.askedBy ? { askedBy: o.askedBy } : {}),
+            },
+        };
+        const result = await gate(action, watch, runId);
+        if (result === 'executed')
+            links[bug.key] = { state: 'filed', url: strOrUndefined(action.meta?.filedUrl) };
+        else if (result === 'pending_approval' || result === 'handed_off')
+            links[bug.key] = { state: 'drafted', url: inboxUrl(), where: place };
+    }
+    return links;
+}
+//# sourceMappingURL=defects.js.map