tumwater 0.2.0 → 0.3.0

package/dist/src/run/stage-backlog-checks.js

@@ -0,0 +1,249 @@
+/** The staging self-check's findings about backlog records (PLANS.md, BUGS.md, QUESTIONS.md and
+ * the finished-entry archives), split from stage-check.ts, which gathers them with the git-level
+ * path checks. Each takes the edited text (`head`) and its merge-base text (`base`), so only a
+ * problem this change adds is reported. All are staging-only: the review gate does not run
+ * them (see stage-check.ts for why each is left out of the gate). */
+import { finishedTitle, readdedHeadings } from "../backlog/backlog-structure.js";
+import { fenceAwareHeadingLines, headingTitle, parseEntryDetails, sectionBodyLines, } from "../backlog/backlog-md.js";
+import { DONE_DATE_RE, FIXED_DATE_RE } from "../backlog/backlog.js";
+import { refusalNote, waitingNote } from "../backlog/backlog-eligibility.js";
+import { entryKey, partKey, planDependencyProblems, seriesPart } from "../backlog/backlog-parts.js";
+import { WAITING_FOR_FAILURE_NOTE } from "../roles/role-guidance.js";
+import { moreSuffix } from "../text/phrases.js";
+import { collapseWhitespace, truncate } from "../text/text.js";
+/** The finding for the heading `requires` clause problems that `head` (the edited PLANS.md)
+ * adds over `base` (its text at the merge-base), or undefined when it adds none; `archivedTitles`
+ * (PLANS-DONE.md's headings) count as existing headings on both sides. Only new
+ * problems count: one already on main is not this run's fault and stays doctor's to report, so
+ * the author is never asked to fix another run's heading. The most serious new problem is named
+ * — cycle, then dangling, unparsed, then misworded — with a count of the rest. */
+export function planDependencyFinding(head, base, archivedTitles = []) {
+    const problems = (text) => planDependencyProblems(parseEntryDetails(text, "Planned"), [...parseEntryDetails(text, "Done").map((e) => e.title), ...archivedTitles]);
+    const was = problems(base);
+    const now = problems(head);
+    const newCycle = now.cycle !== null && was.cycle === null ? now.cycle : null;
+    const newDangling = now.dangling.filter((d) => !was.dangling.some((b) => b.title === d.title && b.ref === d.ref));
+    const newUnparsed = now.unparsed.filter((t) => !was.unparsed.includes(t));
+    const newMisworded = now.misworded.filter((m) => !was.misworded.some((b) => b.title === m.title && b.ref === m.ref));
+    const total = (newCycle !== null ? 1 : 0) + newDangling.length + newUnparsed.length + newMisworded.length;
+    if (total === 0)
+        return undefined;
+    let first;
+    if (newCycle !== null) {
+        first = `PLANS.md's requires clauses now form a cycle: ${newCycle.join(" → ")} — every part on it stays blocked forever; ` + // vocabulary-ok: PLANS.md heading syntax
+            "edit one heading's `requires … landed` clause to break it"; // vocabulary-ok: PLANS.md heading syntax
+    }
+    else if (newDangling.length > 0) {
+        const d = newDangling[0];
+        first = `PLANS.md plan "${d.title}" requires ${d.ref}, which no PLANS.md heading carries — the claim allocator ` +
+            "ignores the clause and hands the plan out now; fix the series name or part number to match the prerequisite's heading";
+    }
+    else if (newUnparsed.length > 0) {
+        first = `PLANS.md plan "${newUnparsed[0]}" has a \`requires … landed\` clause that names no part the claim allocator can read — ` + // vocabulary-ok: PLANS.md heading syntax
+            "it holds nothing; write each ref as `<Series> i/n` or `part i/n` after a `<Series>, part i/n:` heading prefix";
+    }
+    else {
+        const w = newMisworded[0];
+        first = `PLANS.md plan "${w.title}" names ${w.ref} as a prerequisite without a \`requires … landed\` clause — ` + // vocabulary-ok: PLANS.md heading syntax
+            "the claim allocator ignores that wording and hands the part out now; write it as `requires part i/n landed` — fix it before this change commits"; // vocabulary-ok: PLANS.md heading syntax
+    }
+    return `${first}${moreSuffix(total - 1)}`;
+}
+/** A finished heading's identity across done dates: the title without its completion stamp and
+ * its `(planned …)`/`(found …)` parenthetical, whitespace-collapsed. */
+export function finishedKey(title, dateRe) {
+    return collapseWhitespace(finishedTitle(title, dateRe));
+}
+/** The findings for a finished entry that the change leaves in the archive too: a live
+ * `## Done`/`## Fixed` entry the head archive already holds under another stamp (the sweep would
+ * move it as a new entry, or leave it beside an edited copy), and an archive entry the change
+ * added a second time under a new stamp. At most one finding per rule. An exact copy of an
+ * archived entry (same heading and body) is skipped: the sweep drops it. A second copy under an
+ * identical heading is skipped too: `backlogStructureReason` reports it. */
+export function finishedDuplicateFindings(spec, live, archive) {
+    const dateRe = spec.file === "PLANS.md" ? DONE_DATE_RE : FIXED_DATE_RE;
+    const keyed = (md) => parseEntryDetails(md, spec.section).map((e) => ({ ...e, key: finishedKey(e.title, dateRe) }));
+    const findings = [];
+    const liveBase = new Set(keyed(live.base).map((e) => e.key));
+    const archived = keyed(archive.head);
+    const copy = keyed(live.head).find((e) => {
+        if (liveBase.has(e.key))
+            return false;
+        const held = archived.filter((a) => a.key === e.key);
+        if (held.length === 0)
+            return false;
+        const heading = collapseWhitespace(e.title);
+        return !held.some((a) => collapseWhitespace(a.title) === heading && a.body === e.body);
+    });
+    if (copy !== undefined) {
+        findings.push(`${spec.file}'s "## ${spec.section}" entry "${truncate(copy.title, 160)}" is already archived in ${spec.archive} — ` +
+            "the commit-time sweep would leave two copies; edit the archived entry in place (its text and its stamp) and delete this copy");
+    }
+    if (readdedHeadings(archive.base, archive.head).length === 0) {
+        const count = (entries, key) => entries.filter((e) => e.key === key).length;
+        const was = keyed(archive.base);
+        const twice = archived.find((e) => count(archived, e.key) > 1 && count(archived, e.key) > count(was, e.key));
+        if (twice !== undefined) {
+            findings.push(`${spec.archive} holds "${truncate(twice.title, 160)}" ${count(archived, twice.key)} times — this change added a copy under a different heading or stamp; ` +
+                "keep the archived entry once, edited in place, and delete the other copies");
+        }
+    }
+    return findings;
+}
+/** The number of `- **Progress …` lines in an entry body. */
+function progressCount(body) {
+    return body.split("\n").filter((l) => /^-\s+\*\*Progress\b/.test(l.trim())).length;
+}
+/** The finding for a BUGS.md bug that `head` (the edited file) shows with more Progress notes
+ * than `base` (its text at the merge-base) while it stays under `## Open` with neither a Waiting
+ * note nor a Refused note — bugfix's step 2 asks a run that cannot reproduce a bug to write the
+ * Waiting note, and runs that skip it leave the bug open to re-investigation. A newly filed bug
+ * is not a re-investigation. Names the first such bug in file order, with a count of the rest. */
+export function waitingNoteFinding(head, base) {
+    const was = new Map(parseEntryDetails(base, "Open").map((e) => [entryKey(e.title), e.body]));
+    const counting = parseEntryDetails(head, "Open").filter((e) => {
+        const before = was.get(entryKey(e.title));
+        return (before !== undefined &&
+            progressCount(e.body) > progressCount(before) &&
+            waitingNote(e.body) === null &&
+            refusalNote(e.body) === null);
+    });
+    if (counting.length === 0)
+        return undefined;
+    return (`BUGS.md bug "${counting[0].title}" gained a Progress note but stays open with no Waiting for the next ` +
+        `failure note — if this run could not reproduce it, add ${WAITING_FOR_FAILURE_NOTE} as its own line under ` +
+        `the heading so later runs wait for new evidence (bugfix's step 2); if it did reproduce, leave the entry ` +
+        `as it is${moreSuffix(counting.length - 1)}`);
+}
+/** The skeleton placeholder that marks an empty backlog section. */
+const PLACEHOLDER_LINE = "_None yet._";
+/** The live backlog files; the archives have no placeholder sections. */
+export const PLACEHOLDER_FILES = ["PLANS.md", "BUGS.md", "QUESTIONS.md"];
+/** Each `## ` section of `md` that holds the placeholder line outside a fence while also holding
+ * entries, mapped to its entry count. */
+function placeholderSections(md) {
+    const found = new Map();
+    for (const title of fenceAwareHeadingLines(md, "## ").map((l) => headingTitle(l, "## "))) {
+        if (!sectionBodyLines(md, title).some((l) => l.trim() === PLACEHOLDER_LINE))
+            continue;
+        const count = parseEntryDetails(md, title).length;
+        if (count > 0)
+            found.set(title, count);
+    }
+    return found;
+}
+/** The finding for a section of `head` (the edited backlog file `file`) that holds entries and the
+ * empty-section placeholder while `base` (its text at the merge-base) did not, so damage already
+ * on main is not blamed on this change. Names the first such section in file order, with a count
+ * of the rest. */
+export function strayPlaceholderFinding(file, head, base) {
+    const was = placeholderSections(base);
+    const stray = [...placeholderSections(head)].filter(([title]) => !was.has(title));
+    if (stray.length === 0)
+        return undefined;
+    const [title, n] = stray[0];
+    return (`${file}'s "## ${title}" section holds ${n} entr${n === 1 ? "y" : "ies"}, but this change left the ` +
+        `empty-section placeholder ${PLACEHOLDER_LINE} in it — delete that line: it marks a section with no ` +
+        `entries${moreSuffix(stray.length - 1)}`);
+}
+/** The staging finding for a run that holds a claim but moved a different backlog entry
+ * (plans/parallel-work-instances.md "Claims", part 4/7): the assigned entry is the instance's
+ * one task, so moving another is the same class of mistake `backlogStructureReason` catches
+ * and costs one fix-up turn before the change commits. undefined when nothing moved or the
+ * claimed entry itself moved — a merged entry is the expected way to release a claim. */
+export function assignedMovedFinding(claimKey, moved) {
+    if (moved.length === 0 || moved.some((m) => m.key === claimKey))
+        return undefined;
+    return `this run is assigned one backlog entry but moved a different one: "${moved[0].title}"`;
+}
+/** The staging finding for an unassigned run that moved a backlog entry a sibling instance
+ * holds — one the poll listed in the run's `<held-entries>` note (RunnerState.heldElsewhere).
+ * The note is advice the model can ignore; this is the deterministic backstop at the same
+ * point as assignedMovedFinding (BUGS.md 2026-10-12: 24 of 29 staged claims duplicated a
+ * sibling's held entry, and each duplicate cost a gate check, a review, and a conflict
+ * resolver run holding the merge slot). The fix-up turn is asked to drop the duplicate work.
+ * A change that held nothing else then ends with no change to merge. undefined when no moved
+ * entry is held. */
+export function heldMovedFinding(heldKeys, moved) {
+    const dup = moved.find((m) => heldKeys.has(m.key));
+    if (dup === undefined)
+        return undefined;
+    return (`this run moved a backlog entry another instance of this role is working on: "${dup.title}" — it is that ` +
+        `instance's task (see <held-entries>), so revert every edit made for it, including the ` +
+        `entry's move, and leave nothing behind if that was the whole change`);
+}
+/** The reason clause of a Refused note — everything after its leading `Refused … by <role>:` —
+ * or the whole note when it has no such prefix. This is what the refusal rule lets a run write
+ * freely, and what the ungrounded-refusal finding judges. */
+function refusalReason(note) {
+    const i = note.indexOf(": ");
+    return i < 0 ? note : note.slice(i + 2);
+}
+/** True when `reason` grounds the refusal in this entry itself — it names no series part other
+ * than the entry's own (`own`), and cites neither another entry's Refused or Needs note nor a
+ * role's own notes. Any of those means the refusal rests on another entry's hold or on the
+ * role's opinion, not on an objection to this entry, so it should skip the entry instead. A
+ * reason that names a part outside its own series, or any part at all for an entry with no
+ * part (`own === null`), is a different-series reference — the same class as naming 7/9 from a
+ * 6/9 refusal. */
+function groundedRefusalReason(reason, own) {
+    if (/\brefus(?:al|ed|ing)?\s+of\b/i.test(reason))
+        return false; // cites another entry's refusal
+    if (/\bNeeds-[A-Za-z]/.test(reason))
+        return false; // cites another entry's Needs note
+    if (/\b(?:roles?['’]?s?|my|our|own)\s+notes?\b/i.test(reason))
+        return false; // rests on a role's own notes
+    // A part ref: an optional leading series name before `part N/M`, comma- or space-separated
+    // (own series when none is named, or when a space-separated word is not a title-cased series
+    // name — bridge words like `until part 7/9` resolve to the entry's own series).
+    const re = /(?:([A-Za-z][A-Za-z0-9 ._-]*?)([,\s]\s*))?part[s]?\s+([0-9]+[a-z]?)\/(\d+)\b/gi;
+    let m;
+    while ((m = re.exec(reason)) !== null) {
+        const token = (m[3] ?? "").toLowerCase();
+        if (own === null)
+            return false;
+        let series = own.series;
+        if (m[1] !== undefined) {
+            const word = m[1].trim();
+            // An explicit comma names the series whatever its case; a space-separated word is a
+            // series only when it is the entry's own (any case) or title-cased, so a bridge word
+            // like `until` or `behind` still resolves to the entry's own series.
+            const comma = (m[2] ?? "").includes(",");
+            if (comma || word.toLowerCase() === own.series.toLowerCase() || /^[A-Z]/.test(word))
+                series = word;
+        }
+        if (partKey(series, token) !== partKey(own.series, own.part))
+            return false;
+    }
+    return true;
+}
+/** The finding for a Refused note the change adds to `file` (PLANS.md or BUGS.md) whose reason
+ * grounds the refusal outside the entry — it quotes another entry's Refused or Needs note, the
+ * role's own notes, or a different series part (the `b9664a461` case). `head` is the edited
+ * text, `base` its text at the merge-base. A refusal already on main is not this change's and
+ * is skipped; only a newly added (or edited) one is judged. Names the first offending entry in
+ * file order, with a count of the rest. Stages after `waitingNoteFinding`, sharing its guard.
+ * Undefined when the change adds no such refusal. */
+export function ungroundedRefusalFinding(file, head, base) {
+    const refusalByKey = (md) => {
+        const out = new Map();
+        for (const sectionLine of fenceAwareHeadingLines(md, "## ")) {
+            const section = headingTitle(sectionLine, "## ");
+            for (const e of parseEntryDetails(md, section)) {
+                const note = refusalNote(e.body);
+                if (note !== null)
+                    out.set(entryKey(e.title), { title: e.title, note, section });
+            }
+        }
+        return out;
+    };
+    const was = refusalByKey(base);
+    const newlyAdded = [...refusalByKey(head)].filter(([key, e]) => was.get(key)?.note !== e.note && !groundedRefusalReason(refusalReason(e.note), seriesPart(e.title)));
+    if (newlyAdded.length === 0)
+        return undefined;
+    const first = newlyAdded[0][1];
+    return (`${file}'s "${first.section}" entry "${truncate(first.title, 160)}" carries a newly added Refused note ` +
+        `whose reason cites another entry's Refused/Needs note, a role's own notes, or a different series part ` +
+        `instead of an objection to this entry; implement this entry or pick another, but do not refuse it` +
+        moreSuffix(newlyAdded.length - 1));
+}

package/dist/src/run/stage-check.js

@@ -0,0 +1,172 @@
+/** The merge gate's deterministic checks, run BEFORE a changed run commits.
+ *
+ * The gate runs `backlogStructureReason` and `falseFixReason` at merge time, by which point
+ * the author's session is over: a finding costs a queue slot, a verification, and a rejection that
+ * discards the work (13 phantom-fix rejections between 2026-09-23 and 2026-10-02). Both checks
+ * read the worktree and the change's merge-base, so the same questions can be asked at staging
+ * time, while the authoring session can still be continued for one fix-up turn. This module
+ * runs them over the run's uncommitted edits; the gate still has the final say.
+ *
+ * Scope mirrors the gate exactly: `backlogStructureReason` runs on every changed run, while
+ * `falseFixReason` runs only for an exempt (doc-only) diff — the condition under which the gate
+ * consults it.
+ *
+ * The git-level checks described next live in stage-path-checks.ts (`gitLevelFindings`), which
+ * this module appends.
+ *
+ * Part 2/2 appends git-level, language-neutral findings (PLANS.md "Pre-queue self-check, part
+ * 2/2") for path drift, the organize role's main rejection cause: references left behind by a
+ * rename or delete, added lines naming paths that do not exist in the resulting tree, and text
+ * files whose final newline the change removed. These stage the change (`git add -A`) to read
+ * the index with git only, then restore the index to HEAD before returning: staging is a read
+ * aid for the checks, not a change to the run's state. A git hiccup yields no finding rather
+ * than failing the run. Unlike the backlog checks above, the gate does not run these: they are
+ * heuristics for what a reviewer tends to reject, so neither path check looks inside record
+ * prose (isRecordProse), where an old or not-yet-created path is correct as written.
+ *
+ * A fourth check, `staleNameFindings`, reports a compound identifier the change removed from a
+ * JS/TS file that a comment or doc still names (the compiler catches code, not prose). It
+ * exempts a name the change re-declares (a move), a name another file still declares, an
+ * occurrence inside a string literal (legacy-name tables and serialized keys keep old names on
+ * purpose), a line marked `retired-name-ok`, and record prose, where history names old things.
+ * A fifth, `detachedDocFindings`, reads the same `-U0` diff for a JSDoc block the change
+ * separated from its declaration: code inserted between the two, or a declaration deleted
+ * while its doc stayed. A sixth, `movedSourceFindings`, reads that diff for a file that still
+ * exists but lost lines found verbatim in another file, and lists the lines that still name the
+ * old file's path (outside record prose), which may describe code that now lives elsewhere.
+ *
+ * A seventh check, `garbledWordingFindings`, reports added lines (outside record prose) that carry
+ * the broken participles and doubled "run" wording a word-swap rename leaves (has/have/had … ran,
+ * a hyphen before ran, "run" repeated back to back or followed by "running", a possessive run
+ * followed by "run", "run" joined to "run" by and/or, including a phrase split across two added
+ * lines). It also reports any word doubled back to back in comment or doc prose (case-sensitive,
+ * not after `-`, `.` or `/`, "that that" and "had had" excepted). Like the path checks, the gate
+ * does not run it.
+ *
+ * The backlog-record findings named below (`planDependencyFinding`, `waitingNoteFinding`,
+ * `finishedDuplicateFindings`, `strayPlaceholderFinding`) live in stage-backlog-checks.ts, which
+ * also holds the claim-move findings run-stage.ts uses.
+ *
+ * `planDependencyFinding` is staging-only: it is not part of the review gate or the in-lock
+ * merge re-check, because `tumwater doctor`'s plan-dependency warning is the backstop for
+ * anything that gets past the fix-up turn. `waitingNoteFinding` is staging-only and bugfix-only
+ * for the same reason: it nudges a bugfix run that left a Progress note without the hold.
+ * Like `planDependencyFinding`, `finishedDuplicateFindings` runs only at staging. The gate does
+ * not run it, because the sweep that creates the second copy runs after it.
+ * `strayPlaceholderFinding` is staging-only too. It flags a `_None yet._` line the change left in a
+ * PLANS.md, BUGS.md or QUESTIONS.md section that still holds entries. `acceptanceGrepFindings`
+ * runs only at staging and runs the strict "matches nothing" greps of the plan entries the change
+ * finished. The gate does not run it. */
+import path from "node:path";
+import { changedFiles } from "../git/git-diff.js";
+import { conflictMarkerReason } from "../merge/merge-git.js";
+import { isExemptDiff } from "../review/exemptions.js";
+import { backlogStructureReason } from "../backlog/backlog-structure.js";
+import { protectedEditReason } from "../review/protected-edits.js";
+import { secretLeakReason } from "../review/secret-leaks.js";
+import { falseFixReason } from "../verdict/fix-claim.js";
+import { changeBaseRev, fileContentAt } from "../git/git.js";
+import { readTextOrNull } from "../files/files.js";
+import { FINISHED_ARCHIVES, finishedArchiveOf, parseEntryDetails, } from "../backlog/backlog-md.js";
+import { DONE_DATE_RE } from "../backlog/backlog.js";
+import { baseRoleOf } from "../roles/runner-ids.js";
+import { acceptanceGrepFindings } from "./acceptance-greps.js";
+import { PLACEHOLDER_FILES, finishedDuplicateFindings, finishedKey, planDependencyFinding, strayPlaceholderFinding, ungroundedRefusalFinding, waitingNoteFinding, } from "./stage-backlog-checks.js";
+import { gitLevelFindings } from "./stage-path-checks.js";
+/** Where finished plans are archived (plans/backlog-archive.md). */
+const PLANS_ARCHIVE = finishedArchiveOf("PLANS.md").archive;
+/** `file` as it stands at the change's merge-base with `mainBranch`, or undefined when the
+ * merge-base or the read fails. */
+const baseFileText = (wt, mainBranch, file) => changeBaseRev(wt, mainBranch).then((rev) => fileContentAt(wt, rev, file)).catch(() => undefined);
+/** Append the reason `check` resolves to, if any, to `findings`; a check that rejects adds
+ * nothing, as staging never fails on a best-effort check. */
+const pushReason = async (findings, check) => {
+    const reason = await check.catch(() => undefined);
+    if (reason)
+        findings.push(reason);
+};
+/** The findings likely to get this uncommitted change rejected at merge, or an empty list when
+ * it is clean: the merge gate's own deterministic checks plus the staging-only heuristics (plan
+ * dependencies, the bugfix Waiting note, path drift). Checks the worktree at `wt` against
+ * `mainBranch`'s merge-base; `exemptPaths` are the config's review-exemption globs that scope
+ * the false-fix check.
+ *
+ * Never throws: a check that fails yields no finding, so a git hiccup at staging time defers to
+ * the gate instead of failing the run. */
+export async function stageCheckFindings(wt, mainBranch, exemptPaths, role) {
+    const files = await changedFiles(wt).catch(() => null);
+    if (files === null || files.length === 0)
+        return [];
+    const findings = [];
+    await pushReason(findings, backlogStructureReason(wt, mainBranch, files));
+    if (files.includes("PLANS.md")) {
+        const head = readTextOrNull(path.join(wt, "PLANS.md")) ?? "";
+        const base = await baseFileText(wt, mainBranch, "PLANS.md");
+        // Finished plans are archived in PLANS-DONE.md (plans/backlog-archive.md): a requires clause
+        // naming a merged part resolves there, on both sides of the comparison alike.
+        const archived = parseEntryDetails(readTextOrNull(path.join(wt, PLANS_ARCHIVE)) ?? "", "Done").map((e) => e.title);
+        const dependency = base === undefined ? undefined : planDependencyFinding(head, base, archived);
+        if (dependency !== undefined)
+            findings.push(dependency);
+        const refusal = base === undefined ? undefined : ungroundedRefusalFinding("PLANS.md", head, base);
+        if (refusal !== undefined)
+            findings.push(refusal);
+    }
+    const baseRev = FINISHED_ARCHIVES.some((s) => files.includes(s.file) || files.includes(s.archive))
+        ? await changeBaseRev(wt, mainBranch).catch(() => undefined)
+        : undefined;
+    for (const spec of FINISHED_ARCHIVES) {
+        if (baseRev === undefined || !(files.includes(spec.file) || files.includes(spec.archive)))
+            continue;
+        const duplicates = await (async () => {
+            const read = (f) => readTextOrNull(path.join(wt, f)) ?? "";
+            const at = async (f) => (await fileContentAt(wt, baseRev, f)) ?? "";
+            return finishedDuplicateFindings(spec, { head: read(spec.file), base: await at(spec.file) }, { head: read(spec.archive), base: await at(spec.archive) });
+        })().catch(() => []);
+        findings.push(...duplicates);
+        if (spec.file !== "PLANS.md")
+            continue;
+        const greps = await (async () => {
+            const finished = async (f, section) => {
+                const keyed = (md) => parseEntryDetails(md, section).map((e) => ({ ...e, key: finishedKey(e.title, DONE_DATE_RE) }));
+                const seen = new Set(keyed((await fileContentAt(wt, baseRev, f)) ?? "").map((e) => e.key));
+                return keyed(readTextOrNull(path.join(wt, f)) ?? "").filter((e) => !seen.has(e.key));
+            };
+            const entries = [...(await finished(spec.file, spec.section)), ...(await finished(spec.archive, spec.section))];
+            return acceptanceGrepFindings(wt, entries);
+        })().catch(() => []);
+        findings.push(...greps);
+    }
+    if (baseRoleOf(role) === "bugfix" && files.includes("BUGS.md")) {
+        const head = readTextOrNull(path.join(wt, "BUGS.md")) ?? "";
+        const base = await baseFileText(wt, mainBranch, "BUGS.md");
+        const waiting = base === undefined ? undefined : waitingNoteFinding(head, base);
+        if (waiting !== undefined)
+            findings.push(waiting);
+    }
+    if (files.includes("BUGS.md")) {
+        const head = readTextOrNull(path.join(wt, "BUGS.md")) ?? "";
+        const base = await baseFileText(wt, mainBranch, "BUGS.md");
+        const refusal = base === undefined ? undefined : ungroundedRefusalFinding("BUGS.md", head, base);
+        if (refusal !== undefined)
+            findings.push(refusal);
+    }
+    for (const file of PLACEHOLDER_FILES) {
+        if (!files.includes(file))
+            continue;
+        const head = readTextOrNull(path.join(wt, file)) ?? "";
+        const base = (await baseFileText(wt, mainBranch, file)) ?? "";
+        const stray = strayPlaceholderFinding(file, head, base);
+        if (stray !== undefined)
+            findings.push(stray);
+    }
+    await pushReason(findings, protectedEditReason(wt, mainBranch, files, role));
+    await pushReason(findings, secretLeakReason(wt, mainBranch, files));
+    if (isExemptDiff(files, exemptPaths))
+        await pushReason(findings, falseFixReason(wt, mainBranch, files));
+    findings.push(...(await gitLevelFindings(wt, mainBranch).catch(() => [])));
+    const markers = conflictMarkerReason(wt, files);
+    if (markers !== undefined)
+        findings.push(markers);
+    return findings;
+}