pr-report-core 0.2.0 → 0.2.1

package/src/queue-order.mts

@@ -2,13 +2,13 @@
  * Where each pull request stands in `unblock-prs`'s queue, and the order the
  * worker picks the ones it may pick.
  *
- * The worker decides on someone's machine, from what `gh` and `git` return,
- * and the Pull Requests Manager page draws the same queue from what GraphQL
+ * The worker decides on someone's machine, from what `gh` and `git` return, and
+ * the Pull Requests Manager page draws the same queue from what GraphQL
  * returns. So the deciding is here, once, over facts either side can supply,
  * and each side does only its own reading: the worker reads some facts only
  * when the answer needs them — the checks of a `BLOCKED` pull request, the
- * native stack of one without auto-merge — which is why
- * {@link queueStanding} asks for them rather than taking them all up front.
+ * native stack of one without auto-merge — which is why {@link queueStanding}
+ * asks for them rather than taking them all up front.
  *
  * What the worker alone knows is left out: which pull requests one run has
  * demoted (`demotions.mts` in `unblock-prs`) lives in that run's memory, so
@@ -39,8 +39,8 @@ export type QueueFacts = Readonly<{
   headRef: string;
   baseRef: string;
   /**
-   * GitHub's `mergeStateStatus` — `BEHIND`, `DIRTY`, `CLEAN`, `BLOCKED` and
-   * so on — or as near to it as the reader can tell.
+   * GitHub's `mergeStateStatus` — `BEHIND`, `DIRTY`, `CLEAN`, `BLOCKED` and so
+   * on — or as near to it as the reader can tell.
    */
   mergeState: string;
   autoMerge: boolean;
@@ -57,8 +57,8 @@ export type QueueGraphMember = Readonly<{
   baseRef: string;
   fromFork: boolean;
   /**
-   * The open issues it closes, whose `Start-After:` it inherits. Absent for
-   * a reader that did not read them: nothing is inherited.
+   * The open issues it closes, whose `Start-After:` it inherits. Absent for a
+   * reader that did not read them: nothing is inherited.
    */
   closes?: readonly number[];
 }>;
@@ -68,8 +68,8 @@ export type QueueGraph = Readonly<{
   /** Which open pull request each stacked one is on: child → parent. */
   stackParents: ReadonlyMap<number, number>;
   /**
-   * What each pull request must merge after: what it declared, the one it
-   * is stacked on, and what it inherits.
+   * What each pull request must merge after: what it declared, the one it is
+   * stacked on, and what it inherits.
    */
   dependencies: ReadonlyMap<number, readonly number[]>;
   /**
@@ -165,9 +165,9 @@ export const versionBranchName = (defaultBranch: string): string =>
   `changeset-release/${defaultBranch}` as const;
 
 /**
- * Whether a pull request from `headRef` is the version pull request. The
- * branch is the only stable handle on it: the title and body are rewritten
- * on every run, and the number changes with every release.
+ * Whether a pull request from `headRef` is the version pull request. The branch
+ * is the only stable handle on it: the title and body are rewritten on every
+ * run, and the number changes with every release.
  */
 export const isVersionBranch = (
   headRef: string,
@@ -191,8 +191,8 @@ export const isMergeableState = (mergeState: string): boolean =>
 
 /**
  * The stacks, the declared order and its cycles, and what holds the release,
- * read off the open pull requests. `startAfterOf` is what the issues they
- * close declare, each issue's `Start-After:` by its number.
+ * read off the open pull requests. `startAfterOf` is what the issues they close
+ * declare, each issue's `Start-After:` by its number.
  */
 export const queueGraph = (
   pulls: readonly QueueGraphMember[],
@@ -219,12 +219,12 @@ export const queueGraph = (
 
       return [
         pr.number,
-        // The version pull request declares nothing: its body is rewritten
-        // on every push to the base, so a trailer written there would hold
-        // for a cycle or two and then silently stop. `blocks-release`, on
-        // the pull requests it is waiting for, is how an order is declared
-        // on it. Other pull requests may still name *it*. A stacked pull
-        // request waits for the layer below it whether or not it says so.
+        // The version pull request declares nothing: its body is rewritten on
+        // every push to the base, so a trailer written there would hold for a
+        // cycle or two and then silently stop. `blocks-release`, on the pull
+        // requests it is waiting for, is how an order is declared on it. Other
+        // pull requests may still name *it*. A stacked pull request waits for
+        // the layer below it whether or not it says so.
         isVersionBranch(pr.headRef, defaultBranch)
           ? []
           : Arr.uniq([
@@ -241,8 +241,8 @@ export const queueGraph = (
 
       return [
         number,
-        // The version pull request closes nothing it means to, and is held
-        // by `blocks-release` alone.
+        // The version pull request closes nothing it means to, and is held by
+        // `blocks-release` alone.
         isVersionBranch(headRef, defaultBranch)
           ? []
           : (inheritedOrders.get(number)?.mergeAfter ?? []).filter(
@@ -288,15 +288,15 @@ export const queueStanding = (
   if (outOfScope !== undefined) {
     // `merge-queued` is an explicit request, so anything that answers it with
     // "no" is worth saying out loud — a queued pull request left as a draft
-    // would otherwise sit in the queue forever with nothing saying why. A
-    // pull request that never asked is passed over in silence.
+    // would otherwise sit in the queue forever with nothing saying why. A pull
+    // request that never asked is passed over in silence.
     return hasLabel(pr, MERGE_QUEUED_LABEL)
       ? { kind: 'unactionable', reason: outOfScope }
       : { kind: 'ignore' };
   }
 
-  // A pull request set aside, or claimed, is a skill's or a person's until
-  // its comment is resolved (`queue-owner.mts`).
+  // A pull request set aside, or claimed, is a skill's or a person's until its
+  // comment is resolved (`queue-owner.mts`).
   const owner = context.owners.get(pr.number);
 
   if (owner !== undefined && owner.owner !== 'worker') {
@@ -327,9 +327,9 @@ export const queueStanding = (
     }
   }
 
-  // The version pull request is rebuilt from the tip of the base by the
-  // release workflow, never rebased here; taking `skip-ci` off is the whole
-  // of what it can be given.
+  // The version pull request is rebuilt from the tip of the base by the release
+  // workflow, never rebased here; taking `skip-ci` off is the whole of what it
+  // can be given.
   if (isVersionBranch(pr.headRef, context.defaultBranch)) {
     return versionStanding(pr, context, reads);
   }
@@ -342,9 +342,9 @@ export const queueStanding = (
   }
 
   switch (pr.mergeState) {
-    // `DIRTY` is a candidate too: it answers whether *merging* conflicts,
-    // from a cached computation, where the worker *rebases*, and the rebase
-    // is what says whether the conflict is real.
+    // `DIRTY` is a candidate too: it answers whether *merging* conflicts, from
+    // a cached computation, where the worker *rebases*, and the rebase is what
+    // says whether the conflict is real.
     case 'BEHIND':
     case 'DIRTY':
       return waitingOn(pr, context) ?? { kind: 'candidate' };
@@ -363,10 +363,10 @@ export const queueStanding = (
 };
 
 /**
- * Whether what {@link queueStanding} decided is worth asking the review
- * about: one about to be picked, or one about to be watched while GitHub
- * still calls it `BLOCKED`. A merge state GitHub already calls mergeable is
- * its own answer that nothing but the checks is left.
+ * Whether what {@link queueStanding} decided is worth asking the review about:
+ * one about to be picked, or one about to be watched while GitHub still calls
+ * it `BLOCKED`. A merge state GitHub already calls mergeable is its own answer
+ * that nothing but the checks is left.
  */
 export const asksReview = (
   standing: QueueStanding,
@@ -377,8 +377,8 @@ export const asksReview = (
 
 /**
  * The standing once the review is known: a hold that waits for someone holds
- * it; one that only a bypass merges, and none at all, change nothing here —
- * the worker leaves the first unarmed, which is not a question of order.
+ * it; one that only a bypass merges, and none at all, change nothing here — the
+ * worker leaves the first unarmed, which is not a question of order.
  */
 export const withReviewHold = (
   standing: QueueStanding,
@@ -392,9 +392,9 @@ export const withReviewHold = (
 export type QueuePriority = 'high' | 'low' | 'none' | 'both';
 
 /**
- * Which priority label a pull request carries: `both` is the two at once,
- * which contradict each other and so count as neither. `priority:mid` is the
- * same as neither here.
+ * Which priority label a pull request carries: `both` is the two at once, which
+ * contradict each other and so count as neither. `priority:mid` is the same as
+ * neither here.
  */
 export const priorityOfLabels = (labels: readonly string[]): QueuePriority => {
   const high = labels.includes(PRIORITY_HIGH_LABEL);
@@ -427,9 +427,9 @@ export const priorityRankOfLabels = (labels: readonly string[]): 0 | 1 | 2 => {
  * ruleset bypass merges ({@link ReviewHold}): that one ranks with
  * `priority:low` unless labelled `priority:high` — alone, since the two
  * together count as neither. Picked, it is released, goes green and is set
- * aside for a person, so the cycle spent on it lands nothing; picked last,
- * it still has its checks run. `priority:high` is a person saying they want
- * that verdict now, and is the one way to ask for it, so it still counts.
+ * aside for a person, so the cycle spent on it lands nothing; picked last, it
+ * still has its checks run. `priority:high` is a person saying they want that
+ * verdict now, and is the one way to ask for it, so it still counts.
  */
 export const pickPriorityRank = (
   labels: readonly string[],
@@ -443,9 +443,9 @@ export const pickPriorityRank = (
 };
 
 /**
- * The order the worker picks candidates in. The declared order has already
- * been applied, as a gate rather than a sort, so this is lowest number first
- * within these ranks, outermost first:
+ * The order the worker picks candidates in. The declared order has already been
+ * applied, as a gate rather than a sort, so this is lowest number first within
+ * these ranks, outermost first:
  *
  * 1. What a watch has seen green and still open (`demoted`) goes after
  *    everything else, the release and `priority:high` included: everything
@@ -463,8 +463,8 @@ export const pickPriorityRank = (
  *    release: it only says that when a queued change and the release are
  *    both ready, the change goes first.
  *
- * `toSorted` is stable, so each sort keeps the order of the one before it
- * among equals, and the last one is the outermost.
+ * `toSorted` is stable, so each sort keeps the order of the one before it among
+ * equals, and the last one is the outermost.
  */
 export const orderCandidates = <P,>(
   candidates: readonly P[],
@@ -498,9 +498,8 @@ export const orderCandidates = <P,>(
 };
 
 /**
- * Whether `pr` carries the label `name`. A function rather than `includes`
- * in place, which narrows the label constant itself to `never` where it says
- * no.
+ * Whether `pr` carries the label `name`. A function rather than `includes` in
+ * place, which narrows the label constant itself to `never` where it says no.
  */
 const hasLabel = (
   pr: Readonly<{ labels: readonly string[] }>,
@@ -522,10 +521,9 @@ const outOfScopeReason = (
     return `not labelled ${MERGE_QUEUED_LABEL}`;
   }
 
-  // A base that is neither the default branch nor another open pull
-  // request's branch is one nothing here knows how to land on. A stacked one
-  // whose parent has just merged reads this way for the moment before GitHub
-  // moves it.
+  // A base that is neither the default branch nor another open pull request's
+  // branch is one nothing here knows how to land on. A stacked one whose parent
+  // has just merged reads this way for the moment before GitHub moves it.
   return pr.isDraft
     ? 'draft'
     : pr.baseRef !== context.defaultBranch &&
@@ -565,17 +563,17 @@ const byChecks = (reads: QueueReads): QueueStanding =>
       : ({ kind: 'in-flight' } as const);
 
 /**
- * The version pull request: held while anything labelled `blocks-release`
- * is open, and while the branch was built before the tip of the base, then
- * a candidate if paused and otherwise judged by its checks.
+ * The version pull request: held while anything labelled `blocks-release` is
+ * open, and while the branch was built before the tip of the base, then a
+ * candidate if paused and otherwise judged by its checks.
  */
 const versionStanding = (
   pr: QueueFacts,
   context: QueueContext,
   reads: QueueReads,
 ): QueueStanding => {
-  // Never one of its own blockers: the label on it would otherwise hold it
-  // for as long as it existed.
+  // Never one of its own blockers: the label on it would otherwise hold it for
+  // as long as it existed.
   const by = context.releaseBlockers.filter(
     (blocker) => blocker.number !== pr.number,
   );

package/src/queue-order.test.mts

@@ -253,8 +253,8 @@ describe(queueStanding, () => {
     );
   });
 
-  // Otherwise it would hold itself for as long as it existed, with nothing
-  // able to take the label off — a `Merge-After` cycle by another name.
+  // Otherwise it would hold itself for as long as it existed, with nothing able
+  // to take the label off — a `Merge-After` cycle by another name.
   test('never holds the release by its own label', () => {
     const release = facts({
       number: 1,
@@ -338,8 +338,8 @@ describe(orderCandidates, () => {
   });
 
   // Priority comes before every rank but the demotion, the release included:
-  // a release can be declared urgent, and a change declared able to wait
-  // goes out in the release after.
+  // a release can be declared urgent, and a change declared able to wait goes
+  // out in the release after.
   test('takes priority:high first and priority:low last, before what sat green', () => {
     assert.deepStrictEqual(
       order(
@@ -384,8 +384,8 @@ describe(orderCandidates, () => {
     );
   });
 
-  // Picked early, it is released, goes green and is set aside for a person,
-  // and the cycle it took went to nothing that could merge on its own.
+  // Picked early, it is released, goes green and is set aside for a person, and
+  // the cycle it took went to nothing that could merge on its own.
   test('puts one only a bypass merges with priority:low, unless labelled priority:high', () => {
     assert.deepStrictEqual(
       order(

package/src/queue-owner.mts

@@ -4,26 +4,26 @@
  * Who is to move each pull request in the queue next: the worker
  * (`pnpm run unblock-prs`), a skill, a person, or — which is a bug — nobody.
  *
- * The worker and the `/unblock-prs` skill move the same queue side by side
- * and cannot see each other. Each used to decide for itself whether a
+ * The worker and the `/unblock-prs` skill move the same queue side by side and
+ * cannot see each other. Each used to decide for itself whether a
  * set-aside still stood, from its own reading of the tip of the default
- * branch, and when the two readings differed each left the pull request to
- * the other (#2267). So the answer is decided here, once, and every reader
- * asks this function: the worker before it acts, `pr-report` for the skill,
+ * branch, and when the two readings differed each left the pull request to the
+ * other (#2267). So the answer is decided here, once, and every reader asks
+ * this function: the worker before it acts, `pr-report` for the skill,
  * `claim-pr` before it lets a claim be written, and `report-unowned-prs` to
  * turn `none` into an issue.
  *
  * **It reads the comments and the pull request, never the tip of the base.**
- * The set-aside comment is the hand-off: it stands until the worker rewrites
- * it as resolved — when the head moves, when a retry is asked for, or, for a
+ * The set-aside comment is the hand-off: it stands until the worker rewrites it
+ * as resolved — when the head moves, when a retry is asked for, or, for a
  * reason tied to the base, when the base moves and the worker takes the pull
- * request back to try again. Until then it is the skill's or a person's, and
- * a worker that has stopped running leaves it so rather than nobody's.
+ * request back to try again. Until then it is the skill's or a person's, and a
+ * worker that has stopped running leaves it so rather than nobody's.
  *
  * **Every reason the worker sets aside for has an owner**
  * ({@link setAsideOwner}, exhaustive over {@link SET_ASIDE_REASONS}), so `none`
- * is only ever a combination nothing here expected: a reason this module
- * does not know, written by a worker newer than the reader.
+ * is only ever a combination nothing here expected: a reason this module does
+ * not know, written by a worker newer than the reader.
  */
 
 import { claimApplies, type ClaimComment } from './claim.mjs';
@@ -40,8 +40,8 @@ export const QUEUE_OWNERS = ['worker', 'skill', 'human', 'none'] as const;
 
 /**
  * `skill` is the `/unblock-prs` skill, which fixes every queued pull request
- * the worker sets aside — a branch the repository generates included, which
- * it builds again rather than rebases (`generatedBranches` in
+ * the worker sets aside — a branch the repository generates included, which it
+ * builds again rather than rebases (`generatedBranches` in
  * `.github/unblock-prs.json`).
  */
 export type QueueOwner = Readonly<{
@@ -96,8 +96,8 @@ export const queueOwner = (pr: QueueOwnerInput): QueueOwner | undefined => {
     return { owner: 'human', reason: unmovable };
   }
 
-  // A layer waits for the one below whatever it says, and the worker carries
-  // it along when that one moves.
+  // A layer waits for the one below whatever it says, and the worker carries it
+  // along when that one moves.
   if (pr.stackedOn !== undefined) {
     return {
       owner: 'worker',
@@ -173,12 +173,12 @@ export const isSetAsideReason = (reason: string): reason is SetAsideReason =>
   KNOWN_REASONS.has(reason);
 
 /**
- * Whose a pull request set aside for `reason` is, while the comment stands
- * at its head. A skill's reason is one a session can fix by pushing: a
- * conflict to resolve, a failure to reproduce. A person's is one only a
- * setting, a permission, a review or a merge by hand clears, and the comment
- * says which. A `switch` with no default, so a reason added to
- * {@link SET_ASIDE_REASONS} without an owner fails to compile.
+ * Whose a pull request set aside for `reason` is, while the comment stands at
+ * its head. A skill's reason is one a session can fix by pushing: a conflict to
+ * resolve, a failure to reproduce. A person's is one only a setting, a
+ * permission, a review or a merge by hand clears, and the comment says which. A
+ * `switch` with no default, so a reason added to {@link SET_ASIDE_REASONS}
+ * without an owner fails to compile.
  */
 const setAsideOwner = (
   reason: SetAsideReason,
@@ -254,8 +254,8 @@ export type QueueOwnerInput = Readonly<{
 }>;
 
 /**
- * The set-aside `comment` says, if it stands at `headSha` with no retry
- * asked for. The base is not read: see the module comment.
+ * The set-aside `comment` says, if it stands at `headSha` with no retry asked
+ * for. The base is not read: see the module comment.
  */
 const standingAt = (
   comment: SetAsideComment | undefined,
@@ -270,8 +270,8 @@ const standingAt = (
 const KNOWN_REASONS: ReadonlySet<string> = new Set(SET_ASIDE_REASONS);
 
 /**
- * Why nothing in the queue can move `pr` until a person does something, if
- * so: the worker passes these over with a note, and no skill takes them up.
+ * Why nothing in the queue can move `pr` until a person does something, if so:
+ * the worker passes these over with a note, and no skill takes them up.
  */
 const unmovableReason = (pr: QueueOwnerInput): string | undefined =>
   pr.isDraft

package/src/queue-owner.test.mts

@@ -188,8 +188,8 @@ describe(queueOwner, () => {
       },
     );
 
-    // The same as for any other branch: which branches are generated, and
-    // how, is the repository's configuration, which the skill reads.
+    // The same as for any other branch: which branches are generated, and how,
+    // is the repository's configuration, which the skill reads.
     assert.deepStrictEqual(
       queueOwner({ ...update, setAside: standing('rebase-failed') }),
       {

package/src/report.mts

@@ -29,8 +29,8 @@ import type {
 /**
  * Reads the declared merge order and the check verdicts out of the facts.
  *
- * Nothing here talks to GitHub, which is what lets the whole shape of a
- * report be tested against a handful of literals.
+ * Nothing here talks to GitHub, which is what lets the whole shape of a report
+ * be tested against a handful of literals.
  */
 export const buildReport = ({
   repo,
@@ -96,8 +96,8 @@ export const buildEntries = ({
 }: Readonly<{
   /**
    * The contexts the ruleset requires, or `undefined` for a repository that
-   * declares none: each pull request is then judged over every context
-   * reported on its head.
+   * declares none: each pull request is then judged over every context reported
+   * on its head.
    */
   required: readonly string[] | undefined;
   defaultBranch: string;
@@ -195,9 +195,9 @@ export const buildEntries = ({
 
 /**
  * Each open issue with how it stands for being started
- * (`docs/issue-start-after.md`): its start state, or how far someone has
- * got with it when it is startable (`progressOf`), and where each thing it
- * names stands.
+ * (`docs/issue-start-after.md`): its start state, or how far someone has got
+ * with it when it is startable (`progressOf`), and where each thing it names
+ * stands.
  */
 const reportIssues = (
   issues: readonly OpenIssue[],
@@ -243,8 +243,8 @@ const NO_DECLARATIONS: IssueDeclarations = {
 
 /**
  * The issues a pull request closes that may still declare an order: any not
- * known to be closed. One read from the body without a token has an
- * `unknown` state, and is given the benefit of the doubt.
+ * known to be closed. One read from the body without a token has an `unknown`
+ * state, and is given the benefit of the doubt.
  */
 const notKnownClosed = (
   linkedIssues: PullRequestFacts['linkedIssues'],

package/src/review-hold.mts

@@ -5,18 +5,18 @@
  * `main`'s ruleset asks for two things no check reports: an approval from a
  * code owner of every owned path the pull request touches, and every review
  * conversation resolved. A queued pull request missing either goes green and
- * sits there, and a rebase cannot change that. Released anyway, it costs a
- * full matrix and holds the queue for the length of a watch; and because
- * `main` moving is what puts it back in the running, it would be rebased and
- * run again every time anything else merged. So triage reads both before
- * picking, and leaves a pull request they hold in the queue with a note,
- * until an approval or a resolved conversation changes the answer.
+ * sits there, and a rebase cannot change that. Released anyway, it costs a full
+ * matrix and holds the queue for the length of a watch; and because `main`
+ * moving is what puts it back in the running, it would be rebased and run again
+ * every time anything else merged. So triage reads both before picking, and
+ * leaves a pull request they hold in the queue with a note, until an approval
+ * or a resolved conversation changes the answer.
  *
  * Except when nothing can change it: GitHub does not let an author approve
  * their own pull request, so one whose waiting paths only its author owns
- * merges by a ruleset bypass or not at all. Holding that one would hold it
- * for ever, with `skip-ci` on and no verdict for whoever makes the bypass
- * merge to go by. So it is released and watched like any other, with
+ * merges by a ruleset bypass or not at all. Holding that one would hold it for
+ * ever, with `skip-ci` on and no verdict for whoever makes the bypass merge to
+ * go by. So it is released and watched like any other, with
  * auto-merge left off — it could never fire — until its checks report, and
  * then left for that person (`awaiting-bypass`).
  *
@@ -50,11 +50,11 @@ export type ReviewRules = Readonly<{
 }>;
 
 /**
- * What the review does to the pull request: `held` waits for an approval or
- * a resolved conversation, `bypass` waits for nobody — only its author owns
- * what is waiting — and `undefined` holds nothing. What cannot be told for
- * sure — changed files past what could be read — holds nothing: the watch
- * still catches a pull request that goes green and does not merge, and
+ * What the review does to the pull request: `held` waits for an approval or a
+ * resolved conversation, `bypass` waits for nobody — only its author owns what
+ * is waiting — and `undefined` holds nothing. What cannot be told for sure —
+ * changed files past what could be read — holds nothing: the watch still
+ * catches a pull request that goes green and does not merge, and
  * `demotions.mts` is what follows.
  */
 export type ReviewHold = Readonly<{ kind: 'bypass' | 'held'; reason: string }>;

package/src/review-hold.test.mts

@@ -123,9 +123,9 @@ describe(reviewHold, () => {
     );
   });
 
-  // A changed file past what could be read might be owned, but "might" is not
-  // a reason to hold the queue: the watch still catches a pull request that
-  // goes green and does not merge.
+  // A changed file past what could be read might be owned, but "might" is not a
+  // reason to hold the queue: the watch still catches a pull request that goes
+  // green and does not merge.
   test('holds nothing it cannot be sure of', () => {
     assert.isUndefined(
       reviewHold(

package/src/ruleset.mts

@@ -10,8 +10,8 @@ export type RulesetRequirements = Readonly<{
   /** The contexts a pull request has to satisfy. */
   requiredContexts: readonly string[];
   /**
-   * Whether a change to a path `.github/CODEOWNERS` lists waits for one of
-   * its owners to approve it.
+   * Whether a change to a path `.github/CODEOWNERS` lists waits for one of its
+   * owners to approve it.
    */
   requireCodeOwnerReview: boolean;
   /** Whether every review conversation has to be resolved first. */
@@ -23,11 +23,10 @@ export type RulesetRequirements = Readonly<{
  * `pnpm run pr-report`, which reads the checkout. The file is the desired
  * state; what GitHub enforces is {@link requirementsOfRules} over
  * `rules/branches/{branch}`, which `unblock-prs` and the Pull Requests
- * Manager read and which wants no more than read access. The gap is that a
- * file under `repo-settings/` changes nothing until
- * `pnpm run repo-settings:apply` runs, so a context added here and not
- * applied is reported as missing on every pull request — which is a fair
- * thing for a report to say out loud.
+ * Manager read and which wants no more than read access. The gap is that a file
+ * under `repo-settings/` changes nothing until `pnpm run repo-settings:apply`
+ * runs, so a context added here and not applied is reported as missing on every
+ * pull request — which is a fair thing for a report to say out loud.
  *
  * `source` names the file in the messages.
  */
@@ -98,8 +97,8 @@ const RulesetSchema = t.record({ rules: t.array(t.unknown()) });
 
 /**
  * One rule of the several kinds a ruleset holds. The others carry entirely
- * different parameters, so each rule is tried against this and the ones that
- * do not match are simply not the rule being looked for.
+ * different parameters, so each rule is tried against this and the ones that do
+ * not match are simply not the rule being looked for.
  *
  * Written here rather than taken from `octokit-safe-types`, whose
  * `RepositoryRule` is the whole union: validating against it would refuse a
@@ -126,8 +125,8 @@ const ConversationResolutionRuleSchema = t.record({
 
 /**
  * The rules as read: `ruleset.test.mts` checks each against GitHub's API
- * description, so that a field read here that GitHub renames or retypes
- * fails the type check.
+ * description, so that a field read here that GitHub renames or retypes fails
+ * the type check.
  */
 export type RequiredStatusChecksRule = t.TypeOf<
   typeof RequiredStatusChecksRuleSchema