pr-report-core 0.2.0 → 0.3.0

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<{
@@ -55,8 +55,11 @@ export const SET_ASIDE_REASONS = [
   'arm-failed',
   'awaiting-bypass',
   'checks-failed',
+  'checks-not-started',
+  'head-out-of-sync',
   'not-merging',
   'push-failed',
+  'read-failed',
   'rebase-failed',
   'unlabel-failed',
   'watch-timeout',
@@ -96,8 +99,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 +176,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,
@@ -206,12 +209,30 @@ const setAsideOwner = (
         why: 'green, and only a ruleset bypass merges it',
       };
 
+    case 'checks-not-started':
+      return {
+        owner: 'human',
+        why: 'GitHub started no run for a required check on its head; the base moving puts it back in the queue to be rebased in its turn, and a new commit pushed to the branch starts the checks sooner',
+      };
+
+    case 'head-out-of-sync':
+      return {
+        owner: 'human',
+        why: 'GitHub never took in the last push to its branch, so it still shows an older head; push to the branch again, or close and reopen it',
+      };
+
     case 'not-merging':
       return {
         owner: 'human',
         why: 'green but not merging; something the worker cannot read holds it',
       };
 
+    case 'read-failed':
+      return {
+        owner: 'human',
+        why: 'its checks or its base could not be read survey after survey; the comment says what failed',
+      };
+
     case 'push-failed':
       return {
         owner: 'human',
@@ -254,8 +275,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 +291,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

@@ -135,6 +135,8 @@ describe(queueOwner, () => {
     'unlabel-failed',
     'push-failed',
     'watch-timeout',
+    'head-out-of-sync',
+    'checks-not-started',
   ] as const)('is a person’s when set aside %s', (reason) => {
     assert.strictEqual(
       queueOwner({ ...queued, setAside: standing(reason) })?.owner,
@@ -188,8 +190,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. */
@@ -21,13 +21,12 @@ export type RulesetRequirements = Readonly<{
 /**
  * The requirements, read from the declaration rather than from GitHub, for
  * `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.
+ * state; what GitHub enforces is `readBranchRequirements`, which reads it for
+ * `unblock-prs`, the Pull Requests Manager and `pr-report` pointed elsewhere,
+ * 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

package/src/set-aside.mts

@@ -1,30 +1,30 @@
 /**
  * Why `unblock-prs` set a pull request aside, written where GitHub keeps it.
  *
- * The script decides on someone's machine and says so on standard output,
- * which is where nobody can see it afterwards. So each time it sets a pull
- * request aside it also writes a comment on that pull request — one per pull
- * request, edited in place from then on — whose first line is a hidden
- * record this module writes and reads back, and whose last line is a task
- * box a person ticks to have the script try again. What lies between is
- * prose for whoever reads it, and nothing reads it back. The Pull Requests
+ * The script decides on someone's machine and says so on standard output, which
+ * is where nobody can see it afterwards. So each time it sets a pull request
+ * aside it also writes a comment on that pull request — one per pull request,
+ * edited in place from then on — whose first line is a hidden record this
+ * module writes and reads back, and whose last line is a task box a person
+ * ticks to have the script try again. What lies between is prose for whoever
+ * reads it, and nothing reads it back. The Pull Requests
  * Manager page and the script itself read the record; anyone else reads the
  * prose on the pull request.
  *
  * **A comment rather than a commit status**, which is what it used to be. A
- * status has no state that means "for information": `failure` left a red ✗ on
- * a context nothing requires, until the next push, with 140 characters to say
+ * status has no state that means "for information": `failure` left a red ✗ on a
+ * context nothing requires, until the next push, with 140 characters to say
  * why, and nobody could take it off or ask for another try. **Rather than the
  * body**, because the author, a session and `open-pr` write the body too, the
  * REST API has no conditional update to keep an edit made in between, and the
  * version pull request's body is rewritten on every push to the base.
  *
- * **Only the comments the reader's own account wrote count.** The repository
- * is public, so anyone can post a comment that starts with the marker; the
- * script and the page both ask GitHub for `viewerDidAuthor` and read nothing
- * else — the account that runs `unblock-prs` is the one that looks at the
- * page. A task box in someone else's comment can be ticked only by those who
- * can write to the repository, so the retry is not open to outsiders either.
+ * **Only the comments the reader's own account wrote count.** The repository is
+ * public, so anyone can post a comment that starts with the marker; the script
+ * and the page both ask GitHub for `viewerDidAuthor` and read nothing else —
+ * the account that runs `unblock-prs` is the one that looks at the page. A task
+ * box in someone else's comment can be ticked only by those who can write to
+ * the repository, so the retry is not open to outsiders either.
  *
  * **Its own record rather than GitHub's `mergeable`.** That answers whether
  * *merging* the branch conflicts, from a cached background computation; the
@@ -32,8 +32,8 @@
  * parent was squash-merged and on a cache that has not caught up. Only the
  * script knows what the rebase said.
  *
- * **It lasts exactly as long as the state it was reached in.** The record
- * names the head and the base it was reached at; a push moves the head, and
+ * **It lasts exactly as long as the state it was reached in.** The record names
+ * the head and the base it was reached at; a push moves the head, and
  * {@link setAsideApplies} is where a moved head and a moved base are judged,
  * for the script and the page alike. Once it no longer applies, or a person
  * asked for a retry, the script rewrites the comment to one resolved line
@@ -60,9 +60,9 @@ export type SetAside = Readonly<{
 }>;
 
 /**
- * What one of the script's comments says: a pull request still set aside,
- * and whether a person has ticked the retry box on it, or one that was and
- * is not any more.
+ * What one of the script's comments says: a pull request still set aside, and
+ * whether a person has ticked the retry box on it, or one that was and is not
+ * any more.
  */
 export type SetAsideComment = Readonly<
   | { kind: 'resolved' }
@@ -70,9 +70,9 @@ export type SetAsideComment = Readonly<
 >;
 
 /**
- * The record line, `prose`, and an empty retry box on the last line. The
- * whole SHAs rather than short ones, because what reads them back compares
- * them with the head and the base.
+ * The record line, `prose`, and an empty retry box on the last line. The whole
+ * SHAs rather than short ones, because what reads them back compares them with
+ * the head and the base.
  */
 export const writeSetAsideComment = (
   setAside: SetAside,
@@ -148,11 +148,12 @@ export const setAsideApplies = (
  * judged the head.
  *
  * Every reason clears when the base moves, because a moved base is the one
- * thing the script knows how to act on — a rebase that conflicted may not
- * any more — except two whose head a rebase would only put through the same
- * matrix again: `checks-failed`, which the push that carries the fix clears,
- * and `awaiting-bypass`, green and waiting for a ruleset bypass merge, which
- * does not wait for the base.
+ * thing the script knows how to act on — a rebase that conflicted may not any
+ * more — except two whose head a rebase would only put through the same matrix
+ * again: `checks-failed`, which the push that carries the fix clears, and
+ * `awaiting-bypass`, green and waiting for a ruleset bypass merge, which does
+ * not wait for the base. Nor does `head-out-of-sync`: GitHub not having taken
+ * in the branch's last push is not something the base moving changes.
  */
 export const setAsideStillApplies = (
   setAside: Readonly<{ reason: string; baseSha: string }>,
@@ -160,6 +161,7 @@ export const setAsideStillApplies = (
 ): boolean =>
   setAside.reason === 'checks-failed' ||
   setAside.reason === 'awaiting-bypass' ||
+  setAside.reason === 'head-out-of-sync' ||
   setAside.baseSha === baseTip;
 
 /** The first line starts with this, so the comment is found by it. */

package/src/set-aside.test.mts

@@ -160,4 +160,26 @@ describe(setAsideStillApplies, () => {
       ),
     );
   });
+
+  // GitHub never took in the branch's last push, and the base moving does not
+  // make it take it in; a comment rewritten on every merge would be noise.
+  test('outlives a moved base when the branch is out of sync with GitHub', () => {
+    assert.isTrue(
+      setAsideStillApplies(
+        { reason: 'head-out-of-sync', baseSha: BASE },
+        'b'.repeat(40),
+      ),
+    );
+  });
+
+  // The rebase that a moved base brings is a new head, and the push that
+  // carries it is what starts the workflows GitHub did not start before.
+  test('ends with a moved base when no check run started on the head', () => {
+    assert.isFalse(
+      setAsideStillApplies(
+        { reason: 'checks-not-started', baseSha: BASE },
+        'b'.repeat(40),
+      ),
+    );
+  });
 });

package/src/stack.mts

@@ -3,13 +3,13 @@
  * branch, so that its diff is its own layer and nothing below it.
  *
  * The stack is read from the bases alone, because GitHub already holds it: a
- * pull request onto `a` is on top of whichever pull request is `a`'s. When
- * that one merges, GitHub moves the layer above it onto its base and rebases
- * it, so the base chain is the merge order, and everything that orders pull
- * requests here reads a parent as a `Merge-After:` on it. `open-pr --base`
- * writes that trailer too, so that the body states the order as it does for
- * every other; a stack made any other way, without one, counts all the same,
- * and one naming the parent is not counted twice.
+ * pull request onto `a` is on top of whichever pull request is `a`'s. When that
+ * one merges, GitHub moves the layer above it onto its base and rebases it, so
+ * the base chain is the merge order, and everything that orders pull requests
+ * here reads a parent as a `Merge-After:` on it. `open-pr --base` writes that
+ * trailer too, so that the body states the order as it does for every other; a
+ * stack made any other way, without one, counts all the same, and one naming
+ * the parent is not counted twice.
  */
 
 /** The fields a stack is read from. */
@@ -20,8 +20,8 @@ export type StackMember = Readonly<{
   headRef: string;
   baseRef: string;
   /**
-   * Whether the head branch lives in a fork. A fork's branch is not a branch
-   * of this repository, whatever its name, so it is never a parent.
+   * Whether the head branch lives in a fork. A fork's branch is not a branch of
+   * this repository, whatever its name, so it is never a parent.
    */
   fromFork: boolean;
 }>;
@@ -31,9 +31,9 @@ export type StackMember = Readonly<{
  * A pull request that is not stacked has no entry.
  *
  * A base is a parent's head only when exactly one open pull request from this
- * repository heads it: a branch opened against two bases is two pull
- * requests, and which of them a layer above means cannot be told. Nothing
- * onto the default branch is stacked, even if some odd pull request heads it.
+ * repository heads it: a branch opened against two bases is two pull requests,
+ * and which of them a layer above means cannot be told. Nothing onto the
+ * default branch is stacked, even if some odd pull request heads it.
  */
 export const findStackParents = (
   pulls: readonly StackMember[],
@@ -60,9 +60,8 @@ export const findStackParents = (
 };
 
 /**
- * Every layer above `number`, each after the one it is on — the order in
- * which they are moved when `number` moves. Siblings keep the lowest number
- * first.
+ * Every layer above `number`, each after the one it is on — the order in which
+ * they are moved when `number` moves. Siblings keep the lowest number first.
  */
 export const stackDescendants = (
   parents: ReadonlyMap<number, number>,

package/src/stack.test.mts

@@ -65,8 +65,8 @@ describe(findStackParents, () => {
   });
 
   test('nothing onto the default branch is stacked, whatever heads it', () => {
-    // A pull request *from* the default branch is odd but possible, and
-    // reading it as a parent would put every other pull request under it.
+    // A pull request *from* the default branch is odd but possible, and reading
+    // it as a parent would put every other pull request under it.
     const parents = findStackParents(
       pulls([
         [1, 'main', 'release'],
@@ -79,8 +79,8 @@ describe(findStackParents, () => {
   });
 
   test('a branch two open pull requests head is not a parent', () => {
-    // One branch opened against two bases: which of them the stack means
-    // cannot be told, so neither is taken.
+    // One branch opened against two bases: which of them the stack means cannot
+    // be told, so neither is taken.
     const parents = findStackParents(
       pulls([
         [1, 'a', 'main'],