dw-mc 0.4.0 → 0.5.1

package/dist/bin.js

@@ -112,13 +112,21 @@ const encodeYaml = (value) => {
 	return `${out.join("\n")}\n`;
 };
 //#endregion
-//#region src/adapters/config.ts
+//#region src/terms/review.ts
+/**
+* The words a review run is described in.
+*
+* What a run opens on and how much it spends are facts about Claude Code, and
+* how much a finding weighs is a rule of mine, but all three are read on both
+* sides of the adapter seam: the domain writes the turn and weighs the
+* findings, the adapter spawns the turn and is held to the same words.
+*/
 /**
 * How much a review run spends, in the words the slash command takes.
 *
-* The set is Claude Code's and not this tool's, so it is wider than the three
-* words a review used to be held to: a run that would be worth `max` is one I
-* should be able to ask for without spelling the whole command out.
+* The set is Claude Code's and not this tool's, so it is wider than three
+* words: a run that would be worth `max` is one I should be able to ask for
+* without spelling the whole command out.
 */
 const Effort = Schema.Literals([
 	"low",
@@ -133,6 +141,8 @@ const Severity = Schema.Literals([
 	"warning",
 	"info"
 ]);
+//#endregion
+//#region src/adapters/config.ts
 /**
 * What one section of the file may say. Every key is optional: what the file
 * leaves out is inherited rather than reset, so `defaults` and a repository's
@@ -322,7 +332,7 @@ var ConfigMalformed = class extends Schema.TaggedError()("ConfigMalformed", {
 		return `${this.path} is not valid dw-mc configuration: ${this.reason}\nFix the file, or delete it and run 'dw-mc init' again.`;
 	}
 };
-const reasonOf = (cause) => cause instanceof Error ? cause.message : String(cause);
+const reasonOf = (cause) => Predicate.isError(cause) ? cause.message : String(cause);
 /** The keys an earlier version had, read off a file loosely enough to find them. */
 const LegacySection = Schema.Struct({
 	review: Schema.optionalKey(Schema.Struct({
@@ -525,6 +535,18 @@ const textStoreFor = Effect.fn("store.textStoreFor")(function* (namespace) {
 	const store = yield* KeyValueStore.KeyValueStore;
 	return KeyValueStore.prefix(store, `${namespace}/`);
 });
+/**
+* What a store holds under a key, and nothing where it holds nothing this
+* version can read.
+*
+* A record this version cannot read is one another version of it wrote, and the
+* state directory is a cache of work that can be done again ([ADR
+* 0010](../../docs/adr/0010-configuration-that-cannot-be-read.md)): forgetting a
+* record costs that work once, where failing here would cost the command I
+* asked for. Every read of the tool's own records goes through this, so the
+* bargain is struck once rather than at each of them.
+*/
+const remembered = (read) => Effect.orElseSucceed(read, () => Option.none());
 /** The state directory on disk. */
 const layer$1 = Layer.unwrap(Effect.map(stateDirectory, (directory) => KeyValueStore.layerFileSystem(directory)));
 KeyValueStore.layerMemory;
@@ -553,32 +575,63 @@ const sessionOf = (cut) => ({
 })[cut];
 /** Where the bare clones sit, under the state directory. */
 const clonesIn = "repos";
+/** What a bare clone's directory is called, and what tells one from anything beside it. */
+const bare = ".git";
+/** Where the tool keeps one repository's bare clone. */
+const cloneAt = Effect.fn("store.cloneAt")(function* (repo) {
+	return (yield* Path.Path).join(yield* stateDirectory, clonesIn, `${repo}${bare}`);
+});
+/** Where one pull request's checkout goes, under the cut it was made for. */
+const cutAt = Effect.fn("store.cutAt")(function* (cut, repo, number) {
+	return (yield* Path.Path).join(yield* stateDirectory, cut, repo, String(number));
+});
+/**
+* What the branch a standing session works on is called, inside that clone.
+*
+* It carries the session's name because a fix session and a session on a
+* conflict stand at the same time on the same pull request, and one branch
+* between them would be one holding the other's commits.
+*/
+const sessionBranch = (session, number) => `dw-mc/${session}/${number}`;
+/**
+* What the ref a clone keeps one pull request's head under is called.
+*
+* A cut fetches it and a removal reads it back without fetching, so the two
+* have to spell it the same or a session would be asked about a ref nothing
+* ever wrote.
+*/
+const pullRef = (number) => `refs/dw-mc/pr/${number}`;
 /** What a directory holds, or nothing at all where it is not there. */
 const entriesOf = Effect.fnUntraced(function* (directory) {
 	const fs = yield* FileSystem.FileSystem;
 	return yield* Effect.orElseSucceed(fs.readDirectory(directory), () => []);
 });
 /**
-* What `directory` and everything below it weighs.
+* What the entries named under `directory` weigh together.
 *
 * A file that is gone by the time it is asked about weighs nothing rather than
 * failing the walk: the directory is being read while the tool may be writing
 * to it, and a size on a screen is worth less than the listing it sits in.
 */
-const weigh = Effect.fn("store.weigh")(function* (directory) {
+const weightOf = Effect.fnUntraced(function* (directory, entries) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
-	const entries = yield* Effect.orElseSucceed(fs.readDirectory(directory, { recursive: true }), () => []);
 	const sizes = yield* Effect.forEach(entries, (entry) => Effect.orElseSucceed(Effect.map(fs.stat(path.join(directory, entry)), (info) => ByteSize.toBigInt(info.size)), () => BigInt(0)), { concurrency: 16 });
 	return ByteSize.bytes(sizes.reduce((total, size) => total + size, BigInt(0)));
 });
+/** What `directory` and everything below it weighs. */
+const weigh = Effect.fn("store.weigh")(function* (directory) {
+	const fs = yield* FileSystem.FileSystem;
+	const entries = yield* Effect.orElseSucceed(fs.readDirectory(directory, { recursive: true }), () => []);
+	return yield* weightOf(directory, entries);
+});
 /** The bare clones, named by the `owner/repo` the two directory levels spell. */
 const clonesOf = Effect.fnUntraced(function* (state) {
 	const path = yield* Path.Path;
 	const root = path.join(state, clonesIn);
 	const clones = [];
 	for (const owner of yield* entriesOf(root)) for (const name of yield* entriesOf(path.join(root, owner))) {
-		if (!name.endsWith(".git")) continue;
+		if (!name.endsWith(bare)) continue;
 		const directory = path.join(root, owner, name);
 		clones.push({
 			repo: `${owner}/${name.slice(0, -4)}`,
@@ -607,19 +660,16 @@ const cuttingsOf = Effect.fnUntraced(function* (state) {
 });
 /** Everything the state directory holds, in one pass over the disk. */
 const inventory = Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
 	const directory = yield* stateDirectory;
 	const directories = /* @__PURE__ */ new Set([clonesIn, ...cuts]);
 	const keys = (yield* entriesOf(directory)).filter((entry) => !directories.has(entry));
-	const sizes = yield* Effect.forEach(keys, (entry) => Effect.orElseSucceed(Effect.map(fs.stat(path.join(directory, entry)), (info) => ByteSize.toBigInt(info.size)), () => BigInt(0)), { concurrency: 16 });
 	return {
 		directory,
 		clones: yield* clonesOf(directory),
 		cuttings: yield* cuttingsOf(directory),
 		records: {
 			keys: keys.length,
-			size: ByteSize.bytes(sizes.reduce((a, b) => a + b, BigInt(0)))
+			size: yield* weightOf(directory, keys)
 		}
 	};
 }).pipe(Effect.withSpan("store.inventory"));
@@ -657,6 +707,71 @@ const tidy = Effect.fn("store.tidy")(function* (directory, upTo) {
 		at = path.dirname(at);
 	}
 });
+//#endregion
+//#region src/adapters/heartbeat.ts
+/** The frames of the spinner, in the order they turn. */
+const frames = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+/** How long one frame is on the screen. */
+const frameFor = Duration.millis(120);
+/** A stretch of time as a terminal says it: `1m12s`, or `9s` under the minute. */
+const elapsed = (millis) => {
+	const seconds = Math.floor(millis / 1e3);
+	return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m${String(seconds % 60).padStart(2, "0")}s`;
+};
+/**
+* Runs `use` while one line says the work is still going, and hands `use` the
+* way to say how that line reads.
+*
+* Work that takes seconds and prints nothing while it does is work I stop
+* trusting. What the screen showed instead was either silence or a line per
+* step, and a wall of `· Bash` says as little as silence did. This keeps one
+* line and rewrites it: the spinner says the work is alive, the words say how
+* far it has got, and the line is gone when the work is over, so what stays on
+* the screen is the report.
+*
+* What the line counts is the command's and not this module's business. A
+* review counts tools, a sweep counts pull requests, and a command reading two
+* guards counts nothing at all - and a screen that worded any of them here
+* would need the words a command already has.
+*
+* Where there is no screen to measure - a pipe, a CI log, a test - a rewritten
+* line would be a mess of half-drawn ones, so nothing is drawn. What goes out
+* instead is whatever `aside` the command gives, one to a line, and where it
+* gives none the output is what it was before there was a heartbeat at all.
+* `columns` is zero exactly there.
+*/
+const beating = Effect.fnUntraced(function* (from, use) {
+	const terminal = yield* Terminal.Terminal;
+	const columns = yield* terminal.columns;
+	if (columns === 0) return yield* use((_, aside) => aside === void 0 ? Effect.void : Console.log(aside));
+	const started = yield* Clock.currentTimeMillis;
+	const draw = (text) => Effect.ignore(terminal.display(`\r${text.slice(0, columns - 1).padEnd(columns - 1)}`));
+	let reads = from;
+	let at = 0;
+	/** The line as it stands: this frame of the spinner, and the latest wording. */
+	const paint = Effect.flatMap(Clock.currentTimeMillis, (now) => draw(`${frames[at % frames.length]} ${reads(elapsed(now - started))}`));
+	const says = (next) => Effect.andThen(Effect.sync(() => void (reads = next)), paint);
+	yield* paint;
+	const beat = yield* Effect.forkChild(Effect.gen(function* () {
+		for (;;) {
+			yield* Effect.sleep(frameFor);
+			at = at + 1;
+			yield* paint;
+		}
+	}));
+	return yield* Effect.onExit(use(says), () => Effect.flatMap(Fiber.interrupt(beat), () => Effect.ignore(terminal.display(`\r${" ".repeat(columns - 1)}\r`))));
+});
 new TextEncoder();
 /** A program that ran but ended badly. */
 var CommandFailed = class extends Schema.TaggedError()("CommandFailed", {
@@ -712,6 +827,14 @@ const git = (args) => capture("git", args).pipe(Effect.catchTags({
 		detail: error.stderr
 	}))
 }));
+/**
+* `n` commits, which is the one thing this file counts out loud.
+*
+* It is said twice - before a session is cut and before one is taken away -
+* and about the same commits both times: the ones the pull request's head does
+* not have.
+*/
+const commits = (n) => `${n} commit${n === 1 ? "" : "s"}`;
 /** A fix worktree that still holds work of mine, which nothing may cut away. */
 var WorktreeHeld = class extends Schema.TaggedError()("WorktreeHeld", {
 	directory: Schema.String,
@@ -739,42 +862,55 @@ var WorktreeHeld = class extends Schema.TaggedError()("WorktreeHeld", {
 * The head comes from the pull request's ref rather than from what a sweep last
 * saw, so what is cut is the commit the run really reads.
 */
+/**
+* How the heartbeat of a cut reads.
+*
+* The stages are named apart because a first clone and a hundredth fetch take
+* wildly different times, and the line is what explains the difference: a
+* `cloning` that sits there for two minutes is a large repository arriving
+* once, not a tool that has hung.
+*/
+const cutting = (what, repo) => (since) => `${what} ${repo} · ${since}`;
 const whereToCut = Effect.fn("git.whereToCut")(function* (repo, number, cut) {
-	const path = yield* Path.Path;
-	const state = yield* stateDirectory;
-	const clone = path.join(state, clonesIn, `${repo}.git`);
-	if ((yield* Effect.orElseSucceed(git([
+	const clone = yield* cloneAt(repo);
+	const bare = yield* Effect.orElseSucceed(git([
 		"-C",
 		clone,
 		"rev-parse",
 		"--is-bare-repository"
-	]), () => "")) !== "true") yield* git([
-		"clone",
-		"--bare",
-		"--filter=blob:none",
-		`https://github.com/${repo}.git`,
-		clone
-	]);
-	const pullRef = `refs/dw-mc/pr/${number}`;
-	yield* git([
-		"-C",
-		clone,
-		"fetch",
-		"--no-tags",
-		"--force",
-		"origin",
-		`+refs/pull/${number}/head:${pullRef}`,
-		"+refs/heads/*:refs/heads/*"
-	]);
+	]), () => "");
+	const ref = pullRef(number);
 	return {
 		clone,
-		head: yield* git([
-			"-C",
-			clone,
-			"rev-parse",
-			pullRef
-		]),
-		directory: path.join(state, cut, repo, String(number))
+		head: yield* beating(cutting(bare === "true" ? "fetching" : "cloning", repo), (says) => Effect.gen(function* () {
+			if (bare !== "true") {
+				yield* git([
+					"clone",
+					"--bare",
+					"--filter=blob:none",
+					`https://github.com/${repo}.git`,
+					clone
+				]);
+				yield* says(cutting("fetching", repo));
+			}
+			yield* git([
+				"-C",
+				clone,
+				"fetch",
+				"--no-tags",
+				"--force",
+				"origin",
+				`+refs/pull/${number}/head:${ref}`,
+				"+refs/heads/*:refs/heads/*"
+			]);
+			return yield* git([
+				"-C",
+				clone,
+				"rev-parse",
+				ref
+			]);
+		})),
+		directory: yield* cutAt(cut, repo, number)
 	};
 });
 /**
@@ -798,7 +934,7 @@ const withWorktree = Effect.fn("git.withWorktree")(function* (repo, number, use)
 		"--force",
 		directory
 	]));
-	return yield* Effect.acquireUseRelease(Effect.flatMap(remove, () => git([
+	return yield* Effect.acquireUseRelease(beating(cutting("cutting a worktree of", repo), () => Effect.flatMap(remove, () => git([
 		"-C",
 		clone,
 		"worktree",
@@ -806,7 +942,7 @@ const withWorktree = Effect.fn("git.withWorktree")(function* (repo, number, use)
 		"--detach",
 		directory,
 		head
-	])), () => use({
+	]))), () => use({
 		directory,
 		head
 	}), () => remove);
@@ -935,11 +1071,11 @@ const reuseResolutions = Effect.fn("git.reuseResolutions")(function* (clone) {
 */
 const standingWorktree = Effect.fn("git.standingWorktree")(function* (repo, number, prBranch, session) {
 	const { clone, directory, head } = yield* whereToCut(repo, number, under[session]);
-	const branch = `dw-mc/${session}/${number}`;
+	const branch = sessionBranch(session, number);
 	const ahead = yield* aheadOf(clone, branch, head);
 	if (ahead > 0) return yield* new WorktreeHeld({
 		directory,
-		detail: `The last fix session on ${repo}#${number} left ${ahead} commit${ahead === 1 ? "" : "s"} that the pull request's head does not have. Push them or drop them before opening another session.`
+		detail: `The last fix session on ${repo}#${number} left ${commits(ahead)} that the pull request's head does not have. Push them or drop them before opening another session.`
 	});
 	if ((yield* worktreesOf(clone)).includes(directory)) yield* git([
 		"-C",
@@ -950,7 +1086,7 @@ const standingWorktree = Effect.fn("git.standingWorktree")(function* (repo, numb
 	]);
 	yield* perWorktreeConfig(clone);
 	if (session === "rebase") yield* reuseResolutions(clone);
-	yield* git([
+	yield* beating(cutting("cutting a worktree of", repo), () => git([
 		"-C",
 		clone,
 		"worktree",
@@ -959,7 +1095,7 @@ const standingWorktree = Effect.fn("git.standingWorktree")(function* (repo, numb
 		branch,
 		directory,
 		head
-	]);
+	]));
 	yield* git([
 		"-C",
 		clone,
@@ -1181,11 +1317,9 @@ const clear = { _tag: "clear" };
 * pruned or moved by hand still leaves the branch holding the commits.
 */
 const holding = Effect.fn("git.holding")(function* (repo, number, session) {
-	const path = yield* Path.Path;
-	const state = yield* stateDirectory;
-	const clone = path.join(state, clonesIn, `${repo}.git`);
-	const directory = path.join(state, under[session], repo, String(number));
-	const branch = `dw-mc/${session}/${number}`;
+	const clone = yield* cloneAt(repo);
+	const directory = yield* cutAt(under[session], repo, number);
+	const branch = sessionBranch(session, number);
 	if ((yield* Effect.orElseSucceed(git([
 		"-C",
 		directory,
@@ -1208,7 +1342,7 @@ const holding = Effect.fn("git.holding")(function* (repo, number, session) {
 		"-C",
 		clone,
 		"rev-parse",
-		`refs/dw-mc/pr/${number}`
+		pullRef(number)
 	]), () => "");
 	if (head.trim() === "") return {
 		_tag: "held",
@@ -1217,7 +1351,7 @@ const holding = Effect.fn("git.holding")(function* (repo, number, session) {
 	const ahead = yield* aheadOf(clone, branch, head.trim());
 	return ahead === 0 ? clear : {
 		_tag: "held",
-		detail: `${ahead} commit${ahead === 1 ? "" : "s"} that the pull request's head does not have`
+		detail: `${commits(ahead)} that the pull request's head does not have`
 	};
 });
 /**
@@ -1482,7 +1616,7 @@ const lines$3 = (it, state, path, paint) => {
 const cleanup = Command.make("cleanup", { yes: yesFlag }, Effect.fn("cleanup")(function* ({ yes }) {
 	const path = yield* Path.Path;
 	const paint = yield* Paint;
-	const found = yield* inventory;
+	const found = yield* beating((since) => `measuring the state directory · ${since}`, () => inventory);
 	const it = plan(found);
 	if (empty(it)) {
 		yield* Console.log(`Nothing to take back in ${found.directory}.`);
@@ -1914,6 +2048,40 @@ const prConversation = Effect.fnUntraced(function* (repo, number) {
 	}], ...threads];
 });
 //#endregion
+//#region src/cli/exit.ts
+/**
+* The failures a command owes me a sentence for rather than a stack.
+*
+* Every one of them is a machine or a file that needs fixing, and the message
+* says what to fix. Anything not named here is a fault of the tool's own, and a
+* stack is what I want to see for those.
+*/
+const userFacing = [
+	"ConfigMalformed",
+	"GhUnavailable",
+	"GhReadFailed",
+	"GhUnreadable"
+];
+/** The same, for a command that also runs `git` against the tool's own clone. */
+const userFacingAndGit = [...userFacing, "GitFailed"];
+/**
+* The same, for a command that cuts a standing worktree and opens an agent
+* session in it.
+*
+* `dw-mc fix` and `dw-mc resolve` are the two, and they fail the same ways
+* because they do the same thing to different findings: a worktree that holds
+* work of mine and an agent that would not run are the session's failures, not
+* either command's.
+*/
+const userFacingAndSession = [
+	...userFacing,
+	"GitFailed",
+	"WorktreeHeld",
+	"AgentFailed"
+];
+/** Turns one of those into the sentence the CLI prints, and the exit code it leaves. */
+const asUserError = (cause) => Effect.fail(new CliError.UserError({ cause }));
+//#endregion
 //#region src/domain/moment.ts
 const isLater = Order.isGreaterThan(DateTime.Order);
 /** Whether `self` happened after `other`, counting never as before anything. */
@@ -1925,7 +2093,15 @@ const isSame = (self, other) => self === null || other === null ? 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
+//#region src/terms/pr.ts
+/**
+* What GitHub says about a pull request, in this tool's words.
+*
+* The three of them are here because both sides need the same one: `gh` and the
+* checks adapter answer in these words, and the bucket rules decide on them. A
+* union restated on each side is a case that goes unreachable the day the other
+* side gains a member.
+*/
 /** How far GitHub has got towards letting a tracked PR merge. */
 const Mergeability = Schema.Literals([
 	"mergeable",
@@ -1946,6 +2122,8 @@ const ChecksState = Schema.Literals([
 	"pending",
 	"none"
 ]);
+//#endregion
+//#region src/domain/bucket.ts
 /**
 * Everything the bucket rules are allowed to know about a tracked PR.
 *
@@ -2002,6 +2180,15 @@ const order = [
 */
 const unanswered = "a comment I have not answered";
 /**
+* Why a PR is mine to move when a review run found something that withholds
+* the stamp.
+*
+* It is named for the reason `unanswered` is: `dw-mc stamp` says this same
+* sentence about this same number, and two spellings of it would be two
+* answers to what a blocking finding is worth.
+*/
+const blockedBy = (n) => `${n} blocking finding${n === 1 ? "" : "s"}`;
+/**
 * 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.
@@ -2011,7 +2198,7 @@ const needsMe = (facts) => {
 	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 (facts.blockingFindings > 0) return blockedBy(facts.blockingFindings);
 	if (isAfter(facts.newestHumanCommentAt, later(facts.myLastCommentAt, facts.myLastCommitAt))) return unanswered;
 	return null;
 };
@@ -2121,2036 +2308,2084 @@ const resolve$1 = (text, registered) => {
 	};
 };
 //#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}.`;
+//#region src/domain/findings.ts
+/** Whether a review run found anything at all. */
+const Verdict = Schema.Literals(["clean", "findings"]);
+/**
+* Every severity word a review may answer with.
+*
+* The first three are ours, and the only ones a run is asked for. The rest are
+* the persona a run with no slash command carries, which grades in its own
+* words: a turn that comes back in them is worth reading rather than throwing
+* away.
+*/
+const Spelling = Schema.Literals([
+	"error",
+	"warning",
+	"info",
+	"Critical",
+	"Required",
+	"Optional",
+	"Nit",
+	"FYI"
+]);
+/** What each of those words weighs. The record is exhaustive, so neither list can drift. */
+const severityOf = {
+	error: "error",
+	warning: "warning",
+	info: "info",
+	Critical: "error",
+	Required: "error",
+	Optional: "warning",
+	Nit: "info",
+	FYI: "info"
 };
-/** 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) }));
+const Weighed = Spelling.pipe(Schema.decodeTo(Severity, SchemaTransformation.transform({
+	decode: (word) => severityOf[word],
+	encode: (severity) => severity
+})));
+/** The fields both spellings of a finding share. Only the severity differs. */
+const shared = {
+	file: Schema.String,
+	line: Schema.Int,
+	summary: Schema.String
 };
+/** One problem a review run reports, at a file and line. */
+const Finding = Schema.Struct({
+	...shared,
+	severity: Severity
+});
 /**
-* 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.
+* What a review run found: the shape the tool keeps, and the one a fix session
+* is later handed.
 */
-const refuse = (why) => why === null ? Effect.void : Effect.fail(new CliError.UserError({ cause: why }));
+const Findings = Schema.Struct({
+	verdict: Verdict,
+	findings: Schema.Array(Finding)
+});
 /**
-* What the last sweep learned about one pull request, or the sentence sending
-* me to a sweep.
-*
-* 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.
+* The same findings as a runner may spell them, which is what the second turn's
+* output is read with.
 *
-* 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.
+* A word nothing maps fails here, and a failed read is a failure of the run:
+* findings the tool cannot weigh are not findings it can act on.
 */
-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;
+const Reported = Schema.Struct({
+	verdict: Verdict,
+	findings: Schema.Array(Schema.Struct({
+		...shared,
+		severity: Weighed
+	}))
 });
-//#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.
+* The schema every runner must satisfy, as the JSON Schema a runner is handed.
 *
-* 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.
+* It is derived from the schema the findings are kept under rather than written
+* out beside it, so a runner is asked for exactly the shape that is persisted.
+* `Reported` is wider on purpose and only on the severity: what a runner is
+* asked for is our three words, and a persona's five are read where they arrive
+* anyway rather than being asked for.
+*/
+const jsonSchema = JSON.stringify(SchemaRepresentation.toJsonSchemaDocument(SchemaRepresentation.toRepresentation(Findings.ast)).schema);
+/**
+* The findings as the Markdown a report is written in.
 *
-* On a table, the pull request opens itself: the reference carries the URL for
-* the terminal to follow, and nothing else on the row does. What it leads to is
-* where the row already says it is, so a row read where no link can be followed
-* - a pipe, a paste, a terminal that ignores the sequence - loses nothing.
+* It is what a schema-held run's report says: with a schema in force a run
+* answers in findings and not in prose, so the report kept beside it is written
+* from the findings themselves rather than left empty.
 */
-/** 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"
+const asMarkdown = (found) => found.findings.length === 0 ? "Clean: the run found nothing to report." : found.findings.map((finding) => `- \`${finding.file}:${finding.line}\` ${finding.severity}: ${finding.summary}`).join("\n");
+/** Where each severity sits against the others, so the bar can be compared with it. */
+const rank = {
+	info: 0,
+	warning: 1,
+	error: 2
 };
 /**
-* The mark that says which bucket a row is in without being read.
+* The findings that withhold the stamp: everything at `blocksOn` or above it.
 *
-* 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.
+* `stamp.blocks_on` is my bar rather than a constant, so a repository whose
+* warnings I do not want to merge past is configured rather than coded. An
+* error blocks wherever the bar is, because nothing weighs more than one.
 */
-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, and it carries no link at all: 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,
-* and a link costs it the whole URL. The table has no such arithmetic to keep
-* straight, so its rows say it in more than one place and open the pull request
-* besides.
-*/
-const cells = (placed, stamped, room, paint, lead) => {
-	const { facts } = placed;
-	const { bucket } = placed.placement;
-	const say = tint(paint, bucket);
-	const reference = `${facts.repo}#${facts.number}`;
-	const named = lead === "named";
-	const pr = `${named ? reference : paint.link(reference, facts.url)}${facts.draft ? paint.dim(" (draft)") : ""}${stamped ? ` ${paint.green("✓")}` : ""}`;
-	return 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)
-	];
-};
+const blocking = (findings, blocksOn) => findings.filter((finding) => rank[finding.severity] >= rank[blocksOn]);
 //#endregion
-//#region src/adapters/ci.ts
+//#region src/domain/review.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.
+* What a review run came to, which is what its second turn reported.
+*
+* A failure is recorded as one and is never a clean verdict: a turn that exited
+* badly, ran out of patience or answered in a shape that does not validate has
+* found nothing, which is not the same as having found nothing wrong.
 */
-const failing = /* @__PURE__ */ new Set([
-	"FAILURE",
-	"TIMED_OUT",
-	"CANCELLED",
-	"STARTUP_FAILURE",
-	"ACTION_REQUIRED",
-	"ERROR"
-]);
-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 ?? "");
+const Outcome = Schema.Union([Schema.TaggedStruct("reported", {
+	verdict: Verdict,
+	findings: Schema.Array(Finding)
+}), Schema.TaggedStruct("failed", { detail: Schema.String })]);
 /**
-* What the rollup comes to: red when anything failed, pending only while
-* nothing has failed yet, green when every check that counts has passed.
+* One review run against a tracked PR at a specific head commit.
 *
-* `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 review run outlives the command that started it: the
+* state directory is where the next sweep learns that this head has been
+* reviewed, and where a fix session finds what there is to fix.
 */
-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 ReviewRun = Schema.Struct({
+	repo: Schema.String,
+	number: Schema.Int,
+	/** The head the run covers. A run never vouches for code it did not see. */
+	head: Schema.String,
+	/**
+	* The slash command line the run opened on, or null where it opened on the
+	* tool's own prompt. A report found months later says what it was asked, and a
+	* record an earlier version wrote carries no such field and is forgotten.
+	*/
+	command: Schema.NullOr(Schema.String),
+	effort: Schema.NullOr(Effort),
+	/**
+	* The agent session the run happened in, or null where it never reached one.
+	*
+	* A run that would not start or exited before it said anything has no session,
+	* and the run is still recorded: a failure is recorded as what it is.
+	*/
+	sessionId: Schema.NullOr(Schema.String),
+	ranAt: Schema.DateTimeUtcFromString,
+	outcome: Outcome
+});
+/** A head as it is read out loud: the seven characters git itself abbreviates to. */
+const short = (head) => head.slice(0, 7);
 /**
-* 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.
+* Where a run is kept: one key per head, so a run and the code it read cannot
+* drift apart, and a re-review replaces the run before it.
 */
-const failedChecks = (entries, ignore) => checksThatCount(entries, ignore).filter(hasFailed);
+const runKey = (repo, number, head) => `${prKey(repo, number)}@${head}`;
+/** Where the run's report is kept: beside the run, as the Markdown it is. */
+const reportKey = (repo, number, head) => `${runKey(repo, number, head)}.md`;
 /**
-* What a check reports on, out of the URL it reports at.
+* Which head a pull request was last reviewed at: an index beside `runKey` and
+* `reportKey` rather than a thing the glossary names.
 *
-* 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.
+* A run is kept under the head it read, which answers the question a sweep asks
+* of one head. The re-run rule and `dw-mc findings` ask the other one - which
+* head the last run was at - and this is where they read it, so neither has to
+* ask GitHub what is current before it can look anything up.
 */
-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 })) }));
+const LastReviewed = Schema.Struct({ head: Schema.String });
+/** Where that head is kept. No head is spelled `latest`, so nothing collides. */
+const latestKey = (repo, number) => `${prKey(repo, number)}@latest`;
 /**
-* 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.
+* The run at one head, or none where nothing has reviewed it.
+*
+* A head is where the question is asked - the stamp, the bucket and `dw-mc
+* findings` all ask about one commit - and one read off the disk answers it
+* without an index to keep in step.
+*
+* Forgetting a run costs one review.
 */
-const defaultBranch = Effect.fnUntraced(function* (repo) {
-	return (yield* readJson("repo view defaultBranchRef", "gh", [
-		"repo",
-		"view",
-		repo,
-		"--json",
-		"defaultBranchRef"
-	], RepoDefaultBranch)).defaultBranchRef?.name ?? "main";
+const runAt = Effect.fn("review.runAt")(function* (repo, number, head) {
+	const runs = yield* storeFor("runs", ReviewRun);
+	return yield* remembered(runs.get(runKey(repo, number, head)));
+});
+/** The last review run on a pull request, or none where it has had none. */
+const lastRun = Effect.fn("review.lastRun")(function* (repo, number) {
+	const heads = yield* storeFor("runs", LastReviewed);
+	const at = yield* remembered(heads.get(latestKey(repo, number)));
+	return Option.isNone(at) ? Option.none() : yield* runAt(repo, number, at.value.head);
 });
-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"
-]);
 /**
-* Whether `workflow` is red on `branch` right now.
+* What a run reported, or null where it reported nothing at all.
 *
-* 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.
+* A failure is not a clean verdict: a run that could not report has found
+* nothing, which is not the same as having found nothing wrong. Everything that
+* reads a run's findings reads them through here, so the distinction is drawn
+* once rather than at every caller that might forget it.
 */
-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);
-});
+const reportedBy = (run) => run.outcome._tag === "reported" ? {
+	verdict: run.outcome.verdict,
+	findings: run.outcome.findings
+} : null;
 /**
-* How much of a failing job's log is kept.
+* Why a run reported nothing, or null where it reported.
 *
-* 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.
+* The sibling of `reportedBy`, and here for the same reason: the two halves of
+* an outcome are read through one place each rather than re-narrowed at every
+* caller.
 */
-const logTailBytes = 65536;
+const detailOf = (run) => run.outcome._tag === "failed" ? run.outcome.detail : null;
 /**
-* What one failing job printed, from the end.
+* Whether the files changed since the last run are worth paying for another.
 *
-* `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 question is deliberately about what changed rather than how much: one
+* line outside the `docs_only` globs is code nobody has reviewed, and a
+* thousand lines inside them are still prose.
 */
-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 worthRerunning = (changed, docsOnly) => changed.some((file) => !docsOnly.some((glob) => matchesGlob(file, glob)));
 /**
-* The workflow runs behind the failing checks that count, each named once.
-*
-* One broken run usually fails several jobs, and re-running it once per failing
-* job would start the same run over and over.
+* The re-run rule: the head this run is skipped against, or null where it runs.
 *
-* `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.
+* A review costs real money and minutes of my attention, and a typo fix is not
+* worth either. Four things are never skipped, because the rule is here to save
+* me a review and not to stand between me and one I asked for: a pull request
+* with no run behind it, a run that reported nothing, a comparison GitHub would
+* not answer, and anything that changed outside the globs. A head that has
+* already had a run changed nothing at all, which is the one case that needs no
+* comparison to decide.
 */
-const failedRuns = (entries, ignore) => [...new Set(failedChecks(entries, ignore).flatMap((check) => {
-	const reported = reportedAt(check.detailsUrl);
-	return reported === null ? [] : [reported.run];
-}))];
+const skippedSince = (asked, docsOnly) => {
+	if (asked.last === null || reportedBy(asked.last) === null) return null;
+	const changed = asked.last.head === asked.head ? [] : asked.changed;
+	return changed === null || worthRerunning(changed, docsOnly) ? null : asked.last.head;
+};
+/** What a run was opened on, as the report says it. */
+const askedOf$1 = (run) => run.command === null ? "the tool's own prompt" : [run.command, run.effort].filter((part) => part !== null).join(" ");
 /**
-* Asks GitHub to run one workflow run's failed jobs again.
+* The report as it is written down: what it is of, then what the run said.
 *
-* `--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.
+* The heading is the whole point of writing it rather than storing the prose
+* alone - a file found months later says which pull request, which commit and
+* what the run was asked, without anything else having to be open.
 */
-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
+const reportDocument = (run, title, prose) => [
+	`# ${run.repo}#${run.number} ${title}`,
+	"",
+	`- head: ${run.head}`,
+	`- run: ${askedOf$1(run)}`,
+	`- ran: ${DateTime.formatIso(run.ranAt)}`,
+	"",
+	prose.trim(),
+	""
+].join("\n");
 /**
-* The failures that are flaky wherever they appear: a machine, a network or a
-* runner giving up, never a test disagreeing with the code.
+* Whether `head` has the review it needs.
 *
-* `ci.flaky_patterns` adds to this list rather than replacing it, because the
-* failures a repository of mine produces are extra ones, not different ones.
+* A run that reported nothing does not count, which is the same rule
+* `reportedBy` draws everywhere else: a failure has found nothing, not found
+* nothing wrong.
 */
-const builtInPatterns = [
-	"timed out",
-	"deadline exceeded",
-	"ETIMEDOUT",
-	"ECONNRESET",
-	"ECONNREFUSED",
-	"connection refused",
-	"socket hang up",
-	"lock timeout",
-	"could not obtain lock",
-	"runner lost communication",
-	"The runner has received a shutdown signal",
-	"net/http: request canceled",
-	"ResourceExhausted",
-	"Too many open files",
-	"no space left on device"
-];
-const baseName = (path) => path.slice(path.lastIndexOf("/") + 1);
+const reviewedBy = (run) => run !== null && reportedBy(run) !== null;
+/** The findings at one head that withhold the stamp. */
+const blockingIn = (run, blocksOn) => {
+	const found = run === null ? null : reportedBy(run);
+	return found === null ? [] : blocking(found.findings, blocksOn);
+};
 /**
-* The changed file the log names, preferring one it spells in full.
+* What the review runs on `head` say about it, for the stamp to rest on.
 *
-* A bare file name is worth matching - a stack trace often prints nothing else
-* - and it is worth matching second, because a name as ordinary as `index.ts`
-* belongs to more repositories than mine.
-*/
-const escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-/**
-* Whether the log names a file called `base` rather than some longer name
-* ending in it: a changed `src/a.ts` is not what a log printing `data.ts` is
-* complaining about.
-*/
-const namesFile = (log, base) => new RegExp(`(^|[^\\w.-])${escaped(base)}`).test(log);
-const namedChangedFile = (log, changedFiles) => changedFiles.find((file) => log.includes(file)) ?? changedFiles.find((file) => namesFile(log, baseName(file))) ?? null;
-/**
-* The flaky pattern the log matches, mine before the built-in ones.
+* Whether a head has been reviewed is the runs' to say and no sweep's: a run is
+* recorded against one head, and a head with no run of its own has not been
+* reviewed however many sweeps have seen the pull request. A run that could not
+* report findings does not count either: its verdict is what takes a pull
+* request out of Needs review run, and it reached none.
 *
-* A pattern is text and not a regular expression: it comes out of a
-* configuration file I edit by hand, where a stray `*` should cost me a missed
-* match and never a crash.
+* It is one function because the two callers are a sweep and `dw-mc merge`, and
+* the second exists to land what the first only describes: two spellings of
+* this would be two answers to whether a head has been reviewed.
 */
-const matchedPattern = (log, patterns) => {
-	const haystack = log.toLowerCase();
-	return [...patterns, ...builtInPatterns].find((pattern) => haystack.includes(pattern.toLowerCase())) ?? null;
+const reviewedAt = Effect.fn("review.reviewedAt")(function* (repo, number, head, blocksOn) {
+	const run = Option.getOrNull(yield* runAt(repo, number, head));
+	return {
+		reviewRunHead: reviewedBy(run) ? head : null,
+		blockingFindings: blockingIn(run, blocksOn).length
+	};
+});
+//#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) }));
 };
 /**
-* Whether a red CI is mine to fix, and why.
+* What a command that acts on one pull request opens with: which pull request
+* it is, and what the configuration says about its repository.
 *
-* Two of the signals say flaky and one says legitimate, and the one outranks
-* the two: a log that names a file this pull request changes is the failure
-* pointing at my own work, and a workflow that is broken everywhere does not
-* stop it pointing there.
+* Nine commands ask the file the same three questions before they do anything
+* else, and asking them here is what keeps the answers the same: which
+* repositories are registered decides what a bare `28` may name, and a command
+* that read the file its own way would resolve a different pull request from
+* the one beside it.
 *
-* Everything else that is unexplained is mine as well. The two mistakes do not
-* cost the same - a real failure called flaky is a broken pull request nobody
-* tells me about, while a flake called mine costs me one look - so the default
-* is the one I can recover from.
+* `settings` and `launcher` come back whether or not this command wants them,
+* because both are a merge of records already in hand and neither reads
+* anything. The file itself does not, so nothing downstream keeps a copy of it.
 */
-const classify = (evidence, flakyPatterns) => {
-	const named = namedChangedFile(evidence.log, evidence.changedFiles);
-	if (named !== null) return {
-		classification: "legitimate",
-		reason: `the log names ${named}, which this PR changes`
-	};
-	const redOnDefaultBranch = evidence.alsoRedOnDefaultBranch[0];
-	const pattern = matchedPattern(evidence.log, flakyPatterns);
-	const excuses = [redOnDefaultBranch === void 0 ? null : `${redOnDefaultBranch} is red on the default branch too`, pattern === null ? null : `the log matches "${pattern}"`].filter((it) => it !== null);
-	return excuses.length === 0 ? {
-		classification: "legitimate",
-		reason: "nothing explains the failure"
-	} : {
-		classification: "flaky",
-		reason: excuses.join(", and ")
+const forPr = Effect.fn("pr.forPr")(function* (pr) {
+	const file = Option.getOrElse(yield* read, () => ({}));
+	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
+	return {
+		repo,
+		number,
+		settings: settingsFor(file, repo),
+		launcher: launcherOf(file)
 	};
-};
+});
 /**
-* How many failing jobs the log is read from.
+* A domain guard's word, as the command's own failure.
 *
-* One broken workflow usually fails several jobs with the same cause, and the
-* logs are the one read here that is measured in megabytes.
+* 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 loggedJobs = 3;
-/** The values of `xs` that `f` has one for. */
-const filterMap = (xs, f) => xs.flatMap((x) => {
-	const b = f(x);
-	return b === null ? [] : [b];
-});
-/** No evidence at all, which is what an unreadable CI comes to. */
-const nothing$1 = {
-	alsoRedOnDefaultBranch: [],
-	changedFiles: [],
-	log: ""
-};
+const refuse = (why) => why === null ? Effect.void : Effect.fail(new CliError.UserError({ cause: why }));
 /**
-* What a red CI looks like to the classifier.
+* What the last sweep learned about one pull request, or the sentence sending
+* me to a sweep.
 *
-* A read that fails costs its own signal and nothing else. GitHub drops an
-* Actions log after ninety days, so a pull request open that long would
-* otherwise lose its row over a log nobody can fetch any more - and a missing
-* signal only ever moves the verdict towards legitimate, which is the answer
-* that puts the pull request in front of me rather than hiding it.
+* 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 that are missing and facts this version cannot read come to the same
+* sentence, because a sweep can write them again either way.
 */
-const evidenceFor = Effect.fn("flaky.evidenceFor")(function* (repo, number, entries, ignore) {
-	const failed = failedChecks(entries, ignore);
-	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$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), () => []),
-		Effect.forEach(jobs, (job) => Effect.orElseSucceed(jobLog(repo, job), () => ""))
-	], { concurrency: 3 });
-	return {
-		alsoRedOnDefaultBranch: alsoRed.flat(),
-		changedFiles,
-		log: logs.join("\n")
-	};
+const swept = Effect.fn("pr.swept")(function* (repo, number) {
+	const store = yield* storeFor("prs", Facts);
+	const facts = yield* remembered(store.get(prKey(repo, number)));
+	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;
 });
 /**
-* Why a red CI is excused, or null where it is mine to fix.
+* The review run whose findings are the current ones, or the sentence saying
+* there are none.
 *
-* Reading the evidence and classifying it is one act, so it is one function:
-* a sweep writes what it returns down as `ciFlaky`, and `dw-mc rerun` asks it
-* again live. Two callers asking the same question have to get the same answer,
-* which they cannot if each of them spells the question out.
+* The last run on the pull request is what "current" means here, and it is read
+* off the state directory rather than worked out from GitHub: the commands that
+* ask are ones I run inside a fix session, where another round trip to GitHub
+* buys nothing the run it is about to fix does not already say.
 */
-const flakyReason = Effect.fn("flaky.flakyReason")(function* (repo, number, entries, ignore, patterns) {
-	const verdict = classify(yield* evidenceFor(repo, number, entries, ignore), patterns);
-	return verdict.classification === "flaky" ? verdict.reason : null;
+const currentRun = Effect.fn("pr.currentRun")(function* (repo, number) {
+	const run = yield* lastRun(repo, number);
+	if (Option.isNone(run)) return yield* new CliError.UserError({ cause: `No review run on ${repo}#${number}. Run dw-mc review ${number} first.` });
+	return run.value;
 });
+/**
+* The guard reads of one command, under a heartbeat.
+*
+* Every command that acts on a pull request reads its guards live rather than
+* off the last sweep, because each of them is about the pull request as it is
+* now. That read is a second or two against GitHub before a word can be
+* printed, and it used to be spent on a blank screen.
+*
+* There is nothing to count here - two or three calls, and a number counting to
+* three says less than the words do - so the line is what is being read and how
+* long it has taken. It gives the heartbeat no aside, so a piped command prints
+* what it always printed.
+*/
+const reading = (where, read) => beating((since) => `reading ${where} · ${since}`, () => read);
 //#endregion
-//#region src/domain/quiet.ts
-/** The pulse of a PR a previous sweep recorded. */
-const pulseOf = (facts) => ({
-	head: facts.head,
-	checks: facts.checks,
-	newestHumanCommentAt: facts.newestHumanCommentAt
-});
+//#region src/cli/row.ts
 /**
-* Whether a PR is where the last sweep left it.
+* How one tracked PR is written down, wherever it is written down.
 *
-* A quiet PR keeps the facts it already had rather than being read out again,
-* so a sweep over many pull requests spends its time on the few that moved.
-*/
-const isQuiet = (previous, current) => previous.head === current.head && previous.checks === current.checks && isSame(previous.newestHumanCommentAt, current.newestHumanCommentAt);
-//#endregion
-//#region src/domain/rebase.ts
-/**
-* How many pull requests this one stands on.
+* 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.
 *
-* A branch is walked to what it merges into and on from there, however deep the
-* stack goes. Every pull request the walk has already counted is left alone,
-* which is what keeps two branches that merge into each other from being walked
-* around forever.
+* 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.
+*
+* On a table, the pull request opens itself: the reference carries the URL for
+* the terminal to follow, and nothing else on the row does. What it leads to is
+* where the row already says it is, so a row read where no link can be followed
+* - a pipe, a paste, a terminal that ignores the sequence - loses nothing.
 */
-const ancestorsOf = (pr, open, seen) => {
-	let count = 0;
-	let current = pr;
-	for (;;) {
-		const parent = open.find((it) => it.head === current.base && !seen.has(it.number));
-		if (parent === void 0) return count;
-		seen.add(parent.number);
-		count += 1;
-		current = parent;
-	}
+/** 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"
 };
 /**
-* How deep the stack goes above this pull request.
+* The mark that says which bucket a row is in without being read.
 *
-* Two branches cut from the same one are not two stacks deep, they are two
-* branches, so what counts is the deepest single line of them rather than how
-* many pull requests stand above it in total.
+* 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 descendantsOf = (pr, open, seen) => {
-	let deepest = 0;
-	for (const child of open.filter((it) => it.base === pr.head && !seen.has(it.number))) {
-		seen.add(child.number);
-		deepest = Math.max(deepest, 1 + descendantsOf(child, open, seen));
-	}
-	return deepest;
+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 = " │ ";
 /**
-* Where a pull request sits in its stack, or null where it is in none.
+* One row: which pull request, what it is, and what it waits on.
 *
-* A stack is read off the branches alone: a pull request that merges into
-* another pull request's branch, or that another one merges into, is part of
-* one. The tool does not understand stacks and never drives them, so this
-* exists to recognise one and say where the pull request sits in it.
+* 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, and it carries no link at all: 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,
+* and a link costs it the whole URL. The table has no such arithmetic to keep
+* straight, so its rows say it in more than one place and open the pull request
+* besides.
 */
-const stackOf = (number, open) => {
-	const pr = open.find((it) => it.number === number);
-	if (pr === void 0) return null;
-	const seen = /* @__PURE__ */ new Set([number]);
-	const below = ancestorsOf(pr, open, seen);
-	const above = descendantsOf(pr, open, seen);
-	return below === 0 && above === 0 ? null : {
-		position: below + 1,
-		length: below + above + 1
-	};
+const cells = (placed, stamped, room, paint, lead) => {
+	const { facts } = placed;
+	const { bucket } = placed.placement;
+	const say = tint(paint, bucket);
+	const reference = `${facts.repo}#${facts.number}`;
+	const named = lead === "named";
+	const pr = `${named ? reference : paint.link(reference, facts.url)}${facts.draft ? paint.dim(" (draft)") : ""}${stamped ? ` ${paint.green("✓")}` : ""}`;
+	return 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/comments.ts
 /**
-* Why this branch is nobody's to touch here, or null where it is mine.
+* One thread's share of a strand, cut to what is worth reading.
 *
-* These are the guards about the branch rather than about what is done to it,
-* which is why they are their own and why they say nothing about pushing: who
-* authored the pull request and where its branch lives is the boundary itself -
-* a branch somebody else authored and a branch in a fork are not mine to work
-* on, whatever else is true of them and whichever command asks. A stack comes
-* next, and a pull request the stack was not read from counts as one, because a
-* stack the tool cannot see is one it could drive: the tool does not understand
-* stacks, so the one thing it has to say about one is where the pull request
-* sits in it.
+* 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 boundary = (branch) => {
-	const where = `${branch.repo}#${branch.number}`;
-	if (!branch.mine) return `${where} is not mine. dw-mc works on branches I author and on nothing else.`;
-	if (branch.fromFork) return `${where} is opened from a fork, so its branch is not in ${branch.repo}. dw-mc works only on a branch in the repository it read.`;
-	if (!branch.listed) return `${where} was not among the open pull requests of ${branch.repo}, so nothing here can say whether it is in a stack. Read it again before touching the branch.`;
-	if (branch.stack !== null) return `${where} is ${branch.stack.position} of ${branch.stack.length} in a stack. dw-mc does not understand stacks and will not drive one; rebase it with whatever built the stack.`;
-	return null;
+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
+	}];
 };
 /**
-* Why this branch is not one to rebase, or null where it is.
+* The threads worth putting on screen, given what I have already done.
 *
-* This is the single place the guards live, and they matter more than the
-* rebase itself: a force push is the one write the tool makes that can lose
-* work, and every rule here is about it never being a surprise.
+* `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.
 *
-* Being off is said first, because a repository that has not turned rebase on
-* has decided the question and nothing else about the pull request changes it.
-* The branch's own guards come next. CI is last and costs the most to get
-* wrong - rebasing while a run is in flight cancels the run I am waiting on,
-* and a red build is mine to fix where it is.
+* 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 decide$3 = (situation) => {
-	const where = `${situation.repo}#${situation.number}`;
-	if (!situation.enabled) return `Rebase is off for ${situation.repo}. Set rebase.enabled: true for it in the config to turn it on, so a force push is never a surprise.`;
-	const refused = boundary(situation);
-	if (refused !== null) return refused;
-	if (situation.checks === "pending") return `CI is still running on ${where}. A rebase now would cancel the run you are waiting on.`;
-	if (situation.checks === "red") return `CI is red on ${where}, which is yours to fix before the branch moves.`;
-	return null;
+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}`;
 /**
-* A rebase that conflicted: the head it conflicted at and the files it stopped
-* on.
-*
-* The head is what the record is scoped to, as it is for a withdrawn stamp: a
-* conflict is about the code the branch is at, so it lasts exactly as long as
-* that code is what the pull request is. A branch that moved is a branch
-* nothing here has tried to rebase yet.
+* What is true of a thread beyond where it hangs.
 *
-* The paths are what makes the conflict something to open: `a rebase
-* conflicted` cannot tell a stale lockfile from half the pull request. They are
-* an optional key rather than a required one so a record an older version wrote
-* still reads, and a conflict with no paths still puts the pull request in
-* Needs me.
+* 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 Conflict = Schema.Struct({
-	head: Schema.String,
-	paths: Schema.optionalKey(Schema.Array(Schema.String))
-});
+const settled = (thread) => [thread.resolved ? "resolved" : null, thread.outdated ? "outdated" : null].filter((it) => it !== null).join(", ");
 /**
-* The conflict a rebase last left on this pull request, or null where it left
-* none.
+* One thread as a block: where it hangs, then everybody who said something in
+* it, then what they said in full.
 *
-* A record this version cannot read is one another version of it wrote, and a
-* conflict is worth a bucket rather than a failed sweep: forgetting it costs
-* the pull request one reason to be in Needs me, where failing here would cost
-* me the whole table.
+* 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 conflictFor = Effect.fn("rebase.conflictFor")(function* (repo, number) {
-	const store = yield* storeFor("rebases", Conflict);
-	const conflict = yield* Effect.orElseSucceed(store.get(prKey(repo, number)), () => Option.none());
-	return Option.getOrNull(conflict);
-});
-/** Writes down that a rebase of `head` conflicted on `paths`, which is the only head it holds for. */
-const recordConflict = Effect.fn("rebase.recordConflict")(function* (repo, number, head, paths) {
-	yield* (yield* storeFor("rebases", Conflict)).set(prKey(repo, number), {
-		head,
-		paths
-	});
-});
-//#endregion
-//#region src/domain/findings.ts
-/** Whether a review run found anything at all. */
-const Verdict = Schema.Literals(["clean", "findings"]);
+const block$1 = (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]);
 /**
-* Every severity word a review may answer with.
+* The conversation on screen: people first, then a rule, then the bots.
 *
-* The first three are ours, and the only ones a run is asked for. The rest are
-* the persona a run with no slash command carries, which grades in its own
-* words: a turn that comes back in them is worth reading rather than throwing
-* away.
-*/
-const Spelling = Schema.Literals([
-	"error",
-	"warning",
-	"info",
-	"Critical",
-	"Required",
-	"Optional",
-	"Nit",
-	"FYI"
-]);
-/** What each of those words weighs. The record is exhaustive, so neither list can drift. */
-const severityOf = {
-	error: "error",
-	warning: "warning",
-	info: "info",
-	Critical: "error",
-	Required: "error",
-	Optional: "warning",
-	Nit: "info",
-	FYI: "info"
+* The rule is there so the two are never read as one list. A bot's comment is
+* observed and never answered, 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$1(thread, paint));
+	const bots = view.bots.map((thread) => block$1(thread, paint));
+	return separated([...people, ...bots.length === 0 ? [] : [[paint.dim("── bots ──")], ...bots]]);
 };
-const Weighed = Spelling.pipe(Schema.decodeTo(Severity, SchemaTransformation.transform({
-	decode: (word) => severityOf[word],
-	encode: (severity) => severity
-})));
-/** The fields both spellings of a finding share. Only the severity differs. */
-const shared = {
-	file: Schema.String,
-	line: Schema.Int,
-	summary: Schema.String
+/** What to say where there is nothing to print, which depends on why there is not. */
+const nothing$1 = (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];
 };
-/** One problem a review run reports, at a file and line. */
-const Finding = Schema.Struct({
-	...shared,
-	severity: Severity
-});
-/**
-* What a review run found: the shape the tool keeps, and the one a fix session
-* is later handed.
-*/
-const Findings = Schema.Struct({
-	verdict: Verdict,
-	findings: Schema.Array(Finding)
-});
 /**
-* The same findings as a runner may spell them, which is what the second turn's
-* output is read with.
+* The conversation on one tracked pull request, and nothing else.
 *
-* A word nothing maps fails here, and a failed read is a failure of the run:
-* findings the tool cannot weigh are not findings it can act on.
+* 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 Reported = Schema.Struct({
-	verdict: Verdict,
-	findings: Schema.Array(Schema.Struct({
-		...shared,
-		severity: Weighed
-	}))
-});
+const comments = Command.make("comments", {
+	pr: prArgument,
+	all: allFlag
+}, Effect.fn("comments")(function* ({ all, pr }) {
+	const { number, repo } = yield* forPr(pr);
+	const facts = yield* swept(repo, number);
+	const paint = yield* Paint;
+	const view = shown(yield* reading(`${repo}#${number}`, prConversation(repo, number)), {
+		since: later(facts.myLastCommentAt, facts.myLastCommitAt),
+		all
+	});
+	if (view.people.length === 0 && view.bots.length === 0) {
+		yield* Effect.forEach(nothing$1(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(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));
+const jsonFlag = Flag.Boolean("json").pipe(Flag.withDefault(false), Flag.withDescription("Print the findings as the JSON a fix session is handed"));
+/** What a run's findings come to in one line, against the bar that blocks. */
+const summary = (found, blocksOn) => {
+	if (found.findings.length === 0) return "clean, nothing to fix";
+	const blocked = blocking(found.findings, blocksOn).length;
+	return `${count(found.findings.length, "finding")}, ${blocked} blocking`;
+};
+/** Which run these findings are, and what they come to: the line above the list. */
+const header$1 = (run, found, blocksOn) => `${run.repo}#${run.number}  ${short(run.head)}  ${summary(found, blocksOn)}`;
 /**
-* The schema every runner must satisfy, as the JSON Schema a runner is handed.
-*
-* It is derived from the schema the findings are kept under rather than written
-* out beside it, so a runner is asked for exactly the shape that is persisted.
-* `Reported` is wider on purpose and only on the severity: what a runner is
-* asked for is our three words, and a persona's five are read where they arrive
-* anyway rather than being asked for.
+* The findings one to a line, in the order the run reported them, ruled so the
+* three columns read apart.
 */
-const jsonSchema = JSON.stringify(SchemaRepresentation.toJsonSchemaDocument(SchemaRepresentation.toRepresentation(Findings.ast)).schema);
+const lines$1 = (found) => table(found.findings.map((finding) => [
+	`${finding.file}:${finding.line}`,
+	finding.severity,
+	finding.summary
+]), rule);
 /**
-* The findings as the Markdown a report is written in.
+* What the run reported, or the sentence saying it reported nothing at all.
 *
-* It is what a schema-held run's report says: with a schema in force a run
-* answers in findings and not in prose, so the report kept beside it is written
-* from the findings themselves rather than left empty.
+* A run that failed is not a clean one: a pipe must never be handed "no
+* findings" when what happened is that nothing could be read.
 */
-const asMarkdown = (found) => found.findings.length === 0 ? "Clean: the run found nothing to report." : found.findings.map((finding) => `- \`${finding.file}:${finding.line}\` ${finding.severity}: ${finding.summary}`).join("\n");
-/** Where each severity sits against the others, so the bar can be compared with it. */
-const rank = {
-	info: 0,
-	warning: 1,
-	error: 2
+const whatItFound = (run) => {
+	const found = reportedBy(run);
+	return found === null ? Effect.fail(new CliError.UserError({ cause: `The review run on ${short(run.head)} reported no findings: ${run.outcome._tag === "failed" ? run.outcome.detail : ""}\nRun dw-mc review ${run.number} --force to run it again.` })) : Effect.succeed(found);
 };
 /**
-* The findings that withhold the stamp: everything at `blocksOn` or above it.
+* What the current review run found, as a table or as the JSON it is kept in.
 *
-* `stamp.blocks_on` is my bar rather than a constant, so a repository whose
-* warnings I do not want to merge past is configured rather than coded. An
-* error blocks wherever the bar is, because nothing weighs more than one.
+* `--json` is the whole point of the command: it prints the findings and
+* nothing else, so I can pipe them anywhere, and a fix session inside an open
+* agent reads exactly what the tool recorded rather than a retelling of it.
+*
+* A run that failed prints no findings and fails: a review run that could not
+* report has found nothing, which is not the same as having found nothing
+* wrong, and a pipe must never be handed the second when the first is true.
 */
-const blocking = (findings, blocksOn) => findings.filter((finding) => rank[finding.severity] >= rank[blocksOn]);
+const findings = Command.make("findings", {
+	pr: prArgument,
+	json: jsonFlag
+}, Effect.fn("findings")(function* ({ json, pr }) {
+	const { number, repo, settings } = yield* forPr(pr);
+	const run = yield* currentRun(repo, number);
+	const found = yield* whatItFound(run);
+	if (json) {
+		yield* Console.log(yield* asJson$2(found));
+		return;
+	}
+	yield* Console.log(header$1(run, found, settings.stamp.blocks_on));
+	for (const line of lines$1(found)) yield* Console.log(`  ${line}`);
+}, Effect.catchTag(["ConfigMalformed"], asUserError))).pipe(Command.withDescription("Print what the current review run found on one pull request"));
 //#endregion
-//#region src/domain/review.ts
+//#region src/adapters/agent.ts
 /**
-* What a review run came to, which is what its second turn reported.
+* How one turn of Claude Code is spawned and given up on, and what a turn that
+* answers against a schema comes back with.
 *
-* A failure is recorded as one and is never a clean verdict: a turn that exited
-* badly, ran out of patience or answered in a shape that does not validate has
-* found nothing, which is not the same as having found nothing wrong.
+* Every turn is reached this way, so the spawn, the patience and the one failure
+* they can end in live here rather than once per turn.
 */
-const Outcome = Schema.Union([Schema.TaggedStruct("reported", {
-	verdict: Verdict,
-	findings: Schema.Array(Finding)
-}), Schema.TaggedStruct("failed", { detail: Schema.String })]);
+/** A review run that would not start, would not finish, or finished badly. */
+var AgentFailed = class extends Schema.TaggedError()("AgentFailed", {
+	/** The program that was spawned, which is what a search for it has to name. */
+	program: Schema.String,
+	detail: Schema.String
+}) {
+	get message() {
+		return `The ${this.program} review run failed: ${this.detail}`;
+	}
+};
 /**
-* One review run against a tracked PR at a specific head commit.
+* Failures in the name of the program that was spawned.
 *
-* It is a schema because a review run outlives the command that started it: the
-* state directory is where the next sweep learns that this head has been
-* reviewed, and where a fix session finds what there is to fix.
+* Where the launcher starts `claude` through another program, it is that
+* program that would not start or exited badly, and saying `claude` sends the
+* search to the wrong process.
 */
-const ReviewRun = Schema.Struct({
-	repo: Schema.String,
-	number: Schema.Int,
-	/** The head the run covers. A run never vouches for code it did not see. */
-	head: Schema.String,
-	/**
-	* The slash command line the run opened on, or null where it opened on the
-	* tool's own prompt. A report found months later says what it was asked, and a
-	* record an earlier version wrote carries no such field and is forgotten.
-	*/
-	command: Schema.NullOr(Schema.String),
-	effort: Schema.NullOr(Effort),
-	/**
-	* The agent session the run happened in, or null where it never reached one.
-	*
-	* A run that would not start or exited before it said anything has no session,
-	* and the run is still recorded: a failure is recorded as what it is.
-	*/
-	sessionId: Schema.NullOr(Schema.String),
-	ranAt: Schema.DateTimeUtcFromString,
-	outcome: Outcome
+const failedBy = (program) => (detail) => new AgentFailed({
+	program,
+	detail
 });
-/** A head as it is read out loud: the seven characters git itself abbreviates to. */
-const short = (head) => head.slice(0, 7);
-/**
-* Where a run is kept: one key per head, so a run and the code it read cannot
-* drift apart, and a re-review replaces the run before it.
-*/
-const runKey = (repo, number, head) => `${repo}#${number}@${head}`;
-/** Where the run's report is kept: beside the run, as the Markdown it is. */
-const reportKey = (repo, number, head) => `${runKey(repo, number, head)}.md`;
 /**
-* Which head a pull request was last reviewed at: an index beside `runKey` and
-* `reportKey` rather than a thing the glossary names.
+* How long each turn gets before it is given up on.
 *
-* A run is kept under the head it read, which answers the question a sweep asks
-* of one head. The re-run rule and `dw-mc findings` ask the other one - which
-* head the last run was at - and this is where they read it, so neither has to
-* ask GitHub what is current before it can look anything up.
+* The review is the turn that thinks, and a high-effort one that fans out to
+* subagents takes real minutes, so its limit is there to catch a run that has
+* stopped rather than one that is slow. The second turn reads no code and
+* decides nothing - the review it reports on is already in the session it
+* resumes - and every run of it by hand came back in seconds.
+*
+* Either way, a command that hangs forever is worse than one that says it
+* failed: a review I walked away from is one I need to be able to come back to.
 */
-const LastReviewed = Schema.Struct({ head: Schema.String });
-/** Where that head is kept. No head is spelled `latest`, so nothing collides. */
-const latestKey = (repo, number) => `${repo}#${number}@latest`;
+const patience = {
+	reviewing: Duration.minutes(45),
+	reporting: Duration.minutes(5)
+};
 /**
-* The run at one head, or none where nothing has reviewed it.
+* One turn of the launcher in `directory`, with `read` over its standard output.
 *
-* A head is where the question is asked - the stamp, the bucket and `dw-mc
-* findings` all ask about one commit - and one read off the disk answers it
-* without an index to keep in step.
-*
-* A run this version cannot read is a run another version of this record wrote,
-* and the state directory is a cache of work that can be done again: forgetting
-* it costs one review, where failing here would cost me the command I asked for.
+* The launcher's own arguments go in front of the turn's, because they are what
+* gets `claude` started at all. The two output streams are drained together,
+* because draining one to the end first can block a run that is still writing to
+* the other. Every way a turn can fail to finish comes back from here as a
+* `AgentFailed`, so a caller is left with the turn's own answer and nothing else
+* to translate - a turn that never comes back included.
 */
-const runAt = Effect.fn("review.runAt")(function* (repo, number, head) {
-	const runs = yield* storeFor("runs", ReviewRun);
-	return yield* Effect.orElseSucceed(runs.get(runKey(repo, number, head)), () => Option.none());
-});
-/** The last review run on a pull request, or none where it has had none. */
-const lastRun = Effect.fn("review.lastRun")(function* (repo, number) {
-	const heads = yield* storeFor("runs", LastReviewed);
-	const at = yield* Effect.orElseSucceed(heads.get(latestKey(repo, number)), () => Option.none());
-	return Option.isNone(at) ? Option.none() : yield* runAt(repo, number, at.value.head);
+const turn = Effect.fnUntraced(function* (options) {
+	const [program, ...prefix] = options.command;
+	const failed = failedBy(program);
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const running = Effect.gen(function* () {
+		const handle = yield* Effect.mapError(spawner.spawn(ChildProcess.make(program, [...prefix, ...options.args], {
+			cwd: options.directory,
+			stdin: "pipe"
+		})), (error) => failed(error.message));
+		const [got, stderr] = yield* Effect.mapError(Effect.all([options.read(handle.stdout), Stream.mkString(Stream.decodeText(handle.stderr))], { concurrency: 2 }), (error) => failed(error.message));
+		const exitCode = yield* Effect.mapError(handle.exitCode, (error) => failed(error.message));
+		if (exitCode !== 0) return yield* failed(stderr.trim() === "" ? `${program} exited ${exitCode}` : stderr.trim());
+		return got;
+	});
+	return yield* Effect.timeoutOrElse(running, {
+		duration: options.patience.duration,
+		orElse: () => failed(`${options.patience.turn} did not come back within ${Duration.format(options.patience.duration)}`)
+	});
 });
+//#endregion
+//#region src/adapters/claude.ts
 /**
-* What a run reported, or null where it reported nothing at all.
-*
-* A failure is not a clean verdict: a run that could not report has found
-* nothing, which is not the same as having found nothing wrong. Everything that
-* reads a run's findings reads them through here, so the distinction is drawn
-* once rather than at every caller that might forget it.
-*/
-const reportedBy = (run) => run.outcome._tag === "reported" ? {
-	verdict: run.outcome.verdict,
-	findings: run.outcome.findings
-} : null;
-/**
-* Why a run reported nothing, or null where it reported.
-*
-* The sibling of `reportedBy`, and here for the same reason: the two halves of
-* an outcome are read through one place each rather than re-narrowed at every
-* caller.
+* Claude Code: a review on a slash command, a review on the tool's own prompt,
+* and the sessions I steer.
 */
-const detailOf = (run) => run.outcome._tag === "failed" ? run.outcome.detail : null;
 /**
-* Whether the files changed since the last run are worth paying for another.
-*
-* The question is deliberately about what changed rather than how much: one
-* line outside the `docs_only` globs is code nobody has reviewed, and a
-* thousand lines inside them are still prose.
+* The two events of a stream-json run this reads, as the runner really writes
+* them. Every other field of both, and every other event, is ignored: a
+* transcript carries hooks, rate limits, thinking and tool results, and a
+* version that adds another must not stop a run from being read.
 */
-const worthRerunning = (changed, docsOnly) => changed.some((file) => !docsOnly.some((glob) => matchesGlob(file, glob)));
+const Working = Schema.Struct({
+	type: Schema.Literal("assistant"),
+	message: Schema.Struct({ content: Schema.Array(Schema.Struct({
+		type: Schema.String,
+		name: Schema.optionalKey(Schema.String),
+		text: Schema.optionalKey(Schema.String)
+	})) })
+});
+const Ended = Schema.Struct({
+	type: Schema.Literal("result"),
+	subtype: Schema.String,
+	is_error: Schema.Boolean,
+	session_id: Schema.String,
+	result: Schema.optionalKey(Schema.String),
+	/** What a turn given a JSON schema validated, which this hands on unread. */
+	structured_output: Schema.optionalKey(Schema.Unknown)
+});
+const asWorking = Schema.decodeUnknownOption(Schema.fromJsonString(Working));
+const asResult = Schema.decodeUnknownOption(Schema.fromJsonString(Ended));
+const heardIn = (line) => {
+	const blocks = Option.match(asWorking(line), {
+		onNone: () => [],
+		onSome: (event) => event.message.content
+	});
+	return {
+		tools: blocks.flatMap((block) => block.type === "tool_use" && block.name !== void 0 ? [block.name] : []),
+		said: blocks.flatMap((block) => block.type === "text" && block.text !== void 0 ? [block.text] : [])
+	};
+};
 /**
-* The re-run rule: the head this run is skipped against, or null where it runs.
+* The result a turn ended on, or the failure it really was.
 *
-* A review costs real money and minutes of my attention, and a typo fix is not
-* worth either. Four things are never skipped, because the rule is here to save
-* me a review and not to stand between me and one I asked for: a pull request
-* with no run behind it, a run that reported nothing, a comparison GitHub would
-* not answer, and anything that changed outside the globs. A head that has
-* already had a run changed nothing at all, which is the one case that needs no
-* comparison to decide.
+* A turn that said nothing this can read and a turn Claude Code itself calls an
+* error are both failures: `subtype` is where a run that hit its turn limit or
+* lost its connection says so, and its `result` is the only word on why.
 */
-const skippedSince = (asked, docsOnly) => {
-	if (asked.last === null || reportedBy(asked.last) === null) return null;
-	const changed = asked.last.head === asked.head ? [] : asked.changed;
-	return changed === null || worthRerunning(changed, docsOnly) ? null : asked.last.head;
+const ended = (program, result) => {
+	const failed = failedBy(program);
+	if (Option.isNone(result)) return Effect.fail(failed("the turn came back with no result"));
+	const { is_error, result: lastWord, subtype } = result.value;
+	return is_error || subtype !== "success" ? Effect.fail(failed(`${subtype}: ${lastWord ?? "nothing else was said"}`)) : Effect.succeed(result.value);
 };
-/** What a run was opened on, as the report says it. */
-const askedOf$1 = (run) => run.command === null ? "the tool's own prompt" : [run.command, run.effort].filter((part) => part !== null).join(" ");
 /**
-* The report as it is written down: what it is of, then what the run said.
+* A Claude Code `stream-json` turn, read as it arrives: what it reached for goes
+* to `onTool` while the run is still going, and what it said and how it ended
+* are what comes back.
 *
-* The heading is the whole point of writing it rather than storing the prose
-* alone - a file found months later says which pull request, which commit and
-* what the run was asked, without anything else having to be open.
+* Both shapes of review read a turn the same way, so the fold is here rather
+* than once per shape.
 */
-const reportDocument = (run, title, prose) => [
-	`# ${run.repo}#${run.number} ${title}`,
-	"",
-	`- head: ${run.head}`,
-	`- run: ${askedOf$1(run)}`,
-	`- ran: ${DateTime.formatIso(run.ranAt)}`,
-	"",
-	prose.trim(),
-	""
-].join("\n");
+const transcript = (onTool) => (stdout) => stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.mapEffect((line) => {
+	const heard = heardIn(line);
+	return Effect.as(Effect.forEach(heard.tools, onTool, { discard: true }), {
+		line,
+		heard
+	});
+}), Stream.runFold(() => ({
+	said: [],
+	result: Option.none()
+}), (soFar, { heard, line }) => ({
+	said: [...soFar.said, ...heard.said],
+	result: Option.orElse(asResult(line), () => soFar.result)
+})));
 /**
-* Whether `head` has the review it needs.
+* One review run on a slash command, headless, in `directory`.
 *
-* A run that reported nothing does not count, which is the same rule
-* `reportedBy` draws everywhere else: a failure has found nothing, not found
-* nothing wrong.
-*/
-const reviewedBy = (run) => run !== null && reportedBy(run) !== null;
-/** The findings at one head that withhold the stamp. */
-const blockingIn = (run, blocksOn) => {
-	const found = run === null ? null : reportedBy(run);
-	return found === null ? [] : blocking(found.findings, blocksOn);
-};
-/**
-* What the review runs on `head` say about it, for the stamp to rest on.
+* The run is in the foreground and says what it is doing as it does it, which
+* is what `onTool` is for: a review takes minutes, and a terminal that prints
+* nothing for minutes is one I stop trusting.
 *
-* Whether a head has been reviewed is the runs' to say and no sweep's: a run is
-* recorded against one head, and a head with no run of its own has not been
-* reviewed however many sweeps have seen the pull request. A run that could not
-* report findings does not count either: its verdict is what takes a pull
-* request out of Needs review run, and it reached none.
+* `--json-schema` is never passed here: verified by running it, the flag beside
+* `/code-review` breaks the run, which is why a slash command costs a second
+* turn that resumes the session and asks for the findings. My own instructions
+* ride on `--append-system-prompt` rather than on the command's own line,
+* because what a slash command does with its arguments is its business and not
+* this tool's.
 *
-* It is one function because the two callers are a sweep and `dw-mc merge`, and
-* the second exists to land what the first only describes: two spellings of
-* this would be two answers to whether a head has been reviewed.
+* `--comment` is the flag that makes the built-in review post on the pull
+* request, and it is never passed either (ADR 0002). The report is everything
+* the run said on its own turns rather than the `result` alone: verified by
+* running it, a repository whose review command fans out to subagents can end on
+* a remark about them, and the report is the turn before that.
 */
-const reviewedAt = Effect.fn("review.reviewedAt")(function* (repo, number, head, settings) {
-	const run = Option.getOrNull(yield* runAt(repo, number, head));
+const commandReview = Effect.fn("claude.commandReview")(function* (options) {
+	const [program] = options.launcher.command;
+	const run = yield* turn({
+		command: options.launcher.command,
+		directory: options.directory,
+		args: [
+			"-p",
+			options.line,
+			"--output-format",
+			"stream-json",
+			"--verbose",
+			...options.instructions === null ? [] : ["--append-system-prompt", options.instructions],
+			...options.model === null ? [] : ["--model", options.model]
+		],
+		patience: {
+			turn: "the review",
+			duration: patience.reviewing
+		},
+		read: transcript(options.onTool)
+	});
+	const { result: lastWord, session_id } = yield* ended(program, run.result);
+	const report = (run.said.length === 0 ? lastWord ?? "" : run.said.join("\n\n")).trim();
+	if (report === "") return yield* failedBy(program)("the run came back with an empty report");
 	return {
-		reviewRunHead: reviewedBy(run) ? head : null,
-		blockingFindings: blockingIn(run, settings.stamp.blocks_on).length
+		report,
+		sessionId: session_id
 	};
-});
-//#endregion
-//#region src/cli/sweep.ts
-const writtenBy = (comments, login) => comments.filter((comment) => comment.login === login).map((comment) => comment.at);
-const byHumansOtherThan = (comments, login) => comments.filter((comment) => !comment.bot && comment.login !== login).map((comment) => comment.at);
+}, Effect.scoped);
 /**
-* The facts about one tracked PR, read from GitHub and kept on disk.
+* What the second turn asks for.
 *
-* The cheap reads happen every time, because they are what says whether the PR
-* moved. The commits are asked for only when it did: `gh` returns every commit
-* message in full, and on a PR that is where the last sweep left it that whole
-* read buys a timestamp the state directory already has.
+* It asks for a report of what was already said rather than for another look:
+* the prose is the review, and this turn is only what makes it machine
+* readable. The shape it must answer in arrives as a JSON schema beside it, so
+* the prompt does not describe the schema twice.
 */
-const sweepPr = Effect.fn("sweep.pullRequest")(function* (store, me, found, settings) {
-	const view = yield* prView(found.repo, found.number);
-	const [onThePr, inReviews] = yield* Effect.all([prComments(found.repo, found.number), prReviews(found.repo, found.number)], { concurrency: 2 });
-	const comments = [...onThePr, ...inReviews];
-	const checks = rollupState(view.statusCheckRollup, settings.ci.ignore);
-	const newestHumanCommentAt = newest(byHumansOtherThan(comments, me));
-	const key = prKey(found.repo, found.number);
-	const previous = Option.getOrUndefined(yield* Effect.orElseSucceed(store.get(key), () => Option.none()));
-	const reviewed = yield* reviewedAt(found.repo, found.number, view.headRefOid, settings);
-	const quiet = previous !== void 0 && isQuiet(pulseOf(previous), {
-		head: view.headRefOid,
-		checks,
-		newestHumanCommentAt
-	}) ? previous : void 0;
-	const myLastCommitAt = quiet !== void 0 ? quiet.myLastCommitAt : newest((yield* prCommits(found.repo, found.number)).filter((commit) => commit.logins.includes(me)).map((commit) => commit.at));
-	const ciFlaky = checks !== "red" ? null : quiet !== void 0 ? quiet.ciFlaky : yield* flakyReason(found.repo, found.number, view.statusCheckRollup, settings.ci.ignore, settings.ci.flaky_patterns);
-	const rebaseConflictAt = yield* Effect.map(conflictFor(found.repo, found.number), (it) => it?.head ?? null);
-	const facts = {
-		repo: found.repo,
-		number: found.number,
-		title: view.title,
-		url: view.url,
-		draft: view.isDraft,
-		head: view.headRefOid,
-		mergeable: mergeabilityOf(view.mergeable),
-		reviewDecision: reviewDecisionOf(view.reviewDecision),
-		checks,
-		ciFlaky,
-		rebaseConflictAt,
-		newestHumanCommentAt,
-		myLastCommentAt: newest(writtenBy(comments, me)),
-		myLastCommitAt,
-		...reviewed
-	};
-	yield* store.set(key, facts);
-	return facts;
-});
-/** A read that came back, or the trouble it came back with instead. */
-const attempt = (where, read) => read.pipe(Effect.map((got) => ({
-	got,
-	troubles: []
-})), Effect.catch((error) => Effect.succeed({
-	got: [],
-	troubles: [{
-		where,
-		detail: error.message
-	}]
-})));
-const gather = (attempts) => ({
-	got: attempts.flatMap((it) => it.got),
-	troubles: attempts.flatMap((it) => it.troubles)
-});
-/** How many reads of GitHub are in flight at once. */
-const concurrency = 4;
+const reportFindings = [
+	"Report the findings of the review you just gave as structured output.",
+	"Every finding carries the file it is in as a repository path, the line it is at,",
+	"its severity and a one-sentence summary.",
+	"The verdict is clean when there is nothing to report and findings otherwise.",
+	"Report nothing you did not already say."
+].join(" ");
 /**
-* One pass over every tracked PR, and nothing else: a sweep only ever reads.
+* The second turn of a review run: the prose the first one wrote, back as
+* findings that validate.
 *
-* Every repository and every pull request is read on its own, so one of them
-* failing costs me its rows and leaves the rest of the table standing. What
-* failed comes back beside the facts rather than instead of them.
+* It resumes the first turn's session rather than reading the diff again, which
+* is what makes it cheap and what makes it accurate - verified by running it,
+* the line numbers it reports beat the ones the prose gives. The output is
+* handed on as it arrived: what the findings must look like belongs to the
+* domain, and the schema the run is held to comes in from there too.
+*
+* Every way this can end badly ends as an `AgentFailed`, because a review run
+* that could not report is a failure and never a clean verdict.
 */
-const sweep = Effect.gen(function* () {
-	const file = Option.getOrElse(yield* read, () => ({}));
-	const repos = Object.keys(file.repos ?? {}).toSorted();
-	if (repos.length === 0) return {
-		repos,
-		facts: [],
-		troubles: []
-	};
-	const store = yield* storeFor("prs", Facts);
-	const me = yield* viewer;
-	const found = gather(yield* Effect.forEach(repos, (repo) => attempt(repo, searchPrs(repo)), { concurrency }));
-	const swept = gather(yield* Effect.forEach(found.got, (pr) => attempt(`${pr.repo}#${pr.number}`, Effect.map(sweepPr(store, me, pr, settingsFor(file, pr.repo)), (facts) => [facts])), { concurrency }));
+const findingsTurn = Effect.fn("claude.findingsTurn")(function* (options) {
+	const [program] = options.launcher.command;
+	const printed = yield* turn({
+		command: options.launcher.command,
+		directory: options.directory,
+		patience: {
+			turn: "the findings turn",
+			duration: patience.reporting
+		},
+		args: [
+			"-p",
+			"--resume",
+			options.sessionId,
+			reportFindings,
+			"--output-format",
+			"json",
+			"--json-schema",
+			options.jsonSchema
+		],
+		read: (stdout) => Stream.mkString(Stream.decodeText(stdout))
+	});
+	const { structured_output } = yield* ended(program, asResult(printed.trim()));
+	if (structured_output === void 0) return yield* failedBy(program)("the findings turn came back with no structured output");
+	return structured_output;
+}, Effect.scoped);
+/**
+* One review run of the tool's own review prompt, in `directory`.
+*
+* It is one turn rather than two: verified by running it, `--json-schema` beside
+* an ordinary prompt gives both the prose the run wrote and the
+* `structured_output` it validated, where the same flag on a slash command
+* breaks the run. The schema arrives as inline JSON and never as a path - a path
+* is where Claude Code reports `--json-schema is not valid JSON`.
+*/
+const promptReview = Effect.fn("claude.promptReview")(function* (options) {
+	const [program] = options.launcher.command;
+	const run = yield* turn({
+		command: options.launcher.command,
+		directory: options.directory,
+		patience: {
+			turn: "the review",
+			duration: patience.reviewing
+		},
+		args: [
+			"-p",
+			options.prompt,
+			"--output-format",
+			"stream-json",
+			"--verbose",
+			"--json-schema",
+			options.jsonSchema,
+			...options.model === null ? [] : ["--model", options.model]
+		],
+		read: transcript(options.onTool)
+	});
+	const { session_id, structured_output } = yield* ended(program, run.result);
+	if (structured_output === void 0) return yield* failedBy(program)("the review came back with no structured output");
+	const prose = run.said.join("\n\n").trim();
 	return {
-		repos,
-		facts: swept.got,
-		troubles: [...found.troubles, ...swept.troubles]
+		findings: structured_output,
+		sessionId: session_id,
+		prose: prose === "" ? null : prose
 	};
-}).pipe(Effect.withSpan("sweep"));
+}, Effect.scoped);
 /**
-* The failures a sweep can hit before it has a single row, which are the ones
-* worth a sentence: a machine or a file that needs fixing says what to fix
-* instead of printing a stack.
+* One review run, in whichever shape it was configured in.
+*
+* A slash command takes two turns and the tool's own prompt takes one, which is
+* Claude Code's doing and nobody else's: a caller hands over the turn and gets
+* the same answer back either way.
+*
+* The second turn's failure is kept beside the first turn's prose rather than
+* replacing it. A review that ran and could not report is still worth reading,
+* and it is recorded as the failure it is.
 */
-const userFacing = [
-	"ConfigMalformed",
-	"GhUnavailable",
-	"GhReadFailed",
-	"GhUnreadable"
-];
-/** Turns one of those into the sentence the CLI prints. */
-const asUserError = (cause) => Effect.fail(new CliError.UserError({ cause }));
-/** What a sweep could not read, under a heading, so the table above it stands alone. */
-const printTroubles = Effect.fn("sweep.printTroubles")(function* (troubles) {
-	if (troubles.length === 0) return;
-	yield* Console.log("");
-	yield* Console.log("Could not load");
-	for (const trouble of troubles) yield* Console.log(`  ${trouble.where}  ${trouble.detail}`);
+const reviewTurns = Effect.fn("claude.reviewTurns")(function* (options) {
+	const { directory, jsonSchema, launcher, model, onTool } = options;
+	if (options.turn._tag === "prompt") {
+		const run = yield* promptReview({
+			launcher,
+			directory,
+			prompt: options.turn.text,
+			model,
+			jsonSchema,
+			onTool
+		});
+		return {
+			sessionId: run.sessionId,
+			prose: run.prose,
+			findings: Result.succeed(run.findings)
+		};
+	}
+	const run = yield* commandReview({
+		launcher,
+		directory,
+		line: options.turn.line,
+		instructions: options.turn.instructions,
+		model,
+		onTool
+	});
+	const findings = yield* Effect.result(findingsTurn({
+		launcher,
+		directory,
+		sessionId: run.sessionId,
+		jsonSchema
+	}));
+	return {
+		sessionId: run.sessionId,
+		prose: run.report,
+		findings
+	};
 });
 /**
-* Refreshes what mission control knows about every tracked PR.
+* An interactive `claude` in `directory`, opened on `prompt`, with my terminal
+* handed straight to it.
 *
-* `dw-mc status` does this too, so this command is for the pass on its own:
-* warming the state directory, or seeing what GitHub would not answer.
+* The launcher's `fix_args` go here and nowhere else: they are the flags of
+* every session I steer - the one on findings and the one on a conflict - which
+* no headless review turn wants. They sit in front of the
+* prompt, because `claude` takes its flags before its positional argument.
+*
+* This is the one place a run is not read: the three streams are inherited,
+* so what is on the screen is the session itself and not a transcript of it,
+* and what I type reaches it. The child is not detached for the same reason -
+* a detached child sits outside the terminal's foreground process group, where
+* neither my keystrokes nor Ctrl-C would reach it.
+*
+* There is no patience here either. A session I steer lasts as long as I am in
+* it, and a timeout would be the tool closing a session I was still working in.
+*
+* What comes back is the code the session ended on. A session I left with
+* Ctrl-C ended badly for `claude` and not for me, so this reports it rather
+* than failing on it; only a `claude` that would not start at all is a failure.
 */
-const sweepCommand = Command.make("sweep", {}, Effect.fn("sweep.command")(function* () {
-	const report = yield* sweep;
-	yield* Console.log(report.repos.length === 0 ? "No repositories registered. Run dw-mc init inside a repository to register it." : `Swept ${count(report.facts.length, "pull request")} across ${report.repos.length === 1 ? "1 repository" : `${report.repos.length} repositories`}`);
-	yield* printTroubles(report.troubles);
-}, Effect.catchTag(userFacing, asUserError))).pipe(Command.withDescription("Refresh what mission control knows about every tracked pull request"));
+const steeredSession = Effect.fn("claude.steeredSession")(function* (options) {
+	const [program, ...prefix] = options.launcher.command;
+	const failed = failedBy(program);
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const handle = yield* Effect.mapError(spawner.spawn(ChildProcess.make(program, [
+		...prefix,
+		...options.launcher.fix_args,
+		options.prompt
+	], {
+		cwd: options.directory,
+		stdin: "inherit",
+		stdout: "inherit",
+		stderr: "inherit",
+		detached: false
+	})), (error) => failed(error.message));
+	return yield* Effect.mapError(handle.exitCode, (error) => failed(error.message));
+}, Effect.scoped);
 //#endregion
-//#region src/domain/comments.ts
+//#region src/domain/fix.ts
+/** One finding I chose to act on, carrying what I think about it. */
+const Chosen = Schema.Struct({
+	...Finding.fields,
+	note: Schema.optionalKey(Schema.String)
+});
 /**
-* 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.
+* What a fix session is handed: the findings I picked, and the review run they
+* came from.
 *
-* 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.
+* The head is in it because a fix session opens on the commit that was
+* reviewed, and a finding's line means nothing away from it.
 */
-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
-	}];
-};
+const Selection = Schema.Struct({
+	repo: Schema.String,
+	number: Schema.Int,
+	head: Schema.String,
+	findings: Schema.Array(Chosen)
+});
+/** The selection as the JSON the schema defines, rather than as this file spells it. */
+const asJson$1 = Schema.encodeEffect(Schema.fromJsonString(Selection));
 /**
-* The threads worth putting on screen, given what I have already done.
+* The prompt a fix session opens on: what these findings are, and the findings
+* themselves as JSON.
 *
-* `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.
+* The findings go in verbatim rather than described, because a re-description
+* is where a file, a line or my own note quietly changes. A note outranks the
+* finding it is on: the finding is what the review thought, the note is what I
+* think, and I am the one who picked it.
 *
-* 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.
+* Pushing is mine either way, and `commits` says whether committing is too.
+* The tool itself never commits and never pushes; what the session may do
+* inside the worktree is my call, made once in `fix.commits` or for one session
+* with the flag.
 */
-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))
-	};
-};
+const promptFor$1 = (selection, commits) => Effect.map(asJson$1(selection), (json) => [
+	`These are the findings I picked from a dw-mc review run on ${selection.repo}#${selection.number}, at ${short(selection.head)}, the commit their lines are counted from.`,
+	"Work through them one at a time. Where a finding carries a note, the note is mine and outranks the finding's own summary; where it carries none, the summary is the whole brief.",
+	commits ? `Commit what you change, one logical change to a commit. Do not push: I read the commits and push them myself.` : `Do not commit and do not push: I do both myself when I have read what you changed.`,
+	json
+].join("\n\n"));
+/**
+* Why these findings cannot be fixed where the pull request now is, or nothing
+* where they can.
+*
+* A pull request that moved since its last review run has findings at lines
+* that may no longer be there, and a worktree cut at the new head would carry
+* them into code they were never about. Reviewing again is cheap next to fixing
+* the wrong thing.
+*/
+const staleAt = (number, run, now) => run === now ? null : `The findings are from ${short(run)} and the pull request is now at ${short(now)}. Run dw-mc review ${number} again to review the head you would be fixing.`;
 //#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}`;
+//#region src/cli/fix.ts
+const printFlag$1 = Flag.Boolean("print").pipe(Flag.withDefault(false), Flag.withDescription("Print the prompt a session would open on, and open none"));
+const commitFlag = Flag.Boolean("commit").pipe(Flag.withDescription("Let this session commit what it changes, over what the repository configured"), Flag.optional);
 /**
-* What is true of a thread beyond where it hangs.
+* The findings to pick from, each on the line `dw-mc findings` gives it.
 *
-* 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.
+* The rows come from there rather than being built again here, so the list I
+* pick from and the list I read are the same list. A row that does not fit the
+* screen is cut: a prompt draws its own frame around the row, and a row that
+* wraps takes the whole list's alignment with it.
 */
-const settled = (thread) => [thread.resolved ? "resolved" : null, thread.outdated ? "outdated" : null].filter((it) => it !== null).join(", ");
+const choicesOf$1 = (found, screen) => {
+	const rows = lines$1(found);
+	const room = screen === 0 ? Number.POSITIVE_INFINITY : screen - 6;
+	return found.findings.map((finding, index) => ({
+		title: truncate(rows[index] ?? finding.summary, room),
+		value: finding
+	}));
+};
 /**
-* One thread as a block: where it hangs, then everybody who said something in
-* it, then what they said in full.
+* Each picked finding with whatever I have to say about it.
 *
-* 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.
+* The note is asked for one finding at a time, in the order I see them, and
+* having nothing to say is the ordinary answer rather than a step I have to get
+* past.
 */
-const block$1 = (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]);
+const noted = Effect.fn("fix.noted")(function* (picked) {
+	const chosen = [];
+	for (const finding of picked) {
+		const said = yield* note(`Note on ${finding.file}:${finding.line}, or nothing`);
+		chosen.push(Option.match(said, {
+			onNone: () => finding,
+			onSome: (text) => ({
+				...finding,
+				note: text
+			})
+		}));
+	}
+	return chosen;
+});
 /**
-* The conversation on screen: people first, then a rule, then the bots.
+* A fix session: the findings I picked, in an agent session I steer.
 *
-* The rule is there so the two are never read as one list. A bot's comment is
-* observed and never answered, and the bucket rules ignore bots for exactly
-* this reason.
+* The tool fixes nothing. It picks the findings apart with me, cuts a worktree
+* on a branch of its own that tracks the pull request's, and hands the session
+* what I chose as JSON; then it is out of the way. I steer and I push. Nothing
+* here writes to GitHub, and the tool itself commits nothing: whether the
+* session may commit inside the worktree is `fix.commits`, or `--commit` for
+* one session.
 *
-* 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.
+* The worktree is left standing when the session ends, because the work in it
+* is mine and an unpushed commit lives nowhere else. Re-reviewing the result is
+* a new review run against the new head, never a continuation of the run that
+* produced these findings, so what was reviewed at which commit stays honest.
 */
-const lines$2 = (view, paint) => {
-	const people = view.people.map((thread) => block$1(thread, paint));
-	const bots = view.bots.map((thread) => block$1(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];
+const fix = Command.make("fix", {
+	pr: prArgument,
+	commit: commitFlag,
+	print: printFlag$1
+}, Effect.fn("fix")(function* ({ commit, pr, print }) {
+	const { number, repo, settings, launcher } = yield* forPr(pr);
+	const run = yield* currentRun(repo, number);
+	const found = yield* whatItFound(run);
+	yield* Console.log(header$1(run, found, settings.stamp.blocks_on));
+	if (found.findings.length === 0) return;
+	const view = yield* reading(`${repo}#${number}`, prView(repo, number));
+	yield* refuse(staleAt(number, run.head, view.headRefOid));
+	const picked = yield* choose("Which findings does the session carry?", choicesOf$1(found, yield* width));
+	const chosen = yield* Effect.catchTag(noted(Option.getOrElse(picked, () => [])), "QuitError", () => Effect.succeed([]));
+	if (chosen.length === 0) {
+		yield* Console.log("Nothing picked, so no session was opened.");
+		return;
+	}
+	const commits = Option.getOrElse(commit, () => settings.fix.commits);
+	if (print) {
+		yield* Console.log(yield* promptFor$1({
+			repo,
+			number,
+			head: run.head,
+			findings: chosen
+		}, commits));
+		return;
+	}
+	const worktree = yield* standingWorktree(repo, number, view.headRefName, "fix");
+	yield* Console.log(`  ${chosen.length} of ${found.findings.length} findings, ${commits ? "committing" : "not committing"}`);
+	yield* Console.log(`  ${worktree.directory}, pushing to ${view.headRefName}`);
+	const ended = yield* steeredSession({
+		launcher,
+		directory: worktree.directory,
+		prompt: yield* promptFor$1({
+			repo,
+			number,
+			head: worktree.head,
+			findings: chosen
+		}, commits)
+	});
+	yield* Console.log(ended === 0 ? "The session is over." : `The session ended with ${ended}.`);
+	yield* Console.log(`${commits ? "Nothing was pushed" : "Nothing was committed or pushed"} for you; the worktree stands at ${worktree.directory}.`);
+	yield* Console.log(`Once you have pushed, dw-mc review ${number} reviews the new head as a new run.`);
+}, Effect.catchTag(userFacingAndSession, asUserError))).pipe(Command.withDescription("Pick findings from the current review run and open a fix session on them"));
+//#endregion
+//#region src/cli/init.ts
+const effortFlag$1 = Flag.Literals("effort", [
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+]).pipe(Flag.withDescription("How much a review run spends on this repository"), Flag.optional);
+const baseFlag = Flag.String("base").pipe(Flag.withDescription("The branch this repository's pull requests target, over the default one"), Flag.optional);
+/** The settings the flags asked for, and only those. */
+const asked = (base, effort) => ({
+	...Option.isSome(base) ? { base: base.value } : {},
+	...Option.isSome(effort) ? { review: { effort: effort.value } } : {}
+});
+/** What a review will open on, as the setup prints it back. */
+const opening = (defaults) => {
+	const review = {
+		...builtIn.review,
+		...defaults.review
+	};
+	return review.command === null ? "my own prompt" : [review.command, review.effort].filter((part) => part !== null).join(" ");
 };
+const row = (label, value) => `${label.padEnd(12)}${value}`;
 /**
-* 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.
+* Both the machine setup and the repository registration: there is deliberately
+* no separate `setup` command.
 *
-* 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.
+* The first run on a machine checks `gh` and spells the defaults out in the
+* configuration file. Run inside a repository, it also registers that
+* `owner/repo`, taking the name from `gh` so I never type it. Run again, it
+* changes what the flags name, keeps every other setting the file already had,
+* and leaves the file untouched where nothing was decided differently.
 *
-* It writes nothing, here or on GitHub: no reply, no resolve, no reaction
-* (ADR 0002). Reading is the whole command.
+* It asks nothing. Reviews run on Claude Code, and what a run opens on is
+* `review.command` and `review.prompt` - a line and a paragraph that belong in
+* the file rather than in a terminal prompt.
+*
+* `--effort` and `--base` are about one repository, so they land on the
+* repository this ran in, or in the defaults when it ran outside one.
 */
-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"));
+const init = Command.make("init", {
+	effort: effortFlag$1,
+	base: baseFlag
+}, Effect.fn("init")(function* ({ base, effort }) {
+	yield* requireAuth;
+	const config = yield* ConfigStore;
+	const before = yield* read;
+	const file = Option.getOrElse(before, () => ({}));
+	const defaults = file.defaults === void 0 ? merge$1(builtIn, file.defaults ?? {}) : file.defaults ?? {};
+	const state = yield* stateDirectory;
+	const repo = yield* currentRepo.pipe(Effect.asSome, Effect.catchTag("NoRepository", () => Effect.succeedNone));
+	const overrides = asked(base, effort);
+	const written = Option.isSome(repo) ? withRepo(withDefaults(file, defaults), repo.value, overrides) : withDefaults(file, merge$1(defaults, overrides));
+	if (encode(written) !== encode(file) || Option.isNone(before)) yield* write(written);
+	yield* Console.log(row("review", opening(written.defaults ?? {})));
+	yield* Console.log(row("config", config.path));
+	yield* Console.log(row("state", state));
+	yield* Console.log(Option.isNone(repo) ? row("repository", "none here - run dw-mc init inside a repository to register it") : row("repository", `${repo.value} (${file.repos?.[repo.value] === void 0 ? "registered" : "already registered"})`));
+}, Effect.catchTag([
+	"ConfigMalformed",
+	"GhUnauthenticated",
+	"GhUnavailable",
+	"GhUnreadable"
+], asUserError))).pipe(Command.withDescription("Set this machine up and register the repository I am in"));
 //#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));
-const jsonFlag = Flag.Boolean("json").pipe(Flag.withDefault(false), Flag.withDescription("Print the findings as the JSON a fix session is handed"));
-/** What a run's findings come to in one line, against the bar that blocks. */
-const summary = (found, blocksOn) => {
-	if (found.findings.length === 0) return "clean, nothing to fix";
-	const blocked = blocking(found.findings, blocksOn).length;
-	return `${count(found.findings.length, "finding")}, ${blocked} blocking`;
-};
-/** Which run these findings are, and what they come to: the line above the list. */
-const header$1 = (run, found, blocksOn) => `${run.repo}#${run.number}  ${short(run.head)}  ${summary(found, blocksOn)}`;
+//#region src/adapters/ci.ts
 /**
-* The findings one to a line, in the order the run reported them, ruled so the
-* three columns read apart.
+* 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 lines$1 = (found) => table(found.findings.map((finding) => [
-	`${finding.file}:${finding.line}`,
-	finding.severity,
-	finding.summary
-]), " │ ");
+const failing = /* @__PURE__ */ new Set([
+	"FAILURE",
+	"TIMED_OUT",
+	"CANCELLED",
+	"STARTUP_FAILURE",
+	"ACTION_REQUIRED",
+	"ERROR"
+]);
+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 ?? "");
 /**
-* The review run whose findings are the current ones, or the sentence saying
-* there are none.
+* What the rollup comes to: red when anything failed, pending only while
+* nothing has failed yet, green when every check that counts has passed.
 *
-* The last run on the pull request is what "current" means here, and it is read
-* off the state directory rather than worked out from GitHub: this command is
-* one I run inside a fix session, where another round trip to GitHub buys
-* nothing the run it is about to fix does not already say.
+* `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 currentRun = Effect.fn("findings.currentRun")(function* (repo, number) {
-	const run = yield* lastRun(repo, number);
-	return Option.isSome(run) ? run.value : yield* asUserError(`No review run on ${repo}#${number}. Run dw-mc review ${number} first.`);
-});
+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";
+};
 /**
-* What the run reported, or the sentence saying it reported nothing at all.
+* The checks that failed and count, which are the ones there is a log to read.
 *
-* A run that failed is not a clean one: a pipe must never be handed "no
-* findings" when what happened is that nothing could be 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 whatItFound = (run) => {
-	const found = reportedBy(run);
-	return found === null ? Effect.fail(new CliError.UserError({ cause: `The review run on ${short(run.head)} reported no findings: ${run.outcome._tag === "failed" ? run.outcome.detail : ""}\nRun dw-mc review ${run.number} --force to run it again.` })) : Effect.succeed(found);
-};
+const failedChecks = (entries, ignore) => checksThatCount(entries, ignore).filter(hasFailed);
 /**
-* What the current review run found, as a table or as the JSON it is kept in.
+* What a check reports on, out of the URL it reports at.
 *
-* `--json` is the whole point of the command: it prints the findings and
-* nothing else, so I can pipe them anywhere, and a fix session inside an open
-* agent reads exactly what the tool recorded rather than a retelling of it.
+* 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";
+});
+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"
+]);
+/**
+* Whether `workflow` is red on `branch` right now.
 *
-* A run that failed prints no findings and fails: a review run that could not
-* report has found nothing, which is not the same as having found nothing
-* wrong, and a pipe must never be handed the second when the first is true.
+* 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 findings = Command.make("findings", {
-	pr: prArgument,
-	json: jsonFlag
-}, Effect.fn("findings")(function* ({ json, pr }) {
-	const file = Option.getOrElse(yield* read, () => ({}));
-	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
-	const settings = settingsFor(file, repo);
-	const run = yield* currentRun(repo, number);
-	const found = yield* whatItFound(run);
-	if (json) {
-		yield* Console.log(yield* asJson$2(found));
-		return;
-	}
-	yield* Console.log(header$1(run, found, settings.stamp.blocks_on));
-	for (const line of lines$1(found)) yield* Console.log(`  ${line}`);
-}, Effect.catchTag(["ConfigMalformed"], asUserError))).pipe(Command.withDescription("Print what the current review run found on one pull request"));
-//#endregion
-//#region src/adapters/agent.ts
+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 one turn of Claude Code is spawned and given up on, and what a turn that
-* answers against a schema comes back with.
+* How much of a failing job's log is kept.
 *
-* Every turn is reached this way, so the spawn, the patience and the one failure
-* they can end in live here rather than once per turn.
+* 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.
 */
-/** A review run that would not start, would not finish, or finished badly. */
-var AgentFailed = class extends Schema.TaggedError()("AgentFailed", {
-	/** The program that was spawned, which is what a search for it has to name. */
-	program: Schema.String,
-	detail: Schema.String
-}) {
-	get message() {
-		return `The ${this.program} review run failed: ${this.detail}`;
-	}
-};
+const logTailBytes = 65536;
 /**
-* Failures in the name of the program that was spawned.
+* What one failing job printed, from the end.
 *
-* Where the launcher starts `claude` through another program, it is that
-* program that would not start or exited badly, and saying `claude` sends the
-* search to the wrong process.
+* `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 failedBy = (program) => (detail) => new AgentFailed({
-	program,
-	detail
+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);
 });
 /**
-* How long each turn gets before it is given up on.
+* The workflow runs behind the failing checks that count, each named once.
 *
-* The review is the turn that thinks, and a high-effort one that fans out to
-* subagents takes real minutes, so its limit is there to catch a run that has
-* stopped rather than one that is slow. The second turn reads no code and
-* decides nothing - the review it reports on is already in the session it
-* resumes - and every run of it by hand came back in seconds.
+* One broken run usually fails several jobs, and re-running it once per failing
+* job would start the same run over and over.
 *
-* Either way, a command that hangs forever is worse than one that says it
-* failed: a review I walked away from is one I need to be able to come back to.
+* `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 patience = {
-	reviewing: Duration.minutes(45),
-	reporting: Duration.minutes(5)
-};
+const failedRuns = (entries, ignore) => [...new Set(failedChecks(entries, ignore).flatMap((check) => {
+	const reported = reportedAt(check.detailsUrl);
+	return reported === null ? [] : [reported.run];
+}))];
 /**
-* One turn of the launcher in `directory`, with `read` over its standard output.
+* Asks GitHub to run one workflow run's failed jobs again.
 *
-* The launcher's own arguments go in front of the turn's, because they are what
-* gets `claude` started at all. The two output streams are drained together,
-* because draining one to the end first can block a run that is still writing to
-* the other. Every way a turn can fail to finish comes back from here as a
-* `AgentFailed`, so a caller is left with the turn's own answer and nothing else
-* to translate - a turn that never comes back included.
+* `--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 turn = Effect.fnUntraced(function* (options) {
-	const [program, ...prefix] = options.command;
-	const failed = failedBy(program);
-	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-	const running = Effect.gen(function* () {
-		const handle = yield* Effect.mapError(spawner.spawn(ChildProcess.make(program, [...prefix, ...options.args], {
-			cwd: options.directory,
-			stdin: "pipe"
-		})), (error) => failed(error.message));
-		const [got, stderr] = yield* Effect.mapError(Effect.all([options.read(handle.stdout), Stream.mkString(Stream.decodeText(handle.stderr))], { concurrency: 2 }), (error) => failed(error.message));
-		const exitCode = yield* Effect.mapError(handle.exitCode, (error) => failed(error.message));
-		if (exitCode !== 0) return yield* failed(stderr.trim() === "" ? `${program} exited ${exitCode}` : stderr.trim());
-		return got;
-	});
-	return yield* Effect.timeoutOrElse(running, {
-		duration: options.patience.duration,
-		orElse: () => failed(`${options.patience.turn} did not come back within ${Duration.format(options.patience.duration)}`)
-	});
+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/adapters/claude.ts
-/**
-* Claude Code: a review on a slash command, a review on the tool's own prompt,
-* and the sessions I steer.
-*/
+//#region src/domain/stamp.ts
 /**
-* The two events of a stream-json run this reads, as the runner really writes
-* them. Every other field of both, and every other event, is ignored: a
-* transcript carries hooks, rate limits, thinking and tool results, and a
-* version that adds another must not stop a run from being read.
+* A stamp I took off a pull request by hand, and the head I took it off at.
+*
+* The head is the whole record: a withdrawal is my overruling the computation
+* on code I have read, so it lasts exactly as long as that code is what the
+* pull request is.
 */
-const Working = Schema.Struct({
-	type: Schema.Literal("assistant"),
-	message: Schema.Struct({ content: Schema.Array(Schema.Struct({
-		type: Schema.String,
-		name: Schema.optionalKey(Schema.String),
-		text: Schema.optionalKey(Schema.String)
-	})) })
-});
-const Ended = Schema.Struct({
-	type: Schema.Literal("result"),
-	subtype: Schema.String,
-	is_error: Schema.Boolean,
-	session_id: Schema.String,
-	result: Schema.optionalKey(Schema.String),
-	/** What a turn given a JSON schema validated, which this hands on unread. */
-	structured_output: Schema.optionalKey(Schema.Unknown)
+const Withdrawal = Schema.Struct({ head: Schema.String });
+/** The stamp a pull request has not earned, and the first reason it has not. */
+const withheld = (reason) => ({
+	stamped: false,
+	reason
 });
-const asWorking = Schema.decodeUnknownOption(Schema.fromJsonString(Working));
-const asResult = Schema.decodeUnknownOption(Schema.fromJsonString(Ended));
-const heardIn = (line) => {
-	const blocks = Option.match(asWorking(line), {
-		onNone: () => [],
-		onSome: (event) => event.message.content
-	});
-	return {
-		tools: blocks.flatMap((block) => block.type === "tool_use" && block.name !== void 0 ? [block.name] : []),
-		said: blocks.flatMap((block) => block.type === "text" && block.text !== void 0 ? [block.text] : [])
-	};
+/** What CI has to say before the stamp will rest on it, which is green and nothing else. */
+const whyNotGreen = {
+	green: null,
+	red: "CI is red",
+	pending: "CI is still running",
+	none: "no CI ran on this head"
 };
-/**
-* The result a turn ended on, or the failure it really was.
-*
-* A turn that said nothing this can read and a turn Claude Code itself calls an
-* error are both failures: `subtype` is where a run that hit its turn limit or
-* lost its connection says so, and its `result` is the only word on why.
-*/
-const ended = (program, result) => {
-	const failed = failedBy(program);
-	if (Option.isNone(result)) return Effect.fail(failed("the turn came back with no result"));
-	const { is_error, result: lastWord, subtype } = result.value;
-	return is_error || subtype !== "success" ? Effect.fail(failed(`${subtype}: ${lastWord ?? "nothing else was said"}`)) : Effect.succeed(result.value);
+/** What GitHub has to say about merging, which is that it would. */
+const whyNotMergeable = {
+	mergeable: null,
+	conflicting: "merge conflict",
+	unknown: "GitHub has not said whether it merges"
 };
 /**
-* A Claude Code `stream-json` turn, read as it arrives: what it reached for goes
-* to `onTool` while the run is still going, and what it said and how it ended
-* are what comes back.
-*
-* Both shapes of review read a turn the same way, so the fold is here rather
-* than once per shape.
-*/
-const transcript = (onTool) => (stdout) => stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.mapEffect((line) => {
-	const heard = heardIn(line);
-	return Effect.as(Effect.forEach(heard.tools, onTool, { discard: true }), {
-		line,
-		heard
-	});
-}), Stream.runFold(() => ({
-	said: [],
-	result: Option.none()
-}), (soFar, { heard, line }) => ({
-	said: [...soFar.said, ...heard.said],
-	result: Option.orElse(asResult(line), () => soFar.result)
-})));
-/**
-* One review run on a slash command, headless, in `directory`.
+* The stamp of one tracked PR: whether it has passed my bar, and why.
 *
-* The run is in the foreground and says what it is doing as it does it, which
-* is what `onTool` is for: a review takes minutes, and a terminal that prints
-* nothing for minutes is one I stop trusting.
+* The mark is computed rather than clicked, so it means the same thing every
+* time: a review run on this head that found nothing blocking, CI green as the
+* repository's `ci.ignore` defines green, and a pull request GitHub would
+* merge. A red CI the flaky classifier excused is still not green here: an
+* excuse is a reason not to fix a check, not a reason to land code behind one,
+* and this mark is what clears `dw-mc merge` (ADR 0008).
 *
-* `--json-schema` is never passed here: verified by running it, the flag beside
-* `/code-review` breaks the run, which is why a slash command costs a second
-* turn that resumes the session and asks for the findings. My own instructions
-* ride on `--append-system-prompt` rather than on the command's own line,
-* because what a slash command does with its arguments is its business and not
-* this tool's.
+* Nothing about this rests on a previous stamp, which is what makes a head
+* change clear it: facts are about one head, and a run is recorded against one.
 *
-* `--comment` is the flag that makes the built-in review post on the pull
-* request, and it is never passed either (ADR 0002). The report is everything
-* the run said on its own turns rather than the `result` alone: verified by
-* running it, a repository whose review command fans out to subagents can end on
-* a remark about them, and the report is the turn before that.
+* A withdrawal comes first, because it is the one thing here I decided rather
+* than computed.
 */
-const commandReview = Effect.fn("claude.commandReview")(function* (options) {
-	const [program] = options.launcher.command;
-	const run = yield* turn({
-		command: options.launcher.command,
-		directory: options.directory,
-		args: [
-			"-p",
-			options.line,
-			"--output-format",
-			"stream-json",
-			"--verbose",
-			...options.instructions === null ? [] : ["--append-system-prompt", options.instructions],
-			...options.model === null ? [] : ["--model", options.model]
-		],
-		patience: {
-			turn: "the review",
-			duration: patience.reviewing
-		},
-		read: transcript(options.onTool)
-	});
-	const { result: lastWord, session_id } = yield* ended(program, run.result);
-	const report = (run.said.length === 0 ? lastWord ?? "" : run.said.join("\n\n")).trim();
-	if (report === "") return yield* failedBy(program)("the run came back with an empty report");
+const stampFor = (facts, withdrawnAt) => {
+	if (withdrawnAt === facts.head) return withheld("withdrawn by hand");
+	if (facts.reviewRunHead !== facts.head) return withheld("no review run on this head");
+	if (facts.blockingFindings > 0) return withheld(blockedBy(facts.blockingFindings));
+	const ci = whyNotGreen[facts.checks];
+	if (ci !== null) return withheld(ci);
+	const merge = whyNotMergeable[facts.mergeable];
+	if (merge !== null) return withheld(merge);
 	return {
-		report,
-		sessionId: session_id
+		stamped: true,
+		reason: "a clean review run on this head, green CI, mergeable"
 	};
-}, Effect.scoped);
+};
 /**
-* What the second turn asks for.
+* The head a stamp was withdrawn at, or null where none was.
 *
-* It asks for a report of what was already said rather than for another look:
-* the prose is the review, and this turn is only what makes it machine
-* readable. The shape it must answer in arrives as a JSON schema beside it, so
-* the prompt does not describe the schema twice.
+* Forgetting a withdrawal hands the pull request back to the computation, which
+* is what every other input to a stamp already is.
+*/
+const withdrawnAt = Effect.fn("stamp.withdrawnAt")(function* (repo, number) {
+	const store = yield* storeFor("stamps", Withdrawal);
+	const withdrawal = yield* remembered(store.get(prKey(repo, number)));
+	return Option.match(withdrawal, {
+		onNone: () => null,
+		onSome: (it) => it.head
+	});
+});
+/** Takes the stamp off a pull request at `head`, which is the only head it stays off. */
+const withdraw = Effect.fn("stamp.withdraw")(function* (repo, number, head) {
+	yield* (yield* storeFor("stamps", Withdrawal)).set(prKey(repo, number), { head });
+});
+/** The stamp of one tracked PR, with the withdrawal this machine holds against it. */
+const stampOf = Effect.fn("stamp.stampOf")(function* (facts) {
+	return stampFor(facts, yield* withdrawnAt(facts.repo, facts.number));
+});
+/**
+* Which of these tracked PRs carry a stamp, keyed the way their facts are.
+*
+* A table asks the question of every row at once, and the withdrawals are the
+* only thing here that has to be read off the disk.
 */
-const reportFindings = [
-	"Report the findings of the review you just gave as structured output.",
-	"Every finding carries the file it is in as a repository path, the line it is at,",
-	"its severity and a one-sentence summary.",
-	"The verdict is clean when there is nothing to report and findings otherwise.",
-	"Report nothing you did not already say."
-].join(" ");
+const stampedAmong = Effect.fn("stamp.stampedAmong")(function* (facts) {
+	const marks = yield* Effect.forEach(facts, (it) => Effect.map(stampOf(it), (stamp) => ({
+		key: prKey(it.repo, it.number),
+		stamped: stamp.stamped
+	})));
+	return new Set(marks.filter((mark) => mark.stamped).map((mark) => mark.key));
+});
+//#endregion
+//#region src/domain/merge.ts
 /**
-* The second turn of a review run: the prose the first one wrote, back as
-* findings that validate.
+* Why GitHub would not call this pull request Ready, or null where it would.
 *
-* It resumes the first turn's session rather than reading the diff again, which
-* is what makes it cheap and what makes it accurate - verified by running it,
-* the line numbers it reports beat the ones the prose gives. The output is
-* handed on as it arrived: what the findings must look like belongs to the
-* domain, and the schema the run is held to comes in from there too.
+* Ready is GitHub's opinion and nothing of mine: approved, green, mergeable.
+* A repository that requires no reviewer produces no approval, which is why
+* `none` passes and `review-required` does not - what holds a merge is somebody
+* having been asked and not yet answered.
 *
-* Every way this can end badly ends as an `AgentFailed`, because a review run
-* that could not report is a failure and never a clean verdict.
+* A red CI the flaky classifier excused is still red here. The excuse is a
+* reason not to fix a check; it is not a reason to land code behind one.
 */
-const findingsTurn = Effect.fn("claude.findingsTurn")(function* (options) {
-	const [program] = options.launcher.command;
-	const printed = yield* turn({
-		command: options.launcher.command,
-		directory: options.directory,
-		patience: {
-			turn: "the findings turn",
-			duration: patience.reporting
-		},
-		args: [
-			"-p",
-			"--resume",
-			options.sessionId,
-			reportFindings,
-			"--output-format",
-			"json",
-			"--json-schema",
-			options.jsonSchema
-		],
-		read: (stdout) => Stream.mkString(Stream.decodeText(stdout))
-	});
-	const { structured_output } = yield* ended(program, asResult(printed.trim()));
-	if (structured_output === void 0) return yield* failedBy(program)("the findings turn came back with no structured output");
-	return structured_output;
-}, Effect.scoped);
+const whyNotReady = (situation) => {
+	if (situation.reviewDecision === "changes-requested") return "changes are requested";
+	if (situation.reviewDecision === "review-required") return "a review from someone else is still wanted";
+	return whyNotGreen[situation.checks] ?? whyNotMergeable[situation.mergeable];
+};
 /**
-* One review run of the tool's own review prompt, in `directory`.
+* What to do about a pull request that is Ready and carries no stamp.
 *
-* It is one turn rather than two: verified by running it, `--json-schema` beside
-* an ordinary prompt gives both the prose the run wrote and the
-* `structured_output` it validated, where the same flag on a slash command
-* breaks the run. The schema arrives as inline JSON and never as a path - a path
-* is where Claude Code reports `--json-schema is not valid JSON`.
+* The stamp is withheld for one of three reasons and each has its own next
+* step, so the refusal names that step rather than leaving me to work out which
+* of the three it was. A withdrawal is the one with no command: I took the mark
+* off code I had read, and only that code changing puts it back.
 */
-const promptReview = Effect.fn("claude.promptReview")(function* (options) {
-	const [program] = options.launcher.command;
-	const run = yield* turn({
-		command: options.launcher.command,
-		directory: options.directory,
-		patience: {
-			turn: "the review",
-			duration: patience.reviewing
-		},
-		args: [
-			"-p",
-			options.prompt,
-			"--output-format",
-			"stream-json",
-			"--verbose",
-			"--json-schema",
-			options.jsonSchema,
-			...options.model === null ? [] : ["--model", options.model]
-		],
-		read: transcript(options.onTool)
-	});
-	const { session_id, structured_output } = yield* ended(program, run.result);
-	if (structured_output === void 0) return yield* failedBy(program)("the review came back with no structured output");
-	const prose = run.said.join("\n\n").trim();
-	return {
-		findings: structured_output,
-		sessionId: session_id,
-		prose: prose === "" ? null : prose
+const earnsIt = (situation) => {
+	if (situation.withdrawnAt === situation.head) return "\n\nYou took it off at this head, and it stays off until the head changes.";
+	const next = situation.reviewRunHead !== situation.head ? {
+		command: `dw-mc review ${situation.number}`,
+		says: "That reviews this head, and a run that finds nothing blocking stamps it."
+	} : {
+		command: `dw-mc fix ${situation.number}`,
+		says: "That opens a session on the findings. The stamp is back once the head has moved and a review run has read it."
 	};
-}, Effect.scoped);
+	return `\n\n  ${next.command}\n\n${next.says}`;
+};
 /**
-* One review run, in whichever shape it was configured in.
+* Why this pull request is not one to merge, or null where it is.
 *
-* A slash command takes two turns and the tool's own prompt takes one, which is
-* Claude Code's doing and nobody else's: a caller hands over the turn and gets
-* the same answer back either way.
+* This is the single place the merge guards live, and they carry more than the
+* merge does: it is the one write the tool makes that no reflog of mine undoes
+* (ADR 0008). Two bars have to be clear, because each is blind to what the
+* other sees - GitHub does not know whether anything read the diff, and the
+* stamp does not know whether a reviewer asked for changes.
 *
-* The second turn's failure is kept beside the first turn's prose rather than
-* replacing it. A review that ran and could not report is still worth reading,
-* and it is recorded as the failure it is.
+* Whose pull request it is comes first, as it does everywhere else: one
+* somebody else opened is none of this tool's business, whatever is true of it.
+* A draft is next, because a pull request I have not offered to anybody is not
+* one to land however green it is.
+*
+* Ready is asked before the stamp so that the refusal names the bar I am
+* actually under. The stamp insists on green CI and a mergeable pull request
+* too, so everything it can be withheld for here is mine rather than GitHub's.
 */
-const reviewTurns = Effect.fn("claude.reviewTurns")(function* (options) {
-	const { directory, jsonSchema, launcher, model, onTool } = options;
-	if (options.turn._tag === "prompt") {
-		const run = yield* promptReview({
-			launcher,
-			directory,
-			prompt: options.turn.text,
-			model,
-			jsonSchema,
-			onTool
-		});
-		return {
-			sessionId: run.sessionId,
-			prose: run.prose,
-			findings: Result.succeed(run.findings)
-		};
-	}
-	const run = yield* commandReview({
-		launcher,
-		directory,
-		line: options.turn.line,
-		instructions: options.turn.instructions,
-		model,
-		onTool
-	});
-	const findings = yield* Effect.result(findingsTurn({
-		launcher,
-		directory,
-		sessionId: run.sessionId,
-		jsonSchema
-	}));
-	return {
-		sessionId: run.sessionId,
-		prose: run.report,
-		findings
-	};
-});
+const decide$3 = (situation) => {
+	const where = `${situation.repo}#${situation.number}`;
+	if (!situation.mine) return `${where} is not mine. dw-mc merges pull requests I author and nothing else.`;
+	if (situation.draft) return `${where} is a draft. Mark it ready for review before merging it.`;
+	const ready = whyNotReady(situation);
+	if (ready !== null) return `${where} is not Ready: ${ready}. dw-mc merges nothing GitHub would not merge itself.`;
+	const stamp = stampFor(situation, situation.withdrawnAt);
+	return stamp.stamped ? null : `${where} is Ready and carries no stamp: ${stamp.reason}.${earnsIt(situation)}`;
+};
+//#endregion
+//#region src/cli/merge.ts
 /**
-* An interactive `claude` in `directory`, opened on `prompt`, with my terminal
-* handed straight to it.
+* Lands one pull request of mine: squashed, with its branch deleted.
 *
-* The launcher's `fix_args` go here and nowhere else: they are the flags of
-* every session I steer - the one on findings and the one on a conflict - which
-* no headless review turn wants. They sit in front of the
-* prompt, because `claude` takes its flags before its positional argument.
+* This is the write ADR 0008 is about, and the only one the tool makes that no
+* reflog of mine brings back. It is outside ADR 0002's three because it moves a
+* shared branch; everything 0002 bars - comment, reply, thread resolve, label,
+* review, approval, status - still holds here as it does everywhere.
 *
-* This is the one place a run is not read: the three streams are inherited,
-* so what is on the screen is the session itself and not a transcript of it,
-* and what I type reaches it. The child is not detached for the same reason -
-* a detached child sits outside the terminal's foreground process group, where
-* neither my keystrokes nor Ctrl-C would reach it.
+* The threshold is two bars at one head: Ready, which is GitHub's opinion, and
+* my stamp, which is mine. Each is blind to what the other sees, so the write
+* that cannot be undone clears both.
 *
-* There is no patience here either. A session I steer lasts as long as I am in
-* it, and a timeout would be the tool closing a session I was still working in.
+* GitHub's half is read live from a fresh `pr view` rather than off the last
+* sweep, the way the rebase and re-run guards are. A stale verdict costs a
+* re-run some CI minutes; here it costs merging code nobody read. My half comes
+* from the state directory, because the review runs and the withdrawal live
+* there and are already scoped to the head this read just named.
 *
-* What comes back is the code the session ended on. A session I left with
-* Ctrl-C ended badly for `claude` and not for me, so this reports it rather
-* than failing on it; only a `claude` that would not start at all is a failure.
+* Typing the command is the confirmation, so it takes no flag. The picker,
+* where a keystroke is cheaper, asks before it dispatches.
 */
-const steeredSession = Effect.fn("claude.steeredSession")(function* (options) {
-	const [program, ...prefix] = options.launcher.command;
-	const failed = failedBy(program);
-	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-	const handle = yield* Effect.mapError(spawner.spawn(ChildProcess.make(program, [
-		...prefix,
-		...options.launcher.fix_args,
-		options.prompt
-	], {
-		cwd: options.directory,
-		stdin: "inherit",
-		stdout: "inherit",
-		stderr: "inherit",
-		detached: false
-	})), (error) => failed(error.message));
-	return yield* Effect.mapError(handle.exitCode, (error) => failed(error.message));
-}, Effect.scoped);
+const merge = Command.make("merge", { pr: prArgument }, Effect.fn("merge")(function* ({ pr }) {
+	const { number, repo, settings } = yield* forPr(pr);
+	const [view, me] = yield* reading(`${repo}#${number}`, Effect.all([prView(repo, number), viewer]));
+	const head = view.headRefOid;
+	yield* refuse(decide$3({
+		repo,
+		number,
+		head,
+		mine: view.author?.login === me,
+		draft: view.isDraft,
+		reviewDecision: reviewDecisionOf(view.reviewDecision),
+		checks: rollupState(view.statusCheckRollup, settings.ci.ignore),
+		mergeable: mergeabilityOf(view.mergeable),
+		...yield* reviewedAt(repo, number, head, settings.stamp.blocks_on),
+		withdrawnAt: yield* withdrawnAt(repo, number)
+	}));
+	yield* mergePr(repo, number);
+	yield* Console.log(`${repo}#${number}  ${short(head)}  squash-merged into ${view.baseRefName}, and ${view.headRefName} deleted`);
+	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/domain/fix.ts
-/** One finding I chose to act on, carrying what I think about it. */
-const Chosen = Schema.Struct({
-	...Finding.fields,
-	note: Schema.optionalKey(Schema.String)
-});
+//#region src/domain/flaky.ts
 /**
-* What a fix session is handed: the findings I picked, and the review run they
-* came from.
+* The failures that are flaky wherever they appear: a machine, a network or a
+* runner giving up, never a test disagreeing with the code.
 *
-* The head is in it because a fix session opens on the commit that was
-* reviewed, and a finding's line means nothing away from it.
+* `ci.flaky_patterns` adds to this list rather than replacing it, because the
+* failures a repository of mine produces are extra ones, not different ones.
 */
-const Selection = Schema.Struct({
-	repo: Schema.String,
-	number: Schema.Int,
-	head: Schema.String,
-	findings: Schema.Array(Chosen)
-});
-/** The selection as the JSON the schema defines, rather than as this file spells it. */
-const asJson$1 = Schema.encodeEffect(Schema.fromJsonString(Selection));
+const builtInPatterns = [
+	"timed out",
+	"deadline exceeded",
+	"ETIMEDOUT",
+	"ECONNRESET",
+	"ECONNREFUSED",
+	"connection refused",
+	"socket hang up",
+	"lock timeout",
+	"could not obtain lock",
+	"runner lost communication",
+	"The runner has received a shutdown signal",
+	"net/http: request canceled",
+	"ResourceExhausted",
+	"Too many open files",
+	"no space left on device"
+];
+const baseName = (path) => path.slice(path.lastIndexOf("/") + 1);
 /**
-* The prompt a fix session opens on: what these findings are, and the findings
-* themselves as JSON.
-*
-* The findings go in verbatim rather than described, because a re-description
-* is where a file, a line or my own note quietly changes. A note outranks the
-* finding it is on: the finding is what the review thought, the note is what I
-* think, and I am the one who picked it.
+* The changed file the log names, preferring one it spells in full.
 *
-* Pushing is mine either way, and `commits` says whether committing is too.
-* The tool itself never commits and never pushes; what the session may do
-* inside the worktree is my call, made once in `fix.commits` or for one session
-* with the flag.
+* A bare file name is worth matching - a stack trace often prints nothing else
+* - and it is worth matching second, because a name as ordinary as `index.ts`
+* belongs to more repositories than mine.
 */
-const promptFor$1 = (selection, commits) => Effect.map(asJson$1(selection), (json) => [
-	`These are the findings I picked from a dw-mc review run on ${selection.repo}#${selection.number}, at ${short(selection.head)}, the commit their lines are counted from.`,
-	"Work through them one at a time. Where a finding carries a note, the note is mine and outranks the finding's own summary; where it carries none, the summary is the whole brief.",
-	commits ? `Commit what you change, one logical change to a commit. Do not push: I read the commits and push them myself.` : `Do not commit and do not push: I do both myself when I have read what you changed.`,
-	json
-].join("\n\n"));
+const escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 /**
-* Why these findings cannot be fixed where the pull request now is, or nothing
-* where they can.
+* Whether the log names a file called `base` rather than some longer name
+* ending in it: a changed `src/a.ts` is not what a log printing `data.ts` is
+* complaining about.
+*/
+const namesFile = (log, base) => new RegExp(`(^|[^\\w.-])${escaped(base)}`).test(log);
+const namedChangedFile = (log, changedFiles) => changedFiles.find((file) => log.includes(file)) ?? changedFiles.find((file) => namesFile(log, baseName(file))) ?? null;
+/**
+* The flaky pattern the log matches, mine before the built-in ones.
 *
-* A pull request that moved since its last review run has findings at lines
-* that may no longer be there, and a worktree cut at the new head would carry
-* them into code they were never about. Reviewing again is cheap next to fixing
-* the wrong thing.
+* A pattern is text and not a regular expression: it comes out of a
+* configuration file I edit by hand, where a stray `*` should cost me a missed
+* match and never a crash.
 */
-const staleAt = (number, run, now) => run === now ? null : `The findings are from ${short(run)} and the pull request is now at ${short(now)}. Run dw-mc review ${number} again to review the head you would be fixing.`;
-//#endregion
-//#region src/cli/fix.ts
-const printFlag$1 = Flag.Boolean("print").pipe(Flag.withDefault(false), Flag.withDescription("Print the prompt a session would open on, and open none"));
-const commitFlag = Flag.Boolean("commit").pipe(Flag.withDescription("Let this session commit what it changes, over what the repository configured"), Flag.optional);
+const matchedPattern = (log, patterns) => {
+	const haystack = log.toLowerCase();
+	return [...patterns, ...builtInPatterns].find((pattern) => haystack.includes(pattern.toLowerCase())) ?? null;
+};
 /**
-* The findings to pick from, each on the line `dw-mc findings` gives it.
+* Whether a red CI is mine to fix, and why.
 *
-* The rows come from there rather than being built again here, so the list I
-* pick from and the list I read are the same list. A row that does not fit the
-* screen is cut: a prompt draws its own frame around the row, and a row that
-* wraps takes the whole list's alignment with it.
+* Two of the signals say flaky and one says legitimate, and the one outranks
+* the two: a log that names a file this pull request changes is the failure
+* pointing at my own work, and a workflow that is broken everywhere does not
+* stop it pointing there.
+*
+* Everything else that is unexplained is mine as well. The two mistakes do not
+* cost the same - a real failure called flaky is a broken pull request nobody
+* tells me about, while a flake called mine costs me one look - so the default
+* is the one I can recover from.
 */
-const choicesOf$1 = (found, screen) => {
-	const rows = lines$1(found);
-	const room = screen === 0 ? Number.POSITIVE_INFINITY : screen - 6;
-	return found.findings.map((finding, index) => ({
-		title: truncate(rows[index] ?? finding.summary, room),
-		value: finding
-	}));
+const classify = (evidence, flakyPatterns) => {
+	const named = namedChangedFile(evidence.log, evidence.changedFiles);
+	if (named !== null) return {
+		classification: "legitimate",
+		reason: `the log names ${named}, which this PR changes`
+	};
+	const redOnDefaultBranch = evidence.alsoRedOnDefaultBranch[0];
+	const pattern = matchedPattern(evidence.log, flakyPatterns);
+	const excuses = [redOnDefaultBranch === void 0 ? null : `${redOnDefaultBranch} is red on the default branch too`, pattern === null ? null : `the log matches "${pattern}"`].filter((it) => it !== null);
+	return excuses.length === 0 ? {
+		classification: "legitimate",
+		reason: "nothing explains the failure"
+	} : {
+		classification: "flaky",
+		reason: excuses.join(", and ")
+	};
 };
 /**
-* Each picked finding with whatever I have to say about it.
+* How many failing jobs the log is read from.
 *
-* The note is asked for one finding at a time, in the order I see them, and
-* having nothing to say is the ordinary answer rather than a step I have to get
-* past.
+* One broken workflow usually fails several jobs with the same cause, and the
+* logs are the one read here that is measured in megabytes.
 */
-const noted = Effect.fn("fix.noted")(function* (picked) {
-	const chosen = [];
-	for (const finding of picked) {
-		const said = yield* note(`Note on ${finding.file}:${finding.line}, or nothing`);
-		chosen.push(Option.match(said, {
-			onNone: () => finding,
-			onSome: (text) => ({
-				...finding,
-				note: text
-			})
-		}));
-	}
-	return chosen;
+const loggedJobs = 3;
+/** The values of `xs` that `f` has one for. */
+const filterMap = (xs, f) => xs.flatMap((x) => {
+	const b = f(x);
+	return b === null ? [] : [b];
 });
-/** The domain's word on a head that has moved, as the command's own failure. */
-const fixable = (number, run, now) => {
-	const stale = staleAt(number, run, now);
-	return stale === null ? Effect.void : Effect.fail(new CliError.UserError({ cause: stale }));
+/** No evidence at all, which is what an unreadable CI comes to. */
+const nothing = {
+	alsoRedOnDefaultBranch: [],
+	changedFiles: [],
+	log: ""
 };
 /**
-* A fix session: the findings I picked, in an agent session I steer.
+* What a red CI looks like to the classifier.
 *
-* The tool fixes nothing. It picks the findings apart with me, cuts a worktree
-* on a branch of its own that tracks the pull request's, and hands the session
-* what I chose as JSON; then it is out of the way. I steer and I push. Nothing
-* here writes to GitHub, and the tool itself commits nothing: whether the
-* session may commit inside the worktree is `fix.commits`, or `--commit` for
-* one session.
+* A read that fails costs its own signal and nothing else. GitHub drops an
+* Actions log after ninety days, so a pull request open that long would
+* otherwise lose its row over a log nobody can fetch any more - and a missing
+* signal only ever moves the verdict towards legitimate, which is the answer
+* that puts the pull request in front of me rather than hiding it.
+*/
+const evidenceFor = Effect.fn("flaky.evidenceFor")(function* (repo, number, entries, ignore) {
+	const failed = failedChecks(entries, ignore);
+	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;
+	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), () => []),
+		Effect.forEach(jobs, (job) => Effect.orElseSucceed(jobLog(repo, job), () => ""))
+	], { concurrency: 3 });
+	return {
+		alsoRedOnDefaultBranch: alsoRed.flat(),
+		changedFiles,
+		log: logs.join("\n")
+	};
+});
+/**
+* Why a red CI is excused, or null where it is mine to fix.
 *
-* The worktree is left standing when the session ends, because the work in it
-* is mine and an unpushed commit lives nowhere else. Re-reviewing the result is
-* a new review run against the new head, never a continuation of the run that
-* produced these findings, so what was reviewed at which commit stays honest.
+* Reading the evidence and classifying it is one act, so it is one function:
+* a sweep writes what it returns down as `ciFlaky`, and `dw-mc rerun` asks it
+* again live. Two callers asking the same question have to get the same answer,
+* which they cannot if each of them spells the question out.
 */
-const fix = Command.make("fix", {
-	pr: prArgument,
-	commit: commitFlag,
-	print: printFlag$1
-}, Effect.fn("fix")(function* ({ commit, pr, print }) {
-	const file = Option.getOrElse(yield* read, () => ({}));
-	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
-	const settings = settingsFor(file, repo);
-	const run = yield* currentRun(repo, number);
-	const found = yield* whatItFound(run);
-	yield* Console.log(header$1(run, found, settings.stamp.blocks_on));
-	if (found.findings.length === 0) return;
-	const view = yield* prView(repo, number);
-	yield* fixable(number, run.head, view.headRefOid);
-	const picked = yield* choose("Which findings does the session carry?", choicesOf$1(found, yield* width));
-	const chosen = yield* Effect.catchTag(noted(Option.getOrElse(picked, () => [])), "QuitError", () => Effect.succeed([]));
-	if (chosen.length === 0) {
-		yield* Console.log("Nothing picked, so no session was opened.");
-		return;
-	}
-	const commits = Option.getOrElse(commit, () => settings.fix.commits);
-	if (print) {
-		yield* Console.log(yield* promptFor$1({
-			repo,
-			number,
-			head: run.head,
-			findings: chosen
-		}, commits));
-		return;
-	}
-	const worktree = yield* standingWorktree(repo, number, view.headRefName, "fix");
-	yield* Console.log(`  ${chosen.length} of ${found.findings.length} findings, ${commits ? "committing" : "not committing"}`);
-	yield* Console.log(`  ${worktree.directory}, pushing to ${view.headRefName}`);
-	const ended = yield* steeredSession({
-		launcher: launcherOf(file),
-		directory: worktree.directory,
-		prompt: yield* promptFor$1({
-			repo,
-			number,
-			head: worktree.head,
-			findings: chosen
-		}, commits)
-	});
-	yield* Console.log(ended === 0 ? "The session is over." : `The session ended with ${ended}.`);
-	yield* Console.log(`${commits ? "Nothing was pushed" : "Nothing was committed or pushed"} for you; the worktree stands at ${worktree.directory}.`);
-	yield* Console.log(`Once you have pushed, dw-mc review ${number} reviews the new head as a new run.`);
-}, Effect.catchTag([
-	...userFacing,
-	"GitFailed",
-	"WorktreeHeld",
-	"AgentFailed"
-], asUserError))).pipe(Command.withDescription("Pick findings from the current review run and open a fix session on them"));
+const flakyReason = Effect.fn("flaky.flakyReason")(function* (repo, number, entries, ignore, patterns) {
+	const verdict = classify(yield* evidenceFor(repo, number, entries, ignore), patterns);
+	return verdict.classification === "flaky" ? verdict.reason : null;
+});
 //#endregion
-//#region src/cli/init.ts
-const effortFlag$1 = Flag.Literals("effort", [
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max"
-]).pipe(Flag.withDescription("How much a review run spends on this repository"), Flag.optional);
-const baseFlag = Flag.String("base").pipe(Flag.withDescription("The branch this repository's pull requests target, over the default one"), Flag.optional);
-/** The settings the flags asked for, and only those. */
-const asked = (base, effort) => ({
-	...Option.isSome(base) ? { base: base.value } : {},
-	...Option.isSome(effort) ? { review: { effort: effort.value } } : {}
+//#region src/domain/quiet.ts
+/** The pulse of a PR a previous sweep recorded. */
+const pulseOf = (facts) => ({
+	head: facts.head,
+	checks: facts.checks,
+	newestHumanCommentAt: facts.newestHumanCommentAt
 });
-/** What a review will open on, as the setup prints it back. */
-const opening = (defaults) => {
-	const review = {
-		...builtIn.review,
-		...defaults.review
-	};
-	return review.command === null ? "my own prompt" : [review.command, review.effort].filter((part) => part !== null).join(" ");
-};
-const row = (label, value) => `${label.padEnd(12)}${value}`;
 /**
-* Both the machine setup and the repository registration: there is deliberately
-* no separate `setup` command.
-*
-* The first run on a machine checks `gh` and spells the defaults out in the
-* configuration file. Run inside a repository, it also registers that
-* `owner/repo`, taking the name from `gh` so I never type it. Run again, it
-* changes what the flags name, keeps every other setting the file already had,
-* and leaves the file untouched where nothing was decided differently.
-*
-* It asks nothing. Reviews run on Claude Code, and what a run opens on is
-* `review.command` and `review.prompt` - a line and a paragraph that belong in
-* the file rather than in a terminal prompt.
+* Whether a PR is where the last sweep left it.
 *
-* `--effort` and `--base` are about one repository, so they land on the
-* repository this ran in, or in the defaults when it ran outside one.
+* A quiet PR keeps the facts it already had rather than being read out again,
+* so a sweep over many pull requests spends its time on the few that moved.
 */
-const init = Command.make("init", {
-	effort: effortFlag$1,
-	base: baseFlag
-}, Effect.fn("init")(function* ({ base, effort }) {
-	yield* requireAuth;
-	const config = yield* ConfigStore;
-	const before = yield* read;
-	const file = Option.getOrElse(before, () => ({}));
-	const defaults = file.defaults === void 0 ? merge$1(builtIn, file.defaults ?? {}) : file.defaults ?? {};
-	const state = yield* stateDirectory;
-	const repo = yield* currentRepo.pipe(Effect.asSome, Effect.catchTag("NoRepository", () => Effect.succeedNone));
-	const overrides = asked(base, effort);
-	const written = Option.isSome(repo) ? withRepo(withDefaults(file, defaults), repo.value, overrides) : withDefaults(file, merge$1(defaults, overrides));
-	if (encode(written) !== encode(file) || Option.isNone(before)) yield* write(written);
-	yield* Console.log(row("review", opening(written.defaults ?? {})));
-	yield* Console.log(row("config", config.path));
-	yield* Console.log(row("state", state));
-	yield* Console.log(Option.isNone(repo) ? row("repository", "none here - run dw-mc init inside a repository to register it") : row("repository", `${repo.value} (${file.repos?.[repo.value] === void 0 ? "registered" : "already registered"})`));
-}, Effect.catchTag([
-	"ConfigMalformed",
-	"GhUnauthenticated",
-	"GhUnavailable",
-	"GhUnreadable"
-], asUserError))).pipe(Command.withDescription("Set this machine up and register the repository I am in"));
+const isQuiet = (previous, current) => previous.head === current.head && previous.checks === current.checks && isSame(previous.newestHumanCommentAt, current.newestHumanCommentAt);
 //#endregion
-//#region src/domain/stamp.ts
+//#region src/domain/rebase.ts
 /**
-* A stamp I took off a pull request by hand, and the head I took it off at.
+* How many pull requests this one stands on.
 *
-* The head is the whole record: a withdrawal is my overruling the computation
-* on code I have read, so it lasts exactly as long as that code is what the
-* pull request is.
+* A branch is walked to what it merges into and on from there, however deep the
+* stack goes. Every pull request the walk has already counted is left alone,
+* which is what keeps two branches that merge into each other from being walked
+* around forever.
 */
-const Withdrawal = Schema.Struct({ head: Schema.String });
-/** The stamp a pull request has not earned, and the first reason it has not. */
-const withheld = (reason) => ({
-	stamped: false,
-	reason
-});
-/** What CI has to say before the stamp will rest on it, which is green and nothing else. */
-const whyNotGreen = {
-	green: null,
-	red: "CI is red",
-	pending: "CI is still running",
-	none: "no CI ran on this head"
+const ancestorsOf = (pr, open, seen) => {
+	let count = 0;
+	let current = pr;
+	for (;;) {
+		const parent = open.find((it) => it.head === current.base && !seen.has(it.number));
+		if (parent === void 0) return count;
+		seen.add(parent.number);
+		count += 1;
+		current = parent;
+	}
 };
-/** What GitHub has to say about merging, which is that it would. */
-const whyNotMergeable = {
-	mergeable: null,
-	conflicting: "merge conflict",
-	unknown: "GitHub has not said whether it merges"
+/**
+* How deep the stack goes above this pull request.
+*
+* Two branches cut from the same one are not two stacks deep, they are two
+* branches, so what counts is the deepest single line of them rather than how
+* many pull requests stand above it in total.
+*/
+const descendantsOf = (pr, open, seen) => {
+	let deepest = 0;
+	for (const child of open.filter((it) => it.base === pr.head && !seen.has(it.number))) {
+		seen.add(child.number);
+		deepest = Math.max(deepest, 1 + descendantsOf(child, open, seen));
+	}
+	return deepest;
 };
 /**
-* The stamp of one tracked PR: whether it has passed my bar, and why.
+* Where a pull request sits in its stack, or null where it is in none.
 *
-* The mark is computed rather than clicked, so it means the same thing every
-* time: a review run on this head that found nothing blocking, CI green as the
-* repository's `ci.ignore` defines green, and a pull request GitHub would
-* merge. A red CI the flaky classifier excused is still not green here: an
-* excuse is a reason not to fix a check, not a reason to land code behind one,
-* and this mark is what clears `dw-mc merge` (ADR 0008).
+* A stack is read off the branches alone: a pull request that merges into
+* another pull request's branch, or that another one merges into, is part of
+* one. The tool does not understand stacks and never drives them, so this
+* exists to recognise one and say where the pull request sits in it.
+*/
+const stackOf = (number, open) => {
+	const pr = open.find((it) => it.number === number);
+	if (pr === void 0) return null;
+	const seen = /* @__PURE__ */ new Set([number]);
+	const below = ancestorsOf(pr, open, seen);
+	const above = descendantsOf(pr, open, seen);
+	return below === 0 && above === 0 ? null : {
+		position: below + 1,
+		length: below + above + 1
+	};
+};
+/**
+* Why this branch is nobody's to touch here, or null where it is mine.
 *
-* Nothing about this rests on a previous stamp, which is what makes a head
-* change clear it: facts are about one head, and a run is recorded against one.
+* These are the guards about the branch rather than about what is done to it,
+* which is why they are their own and why they say nothing about pushing: who
+* authored the pull request and where its branch lives is the boundary itself -
+* a branch somebody else authored and a branch in a fork are not mine to work
+* on, whatever else is true of them and whichever command asks. A stack comes
+* next, and a pull request the stack was not read from counts as one, because a
+* stack the tool cannot see is one it could drive: the tool does not understand
+* stacks, so the one thing it has to say about one is where the pull request
+* sits in it.
+*/
+const boundary = (branch) => {
+	const where = `${branch.repo}#${branch.number}`;
+	if (!branch.mine) return `${where} is not mine. dw-mc works on branches I author and on nothing else.`;
+	if (branch.fromFork) return `${where} is opened from a fork, so its branch is not in ${branch.repo}. dw-mc works only on a branch in the repository it read.`;
+	if (!branch.listed) return `${where} was not among the open pull requests of ${branch.repo}, so nothing here can say whether it is in a stack. Read it again before touching the branch.`;
+	if (branch.stack !== null) return `${where} is ${branch.stack.position} of ${branch.stack.length} in a stack. dw-mc does not understand stacks and will not drive one; rebase it with whatever built the stack.`;
+	return null;
+};
+/**
+* Why this branch is not one to rebase, or null where it is.
 *
-* A withdrawal comes first, because it is the one thing here I decided rather
-* than computed.
+* This is the single place the guards live, and they matter more than the
+* rebase itself: a force push is the one write the tool makes that can lose
+* work, and every rule here is about it never being a surprise.
+*
+* Being off is said first, because a repository that has not turned rebase on
+* has decided the question and nothing else about the pull request changes it.
+* The branch's own guards come next. CI is last and costs the most to get
+* wrong - rebasing while a run is in flight cancels the run I am waiting on,
+* and a red build is mine to fix where it is.
 */
-const stampFor = (facts, withdrawnAt) => {
-	if (withdrawnAt === facts.head) return withheld("withdrawn by hand");
-	if (facts.reviewRunHead !== facts.head) return withheld("no review run on this head");
-	if (facts.blockingFindings > 0) return withheld(`${facts.blockingFindings} blocking finding${facts.blockingFindings === 1 ? "" : "s"}`);
-	const ci = whyNotGreen[facts.checks];
-	if (ci !== null) return withheld(ci);
-	const merge = whyNotMergeable[facts.mergeable];
-	if (merge !== null) return withheld(merge);
-	return {
-		stamped: true,
-		reason: "a clean review run on this head, green CI, mergeable"
-	};
+const decide$2 = (situation) => {
+	const where = `${situation.repo}#${situation.number}`;
+	if (!situation.enabled) return `Rebase is off for ${situation.repo}. Set rebase.enabled: true for it in the config to turn it on, so a force push is never a surprise.`;
+	const refused = boundary(situation);
+	if (refused !== null) return refused;
+	if (situation.checks === "pending") return `CI is still running on ${where}. A rebase now would cancel the run you are waiting on.`;
+	if (situation.checks === "red") return `CI is red on ${where}, which is yours to fix before the branch moves.`;
+	return null;
 };
 /**
-* The head a stamp was withdrawn at, or null where none was.
+* A rebase that conflicted: the head it conflicted at and the files it stopped
+* on.
+*
+* The head is what the record is scoped to, as it is for a withdrawn stamp: a
+* conflict is about the code the branch is at, so it lasts exactly as long as
+* that code is what the pull request is. A branch that moved is a branch
+* nothing here has tried to rebase yet.
 *
-* A withdrawal this version cannot read is one another version of this record
-* wrote, and a stamp is computed from everything else: forgetting it hands the
-* pull request back to the computation, where failing here would cost me the
-* command I asked for.
+* The paths are what makes the conflict something to open: `a rebase
+* conflicted` cannot tell a stale lockfile from half the pull request. They are
+* an optional key rather than a required one so a record an older version wrote
+* still reads, and a conflict with no paths still puts the pull request in
+* Needs me.
 */
-const withdrawnAt = Effect.fn("stamp.withdrawnAt")(function* (repo, number) {
-	const store = yield* storeFor("stamps", Withdrawal);
-	const withdrawal = yield* Effect.orElseSucceed(store.get(prKey(repo, number)), () => Option.none());
-	return Option.match(withdrawal, {
-		onNone: () => null,
-		onSome: (it) => it.head
-	});
+const Conflict = Schema.Struct({
+	head: Schema.String,
+	paths: Schema.optionalKey(Schema.Array(Schema.String))
 });
-/** Takes the stamp off a pull request at `head`, which is the only head it stays off. */
-const withdraw = Effect.fn("stamp.withdraw")(function* (repo, number, head) {
-	yield* (yield* storeFor("stamps", Withdrawal)).set(prKey(repo, number), { head });
+/**
+* The conflict a rebase last left on this pull request, or null where it left
+* none.
+*
+* Forgetting one costs the pull request one reason to be in Needs me, where
+* failing here would cost me the whole table.
+*/
+const conflictFor = Effect.fn("rebase.conflictFor")(function* (repo, number) {
+	const store = yield* storeFor("rebases", Conflict);
+	const conflict = yield* remembered(store.get(prKey(repo, number)));
+	return Option.getOrNull(conflict);
 });
-/** The stamp of one tracked PR, with the withdrawal this machine holds against it. */
-const stampOf = Effect.fn("stamp.stampOf")(function* (facts) {
-	return stampFor(facts, yield* withdrawnAt(facts.repo, facts.number));
+/** Writes down that a rebase of `head` conflicted on `paths`, which is the only head it holds for. */
+const recordConflict = Effect.fn("rebase.recordConflict")(function* (repo, number, head, paths) {
+	yield* (yield* storeFor("rebases", Conflict)).set(prKey(repo, number), {
+		head,
+		paths
+	});
+});
+//#endregion
+//#region src/cli/sweep.ts
+const writtenBy = (comments, login) => comments.filter((comment) => comment.login === login).map((comment) => comment.at);
+const byHumansOtherThan = (comments, login) => comments.filter((comment) => !comment.bot && comment.login !== login).map((comment) => comment.at);
+/**
+* The facts about one tracked PR, read from GitHub and kept on disk.
+*
+* The cheap reads happen every time, because they are what says whether the PR
+* moved. The commits are asked for only when it did: `gh` returns every commit
+* message in full, and on a PR that is where the last sweep left it that whole
+* read buys a timestamp the state directory already has.
+*/
+const sweepPr = Effect.fn("sweep.pullRequest")(function* (store, me, found, settings) {
+	const view = yield* prView(found.repo, found.number);
+	const [onThePr, inReviews] = yield* Effect.all([prComments(found.repo, found.number), prReviews(found.repo, found.number)], { concurrency: 2 });
+	const comments = [...onThePr, ...inReviews];
+	const checks = rollupState(view.statusCheckRollup, settings.ci.ignore);
+	const newestHumanCommentAt = newest(byHumansOtherThan(comments, me));
+	const key = prKey(found.repo, found.number);
+	const previous = Option.getOrUndefined(yield* remembered(store.get(key)));
+	const reviewed = yield* reviewedAt(found.repo, found.number, view.headRefOid, settings.stamp.blocks_on);
+	const quiet = previous !== void 0 && isQuiet(pulseOf(previous), {
+		head: view.headRefOid,
+		checks,
+		newestHumanCommentAt
+	}) ? previous : void 0;
+	const myLastCommitAt = quiet !== void 0 ? quiet.myLastCommitAt : newest((yield* prCommits(found.repo, found.number)).filter((commit) => commit.logins.includes(me)).map((commit) => commit.at));
+	const ciFlaky = checks !== "red" ? null : quiet !== void 0 ? quiet.ciFlaky : yield* flakyReason(found.repo, found.number, view.statusCheckRollup, settings.ci.ignore, settings.ci.flaky_patterns);
+	const rebaseConflictAt = yield* Effect.map(conflictFor(found.repo, found.number), (it) => it?.head ?? null);
+	const facts = {
+		repo: found.repo,
+		number: found.number,
+		title: view.title,
+		url: view.url,
+		draft: view.isDraft,
+		head: view.headRefOid,
+		mergeable: mergeabilityOf(view.mergeable),
+		reviewDecision: reviewDecisionOf(view.reviewDecision),
+		checks,
+		ciFlaky,
+		rebaseConflictAt,
+		newestHumanCommentAt,
+		myLastCommentAt: newest(writtenBy(comments, me)),
+		myLastCommitAt,
+		...reviewed
+	};
+	yield* store.set(key, facts);
+	return facts;
 });
-/**
-* Which of these tracked PRs carry a stamp, keyed the way their facts are.
-*
-* A table asks the question of every row at once, and the withdrawals are the
-* only thing here that has to be read off the disk.
-*/
-const stampedAmong = Effect.fn("stamp.stampedAmong")(function* (facts) {
-	const marks = yield* Effect.forEach(facts, (it) => Effect.map(stampOf(it), (stamp) => ({
-		key: prKey(it.repo, it.number),
-		stamped: stamp.stamped
-	})));
-	return new Set(marks.filter((mark) => mark.stamped).map((mark) => mark.key));
+/** A read that came back, or the trouble it came back with instead. */
+const attempt = (where, read) => read.pipe(Effect.map((got) => ({
+	got,
+	troubles: []
+})), Effect.catch((error) => Effect.succeed({
+	got: [],
+	troubles: [{
+		where,
+		detail: error.message
+	}]
+})));
+const gather = (attempts) => ({
+	got: attempts.flatMap((it) => it.got),
+	troubles: attempts.flatMap((it) => it.troubles)
 });
-//#endregion
-//#region src/domain/merge.ts
+/** How many reads of GitHub are in flight at once. */
+const concurrency = 4;
+/** `n` repositories, which `count` cannot say: the plural is not the noun plus s. */
+const repositories = (n) => n === 1 ? "1 repository" : `${n} repositories`;
+/** How the heartbeat of a sweep reads, wherever a command turns one. */
+const saying$1 = (swept) => (since) => [
+	"sweeping",
+	swept._tag === "searching" ? `${swept.done} of ${repositories(swept.of)}` : `${swept.done} of ${count(swept.of, "pull request")}`,
+	since
+].join(" · ");
 /**
-* Why GitHub would not call this pull request Ready, or null where it would.
-*
-* Ready is GitHub's opinion and nothing of mine: approved, green, mergeable.
-* A repository that requires no reviewer produces no approval, which is why
-* `none` passes and `review-required` does not - what holds a merge is somebody
-* having been asked and not yet answered.
+* One pass over every tracked PR, and nothing else: a sweep only ever reads.
 *
-* A red CI the flaky classifier excused is still red here. The excuse is a
-* reason not to fix a check; it is not a reason to land code behind one.
-*/
-const whyNotReady = (situation) => {
-	if (situation.reviewDecision === "changes-requested") return "changes are requested";
-	if (situation.reviewDecision === "review-required") return "a review from someone else is still wanted";
-	return whyNotGreen[situation.checks] ?? whyNotMergeable[situation.mergeable];
-};
-/**
-* What to do about a pull request that is Ready and carries no stamp.
+* Every repository and every pull request is read on its own, so one of them
+* failing costs me its rows and leaves the rest of the table standing. What
+* failed comes back beside the facts rather than instead of them.
 *
-* The stamp is withheld for one of three reasons and each has its own next
-* step, so the refusal names that step rather than leaving me to work out which
-* of the three it was. A withdrawal is the one with no command: I took the mark
-* off code I had read, and only that code changing puts it back.
+* `report` is told how far the pass has got, every time it gets further. What
+* that is worth saying is the caller's, which is why it is handed a count and
+* not a sentence.
 */
-const earnsIt = (situation) => {
-	if (situation.withdrawnAt === situation.head) return "\n\nYou took it off at this head, and it stays off until the head changes.";
-	const next = situation.reviewRunHead !== situation.head ? {
-		command: `dw-mc review ${situation.number}`,
-		says: "That reviews this head, and a run that finds nothing blocking stamps it."
-	} : {
-		command: `dw-mc fix ${situation.number}`,
-		says: "That opens a session on the findings. The stamp is back once the head has moved and a review run has read it."
+const sweep = Effect.fn("sweep")(function* (report) {
+	const file = Option.getOrElse(yield* read, () => ({}));
+	const repos = Object.keys(file.repos ?? {}).toSorted();
+	if (repos.length === 0) return {
+		repos,
+		facts: [],
+		troubles: []
 	};
-	return `\n\n  ${next.command}\n\n${next.says}`;
-};
+	const store = yield* storeFor("prs", Facts);
+	const me = yield* viewer;
+	let searched = 0;
+	yield* report({
+		_tag: "searching",
+		done: 0,
+		of: repos.length
+	});
+	const found = gather(yield* Effect.forEach(repos, (repo) => Effect.tap(attempt(repo, searchPrs(repo)), () => {
+		searched = searched + 1;
+		return report({
+			_tag: "searching",
+			done: searched,
+			of: repos.length
+		});
+	}), { concurrency }));
+	let read$1 = 0;
+	yield* report({
+		_tag: "reading",
+		done: 0,
+		of: found.got.length
+	});
+	const swept = gather(yield* Effect.forEach(found.got, (pr) => Effect.tap(attempt(`${pr.repo}#${pr.number}`, Effect.map(sweepPr(store, me, pr, settingsFor(file, pr.repo)), (facts) => [facts])), () => {
+		read$1 = read$1 + 1;
+		return report({
+			_tag: "reading",
+			done: read$1,
+			of: found.got.length
+		});
+	}), { concurrency }));
+	return {
+		repos,
+		facts: swept.got,
+		troubles: [...found.troubles, ...swept.troubles]
+	};
+});
 /**
-* Why this pull request is not one to merge, or null where it is.
-*
-* This is the single place the merge guards live, and they carry more than the
-* merge does: it is the one write the tool makes that no reflog of mine undoes
-* (ADR 0008). Two bars have to be clear, because each is blind to what the
-* other sees - GitHub does not know whether anything read the diff, and the
-* stamp does not know whether a reviewer asked for changes.
-*
-* Whose pull request it is comes first, as it does everywhere else: one
-* somebody else opened is none of this tool's business, whatever is true of it.
-* A draft is next, because a pull request I have not offered to anybody is not
-* one to land however green it is.
+* A sweep under its heartbeat, which is how every command that sweeps runs one.
 *
-* Ready is asked before the stamp so that the refusal names the bar I am
-* actually under. The stamp insists on green CI and a mergeable pull request
-* too, so everything it can be withheld for here is mine rather than GitHub's.
+* The three of them want the same line, so they say it once here rather than
+* three times over. It gives the heartbeat no aside, so a piped `dw-mc status`
+* prints exactly what it printed before there was a heartbeat at all.
 */
-const decide$2 = (situation) => {
-	const where = `${situation.repo}#${situation.number}`;
-	if (!situation.mine) return `${where} is not mine. dw-mc merges pull requests I author and nothing else.`;
-	if (situation.draft) return `${where} is a draft. Mark it ready for review before merging it.`;
-	const ready = whyNotReady(situation);
-	if (ready !== null) return `${where} is not Ready: ${ready}. dw-mc merges nothing GitHub would not merge itself.`;
-	const stamp = stampFor(situation, situation.withdrawnAt);
-	return stamp.stamped ? null : `${where} is Ready and carries no stamp: ${stamp.reason}.${earnsIt(situation)}`;
-};
-//#endregion
-//#region src/cli/merge.ts
+const sweeping = beating((since) => `sweeping · ${since}`, (says) => sweep((swept) => says(saying$1(swept))));
+/** What a sweep could not read, under a heading, so the table above it stands alone. */
+const printTroubles = Effect.fn("sweep.printTroubles")(function* (troubles) {
+	if (troubles.length === 0) return;
+	yield* Console.log("");
+	yield* Console.log("Could not load");
+	for (const trouble of troubles) yield* Console.log(`  ${trouble.where}  ${trouble.detail}`);
+});
 /**
-* Lands one pull request of mine: squashed, with its branch deleted.
-*
-* This is the write ADR 0008 is about, and the only one the tool makes that no
-* reflog of mine brings back. It is outside ADR 0002's three because it moves a
-* shared branch; everything 0002 bars - comment, reply, thread resolve, label,
-* review, approval, status - still holds here as it does everywhere.
-*
-* The threshold is two bars at one head: Ready, which is GitHub's opinion, and
-* my stamp, which is mine. Each is blind to what the other sees, so the write
-* that cannot be undone clears both.
-*
-* GitHub's half is read live from a fresh `pr view` rather than off the last
-* sweep, the way the rebase and re-run guards are. A stale verdict costs a
-* re-run some CI minutes; here it costs merging code nobody read. My half comes
-* from the state directory, because the review runs and the withdrawal live
-* there and are already scoped to the head this read just named.
+* Refreshes what mission control knows about every tracked PR.
 *
-* Typing the command is the confirmation, so it takes no flag. The picker,
-* where a keystroke is cheaper, asks before it dispatches.
+* `dw-mc status` does this too, so this command is for the pass on its own:
+* warming the state directory, or seeing what GitHub would not answer.
 */
-const merge = Command.make("merge", { pr: prArgument }, Effect.fn("merge")(function* ({ pr }) {
-	const file = Option.getOrElse(yield* read, () => ({}));
-	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
-	const settings = settingsFor(file, repo);
-	const view = yield* prView(repo, number);
-	const me = yield* viewer;
-	const head = view.headRefOid;
-	yield* refuse(decide$2({
-		repo,
-		number,
-		head,
-		mine: view.author?.login === me,
-		draft: view.isDraft,
-		reviewDecision: reviewDecisionOf(view.reviewDecision),
-		checks: rollupState(view.statusCheckRollup, settings.ci.ignore),
-		mergeable: mergeabilityOf(view.mergeable),
-		...yield* reviewedAt(repo, number, head, settings),
-		withdrawnAt: yield* withdrawnAt(repo, number)
-	}));
-	yield* mergePr(repo, number);
-	yield* Console.log(`${repo}#${number}  ${short(head)}  squash-merged into ${view.baseRefName}, and ${view.headRefName} deleted`);
-	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"));
+const sweepCommand = Command.make("sweep", {}, Effect.fn("sweep.command")(function* () {
+	const report = yield* sweeping;
+	yield* Console.log(report.repos.length === 0 ? "No repositories registered. Run dw-mc init inside a repository to register it." : `Swept ${count(report.facts.length, "pull request")} across ${repositories(report.repos.length)}`);
+	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/pick.ts
 /**
@@ -4275,13 +4510,11 @@ const Rerun = Schema.Struct({ head: Schema.String });
 * The head a re-run was last asked for at on this pull request, or null where
 * none has been.
 *
-* A record this version cannot read is one another version of it wrote. Reading
-* it again as nothing costs a flaky pull request one extra re-run, where failing
-* here would cost the command outright.
+* Forgetting one costs a flaky pull request one extra re-run.
 */
 const rerunFor = Effect.fn("rerun.rerunFor")(function* (repo, number) {
 	const store = yield* storeFor("reruns", Rerun);
-	const rerun = yield* Effect.orElseSucceed(store.get(prKey(repo, number)), () => Option.none());
+	const rerun = yield* remembered(store.get(prKey(repo, number)));
 	return Option.getOrNull(rerun)?.head ?? null;
 });
 /** Writes down that a re-run was asked for at `head`, which is the only head it caps. */
@@ -4370,7 +4603,7 @@ const where = (facts) => `${facts.repo}#${facts.number}`;
 * and a merge must never cost only that (ADR 0008).
 */
 const picker = (dispatch) => Effect.fn("pick")(function* () {
-	const report = yield* sweep;
+	const report = yield* sweeping;
 	if (report.repos.length === 0) {
 		yield* Console.log("No repositories registered. Run dw-mc init inside a repository to register it.");
 		return;
@@ -4433,13 +4666,13 @@ const picker = (dispatch) => Effect.fn("pick")(function* () {
 * so what it has to say about one is where the pull request sits in it.
 */
 const rebase = Command.make("rebase", { pr: prArgument }, Effect.fn("rebase")(function* ({ pr }) {
-	const file = Option.getOrElse(yield* read, () => ({}));
-	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
-	const settings = settingsFor(file, repo);
-	const view = yield* prView(repo, number);
-	const open = yield* openPrs(repo);
-	const me = yield* viewer;
-	yield* refuse(decide$3({
+	const { number, repo, settings } = yield* forPr(pr);
+	const [view, open, me] = yield* reading(`${repo}#${number}`, Effect.all([
+		prView(repo, number),
+		openPrs(repo),
+		viewer
+	]));
+	yield* refuse(decide$2({
 		repo,
 		number,
 		base: view.baseRefName,
@@ -4472,7 +4705,7 @@ const rebase = Command.make("rebase", { pr: prArgument }, Effect.fn("rebase")(fu
 		return;
 	}
 	yield* Console.log(`${where}  ${short(done.before)} → ${short(done.after)}  rebased ${count(done.behind, "commit")} of ${view.baseRefName} and pushed with a lease`);
-}, Effect.catchTag([...userFacing, "GitFailed"], asUserError))).pipe(Command.withDescription("Rebase one branch onto its base and push it with a lease"));
+}, Effect.catchTag(userFacingAndGit, asUserError))).pipe(Command.withDescription("Rebase one branch onto its base and push it with a lease"));
 //#endregion
 //#region src/cli/rerun.ts
 /**
@@ -4494,11 +4727,8 @@ const rebase = Command.make("rebase", { pr: prArgument }, Effect.fn("rebase")(fu
 * it is a pull request re-running itself until the minutes run out.
 */
 const rerun = Command.make("rerun", { pr: prArgument }, Effect.fn("rerun")(function* ({ pr }) {
-	const file = Option.getOrElse(yield* read, () => ({}));
-	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
-	const settings = settingsFor(file, repo);
-	const view = yield* prView(repo, number);
-	const me = yield* viewer;
+	const { number, repo, settings } = yield* forPr(pr);
+	const [view, me] = yield* reading(`${repo}#${number}`, Effect.all([prView(repo, number), viewer]));
 	const unclassified = {
 		repo,
 		number,
@@ -4585,11 +4815,6 @@ const promptFor = (conflicted) => Effect.map(asJson(conflicted), (json) => [
 //#endregion
 //#region src/cli/resolve.ts
 const printFlag = Flag.Boolean("print").pipe(Flag.withDefault(false), Flag.withDescription("Print the prompt a session would open on, and open none"));
-/** The domain's word on a conflict that is not one to open, as the command's own failure. */
-const allowed = (situation) => {
-	const refused = decide(situation);
-	return refused === null ? Effect.void : Effect.fail(new CliError.UserError({ cause: refused }));
-};
 /**
 * A session on the conflict that stopped a rebase, in a worktree that is mine.
 *
@@ -4614,13 +4839,14 @@ const resolve = Command.make("resolve", {
 	pr: prArgument,
 	print: printFlag
 }, Effect.fn("resolve")(function* ({ pr, print }) {
-	const file = Option.getOrElse(yield* read, () => ({}));
-	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
-	const view = yield* prView(repo, number);
-	const open = yield* openPrs(repo);
-	const me = yield* viewer;
+	const { number, repo, launcher } = yield* forPr(pr);
+	const [view, open, me] = yield* reading(`${repo}#${number}`, Effect.all([
+		prView(repo, number),
+		openPrs(repo),
+		viewer
+	]));
 	const conflict = yield* conflictFor(repo, number);
-	yield* allowed({
+	yield* refuse(decide({
 		repo,
 		number,
 		mine: view.author?.login === me,
@@ -4629,7 +4855,7 @@ const resolve = Command.make("resolve", {
 		stack: stackOf(number, open),
 		head: view.headRefOid,
 		conflictAt: conflict === null ? null : conflict.head
-	});
+	}));
 	/** The conflict as the prompt takes it, around whichever paths are known by then. */
 	const conflicted = (paths) => ({
 		repo,
@@ -4662,7 +4888,7 @@ const resolve = Command.make("resolve", {
 	yield* Console.log(`It stopped on ${count(stopped.paths.length, "file")}:`);
 	yield* Effect.forEach(stopped.paths, (path) => Console.log(`  ${path}`));
 	const ended = yield* steeredSession({
-		launcher: launcherOf(file),
+		launcher,
 		directory: worktree.directory,
 		prompt: yield* promptFor(conflicted(stopped.paths))
 	});
@@ -4676,12 +4902,7 @@ const resolve = Command.make("resolve", {
 		``
 	], (line) => Console.log(line));
 	yield* Console.log(`Once you have pushed, dw-mc review ${number} reviews the new head as a new run.`);
-}, Effect.catchTag([
-	...userFacing,
-	"GitFailed",
-	"WorktreeHeld",
-	"AgentFailed"
-], asUserError))).pipe(Command.withDescription("Open a session on the conflict that stopped a rebase, in a worktree of my own"));
+}, Effect.catchTag(userFacingAndSession, asUserError))).pipe(Command.withDescription("Open a session on the conflict that stopped a rebase, in a worktree of my own"));
 //#endregion
 //#region src/adapters/notify.ts
 /** A string as AppleScript spells one, so a quotation mark cannot end it early. */
@@ -4701,73 +4922,6 @@ const announce = Effect.fn("notify.announce")(function* (title, message) {
 	yield* Effect.ignore(capture("osascript", ["-e", `display notification ${quoted(message)} with title ${quoted(title)}`]));
 });
 //#endregion
-//#region src/adapters/progress.ts
-/** The frames of the spinner, in the order they turn. */
-const frames = [
-	"⠋",
-	"⠙",
-	"⠹",
-	"⠸",
-	"⠼",
-	"⠴",
-	"⠦",
-	"⠧",
-	"⠇",
-	"⠏"
-];
-/** How long one frame is on the screen. */
-const frameFor = Duration.millis(120);
-/** A stretch of time as a terminal says it: `1m12s`, or `9s` under the minute. */
-const elapsed = (millis) => {
-	const seconds = Math.floor(millis / 1e3);
-	return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m${String(seconds % 60).padStart(2, "0")}s`;
-};
-/**
-* Runs `use` while the screen says it is still going, and hands `use` the way
-* to report what the run reached for.
-*
-* A review takes minutes, and a terminal that prints nothing for minutes is one
-* I stop trusting. What it printed instead was a line per tool call, which is a
-* wall of `· Bash` that says as little as silence did. This keeps one line and
-* rewrites it: the spinner says the run is alive, the counts say how far it has
-* got, and the line is gone when the run is over, so what stays on the screen is
-* the report.
-*
-* How that line reads is `reads` and not this module's business. What a count
-* is worth saying belongs to the command that is counting, and a screen that
-* worded it here would need the words a command already has.
-*
-* Where there is no screen to measure - a pipe, a CI log, a test - the counts
-* would be a mess of half-drawn lines, so the tools go out one to a line as
-* they did before. `columns` is zero exactly there.
-*/
-const spinning = Effect.fnUntraced(function* (reads, use) {
-	const terminal = yield* Terminal.Terminal;
-	const columns = yield* terminal.columns;
-	if (columns === 0) return yield* use((tool) => Console.log(`  · ${tool}`));
-	let doing = {
-		tools: 0,
-		subagents: 0
-	};
-	const onTool = (tool) => Effect.sync(() => {
-		doing = {
-			tools: doing.tools + 1,
-			subagents: doing.subagents + (tool === "Agent" ? 1 : 0)
-		};
-	});
-	const started = yield* Clock.currentTimeMillis;
-	const draw = (text) => Effect.ignore(terminal.display(`\r${text.slice(0, columns - 1).padEnd(columns - 1)}`));
-	const frame = (since, turn) => `${frames[turn % frames.length]} ${reads(doing, elapsed(since))}`;
-	yield* draw(frame(0, 0));
-	const turning = yield* Effect.forkChild(Effect.gen(function* () {
-		for (let turn = 1;; turn = turn + 1) {
-			yield* Effect.sleep(frameFor);
-			yield* draw(frame((yield* Clock.currentTimeMillis) - started, turn));
-		}
-	}));
-	return yield* Effect.onExit(use(onTool), () => Effect.flatMap(Fiber.interrupt(turning), () => Effect.ignore(terminal.display(`\r${" ".repeat(columns - 1)}\r`))));
-});
-//#endregion
 //#region src/domain/persona.ts
 /**
 * The reviewer persona, derived from Addy Osmani's `code-reviewer` agent
@@ -4859,8 +5013,8 @@ const turnFor = (review, about) => review.command === null ? {
 };
 //#endregion
 //#region src/cli/review.ts
-/** What the spinner says a run has got through, while it is still going. */
-const saying = (doing, since) => [
+/** What the heartbeat says a run has got through, while it is still going. */
+const saying = (doing) => (since) => [
 	"reviewing",
 	count(doing.tools, "tool"),
 	doing.subagents === 0 ? null : count(doing.subagents, "subagent"),
@@ -4925,13 +5079,23 @@ const spending = (turn, model) => [
 */
 const reviewOn = Effect.fn("review.reviewOn")(function* (options) {
 	const { directory, launcher, model, turn } = options;
-	const run = yield* spinning(saying, (onTool) => reviewTurns({
+	let doing = {
+		tools: 0,
+		subagents: 0
+	};
+	const run = yield* beating(saying(doing), (says) => reviewTurns({
 		launcher,
 		directory,
 		turn,
 		model,
 		jsonSchema,
-		onTool
+		onTool: (tool) => {
+			doing = {
+				tools: doing.tools + 1,
+				subagents: doing.subagents + (tool === "Agent" ? 1 : 0)
+			};
+			return says(saying(doing), `  · ${tool}`);
+		}
 	}));
 	const answered = Result.isFailure(run.findings) ? Effect.fail(run.findings.failure) : Effect.succeed(run.findings.success);
 	const reported = yield* Effect.result(Effect.flatMap(answered, (output) => Schema.decodeUnknownEffect(Reported)(output)));
@@ -5014,10 +5178,7 @@ const review = Command.make("review", {
 	commandOnly: commandOnlyFlag,
 	force: forceFlag$1
 }, Effect.fn("review")(function* ({ command, commandOnly, effort, force, model, pr, prompt, promptOnly }) {
-	const file = Option.getOrElse(yield* read, () => ({}));
-	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
-	const settings = settingsFor(file, repo);
-	const launcher = launcherOf(file);
+	const { number, repo, settings, launcher } = yield* forPr(pr);
 	const asked = yield* asking({
 		settings,
 		command,
@@ -5091,7 +5252,7 @@ const review = Command.make("review", {
 		yield* Console.log(`Recorded against ${short(ran.head)} in ${yield* stateDirectory}`);
 		yield* unreported(run, number);
 	}).pipe(Effect.onExit((exit) => announce("dw-mc review", `${repo}#${number} ${Exit.isSuccess(exit) ? "reviewed" : "could not be reviewed"}`)));
-}, Effect.catchTag([...userFacing, "GitFailed"], asUserError))).pipe(Command.withDescription("Review one pull request on Claude Code, in a throwaway worktree"));
+}, Effect.catchTag(userFacingAndGit, asUserError))).pipe(Command.withDescription("Review one pull request on Claude Code, in a throwaway worktree"));
 //#endregion
 //#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"));
@@ -5116,8 +5277,7 @@ const stampCommand = Command.make("stamp", {
 	pr: prArgument,
 	withdraw: withdrawFlag
 }, 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 { number, repo } = yield* forPr(pr);
 	const facts = yield* swept(repo, number);
 	const where = `${repo}#${number}  ${short(facts.head)}`;
 	if (byHand) {
@@ -5157,7 +5317,7 @@ const lines = (grouped, stamped, paint) => {
 * It sweeps first, every time: a table I read is never one I forgot to refresh.
 */
 const status = Command.make("status", {}, Effect.fn("status")(function* () {
-	const report = yield* sweep;
+	const report = yield* sweeping;
 	if (report.repos.length === 0) {
 		yield* Console.log("No repositories registered. Run dw-mc init inside a repository to register it.");
 		return;
@@ -5249,7 +5409,7 @@ const uninstall = Command.make("uninstall", {
 * 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.4.0";
+const version = "0.5.1";
 /** Where the project lives, printed beside the version in the header. */
 const projectUrl = "github.com/dominikwozniak/dw-mc";
 const subcommands = [