dw-sdlc 0.9.0 → 0.11.0

package/dist/pr/delta.js

@@ -0,0 +1,60 @@
+// GitHub's compare of two commits, read two ways: whether a head carries the Review of an earlier commit,
+// the pull request's own changes from the base the same at both, since a merge of the base in adds none
+// of its own; and the files a Review would read, with their changed lines, for `pr.review: auto`.
+import { fieldOf, integer, object, ReplyError, rootOf, shown, string } from "./state.js";
+/** GitHub's compare lists at most this many files; one that lists as many may hold back the rest. */
+const FILE_LIMIT = 300;
+/** The gh arguments of the compare from `from` to `commit`, the files on its one page. */
+export function compareArgs(repo, from, commit) {
+    return ["api", `repos/${repo}/compare/${from}...${commit}?per_page=1`];
+}
+/** The files a compare reply lists. */
+function filesOf(reply) {
+    const { value, at } = fieldOf(rootOf(reply, "the compare"), "files");
+    if (!Array.isArray(value)) {
+        throw new ReplyError(`${at} is ${shown(value)}, not a list`);
+    }
+    return value.map((item, index) => object(item, `${at}[${index}]`));
+}
+/** How many commits of the compare's base its head lacks: 0 when the head carries all of it. */
+export function behindOf(reply) {
+    return integer(rootOf(reply, "the compare"), "behind_by");
+}
+/** A field the compare may leave out, as a file's patch or its previous name. */
+function optional(file, key) {
+    return file.value[key] === undefined || file.value[key] === null ? null : string(file, key);
+}
+/**
+ * A file's own change: its status, its names and the lines its patch adds and removes, in order,
+ * without the hunk headers and context a moved base shifts; null when the compare shows no patch.
+ */
+function changeOf(file) {
+    const names = [string(file, "filename"), string(file, "status"), optional(file, "previous_filename")];
+    const patch = optional(file, "patch");
+    if (patch === null) {
+        return null;
+    }
+    return JSON.stringify([...names, patch.split("\n").filter((line) => /^[-+\\]/.test(line))]);
+}
+/** The own changes a compare reply lists, file by file; null when it cannot show them whole. */
+export function changesOf(reply) {
+    const changes = filesOf(reply).map(changeOf);
+    const whole = changes.filter((change) => change !== null);
+    return changes.length >= FILE_LIMIT || whole.length < changes.length ? null : whole;
+}
+/** The files a compare reply lists with their changed lines; `unsized` when it may hold some back. */
+export function changedOf(reply) {
+    const files = filesOf(reply).map((file) => ({
+        path: string(file, "filename"),
+        previous: optional(file, "previous_filename"),
+        lines: optional(file, "patch") === null ? null : integer(file, "additions") + integer(file, "deletions")
+    }));
+    return files.length >= FILE_LIMIT ? "unsized" : files;
+}
+/** Whether the own changes at the head are those at the reviewed commit; unknown changes never are. */
+export function sameChanges(then, now) {
+    if (then === null || now === null) {
+        return false;
+    }
+    return JSON.stringify(then.toSorted()) === JSON.stringify(now.toSorted());
+}

package/dist/pr/read.d.ts

@@ -1,5 +1,5 @@
 import { type PrState } from "./state.ts";
-/** What stops a pr command before it answers: exit 2, the problem and its remedy on one line. */
+/** What stops a pr command or recap before it answers: exit 2, the problem and its remedy on one line. */
 export declare class CannotRun extends Error {
     remedy: string;
     constructor(message: string, remedy: string);
@@ -18,7 +18,18 @@ export declare function gh(args: string[]): {
     stdout: string;
     stderr: string;
 };
-/** The state of the pull request `named`; `command`, as `pr ship`, names the call in a remedy. */
-export declare function read(named: Named, command: string): PrState;
+/**
+ * The state of the pull request `named`; `command`, as `pr ship`, names the call in a remedy. With
+ * `sized`, as `pr.review: auto` needs, the read sizes the changes a Review would read.
+ */
+export declare function read(named: Named, command: string, sized: boolean): PrState;
+/** The state of the current branch's pull request, open or not, or null when gh finds none. */
+export declare function readBranch(sized: boolean): PrState | null;
+/** The default branch of the repository gh resolves from the current directory. */
+export declare function defaultBranch(): string;
+/** The time the decision reads: DW_SDLC_NOW, an ISO 8601 time a test sets, else the system clock. */
+export declare function now(): number;
 /** The state of `pr` once more, after an action the script performed on it: the same pull request. */
-export declare function readAgain(pr: PrState): PrState;
+export declare function readAgain(pr: PrState, sized: boolean): PrState;
+/** Whether the head of `after` carries the base `before` read: the compare shows it behind by none. */
+export declare function carriesBase(before: PrState, after: PrState): boolean;

package/dist/pr/read.js

@@ -1,8 +1,10 @@
-// The read both pr commands make: gh as a child process, its auth on the host gh api reads from, the
-// pull request a command names, and that pull request's state from one GraphQL request.
+// The read the pr commands and recap make: gh as a child process, its auth, the pull request a command names,
+// its state from one GraphQL request with the compares that tell whether its head carries an earlier Review
+// and that size its changes, and beside them the default branch and the clock the decision reads.
 import { spawnSync } from "node:child_process";
-import { parsePr, parseView, QUERY, ReplyError } from "./state.js";
-/** What stops a pr command before it answers: exit 2, the problem and its remedy on one line. */
+import { behindOf, changedOf, changesOf, compareArgs, sameChanges } from "./delta.js";
+import { awaitsReview, parseDefaultBranch, parsePr, parseView, QUERY, ReplyError } from "./state.js";
+/** What stops a pr command or recap before it answers: exit 2, the problem and its remedy on one line. */
 export class CannotRun extends Error {
     remedy;
     constructor(message, remedy) {
@@ -15,7 +17,8 @@ const REMEDIES = {
     auth: "run gh auth login, or set GH_TOKEN",
     target: "check the number, or name the repository with -R owner/name",
     read: "check gh auth status and the network, then call again",
-    reply: "gh answered a shape dw-sdlc does not read; report it with the output of gh --version"
+    reply: "gh answered a shape dw-sdlc does not read; report it with the output of gh --version",
+    clock: "unset it: it stands in for the clock in tests"
 };
 /** The problem with `<n>` or `-R` as given on a command line, if there is one. */
 export function namedProblem(number, repo) {
@@ -74,22 +77,101 @@ function targetOf({ number, repo }, command) {
     }
     return parseOrCannotRun(() => parseView(view.stdout));
 }
-/** The state of the pull request `named`; `command`, as `pr ship`, names the call in a remedy. */
-export function read(named, command) {
+function requireAuth() {
     // The host gh api reads from: an account on any other host has no say in this call.
     const host = process.env.GH_HOST?.trim() || "github.com";
     const auth = gh(["auth", "status", "--active", "--hostname", host]);
     if (auth.status !== 0) {
         throw new CannotRun(`gh auth status failed: ${authProblem(auth.stderr)}`, REMEDIES.auth);
     }
-    return query(targetOf(named, command));
+}
+/**
+ * The state of the pull request `named`; `command`, as `pr ship`, names the call in a remedy. With
+ * `sized`, as `pr.review: auto` needs, the read sizes the changes a Review would read.
+ */
+export function read(named, command, sized) {
+    requireAuth();
+    return query(targetOf(named, command), sized);
+}
+/** The state of the current branch's pull request, open or not, or null when gh finds none. */
+export function readBranch(sized) {
+    requireAuth();
+    const view = gh(["pr", "view", "--json", "url"]);
+    if (view.status === 0) {
+        return query(parseOrCannotRun(() => parseView(view.stdout)), sized);
+    }
+    if (said(view.stderr).startsWith("no pull requests found")) {
+        return null;
+    }
+    throw new CannotRun(`gh pr view failed: ${said(view.stderr)}`, REMEDIES.read);
+}
+/** The default branch of the repository gh resolves from the current directory. */
+export function defaultBranch() {
+    const view = gh(["repo", "view", "--json", "defaultBranchRef"]);
+    if (view.status !== 0) {
+        throw new CannotRun(`gh repo view failed: ${said(view.stderr)}`, REMEDIES.read);
+    }
+    return parseOrCannotRun(() => parseDefaultBranch(view.stdout));
+}
+/** The time the decision reads: DW_SDLC_NOW, an ISO 8601 time a test sets, else the system clock. */
+export function now() {
+    const given = process.env.DW_SDLC_NOW?.trim();
+    if (given === undefined || given === "") {
+        return Date.now();
+    }
+    const time = Date.parse(given);
+    if (Number.isNaN(time)) {
+        throw new CannotRun(`DW_SDLC_NOW is ${JSON.stringify(given)}, not an ISO 8601 time`, REMEDIES.clock);
+    }
+    return time;
 }
 /** The state of `pr` once more, after an action the script performed on it: the same pull request. */
-export function readAgain(pr) {
-    return query(pr);
+export function readAgain(pr, sized) {
+    return query(pr, sized);
+}
+/** The reply of the compare from `from` to `commit`; `what` names it when gh refuses it. */
+function compared(pr, from, commit, what) {
+    const reply = gh(compareArgs(pr.repo, from, commit));
+    if (reply.status !== 0) {
+        throw new CannotRun(`${pr.repo}#${pr.number}: ${what}: ${said(reply.stderr)}`, REMEDIES.read);
+    }
+    return reply.stdout;
+}
+/** Whether the head of `after` carries the base `before` read: the compare shows it behind by none. */
+export function carriesBase(before, after) {
+    const reply = compared(after, before.baseOid, after.head, `the compare with ${before.baseOid.slice(0, 7)}`);
+    return parseOrCannotRun(() => behindOf(reply)) === 0;
+}
+/** The own changes of `pr` at `commit`, from the compare with its base; null when it cannot show them whole. */
+function ownChanges(pr, commit) {
+    const reply = compared(pr, pr.baseOid, commit, `the compare with ${commit.slice(0, 7)}`);
+    return parseOrCannotRun(() => changesOf(reply));
+}
+/**
+ * `pr` and whether its head carries the last reviewed commit's status: only merges since it, and the
+ * same own changes at both. The compares run only when a Review awaits the head.
+ */
+function withCarried(pr) {
+    const last = pr.lastReviewed;
+    if (last === null || !last.mergesOnly || pr.state !== "OPEN" || !awaitsReview(pr)) {
+        return { ...pr, carried: false };
+    }
+    return { ...pr, carried: sameChanges(ownChanges(pr, last.commit), ownChanges(pr, pr.head)) };
+}
+/**
+ * `pr` and, when `sized` and a Review awaits a head that carries none, the files the Review would read:
+ * the compare from the last reviewed commit, else from the base, to the head.
+ */
+function withChanged(pr, sized) {
+    if (!sized || pr.carried || pr.state !== "OPEN" || !awaitsReview(pr)) {
+        return { ...pr, changed: null };
+    }
+    const from = pr.lastReviewed?.commit ?? pr.baseOid;
+    const reply = compared(pr, from, pr.head, `the compare of ${from.slice(0, 7)}...${pr.head.slice(0, 7)}`);
+    return { ...pr, changed: parseOrCannotRun(() => changedOf(reply)) };
 }
-/** The state of pull request `number` of `repo`, from one GraphQL request. */
-function query({ repo, number }) {
+/** The state of pull request `number` of `repo`, from one GraphQL request and the compares a Review needs. */
+function query({ repo, number }, sized) {
     const [owner = "", name = ""] = repo.split("/");
     const reply = gh([
         "api",
@@ -108,5 +190,5 @@ function query({ repo, number }) {
         const remedy = problem.startsWith("Could not resolve to a") ? REMEDIES.target : REMEDIES.read;
         throw new CannotRun(`${repo}#${number}: ${problem}`, remedy);
     }
-    return parseOrCannotRun(() => parsePr(reply.stdout, repo));
+    return withChanged(withCarried(parseOrCannotRun(() => parsePr(reply.stdout, repo))), sized);
 }

package/dist/pr/route.d.ts

@@ -0,0 +1,14 @@
+import type { ReviewDepth } from "../agentic-config.ts";
+import type { ChangedFile } from "./state.ts";
+/** A routed depth, and under off why no one reads the changes, as the status the script posts says. */
+export type Routed = {
+    depth: Exclude<ReviewDepth, "off">;
+} | {
+    depth: "off";
+    why: string;
+};
+/**
+ * The depth the rules route `changed` to. A change not read or not sized reads in full, as does a file
+ * outside lockfiles the compare shows no patch for.
+ */
+export declare function route(changed: ChangedFile[] | "unsized" | null): Routed;

package/dist/pr/route.js

@@ -0,0 +1,52 @@
+// The built-in rules `pr.review: auto` routes a Review depth by, from the files the Review would read:
+// lockfiles alone are off; a workflow file, more than 100 changed lines outside lockfiles, or a change
+// the compare cannot size is full; the rest is light. No config key moves them.
+/** The lockfiles a package manager writes, by file name in any directory. */
+const LOCKFILES = new Set([
+    "pnpm-lock.yaml",
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+    "yarn.lock",
+    "bun.lock",
+    "bun.lockb",
+    "Gemfile.lock",
+    "Cargo.lock",
+    "poetry.lock",
+    "uv.lock",
+    "Pipfile.lock",
+    "composer.lock",
+    "go.sum",
+    "Podfile.lock",
+    "pubspec.lock",
+    "mix.lock",
+    "flake.lock"
+]);
+/** Where GitHub Actions reads its workflows: a change there runs with the repository's secrets. */
+const WORKFLOWS = ".github/workflows/";
+/** The most changed lines outside lockfiles a light Review reads. */
+const LINE_LIMIT = 100;
+function isLockfile(path) {
+    return LOCKFILES.has(path.slice(path.lastIndexOf("/") + 1));
+}
+function isWorkflow({ path, previous }) {
+    return [path, previous].some((name) => name?.startsWith(WORKFLOWS) === true);
+}
+/**
+ * The depth the rules route `changed` to. A change not read or not sized reads in full, as does a file
+ * outside lockfiles the compare shows no patch for.
+ */
+export function route(changed) {
+    if (changed === null || changed === "unsized") {
+        return { depth: "full" };
+    }
+    const code = changed.filter((file) => !isLockfile(file.path));
+    if (changed.length > 0 && code.length === 0) {
+        return { depth: "off", why: "lockfiles only" };
+    }
+    const lines = code.map((file) => file.lines);
+    if (changed.some(isWorkflow) || lines.includes(null)) {
+        return { depth: "full" };
+    }
+    const total = lines.reduce((sum, count) => sum + (count ?? 0), 0);
+    return { depth: total > LINE_LIMIT ? "full" : "light" };
+}

package/dist/pr/state.d.ts

@@ -1,4 +1,8 @@
-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 baseRefName\n      viewerDidAuthor mergeCommit { oid }\n      reviewThreads(first: 100) { 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) { nodes {\n          ... on CheckRun { name status conclusion detailsUrl startedAt isRequired(pullRequestNumber: $number) }\n          ... on StatusContext { context state targetUrl createdAt isRequired(pullRequestNumber: $number) } } } } } } }\n    }\n  }\n}";
+/** 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. */
+export declare const OFF_PREFIX = "off:";
+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 baseRefName baseRefOid\n      viewerDidAuthor mergeCommit { oid }\n      reviewThreads(first: 100) { 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) { 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 type Bucket = "pass" | "fail" | "pending" | "skipping";
 export type CiCheck = {
     name: string;
@@ -36,19 +40,65 @@ export type PrState = {
     headCommittedAt: string;
     branch: string;
     base: string;
+    /** The commit the base branch points at. */
+    baseOid: string;
     mergeCommit: string | null;
     checks: CiCheck[];
     /** The threads neither resolved nor outdated. */
     unresolvedThreads: Thread[];
+    /** The oids of the pull request's last 100 commits, oldest first, the head last. */
+    commits: string[];
+    /** The last commit before the head with a review success not posted under off, of the last 100. */
+    lastReviewed: LastReviewed | null;
+    /** Whether the head carries the success of `lastReviewed`: the read decides it from two compares. */
+    carried: boolean;
+    /**
+     * The files a Review would read, from `lastReviewed` 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;
+};
+/**
+ * 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 reviewed commit, and whether every commit after it, the head included, is a merge. */
+export type LastReviewed = {
+    commit: string;
+    mergesOnly: boolean;
 };
 /** 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 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. */
 export declare function parseView(reply: string): {
     repo: string;
     number: number;
 };
+/** 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): PrState;
+export declare function parsePr(reply: string, repo: string): Omit<PrState, "carried" | "changed">;
 export {};

package/dist/pr/state.js

@@ -1,9 +1,13 @@
 // 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.
+/** 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. */
+export const OFF_PREFIX = "off:";
 export const QUERY = `query($owner: String!, $name: String!, $number: Int!) {
   repository(owner: $owner, name: $name) {
     pullRequest(number: $number) {
-      url number state isDraft mergeable mergeStateStatus reviewDecision headRefOid headRefName baseRefName
+      url number state isDraft mergeable mergeStateStatus reviewDecision headRefOid headRefName baseRefName baseRefOid
       viewerDidAuthor mergeCommit { oid }
       reviewThreads(first: 100) { nodes { id isResolved isOutdated path line
         comments(first: 1) { nodes { author { login } body } }
@@ -12,6 +16,7 @@ export const QUERY = `query($owner: String!, $name: String!, $number: Int!) {
         contexts(first: 50) { nodes {
           ... on CheckRun { name status conclusion detailsUrl startedAt isRequired(pullRequestNumber: $number) }
           ... on StatusContext { context state targetUrl createdAt isRequired(pullRequestNumber: $number) } } } } } } }
+      history: commits(last: 100) { nodes { commit { oid parents { totalCount } status { context(name: "${REVIEW}") { state description } } } } }
     }
   }
 }`;
@@ -24,11 +29,11 @@ export class ReplyError extends Error {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function shown(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. */
-function rootOf(reply, what) {
+export function rootOf(reply, what) {
     let json;
     try {
         json = JSON.parse(reply);
@@ -41,10 +46,10 @@ function rootOf(reply, what) {
     }
     return { value: json, at: "" };
 }
-function fieldOf(node, key) {
+export function fieldOf(node, key) {
     return { value: node.value[key], at: node.at === "" ? key : `${node.at}.${key}` };
 }
-function object(value, at) {
+export function object(value, at) {
     if (!isRecord(value)) {
         throw new ReplyError(`${at} is ${shown(value)}, not an object`);
     }
@@ -58,7 +63,7 @@ function childOrNull(node, key) {
     const { value, at } = fieldOf(node, key);
     return value === null ? null : object(value, at);
 }
-function string(node, key) {
+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`);
@@ -75,7 +80,7 @@ function boolean(node, key) {
     }
     return value;
 }
-function integer(node, key) {
+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`);
@@ -182,6 +187,31 @@ function threadOf(thread) {
         lastByViewer: boolean(firstNode(thread, "latest"), "viewerDidAuthor")
     };
 }
+/** The viewer's own pull request without a review success on its head: the one a Review reads. */
+export function awaitsReview(pr) {
+    return pr.viewerDidAuthor && !pr.checks.some((check) => check.name === REVIEW && check.bucket === "pass");
+}
+/** A commit whose review success says someone read it: a status posted under off never does. */
+function isReviewed(commit) {
+    const status = childOrNull(commit, "status");
+    const context = status === null ? null : childOrNull(status, "context");
+    if (context === null || string(context, "state") !== "SUCCESS") {
+        return false;
+    }
+    return !(stringOrNull(context, "description") ?? "").startsWith(OFF_PREFIX);
+}
+/** The last commit before `head` that `isReviewed` takes, the history oldest first. */
+function lastReviewedOf(pr, head) {
+    const commits = nodes(pr, "history").map((node) => child(node, "commit"));
+    const index = commits.findLastIndex((commit) => string(commit, "oid") !== head && isReviewed(commit));
+    const reviewed = commits[index];
+    if (reviewed === undefined) {
+        return null;
+    }
+    const after = commits.slice(index + 1);
+    const mergesOnly = after.every((commit) => integer(child(commit, "parents"), "totalCount") > 1);
+    return { commit: string(reviewed, "oid"), mergesOnly };
+}
 /** 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");
@@ -191,12 +221,17 @@ export function parseView(reply) {
     }
     return { repo, number: Number(number) };
 }
+/** The default branch of the repository whose `gh repo view --json defaultBranchRef` printed `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`. */
 export function parsePr(reply, repo) {
     const pr = child(child(child(rootOf(reply, "the reply"), "data"), "repository"), "pullRequest");
     const commit = child(firstNode(pr, "commits"), "commit");
     const rollup = childOrNull(commit, "statusCheckRollup");
     const mergeCommit = childOrNull(pr, "mergeCommit");
+    const head = string(pr, "headRefOid");
     return {
         url: string(pr, "url"),
         repo,
@@ -207,14 +242,17 @@ export function parsePr(reply, repo) {
         mergeStateStatus: string(pr, "mergeStateStatus"),
         reviewDecision: pr.value.reviewDecision === null ? null : oneOf(pr, "reviewDecision", REVIEW_DECISIONS),
         viewerDidAuthor: boolean(pr, "viewerDidAuthor"),
-        head: string(pr, "headRefOid"),
+        head,
         headCommittedAt: time(commit, "committedDate"),
         branch: string(pr, "headRefName"),
         base: string(pr, "baseRefName"),
+        baseOid: string(pr, "baseRefOid"),
         mergeCommit: mergeCommit === null ? null : string(mergeCommit, "oid"),
         checks: rollup === null ? [] : nodes(rollup, "contexts").map((context) => checkOf(context, repo)),
         unresolvedThreads: nodes(pr, "reviewThreads")
             .filter((thread) => !boolean(thread, "isResolved") && !boolean(thread, "isOutdated"))
-            .map(threadOf)
+            .map(threadOf),
+        commits: nodes(pr, "history").map((node) => string(child(node, "commit"), "oid")),
+        lastReviewed: lastReviewedOf(pr, head)
     };
 }

package/dist/setup-worker.d.ts

@@ -0,0 +1,11 @@
+import { type JsonObject } from "./json-text.ts";
+/** The `worker` block a local file holds, carried through on every run, `--force` included. */
+export declare function keptWorker(existing: unknown): JsonObject | undefined;
+/**
+ * The `worker` block to write: the one the file holds, with `command` added when it has none and `cswap`
+ * is on PATH. A command already there, whatever it holds, stays; without `cswap` nothing is added.
+ */
+export declare function pinnedWorker(kept: JsonObject | undefined, pathVariable: string | undefined): {
+    worker: JsonObject | undefined;
+    detail?: string;
+};

package/dist/setup-worker.js

@@ -0,0 +1,37 @@
+// The `worker` block of the machine's local layer: the command a Worker starts with, which the setup
+// writes once when `cswap` is on PATH so no prompt ever carries it.
+import { accessSync, constants, statSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { isObject } from "./json-text.js";
+/** The command that starts a Worker on the account `cswap` maps to the repository, prompts bypassed. */
+const CSWAP_WORKER_COMMAND = "cswap run -- --dangerously-skip-permissions";
+/** Whether an executable file `name` sits in a directory of `pathVariable`, a PATH as the shell reads it. */
+function onPath(name, pathVariable) {
+    return (pathVariable ?? "").split(delimiter).some((dir) => {
+        if (dir === "") {
+            return false;
+        }
+        try {
+            const file = join(dir, name);
+            accessSync(file, constants.X_OK);
+            return statSync(file).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** The `worker` block a local file holds, carried through on every run, `--force` included. */
+export function keptWorker(existing) {
+    return isObject(existing) && isObject(existing.worker) ? existing.worker : undefined;
+}
+/**
+ * The `worker` block to write: the one the file holds, with `command` added when it has none and `cswap`
+ * is on PATH. A command already there, whatever it holds, stays; without `cswap` nothing is added.
+ */
+export function pinnedWorker(kept, pathVariable) {
+    if ((kept !== undefined && "command" in kept) || !onPath("cswap", pathVariable)) {
+        return { worker: kept };
+    }
+    return { worker: { ...kept, command: CSWAP_WORKER_COMMAND }, detail: `worker.command: ${CSWAP_WORKER_COMMAND}` };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dw-sdlc",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "The Gate and the agentic config of a repository: the dw-sdlc bin with the Gate, the setup, the doctor, the config check, the Sync and setup of References, and the Ship script that drives a pull request to merged; the resolver of the config's layers, its JSON Schema and the validator that reads it.",
   "license": "MIT",
   "repository": {