dw-mc 0.1.0 → 0.2.0

package/dist/bin.js

@@ -509,70 +509,6 @@ const textStoreFor = Effect.fn("store.textStoreFor")(function* (namespace) {
 /** The state directory on disk. */
 const layer$1 = Layer.unwrap(Effect.map(stateDirectory, (directory) => KeyValueStore.layerFileSystem(directory)));
 KeyValueStore.layerMemory;
-//#endregion
-//#region src/domain/reference.ts
-/** `owner/name#12`, or `12` on its own. */
-const spelled = /^(?:([^\s/]+\/[^\s/]+)#)?(\d+)$/;
-/**
-* A segment of nothing but dots, which no repository is called.
-*
-* The repository names a directory under the state directory before it names
-* anything else, so `../x` would be a way out of it.
-*/
-const onlyDots = /^\.+$/;
-/**
-* The pull request a reference names.
-*
-* A reference that spells its repository out is taken as it is, registered or
-* not: reviewing someone else's pull request is a thing to ask for, and the
-* settings a repository nothing registered gets are the global defaults.
-*/
-const resolve$1 = (text, registered) => {
-	const found = spelled.exec(text);
-	const number = found?.[2];
-	if (number === void 0) return {
-		_tag: "unreadable",
-		text
-	};
-	const spelledRepo = found?.[1];
-	if (spelledRepo !== void 0 && spelledRepo.split("/").some((segment) => onlyDots.test(segment))) return {
-		_tag: "unreadable",
-		text
-	};
-	const repo = spelledRepo ?? (registered.length === 1 ? registered[0] : void 0);
-	if (repo === void 0) return {
-		_tag: "ambiguous",
-		repos: registered
-	};
-	return {
-		_tag: "resolved",
-		repo,
-		number: Number(number)
-	};
-};
-//#endregion
-//#region src/cli/pr.ts
-/** The pull request a command acts on, named the way I actually type it. */
-const prArgument = Argument.String("pr").pipe(Argument.withDescription("The pull request, as 28 or owner/name#28"));
-/** What to say about a reference that named no one pull request. */
-const whyNothingNamed = (reference) => {
-	if (reference._tag === "unreadable") return `'${reference.text}' is not a pull request. Name one as 28, or as owner/name#28.`;
-	const example = `${reference.repos[0] ?? "owner/name"}#28`;
-	return reference.repos.length === 0 ? `No repositories are registered, so a number alone names nothing. Run dw-mc init inside a repository, or name the pull request as ${example}.` : `${reference.repos.length} repositories are registered, so a number alone could be any of them. Name the pull request as ${example}.`;
-};
-/** The pull request the argument names, or the sentence saying why it names none. */
-const named = (pr, registered) => {
-	const reference = resolve$1(pr, registered);
-	return reference._tag === "resolved" ? Effect.succeed(reference) : Effect.fail(new CliError.UserError({ cause: whyNothingNamed(reference) }));
-};
-/**
-* A domain guard's word, as the command's own failure.
-*
-* Every guard in the tool answers the same shape - the sentence saying why not,
-* or null - so turning that answer into a refusal is spelled once here rather
-* than beside each command that asks one.
-*/
-const refuse = (why) => why === null ? Effect.void : Effect.fail(new CliError.UserError({ cause: why }));
 new TextEncoder();
 /** A program that ran but ended badly. */
 var CommandFailed = class extends Schema.TaggedError()("CommandFailed", {
@@ -802,7 +738,7 @@ const Comments = Schema.fromJsonString(Schema.Array(Schema.Struct({
 		type: Schema.String
 	}))
 })));
-const comments = (label, path) => readJson(label, "gh", ["api", path], Comments).pipe(Effect.map((all) => all.flatMap((comment) => comment.user === null ? [] : [{
+const comments$1 = (label, path) => readJson(label, "gh", ["api", path], Comments).pipe(Effect.map((all) => all.flatMap((comment) => comment.user === null ? [] : [{
 	login: comment.user.login,
 	bot: comment.user.type === "Bot",
 	at: comment.created_at
@@ -819,7 +755,7 @@ const comments = (label, path) => readJson(label, "gh", ["api", path], Comments)
 */
 const prComments = Effect.fnUntraced(function* (repo, number) {
 	const page = "per_page=100";
-	const [conversation, onDiff] = yield* Effect.all([comments("api issue comments", `repos/${repo}/issues/${number}/comments?${page}`), comments("api review comments", `repos/${repo}/pulls/${number}/comments?${page}`)], { concurrency: 2 });
+	const [conversation, onDiff] = yield* Effect.all([comments$1("api issue comments", `repos/${repo}/issues/${number}/comments?${page}`), comments$1("api review comments", `repos/${repo}/pulls/${number}/comments?${page}`)], { concurrency: 2 });
 	return [...conversation, ...onDiff];
 });
 const Reviews = Schema.fromJsonString(Schema.Array(Schema.Struct({
@@ -932,198 +868,343 @@ const mergePr = Effect.fnUntraced(function* (repo, number) {
 	}));
 });
 //#endregion
-//#region src/adapters/ci.ts
-/**
-* What GitHub says about a pull request's checks, and the evidence a red one
-* is classified on. Every read here goes through the same `gh` the rest of the
-* tool does; what it owns is the checks, not the boundary.
-*/
-const failing = /* @__PURE__ */ new Set([
-	"FAILURE",
-	"TIMED_OUT",
-	"CANCELLED",
-	"STARTUP_FAILURE",
-	"ACTION_REQUIRED",
-	"ERROR"
+//#region src/adapters/conversation.ts
+const Actor = Schema.NullOr(Schema.Struct({
+	login: Schema.String,
+	__typename: Schema.String
+}));
+const Said = Schema.Struct({
+	author: Actor,
+	body: Schema.String,
+	createdAt: Schema.DateTimeUtcFromString
+});
+const Conversation = Schema.fromJsonString(Schema.Struct({ data: Schema.Struct({ repository: Schema.Struct({ pullRequest: Schema.Struct({
+	comments: Schema.Struct({ nodes: Schema.Array(Said) }),
+	reviews: Schema.Struct({ nodes: Schema.Array(Schema.Struct({
+		author: Actor,
+		body: Schema.String,
+		submittedAt: Schema.NullOr(Schema.DateTimeUtcFromString)
+	})) }),
+	reviewThreads: Schema.Struct({ nodes: Schema.Array(Schema.Struct({
+		isResolved: Schema.Boolean,
+		isOutdated: Schema.Boolean,
+		path: Schema.NullOr(Schema.String),
+		line: Schema.NullOr(Schema.Int),
+		comments: Schema.Struct({ nodes: Schema.Array(Said) })
+	})) })
+}) }) }) }));
+const remark = (said, at) => said.author === null || at === null || said.body.trim() === "" ? [] : [{
+	login: said.author.login,
+	bot: said.author.__typename === "Bot",
+	at,
+	body: said.body.trim()
+}];
+const byTime = (self, other) => DateTime.Order(self.at, other.at);
+/**
+* A pull request's whole conversation: the comments on it, the bodies of the
+* reviews, and every thread on the diff with whether it is settled.
+*
+* GraphQL rather than the two REST endpoints a sweep reads, because resolution
+* is not in REST at all: a review comment's payload carries `body`, `path`,
+* `line`, `diff_hunk` and `side`, and nothing saying whether somebody closed
+* the thread it belongs to. A thread that was settled a week ago is not
+* something to answer, so the state that says so has to arrive with it.
+*
+* The pull request's own comments and the reviews' bodies come back as one
+* strand under no path, in the order they were written: they are one
+* conversation as it happened, and which endpoint each line came from is an
+* accident of GitHub's model rather than anything to read.
+*
+* `__typename` is what says a bot is a bot, the way `user.type` does in REST.
+*/
+const prConversation = Effect.fnUntraced(function* (repo, number) {
+	const [owner = repo, name = repo] = repo.split("/");
+	const pr = (yield* readJson("api graphql", "gh", [
+		"api",
+		"graphql",
+		"-f",
+		`query=query($owner:String!,$name:String!,$number:Int!){
+        repository(owner:$owner,name:$name){
+          pullRequest(number:$number){
+            comments(last:100){nodes{author{login __typename} body createdAt}}
+            reviews(last:100){nodes{author{login __typename} body submittedAt}}
+            reviewThreads(last:100){nodes{
+              isResolved isOutdated path line
+              comments(first:100){nodes{author{login __typename} body createdAt}}
+            }}
+          }
+        }
+      }`,
+		"-F",
+		`owner=${owner}`,
+		"-F",
+		`name=${name}`,
+		"-F",
+		`number=${number}`
+	], Conversation)).data.repository.pullRequest;
+	const conversation = [...pr.comments.nodes.flatMap((it) => remark(it, it.createdAt)), ...pr.reviews.nodes.flatMap((it) => remark(it, it.submittedAt))].toSorted(byTime);
+	const threads = pr.reviewThreads.nodes.map((it) => ({
+		path: it.path,
+		line: it.line,
+		resolved: it.isResolved,
+		outdated: it.isOutdated,
+		comments: it.comments.nodes.flatMap((comment) => remark(comment, comment.createdAt)).toSorted(byTime)
+	}));
+	return [...conversation.length === 0 ? [] : [{
+		path: null,
+		line: null,
+		resolved: false,
+		outdated: false,
+		comments: conversation
+	}], ...threads];
+});
+//#endregion
+//#region src/domain/moment.ts
+const isLater = Order.isGreaterThan(DateTime.Order);
+/** Whether `self` happened after `other`, counting never as before anything. */
+const isAfter = (self, other) => Predicate.isNotNull(self) && (other === null || isLater(self, other));
+/** The later of the two. */
+const later = (self, other) => isAfter(self, other) ? self : other;
+/** Whether the two are the same moment, counting never as the same as never. */
+const isSame = (self, other) => self === null || other === null ? self === other : DateTime.Equivalence(self, other);
+/** The latest of many, or never when there are none. */
+const newest = (moments) => moments.reduce(later, null);
+//#endregion
+//#region src/domain/bucket.ts
+/** How far GitHub has got towards letting a tracked PR merge. */
+const Mergeability = Schema.Literals([
+	"mergeable",
+	"conflicting",
+	"unknown"
 ]);
-const running = /* @__PURE__ */ new Set([
-	"QUEUED",
-	"IN_PROGRESS",
-	"WAITING",
-	"PENDING",
-	"REQUESTED",
-	"EXPECTED"
+/** What the reviewers have decided, or that nobody is required to. */
+const ReviewDecision = Schema.Literals([
+	"approved",
+	"changes-requested",
+	"review-required",
+	"none"
+]);
+/** What CI says about the current head. */
+const ChecksState = Schema.Literals([
+	"green",
+	"red",
+	"pending",
+	"none"
 ]);
-const nameOf = (entry) => entry.name ?? entry.context ?? "";
-const checksThatCount = (entries, ignore) => (entries ?? []).filter((entry) => !ignore.includes(nameOf(entry)));
-const hasFailed = (entry) => failing.has(entry.conclusion ?? "") || failing.has(entry.state ?? "");
 /**
-* What the rollup comes to: red when anything failed, pending only while
-* nothing has failed yet, green when every check that counts has passed.
+* Everything the bucket rules are allowed to know about a tracked PR.
 *
-* `ci.ignore` names the checks that do not count towards green, so a check I
-* have decided to live with cannot hold a PR out of Ready.
+* It is a schema because a sweep writes it to the state directory and reads it
+* back on the next one: the same facts that decide a bucket are what a quiet PR
+* is recognised by.
 */
-const rollupState = (entries, ignore) => {
-	const checks = checksThatCount(entries, ignore);
-	if (checks.length === 0) return "none";
-	if (checks.some(hasFailed)) return "red";
-	if (checks.some((entry) => entry.status !== void 0 && entry.status !== "COMPLETED" || running.has(entry.state ?? ""))) return "pending";
-	return "green";
-};
+const Facts = Schema.Struct({
+	repo: Schema.String,
+	number: Schema.Int,
+	title: Schema.String,
+	url: Schema.String,
+	/** Shown, never acted on unless I ask. */
+	draft: Schema.Boolean,
+	/** The head commit every other fact here is about. */
+	head: Schema.String,
+	mergeable: Mergeability,
+	reviewDecision: ReviewDecision,
+	checks: ChecksState,
+	/** Why the flaky classifier excuses this red CI, or null where it does not. */
+	ciFlaky: Schema.NullOr(Schema.String),
+	/** The head a rebase onto the base conflicted at, or null where none has. */
+	rebaseConflictAt: Schema.NullOr(Schema.String),
+	/** The newest comment from a person who is not me, bots excluded. */
+	newestHumanCommentAt: Schema.NullOr(Schema.DateTimeUtcFromString),
+	myLastCommentAt: Schema.NullOr(Schema.DateTimeUtcFromString),
+	myLastCommitAt: Schema.NullOr(Schema.DateTimeUtcFromString),
+	/** The head a review run has already covered, or null where none has. */
+	reviewRunHead: Schema.NullOr(Schema.String),
+	/** Findings on this head that withhold the stamp, at the bar `stamp.blocks_on` sets. */
+	blockingFindings: Schema.Int
+});
+Schema.Literals([
+	"needs-me",
+	"needs-review-run",
+	"waiting-on-others",
+	"ready"
+]);
+/** The buckets in the order I act on them: the top of the table is my next move. */
+const order = [
+	"needs-me",
+	"needs-review-run",
+	"waiting-on-others",
+	"ready"
+];
 /**
-* The checks that failed and count, which are the ones there is a log to read.
+* Why a PR is mine to move when somebody has said something I have not
+* answered.
 *
-* `ci.ignore` is applied here as well as in the rollup: a check that cannot
-* hold a PR out of Ready is not one the classifier should be explaining either.
+* It is named because it is read twice: here, where it puts the PR in Needs me,
+* and by `dw-mc comments`, which says what settles that one branch of the
+* bucket. A sentence matched from the other side of the tool is a rule that
+* breaks on a reword.
 */
-const failedChecks = (entries, ignore) => checksThatCount(entries, ignore).filter(hasFailed);
+const unanswered = "a comment I have not answered";
 /**
-* What a check reports on, out of the URL it reports at.
-*
-* A check run details URL ends `/actions/runs/<run>/job/<job>`. The job id is
-* what the logs endpoint takes and the run id is what `gh run rerun` takes, so
-* the two ids the tool needs are the two halves of one URL and are read
-* together. A commit status points somewhere else entirely, which is null:
-* there is no log of ours to read and no run of ours to re-run.
+* The first of the rules that makes a PR mine to move, or null when none
+* does. The order is the order I would fix them in: a conflict makes every
+* other signal on the PR stale, and a red build is worth more than a comment.
 */
-const reportedAt = (detailsUrl) => {
-	const found = detailsUrl?.match(/\/actions\/runs\/(\d+)\/job\/(\d+)/);
-	return found?.[1] === void 0 || found[2] === void 0 ? null : {
-		run: found[1],
-		job: found[2]
-	};
+const needsMe = (facts) => {
+	if (facts.mergeable === "conflicting") return "merge conflict";
+	if (facts.rebaseConflictAt === facts.head) return "a rebase onto the base conflicted";
+	if (facts.checks === "red" && facts.ciFlaky === null) return "CI is red";
+	if (facts.reviewDecision === "changes-requested") return "changes requested";
+	if (facts.blockingFindings > 0) return `${facts.blockingFindings} blocking finding${facts.blockingFindings === 1 ? "" : "s"}`;
+	if (isAfter(facts.newestHumanCommentAt, later(facts.myLastCommentAt, facts.myLastCommitAt))) return unanswered;
+	return null;
 };
-const RepoDefaultBranch = Schema.fromJsonString(Schema.Struct({ defaultBranchRef: Schema.NullOr(Schema.Struct({ name: Schema.String })) }));
 /**
-* The branch a repository merges into, which is the one the first flaky signal
-* asks about. An empty repository has none, and `main` is the better guess than
-* failing the sweep over it.
+* What is actually true of a PR nothing is waiting on.
+*
+* Ready is reached by having no reason not to be, so the reason says only what
+* holds: a repository that requires no reviewer produces no approval, and a
+* pull request with no CI at all is not green.
+*
+* A red CI the classifier excused is said out loud, because GitHub does not
+* excuse it: the check is still red, and Ready is what `dw-mc merge` reads.
 */
-const defaultBranch = Effect.fnUntraced(function* (repo) {
-	return (yield* readJson("repo view defaultBranchRef", "gh", [
-		"repo",
-		"view",
-		repo,
-		"--json",
-		"defaultBranchRef"
-	], RepoDefaultBranch)).defaultBranchRef?.name ?? "main";
-});
-const Runs = Schema.fromJsonString(Schema.Array(Schema.Struct({ conclusion: Schema.String })));
-/** How far back to look for a run that reached a verdict at all. */
-const recentRuns = 5;
-/** `gh run list` reports a conclusion in lower case, unlike every check on a PR. */
-const failedRun = /* @__PURE__ */ new Set(["failure", "timed_out"]);
-/** A run that decided something. A skipped or cancelled run says nothing either way. */
-const verdicts = /* @__PURE__ */ new Set([
-	"failure",
-	"timed_out",
-	"success"
-]);
+const readyReason = (facts) => {
+	const held = [
+		facts.reviewDecision === "approved" ? "approved" : null,
+		facts.checks === "green" ? "green" : null,
+		facts.mergeable === "mergeable" ? "mergeable" : null
+	].filter((it) => it !== null);
+	const standing = held.length === 0 ? "nothing left to wait on" : held.join(", ");
+	return facts.checks === "red" && facts.ciFlaky !== null ? `${standing} (red CI called flaky: ${facts.ciFlaky})` : standing;
+};
 /**
-* Whether `workflow` is red on `branch` right now.
+* The bucket a tracked PR sits in, and the reason for it.
 *
-* The newest run that reached a verdict is the whole answer: a workflow that
-* broke last week and was fixed since is not red, and excusing a pull request
-* for it would hide a failure that is real. A handful of runs are asked for
-* because the newest ones are often skipped by a path filter.
-*/
-const workflowFailsOn = Effect.fnUntraced(function* (repo, branch, workflow) {
-	const newest = (yield* readJson("run list", "gh", [
-		"run",
-		"list",
-		"--repo",
-		repo,
-		"--branch",
-		branch,
-		"--workflow",
-		workflow,
-		"--limit",
-		String(recentRuns),
-		"--json",
-		"conclusion"
-	], Runs)).find((run) => verdicts.has(run.conclusion));
-	return newest !== void 0 && failedRun.has(newest.conclusion);
-});
-const PrFiles = Schema.fromJsonString(Schema.Struct({ files: Schema.Array(Schema.Struct({ path: Schema.String })) }));
-/** The repository paths a pull request changes. */
-const prFiles = Effect.fnUntraced(function* (repo, number) {
-	return (yield* readJson("pr view files", "gh", [
-		"pr",
-		"view",
-		String(number),
-		"--repo",
-		repo,
-		"--json",
-		"files"
-	], PrFiles)).files.map((file) => file.path);
-});
-/**
-* How much of a failing job's log is kept.
+* This is the single place the bucket rules exist. Every tracked PR lands in
+* exactly one bucket, so the rules are tried in priority order and the first
+* that claims the PR wins: a PR that both needs a review run and has changes
+* requested is mine to move, not the runner's.
 *
-* A job that failed prints what went wrong at the end, so the tail is the part
-* worth classifying, and a build that logged a whole dependency tree is not
-* worth holding in memory beyond it.
+* Ready does not insist on an approval, because a repository that requires no
+* reviewer never produces one. What it insists on is that nobody else has been
+* asked and is yet to answer.
 */
-const logTailBytes = 65536;
+const place = (facts) => {
+	const mine = needsMe(facts);
+	if (mine !== null) return {
+		bucket: "needs-me",
+		reason: mine
+	};
+	if (facts.reviewRunHead !== facts.head) return {
+		bucket: "needs-review-run",
+		reason: "no review run on this head"
+	};
+	if (facts.reviewDecision === "review-required") return {
+		bucket: "waiting-on-others",
+		reason: "a review from someone else"
+	};
+	if (facts.checks === "pending") return {
+		bucket: "waiting-on-others",
+		reason: "CI is still running"
+	};
+	return {
+		bucket: "ready",
+		reason: readyReason(facts)
+	};
+};
+const group = (facts) => {
+	const placed = facts.map((it) => ({
+		facts: it,
+		placement: place(it)
+	})).toSorted((a, b) => a.facts.repo.localeCompare(b.facts.repo) || a.facts.number - b.facts.number);
+	return order.map((bucket) => ({
+		bucket,
+		placed: placed.filter((it) => it.placement.bucket === bucket)
+	})).filter((bucket) => bucket.placed.length > 0);
+};
+//#endregion
+//#region src/domain/reference.ts
+/** `owner/name#12`, or `12` on its own. */
+const spelled = /^(?:([^\s/]+\/[^\s/]+)#)?(\d+)$/;
 /**
-* What one failing job printed, from the end.
+* A segment of nothing but dots, which no repository is called.
 *
-* `gh api` refuses a response carrying terminal escape sequences unless it is
-* told otherwise, and a runner log is full of them. Verified by running it: the
-* endpoint answers with the plain log once the flag is passed.
+* The repository names a directory under the state directory before it names
+* anything else, so `../x` would be a way out of it.
 */
-const jobLog = Effect.fnUntraced(function* (repo, jobId) {
-	const log = yield* capture("gh", [
-		"api",
-		`repos/${repo}/actions/jobs/${jobId}/logs`,
-		"--allow-escape-sequences"
-	]).pipe(Effect.catchTags({
-		PlatformError: (error) => Effect.fail(unavailable(error)),
-		CommandFailed: (error) => Effect.fail(new GhReadFailed({
-			command: "api job logs",
-			detail: error.stderr
-		}))
-	}));
-	return log.length <= logTailBytes ? log : log.slice(-65536);
-});
+const onlyDots = /^\.+$/;
 /**
-* The workflow runs behind the failing checks that count, each named once.
+* The pull request a reference names.
 *
-* One broken run usually fails several jobs, and re-running it once per failing
-* job would start the same run over and over.
+* A reference that spells its repository out is taken as it is, registered or
+* not: reviewing someone else's pull request is a thing to ask for, and the
+* settings a repository nothing registered gets are the global defaults.
+*/
+const resolve$1 = (text, registered) => {
+	const found = spelled.exec(text);
+	const number = found?.[2];
+	if (number === void 0) return {
+		_tag: "unreadable",
+		text
+	};
+	const spelledRepo = found?.[1];
+	if (spelledRepo !== void 0 && spelledRepo.split("/").some((segment) => onlyDots.test(segment))) return {
+		_tag: "unreadable",
+		text
+	};
+	const repo = spelledRepo ?? (registered.length === 1 ? registered[0] : void 0);
+	if (repo === void 0) return {
+		_tag: "ambiguous",
+		repos: registered
+	};
+	return {
+		_tag: "resolved",
+		repo,
+		number: Number(number)
+	};
+};
+//#endregion
+//#region src/cli/pr.ts
+/** The pull request a command acts on, named the way I actually type it. */
+const prArgument = Argument.String("pr").pipe(Argument.withDescription("The pull request, as 28 or owner/name#28"));
+/** What to say about a reference that named no one pull request. */
+const whyNothingNamed = (reference) => {
+	if (reference._tag === "unreadable") return `'${reference.text}' is not a pull request. Name one as 28, or as owner/name#28.`;
+	const example = `${reference.repos[0] ?? "owner/name"}#28`;
+	return reference.repos.length === 0 ? `No repositories are registered, so a number alone names nothing. Run dw-mc init inside a repository, or name the pull request as ${example}.` : `${reference.repos.length} repositories are registered, so a number alone could be any of them. Name the pull request as ${example}.`;
+};
+/** The pull request the argument names, or the sentence saying why it names none. */
+const named = (pr, registered) => {
+	const reference = resolve$1(pr, registered);
+	return reference._tag === "resolved" ? Effect.succeed(reference) : Effect.fail(new CliError.UserError({ cause: whyNothingNamed(reference) }));
+};
+/**
+* A domain guard's word, as the command's own failure.
 *
-* `ci.ignore` decides which checks get a run into this list, and no more than
-* that: a run is re-run whole, so an ignored job sharing a run with a counted
-* one is re-run beside it. What the setting buys is that an ignored check is
-* never on its own a reason to spend CI minutes.
+* Every guard in the tool answers the same shape - the sentence saying why not,
+* or null - so turning that answer into a refusal is spelled once here rather
+* than beside each command that asks one.
 */
-const failedRuns = (entries, ignore) => [...new Set(failedChecks(entries, ignore).flatMap((check) => {
-	const reported = reportedAt(check.detailsUrl);
-	return reported === null ? [] : [reported.run];
-}))];
+const refuse = (why) => why === null ? Effect.void : Effect.fail(new CliError.UserError({ cause: why }));
 /**
-* Asks GitHub to run one workflow run's failed jobs again.
+* What the last sweep learned about one pull request, or the sentence sending
+* me to a sweep.
 *
-* `--failed` is what makes this cheap: the jobs that passed are not run a
-* second time, so a flaky job costs the minutes it costs and no more. This is a
-* write to GitHub, and it is one of the three ADR 0002 allows.
+* A command that reads these rather than GitHub says what the table said: the
+* stamp and the cutoff a conversation is measured against are both computed
+* from the facts a sweep wrote down, and asking GitHub again would make them a
+* different answer from the one `dw-mc status` printed.
+*
+* Facts this version cannot read are facts another version of them wrote, and a
+* sweep can write them again, so both cases say the same thing.
 */
-const rerunFailed = Effect.fnUntraced(function* (repo, runId) {
-	yield* capture("gh", [
-		"run",
-		"rerun",
-		runId,
-		"--repo",
-		repo,
-		"--failed"
-	]).pipe(Effect.catchTags({
-		PlatformError: (error) => Effect.fail(unavailable(error)),
-		CommandFailed: (error) => Effect.fail(new GhReadFailed({
-			command: "run rerun",
-			detail: error.stderr
-		}))
-	}));
+const swept = Effect.fn("pr.swept")(function* (repo, number) {
+	const store = yield* storeFor("prs", Facts);
+	const facts = yield* Effect.orElseSucceed(store.get(prKey(repo, number)), () => Option.none());
+	if (Option.isNone(facts)) return yield* new CliError.UserError({ cause: `Nothing is known about ${repo}#${number} yet. Run dw-mc sweep first.` });
+	return facts.value;
 });
 //#endregion
 //#region src/cli/table.ts
@@ -1170,161 +1251,278 @@ const truncate = (text, width) => {
 /** `n` of something, pluralised the one way English usually is. */
 const count = (n, noun) => `${n} ${noun}${n === 1 ? "" : "s"}`;
 //#endregion
-//#region src/domain/moment.ts
-const isLater = Order.isGreaterThan(DateTime.Order);
-/** Whether `self` happened after `other`, counting never as before anything. */
-const isAfter = (self, other) => Predicate.isNotNull(self) && (other === null || isLater(self, other));
-/** The later of the two. */
-const later = (self, other) => isAfter(self, other) ? self : other;
-/** Whether the two are the same moment, counting never as the same as never. */
-const isSame = (self, other) => self === null || other === null ? self === other : DateTime.Equivalence(self, other);
-/** The latest of many, or never when there are none. */
-const newest = (moments) => moments.reduce(later, null);
+//#region src/cli/row.ts
+/**
+* How one tracked PR is written down, wherever it is written down.
+*
+* The table `dw-mc status` prints and the list the picker asks me to choose
+* from are the same rows, so a pull request reads the same in both and neither
+* command owns how the other draws it.
+*
+* Colour here says one thing: which bucket the pull request is in, and so what
+* it waits on. Everything else on the row is either `dim`, because it is
+* context rather than state, or left alone. A row read with no colour at all
+* says the same, which is what the marker is for.
+*/
+/** The glossary's name for each bucket, which is what the heading says. */
+const heading = {
+	"needs-me": "Needs me",
+	"needs-review-run": "Needs review run",
+	"waiting-on-others": "Waiting on others",
+	ready: "Ready"
+};
+/**
+* The mark that says which bucket a row is in without being read.
+*
+* One character apiece, from the part of Unicode a terminal font has: the
+* padding is counted in characters, and a glyph a terminal draws double width
+* takes a column the count never gave it. How full the mark looks tracks how
+* much of the pull request is done, so the column reads at a glance even where
+* the colour is off.
+*/
+const marker = {
+	"needs-me": "●",
+	"needs-review-run": "◐",
+	"waiting-on-others": "○",
+	ready: "◆"
+};
+/** The colour a bucket is said in: red is mine, yellow is next, green is done, dim is not my turn. */
+const tint = (paint, bucket) => ({
+	"needs-me": paint.red,
+	"needs-review-run": paint.yellow,
+	"waiting-on-others": paint.dim,
+	ready: paint.green
+})[bucket];
+/** What sits between two columns: three columns of prose run into one another without a rule. */
+const rule = " │ ";
+/**
+* One row: which pull request, what it is, and what it waits on.
+*
+* A stamp is a mark beside the pull request rather than a column of its own, so
+* a table where nothing is stamped is exactly the table it was before: the
+* stamp is a thing I look for, not a thing I read every row of.
+*
+* The title is the only cell with give in it, so how much room it gets is the
+* caller's to say: a table printed down the screen can afford a whole commit
+* subject, and a row inside a prompt has a column more to carry and a frame
+* around it.
+*
+* A named lead carries the colour for the whole row. It is the one place a
+* prompt's row is coloured: a prompt counts the lines it has to erase from the
+* length of what it drew, escape sequences and all, so every colour on a row
+* costs the title characters it could have shown. The table has no such
+* arithmetic to keep straight, so its rows say it in more than one place.
+*/
+const cells = (placed, stamped, room, paint, lead) => {
+	const { facts } = placed;
+	const { bucket } = placed.placement;
+	const say = tint(paint, bucket);
+	const pr = `${facts.repo}#${facts.number}${facts.draft ? paint.dim(" (draft)") : ""}${stamped ? ` ${paint.green("✓")}` : ""}`;
+	return lead === "named" ? [
+		say(`${marker[bucket]} ${heading[bucket]}`),
+		pr,
+		truncate(facts.title, room),
+		placed.placement.reason
+	] : [
+		`${say(marker[bucket])} ${pr}`,
+		paint.dim(truncate(facts.title, room)),
+		say(placed.placement.reason)
+	];
+};
 //#endregion
-//#region src/domain/bucket.ts
-/** How far GitHub has got towards letting a tracked PR merge. */
-const Mergeability = Schema.Literals([
-	"mergeable",
-	"conflicting",
-	"unknown"
-]);
-/** What the reviewers have decided, or that nobody is required to. */
-const ReviewDecision = Schema.Literals([
-	"approved",
-	"changes-requested",
-	"review-required",
-	"none"
+//#region src/adapters/ci.ts
+/**
+* What GitHub says about a pull request's checks, and the evidence a red one
+* is classified on. Every read here goes through the same `gh` the rest of the
+* tool does; what it owns is the checks, not the boundary.
+*/
+const failing = /* @__PURE__ */ new Set([
+	"FAILURE",
+	"TIMED_OUT",
+	"CANCELLED",
+	"STARTUP_FAILURE",
+	"ACTION_REQUIRED",
+	"ERROR"
 ]);
-/** What CI says about the current head. */
-const ChecksState = Schema.Literals([
-	"green",
-	"red",
-	"pending",
-	"none"
+const running = /* @__PURE__ */ new Set([
+	"QUEUED",
+	"IN_PROGRESS",
+	"WAITING",
+	"PENDING",
+	"REQUESTED",
+	"EXPECTED"
 ]);
+const nameOf = (entry) => entry.name ?? entry.context ?? "";
+const checksThatCount = (entries, ignore) => (entries ?? []).filter((entry) => !ignore.includes(nameOf(entry)));
+const hasFailed = (entry) => failing.has(entry.conclusion ?? "") || failing.has(entry.state ?? "");
 /**
-* Everything the bucket rules are allowed to know about a tracked PR.
+* What the rollup comes to: red when anything failed, pending only while
+* nothing has failed yet, green when every check that counts has passed.
 *
-* It is a schema because a sweep writes it to the state directory and reads it
-* back on the next one: the same facts that decide a bucket are what a quiet PR
-* is recognised by.
+* `ci.ignore` names the checks that do not count towards green, so a check I
+* have decided to live with cannot hold a PR out of Ready.
 */
-const Facts = Schema.Struct({
-	repo: Schema.String,
-	number: Schema.Int,
-	title: Schema.String,
-	url: Schema.String,
-	/** Shown, never acted on unless I ask. */
-	draft: Schema.Boolean,
-	/** The head commit every other fact here is about. */
-	head: Schema.String,
-	mergeable: Mergeability,
-	reviewDecision: ReviewDecision,
-	checks: ChecksState,
-	/** Why the flaky classifier excuses this red CI, or null where it does not. */
-	ciFlaky: Schema.NullOr(Schema.String),
-	/** The head a rebase onto the base conflicted at, or null where none has. */
-	rebaseConflictAt: Schema.NullOr(Schema.String),
-	/** The newest comment from a person who is not me, bots excluded. */
-	newestHumanCommentAt: Schema.NullOr(Schema.DateTimeUtcFromString),
-	myLastCommentAt: Schema.NullOr(Schema.DateTimeUtcFromString),
-	myLastCommitAt: Schema.NullOr(Schema.DateTimeUtcFromString),
-	/** The head a review run has already covered, or null where none has. */
-	reviewRunHead: Schema.NullOr(Schema.String),
-	/** Findings on this head that withhold the stamp, at the bar `stamp.blocks_on` sets. */
-	blockingFindings: Schema.Int
+const rollupState = (entries, ignore) => {
+	const checks = checksThatCount(entries, ignore);
+	if (checks.length === 0) return "none";
+	if (checks.some(hasFailed)) return "red";
+	if (checks.some((entry) => entry.status !== void 0 && entry.status !== "COMPLETED" || running.has(entry.state ?? ""))) return "pending";
+	return "green";
+};
+/**
+* The checks that failed and count, which are the ones there is a log to read.
+*
+* `ci.ignore` is applied here as well as in the rollup: a check that cannot
+* hold a PR out of Ready is not one the classifier should be explaining either.
+*/
+const failedChecks = (entries, ignore) => checksThatCount(entries, ignore).filter(hasFailed);
+/**
+* What a check reports on, out of the URL it reports at.
+*
+* A check run details URL ends `/actions/runs/<run>/job/<job>`. The job id is
+* what the logs endpoint takes and the run id is what `gh run rerun` takes, so
+* the two ids the tool needs are the two halves of one URL and are read
+* together. A commit status points somewhere else entirely, which is null:
+* there is no log of ours to read and no run of ours to re-run.
+*/
+const reportedAt = (detailsUrl) => {
+	const found = detailsUrl?.match(/\/actions\/runs\/(\d+)\/job\/(\d+)/);
+	return found?.[1] === void 0 || found[2] === void 0 ? null : {
+		run: found[1],
+		job: found[2]
+	};
+};
+const RepoDefaultBranch = Schema.fromJsonString(Schema.Struct({ defaultBranchRef: Schema.NullOr(Schema.Struct({ name: Schema.String })) }));
+/**
+* The branch a repository merges into, which is the one the first flaky signal
+* asks about. An empty repository has none, and `main` is the better guess than
+* failing the sweep over it.
+*/
+const defaultBranch = Effect.fnUntraced(function* (repo) {
+	return (yield* readJson("repo view defaultBranchRef", "gh", [
+		"repo",
+		"view",
+		repo,
+		"--json",
+		"defaultBranchRef"
+	], RepoDefaultBranch)).defaultBranchRef?.name ?? "main";
 });
-Schema.Literals([
-	"needs-me",
-	"needs-review-run",
-	"waiting-on-others",
-	"ready"
+const Runs = Schema.fromJsonString(Schema.Array(Schema.Struct({ conclusion: Schema.String })));
+/** How far back to look for a run that reached a verdict at all. */
+const recentRuns = 5;
+/** `gh run list` reports a conclusion in lower case, unlike every check on a PR. */
+const failedRun = /* @__PURE__ */ new Set(["failure", "timed_out"]);
+/** A run that decided something. A skipped or cancelled run says nothing either way. */
+const verdicts = /* @__PURE__ */ new Set([
+	"failure",
+	"timed_out",
+	"success"
 ]);
-/** The buckets in the order I act on them: the top of the table is my next move. */
-const order = [
-	"needs-me",
-	"needs-review-run",
-	"waiting-on-others",
-	"ready"
-];
 /**
-* The first of the rules that makes a PR mine to move, or null when none
-* does. The order is the order I would fix them in: a conflict makes every
-* other signal on the PR stale, and a red build is worth more than a comment.
+* Whether `workflow` is red on `branch` right now.
+*
+* The newest run that reached a verdict is the whole answer: a workflow that
+* broke last week and was fixed since is not red, and excusing a pull request
+* for it would hide a failure that is real. A handful of runs are asked for
+* because the newest ones are often skipped by a path filter.
+*/
+const workflowFailsOn = Effect.fnUntraced(function* (repo, branch, workflow) {
+	const newest = (yield* readJson("run list", "gh", [
+		"run",
+		"list",
+		"--repo",
+		repo,
+		"--branch",
+		branch,
+		"--workflow",
+		workflow,
+		"--limit",
+		String(recentRuns),
+		"--json",
+		"conclusion"
+	], Runs)).find((run) => verdicts.has(run.conclusion));
+	return newest !== void 0 && failedRun.has(newest.conclusion);
+});
+const PrFiles = Schema.fromJsonString(Schema.Struct({ files: Schema.Array(Schema.Struct({ path: Schema.String })) }));
+/** The repository paths a pull request changes. */
+const prFiles = Effect.fnUntraced(function* (repo, number) {
+	return (yield* readJson("pr view files", "gh", [
+		"pr",
+		"view",
+		String(number),
+		"--repo",
+		repo,
+		"--json",
+		"files"
+	], PrFiles)).files.map((file) => file.path);
+});
+/**
+* How much of a failing job's log is kept.
+*
+* A job that failed prints what went wrong at the end, so the tail is the part
+* worth classifying, and a build that logged a whole dependency tree is not
+* worth holding in memory beyond it.
 */
-const needsMe = (facts) => {
-	if (facts.mergeable === "conflicting") return "merge conflict";
-	if (facts.rebaseConflictAt === facts.head) return "a rebase onto the base conflicted";
-	if (facts.checks === "red" && facts.ciFlaky === null) return "CI is red";
-	if (facts.reviewDecision === "changes-requested") return "changes requested";
-	if (facts.blockingFindings > 0) return `${facts.blockingFindings} blocking finding${facts.blockingFindings === 1 ? "" : "s"}`;
-	if (isAfter(facts.newestHumanCommentAt, later(facts.myLastCommentAt, facts.myLastCommitAt))) return "a comment I have not answered";
-	return null;
-};
+const logTailBytes = 65536;
 /**
-* What is actually true of a PR nothing is waiting on.
-*
-* Ready is reached by having no reason not to be, so the reason says only what
-* holds: a repository that requires no reviewer produces no approval, and a
-* pull request with no CI at all is not green.
+* What one failing job printed, from the end.
 *
-* A red CI the classifier excused is said out loud, because GitHub does not
-* excuse it: the check is still red, and Ready is what `dw-mc merge` reads.
+* `gh api` refuses a response carrying terminal escape sequences unless it is
+* told otherwise, and a runner log is full of them. Verified by running it: the
+* endpoint answers with the plain log once the flag is passed.
 */
-const readyReason = (facts) => {
-	const held = [
-		facts.reviewDecision === "approved" ? "approved" : null,
-		facts.checks === "green" ? "green" : null,
-		facts.mergeable === "mergeable" ? "mergeable" : null
-	].filter((it) => it !== null);
-	const standing = held.length === 0 ? "nothing left to wait on" : held.join(", ");
-	return facts.checks === "red" && facts.ciFlaky !== null ? `${standing} (red CI called flaky: ${facts.ciFlaky})` : standing;
-};
+const jobLog = Effect.fnUntraced(function* (repo, jobId) {
+	const log = yield* capture("gh", [
+		"api",
+		`repos/${repo}/actions/jobs/${jobId}/logs`,
+		"--allow-escape-sequences"
+	]).pipe(Effect.catchTags({
+		PlatformError: (error) => Effect.fail(unavailable(error)),
+		CommandFailed: (error) => Effect.fail(new GhReadFailed({
+			command: "api job logs",
+			detail: error.stderr
+		}))
+	}));
+	return log.length <= logTailBytes ? log : log.slice(-65536);
+});
 /**
-* The bucket a tracked PR sits in, and the reason for it.
+* The workflow runs behind the failing checks that count, each named once.
 *
-* This is the single place the bucket rules exist. Every tracked PR lands in
-* exactly one bucket, so the rules are tried in priority order and the first
-* that claims the PR wins: a PR that both needs a review run and has changes
-* requested is mine to move, not the runner's.
+* One broken run usually fails several jobs, and re-running it once per failing
+* job would start the same run over and over.
 *
-* Ready does not insist on an approval, because a repository that requires no
-* reviewer never produces one. What it insists on is that nobody else has been
-* asked and is yet to answer.
+* `ci.ignore` decides which checks get a run into this list, and no more than
+* that: a run is re-run whole, so an ignored job sharing a run with a counted
+* one is re-run beside it. What the setting buys is that an ignored check is
+* never on its own a reason to spend CI minutes.
 */
-const place = (facts) => {
-	const mine = needsMe(facts);
-	if (mine !== null) return {
-		bucket: "needs-me",
-		reason: mine
-	};
-	if (facts.reviewRunHead !== facts.head) return {
-		bucket: "needs-review-run",
-		reason: "no review run on this head"
-	};
-	if (facts.reviewDecision === "review-required") return {
-		bucket: "waiting-on-others",
-		reason: "a review from someone else"
-	};
-	if (facts.checks === "pending") return {
-		bucket: "waiting-on-others",
-		reason: "CI is still running"
-	};
-	return {
-		bucket: "ready",
-		reason: readyReason(facts)
-	};
-};
-const group = (facts) => {
-	const placed = facts.map((it) => ({
-		facts: it,
-		placement: place(it)
-	})).toSorted((a, b) => a.facts.repo.localeCompare(b.facts.repo) || a.facts.number - b.facts.number);
-	return order.map((bucket) => ({
-		bucket,
-		placed: placed.filter((it) => it.placement.bucket === bucket)
-	})).filter((bucket) => bucket.placed.length > 0);
-};
+const failedRuns = (entries, ignore) => [...new Set(failedChecks(entries, ignore).flatMap((check) => {
+	const reported = reportedAt(check.detailsUrl);
+	return reported === null ? [] : [reported.run];
+}))];
+/**
+* Asks GitHub to run one workflow run's failed jobs again.
+*
+* `--failed` is what makes this cheap: the jobs that passed are not run a
+* second time, so a flaky job costs the minutes it costs and no more. This is a
+* write to GitHub, and it is one of the three ADR 0002 allows.
+*/
+const rerunFailed = Effect.fnUntraced(function* (repo, runId) {
+	yield* capture("gh", [
+		"run",
+		"rerun",
+		runId,
+		"--repo",
+		repo,
+		"--failed"
+	]).pipe(Effect.catchTags({
+		PlatformError: (error) => Effect.fail(unavailable(error)),
+		CommandFailed: (error) => Effect.fail(new GhReadFailed({
+			command: "run rerun",
+			detail: error.stderr
+		}))
+	}));
+});
 //#endregion
 //#region src/domain/flaky.ts
 /**
@@ -1421,7 +1619,7 @@ const filterMap = (xs, f) => xs.flatMap((x) => {
 	return b === null ? [] : [b];
 });
 /** No evidence at all, which is what an unreadable CI comes to. */
-const nothing = {
+const nothing$1 = {
 	alsoRedOnDefaultBranch: [],
 	changedFiles: [],
 	log: ""
@@ -1440,7 +1638,7 @@ const evidenceFor = Effect.fn("flaky.evidenceFor")(function* (repo, number, entr
 	const workflows = [...new Set(filterMap(failed, (check) => check.workflowName ?? null))];
 	const jobs = filterMap(failed, (check) => reportedAt(check.detailsUrl)?.job ?? null).slice(0, loggedJobs);
 	const branch = yield* Effect.orElseSucceed(defaultBranch(repo), () => null);
-	if (branch === null) return nothing;
+	if (branch === null) return nothing$1;
 	const [alsoRed, changedFiles, logs] = yield* Effect.all([
 		Effect.forEach(workflows, (workflow) => Effect.map(Effect.orElseSucceed(workflowFailsOn(repo, branch, workflow), () => false), (red) => red ? [workflow] : [])),
 		Effect.orElseSucceed(prFiles(repo, number), () => []),
@@ -2069,6 +2267,136 @@ const sweepCommand = Command.make("sweep", {}, Effect.fn("sweep.command")(functi
 	yield* printTroubles(report.troubles);
 }, Effect.catchTag(userFacing, asUserError))).pipe(Command.withDescription("Refresh what mission control knows about every tracked pull request"));
 //#endregion
+//#region src/domain/comments.ts
+/**
+* One thread's share of a strand, cut to what is worth reading.
+*
+* A review thread is answered as a whole, so a single comment newer than my
+* last activity brings the whole thread with it: the follow-up on its own is a
+* line answering something the screen does not show, which is what sends me to
+* the browser.
+*
+* The pull request's own comments are not a thread but a stream, and there is
+* no reply to lose the question of, so they are cut comment by comment.
+*/
+const only = (thread, keep, since, all) => {
+	const strand = thread.comments.filter((it) => keep(it.bot));
+	const comments = all ? strand : thread.path === null ? strand.filter((it) => isAfter(it.at, since)) : strand.some((it) => isAfter(it.at, since)) ? strand : [];
+	return comments.length === 0 ? [] : [{
+		...thread,
+		comments
+	}];
+};
+/**
+* The threads worth putting on screen, given what I have already done.
+*
+* `since` is my last activity on the pull request - the later of my last
+* comment and my last commit - which is the same moment the bucket rule
+* measures a comment against. Showing exactly what is newer than it means the
+* command answers the question the bucket asked.
+*
+* A thread somebody resolved and one against code that is gone are left out:
+* neither is something to answer, and both are still there to read under
+* `--all`, which asks for the whole conversation and so measures nothing
+* against anything.
+*/
+const shown = (threads, options) => {
+	const kept = options.all ? threads : threads.filter((it) => !it.resolved && !it.outdated);
+	return {
+		people: kept.flatMap((it) => only(it, (bot) => !bot, options.since, options.all)),
+		bots: kept.flatMap((it) => only(it, (bot) => bot, options.since, options.all))
+	};
+};
+//#endregion
+//#region src/cli/comments.ts
+const allFlag = Flag.Boolean("all").pipe(Flag.withDefault(false), Flag.withDescription("Print the whole conversation, including what is resolved, outdated and already answered"));
+/** Where a thread hangs: a line of the diff, or the pull request itself. */
+const where$1 = (thread) => thread.path === null ? "Conversation" : thread.line === null ? thread.path : `${thread.path}:${thread.line}`;
+/**
+* What is true of a thread beyond where it hangs.
+*
+* It is only ever printed under `--all`, which is the only way a settled thread
+* reaches the screen at all, and it is there so that reading one is never
+* reading it as something still open.
+*/
+const settled = (thread) => [thread.resolved ? "resolved" : null, thread.outdated ? "outdated" : null].filter((it) => it !== null).join(", ");
+/**
+* One thread as a block: where it hangs, then everybody who said something in
+* it, then what they said in full.
+*
+* In full because a review comment is usually a paragraph carrying a
+* suggestion, and a first line is what sends me to the browser this command
+* exists to replace. No diff hunk with it: the code is on this machine, under
+* the path the heading already prints.
+*/
+const block = (thread, paint) => [`${paint.bold(where$1(thread))}${settled(thread) === "" ? "" : paint.dim(`  (${settled(thread)})`)}`, ...thread.comments.flatMap((comment) => [`  ${paint.dim(`@${comment.login}  ${DateTime.formatIso(comment.at)}`)}`, ...comment.body.split("\n").map((line) => `    ${line}`)])];
+const separated = (blocks) => blocks.flatMap((lines, index) => index === 0 ? lines : ["", ...lines]);
+/**
+* The conversation on screen: people first, then a rule, then the bots.
+*
+* The rule is there so the two are never read as one list. A bot's comment is
+* observed and never answered, which is the same asymmetry between a deciding
+* and a supporting runner the glossary already draws, and the bucket rules
+* ignore bots for exactly this reason.
+*
+* A bot is cut at the same moment I am measured against, because the window is
+* what has happened since I last acted rather than what is owed an answer. A
+* verdict older than my last push is one I have already had the chance to read,
+* and `--all` is where it still is.
+*/
+const lines$2 = (view, paint) => {
+	const people = view.people.map((thread) => block(thread, paint));
+	const bots = view.bots.map((thread) => block(thread, paint));
+	return separated([...people, ...bots.length === 0 ? [] : [[paint.dim("── bots ──")], ...bots]]);
+};
+/** What to say where there is nothing to print, which depends on why there is not. */
+const nothing = (facts, all) => {
+	const pr = `${facts.repo}#${facts.number}`;
+	if (all) return [`Nothing has been said on ${pr}.`];
+	const placement = place(facts);
+	const rest = `dw-mc comments ${facts.number} --all prints the whole conversation.`;
+	return placement.bucket === "needs-me" && placement.reason === "a comment I have not answered" ? [
+		"Nothing here is waiting on you: every thread is resolved, outdated, or older than your last comment or commit.",
+		`${pr} sits in ${heading[placement.bucket]} all the same, and a reply or a push is what settles it.`,
+		rest
+	] : [`Nothing has been said on ${pr} since your last comment or commit.`, rest];
+};
+/**
+* The conversation on one tracked pull request, and nothing else.
+*
+* What it shows by default is what the bucket rule measures: the comments newer
+* than the later of my last comment and my last commit, which are the ones that
+* put the pull request in Needs me. Reading it answers the question the table
+* asked.
+*
+* The cutoff is read off the last sweep rather than worked out again here, so
+* the command shows exactly what `dw-mc status` counted rather than a second
+* opinion about it.
+*
+* It writes nothing, here or on GitHub: no reply, no resolve, no reaction
+* (ADR 0002). Reading is the whole command.
+*/
+const comments = Command.make("comments", {
+	pr: prArgument,
+	all: allFlag
+}, Effect.fn("comments")(function* ({ all, pr }) {
+	const file = Option.getOrElse(yield* read, () => ({}));
+	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
+	const facts = yield* swept(repo, number);
+	const paint = yield* Paint;
+	const view = shown(yield* prConversation(repo, number), {
+		since: later(facts.myLastCommentAt, facts.myLastCommitAt),
+		all
+	});
+	if (view.people.length === 0 && view.bots.length === 0) {
+		yield* Effect.forEach(nothing(facts, all), (line) => Console.log(line));
+		return;
+	}
+	yield* Console.log(paint.bold(`${repo}#${number}`) + `  ${paint.dim(facts.title)}`);
+	yield* Console.log("");
+	yield* Effect.forEach(lines$2(view, paint), (line) => Console.log(line));
+}, Effect.catchTag(["ConfigMalformed", ...userFacing], asUserError))).pipe(Command.withDescription("Print the conversation on one pull request, and what is waiting on me in it"));
+//#endregion
 //#region src/cli/findings.ts
 /** The findings as the JSON the schema defines, rather than as this file spells it. */
 const asJson$2 = Schema.encodeEffect(Schema.fromJsonString(Findings));
@@ -3636,85 +3964,6 @@ const merge = Command.make("merge", { pr: prArgument }, Effect.fn("merge")(funct
 	yield* Console.log(`The squash subject is the pull request title: ${view.title}`);
 }, Effect.catchTag(userFacing, asUserError))).pipe(Command.withDescription("Squash-merge a Ready, stamped pull request of mine and delete its branch"));
 //#endregion
-//#region src/cli/row.ts
-/**
-* How one tracked PR is written down, wherever it is written down.
-*
-* The table `dw-mc status` prints and the list the picker asks me to choose
-* from are the same rows, so a pull request reads the same in both and neither
-* command owns how the other draws it.
-*
-* Colour here says one thing: which bucket the pull request is in, and so what
-* it waits on. Everything else on the row is either `dim`, because it is
-* context rather than state, or left alone. A row read with no colour at all
-* says the same, which is what the marker is for.
-*/
-/** The glossary's name for each bucket, which is what the heading says. */
-const heading = {
-	"needs-me": "Needs me",
-	"needs-review-run": "Needs review run",
-	"waiting-on-others": "Waiting on others",
-	ready: "Ready"
-};
-/**
-* The mark that says which bucket a row is in without being read.
-*
-* One character apiece, from the part of Unicode a terminal font has: the
-* padding is counted in characters, and a glyph a terminal draws double width
-* takes a column the count never gave it. How full the mark looks tracks how
-* much of the pull request is done, so the column reads at a glance even where
-* the colour is off.
-*/
-const marker = {
-	"needs-me": "●",
-	"needs-review-run": "◐",
-	"waiting-on-others": "○",
-	ready: "◆"
-};
-/** The colour a bucket is said in: red is mine, yellow is next, green is done, dim is not my turn. */
-const tint = (paint, bucket) => ({
-	"needs-me": paint.red,
-	"needs-review-run": paint.yellow,
-	"waiting-on-others": paint.dim,
-	ready: paint.green
-})[bucket];
-/** What sits between two columns: three columns of prose run into one another without a rule. */
-const rule = " │ ";
-/**
-* One row: which pull request, what it is, and what it waits on.
-*
-* A stamp is a mark beside the pull request rather than a column of its own, so
-* a table where nothing is stamped is exactly the table it was before: the
-* stamp is a thing I look for, not a thing I read every row of.
-*
-* The title is the only cell with give in it, so how much room it gets is the
-* caller's to say: a table printed down the screen can afford a whole commit
-* subject, and a row inside a prompt has a column more to carry and a frame
-* around it.
-*
-* A named lead carries the colour for the whole row. It is the one place a
-* prompt's row is coloured: a prompt counts the lines it has to erase from the
-* length of what it drew, escape sequences and all, so every colour on a row
-* costs the title characters it could have shown. The table has no such
-* arithmetic to keep straight, so its rows say it in more than one place.
-*/
-const cells = (placed, stamped, room, paint, lead) => {
-	const { facts } = placed;
-	const { bucket } = placed.placement;
-	const say = tint(paint, bucket);
-	const pr = `${facts.repo}#${facts.number}${facts.draft ? paint.dim(" (draft)") : ""}${stamped ? ` ${paint.green("✓")}` : ""}`;
-	return lead === "named" ? [
-		say(`${marker[bucket]} ${heading[bucket]}`),
-		pr,
-		truncate(facts.title, room),
-		placed.placement.reason
-	] : [
-		`${say(marker[bucket])} ${pr}`,
-		paint.dim(truncate(facts.title, room)),
-		say(placed.placement.reason)
-	];
-};
-//#endregion
 //#region src/domain/pick.ts
 /**
 * The actions worth offering on one tracked PR, in the order I would take them.
@@ -4679,23 +4928,6 @@ const review = Command.make("review", {
 //#region src/cli/stamp.ts
 const withdrawFlag = Flag.Boolean("withdraw").pipe(Flag.withDefault(false), Flag.withDescription("Take the stamp off this pull request, until its head changes"));
 /**
-* What the last sweep learned about one pull request, or the sentence sending
-* me to a sweep.
-*
-* The stamp is computed from the facts a sweep wrote down, so this command
-* reads them rather than GitHub: a mark that asked GitHub again would be a
-* different mark from the one `dw-mc status` prints.
-*
-* Facts this version cannot read are facts another version of them wrote, and a
-* sweep can write them again, so both cases say the same thing.
-*/
-const sweptFacts = Effect.fn("stamp.sweptFacts")(function* (repo, number) {
-	const store = yield* storeFor("prs", Facts);
-	const facts = yield* Effect.orElseSucceed(store.get(prKey(repo, number)), () => Option.none());
-	if (Option.isNone(facts)) return yield* asUserError(`Nothing is known about ${repo}#${number} yet. Run dw-mc sweep first.`);
-	return facts.value;
-});
-/**
 * The stamp of one pull request, and the one way to take it off by hand.
 *
 * Printing it is the whole command without `--withdraw`: the mark is computed,
@@ -4718,7 +4950,7 @@ const stampCommand = Command.make("stamp", {
 }, Effect.fn("stamp")(function* ({ pr, withdraw: byHand }) {
 	const file = Option.getOrElse(yield* read, () => ({}));
 	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
-	const facts = yield* sweptFacts(repo, number);
+	const facts = yield* swept(repo, number);
 	const where = `${repo}#${number}  ${short(facts.head)}`;
 	if (byHand) {
 		yield* withdraw(repo, number, facts.head);
@@ -4775,12 +5007,13 @@ const status = Command.make("status", {}, Effect.fn("status")(function* () {
 * Running from source leaves the constant undeclared rather than undefined, so
 * the check has to be `typeof` and the fallback is what a test reads.
 */
-const version = "0.1.0";
+const version = "0.2.0";
 /** Where the project lives, printed beside the version in the header. */
 const projectUrl = "github.com/dominikwozniak/dw-mc";
 const subcommands = [
 	init,
 	review,
+	comments,
 	findings,
 	fix,
 	rebase,