dw-mc 0.6.0 → 0.8.0

package/dist/bin.js

@@ -547,9 +547,60 @@ const textStoreFor = Effect.fn("store.textStoreFor")(function* (namespace) {
 * bargain is struck once rather than at each of them.
 */
 const remembered = (read) => Effect.orElseSucceed(read, () => Option.none());
+/**
+* Every key the state directory holds, whichever namespace it sits in.
+*
+* A key/value store answers about a key it is given and never lists one, and
+* forgetting a pull request needs the list: a review run is kept under the head
+* it read, and nothing on hand names every head a pull request was reviewed at.
+*/
+var Keys = class extends Context.Service()("dw-mc/store/Keys") {};
+/**
+* The key a file in the state directory was written under, and none for a
+* file no key could have been written as: the file store names every file it
+* writes by percent-encoding its key, so a name that does not decode is
+* something else put there.
+*/
+const keyOf$1 = (entry) => {
+	try {
+		return [decodeURIComponent(entry)];
+	} catch {
+		return [];
+	}
+};
+/**
+* The keys a file store over `directory` holds: one file each, named by the
+* percent-encoded key.
+*
+* The clones and the checkouts sit beside them as directories, and none of
+* them is a key.
+*/
+const keysOnDisk = (directory) => Layer.effect(Keys, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const directories = /* @__PURE__ */ new Set([clonesIn, ...cuts]);
+	return { all: fs.readDirectory(directory).pipe(Effect.map((entries) => entries.filter((entry) => !directories.has(entry)).flatMap(keyOf$1)), Effect.mapError((cause) => new KeyValueStore.KeyValueStoreError({
+		method: "keys",
+		message: "Unable to list the keys",
+		cause
+	}))) };
+}));
+/** Every key the state directory holds. */
+const allKeys = Effect.gen(function* () {
+	return yield* (yield* Keys).all;
+});
 /** The state directory on disk. */
-const layer$1 = Layer.unwrap(Effect.map(stateDirectory, (directory) => KeyValueStore.layerFileSystem(directory)));
-KeyValueStore.layerMemory;
+const layer$1 = Layer.unwrap(Effect.map(stateDirectory, (directory) => Layer.merge(KeyValueStore.layerFileSystem(directory), keysOnDisk(directory))));
+Layer.effectContext(Effect.gen(function* () {
+	const inner = yield* KeyValueStore.KeyValueStore;
+	const held = /* @__PURE__ */ new Set();
+	const store = KeyValueStore.make({
+		...inner,
+		set: (key, value) => Effect.tap(inner.set(key, value), () => Effect.sync(() => held.add(key))),
+		remove: (key) => Effect.tap(inner.remove(key), () => Effect.sync(() => held.delete(key))),
+		clear: Effect.tap(inner.clear, () => Effect.sync(() => held.clear()))
+	});
+	return Context.make(KeyValueStore.KeyValueStore, store).pipe(Context.add(Keys, { all: Effect.sync(() => [...held]) }));
+})).pipe(Layer.provide(KeyValueStore.layerMemory));
 /** The three directories the tool cuts a checkout into, under the state directory. */
 const cuts = [
 	"worktrees",
@@ -1503,1094 +1554,1151 @@ const truncate = (text, width) => {
 /** `n` of something, pluralised the one way English usually is. */
 const count = (n, noun) => `${n} ${noun}${n === 1 ? "" : "s"}`;
 //#endregion
-//#region src/domain/cleanup.ts
-/** The checkouts that stand for a session, named by the session they stand for. */
-const standing = (inventory) => inventory.cuttings.flatMap((cutting) => {
-	const session = sessionOf(cutting.cut);
-	return session === void 0 ? [] : [{
-		...cutting,
-		session
-	}];
-});
-/** The checkouts a review run cut, which no run that ended still needs. */
-const orphaned = (inventory) => inventory.cuttings.filter((cutting) => cutting.cut === "worktrees");
-const sum = (sizes) => ByteSize.bytes(sizes.reduce((total, size) => total + ByteSize.toBigInt(size), BigInt(0)));
-const reason = (sessions) => sessions.map((it) => `a ${it.session === "fix" ? "fix" : "resolve"} session stands on ${it.repo}#${it.number}`).join(", ");
+//#region src/domain/findings.ts
+/** Whether a review run found anything at all. */
+const Verdict = Schema.Literals(["clean", "findings"]);
 /**
-* What a cleanup would take, weighed.
+* Every severity word a review may answer with.
 *
-* A clone whose repository has a session standing on it stays, and that is not
-* politeness: a standing worktree keeps its history inside the clone, so a
-* clone removed from under one leaves a directory of files with nothing behind
-* them. The worktrees of that session stay with it; the review run's own go
-* either way, because they belong to a run that has ended.
+* 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 plan = (inventory) => {
-	const sessions = standing(inventory);
-	const worktrees = orphaned(inventory);
-	const held = /* @__PURE__ */ new Map();
-	for (const session of sessions) held.set(session.repo, [...held.get(session.repo) ?? [], session]);
-	const clones = inventory.clones.filter((clone) => !held.has(clone.repo));
-	return {
-		clones,
-		worktrees,
-		kept: inventory.clones.flatMap((clone) => {
-			const sessionsHere = held.get(clone.repo);
-			return sessionsHere === void 0 ? [] : [{
-				clone,
-				because: reason(sessionsHere)
-			}];
-		}),
-		size: sum([...clones, ...worktrees].map((it) => it.size))
-	};
-};
-/** What the whole state directory weighs: the clones, the checkouts and the records. */
-const everything$1 = (inventory) => sum([
-	...inventory.clones.map((it) => it.size),
-	...inventory.cuttings.map((it) => it.size),
-	inventory.records.size
+const Spelling = Schema.Literals([
+	"error",
+	"warning",
+	"info",
+	"Critical",
+	"Required",
+	"Optional",
+	"Nit",
+	"FYI"
 ]);
-/** Whether a plan has anything to do at all. */
-const empty = (it) => it.clones.length === 0 && it.worktrees.length === 0;
-/** A size as a line says it: three digits at most, and the unit the terminal reads. */
-const weight = (size) => ByteSize.format(size, {
-	system: "decimal",
-	precision: 1
+/** 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"
+};
+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
 });
-//#endregion
-//#region src/cli/cleanup.ts
-const yesFlag = Flag.Boolean("yes").pipe(Flag.withDefault(false), Flag.withDescription("Do it without asking, for a machine that has no terminal to ask at"));
-/** A path said as the state directory's own, which is the heading it sits under. */
-const inside = (path, state, directory) => path.relative(state, directory);
 /**
-* The two blocks a cleanup writes: what it takes and what it leaves.
+* 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 weight is on every row because the whole question is whether this is
-* worth doing, and the reason is on every row because a clone and a worktree
-* are taken back for different reasons and both read as "a directory of mine"
-* on the screen.
+* 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 lines$3 = (it, state, path, paint) => {
-	const taking = table([...it.worktrees.map((worktree) => [
-		paint.dim(inside(path, state, worktree.directory)),
-		weight(worktree.size),
-		"a review worktree a run left behind"
-	]), ...it.clones.map((clone) => [
-		paint.dim(inside(path, state, clone.directory)),
-		weight(clone.size),
-		"a bare clone, cloned again on the next run"
-	])]);
-	const staying = table(it.kept.map((kept) => [
-		paint.dim(inside(path, state, kept.clone.directory)),
-		weight(kept.clone.size),
-		kept.because
-	]));
-	return [
-		"Takes back",
-		...taking.map((line) => `  ${line}`),
-		"",
-		...staying.length === 0 ? [] : [
-			"Stays",
-			...staying.map((line) => `  ${line}`),
-			""
-		]
-	];
-};
+const Reported = Schema.Struct({
+	verdict: Verdict,
+	findings: Schema.Array(Schema.Struct({
+		...shared,
+		severity: Weighed
+	}))
+});
 /**
-* Takes back the disk the tool spent on itself, and nothing that is mine.
+* The schema every runner must satisfy, as the JSON Schema a runner is handed.
 *
-* What it removes is what the tool builds again by itself: the bare clones and
-* the worktrees a review run cut. What it never removes is what I decided - the
-* configuration file - and what I worked in - the worktree of a fix or resolve
-* session, which stands on a branch of the tool's own and holds what I
-* committed there. Forgetting a pull request's records is a different question
-* with a different answer (#58), and it is not asked here.
+* 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.
 *
-* A clone with a session standing on it stays with the session: a standing
-* worktree keeps its history inside the clone, so a clone taken from under one
-* would leave a directory of files with nothing behind them. The clones that
-* stay are pruned instead, because a worktree directory removed under `git`
-* leaves the clone's record of it behind and the next session cut at that path
-* is refused as already registered.
+* 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.
 */
-const cleanup = Command.make("cleanup", { yes: yesFlag }, Effect.fn("cleanup")(function* ({ yes }) {
-	const path = yield* Path.Path;
-	const paint = yield* Paint;
-	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}.`);
-		return;
-	}
-	yield* Effect.forEach(lines$3(it, found.directory, path, paint), (line) => Console.log(line));
-	if (!yes && !(yield* confirm(`Take back ${weight(it.size)}?`))) {
-		yield* Console.log("Nothing was removed.");
-		return;
-	}
-	yield* Effect.forEach([...it.worktrees, ...it.clones], (taken) => Effect.andThen(discard(taken.directory), tidy(taken.directory, found.directory)));
-	yield* Effect.forEach(it.kept, (kept) => prune(kept.clone.directory));
-	yield* Console.log(`Took back ${weight(it.size)}.`);
-})).pipe(Command.withDescription("Take back the disk the tool spent on clones and review worktrees"));
-//#endregion
-//#region src/adapters/gh.ts
-/** `gh` is on the machine but would not run. */
-var GhUnavailable = class extends Schema.TaggedError()("GhUnavailable", { detail: Schema.String }) {
-	get message() {
-		return `gh could not be run: ${this.detail}\nInstall it from https://cli.github.com, then run 'gh auth login'.`;
-	}
-};
-/** `gh` runs but is not logged in, so every read of GitHub would fail. */
-var GhUnauthenticated = class extends Schema.TaggedError()("GhUnauthenticated", { detail: Schema.String }) {
-	get message() {
-		return `gh is not authenticated. Run 'gh auth login'.\n${this.detail}`;
-	}
-};
-/** The working directory is not inside a repository `gh` can name. */
-var NoRepository = class extends Schema.TaggedError()("NoRepository", { detail: Schema.String }) {
-	get message() {
-		return `This directory is not a GitHub repository dw-mc can register.\n${this.detail}`;
-	}
-};
-/** `gh` answered, in a shape this version of dw-mc does not know. */
-var GhUnreadable = class extends Schema.TaggedError()("GhUnreadable", {
-	command: Schema.String,
-	reason: Schema.String
-}) {
-	get message() {
-		return `gh ${this.command} answered with something dw-mc cannot read: ${this.reason}`;
-	}
+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
 };
-/** What a `gh` that would not even start comes to. */
-const unavailable = (error) => new GhUnavailable({ detail: error.reason._tag === "NotFound" ? "it is not installed" : error.message });
 /**
-* Stops unless `gh` is installed and logged in.
+* The findings that withhold the stamp: everything at `blocksOn` or above it.
 *
-* Every read of GitHub goes through `gh` as me, so a missing or logged-out `gh`
-* is worth saying once, up front, rather than as an empty table later.
+* `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 requireAuth = capture("gh", ["auth", "status"]).pipe(Effect.asVoid, Effect.catchTags({
-	PlatformError: (error) => Effect.fail(unavailable(error)),
-	CommandFailed: (error) => Effect.fail(new GhUnauthenticated({ detail: error.stderr }))
-}), Effect.withSpan("gh.requireAuth"));
-const RepoView = Schema.fromJsonString(Schema.Struct({ nameWithOwner: Schema.String }));
-/** The `owner/repo` of the repository the working directory is in. */
-const currentRepo = Effect.gen(function* () {
-	const json = yield* capture("gh", [
-		"repo",
-		"view",
-		"--json",
-		"nameWithOwner"
-	]).pipe(Effect.catchTags({
-		PlatformError: (error) => Effect.fail(unavailable(error)),
-		CommandFailed: (error) => Effect.fail(new NoRepository({ detail: error.stderr }))
-	}));
-	return (yield* Schema.decodeEffect(RepoView)(json).pipe(Effect.mapError((error) => new GhUnreadable({
-		command: "repo view",
-		reason: error.message
-	})))).nameWithOwner;
-}).pipe(Effect.withSpan("gh.currentRepo"));
-/** A call to GitHub that `gh` itself refused, whether it was reading or writing. */
-var GhReadFailed = class extends Schema.TaggedError()("GhReadFailed", {
-	command: Schema.String,
-	detail: Schema.String
-}) {
-	get message() {
-		return `gh ${this.command} failed: ${this.detail}`;
-	}
-};
-/** One `gh` read, decoded, with every way it can go wrong in our words. */
-const readJson = (label, command, args, schema) => capture(command, args).pipe(Effect.catchTags({
-	PlatformError: (error) => Effect.fail(unavailable(error)),
-	CommandFailed: (error) => Effect.fail(new GhReadFailed({
-		command: label,
-		detail: error.stderr
-	}))
-}), Effect.flatMap((json) => Schema.decodeEffect(schema)(json).pipe(Effect.mapError((error) => new GhUnreadable({
-	command: label,
-	reason: error.message
-})))), Effect.withSpan(`gh.${label}`));
-/** The login `gh` is authenticated as: the "me" every read is scoped to. */
-const viewer = readJson("api user", "gh", ["api", "user"], Schema.fromJsonString(Schema.Struct({ login: Schema.String }))).pipe(Effect.map((user) => user.login));
-const SearchResults = Schema.fromJsonString(Schema.Array(Schema.Struct({
-	number: Schema.Int,
-	repository: Schema.Struct({ nameWithOwner: Schema.String })
-})));
+const blocking = (findings, blocksOn) => findings.filter((finding) => rank[finding.severity] >= rank[blocksOn]);
+//#endregion
+//#region src/domain/review.ts
 /**
-* The open pull requests I authored in `repo`.
+* What a review run came to, which is what its second turn reported.
 *
-* One search per repository rather than one for all of them: a repository `gh`
-* cannot read then costs me that repository's rows and not the whole table.
+* 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 searchPrs = Effect.fnUntraced(function* (repo) {
-	return (yield* readJson("search prs", "gh", [
-		"search",
-		"prs",
-		"--author=@me",
-		"--state=open",
-		"--repo",
-		repo,
-		"--limit",
-		"100",
-		"--json",
-		"number,repository"
-	], SearchResults)).map((it) => ({
-		repo: it.repository.nameWithOwner,
-		number: it.number
-	}));
-});
+const Outcome = Schema.Union([Schema.TaggedStruct("reported", {
+	verdict: Verdict,
+	findings: Schema.Array(Finding)
+}), Schema.TaggedStruct("failed", { detail: Schema.String })]);
 /**
-* One entry of a PR's status check rollup.
+* One review run against a tracked PR at a specific head commit.
 *
-* A rollup mixes two shapes: a `CheckRun` reports a `status` and a `conclusion`,
-* a `StatusContext` an overall `state`. Every field is optional because which
-* ones arrive depends on which shape it is.
+* 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 CheckEntry = Schema.Struct({
-	name: Schema.optionalKey(Schema.String),
-	context: Schema.optionalKey(Schema.String),
-	status: Schema.optionalKey(Schema.String),
-	conclusion: Schema.optionalKey(Schema.String),
-	state: Schema.optionalKey(Schema.String),
-	/** The workflow the check runs in. A commit status belongs to no workflow. */
-	workflowName: Schema.optionalKey(Schema.String),
-	/** Where the check reports, which is the only place its job id appears. */
-	detailsUrl: Schema.optionalKey(Schema.String)
-});
-const PrView = Schema.fromJsonString(Schema.Struct({
+const ReviewRun = Schema.Struct({
+	repo: Schema.String,
 	number: Schema.Int,
-	title: Schema.String,
-	url: Schema.String,
-	isDraft: Schema.Boolean,
-	headRefOid: Schema.String,
-	headRefName: Schema.String,
-	baseRefName: Schema.String,
-	/** Who opened it, which is what says whether its branch is mine to push to. */
-	author: Schema.NullOr(Schema.Struct({ login: Schema.String })),
-	/** Whether the head branch lives in a fork rather than in this repository. */
-	isCrossRepository: Schema.Boolean,
-	mergeable: Schema.String,
-	reviewDecision: Schema.String,
-	statusCheckRollup: Schema.NullOr(Schema.Array(CheckEntry))
-}));
+	/** 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 fields one `gh pr view` asks for, named so a test can spell the vector it
-* expects without copying the list and watching it drift.
+* 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 viewFields = "number,title,url,isDraft,headRefOid,headRefName,baseRefName,author,isCrossRepository,mergeable,reviewDecision,statusCheckRollup";
+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`;
 /**
-* Everything about one pull request that arrives without paging through it:
-* its head, what GitHub thinks of merging it, and where CI got to.
+* Which head a pull request was last reviewed at: an index beside `runKey` and
+* `reportKey` rather than a thing the glossary names.
+*
+* 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 prView = Effect.fnUntraced(function* (repo, number) {
-	return yield* readJson("pr view", "gh", [
-		"pr",
-		"view",
-		String(number),
-		"--repo",
-		repo,
-		"--json",
-		viewFields
-	], PrView);
-});
-const OpenPrs = Schema.fromJsonString(Schema.Array(Schema.Struct({
-	number: Schema.Int,
-	headRefName: Schema.String,
-	baseRefName: 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`;
 /**
-* Every open pull request on a repository, by branch.
+* The run at one head, or none where nothing has reviewed it.
 *
-* Everyone's and not only mine: a stack is recognised from branches built on
-* branches, and a pull request of mine can sit on one somebody else opened.
+* 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.
 *
-* The page is deep because a pull request this misses is one that looks like it
-* is in no stack, and a stack the tool cannot see is one it could drive.
+* Forgetting a run costs one review.
 */
-const openPrs = Effect.fnUntraced(function* (repo) {
-	return (yield* readJson("pr list", "gh", [
-		"pr",
-		"list",
-		"--repo",
-		repo,
-		"--state",
-		"open",
-		"--limit",
-		"500",
-		"--json",
-		"number,headRefName,baseRefName"
-	], OpenPrs)).map((it) => ({
-		number: it.number,
-		head: it.headRefName,
-		base: it.baseRefName
-	}));
+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 Comments = Schema.fromJsonString(Schema.Array(Schema.Struct({
-	created_at: Schema.DateTimeUtcFromString,
-	user: Schema.NullOr(Schema.Struct({
-		login: Schema.String,
-		type: Schema.String
-	}))
-})));
-const comments$1 = (label, path) => readJson(label, "gh", ["api", path], Comments).pipe(Effect.map((all) => all.flatMap((comment) => comment.user === null ? [] : [{
-	login: comment.user.login,
-	bot: comment.user.type === "Bot",
-	at: comment.created_at
-}])));
 /**
-* Every comment on a pull request: the ones on the conversation and the ones
-* left on the diff.
+* What a run reported, or null where it reported nothing at all.
 *
-* REST is what says whether an author is a person or an app - `gh pr view`
-* reports a bot's login with no sign that it is one - and the bucket rules turn
-* on exactly that. Verified by running both: the endpoints ignore `direction`,
-* so a page is asked for at its maximum and the newest comment is picked out of
-* it rather than asked for first.
+* 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 prComments = Effect.fnUntraced(function* (repo, number) {
-	const page = "per_page=100";
-	const [conversation, onDiff] = yield* Effect.all([comments$1("api issue comments", `repos/${repo}/issues/${number}/comments?${page}`), comments$1("api review comments", `repos/${repo}/pulls/${number}/comments?${page}`)], { concurrency: 2 });
-	return [...conversation, ...onDiff];
-});
-const Reviews = Schema.fromJsonString(Schema.Array(Schema.Struct({
-	submitted_at: Schema.DateTimeUtcFromString,
-	body: Schema.String,
-	user: Schema.NullOr(Schema.Struct({
-		login: Schema.String,
-		type: Schema.String
-	}))
-})));
+const reportedBy = (run) => run.outcome._tag === "reported" ? {
+	verdict: run.outcome.verdict,
+	findings: run.outcome.findings
+} : null;
 /**
-* The reviews on a pull request that said something, as comments.
+* Why a run reported nothing, or null where it reported.
 *
-* A review carries a body of its own, which is where a reviewer writes the
-* sentence that is not attached to any line. An empty body is a verdict and
-* nothing more, and the verdict arrives with the PR as `reviewDecision`.
+* 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 prReviews = Effect.fnUntraced(function* (repo, number) {
-	return (yield* readJson("api reviews", "gh", ["api", `repos/${repo}/pulls/${number}/reviews?per_page=100`], Reviews)).flatMap((review) => review.user === null || review.body.trim() === "" ? [] : [{
-		login: review.user.login,
-		bot: review.user.type === "Bot",
-		at: review.submitted_at
-	}]);
-});
-const Compare = Schema.fromJsonString(Schema.Struct({ files: Schema.optionalKey(Schema.Array(Schema.Struct({ filename: Schema.String }))) }));
+const detailOf = (run) => run.outcome._tag === "failed" ? run.outcome.detail : null;
 /**
-* The repository paths that changed between two commits.
-*
-* GitHub compares them rather than git, because the commit a run was recorded
-* against is not one the tool's own clone is promised to still have: a force
-* push moves the pull request's ref and the old commit goes with it, where
-* GitHub keeps both sides of the comparison. A comparison of a commit with
-* itself reports no files at all, and so does one of two commits with nothing
-* between them, which is why the key is optional.
+* Whether the files changed since the last run are worth paying for another.
 *
-* `base...head` measures from where the two commits last agreed, so two heads
-* on one branch report what was pushed between them, and a branch rebased since
-* reports its whole diff. The second is the right answer for a caller deciding
-* whether the code has moved: after a rebase it has, all of it.
+* 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 comparedFiles = Effect.fnUntraced(function* (repo, base, head) {
-	return ((yield* readJson("api compare", "gh", ["api", `repos/${repo}/compare/${base}...${head}`], Compare)).files ?? []).map((file) => file.filename);
-});
-const Commits = Schema.fromJsonString(Schema.Struct({ commits: Schema.Array(Schema.Struct({
-	committedDate: Schema.DateTimeUtcFromString,
-	authors: Schema.Array(Schema.Struct({ login: Schema.NullOr(Schema.String) }))
-})) }));
+const worthRerunning = (changed, docsOnly) => changed.some((file) => !docsOnly.some((glob) => matchesGlob(file, glob)));
 /**
-* The commits on a pull request.
+* The re-run rule: the head this run is skipped against, or null where it runs.
 *
-* This is the expensive read of the three: `gh` returns every commit with its
-* whole message, so a sweep only asks for it when something about the PR has
-* actually moved.
+* 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 prCommits = Effect.fnUntraced(function* (repo, number) {
-	return (yield* readJson("pr view commits", "gh", [
-		"pr",
-		"view",
-		String(number),
-		"--repo",
-		repo,
-		"--json",
-		"commits"
-	], Commits)).commits.map((commit) => ({
-		logins: commit.authors.flatMap((author) => author.login === null ? [] : [author.login]),
-		at: commit.committedDate
-	}));
-});
+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$2 = (run) => run.command === null ? "the tool's own prompt" : [run.command, run.effort].filter((part) => part !== null).join(" ");
 /**
-* What `gh` says about merging, in our words. Anything else is `unknown`:
-* GitHub answers that too, for a PR whose mergeability it is still computing.
+* The report as it is written down: what it is of, then what the run said.
 *
-* `Match.withReturnType` comes first in the pipeline or the return type is not
-* enforced: a handler's literal widens to `string` on its own.
+* 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 mergeabilityOf = (raw) => Match.value(raw).pipe(Match.withReturnType(), Match.when("MERGEABLE", () => "mergeable"), Match.when("CONFLICTING", () => "conflicting"), Match.orElse(() => "unknown"));
+const reportDocument = (run, title, prose) => [
+	`# ${run.repo}#${run.number} ${title}`,
+	"",
+	`- head: ${run.head}`,
+	`- run: ${askedOf$2(run)}`,
+	`- ran: ${DateTime.formatIso(run.ranAt)}`,
+	"",
+	prose.trim(),
+	""
+].join("\n");
 /**
-* What `gh` says the reviewers decided, in our words. A repository that requires
-* no reviewer reports an empty string, which is `none` rather than pending.
+* Whether `head` has the review it needs.
+*
+* 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 reviewDecisionOf = (raw) => Match.value(raw).pipe(Match.withReturnType(), Match.when("APPROVED", () => "approved"), Match.when("CHANGES_REQUESTED", () => "changes-requested"), Match.when("REVIEW_REQUIRED", () => "review-required"), Match.orElse(() => "none"));
+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);
+};
 /**
-* Squash-merges a pull request and deletes the branch it stood on.
+* What the review runs on `head` say about it, for the stamp to rest on.
 *
-* The one write the tool makes that no reflog of mine undoes, and the whole of
-* it: a squash, because that is how the repository lands a pull request and the
-* squash subject is its title, and the branch, because squashing kills it
-* anyway. No `--auto`, which would hand GitHub a merge to make at a head
-* nothing here has read (ADR 0008).
+* 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.
 *
-* Whether this pull request is one to merge is decided before we get here, and
-* `gh` still has the last word: a branch protection this machine cannot see
-* comes back as a failure and is printed as one.
+* 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 mergePr = Effect.fnUntraced(function* (repo, number) {
-	yield* capture("gh", [
-		"pr",
-		"merge",
-		String(number),
-		"--repo",
-		repo,
-		"--squash",
-		"--delete-branch"
-	]).pipe(Effect.catchTags({
-		PlatformError: (error) => Effect.fail(unavailable(error)),
-		CommandFailed: (error) => Effect.fail(new GhReadFailed({
-			command: "pr merge",
-			detail: error.stderr
-		}))
-	}));
+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/adapters/conversation.ts
-const Actor = Schema.NullOr(Schema.Struct({
-	login: Schema.String,
-	__typename: Schema.String
-}));
-const Said = Schema.Struct({
-	author: Actor,
-	body: Schema.String,
-	createdAt: Schema.DateTimeUtcFromString
-});
-const Conversation = Schema.fromJsonString(Schema.Struct({ data: Schema.Struct({ repository: Schema.Struct({ pullRequest: Schema.Struct({
-	comments: Schema.Struct({ nodes: Schema.Array(Said) }),
-	reviews: Schema.Struct({ nodes: Schema.Array(Schema.Struct({
-		author: Actor,
-		body: Schema.String,
-		submittedAt: Schema.NullOr(Schema.DateTimeUtcFromString)
-	})) }),
-	reviewThreads: Schema.Struct({ nodes: Schema.Array(Schema.Struct({
-		isResolved: Schema.Boolean,
-		isOutdated: Schema.Boolean,
-		path: Schema.NullOr(Schema.String),
-		line: Schema.NullOr(Schema.Int),
-		comments: Schema.Struct({ nodes: Schema.Array(Said) })
-	})) })
-}) }) }) }));
-const remark = (said, at) => said.author === null || at === null || said.body.trim() === "" ? [] : [{
-	login: said.author.login,
-	bot: said.author.__typename === "Bot",
-	at,
-	body: said.body.trim()
-}];
-const byTime = (self, other) => DateTime.Order(self.at, other.at);
+//#region src/cli/block.ts
 /**
-* A pull request's whole conversation: the comments on it, the bodies of the
-* reviews, and every thread on the diff with whether it is settled.
-*
-* GraphQL rather than the two REST endpoints a sweep reads, because resolution
-* is not in REST at all: a review comment's payload carries `body`, `path`,
-* `line`, `diff_hunk` and `side`, and nothing saying whether somebody closed
-* the thread it belongs to. A thread that was settled a week ago is not
-* something to answer, so the state that says so has to arrive with it.
+* How a command that reports rather than tabulates writes its page: in blocks,
+* each a heading with its body indented under it, and a blank line before the
+* next one (ADR 0007).
 *
-* The pull request's own comments and the reviews' bodies come back as one
-* strand under no path, in the order they were written: they are one
-* conversation as it happened, and which endpoint each line came from is an
-* accident of GitHub's model rather than anything to read.
+* What a command says is its own. The shape is here, so a report reads the
+* same whichever command wrote it, and so do the three lines more than one of
+* them writes: the opener, the files a rebase stopped on, and a command to
+* retype.
 *
-* `__typename` is what says a bot is a bot, the way `user.type` does in REST.
+* A block is its lines, and a line of prose on its own is a block with no
+* body. Nothing here colours a heading or a line of prose.
 */
-const prConversation = Effect.fnUntraced(function* (repo, number) {
-	const [owner = repo, name = repo] = repo.split("/");
-	const pr = (yield* readJson("api graphql", "gh", [
-		"api",
-		"graphql",
-		"-f",
-		`query=query($owner:String!,$name:String!,$number:Int!){
-        repository(owner:$owner,name:$name){
-          pullRequest(number:$number){
-            comments(last:100){nodes{author{login __typename} body createdAt}}
-            reviews(last:100){nodes{author{login __typename} body submittedAt}}
-            reviewThreads(last:100){nodes{
-              isResolved isOutdated path line
-              comments(first:100){nodes{author{login __typename} body createdAt}}
-            }}
-          }
-        }
-      }`,
-		"-F",
-		`owner=${owner}`,
-		"-F",
-		`name=${name}`,
-		"-F",
-		`number=${number}`
-	], Conversation)).data.repository.pullRequest;
-	const conversation = [...pr.comments.nodes.flatMap((it) => remark(it, it.createdAt)), ...pr.reviews.nodes.flatMap((it) => remark(it, it.submittedAt))].toSorted(byTime);
-	const threads = pr.reviewThreads.nodes.map((it) => ({
-		path: it.path,
-		line: it.line,
-		resolved: it.isResolved,
-		outdated: it.isOutdated,
-		comments: it.comments.nodes.flatMap((comment) => remark(comment, comment.createdAt)).toSorted(byTime)
-	}));
-	return [...conversation.length === 0 ? [] : [{
-		path: null,
-		line: null,
-		resolved: false,
-		outdated: false,
-		comments: conversation
-	}], ...threads];
-});
-//#endregion
-//#region src/cli/exit.ts
 /**
-* The failures a command owes me a sentence for rather than a stack.
+* A line of a block's body, under its heading. A blank line stays blank.
 *
-* 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.
+* On its own it is for a body written a line at a time, under a heading
+* already on the screen, while the command is still finding out what it says.
 */
-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"];
+const indent = (line) => line === "" ? "" : `  ${line}`;
+/** One block: the heading, then the body indented under it. */
+const block = (heading, body) => [heading, ...body.map(indent)];
+const nonEmpty = (lines) => lines.length > 0;
 /**
-* 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.
+* The blocks of one page, a blank line apart. A block that came to nothing
+* leaves no gap where it would have been.
 */
-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. */
-const isAfter = (self, other) => Predicate.isNotNull(self) && (other === null || isLater(self, other));
-/** The later of the two. */
-const later = (self, other) => isAfter(self, other) ? self : other;
-/** Whether the two are the same moment, counting never as the same as never. */
-const isSame = (self, other) => self === null || other === null ? self === other : DateTime.Equivalence(self, other);
-/** The latest of many, or never when there are none. */
-const newest = (moments) => moments.reduce(later, null);
-//#endregion
-//#region src/terms/pr.ts
+const separated = (blocks) => blocks.filter(nonEmpty).flatMap((lines, index) => index === 0 ? lines : ["", ...lines]);
 /**
-* 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.
+* Blocks that follow what is already on the screen - a line written before a
+* session, a prompt or a heartbeat took the terminal - so each of them opens
+* on its blank line, the first as well.
 */
-/** How far GitHub has got towards letting a tracked PR merge. */
-const Mergeability = Schema.Literals([
-	"mergeable",
-	"conflicting",
-	"unknown"
-]);
-/** What the reviewers have decided, or that nobody is required to. */
-const ReviewDecision = Schema.Literals([
-	"approved",
-	"changes-requested",
-	"review-required",
-	"none"
-]);
-/** What CI says about the current head. */
-const ChecksState = Schema.Literals([
-	"green",
-	"red",
-	"pending",
-	"none"
-]);
+const following = (blocks) => blocks.filter(nonEmpty).flatMap((lines) => ["", ...lines]);
+/** A page's lines, printed one to a line. */
+const print = (lines) => Effect.forEach(lines, (line) => Console.log(line), { discard: true });
+/**
+* The line a report on one pull request opens on: which one, at which head,
+* and what happened to it. The head is context, so it is dim.
+*/
+const opener = (paint, repo, number, head, what) => `${repo}#${number}  ${typeof head === "string" ? paint.dim(short(head)) : `${paint.dim(short(head.before))} → ${paint.dim(short(head.after))}`}  ${what}`;
+/** The files a rebase stopped on, under their count, or nothing where none is known. */
+const stoppedOn = (paint, paths) => paths.length === 0 ? [] : block(`It stopped on ${count(paths.length, "file")}:`, paths.map(paint.dim));
+/**
+* Commands I am meant to retype, one to a line, as a block of their own so
+* they stand clear of the prose around them. Cyan is the one colour no state
+* uses, so it says this and nothing else.
+*/
+const retype = (paint, ...commands) => commands.map((command) => indent(paint.cyan(command)));
 //#endregion
-//#region src/domain/bucket.ts
+//#region src/domain/cleanup.ts
+/** The checkouts that stand for a session, named by the session they stand for. */
+const standing$1 = (inventory) => inventory.cuttings.flatMap((cutting) => {
+	const session = sessionOf(cutting.cut);
+	return session === void 0 ? [] : [{
+		...cutting,
+		session
+	}];
+});
+/** The checkouts a review run cut, which no run that ended still needs. */
+const orphaned = (inventory) => inventory.cuttings.filter((cutting) => cutting.cut === "worktrees");
+const sum = (sizes) => ByteSize.bytes(sizes.reduce((total, size) => total + ByteSize.toBigInt(size), BigInt(0)));
+/** What the glossary calls the session a standing checkout was cut for. */
+const sessionName = (session) => session === "fix" ? "fix" : "resolve";
+const reason = (sessions) => sessions.map((it) => `a ${sessionName(it.session)} session stands on ${it.repo}#${it.number}`).join(", ");
 /**
-* Everything the bucket rules are allowed to know about a tracked PR.
+* What a cleanup would take, weighed.
 *
-* It is a schema because a sweep writes it to the state directory and reads it
-* back on the next one: the same facts that decide a bucket are what a quiet PR
-* is recognised by.
+* A clone whose repository has a session standing on it stays, and that is not
+* politeness: a standing worktree keeps its history inside the clone, so a
+* clone removed from under one leaves a directory of files with nothing behind
+* them. The worktrees of that session stay with it; the review run's own go
+* either way, because they belong to a run that has ended.
 */
-const Facts = Schema.Struct({
-	repo: Schema.String,
-	number: Schema.Int,
-	title: Schema.String,
-	url: Schema.String,
-	/** Shown, never acted on unless I ask. */
-	draft: Schema.Boolean,
-	/** The head commit every other fact here is about. */
-	head: Schema.String,
-	mergeable: Mergeability,
-	reviewDecision: ReviewDecision,
-	checks: ChecksState,
-	/** Why the flaky classifier excuses this red CI, or null where it does not. */
-	ciFlaky: Schema.NullOr(Schema.String),
-	/** The head a rebase onto the base conflicted at, or null where none has. */
-	rebaseConflictAt: Schema.NullOr(Schema.String),
-	/** The newest comment from a person who is not me, bots excluded. */
-	newestHumanCommentAt: Schema.NullOr(Schema.DateTimeUtcFromString),
-	myLastCommentAt: Schema.NullOr(Schema.DateTimeUtcFromString),
-	myLastCommitAt: Schema.NullOr(Schema.DateTimeUtcFromString),
-	/** The head a review run has already covered, or null where none has. */
-	reviewRunHead: Schema.NullOr(Schema.String),
-	/** Findings on this head that withhold the stamp, at the bar `stamp.blocks_on` sets. */
-	blockingFindings: Schema.Int
-});
-Schema.Literals([
-	"needs-me",
-	"needs-review-run",
-	"waiting-on-others",
-	"ready"
+const plan = (inventory) => {
+	const sessions = standing$1(inventory);
+	const worktrees = orphaned(inventory);
+	const held = /* @__PURE__ */ new Map();
+	for (const session of sessions) held.set(session.repo, [...held.get(session.repo) ?? [], session]);
+	const clones = inventory.clones.filter((clone) => !held.has(clone.repo));
+	return {
+		clones,
+		worktrees,
+		kept: inventory.clones.flatMap((clone) => {
+			const sessionsHere = held.get(clone.repo);
+			return sessionsHere === void 0 ? [] : [{
+				clone,
+				because: reason(sessionsHere)
+			}];
+		}),
+		size: sum([...clones, ...worktrees].map((it) => it.size))
+	};
+};
+/** What the whole state directory weighs: the clones, the checkouts and the records. */
+const everything$1 = (inventory) => sum([
+	...inventory.clones.map((it) => it.size),
+	...inventory.cuttings.map((it) => it.size),
+	inventory.records.size
 ]);
-/** The buckets in the order I act on them: the top of the table is my next move. */
-const order = [
-	"needs-me",
-	"needs-review-run",
-	"waiting-on-others",
-	"ready"
-];
+/** Whether a plan has anything to do at all. */
+const empty = (it) => it.clones.length === 0 && it.worktrees.length === 0;
+/** A size as a line says it: three digits at most, and the unit the terminal reads. */
+const weight = (size) => ByteSize.format(size, {
+	system: "decimal",
+	precision: 1
+});
+//#endregion
+//#region src/cli/cleanup.ts
+const yesFlag = Flag.Boolean("yes").pipe(Flag.withDefault(false), Flag.withDescription("Do it without asking, for a machine that has no terminal to ask at"));
+/** A path said as the state directory's own, which is the heading it sits under. */
+const inside = (path, state, directory) => path.relative(state, directory);
 /**
-* Why a PR is mine to move when somebody has said something I have not
-* answered.
+* The two blocks a cleanup writes: what it takes and what it leaves.
 *
-* It is named because it is read twice: here, where it puts the PR in Needs me,
-* and by `dw-mc comments`, which says what settles that one branch of the
-* bucket. A sentence matched from the other side of the tool is a rule that
-* breaks on a reword.
+* The weight is on every row because the whole question is whether this is
+* worth doing, and the reason is on every row because a clone and a worktree
+* are taken back for different reasons and both read as "a directory of mine"
+* on the screen.
 */
-const unanswered = "a comment I have not answered";
+const lines$2 = (it, state, path, paint) => {
+	const taking = table([...it.worktrees.map((worktree) => [
+		paint.dim(inside(path, state, worktree.directory)),
+		weight(worktree.size),
+		"a review worktree a run left behind"
+	]), ...it.clones.map((clone) => [
+		paint.dim(inside(path, state, clone.directory)),
+		weight(clone.size),
+		"a bare clone, cloned again on the next run"
+	])]);
+	const staying = table(it.kept.map((kept) => [
+		paint.dim(inside(path, state, kept.clone.directory)),
+		weight(kept.clone.size),
+		kept.because
+	]));
+	return separated([block("Takes back", taking), staying.length === 0 ? [] : block("Stays", staying)]);
+};
 /**
-* Why a PR is mine to move when a review run found something that withholds
-* the stamp.
+* Takes back the disk the tool spent on itself, and nothing that is mine.
 *
-* 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.
+* What it removes is what the tool builds again by itself: the bare clones and
+* the worktrees a review run cut. What it never removes is what I decided - the
+* configuration file - and what I worked in - the worktree of a fix or resolve
+* session, which stands on a branch of the tool's own and holds what I
+* committed there. Forgetting a pull request's records is a different question
+* with a different answer (`dw-mc forget`), and it is not asked here.
+*
+* A clone with a session standing on it stays with the session: a standing
+* worktree keeps its history inside the clone, so a clone taken from under one
+* would leave a directory of files with nothing behind them. The clones that
+* stay are pruned instead, because a worktree directory removed under `git`
+* leaves the clone's record of it behind and the next session cut at that path
+* is refused as already registered.
 */
-const blockedBy = (n) => `${n} blocking finding${n === 1 ? "" : "s"}`;
+const cleanup = Command.make("cleanup", { yes: yesFlag }, Effect.fn("cleanup")(function* ({ yes }) {
+	const path = yield* Path.Path;
+	const paint = yield* Paint;
+	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}.`);
+		return;
+	}
+	yield* print([...lines$2(it, found.directory, path, paint), ""]);
+	if (!yes && !(yield* confirm(`Take back ${weight(it.size)}?`))) {
+		yield* Console.log("Nothing was removed.");
+		return;
+	}
+	yield* Effect.forEach([...it.worktrees, ...it.clones], (taken) => Effect.andThen(discard(taken.directory), tidy(taken.directory, found.directory)));
+	yield* Effect.forEach(it.kept, (kept) => prune(kept.clone.directory));
+	yield* Console.log(`Took back ${weight(it.size)}.`);
+})).pipe(Command.withDescription("Take back the disk the tool spent on clones and review worktrees"));
+//#endregion
+//#region src/adapters/gh.ts
+/** `gh` is on the machine but would not run. */
+var GhUnavailable = class extends Schema.TaggedError()("GhUnavailable", { detail: Schema.String }) {
+	get message() {
+		return `gh could not be run: ${this.detail}\nInstall it from https://cli.github.com, then run 'gh auth login'.`;
+	}
+};
+/** `gh` runs but is not logged in, so every read of GitHub would fail. */
+var GhUnauthenticated = class extends Schema.TaggedError()("GhUnauthenticated", { detail: Schema.String }) {
+	get message() {
+		return `gh is not authenticated. Run 'gh auth login'.\n${this.detail}`;
+	}
+};
+/** The working directory is not inside a repository `gh` can name. */
+var NoRepository = class extends Schema.TaggedError()("NoRepository", { detail: Schema.String }) {
+	get message() {
+		return `This directory is not a GitHub repository dw-mc can register.\n${this.detail}`;
+	}
+};
+/** `gh` answered, in a shape this version of dw-mc does not know. */
+var GhUnreadable = class extends Schema.TaggedError()("GhUnreadable", {
+	command: Schema.String,
+	reason: Schema.String
+}) {
+	get message() {
+		return `gh ${this.command} answered with something dw-mc cannot read: ${this.reason}`;
+	}
+};
+/** What a `gh` that would not even start comes to. */
+const unavailable = (error) => new GhUnavailable({ detail: error.reason._tag === "NotFound" ? "it is not installed" : error.message });
 /**
-* 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.
+* Stops unless `gh` is installed and logged in.
+*
+* Every read of GitHub goes through `gh` as me, so a missing or logged-out `gh`
+* is worth saying once, up front, rather than as an empty table later.
 */
-const needsMe = (facts) => {
-	if (facts.mergeable === "conflicting") return "merge conflict";
-	if (facts.rebaseConflictAt === facts.head) return "a rebase onto the base conflicted";
-	if (facts.checks === "red" && facts.ciFlaky === null) return "CI is red";
-	if (facts.reviewDecision === "changes-requested") return "changes requested";
-	if (facts.blockingFindings > 0) return blockedBy(facts.blockingFindings);
-	if (isAfter(facts.newestHumanCommentAt, later(facts.myLastCommentAt, facts.myLastCommitAt))) return unanswered;
-	return null;
+const requireAuth = capture("gh", ["auth", "status"]).pipe(Effect.asVoid, Effect.catchTags({
+	PlatformError: (error) => Effect.fail(unavailable(error)),
+	CommandFailed: (error) => Effect.fail(new GhUnauthenticated({ detail: error.stderr }))
+}), Effect.withSpan("gh.requireAuth"));
+const RepoView = Schema.fromJsonString(Schema.Struct({ nameWithOwner: Schema.String }));
+/** The `owner/repo` of the repository the working directory is in. */
+const currentRepo = Effect.gen(function* () {
+	const json = yield* capture("gh", [
+		"repo",
+		"view",
+		"--json",
+		"nameWithOwner"
+	]).pipe(Effect.catchTags({
+		PlatformError: (error) => Effect.fail(unavailable(error)),
+		CommandFailed: (error) => Effect.fail(new NoRepository({ detail: error.stderr }))
+	}));
+	return (yield* Schema.decodeEffect(RepoView)(json).pipe(Effect.mapError((error) => new GhUnreadable({
+		command: "repo view",
+		reason: error.message
+	})))).nameWithOwner;
+}).pipe(Effect.withSpan("gh.currentRepo"));
+/** A call to GitHub that `gh` itself refused, whether it was reading or writing. */
+var GhReadFailed = class extends Schema.TaggedError()("GhReadFailed", {
+	command: Schema.String,
+	detail: Schema.String
+}) {
+	get message() {
+		return `gh ${this.command} failed: ${this.detail}`;
+	}
 };
+/** One `gh` read, decoded, with every way it can go wrong in our words. */
+const readJson = (label, command, args, schema) => capture(command, args).pipe(Effect.catchTags({
+	PlatformError: (error) => Effect.fail(unavailable(error)),
+	CommandFailed: (error) => Effect.fail(new GhReadFailed({
+		command: label,
+		detail: error.stderr
+	}))
+}), Effect.flatMap((json) => Schema.decodeEffect(schema)(json).pipe(Effect.mapError((error) => new GhUnreadable({
+	command: label,
+	reason: error.message
+})))), Effect.withSpan(`gh.${label}`));
+/** The login `gh` is authenticated as: the "me" every read is scoped to. */
+const viewer = readJson("api user", "gh", ["api", "user"], Schema.fromJsonString(Schema.Struct({ login: Schema.String }))).pipe(Effect.map((user) => user.login));
+const SearchResults = Schema.fromJsonString(Schema.Array(Schema.Struct({
+	number: Schema.Int,
+	repository: Schema.Struct({ nameWithOwner: Schema.String })
+})));
 /**
-* What is actually true of a PR nothing is waiting on.
+* The open pull requests I authored in `repo`.
 *
-* Ready is reached by having no reason not to be, so the reason says only what
-* holds: a repository that requires no reviewer produces no approval, and a
-* pull request with no CI at all is not green.
+* One search per repository rather than one for all of them: a repository `gh`
+* cannot read then costs me that repository's rows and not the whole table.
+*/
+const searchPrs = Effect.fnUntraced(function* (repo) {
+	return (yield* readJson("search prs", "gh", [
+		"search",
+		"prs",
+		"--author=@me",
+		"--state=open",
+		"--repo",
+		repo,
+		"--limit",
+		"100",
+		"--json",
+		"number,repository"
+	], SearchResults)).map((it) => ({
+		repo: it.repository.nameWithOwner,
+		number: it.number
+	}));
+});
+/**
+* One entry of a PR's status check rollup.
 *
-* A red CI the classifier excused is said out loud, because GitHub does not
-* excuse it: the check is still red, and Ready is what `dw-mc merge` reads.
+* A rollup mixes two shapes: a `CheckRun` reports a `status` and a `conclusion`,
+* a `StatusContext` an overall `state`. Every field is optional because which
+* ones arrive depends on which shape it is.
 */
-const readyReason = (facts) => {
-	const held = [
-		facts.reviewDecision === "approved" ? "approved" : null,
-		facts.checks === "green" ? "green" : null,
-		facts.mergeable === "mergeable" ? "mergeable" : null
-	].filter((it) => it !== null);
-	const standing = held.length === 0 ? "nothing left to wait on" : held.join(", ");
-	return facts.checks === "red" && facts.ciFlaky !== null ? `${standing} (red CI called flaky: ${facts.ciFlaky})` : standing;
-};
+const CheckEntry = Schema.Struct({
+	name: Schema.optionalKey(Schema.String),
+	context: Schema.optionalKey(Schema.String),
+	status: Schema.optionalKey(Schema.String),
+	conclusion: Schema.optionalKey(Schema.String),
+	state: Schema.optionalKey(Schema.String),
+	/** The workflow the check runs in. A commit status belongs to no workflow. */
+	workflowName: Schema.optionalKey(Schema.String),
+	/** Where the check reports, which is the only place its job id appears. */
+	detailsUrl: Schema.optionalKey(Schema.String)
+});
+const PrView = Schema.fromJsonString(Schema.Struct({
+	number: Schema.Int,
+	title: Schema.String,
+	url: Schema.String,
+	isDraft: Schema.Boolean,
+	headRefOid: Schema.String,
+	headRefName: Schema.String,
+	baseRefName: Schema.String,
+	/** Who opened it, which is what says whether its branch is mine to push to. */
+	author: Schema.NullOr(Schema.Struct({ login: Schema.String })),
+	/** Whether the head branch lives in a fork rather than in this repository. */
+	isCrossRepository: Schema.Boolean,
+	mergeable: Schema.String,
+	reviewDecision: Schema.String,
+	statusCheckRollup: Schema.NullOr(Schema.Array(CheckEntry))
+}));
 /**
-* The bucket a tracked PR sits in, and the reason for it.
+* The fields one `gh pr view` asks for, named so a test can spell the vector it
+* expects without copying the list and watching it drift.
+*/
+const viewFields = "number,title,url,isDraft,headRefOid,headRefName,baseRefName,author,isCrossRepository,mergeable,reviewDecision,statusCheckRollup";
+/**
+* Everything about one pull request that arrives without paging through it:
+* its head, what GitHub thinks of merging it, and where CI got to.
+*/
+const prView = Effect.fnUntraced(function* (repo, number) {
+	return yield* readJson("pr view", "gh", [
+		"pr",
+		"view",
+		String(number),
+		"--repo",
+		repo,
+		"--json",
+		viewFields
+	], PrView);
+});
+const OpenPrs = Schema.fromJsonString(Schema.Array(Schema.Struct({
+	number: Schema.Int,
+	headRefName: Schema.String,
+	baseRefName: Schema.String
+})));
+/**
+* Every open pull request on a repository, by branch.
 *
-* This is the single place the bucket rules exist. Every tracked PR lands in
-* exactly one bucket, so the rules are tried in priority order and the first
-* that claims the PR wins: a PR that both needs a review run and has changes
-* requested is mine to move, not the review's.
+* Everyone's and not only mine: a stack is recognised from branches built on
+* branches, and a pull request of mine can sit on one somebody else opened.
 *
-* Ready does not insist on an approval, because a repository that requires no
-* reviewer never produces one. What it insists on is that nobody else has been
-* asked and is yet to answer.
+* The page is deep because a pull request this misses is one that looks like it
+* is in no stack, and a stack the tool cannot see is one it could drive.
 */
-const place = (facts) => {
-	const mine = needsMe(facts);
-	if (mine !== null) return {
-		bucket: "needs-me",
-		reason: mine
-	};
-	if (facts.reviewRunHead !== facts.head) return {
-		bucket: "needs-review-run",
-		reason: "no review run on this head"
-	};
-	if (facts.reviewDecision === "review-required") return {
-		bucket: "waiting-on-others",
-		reason: "a review from someone else"
-	};
-	if (facts.checks === "pending") return {
-		bucket: "waiting-on-others",
-		reason: "CI is still running"
-	};
-	return {
-		bucket: "ready",
-		reason: readyReason(facts)
-	};
-};
-const group = (facts) => {
-	const placed = facts.map((it) => ({
-		facts: it,
-		placement: place(it)
-	})).toSorted((a, b) => a.facts.repo.localeCompare(b.facts.repo) || a.facts.number - b.facts.number);
-	return order.map((bucket) => ({
-		bucket,
-		placed: placed.filter((it) => it.placement.bucket === bucket)
-	})).filter((bucket) => bucket.placed.length > 0);
-};
-//#endregion
-//#region src/domain/reference.ts
-/** `owner/name#12`, or `12` on its own. */
-const spelled = /^(?:([^\s/]+\/[^\s/]+)#)?(\d+)$/;
+const openPrs = Effect.fnUntraced(function* (repo) {
+	return (yield* readJson("pr list", "gh", [
+		"pr",
+		"list",
+		"--repo",
+		repo,
+		"--state",
+		"open",
+		"--limit",
+		"500",
+		"--json",
+		"number,headRefName,baseRefName"
+	], OpenPrs)).map((it) => ({
+		number: it.number,
+		head: it.headRefName,
+		base: it.baseRefName
+	}));
+});
+const Comments = Schema.fromJsonString(Schema.Array(Schema.Struct({
+	created_at: Schema.DateTimeUtcFromString,
+	user: Schema.NullOr(Schema.Struct({
+		login: Schema.String,
+		type: Schema.String
+	}))
+})));
+const comments$1 = (label, path) => readJson(label, "gh", ["api", path], Comments).pipe(Effect.map((all) => all.flatMap((comment) => comment.user === null ? [] : [{
+	login: comment.user.login,
+	bot: comment.user.type === "Bot",
+	at: comment.created_at
+}])));
+/**
+* Every comment on a pull request: the ones on the conversation and the ones
+* left on the diff.
+*
+* REST is what says whether an author is a person or an app - `gh pr view`
+* reports a bot's login with no sign that it is one - and the bucket rules turn
+* on exactly that. Verified by running both: the endpoints ignore `direction`,
+* so a page is asked for at its maximum and the newest comment is picked out of
+* it rather than asked for first.
+*/
+const prComments = Effect.fnUntraced(function* (repo, number) {
+	const page = "per_page=100";
+	const [conversation, onDiff] = yield* Effect.all([comments$1("api issue comments", `repos/${repo}/issues/${number}/comments?${page}`), comments$1("api review comments", `repos/${repo}/pulls/${number}/comments?${page}`)], { concurrency: 2 });
+	return [...conversation, ...onDiff];
+});
+const Reviews = Schema.fromJsonString(Schema.Array(Schema.Struct({
+	submitted_at: Schema.DateTimeUtcFromString,
+	body: Schema.String,
+	user: Schema.NullOr(Schema.Struct({
+		login: Schema.String,
+		type: Schema.String
+	}))
+})));
+/**
+* The reviews on a pull request that said something, as comments.
+*
+* A review carries a body of its own, which is where a reviewer writes the
+* sentence that is not attached to any line. An empty body is a verdict and
+* nothing more, and the verdict arrives with the PR as `reviewDecision`.
+*/
+const prReviews = Effect.fnUntraced(function* (repo, number) {
+	return (yield* readJson("api reviews", "gh", ["api", `repos/${repo}/pulls/${number}/reviews?per_page=100`], Reviews)).flatMap((review) => review.user === null || review.body.trim() === "" ? [] : [{
+		login: review.user.login,
+		bot: review.user.type === "Bot",
+		at: review.submitted_at
+	}]);
+});
+const Compare = Schema.fromJsonString(Schema.Struct({ files: Schema.optionalKey(Schema.Array(Schema.Struct({ filename: Schema.String }))) }));
 /**
-* A segment of nothing but dots, which no repository is called.
+* The repository paths that changed between two commits.
 *
-* The repository names a directory under the state directory before it names
-* anything else, so `../x` would be a way out of it.
+* GitHub compares them rather than git, because the commit a run was recorded
+* against is not one the tool's own clone is promised to still have: a force
+* push moves the pull request's ref and the old commit goes with it, where
+* GitHub keeps both sides of the comparison. A comparison of a commit with
+* itself reports no files at all, and so does one of two commits with nothing
+* between them, which is why the key is optional.
+*
+* `base...head` measures from where the two commits last agreed, so two heads
+* on one branch report what was pushed between them, and a branch rebased since
+* reports its whole diff. The second is the right answer for a caller deciding
+* whether the code has moved: after a rebase it has, all of it.
 */
-const onlyDots = /^\.+$/;
+const comparedFiles = Effect.fnUntraced(function* (repo, base, head) {
+	return ((yield* readJson("api compare", "gh", ["api", `repos/${repo}/compare/${base}...${head}`], Compare)).files ?? []).map((file) => file.filename);
+});
+const Commits = Schema.fromJsonString(Schema.Struct({ commits: Schema.Array(Schema.Struct({
+	committedDate: Schema.DateTimeUtcFromString,
+	authors: Schema.Array(Schema.Struct({ login: Schema.NullOr(Schema.String) }))
+})) }));
 /**
-* The pull request a reference names.
+* The commits on a pull request.
 *
-* A reference that spells its repository out is taken as it is, registered or
-* not: reviewing someone else's pull request is a thing to ask for, and the
-* settings a repository nothing registered gets are the global defaults.
+* This is the expensive read of the three: `gh` returns every commit with its
+* whole message, so a sweep only asks for it when something about the PR has
+* actually moved.
 */
-const resolve$1 = (text, registered) => {
-	const found = spelled.exec(text);
-	const number = found?.[2];
-	if (number === void 0) return {
-		_tag: "unreadable",
-		text
-	};
-	const spelledRepo = found?.[1];
-	if (spelledRepo !== void 0 && spelledRepo.split("/").some((segment) => onlyDots.test(segment))) return {
-		_tag: "unreadable",
-		text
-	};
-	const repo = spelledRepo ?? (registered.length === 1 ? registered[0] : void 0);
-	if (repo === void 0) return {
-		_tag: "ambiguous",
-		repos: registered
-	};
-	return {
-		_tag: "resolved",
+const prCommits = Effect.fnUntraced(function* (repo, number) {
+	return (yield* readJson("pr view commits", "gh", [
+		"pr",
+		"view",
+		String(number),
+		"--repo",
 		repo,
-		number: Number(number)
-	};
-};
-//#endregion
-//#region src/domain/findings.ts
-/** Whether a review run found anything at all. */
-const Verdict = Schema.Literals(["clean", "findings"]);
+		"--json",
+		"commits"
+	], Commits)).commits.map((commit) => ({
+		logins: commit.authors.flatMap((author) => author.login === null ? [] : [author.login]),
+		at: commit.committedDate
+	}));
+});
 /**
-* Every severity word a review may answer with.
+* What `gh` says about merging, in our words. Anything else is `unknown`:
+* GitHub answers that too, for a PR whose mergeability it is still computing.
 *
-* 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.
+* `Match.withReturnType` comes first in the pipeline or the return type is not
+* enforced: a handler's literal widens to `string` on its own.
 */
-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"
-};
-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
-});
+const mergeabilityOf = (raw) => Match.value(raw).pipe(Match.withReturnType(), Match.when("MERGEABLE", () => "mergeable"), Match.when("CONFLICTING", () => "conflicting"), Match.orElse(() => "unknown"));
 /**
-* What a review run found: the shape the tool keeps, and the one a fix session
-* is later handed.
+* What `gh` says the reviewers decided, in our words. A repository that requires
+* no reviewer reports an empty string, which is `none` rather than pending.
 */
-const Findings = Schema.Struct({
-	verdict: Verdict,
-	findings: Schema.Array(Finding)
-});
+const reviewDecisionOf = (raw) => Match.value(raw).pipe(Match.withReturnType(), Match.when("APPROVED", () => "approved"), Match.when("CHANGES_REQUESTED", () => "changes-requested"), Match.when("REVIEW_REQUIRED", () => "review-required"), Match.orElse(() => "none"));
 /**
-* The same findings as a runner may spell them, which is what the second turn's
-* output is read with.
+* Squash-merges a pull request and deletes the branch it stood on.
 *
-* 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.
+* The one write the tool makes that no reflog of mine undoes, and the whole of
+* it: a squash, because that is how the repository lands a pull request and the
+* squash subject is its title, and the branch, because squashing kills it
+* anyway. No `--auto`, which would hand GitHub a merge to make at a head
+* nothing here has read (ADR 0008).
+*
+* Whether this pull request is one to merge is decided before we get here, and
+* `gh` still has the last word: a branch protection this machine cannot see
+* comes back as a failure and is printed as one.
 */
-const Reported = Schema.Struct({
-	verdict: Verdict,
-	findings: Schema.Array(Schema.Struct({
-		...shared,
-		severity: Weighed
-	}))
+const mergePr = Effect.fnUntraced(function* (repo, number) {
+	yield* capture("gh", [
+		"pr",
+		"merge",
+		String(number),
+		"--repo",
+		repo,
+		"--squash",
+		"--delete-branch"
+	]).pipe(Effect.catchTags({
+		PlatformError: (error) => Effect.fail(unavailable(error)),
+		CommandFailed: (error) => Effect.fail(new GhReadFailed({
+			command: "pr merge",
+			detail: error.stderr
+		}))
+	}));
+});
+//#endregion
+//#region src/adapters/conversation.ts
+const Actor = Schema.NullOr(Schema.Struct({
+	login: Schema.String,
+	__typename: Schema.String
+}));
+const Said$1 = Schema.Struct({
+	author: Actor,
+	body: Schema.String,
+	createdAt: Schema.DateTimeUtcFromString
 });
+const Conversation = Schema.fromJsonString(Schema.Struct({ data: Schema.Struct({ repository: Schema.Struct({ pullRequest: Schema.Struct({
+	comments: Schema.Struct({ nodes: Schema.Array(Said$1) }),
+	reviews: Schema.Struct({ nodes: Schema.Array(Schema.Struct({
+		author: Actor,
+		body: Schema.String,
+		submittedAt: Schema.NullOr(Schema.DateTimeUtcFromString)
+	})) }),
+	reviewThreads: Schema.Struct({ nodes: Schema.Array(Schema.Struct({
+		isResolved: Schema.Boolean,
+		isOutdated: Schema.Boolean,
+		path: Schema.NullOr(Schema.String),
+		line: Schema.NullOr(Schema.Int),
+		comments: Schema.Struct({ nodes: Schema.Array(Said$1) })
+	})) })
+}) }) }) }));
+const remark = (said, at) => said.author === null || at === null || said.body.trim() === "" ? [] : [{
+	login: said.author.login,
+	bot: said.author.__typename === "Bot",
+	at,
+	body: said.body.trim()
+}];
+const byTime = (self, other) => DateTime.Order(self.at, other.at);
 /**
-* The schema every runner must satisfy, as the JSON Schema a runner is handed.
+* A pull request's whole conversation: the comments on it, the bodies of the
+* reviews, and every thread on the diff with whether it is settled.
 *
-* 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.
+* GraphQL rather than the two REST endpoints a sweep reads, because resolution
+* is not in REST at all: a review comment's payload carries `body`, `path`,
+* `line`, `diff_hunk` and `side`, and nothing saying whether somebody closed
+* the thread it belongs to. A thread that was settled a week ago is not
+* something to answer, so the state that says so has to arrive with it.
+*
+* The pull request's own comments and the reviews' bodies come back as one
+* strand under no path, in the order they were written: they are one
+* conversation as it happened, and which endpoint each line came from is an
+* accident of GitHub's model rather than anything to read.
+*
+* `__typename` is what says a bot is a bot, the way `user.type` does in REST.
 */
-const jsonSchema = JSON.stringify(SchemaRepresentation.toJsonSchemaDocument(SchemaRepresentation.toRepresentation(Findings.ast)).schema);
+const prConversation = Effect.fnUntraced(function* (repo, number) {
+	const [owner = repo, name = repo] = repo.split("/");
+	const pr = (yield* readJson("api graphql", "gh", [
+		"api",
+		"graphql",
+		"-f",
+		`query=query($owner:String!,$name:String!,$number:Int!){
+        repository(owner:$owner,name:$name){
+          pullRequest(number:$number){
+            comments(last:100){nodes{author{login __typename} body createdAt}}
+            reviews(last:100){nodes{author{login __typename} body submittedAt}}
+            reviewThreads(last:100){nodes{
+              isResolved isOutdated path line
+              comments(first:100){nodes{author{login __typename} body createdAt}}
+            }}
+          }
+        }
+      }`,
+		"-F",
+		`owner=${owner}`,
+		"-F",
+		`name=${name}`,
+		"-F",
+		`number=${number}`
+	], Conversation)).data.repository.pullRequest;
+	const conversation = [...pr.comments.nodes.flatMap((it) => remark(it, it.createdAt)), ...pr.reviews.nodes.flatMap((it) => remark(it, it.submittedAt))].toSorted(byTime);
+	const threads = pr.reviewThreads.nodes.map((it) => ({
+		path: it.path,
+		line: it.line,
+		resolved: it.isResolved,
+		outdated: it.isOutdated,
+		comments: it.comments.nodes.flatMap((comment) => remark(comment, comment.createdAt)).toSorted(byTime)
+	}));
+	return [...conversation.length === 0 ? [] : [{
+		path: null,
+		line: null,
+		resolved: false,
+		outdated: false,
+		comments: conversation
+	}], ...threads];
+});
+//#endregion
+//#region src/cli/exit.ts
 /**
-* The findings as the Markdown a report is written in.
+* The failures a command owes me a sentence for rather than a stack.
 *
-* 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.
+* 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 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 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 findings that withhold the stamp: everything at `blocksOn` or above it.
+* The same, for a command that cuts a standing worktree and opens an agent
+* session in it.
 *
-* `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.
+* `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 blocking = (findings, blocksOn) => findings.filter((finding) => rank[finding.severity] >= rank[blocksOn]);
+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/review.ts
+//#region src/domain/moment.ts
+const isLater = Order.isGreaterThan(DateTime.Order);
+/** Whether `self` happened after `other`, counting never as before anything. */
+const isAfter = (self, other) => Predicate.isNotNull(self) && (other === null || isLater(self, other));
+/** The later of the two. */
+const later = (self, other) => isAfter(self, other) ? self : other;
+/** Whether the two are the same moment, counting never as the same as never. */
+const isSame = (self, other) => self === null || other === null ? self === other : DateTime.Equivalence(self, other);
+/** The latest of many, or never when there are none. */
+const newest = (moments) => moments.reduce(later, null);
+//#endregion
+//#region src/terms/pr.ts
 /**
-* What a review run came to, which is what its second turn reported.
+* What GitHub says about a pull request, in this tool's words.
 *
-* 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.
+* 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.
 */
-const Outcome = Schema.Union([Schema.TaggedStruct("reported", {
-	verdict: Verdict,
-	findings: Schema.Array(Finding)
-}), Schema.TaggedStruct("failed", { detail: Schema.String })]);
+/** How far GitHub has got towards letting a tracked PR merge. */
+const Mergeability = Schema.Literals([
+	"mergeable",
+	"conflicting",
+	"unknown"
+]);
+/** What the reviewers have decided, or that nobody is required to. */
+const ReviewDecision = Schema.Literals([
+	"approved",
+	"changes-requested",
+	"review-required",
+	"none"
+]);
+/** What CI says about the current head. */
+const ChecksState = Schema.Literals([
+	"green",
+	"red",
+	"pending",
+	"none"
+]);
+//#endregion
+//#region src/domain/bucket.ts
 /**
-* One review run against a tracked PR at a specific head commit.
+* Everything the bucket rules are allowed to know about a tracked PR.
 *
-* 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.
+* It is a schema because a sweep writes it to the state directory and reads it
+* back on the next one: the same facts that decide a bucket are what a quiet PR
+* is recognised by.
 */
-const ReviewRun = Schema.Struct({
+const Facts = Schema.Struct({
 	repo: Schema.String,
 	number: Schema.Int,
-	/** The head the run covers. A run never vouches for code it did not see. */
+	title: Schema.String,
+	url: Schema.String,
+	/** Shown, never acted on unless I ask. */
+	draft: Schema.Boolean,
+	/** The head commit every other fact here is about. */
 	head: Schema.String,
-	/**
-	* 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);
-/**
-* 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) => `${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`;
-/**
-* Which head a pull request was last reviewed at: an index beside `runKey` and
-* `reportKey` rather than a thing the glossary names.
-*
-* 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 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 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 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);
+	mergeable: Mergeability,
+	reviewDecision: ReviewDecision,
+	checks: ChecksState,
+	/** Why the flaky classifier excuses this red CI, or null where it does not. */
+	ciFlaky: Schema.NullOr(Schema.String),
+	/** The head a rebase onto the base conflicted at, or null where none has. */
+	rebaseConflictAt: Schema.NullOr(Schema.String),
+	/** The newest comment from a person who is not me, bots excluded. */
+	newestHumanCommentAt: Schema.NullOr(Schema.DateTimeUtcFromString),
+	myLastCommentAt: Schema.NullOr(Schema.DateTimeUtcFromString),
+	myLastCommitAt: Schema.NullOr(Schema.DateTimeUtcFromString),
+	/** The newest comment my acknowledgement covers, or null where I have made none. */
+	acknowledgedAt: Schema.NullOr(Schema.DateTimeUtcFromString),
+	/** The head a review run has already covered, or null where none has. */
+	reviewRunHead: Schema.NullOr(Schema.String),
+	/** Findings on this head that withhold the stamp, at the bar `stamp.blocks_on` sets. */
+	blockingFindings: Schema.Int
 });
+/** The one place a tracked PR sits at a time, named for what it waits on. */
+const Bucket = Schema.Literals([
+	"needs-me",
+	"needs-review-run",
+	"waiting-on-others",
+	"ready"
+]);
+/** The buckets in the order I act on them: the top of the table is my next move. */
+const order = [
+	"needs-me",
+	"needs-review-run",
+	"waiting-on-others",
+	"ready"
+];
 /**
-* What a run reported, or null where it reported nothing at all.
+* Why a PR is mine to move when somebody has said something I have not
+* answered.
 *
-* 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.
+* It is named because it is read twice: here, where it puts the PR in Needs me,
+* and by `dw-mc comments`, which says what settles that one branch of the
+* bucket. A sentence matched from the other side of the tool is a rule that
+* breaks on a reword.
 */
-const reportedBy = (run) => run.outcome._tag === "reported" ? {
-	verdict: run.outcome.verdict,
-	findings: run.outcome.findings
-} : null;
+const unanswered = "a comment I have not answered";
 /**
-* Why a run reported nothing, or null where it reported.
+* Why a PR is mine to move when a review run found something that withholds
+* the stamp.
 *
-* 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.
+* 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 detailOf = (run) => run.outcome._tag === "failed" ? run.outcome.detail : null;
+const blockedBy = (n) => `${n} blocking finding${n === 1 ? "" : "s"}`;
 /**
-* Whether the files changed since the last run are worth paying for another.
+* How far my answer to the conversation reaches: the latest of my last comment,
+* my last commit and my acknowledgement.
 *
-* 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.
+* A comment is answered by a reply, by a push, or by my word that nothing in it
+* was mine to answer. It is named because it is read twice: here, where a newer
+* comment puts the PR in Needs me, and by `dw-mc comments`, which shows exactly
+* the comments newer than it.
 */
-const worthRerunning = (changed, docsOnly) => changed.some((file) => !docsOnly.some((glob) => matchesGlob(file, glob)));
+const answeredAt = (facts) => later(later(facts.myLastCommentAt, facts.myLastCommitAt), facts.acknowledgedAt);
 /**
-* The re-run rule: the head this run is skipped against, or null where it runs.
-*
-* 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.
+* The first of the rules that makes a PR mine to move, or null when none
+* does. The order is the order I would fix them in: a conflict makes every
+* other signal on the PR stale, and a red build is worth more than a comment.
 */
-const 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 needsMe = (facts) => {
+	if (facts.mergeable === "conflicting") return "merge conflict";
+	if (facts.rebaseConflictAt === facts.head) return "a rebase onto the base conflicted";
+	if (facts.checks === "red" && facts.ciFlaky === null) return "CI is red";
+	if (facts.reviewDecision === "changes-requested") return "changes requested";
+	if (facts.blockingFindings > 0) return blockedBy(facts.blockingFindings);
+	if (isAfter(facts.newestHumanCommentAt, answeredAt(facts))) return unanswered;
+	return null;
 };
-/** What a run was opened on, as the report says it. */
-const askedOf$2 = (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.
+* What is actually true of a PR nothing is waiting on.
+*
+* Ready is reached by having no reason not to be, so the reason says only what
+* holds: a repository that requires no reviewer produces no approval, and a
+* pull request with no CI at all is not green.
 *
-* 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.
+* A red CI the classifier excused is said out loud, because GitHub does not
+* excuse it: the check is still red, and Ready is what `dw-mc merge` reads.
 */
-const reportDocument = (run, title, prose) => [
-	`# ${run.repo}#${run.number} ${title}`,
-	"",
-	`- head: ${run.head}`,
-	`- run: ${askedOf$2(run)}`,
-	`- ran: ${DateTime.formatIso(run.ranAt)}`,
-	"",
-	prose.trim(),
-	""
-].join("\n");
+const readyReason = (facts) => {
+	const held = [
+		facts.reviewDecision === "approved" ? "approved" : null,
+		facts.checks === "green" ? "green" : null,
+		facts.mergeable === "mergeable" ? "mergeable" : null
+	].filter((it) => it !== null);
+	const standing = held.length === 0 ? "nothing left to wait on" : held.join(", ");
+	return facts.checks === "red" && facts.ciFlaky !== null ? `${standing} (red CI called flaky: ${facts.ciFlaky})` : standing;
+};
 /**
-* Whether `head` has the review it needs.
+* The bucket a tracked PR sits in, and the reason for it.
 *
-* 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.
+* This is the single place the bucket rules exist. Every tracked PR lands in
+* exactly one bucket, so the rules are tried in priority order and the first
+* that claims the PR wins: a PR that both needs a review run and has changes
+* requested is mine to move, not the review's.
+*
+* Ready does not insist on an approval, because a repository that requires no
+* reviewer never produces one. What it insists on is that nobody else has been
+* asked and is yet to answer.
 */
-const 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);
+const place = (facts) => {
+	const mine = needsMe(facts);
+	if (mine !== null) return {
+		bucket: "needs-me",
+		reason: mine
+	};
+	if (facts.reviewRunHead !== facts.head) return {
+		bucket: "needs-review-run",
+		reason: "no review run on this head"
+	};
+	if (facts.reviewDecision === "review-required") return {
+		bucket: "waiting-on-others",
+		reason: "a review from someone else"
+	};
+	if (facts.checks === "pending") return {
+		bucket: "waiting-on-others",
+		reason: "CI is still running"
+	};
+	return {
+		bucket: "ready",
+		reason: readyReason(facts)
+	};
+};
+const group = (facts) => {
+	const placed = facts.map((it) => ({
+		facts: it,
+		placement: place(it)
+	})).toSorted((a, b) => a.facts.repo.localeCompare(b.facts.repo) || a.facts.number - b.facts.number);
+	return order.map((bucket) => ({
+		bucket,
+		placed: placed.filter((it) => it.placement.bucket === bucket)
+	})).filter((bucket) => bucket.placed.length > 0);
 };
+//#endregion
+//#region src/domain/reference.ts
+/** `owner/name#12`, or `12` on its own. */
+const spelled = /^(?:([^\s/]+\/[^\s/]+)#)?(\d+)$/;
 /**
-* What the review runs on `head` say about it, for the stamp to rest on.
+* A segment of nothing but dots, which no repository is called.
 *
-* 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.
+* The repository names a directory under the state directory before it names
+* anything else, so `../x` would be a way out of it.
+*/
+const onlyDots = /^\.+$/;
+/**
+* The pull request a reference names.
 *
-* 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.
+* A reference that spells its repository out is taken as it is, registered or
+* not: reviewing someone else's pull request is a thing to ask for, and the
+* settings a repository nothing registered gets are the global defaults.
 */
-const reviewedAt = Effect.fn("review.reviewedAt")(function* (repo, number, head, blocksOn) {
-	const run = Option.getOrNull(yield* runAt(repo, number, head));
+const resolve$1 = (text, registered) => {
+	const found = spelled.exec(text);
+	const number = found?.[2];
+	if (number === void 0) return {
+		_tag: "unreadable",
+		text
+	};
+	const spelledRepo = found?.[1];
+	if (spelledRepo !== void 0 && spelledRepo.split("/").some((segment) => onlyDots.test(segment))) return {
+		_tag: "unreadable",
+		text
+	};
+	const repo = spelledRepo ?? (registered.length === 1 ? registered[0] : void 0);
+	if (repo === void 0) return {
+		_tag: "ambiguous",
+		repos: registered
+	};
 	return {
-		reviewRunHead: reviewedBy(run) ? head : null,
-		blockingFindings: blockingIn(run, blocksOn).length
+		_tag: "resolved",
+		repo,
+		number: Number(number)
 	};
-});
+};
 //#endregion
 //#region src/cli/pr.ts
 /** The pull request a command acts on, named the way I actually type it. */
@@ -2725,6 +2833,20 @@ const marker = {
 	"waiting-on-others": "○",
 	ready: "◆"
 };
+/**
+* What sits in front of a row: `+` for a pull request never shown, `*` for one
+* that moved since it was last shown, and a blank for one that did neither.
+*
+* It is one character from the part of Unicode every font has, for the reason
+* the marker is, and it is not coloured: the bucket is what the colour says.
+*/
+const gutter = {
+	new: "+",
+	moved: "*",
+	still: " "
+};
+/** How a row names its pull request. */
+const reference = (facts) => `${facts.repo}#${facts.number}`;
 /** 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,
@@ -2737,6 +2859,8 @@ const rule = " │ ";
 /**
 * One row: which pull request, what it is, and what it waits on.
 *
+* In front of it all is the gutter, which says what moved since I last looked.
+*
 * 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.
@@ -2754,25 +2878,51 @@ const rule = " │ ";
 * 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 cells = (placed, stamped, since, 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("✓")}` : ""}`;
+	const pr = `${named ? reference(facts) : paint.link(reference(facts), facts.url)}${facts.draft ? paint.dim(" (draft)") : ""}${stamped ? ` ${paint.green("✓")}` : ""}`;
+	const front = gutter[since._tag];
 	return named ? [
-		say(`${marker[bucket]} ${heading[bucket]}`),
+		`${front} ${say(`${marker[bucket]} ${heading[bucket]}`)}`,
 		pr,
 		truncate(facts.title, room),
 		placed.placement.reason
 	] : [
-		`${say(marker[bucket])} ${pr}`,
+		`${front} ${say(marker[bucket])} ${pr}`,
 		paint.dim(truncate(facts.title, room)),
 		say(placed.placement.reason)
 	];
 };
 //#endregion
+//#region src/domain/acknowledgement.ts
+/**
+* My word that I have read a pull request's conversation as far as one comment,
+* and that nothing in it is mine to answer.
+*
+* The comment's moment is the whole record, and no head is: everything else the
+* tool records is about code and lapses when the head changes, and this one is
+* about a conversation. A push is already counted as my answer to a comment, so
+* tying this to a head would only bring back a comment the push had nothing to
+* do with.
+*/
+const Acknowledgement = Schema.Struct({ at: Schema.DateTimeUtcFromString });
+/** The newest comment I have acknowledged on a pull request, or null where I have acknowledged none. */
+const acknowledgedAt = Effect.fn("acknowledgement.acknowledgedAt")(function* (repo, number) {
+	const store = yield* storeFor("acknowledgements", Acknowledgement);
+	const acknowledgement = yield* remembered(store.get(prKey(repo, number)));
+	return Option.match(acknowledgement, {
+		onNone: () => null,
+		onSome: (it) => it.at
+	});
+});
+/** Records that I have read a pull request's conversation as far as the comment written at `at`. */
+const acknowledge = Effect.fn("acknowledgement.acknowledge")(function* (repo, number, at) {
+	yield* (yield* storeFor("acknowledgements", Acknowledgement)).set(prKey(repo, number), { at });
+});
+//#endregion
 //#region src/domain/comments.ts
 /**
 * One thread's share of a strand, cut to what is worth reading.
@@ -2813,9 +2963,24 @@ const shown = (threads, options) => {
 		bots: kept.flatMap((it) => only(it, (bot) => bot, options.since, options.all))
 	};
 };
+/**
+* The comment an acknowledgement of this conversation covers: the newest thing
+* a person said in it, whichever thread it is in.
+*
+* The whole conversation rather than what went on screen, because the bucket
+* rule counts the whole of it: a comment on a thread somebody resolved still
+* puts the pull request in Needs me, and an acknowledgement that stopped short
+* of it would settle nothing. A bot is left out for the reason the rule leaves
+* it out.
+*
+* It is a comment's own moment and never the clock's, so a comment written
+* after the conversation was read is one the acknowledgement does not cover.
+*/
+const acknowledging = (threads) => newest(threads.flatMap((thread) => thread.comments.filter((it) => !it.bot).map((it) => it.at)));
 //#endregion
 //#region src/cli/comments.ts
 const allFlag$1 = Flag.Boolean("all").pipe(Flag.withDefault(false), Flag.withDescription("Print the whole conversation, including what is resolved, outdated and already answered"));
+const ackFlag = Flag.Boolean("ack").pipe(Flag.withDefault(false), Flag.withDescription("Record that I have read the conversation and nothing in it is mine to answer"));
 /** 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}`;
 /**
@@ -2835,8 +3000,7 @@ const settled = (thread) => [thread.resolved ? "resolved" : null, thread.outdate
 * exists to replace. No diff hunk with it: the code is on this machine, under
 * the path the heading already prints.
 */
-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 threadBlock = (thread, paint) => block(`${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(indent)]));
 /**
 * The conversation on screen: people first, then a rule, then the bots.
 *
@@ -2849,10 +3013,10 @@ const separated = (blocks) => blocks.flatMap((lines, index) => index === 0 ? lin
 * 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 blocks = (view, paint) => {
+	const people = view.people.map((thread) => threadBlock(thread, paint));
+	const bots = view.bots.map((thread) => threadBlock(thread, paint));
+	return [...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$1 = (facts, all) => {
@@ -2861,50 +3025,68 @@ const nothing$1 = (facts, all) => {
 	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.`,
+		"Nothing here is waiting on you: every thread is resolved, outdated, or older than your last comment, commit or acknowledgement.",
+		`${pr} sits in ${heading[placement.bucket]} all the same, and a reply, a push or dw-mc comments ${facts.number} --ack is what settles it.`,
 		rest
-	] : [`Nothing has been said on ${pr} since your last comment or commit.`, rest];
+	] : [`Nothing has been said on ${pr} since your last comment, commit or acknowledgement.`, rest];
 };
 /**
+* Records an acknowledgement of the conversation read, and says what it covers
+* and where the pull request sits with it.
+*
+* Where it sits is worked out from the last sweep with the acknowledgement laid
+* over it, which is the same answer the next sweep gives unless somebody says
+* something new in between.
+*/
+const acknowledged = Effect.fn("comments.acknowledged")(function* (facts, threads) {
+	const pr = `${facts.repo}#${facts.number}`;
+	const at = acknowledging(threads);
+	if (at === null) return [`Nothing to acknowledge: nobody has said anything on ${pr}.`];
+	yield* acknowledge(facts.repo, facts.number, at);
+	const placement = place({
+		...facts,
+		acknowledgedAt: at
+	});
+	return [`Acknowledged everything said on ${pr} up to ${DateTime.formatIso(at)}.`, `${pr} sits in ${heading[placement.bucket]}: ${placement.reason}.`];
+});
+/**
 * 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.
+* than the latest of my last comment, my last commit and my acknowledgement,
+* 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.
+* It writes nothing to GitHub: no reply, no resolve, no reaction (ADR 0002).
+* `--ack` is the one thing it writes at all, and only on this machine: whether a
+* comment needs an answer is known after reading it, so reading cannot be what
+* decides it.
 */
 const comments = Command.make("comments", {
 	pr: prArgument,
-	all: allFlag$1
-}, Effect.fn("comments")(function* ({ all, pr }) {
+	all: allFlag$1,
+	ack: ackFlag
+}, Effect.fn("comments")(function* ({ ack, 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),
+	const threads = yield* reading(`${repo}#${number}`, prConversation(repo, number));
+	const view = shown(threads, {
+		since: answeredAt(facts),
 		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"));
+	yield* print(view.people.length === 0 && view.bots.length === 0 ? nothing$1(facts, all) : separated([[`${repo}#${number}  ${paint.dim(facts.title)}`], ...blocks(view, paint)]));
+	if (ack) yield* print(following([yield* acknowledged(facts, threads)]));
+}, Effect.catchTag(userFacing, asUserError))).pipe(Command.withDescription("Print the conversation on one pull request and what is waiting on me in it, and with --ack record that I read 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"));
+const asJson$3 = Schema.encodeEffect(Schema.fromJsonString(Findings));
+const jsonFlag$1 = 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";
@@ -2912,14 +3094,21 @@ const summary = (found, blocksOn) => {
 	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)}`;
+const header$1 = (run, found, blocksOn, paint) => opener(paint, run.repo, run.number, run.head, summary(found, blocksOn));
+/** The bucket whose colour a severity is said in, so one colour means one thing everywhere (ADR 0007). */
+const colourOf = {
+	error: "needs-me",
+	warning: "needs-review-run",
+	info: "waiting-on-others"
+};
 /**
 * The findings one to a line, in the order the run reported them, ruled so the
-* three columns read apart.
+* three columns read apart. The place is context and the severity is state;
+* what the finding says is prose.
 */
-const lines$1 = (found) => table(found.findings.map((finding) => [
-	`${finding.file}:${finding.line}`,
-	finding.severity,
+const lines$1 = (found, paint) => table(found.findings.map((finding) => [
+	paint.dim(`${finding.file}:${finding.line}`),
+	tint(paint, colourOf[finding.severity])(finding.severity),
 	finding.summary
 ]), rule);
 /**
@@ -2945,17 +3134,17 @@ const whatItFound = (run) => {
 */
 const findings = Command.make("findings", {
 	pr: prArgument,
-	json: jsonFlag
+	json: jsonFlag$1
 }, 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));
+		yield* Console.log(yield* asJson$3(found));
 		return;
 	}
-	yield* Console.log(header$1(run, found, settings.stamp.blocks_on));
-	for (const line of lines$1(found)) yield* Console.log(`  ${line}`);
+	const paint = yield* Paint;
+	yield* print(block(header$1(run, found, settings.stamp.blocks_on, paint), lines$1(found, paint)));
 }, Effect.catchTag(["ConfigMalformed"], asUserError))).pipe(Command.withDescription("Print what the current review run found on one pull request"));
 //#endregion
 //#region src/adapters/agent.ts
@@ -3355,7 +3544,7 @@ const Selection = Schema.Struct({
 	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 asJson$2 = Schema.encodeEffect(Schema.fromJsonString(Selection));
 /**
 * The prompt a fix session opens on: what these findings are, and the findings
 * themselves as JSON.
@@ -3370,7 +3559,7 @@ const asJson$1 = Schema.encodeEffect(Schema.fromJsonString(Selection));
 * inside the worktree is my call, made once in `fix.commits` or for one session
 * with the flag.
 */
-const promptFor$1 = (selection, commits) => Effect.map(asJson$1(selection), (json) => [
+const promptFor$1 = (selection, commits) => Effect.map(asJson$2(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.`,
@@ -3396,10 +3585,11 @@ const commitFlag = Flag.Boolean("commit").pipe(Flag.withDescription("Let this se
 * 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.
+* wraps takes the whole list's alignment with it. They are plain, because a
+* prompt counts the colour it erases as rows (ADR 0007).
 */
 const choicesOf$1 = (found, screen) => {
-	const rows = lines$1(found);
+	const rows = lines$1(found, plain);
 	const room = screen === 0 ? Number.POSITIVE_INFINITY : screen - 6;
 	return found.findings.map((finding, index) => ({
 		title: truncate(rows[index] ?? finding.summary, room),
@@ -3446,11 +3636,12 @@ const fix = Command.make("fix", {
 	pr: prArgument,
 	commit: commitFlag,
 	print: printFlag$1
-}, Effect.fn("fix")(function* ({ commit, pr, print }) {
+}, Effect.fn("fix")(function* ({ commit, pr, print: promptOnly }) {
 	const { number, repo, settings, launcher } = yield* forPr(pr);
+	const paint = yield* Paint;
 	const run = yield* currentRun(repo, number);
 	const found = yield* whatItFound(run);
-	yield* Console.log(header$1(run, found, settings.stamp.blocks_on));
+	yield* print([header$1(run, found, settings.stamp.blocks_on, paint)]);
 	if (found.findings.length === 0) return;
 	const view = yield* reading(`${repo}#${number}`, prView(repo, number));
 	yield* refuse(staleAt(number, run.head, view.headRefOid));
@@ -3461,7 +3652,7 @@ const fix = Command.make("fix", {
 		return;
 	}
 	const commits = Option.getOrElse(commit, () => settings.fix.commits);
-	if (print) {
+	if (promptOnly) {
 		yield* Console.log(yield* promptFor$1({
 			repo,
 			number,
@@ -3471,8 +3662,7 @@ const fix = Command.make("fix", {
 		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}`);
+	yield* print([indent(`${chosen.length} of ${found.findings.length} findings, ${commits ? "committing" : "not committing"}`), indent(`${paint.dim(worktree.directory)}, pushing to ${view.headRefName}`)]);
 	const ended = yield* steeredSession({
 		launcher,
 		directory: worktree.directory,
@@ -3483,11 +3673,90 @@ const fix = Command.make("fix", {
 			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.`);
+	yield* print(following([[
+		ended === 0 ? "The session is over." : `The session ended with ${ended}.`,
+		`${commits ? "Nothing was pushed" : "Nothing was committed or pushed"} for you; the worktree stands at ${paint.dim(worktree.directory)}.`,
+		`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/domain/forget.ts
+/**
+* Whether a key in the state directory is about this pull request, whichever
+* namespace it sits in.
+*
+* Every namespace names a pull request by `prKey`, and the review runs add the
+* head after an `@`. Reading the key rather than a list of namespaces is what
+* lets a namespace added later be forgotten with the rest.
+*/
+const isAbout = (key, repo, number) => {
+	const slash = key.indexOf("/");
+	if (slash < 0) return false;
+	const rest = key.slice(slash + 1);
+	const pr = prKey(repo, number);
+	return rest === pr || rest.startsWith(`${pr}@`);
+};
+/**
+* Removes everything the state directory keeps about one pull request, and
+* says how many keys that was.
+*
+* A pull request it keeps nothing about is forgotten already, so that is none
+* rather than a failure.
+*/
+const forget = Effect.fn("forget.forget")(function* (repo, number) {
+	const store = yield* KeyValueStore.KeyValueStore;
+	const about = (yield* allKeys).filter((key) => isAbout(key, repo, number));
+	yield* Effect.forEach(about, (key) => store.remove(key), { discard: true });
+	return about.length;
+});
+/**
+* The session worktrees that stand on one pull request.
+*
+* Forgetting takes none of them: each stands on a branch of the tool's own and
+* holds what I committed there, so what the tool does is say they are there.
+*/
+const standingOn = (inventory, repo, number) => standing$1(inventory).filter((it) => it.repo === repo && it.number === number);
+//#endregion
+//#region src/cli/forget.ts
+/**
+* Forgets one pull request, and answers with the blocks that say what stays:
+* the records go, the session worktrees standing on it do not.
+*
+* `deleted` is the branch the pull request stood on, where the caller has just
+* deleted it. A session there tracks a branch that is gone, which is worth
+* saying, and what it holds is still mine, so saying it is all this does.
+*/
+const forgetting = Effect.fn("forgetting")(function* (repo, number, options = {}) {
+	const deleted = options.deleted;
+	const path = yield* Path.Path;
+	const paint = yield* Paint;
+	const where = `${repo}#${number}`;
+	const forgot = yield* forget(repo, number);
+	const forgotten = [forgot === 0 ? `Nothing is kept about ${where}.` : `Forgot ${where}: ${count(forgot, "record")}.`];
+	const found = yield* inventory;
+	const sessions = standingOn(found, repo, number);
+	if (sessions.length === 0) return [forgotten];
+	const rows = table(sessions.map((it) => [paint.dim(path.relative(found.directory, it.directory)), `a ${sessionName(it.session)} session's worktree, on ${sessionBranch(it.session, number)}` + (deleted === void 0 ? "" : `, which tracked ${deleted} - deleted with the merge`)]));
+	return [
+		forgotten,
+		block("Stays", rows),
+		["What you committed there is yours, so nothing here takes it down."]
+	];
+});
+/**
+* Forgets a pull request that closed some other way than `dw-mc merge`.
+*
+* A sweep never does this on its own. A pull request missing from one search is
+* not one that is gone - a failed `gh search` would look the same - and a sweep
+* is built so that a failure costs a row rather than the table. Being done is
+* something I know and the tool does not, except when it merged the pull
+* request itself.
+*/
+const forgetCommand = Command.make("forget", { pr: prArgument }, Effect.fn("forget")(function* ({ pr }) {
+	const { number, repo } = yield* forPr(pr);
+	yield* print(separated(yield* forgetting(repo, number)));
+})).pipe(Command.withDescription("Forget everything kept about a pull request that is done"));
+//#endregion
 //#region src/cli/init.ts
 const effortFlag$1 = Flag.Literals("effort", [
 	"low",
@@ -3542,10 +3811,13 @@ const init = Command.make("init", {
 	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"})`));
+	const paint = yield* Paint;
+	yield* print([
+		row("review", opening(written.defaults ?? {})),
+		row("config", paint.dim(config.path)),
+		row("state", paint.dim(state)),
+		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",
@@ -3924,6 +4196,10 @@ const decide$3 = (situation) => {
 *
 * Typing the command is the confirmation, so it takes no flag. The picker,
 * where a keystroke is cheaper, asks before it dispatches.
+*
+* Its last step is forgetting the pull request, in every namespace. A session
+* worktree standing on it stays, and is named, because its branch tracked the
+* one this just deleted.
 */
 const merge = Command.make("merge", { pr: prArgument }, Effect.fn("merge")(function* ({ pr }) {
 	const { number, repo, settings } = yield* forPr(pr);
@@ -3942,8 +4218,10 @@ const merge = Command.make("merge", { pr: prArgument }, Effect.fn("merge")(funct
 		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}`);
+	const paint = yield* Paint;
+	yield* print(separated([[opener(paint, repo, number, head, `squash-merged into ${view.baseRefName}, and ${view.headRefName} deleted`)], [`The squash subject is the pull request title: ${paint.dim(view.title)}`]]));
+	const forgot = yield* forgetting(repo, number, { deleted: view.headRefName }).pipe(Effect.catch((error) => Effect.succeed([[`Could not forget ${repo}#${number}: ${error.message}. Run dw-mc forget ${number} to try again.`]])));
+	yield* print(following(forgot));
 }, Effect.catchTag(userFacing, asUserError))).pipe(Command.withDescription("Squash-merge a Ready, stamped pull request of mine and delete its branch"));
 //#endregion
 //#region src/domain/coverage.ts
@@ -4325,6 +4603,7 @@ const sweepPr = Effect.fn("sweep.pullRequest")(function* (store, me, found, sett
 		newestHumanCommentAt,
 		myLastCommentAt: newest(writtenBy(comments, me)),
 		myLastCommitAt,
+		acknowledgedAt: yield* acknowledgedAt(found.repo, found.number),
 		...reviewed
 	};
 	yield* store.set(key, facts);
@@ -4439,15 +4718,12 @@ const askedOf$1 = (flags) => ({
 */
 const printLeftOut = Effect.fn("sweep.printLeftOut")(function* (report) {
 	if (report.leftOut === 0) return;
-	yield* Console.log("");
-	yield* Console.log(`Only ${report.repos.join(", ")}. --all covers all ${report.repos.length + report.leftOut} registered repositories.`);
+	yield* print(following([[`Only ${report.repos.join(", ")}. --all covers all ${report.repos.length + report.leftOut} registered repositories.`]]));
 });
 /** 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}`);
+	yield* print(following([block("Could not load", troubles.map((trouble) => `${trouble.where}  ${trouble.detail}`))]));
 });
 /**
 * Refreshes what mission control knows about the tracked PRs it covers.
@@ -4600,6 +4876,113 @@ const recordRerun = Effect.fn("rerun.recordRerun")(function* (repo, number, head
 	yield* (yield* storeFor("reruns", Rerun)).set(prKey(repo, number), { head });
 });
 //#endregion
+//#region src/domain/watermark.ts
+/** What a row turns on, which is what a watermark keeps of it. */
+const Said = Schema.Struct({
+	bucket: Bucket,
+	mergeable: Mergeability,
+	checks: ChecksState,
+	/** Whether the flaky classifier excused a red CI. */
+	excused: Schema.Boolean,
+	reviewDecision: ReviewDecision,
+	blockingFindings: Schema.Int,
+	newestHumanCommentAt: Schema.NullOr(Schema.DateTimeUtcFromString),
+	draft: Schema.Boolean
+});
+/**
+* The moment a tracked PR's row was last shown to me, and what the row said.
+*
+* It is kept on its own rather than on `Facts`, because a quiet PR carries its
+* old facts forward unchanged and a moment stored there would be about the
+* wrong thing. What it holds is only what a row turns on, so a fact the sweep
+* starts reading later does not make every row look new.
+*
+* Only a command that puts the row on screen writes one. A sweep on its own
+* shows nothing, and moving the watermark there would erase movement nobody saw.
+*/
+const Watermark = Schema.Struct({
+	at: Schema.DateTimeUtcFromString,
+	...Said.fields
+});
+const keyOf = ({ facts }) => prKey(facts.repo, facts.number);
+/** What a row says. */
+const said = ({ facts, placement }) => ({
+	bucket: placement.bucket,
+	mergeable: facts.mergeable,
+	checks: facts.checks,
+	excused: facts.ciFlaky !== null,
+	reviewDecision: facts.reviewDecision,
+	blockingFindings: facts.blockingFindings,
+	newestHumanCommentAt: facts.newestHumanCommentAt,
+	draft: facts.draft
+});
+/** What a row said at the moment it was shown. */
+const sighted = (placed, at) => ({
+	at,
+	...said(placed)
+});
+const ci = (it) => it.checks === "red" && it.excused ? "red, called flaky" : it.checks;
+const review$1 = {
+	approved: "approved",
+	"changes-requested": "changes requested",
+	"review-required": "review required",
+	none: "no review decision"
+};
+/**
+* The facts that moved between two sightings, said the way the row would say them.
+*
+* The head is left out on purpose: it changes on every push, and a list that
+* leads with it drowns what the push did. A mergeability GitHub has not worked
+* out yet is left out too, because it flickers to unknown and back on its own.
+*/
+const moved = (then, now) => [
+	then.mergeable !== now.mergeable && then.mergeable !== "unknown" && now.mergeable !== "unknown" ? `${then.mergeable} → ${now.mergeable}` : null,
+	ci(then) !== ci(now) ? `CI ${ci(then)} → ${ci(now)}` : null,
+	then.reviewDecision !== now.reviewDecision ? `${review$1[then.reviewDecision]} → ${review$1[now.reviewDecision]}` : null,
+	then.blockingFindings !== now.blockingFindings ? `${then.blockingFindings} → ${now.blockingFindings} blocking findings` : null,
+	isAfter(now.newestHumanCommentAt, then.newestHumanCommentAt) ? "a new comment" : null,
+	then.draft !== now.draft ? now.draft ? "back to draft" : "out of draft" : null
+].filter((it) => it !== null);
+/**
+* What happened to a row since `watermark`, the last time it was shown.
+*
+* Movement is a bucket transition plus the facts that moved with it. Either one
+* alone misses something: every field compared drowns in the head, and a bucket
+* on its own says nothing when CI goes green on a PR still mine for another
+* reason.
+*/
+const since = (watermark, placed) => {
+	if (watermark === void 0) return { _tag: "new" };
+	const now = said(placed);
+	const what = moved(watermark, now);
+	const from = watermark.bucket === now.bucket ? void 0 : watermark.bucket;
+	return from === void 0 && what.length === 0 ? { _tag: "still" } : {
+		_tag: "moved",
+		from,
+		what
+	};
+};
+/**
+* What happened to each of these rows since it was last shown.
+*
+* It answers for any row, and a row it was not given is one it has no
+* watermark for, which is a row never shown.
+*/
+const sinceShown = Effect.fn("watermark.sinceShown")(function* (placed) {
+	const store = yield* storeFor("watermarks", Watermark);
+	const found = new Map(yield* Effect.forEach(placed, (it) => {
+		const key = keyOf(it);
+		return Effect.map(remembered(store.get(key)), (mark) => [key, since(Option.getOrUndefined(mark), it)]);
+	}));
+	return (it) => found.get(keyOf(it)) ?? { _tag: "new" };
+});
+/** Records that these rows were shown to me, now, saying what they say. */
+const markShown = Effect.fn("watermark.markShown")(function* (placed) {
+	const store = yield* storeFor("watermarks", Watermark);
+	const now = yield* DateTime.now;
+	yield* Effect.forEach(placed, (it) => store.set(keyOf(it), sighted(it, now)), { discard: true });
+});
+//#endregion
 //#region src/cli/pick.ts
 /** A title cut this short says nothing, so a row that tight loses the column instead. */
 const shortest = 12;
@@ -4625,9 +5008,10 @@ const screenRoom = (screen, paint) => screen === 0 ? Number.POSITIVE_INFINITY :
 * The cells come from there rather than being built again here, so the list I
 * pick from and the table I read are the same rows with the bucket moved onto
 * each of them. A prompt has no headings to group under, so the bucket is named
-* on every row; the rows are still in the order the buckets are acted on.
+* on every row; the rows are still in the order the buckets are acted on. The
+* gutter in front says what moved since I last looked, as it does in the table.
 */
-const cellsOf = ({ placed, stamped }, room, paint) => cells(placed, stamped, room, paint, "named");
+const cellsOf = ({ placed, stamped }, since, room, paint) => cells(placed, stamped, since, room, paint, "named");
 /**
 * Every tracked PR as something to pick, aligned down the whole list.
 *
@@ -4638,13 +5022,13 @@ const cellsOf = ({ placed, stamped }, room, paint) => cells(placed, stamped, roo
 * tells me less than the room it took. A screen too narrow for all four columns
 * loses the title's column rather than the reason's words.
 */
-const choicesOf = (standings, screen, paint) => {
-	const measured = standings.map((it) => cellsOf(it, Number.POSITIVE_INFINITY, paint));
+const choicesOf = (standings, sinceOf, screen, paint) => {
+	const measured = standings.map((it) => cellsOf(it, sinceOf(it.placed), Number.POSITIVE_INFINITY, paint));
 	const widest = (index) => Math.max(...measured.map((row) => visible(row[index] ?? "")));
 	const room = screenRoom(screen, paint) - (widest(0) + widest(1) + widest(3)) - 9;
 	const told = room >= shortest;
 	const rows = table(standings.map((it) => {
-		const row = cellsOf(it, told ? room : 0, paint);
+		const row = cellsOf(it, sinceOf(it.placed), told ? room : 0, paint);
 		return told ? row : [
 			row[0] ?? "",
 			row[1] ?? "",
@@ -4701,7 +5085,10 @@ const picker = (dispatch) => Effect.fn("pick")(function* () {
 		yield* Console.log("No open pull requests.");
 		return;
 	}
-	const chosen = yield* pick("Which pull request?", choicesOf(standings, yield* width, yield* Paint));
+	const shown = standings.map((it) => it.placed);
+	const choices = choicesOf(standings, yield* sinceShown(shown), yield* width, yield* Paint);
+	yield* markShown(shown);
+	const chosen = yield* pick("Which pull request?", choices);
 	if (Option.isNone(chosen)) return;
 	const facts = chosen.value.placed.facts;
 	const offer = yield* pick(`What do I do with ${where(facts)}?`, actionChoices(actionsFor(chosen.value)));
@@ -4761,28 +5148,26 @@ const rebase = Command.make("rebase", { pr: prArgument }, Effect.fn("rebase")(fu
 		checks: rollupState(view.statusCheckRollup, settings.ci.ignore),
 		stack: stackOf(number, open)
 	}));
-	const where = `${repo}#${number}`;
+	const paint = yield* Paint;
 	const done = yield* rebaseOnto(repo, number, view.baseRefName, view.headRefName);
 	if (done._tag === "up-to-date") {
-		yield* Console.log(`${where}  ${short(view.headRefOid)}  already on ${view.baseRefName}`);
+		yield* print([opener(paint, repo, number, view.headRefOid, `already on ${view.baseRefName}`)]);
 		return;
 	}
 	if (done._tag === "conflicted") {
 		yield* recordConflict(repo, number, view.headRefOid, done.paths);
-		yield* Console.log(`${where}  ${short(view.headRefOid)}  the rebase onto ${view.baseRefName} conflicted, so it was aborted and nothing was pushed.`);
-		if (done.paths.length > 0) {
-			yield* Console.log(`It stopped on ${count(done.paths.length, "file")}:`);
-			yield* Effect.forEach(done.paths, (path) => Console.log(`  ${path}`));
-		}
-		yield* Effect.forEach([
-			``,
-			`  dw-mc resolve ${number}`,
-			``
-		], (line) => Console.log(line));
-		yield* Console.log("That opens a session on the conflict, in a worktree of your own. The next sweep puts it in Needs me, and it stays there until the branch moves.");
+		yield* print(separated([
+			[opener(paint, repo, number, view.headRefOid, `the rebase onto ${view.baseRefName} conflicted, so it was aborted and nothing was pushed.`)],
+			stoppedOn(paint, done.paths),
+			retype(paint, `dw-mc resolve ${number}`),
+			["That opens a session on the conflict, in a worktree of your own. The next sweep puts it in Needs me, and it stays there until the branch moves."]
+		]));
 		return;
 	}
-	yield* Console.log(`${where}  ${short(done.before)} → ${short(done.after)}  rebased ${count(done.behind, "commit")} of ${view.baseRefName} and pushed with a lease`);
+	yield* print([opener(paint, repo, number, {
+		before: done.before,
+		after: done.after
+	}, `rebased ${count(done.behind, "commit")} of ${view.baseRefName} and pushed 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
@@ -4824,10 +5209,8 @@ const rerun = Command.make("rerun", { pr: prArgument }, Effect.fn("rerun")(funct
 	}));
 	yield* recordRerun(repo, number, view.headRefOid);
 	yield* Effect.forEach(unclassified.runs, (run) => rerunFailed(repo, run));
-	const where = `${repo}#${number}`;
-	yield* Console.log(`${where}  ${short(view.headRefOid)}  re-ran the failed jobs of ${count(unclassified.runs.length, "workflow run")}`);
-	yield* Console.log(`It is flaky because ${flaky}.`);
-	yield* Console.log(`This head gets no second re-run; if it fails again, the failure is yours.`);
+	const paint = yield* Paint;
+	yield* print(separated([[opener(paint, repo, number, view.headRefOid, `re-ran the failed jobs of ${count(unclassified.runs.length, "workflow run")}`)], [`It is flaky because ${flaky}.`, `This head gets no second re-run; if it fails again, the failure is yours.`]]));
 }, Effect.catchTag(userFacing, asUserError))).pipe(Command.withDescription("Run a flaky red CI again, once per head"));
 //#endregion
 //#region src/domain/resolve.ts
@@ -4868,7 +5251,7 @@ const Conflicted = Schema.Struct({
 	paths: Schema.Array(Schema.String)
 });
 /** The conflict as the JSON the schema defines, rather than as this file spells it. */
-const asJson = Schema.encodeEffect(Schema.fromJsonString(Conflicted));
+const asJson$1 = Schema.encodeEffect(Schema.fromJsonString(Conflicted));
 /**
 * The prompt a resolve session opens on: what stopped the replay, and the
 * conflict itself as JSON.
@@ -4884,7 +5267,7 @@ const asJson = Schema.encodeEffect(Schema.fromJsonString(Conflicted));
 * after reading what it did, and a session that did them would be resolving the
 * conflict for me rather than with me.
 */
-const promptFor = (conflicted) => Effect.map(asJson(conflicted), (json) => [
+const promptFor = (conflicted) => Effect.map(asJson$1(conflicted), (json) => [
 	`A dw-mc rebase of ${conflicted.repo}#${conflicted.number} onto ${conflicted.base} stopped on a conflict. You are in a worktree standing on the pull request's commits at ${short(conflicted.head)}, with that rebase in progress and the files below unmerged.`,
 	`The pull request is "${conflicted.title}". Resolve each file so it keeps meaning that and keeps whatever ${conflicted.base} changed underneath it; where the two cannot both hold, say so and stop.`,
 	"Do not run git rebase --continue, do not commit and do not push. I read the resolution and do all three myself.",
@@ -4916,7 +5299,7 @@ const printFlag = Flag.Boolean("print").pipe(Flag.withDefault(false), Flag.withD
 const resolve = Command.make("resolve", {
 	pr: prArgument,
 	print: printFlag
-}, Effect.fn("resolve")(function* ({ pr, print }) {
+}, Effect.fn("resolve")(function* ({ pr, print: promptOnly }) {
 	const { number, repo, launcher } = yield* forPr(pr);
 	const [view, open, me] = yield* reading(`${repo}#${number}`, Effect.all([
 		prView(repo, number),
@@ -4943,43 +5326,34 @@ const resolve = Command.make("resolve", {
 		title: view.title,
 		paths
 	});
-	if (print) {
+	if (promptOnly) {
 		yield* Console.log(yield* promptFor(conflicted(conflict?.paths ?? [])));
 		return;
 	}
-	const where = `${repo}#${number}`;
+	const paint = yield* Paint;
 	const worktree = yield* standingWorktree(repo, number, view.headRefName, "rebase");
-	yield* Console.log(`${where}  ${short(view.headRefOid)}  replaying onto ${view.baseRefName} in ${worktree.directory}`);
+	yield* print([opener(paint, repo, number, view.headRefOid, `replaying onto ${view.baseRefName} in ${paint.dim(worktree.directory)}`)]);
+	const reviewNext = `Once you have pushed, dw-mc review ${number} reviews the new head as a new run.`;
 	const stopped = yield* rebaseInPlace(worktree.directory, view.baseRefName);
 	if (stopped._tag === "replayed") {
-		yield* Console.log("The replay went through, so there is nothing to resolve: git replayed a resolution you made before, or the conflict is gone.");
-		yield* Console.log(`The worktree stands where it replayed, and the push onto ${view.headRefName} is yours:`);
-		yield* Effect.forEach([
-			``,
-			`  cd ${worktree.directory}`,
-			`  git push`,
-			``
-		], (line) => Console.log(line));
-		yield* Console.log(`Once you have pushed, dw-mc review ${number} reviews the new head as a new run.`);
+		yield* print(following([
+			["The replay went through, so there is nothing to resolve: git replayed a resolution you made before, or the conflict is gone.", `The worktree stands where it replayed, and the push onto ${view.headRefName} is yours:`],
+			retype(paint, `cd ${worktree.directory}`, `git push`),
+			[reviewNext]
+		]));
 		return;
 	}
-	yield* Console.log(`It stopped on ${count(stopped.paths.length, "file")}:`);
-	yield* Effect.forEach(stopped.paths, (path) => Console.log(`  ${path}`));
+	yield* print(following([stoppedOn(paint, stopped.paths)]));
 	const ended = yield* steeredSession({
 		launcher,
 		directory: worktree.directory,
 		prompt: yield* promptFor(conflicted(stopped.paths))
 	});
-	yield* Console.log(ended === 0 ? "The session is over." : `The session ended with ${ended}.`);
-	yield* Console.log("Nothing was committed or pushed for you; the rebase stands where it stopped.");
-	yield* Effect.forEach([
-		``,
-		`  cd ${worktree.directory}`,
-		`  git rebase --continue`,
-		`  git push`,
-		``
-	], (line) => Console.log(line));
-	yield* Console.log(`Once you have pushed, dw-mc review ${number} reviews the new head as a new run.`);
+	yield* print(following([
+		[ended === 0 ? "The session is over." : `The session ended with ${ended}.`, "Nothing was committed or pushed for you; the rebase stands where it stopped."],
+		retype(paint, `cd ${worktree.directory}`, `git rebase --continue`, `git push`),
+		[reviewNext]
+	]));
 }, 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
@@ -5172,7 +5546,7 @@ const reviewOn = Effect.fn("review.reviewOn")(function* (options) {
 				tools: doing.tools + 1,
 				subagents: doing.subagents + (tool === "Agent" ? 1 : 0)
 			};
-			return says(saying(doing), `  · ${tool}`);
+			return says(saying(doing), indent(`· ${tool}`));
 		}
 	}));
 	const answered = Result.isFailure(run.findings) ? Effect.fail(run.findings.failure) : Effect.succeed(run.findings.success);
@@ -5266,11 +5640,12 @@ const review = Command.make("review", {
 		promptOnly,
 		commandOnly
 	});
+	const paint = yield* Paint;
 	const view = yield* prView(repo, number);
-	yield* Console.log(`${repo}#${number}  ${view.title}`);
+	yield* print([`${repo}#${number}  ${paint.dim(view.title)}`]);
 	const since = force ? null : skippedSince(yield* askedOf(repo, number, view.headRefOid), settings.review.docs_only);
 	if (since !== null) {
-		yield* Console.log(`  only documentation changed since ${short(since)}, so this run is skipped. Pass --force to review it anyway.`);
+		yield* print([indent(`only documentation changed since ${paint.dim(short(since))}, so this run is skipped. Pass --force to review it anyway.`)]);
 		return;
 	}
 	const about = {
@@ -5283,7 +5658,7 @@ const review = Command.make("review", {
 	const turn = turnFor(asked, about);
 	yield* Effect.gen(function* () {
 		const ran = yield* withWorktree(repo, number, (worktree) => Effect.gen(function* () {
-			yield* Console.log(`  head ${short(worktree.head)}  ${spending(turn, asked.model)}`);
+			yield* print([indent(`head ${paint.dim(short(worktree.head))}  ${spending(turn, asked.model)}`)]);
 			const got = yield* Effect.result(reviewOn({
 				launcher,
 				directory: worktree.directory,
@@ -5313,21 +5688,14 @@ const review = Command.make("review", {
 		yield* runs.set(runKey(repo, number, run.head), run);
 		yield* latest.set(latestKey(repo, number), { head: run.head });
 		yield* reports.set(reportKey(repo, number, run.head), reportDocument(run, view.title, got.prose ?? ""));
-		yield* Console.log("");
 		const detail = detailOf(run);
-		if (detail !== null) yield* Console.log(`  reported nothing: ${detail}`);
-		else {
-			const found = reportedBy(run);
-			if (found !== null) {
-				if (got.prose !== null) {
-					yield* Console.log(got.prose);
-					yield* Console.log("");
-				}
-				yield* Console.log(summary(found, settings.stamp.blocks_on));
-				for (const line of lines$1(found)) yield* Console.log(`  ${line}`);
-			}
-		}
-		yield* Console.log(`Recorded against ${short(ran.head)} in ${yield* stateDirectory}`);
+		const found = detail === null ? reportedBy(run) : null;
+		yield* print(following([
+			detail === null ? [] : [indent(`reported nothing: ${detail}`)],
+			found === null || got.prose === null ? [] : [got.prose],
+			found === null ? [] : block(summary(found, settings.stamp.blocks_on), lines$1(found, paint)),
+			[`Recorded against ${paint.dim(short(ran.head))} in ${paint.dim(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(userFacingAndGit, asUserError))).pipe(Command.withDescription("Review one pull request on Claude Code, in a throwaway worktree"));
@@ -5357,17 +5725,94 @@ const stampCommand = Command.make("stamp", {
 }, Effect.fn("stamp")(function* ({ pr, withdraw: byHand }) {
 	const { number, repo } = yield* forPr(pr);
 	const facts = yield* swept(repo, number);
-	const where = `${repo}#${number}  ${short(facts.head)}`;
+	const paint = yield* Paint;
 	if (byHand) {
 		yield* withdraw(repo, number, facts.head);
-		yield* Console.log(`${where}  stamp withdrawn, until the head changes`);
+		yield* print([opener(paint, repo, number, facts.head, "stamp withdrawn, until the head changes")]);
 		return;
 	}
 	const stamp = yield* stampOf(facts);
-	yield* Console.log(`${where}  ${stamp.stamped ? "stamped" : `not stamped: ${stamp.reason}`}`);
+	yield* print([opener(paint, repo, number, facts.head, stamp.stamped ? "stamped" : `not stamped: ${stamp.reason}`)]);
 }, Effect.catchTag(["ConfigMalformed"], asUserError))).pipe(Command.withDescription("Print my stamp on one pull request, or withdraw it by hand"));
 //#endregion
 //#region src/cli/status.ts
+/** What moved a row, as the JSON says it: `from` is null where the row kept its bucket. */
+const SinceJson = Schema.Union([
+	Schema.TaggedStruct("new", {}),
+	Schema.TaggedStruct("still", {}),
+	Schema.TaggedStruct("moved", {
+		from: Schema.NullOr(Bucket),
+		what: Schema.Array(Schema.String)
+	})
+]);
+/**
+* One pass of `dw-mc status`, as the JSON a machine reads it in.
+*
+* A row carries every fact flat beside its placement, so `jq` reaches
+* `.prs[].checks` without unwrapping anything. What the table says in lines
+* after it - what the pass could not read, and how many registered
+* repositories it left out - is here as well, because a document without them
+* reads as the whole picture when it is not.
+*/
+const StatusJson = Schema.Struct({
+	/** When the pass ended: status sweeps on every run. */
+	sweptAt: Schema.DateTimeUtcFromString,
+	repos: Schema.Array(Schema.String),
+	leftOut: Schema.Int,
+	prs: Schema.Array(Schema.Struct({
+		bucket: Bucket,
+		reason: Schema.String,
+		stamped: Schema.Boolean,
+		since: SinceJson,
+		...Facts.fields
+	})),
+	troubles: Schema.Array(Schema.Struct({
+		where: Schema.String,
+		detail: Schema.String
+	}))
+});
+const asJson = Schema.encodeEffect(Schema.fromJsonString(StatusJson));
+const jsonFlag = Flag.Boolean("json").pipe(Flag.withDefault(false), Flag.withDescription("Print the pass as JSON, for jq or an agent session, and leave what I last looked at alone"));
+const sinceJson = (since) => since._tag === "moved" ? {
+	_tag: "moved",
+	from: since.from ?? null,
+	what: since.what
+} : since;
+/**
+* The pass as one JSON document, and nothing else on stdout.
+*
+* It sweeps without a heartbeat, because what reads this is a pipe or a
+* session, and a line drawn over the document is a document broken. What moved
+* is read and never written: a machine reading the pass is not me looking, so
+* the watermark stays where the last table left it.
+*/
+const printJson = Effect.fn("status.json")(function* (asked) {
+	const report = yield* sweep(asked, () => Effect.void);
+	const sweptAt = yield* DateTime.now;
+	const placed = group(report.facts).flatMap((it) => it.placed);
+	const stamped = yield* stampedAmong(report.facts);
+	const sinceOf = yield* sinceShown(placed);
+	yield* Console.log(yield* asJson({
+		sweptAt,
+		repos: report.repos,
+		leftOut: report.leftOut,
+		prs: placed.map((it) => ({
+			bucket: it.placement.bucket,
+			reason: it.placement.reason,
+			stamped: stamped.has(prKey(it.facts.repo, it.facts.number)),
+			since: sinceJson(sinceOf(it)),
+			...it.facts
+		})),
+		troubles: report.troubles
+	}));
+});
+/** What moved a row, said on its own line above the group it now sits in. */
+const movement = (placed, since) => {
+	if (since._tag !== "moved") return [];
+	const from = since.from === void 0 ? "" : ` from ${heading[since.from]}`;
+	const what = since.what.length === 0 ? "" : `: ${since.what.join(", ")}`;
+	return [`  ↳ ${reference(placed.facts)}${from}${what}`];
+};
 /**
 * Every tracked PR under the bucket it sits in, in the order I act on them.
 *
@@ -5375,9 +5820,12 @@ const stampCommand = Command.make("stamp", {
 * the whole table rather than restarting under each heading, and they are ruled
 * apart: three columns of prose run into one another without a rule, and the
 * middle one is a commit subject that can end in anything.
+*
+* What moved since I last looked is marked in the gutter the rows are indented
+* by, so a mark costs no column and a row with none reads as it always did.
 */
-const lines = (grouped, stamped, paint) => {
-	const rows = table(grouped.flatMap((it) => it.placed.map((placed) => cells(placed, stamped.has(prKey(placed.facts.repo, placed.facts.number)), 56, paint, "marker"))), rule);
+const lines = (grouped, stamped, sinceOf, paint) => {
+	const rows = table(grouped.flatMap((it) => it.placed.map((placed) => cells(placed, stamped.has(prKey(placed.facts.repo, placed.facts.number)), sinceOf(placed), 56, paint, "marker"))), rule);
 	let taken = 0;
 	return grouped.flatMap((it, index) => {
 		const mine = rows.slice(taken, taken + it.placed.length);
@@ -5385,7 +5833,8 @@ const lines = (grouped, stamped, paint) => {
 		return [
 			...index === 0 ? [] : [""],
 			heading[it.bucket],
-			...mine.map((row) => `  ${row}`)
+			...it.placed.flatMap((placed) => movement(placed, sinceOf(placed))),
+			...mine
 		];
 	});
 };
@@ -5393,11 +5842,17 @@ const lines = (grouped, stamped, paint) => {
 * The table of what every tracked PR waits on.
 *
 * It sweeps first, every time: a table I read is never one I forgot to refresh.
+* `--json` prints the same pass for a machine.
 */
 const status = Command.make("status", {
 	repo: repoFlag,
-	all: allFlag
+	all: allFlag,
+	json: jsonFlag
 }, Effect.fn("status")(function* (flags) {
+	if (flags.json) {
+		yield* printJson(askedOf$1(flags));
+		return;
+	}
 	const report = yield* sweeping(askedOf$1(flags));
 	if (report.repos.length === 0) {
 		yield* Console.log("No repositories registered. Run dw-mc init inside a repository to register it.");
@@ -5405,20 +5860,17 @@ const status = Command.make("status", {
 	}
 	const grouped = group(report.facts);
 	if (grouped.length === 0) yield* Console.log("No open pull requests.");
-	for (const line of lines(grouped, yield* stampedAmong(report.facts), yield* Paint)) yield* Console.log(line);
+	const shown = grouped.flatMap((it) => it.placed);
+	for (const line of lines(grouped, yield* stampedAmong(report.facts), yield* sinceShown(shown), yield* Paint)) yield* Console.log(line);
 	yield* printLeftOut(report);
 	yield* printTroubles(report.troubles);
-}, Effect.catchTag(userFacing, asUserError))).pipe(Command.withDescription("Show which bucket every tracked pull request of the repository I stand in, or of every one, sits in, and which ones I have stamped"));
+	yield* markShown(shown);
+}, Effect.catchTag(userFacing, asUserError))).pipe(Command.withDescription("Show which bucket every tracked pull request of the repository I stand in, or of every one, sits in, which ones I have stamped, and what moved since I last looked"));
 //#endregion
 //#region src/cli/uninstall.ts
 const configFlag = Flag.Boolean("config").pipe(Flag.withDefault(false), Flag.withDescription("Take the configuration file too, and not only the state"));
 const forceFlag = Flag.Boolean("force").pipe(Flag.withDefault(false), Flag.withDescription("Remove a session worktree that still holds work of mine"));
-const block = (heading, rows) => rows.length === 0 ? [] : [
-	heading,
-	...table(rows).map((line) => `  ${line}`),
-	""
-];
-const removes = (state, config, paint) => block("Removes", [[
+const removes = (state, config, paint) => block("Removes", table([[
 	paint.dim(state.directory),
 	state.size,
 	"every record, report, clone and worktree"
@@ -5426,8 +5878,8 @@ const removes = (state, config, paint) => block("Removes", [[
 	paint.dim(config),
 	"",
 	"the runner and every repository registered"
-]]]);
-const held = (holds, paint) => block("Holds work of mine", holds.map((it) => [paint.dim(it.at.directory), it.detail]));
+]]]));
+const held = (holds, paint) => holds.length === 0 ? [] : block("Holds work of mine", table(holds.map((it) => [paint.dim(it.at.directory), it.detail])));
 /**
 * Takes the tool's own footprint off this machine, which no package manager
 * does.
@@ -5458,20 +5910,17 @@ const uninstall = Command.make("uninstall", {
 	const found = yield* inventory;
 	const file = yield* configPath;
 	const configured = yield* fs.exists(file);
-	const holds = yield* Effect.forEach(standing(found), (at) => Effect.map(holding(at.repo, at.number, at.session), (holding_) => holding_._tag === "held" ? [{
+	const holds = yield* Effect.forEach(standing$1(found), (at) => Effect.map(holding(at.repo, at.number, at.session), (holding_) => holding_._tag === "held" ? [{
 		at,
 		detail: holding_.detail
 	}] : [])).pipe(Effect.map((found_) => found_.flat()));
-	yield* Effect.forEach(removes({
+	yield* print([...separated([removes({
 		directory: found.directory,
 		size: weight(everything$1(found))
-	}, alsoConfig && configured ? file : void 0, paint), (line) => Console.log(line));
-	if (holds.length > 0) {
-		yield* Effect.forEach(held(holds, paint), (line) => Console.log(line));
-		if (!force) {
-			yield* Console.log("Nothing was removed. Push that work or drop it, or run this again with --force.");
-			return;
-		}
+	}, alsoConfig && configured ? file : void 0, paint), held(holds, paint)]), ""]);
+	if (holds.length > 0 && !force) {
+		yield* Console.log("Nothing was removed. Push that work or drop it, or run this again with --force.");
+		return;
 	}
 	if (!yes && !(yield* confirm("Remove it all?"))) {
 		yield* Console.log("Nothing was removed.");
@@ -5491,7 +5940,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.6.0";
+const version = "0.8.0";
 /** Where the project lives, printed beside the version in the header. */
 const projectUrl = "github.com/dominikwozniak/dw-mc";
 const subcommands = [
@@ -5504,6 +5953,7 @@ const subcommands = [
 	rerun,
 	resolve,
 	merge,
+	forgetCommand,
 	sweepCommand,
 	status,
 	stampCommand,
@@ -5548,18 +5998,41 @@ const header = (colors) => {
 		return meta === "" ? paint.cyan(line) : `${paint.cyan(line.padEnd(width))}${gap}${paint.dim(meta)}`;
 	}).join("\n");
 };
+/** A path under my home, the way I would type it. */
+const tilde = (path, home) => home !== void 0 && path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
+/**
+* What the configuration file says of this machine, in the few words a help
+* screen has room for.
+*
+* A file that cannot be read keeps the help screen standing and says only that
+* it cannot: the reason is ADR 0010's, and every other command prints it.
+*/
+const standing = read.pipe(Effect.map(Option.match({
+	onNone: () => "not set up - run dw-mc init",
+	onSome: (file) => {
+		const n = Object.keys(file.repos ?? {}).length;
+		return n === 1 ? "1 repository registered" : `${n} repositories registered`;
+	}
+})), Effect.catchTag("ConfigMalformed", () => Effect.succeed("cannot be read - any other command says why")));
+/**
+* The two lines naming this machine's setup, with the labels `dw-mc init`
+* prints. The paths are dimmed as context, and nothing is coloured by state.
+*/
+const described = (setup, registered, paint) => [`config  ${paint.dim(setup.config)}   ${registered}`, `state   ${paint.dim(setup.state)}`];
 /**
 * The formatter for the two screens the tool introduces itself on, with the
-* header above what the default formatter draws.
+* header above what the default formatter draws, and on the help screen the
+* lines naming this machine's setup under it.
 *
 * The root command is the one whose help document lists subcommands, which is
 * what keeps the header off `dw-mc status --help`.
 */
-const formatter = (colors) => {
+const formatter = (colors, setupLines) => {
 	const inner = CliOutput.defaultFormatter({ colors });
 	const drawn = header(colors);
+	const withSetup = setupLines.length === 0 ? drawn : `${drawn}\n\n${setupLines.join("\n")}`;
 	return {
-		formatHelpDoc: (doc) => doc.subcommands === void 0 ? inner.formatHelpDoc(doc) : `${drawn}\n\n${inner.formatHelpDoc(doc)}`,
+		formatHelpDoc: (doc) => doc.subcommands === void 0 ? inner.formatHelpDoc(doc) : `${withSetup}\n\n${inner.formatHelpDoc(doc)}`,
 		formatVersion: (name, printed) => `${drawn}\n\n${inner.formatVersion(name, printed)}`,
 		formatCliError: inner.formatCliError,
 		formatError: inner.formatError,
@@ -5572,17 +6045,30 @@ const formatter = (colors) => {
 * It replaces the formatter under `--help` and `--version` rather than for the
 * run, because a failed parse prints the help screen through the same
 * formatter: decorating that one would bury the error under a logo.
+*
+* The paths are worked out as the layer is built, from the environment alone.
+* The configuration file is read only once `--help` is asked for, because no
+* other run of the tool prints what it says here. A store that fails outright
+* leaves the lines off rather than the help screen.
 */
-const layer = Layer.unwrap(Effect.map(screened, (colors) => {
-	const introducing = Effect.provideService(CliOutput.Formatter, formatter(colors));
-	return CliConfig.layer({ builtIns: CliConfig.defaults.builtIns.map((builtIn) => builtIn === GlobalFlag.Help || builtIn === GlobalFlag.Version ? GlobalFlag.Action({
+const layer = Layer.unwrap(Effect.gen(function* () {
+	const colors = yield* screened;
+	const config = yield* ConfigStore;
+	const home = Option.getOrUndefined(yield* Config.String("HOME").pipe(Config.option));
+	const setup = {
+		config: tilde(config.path, home),
+		state: tilde(yield* stateDirectory, home)
+	};
+	const setupLines = Effect.provideService(standing, ConfigStore, config).pipe(Effect.map((said) => described(setup, said, paintFor(colors))), Effect.orElseSucceed(() => []));
+	const introducing = (builtIn, lines) => GlobalFlag.Action({
 		flag: builtIn.flag,
-		run: (value, context) => introducing(builtIn.run(value, context))
-	}) : builtIn) });
+		run: (value, context) => Effect.flatMap(lines, (it) => Effect.provideService(builtIn.run(value, context), CliOutput.Formatter, formatter(colors, it)))
+	});
+	return CliConfig.layer({ builtIns: CliConfig.defaults.builtIns.map((builtIn) => builtIn === GlobalFlag.Help ? introducing(GlobalFlag.Help, setupLines) : builtIn === GlobalFlag.Version ? introducing(GlobalFlag.Version, Effect.succeed([])) : builtIn) });
 }));
 //#endregion
 //#region src/cli/bin.ts
-dwMc.pipe(Command.run({ version }), Effect.provide(Layer.provideMerge(Layer.mergeAll(ConfigStore.layer, layer$1, layer, layer$2), NodeServices.layer)), NodeRuntime.runMain);
+dwMc.pipe(Command.run({ version }), Effect.provide(Layer.provideMerge(Layer.mergeAll(Layer.provideMerge(layer, ConfigStore.layer), layer$1, layer$2), NodeServices.layer)), NodeRuntime.runMain);
 //#endregion
 export {};