dw-sdlc 0.20.0 → 0.21.1

package/dist/pr/standing.js

@@ -0,0 +1,181 @@
+// The Review's standing at a pull request's head: what the Reviews before it read, from the review status
+// each commit carries and the commits force pushes left behind; what the head carries of them; what the
+// next Review reads, through a port onto GitHub's compares; and so the Review the head gets.
+import { route } from "./route.js";
+/**
+ * How many Reviews that each left a Finding open, with no success between them, the script lets run: the
+ * next call parks the pull request for the dev. A constant, like the depth rules, so no repository turns
+ * the loop back on.
+ */
+const REVIEW_LIMIT = 3;
+/** A change as a key, equal exactly when the two changes are. */
+function keyOf({ path, status, previous, lines }) {
+    return JSON.stringify([path, status, previous, lines]);
+}
+/** Whether the own changes at the head are those at the reviewed commit; unknown changes never are. */
+function sameChanges(then, now) {
+    if (then === null || now === null) {
+        return false;
+    }
+    return JSON.stringify(then.map(keyOf).toSorted()) === JSON.stringify(now.map(keyOf).toSorted());
+}
+/**
+ * The files whose own change differs between `before` and `after`, a rename under both names; null when a
+ * compare cannot show either whole.
+ */
+function movedFiles(before, after) {
+    if (before === null || after === null) {
+        return null;
+    }
+    const was = new Set(before.map(keyOf));
+    const is = new Set(after.map(keyOf));
+    const moved = [
+        ...after.filter((change) => !was.has(keyOf(change))),
+        ...before.filter((change) => !is.has(keyOf(change)))
+    ];
+    const names = moved.flatMap(({ path, previous }) => (previous === null ? [path] : [path, previous]));
+    return [...new Set(names)].toSorted();
+}
+/**
+ * The last commit before the head a Review read, a success under off passed over, or `open`: a read mark
+ * on the head, or one with only merges after it. No fix answers its Findings, so no read stands in.
+ */
+function lastReadOf({ commits, head }) {
+    if (commits.some(({ oid, posted }) => oid === head && posted === "findings")) {
+        return { lastRead: null, open: head };
+    }
+    const index = commits.findLastIndex(({ oid, posted }) => oid !== head && (posted === "clean" || posted === "findings"));
+    const last = commits[index];
+    if (last === undefined) {
+        return { lastRead: null, open: null };
+    }
+    const after = commits.slice(index + 1);
+    const baseOnly = after.every(({ merge }) => merge);
+    if (last.posted === "findings" && baseOnly) {
+        return { lastRead: null, open: last.oid };
+    }
+    const baseMoved = after.some(({ merge }) => merge);
+    return { lastRead: { commit: last.oid, clean: last.posted === "clean", baseOnly, baseMoved }, open: null };
+}
+/** The newest commit force pushes left behind that a Review read: a rebase moved the base under it. */
+function leftBehindRead({ leftBehind }) {
+    const read = leftBehind.find(({ posted }) => posted === "clean" || posted === "findings");
+    return read === undefined
+        ? null
+        : { commit: read.oid, clean: read.posted === "clean", baseOnly: true, baseMoved: true };
+}
+/**
+ * A read mark a force push left behind and posted after every read of the history: the Review the head
+ * needs reads from it, not from the history's last read, whose clean status no longer stands.
+ */
+function leftBehindMark(history) {
+    const newest = inPostedOrder(history).findLast(({ posted }) => posted === "clean" || posted === "findings");
+    if (newest?.posted !== "findings" || history.commits.some(({ oid }) => oid === newest.oid)) {
+        return null;
+    }
+    return { commit: newest.oid, clean: false, baseOnly: true, baseMoved: true };
+}
+/**
+ * The read mark `read` left open, no fix showing after it (ADR 0023): no change since it after the branch's
+ * own commits alone, else the same own changes at both commits or a compare that cannot show them whole.
+ * Null for any other read.
+ */
+function openAt(read, { changed }, own, head) {
+    if (read === null || read.clean) {
+        return null;
+    }
+    if (!read.baseMoved) {
+        const since = changed(read.commit, head);
+        return since !== "unsized" && since.length === 0 ? read.commit : null;
+    }
+    const atRead = own(read.commit);
+    const atHead = own(head);
+    return atRead !== null && atHead !== null && !sameChanges(atRead, atHead) ? null : read.commit;
+}
+/** Whether a commit carries a review success of any kind. */
+function isSuccess({ posted }) {
+    return posted === "clean" || posted === "off";
+}
+/** How many of `marked` carry a read mark. */
+function findings(marked) {
+    return marked.filter(({ posted }) => posted === "findings").length;
+}
+/**
+ * The commits in the order their review statuses were posted: each line a force push left behind just
+ * after the commit of the history it was pushed on, older pushes first, and a line that holds none of
+ * the history before all of it.
+ */
+function inPostedOrder({ commits, leftBehind }) {
+    const oldestFirst = leftBehind.toReversed();
+    const pushedOn = (index) => oldestFirst.filter(({ forksAt }) => forksAt === index);
+    return [...pushedOn(-1), ...commits.flatMap((commit, index) => [commit, ...pushedOn(index)])];
+}
+/** The read marks posted after the last success, of the history and of the commits force pushes left behind. */
+function readMarksOf(history) {
+    const posted = inPostedOrder(history);
+    const success = posted.findLastIndex(isSuccess);
+    return { count: findings(posted.slice(success + 1)), since: posted[success]?.oid ?? null };
+}
+/**
+ * The standing at the head of `history`. The compares run only when a Review `awaits` the head, and the
+ * files that Review would read are read only when `sized`, as `pr.review: auto` routes on them.
+ */
+export function standingOf(history, compares, { awaits, sized }) {
+    const marks = readMarksOf(history);
+    const inHistory = lastReadOf(history);
+    const read = inHistory.open === null ? (leftBehindMark(history) ?? inHistory.lastRead ?? leftBehindRead(history)) : null;
+    if (!awaits) {
+        return { lastRead: read, open: inHistory.open, marks, carried: false, changed: null, scope: null };
+    }
+    const { head, base } = history;
+    const own = (commit) => compares.ownChanges(base, commit);
+    const open = inHistory.open ?? openAt(read, compares, own, head);
+    const lastRead = open === null ? read : null;
+    const reads = { lastRead, open, marks };
+    // A clean read carries over the base's changes alone.
+    const carried = lastRead !== null && lastRead.clean && lastRead.baseOnly && sameChanges(own(lastRead.commit), own(head));
+    if (carried) {
+        return { ...reads, carried, changed: null, scope: null };
+    }
+    const scope = lastRead?.baseMoved === true ? movedFiles(own(lastRead.commit), own(head)) : null;
+    if (!sized) {
+        return { ...reads, carried, changed: null, scope };
+    }
+    const changed = compares.changed(lastRead?.commit ?? base, head);
+    if (scope === null || changed === "unsized") {
+        return { ...reads, carried, changed, scope };
+    }
+    const within = changed.filter(({ path, previous }) => scope.includes(path) || (previous !== null && scope.includes(previous)));
+    return { ...reads, carried, changed: within, scope };
+}
+/** Whether a Finding stands: a read mark since the last success, as the last read, or left open (ADR 0016). */
+function findingsOpen({ marks, lastRead, open }) {
+    return marks.count > 0 || lastRead?.clean === false || open !== null;
+}
+/** The depth the head is read at: the dev's or the one `pr.review` sets, else the one the rules route. */
+function depthOf({ depth, source }, standing) {
+    if (depth === "off") {
+        return { depth, source, why: source === "flag" ? "--review off" : "pr.review" };
+    }
+    if (depth !== "auto") {
+        return { depth, source };
+    }
+    return { ...route(standing.changed, findingsOpen(standing)), source: "auto" };
+}
+/** The Review the head gets at `standing` under `review`; the dev's word goes over a carry. */
+export function reviewCall(standing, review) {
+    const { lastRead, open, marks, carried, scope } = standing;
+    const flagged = review.source === "flag";
+    if (carried && lastRead !== null && !flagged) {
+        return { kind: "carry", from: lastRead.commit };
+    }
+    const depth = depthOf(review, standing);
+    // The dev's own depth buys one Review past the limit, and only one: the flag rides on every
+    // later call. Their --review off posts past it: no one reads, by their word.
+    const limit = flagged ? REVIEW_LIMIT + 1 : REVIEW_LIMIT;
+    if (!(flagged && depth.depth === "off") && marks.count >= limit) {
+        return { ...marks, kind: "limit" };
+    }
+    // Over a carry the dev's depth reads the whole diff: the changes after the read are only the base's.
+    return { ...depth, kind: "review", since: carried ? null : (lastRead?.commit ?? null), paths: scope, open };
+}

package/dist/pr/state.d.ts

@@ -1,3 +1,4 @@
+import type { History, Standing } from "./standing.ts";
 /** The commit status a clean review of the head leaves on it. */
 export declare const REVIEW = "dw-sdlc/review";
 /** How the description of a success the script posts under off begins: no one read that head. */
@@ -10,7 +11,7 @@ export declare const MARK_STATE = "failure";
 export declare const READ_MARK = "read, findings open";
 /** How the description of the success the dev's `--accept` posts reads: the head, taken with its Findings open. */
 export declare const ACCEPTED = "accepted by the dev, findings open";
-export declare const QUERY = "query($owner: String!, $name: String!, $number: Int!) {\n  repository(owner: $owner, name: $name) {\n    pullRequest(number: $number) {\n      url number state isDraft mergeable mergeStateStatus reviewDecision headRefOid headRefName headRef { name } isCrossRepository baseRefName\n      baseRefOid baseRef { target { oid } } viewerDidAuthor mergeCommit { oid }\n      ready: timelineItems(last: 1, itemTypes: [READY_FOR_REVIEW_EVENT]) { nodes { ... on ReadyForReviewEvent { createdAt } } }\n      latestReviews(first: 100) { nodes { state author { login } commit { oid } } }\n      reviewThreads(first: 100) { pageInfo { hasNextPage } nodes { id isResolved isOutdated path line\n        comments(first: 1) { nodes { author { login } body } }\n        latest: comments(last: 1) { nodes { viewerDidAuthor } } } }\n      commits(last: 1) { nodes { commit { committedDate statusCheckRollup {\n        contexts(first: 50) { pageInfo { hasNextPage } nodes {\n          ... on CheckRun { name status conclusion detailsUrl startedAt isRequired(pullRequestNumber: $number) }\n          ... on StatusContext { context state targetUrl createdAt isRequired(pullRequestNumber: $number) } } } } } } }\n      history: commits(last: 100) { nodes { commit { oid parents { totalCount } status { context(name: \"dw-sdlc/review\") { state description } } } } }\n    }\n  }\n}";
+export declare const QUERY = "query($owner: String!, $name: String!, $number: Int!) {\n  repository(owner: $owner, name: $name) {\n    pullRequest(number: $number) {\n      url number state isDraft mergeable mergeStateStatus reviewDecision headRefOid headRefName headRef { name } isCrossRepository baseRefName\n      baseRefOid baseRef { target { oid } } viewerDidAuthor mergeCommit { oid }\n      ready: timelineItems(last: 1, itemTypes: [READY_FOR_REVIEW_EVENT]) { nodes { ... on ReadyForReviewEvent { createdAt } } }\n      latestReviews(first: 100) { nodes { state author { login } commit { oid } } }\n      reviewThreads(first: 100) { pageInfo { hasNextPage } nodes { id isResolved isOutdated path line\n        comments(first: 1) { nodes { author { login } body } }\n        latest: comments(last: 1) { nodes { viewerDidAuthor } } } }\n      commits(last: 1) { nodes { commit { committedDate statusCheckRollup {\n        contexts(first: 50) { pageInfo { hasNextPage } nodes {\n          ... on CheckRun { name status conclusion detailsUrl startedAt isRequired(pullRequestNumber: $number) }\n          ... on StatusContext { context state targetUrl createdAt isRequired(pullRequestNumber: $number) } } } }\n        status { context(name: \"dw-sdlc/review\") { context state targetUrl createdAt isRequired(pullRequestNumber: $number) } } } } }\n      history: commits(last: 100) { nodes { commit { oid parents { totalCount } status { context(name: \"dw-sdlc/review\") { state description } } } } }\n      rewritten: timelineItems(last: 20, itemTypes: [HEAD_REF_FORCE_PUSHED_EVENT]) { nodes { ... on HeadRefForcePushedEvent {\n        beforeCommit { oid history(first: 20) { nodes { oid parents(first: 1) { nodes { oid } }\n          status { context(name: \"dw-sdlc/review\") { state description } } } } } } } }\n    }\n  }\n}";
 export type Bucket = "pass" | "fail" | "pending" | "skipping";
 export type CiCheck = {
     name: string;
@@ -38,7 +39,8 @@ export type ChangeRequest = {
     reviewer: string;
     answered: boolean;
 };
-export type PrState = {
+/** The pull request as the reply holds it, before the Review's standing is read. */
+export type PullRequest = {
     url: string;
     repo: string;
     number: number;
@@ -74,72 +76,9 @@ export type PrState = {
     cutOff: string[];
     /** The oids of the pull request's last 100 commits, oldest first, the head last. */
     commits: string[];
-    /**
-     * The last commit before the head a Review read, of the last 100: a review success not posted under
-     * off, or a read mark.
-     */
-    lastRead: LastRead | null;
-    /** The read marks since the last review success of any kind, of the last 100 commits. */
-    marks: ReadMarks;
-    /** Whether the head carries the success of `lastRead`: the read decides it from two compares. */
-    carried: boolean;
-    /**
-     * The files a Review would read, from `lastRead` or the base to the head, read only for `pr.review:
-     * auto` to route on: `unsized` when the compare cannot list them all, null when not read.
-     */
-    changed: ChangedFile[] | "unsized" | null;
-    /**
-     * The files whose own change moved since `lastRead`, when a merge of the base came after it: the files
-     * a fix touched, the base's own left out. Null with no such merge, or when a compare cannot show them.
-     */
-    scope: string[] | null;
 };
-/**
- * A file a Review would read: its name, its name before a rename, and the lines it adds and removes,
- * null when the compare shows no patch for it, as for a binary file.
- */
-export type ChangedFile = {
-    path: string;
-    previous: string | null;
-    lines: number | null;
-};
-/**
- * A commit a Review read; `clean` when that Review left a success on it, not a read mark; and whether
- * every commit after it, the head included, is a merge.
- */
-export type LastRead = {
-    commit: string;
-    clean: boolean;
-    mergesOnly: boolean;
-    merges: boolean;
-};
-/**
- * The Reviews that left a Finding open since the last review success, a success under off and the dev's
- * acceptance included: `count` their read marks, the head's own among them, and `since` that success's
- * commit, null when none of the last 100 holds one.
- */
-export type ReadMarks = {
-    count: number;
-    since: string | null;
-};
-/** A reply that is not the shape the query asks for; the message names the field. */
-export declare class ReplyError extends Error {
-}
-/** A JSON object of the reply and the path that reached it, as `data.repository.pullRequest`. */
-export type Node = {
-    value: Record<string, unknown>;
-    at: string;
-};
-export declare function shown(value: unknown): string;
-/** The JSON object `reply` holds, the root its fields' paths start from; `what` names it in a problem. */
-export declare function rootOf(reply: string, what: string): Node;
-export declare function fieldOf(node: Node, key: string): {
-    value: unknown;
-    at: string;
-};
-export declare function object(value: unknown, at: string): Node;
-export declare function string(node: Node, key: string): string;
-export declare function integer(node: Node, key: string): number;
+/** The pull request and the Review's standing at its head. */
+export type PrState = PullRequest & Standing;
 /** The viewer's own pull request without a review success on its head: the one a Review reads. */
 export declare function awaitsReview(pr: Pick<PrState, "viewerDidAuthor" | "checks">): boolean;
 /** The repository and number of the pull request whose URL `gh pr view --json url` printed. */
@@ -149,6 +88,12 @@ export declare function parseView(reply: string): {
 };
 /** The default branch of the repository whose `gh repo view --json defaultBranchRef` printed `reply`. */
 export declare function parseDefaultBranch(reply: string): string;
-/** The state of the pull request in `reply`, the text `gh api graphql` printed for QUERY on `repo`. */
-export declare function parsePr(reply: string, repo: string): Omit<PrState, "carried" | "changed" | "scope">;
+/**
+ * The pull request in `reply`, the text `gh api graphql` printed for QUERY on `repo`, and the history the
+ * Review's standing at its head is read from.
+ */
+export declare function parsePr(reply: string, repo: string): {
+    pr: PullRequest;
+    history: History;
+};
 export {};

package/dist/pr/state.js

@@ -1,5 +1,7 @@
 // One pull request as the Ship script reads it: the one GraphQL query, and its reply parsed into the
-// state the decision reads. Every field the state needs is checked; a reply that fails names the field.
+// state the decision reads, the review history the Review's standing is read from beside it. Every field
+// the state needs is checked; a reply that fails names the field.
+import { boolean, child, childOrNull, firstNode, hasMore, integer, integerOrNull, nodes, oneOf, ReplyError, rootOf, string, stringOrNull, time, timeOrNull } from "./reply.js";
 /** The commit status a clean review of the head leaves on it. */
 export const REVIEW = "dw-sdlc/review";
 /** How the description of a success the script posts under off begins: no one read that head. */
@@ -15,6 +17,12 @@ export const ACCEPTED = "accepted by the dev, findings open";
 /** How many checks and review threads the one read holds; each list's `pageInfo` says when more follow. */
 const CHECKS_READ = 50;
 const THREADS_READ = 100;
+/**
+ * How many of the last force pushes the read holds, each with the head it left behind, and how many
+ * commits of that head's history.
+ */
+const FORCE_PUSHES_READ = 20;
+const LEFT_BEHIND_READ = 20;
 export const QUERY = `query($owner: String!, $name: String!, $number: Int!) {
   repository(owner: $owner, name: $name) {
     pullRequest(number: $number) {
@@ -28,126 +36,18 @@ export const QUERY = `query($owner: String!, $name: String!, $number: Int!) {
       commits(last: 1) { nodes { commit { committedDate statusCheckRollup {
         contexts(first: ${CHECKS_READ}) { pageInfo { hasNextPage } nodes {
           ... on CheckRun { name status conclusion detailsUrl startedAt isRequired(pullRequestNumber: $number) }
-          ... on StatusContext { context state targetUrl createdAt isRequired(pullRequestNumber: $number) } } } } } } }
+          ... on StatusContext { context state targetUrl createdAt isRequired(pullRequestNumber: $number) } } } }
+        status { context(name: "${REVIEW}") { context state targetUrl createdAt isRequired(pullRequestNumber: $number) } } } } }
       history: commits(last: 100) { nodes { commit { oid parents { totalCount } status { context(name: "${REVIEW}") { state description } } } } }
+      rewritten: timelineItems(last: ${FORCE_PUSHES_READ}, itemTypes: [HEAD_REF_FORCE_PUSHED_EVENT]) { nodes { ... on HeadRefForcePushedEvent {
+        beforeCommit { oid history(first: ${LEFT_BEHIND_READ}) { nodes { oid parents(first: 1) { nodes { oid } }
+          status { context(name: "${REVIEW}") { state description } } } } } } } }
     }
   }
 }`;
 const STATES = ["OPEN", "CLOSED", "MERGED"];
 const MERGEABLE = ["MERGEABLE", "CONFLICTING", "UNKNOWN"];
 const REVIEW_DECISIONS = ["APPROVED", "CHANGES_REQUESTED", "REVIEW_REQUIRED"];
-/** A reply that is not the shape the query asks for; the message names the field. */
-export class ReplyError extends Error {
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export function shown(value) {
-    return value === undefined ? "missing" : JSON.stringify(value);
-}
-/** The JSON object `reply` holds, the root its fields' paths start from; `what` names it in a problem. */
-export function rootOf(reply, what) {
-    let json;
-    try {
-        json = JSON.parse(reply);
-    }
-    catch {
-        throw new ReplyError(`${what} is not JSON`);
-    }
-    if (!isRecord(json)) {
-        throw new ReplyError(`${what} is not a JSON object`);
-    }
-    return { value: json, at: "" };
-}
-export function fieldOf(node, key) {
-    return { value: node.value[key], at: node.at === "" ? key : `${node.at}.${key}` };
-}
-export function object(value, at) {
-    if (!isRecord(value)) {
-        throw new ReplyError(`${at} is ${shown(value)}, not an object`);
-    }
-    return { value, at };
-}
-function child(node, key) {
-    const { value, at } = fieldOf(node, key);
-    return object(value, at);
-}
-function childOrNull(node, key) {
-    const { value, at } = fieldOf(node, key);
-    return value === null ? null : object(value, at);
-}
-export function string(node, key) {
-    const { value, at } = fieldOf(node, key);
-    if (typeof value !== "string") {
-        throw new ReplyError(`${at} is ${shown(value)}, not a string`);
-    }
-    return value;
-}
-function stringOrNull(node, key) {
-    return node.value[key] === null ? null : string(node, key);
-}
-function boolean(node, key) {
-    const { value, at } = fieldOf(node, key);
-    if (typeof value !== "boolean") {
-        throw new ReplyError(`${at} is ${shown(value)}, not a boolean`);
-    }
-    return value;
-}
-export function integer(node, key) {
-    const { value, at } = fieldOf(node, key);
-    if (typeof value !== "number" || !Number.isInteger(value)) {
-        throw new ReplyError(`${at} is ${shown(value)}, not an integer`);
-    }
-    return value;
-}
-function integerOrNull(node, key) {
-    const { value, at } = fieldOf(node, key);
-    if (value !== null && !Number.isInteger(value)) {
-        throw new ReplyError(`${at} is ${shown(value)}, not an integer or null`);
-    }
-    return typeof value === "number" ? value : null;
-}
-/** A time as GitHub writes it, ISO 8601; the decision reads it as one. */
-function time(node, key) {
-    const value = string(node, key);
-    if (Number.isNaN(Date.parse(value))) {
-        throw new ReplyError(`${fieldOf(node, key).at} is ${shown(value)}, not a time`);
-    }
-    return value;
-}
-function timeOrNull(node, key) {
-    return node.value[key] === null ? null : time(node, key);
-}
-function isOneOf(values, value) {
-    return values.some((known) => known === value);
-}
-function oneOf(node, key, values) {
-    const { value, at } = fieldOf(node, key);
-    if (!isOneOf(values, value)) {
-        throw new ReplyError(`${at} is ${shown(value)}, not one of ${values.join(", ")}`);
-    }
-    return value;
-}
-/** The objects of a connection's `nodes`. */
-function nodes(node, key) {
-    const { value, at } = fieldOf(child(node, key), "nodes");
-    if (!Array.isArray(value)) {
-        throw new ReplyError(`${at} is ${shown(value)}, not a list`);
-    }
-    return value.map((item, index) => object(item, `${at}[${index}]`));
-}
-/** Whether a connection has more nodes after the ones the reply holds. */
-function hasMore(node, key) {
-    return boolean(child(child(node, key), "pageInfo"), "hasNextPage");
-}
-/** The first object of a connection's `nodes`; an empty connection does not parse. */
-function firstNode(node, key) {
-    const [first] = nodes(node, key);
-    if (first === undefined) {
-        throw new ReplyError(`${node.at}.${key}.nodes is empty`);
-    }
-    return first;
-}
 const FAIL = new Set(["ERROR", "FAILURE", "TIMED_OUT", "ACTION_REQUIRED", "CANCELLED", "STARTUP_FAILURE"]);
 const SKIPPING = new Set(["SKIPPED", "NEUTRAL"]);
 /** A check's bucket as `gh pr checks` sorts it: every word not passed, failed or skipped is pending. */
@@ -191,6 +91,23 @@ function checkOf(context, repo) {
     }
     throw new ReplyError(`${context.at} is neither a CheckRun nor a StatusContext`);
 }
+/**
+ * The head's checks as the rollup lists them. With more past its first 50, the review status is read by
+ * its name too, so whether the head is reviewed never hangs on where the rollup lists it.
+ */
+function checksOf(commit, repo) {
+    const rollup = childOrNull(commit, "statusCheckRollup");
+    if (rollup === null) {
+        return [];
+    }
+    const listed = nodes(rollup, "contexts").map((context) => checkOf(context, repo));
+    if (!hasMore(rollup, "contexts") || listed.some(({ name }) => name === REVIEW)) {
+        return listed;
+    }
+    const status = childOrNull(commit, "status");
+    const review = status === null ? null : childOrNull(status, "context");
+    return review === null ? listed : [...listed, checkOf(review, repo)];
+}
 /** A thread by its opening comment; a deleted account's comment has no author and reads as GitHub's ghost. */
 function threadOf(thread) {
     const first = firstNode(thread, "comments");
@@ -237,31 +154,43 @@ function historyOf(pr) {
     });
 }
 /**
- * The last commit before `head` a Review read, the history oldest first. A read mark with only merges
- * after it is passed over: no fix answers its Findings yet, and a Review from it would read only the
- * base's changes, so the Review reads from the read before it and finds them again.
+ * The commits a force push left behind: the head, then down its first parents within the history the
+ * read holds of it. A merge's first parent is the branch, so the walk stays off the base's side.
  */
-function lastReadOf(history, head) {
-    const commits = history.map(({ oid, posted, merge }) => ({
-        oid,
-        read: oid === head || posted === "off" ? null : posted,
-        merge
-    }));
-    const mergesOnlyAfter = (index) => commits.slice(index + 1).every(({ merge }) => merge);
-    const index = commits.findLastIndex(({ read }, at) => read === "clean" || (read === "findings" && !mergesOnlyAfter(at)));
-    const last = commits[index];
-    if (last === undefined) {
-        return null;
+function lineOf(left) {
+    const held = new Map(nodes(left, "history").map((commit) => [string(commit, "oid"), commit]));
+    const line = [];
+    let commit = held.get(string(left, "oid"));
+    while (commit !== undefined && line.length < held.size) {
+        line.push({ oid: string(commit, "oid"), posted: postedOn(commit) });
+        const [parent] = nodes(commit, "parents");
+        commit = parent === undefined ? undefined : held.get(string(parent, "oid"));
     }
-    return {
-        commit: last.oid,
-        clean: last.read === "clean",
-        mergesOnly: mergesOnlyAfter(index),
-        merges: commits.slice(index + 1).some(({ merge }) => merge)
-    };
+    return line;
 }
 /**
- * Whether a non-merge commit follows `commit` in the history, oldest first, as `lastReadOf` judges a read
+ * The commits the force pushes left behind, newest push first, each once and none the history still
+ * holds: a line stops where it meets the history, as under an amend, or a newer push's line, and forks
+ * where the commit it meets does.
+ */
+function leftBehindOf(pr, history) {
+    const forks = new Map(history.map(({ oid }, index) => [oid, index]));
+    const left = [];
+    for (const event of nodes(pr, "rewritten").toReversed()) {
+        const head = childOrNull(event, "beforeCommit");
+        const line = head === null ? [] : lineOf(head);
+        const met = line.findIndex(({ oid }) => forks.has(oid));
+        const meets = line[met];
+        const forksAt = meets === undefined ? -1 : (forks.get(meets.oid) ?? -1);
+        for (const commit of meets === undefined ? line : line.slice(0, met)) {
+            forks.set(commit.oid, forksAt);
+            left.push({ ...commit, forksAt });
+        }
+    }
+    return left;
+}
+/**
+ * Whether a non-merge commit follows `commit` in the history, oldest first, as the standing judges a read
  * mark. A commit outside the history, after a force-push or past the last 100, is not answered.
  */
 function answeredAfter(history, commit) {
@@ -281,11 +210,6 @@ function changeRequestsOf(pr, history) {
         };
     });
 }
-function readMarksOf(history) {
-    const success = history.findLastIndex(({ posted }) => posted === "clean" || posted === "off");
-    const count = history.slice(success + 1).filter(({ posted }) => posted === "findings").length;
-    return { count, since: history[success]?.oid ?? null };
-}
 /** The repository and number of the pull request whose URL `gh pr view --json url` printed. */
 export function parseView(reply) {
     const url = string(rootOf(reply, "the reply of gh pr view"), "url");
@@ -299,7 +223,10 @@ export function parseView(reply) {
 export function parseDefaultBranch(reply) {
     return string(child(rootOf(reply, "the reply of gh repo view"), "defaultBranchRef"), "name");
 }
-/** The state of the pull request in `reply`, the text `gh api graphql` printed for QUERY on `repo`. */
+/**
+ * The pull request in `reply`, the text `gh api graphql` printed for QUERY on `repo`, and the history the
+ * Review's standing at its head is read from.
+ */
 export function parsePr(reply, repo) {
     const pr = child(child(child(rootOf(reply, "the reply"), "data"), "repository"), "pullRequest");
     const commit = child(firstNode(pr, "commits"), "commit");
@@ -307,9 +234,9 @@ export function parsePr(reply, repo) {
     const mergeCommit = childOrNull(pr, "mergeCommit");
     const head = string(pr, "headRefOid");
     const baseRef = childOrNull(pr, "baseRef");
-    const history = historyOf(pr);
+    const commits = historyOf(pr);
     const [ready] = nodes(pr, "ready");
-    return {
+    const parsed = {
         url: string(pr, "url"),
         repo,
         number: integer(pr, "number"),
@@ -328,17 +255,17 @@ export function parsePr(reply, repo) {
         base: string(pr, "baseRefName"),
         baseOid: baseRef === null ? string(pr, "baseRefOid") : string(child(baseRef, "target"), "oid"),
         mergeCommit: mergeCommit === null ? null : string(mergeCommit, "oid"),
-        checks: rollup === null ? [] : nodes(rollup, "contexts").map((context) => checkOf(context, repo)),
+        checks: checksOf(commit, repo),
         unresolvedThreads: nodes(pr, "reviewThreads")
             .filter((thread) => !boolean(thread, "isResolved") && !boolean(thread, "isOutdated"))
             .map(threadOf),
-        changeRequests: changeRequestsOf(pr, history),
+        changeRequests: changeRequestsOf(pr, commits),
         cutOff: [
             ...(rollup !== null && hasMore(rollup, "contexts") ? [`the first ${CHECKS_READ} checks`] : []),
             ...(hasMore(pr, "reviewThreads") ? [`the first ${THREADS_READ} threads`] : [])
         ],
-        commits: history.map(({ oid }) => oid),
-        lastRead: lastReadOf(history, head),
-        marks: readMarksOf(history)
+        commits: commits.map(({ oid }) => oid)
     };
+    const history = { commits, leftBehind: leftBehindOf(pr, commits), head, base: parsed.baseOid };
+    return { pr: parsed, history };
 }

package/dist/pr/upstream.d.ts

@@ -1,11 +1,6 @@
 import type { PrState } from "./state.ts";
-/**
- * The remote branch name `branch` tracks, when it differs from `branch`. Read from the config, so it holds
- * after the remote deleted the branch.
- */
-export declare function upstreamName(root: string, branch: string): string | undefined;
 /** Whether `pr`'s commits hold `head`, so the head is on GitHub whatever became of the upstream. */
-export declare function holds(pr: PrState, head: string | null): boolean;
+export declare function holds(pr: Pick<PrState, "commits">, head: string | null): boolean;
 /** The checked-out branch at `root`, its head commit, and the other name its upstream gives. */
 export type RenamedUpstream = {
     branch: string;

package/dist/pr/upstream.js

@@ -1,12 +1,12 @@
 // A branch's upstream, read from git, for a branch pushed under another name: gh resolves
 // its pull request neither through `@{push}` nor by the local name, so `pr ship` and recap ask by the name
 // the upstream gives, and take that pull request only when its commits hold the local head.
-import { asked } from "../working-tree.js";
+import { asked } from "../git.js";
 /**
  * The remote branch name `branch` tracks, when it differs from `branch`. Read from the config, so it holds
  * after the remote deleted the branch.
  */
-export function upstreamName(root, branch) {
+function upstreamName(root, branch) {
     const remote = asked(root, ["config", "--get", `branch.${branch}.remote`]);
     const merge = asked(root, ["config", "--get", `branch.${branch}.merge`]);
     if (remote === undefined || remote === "." || merge === undefined || !merge.startsWith("refs/heads/")) {

package/dist/primitives-diff.js

@@ -4,7 +4,7 @@
 import { resolveConfig } from "./agentic-config.js";
 import { parseCatalogue, primitivesNaming } from "./catalogue.js";
 import { catalogueFile } from "./checks/primitives.js";
-import { asked, git } from "./working-tree.js";
+import { asked, git } from "./git.js";
 const CLASSES = ["removes", "adds", "extends"];
 const REMEDIES = {
     missing: "create it, or point gate.checks.primitives.file at the catalogue",