dw-mc 0.6.0 → 0.7.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",
@@ -1515,7 +1566,9 @@ const standing = (inventory) => inventory.cuttings.flatMap((cutting) => {
 /** 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(", ");
+/** 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(", ");
 /**
 * What a cleanup would take, weighed.
 *
@@ -1604,7 +1657,7 @@ const lines$3 = (it, state, path, paint) => {
 * 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.
+* 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
@@ -1966,13 +2019,13 @@ const Actor = Schema.NullOr(Schema.Struct({
 	login: Schema.String,
 	__typename: Schema.String
 }));
-const Said = Schema.Struct({
+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) }),
+	comments: Schema.Struct({ nodes: Schema.Array(Said$1) }),
 	reviews: Schema.Struct({ nodes: Schema.Array(Schema.Struct({
 		author: Actor,
 		body: Schema.String,
@@ -1983,7 +2036,7 @@ const Conversation = Schema.fromJsonString(Schema.Struct({ data: Schema.Struct({
 		isOutdated: Schema.Boolean,
 		path: Schema.NullOr(Schema.String),
 		line: Schema.NullOr(Schema.Int),
-		comments: Schema.Struct({ nodes: Schema.Array(Said) })
+		comments: Schema.Struct({ nodes: Schema.Array(Said$1) })
 	})) })
 }) }) }) }));
 const remark = (said, at) => said.author === null || at === null || said.body.trim() === "" ? [] : [{
@@ -2155,12 +2208,15 @@ const Facts = Schema.Struct({
 	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
 });
-Schema.Literals([
+/** 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",
@@ -2193,6 +2249,16 @@ const unanswered = "a comment I have not answered";
 */
 const blockedBy = (n) => `${n} blocking finding${n === 1 ? "" : "s"}`;
 /**
+* How far my answer to the conversation reaches: the latest of my last comment,
+* my last commit and my acknowledgement.
+*
+* 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 answeredAt = (facts) => later(later(facts.myLastCommentAt, facts.myLastCommitAt), facts.acknowledgedAt);
+/**
 * 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.
@@ -2203,7 +2269,7 @@ const needsMe = (facts) => {
 	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;
+	if (isAfter(facts.newestHumanCommentAt, answeredAt(facts))) return unanswered;
 	return null;
 };
 /**
@@ -2725,6 +2791,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 +2817,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 +2836,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 +2921,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}`;
 /**
@@ -2861,45 +2984,75 @@ 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) {
+		yield* Console.log(`Nothing to acknowledge: nobody has said anything on ${pr}.`);
+		return;
+	}
+	yield* acknowledge(facts.repo, facts.number, at);
+	const placement = place({
+		...facts,
+		acknowledgedAt: at
+	});
+	yield* Console.log(`Acknowledged everything said on ${pr} up to ${DateTime.formatIso(at)}.`);
+	yield* Console.log(`${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;
+	if (view.people.length === 0 && view.bots.length === 0) yield* Effect.forEach(nothing$1(facts, all), (line) => Console.log(line));
+	else {
+		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));
 	}
-	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"));
+	if (ack) {
+		yield* Console.log("");
+		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. */
@@ -3488,6 +3641,83 @@ const fix = Command.make("fix", {
 	yield* Console.log(`Once you have pushed, dw-mc review ${number} reviews the new head as a new run.`);
 }, Effect.catchTag(userFacingAndSession, asUserError))).pipe(Command.withDescription("Pick findings from the current review run and open a fix session on them"));
 //#endregion
+//#region src/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(inventory).filter((it) => it.repo === repo && it.number === number);
+//#endregion
+//#region src/cli/forget.ts
+/**
+* Forgets one pull request and says 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);
+	yield* Console.log(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;
+	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`)]));
+	yield* Console.log("");
+	yield* Console.log("Stays");
+	yield* Effect.forEach(rows, (row) => Console.log(`  ${row}`));
+	yield* Console.log("");
+	yield* Console.log("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* 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",
@@ -3924,6 +4154,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);
@@ -3944,6 +4178,7 @@ const merge = Command.make("merge", { pr: prArgument }, Effect.fn("merge")(funct
 	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}`);
+	yield* forgetting(repo, number, { deleted: view.headRefName }).pipe(Effect.catch((error) => Console.log(`\nCould not forget ${repo}#${number}: ${error.message}. Run dw-mc forget ${number} to try again.`)));
 }, 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 +4560,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);
@@ -4600,6 +4836,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 +4968,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 +4982,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 +5045,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)));
@@ -5368,6 +5715,13 @@ const stampCommand = Command.make("stamp", {
 }, 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, 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 +5729,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 +5742,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
 		];
 	});
 };
@@ -5405,10 +5763,12 @@ 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"));
@@ -5491,7 +5851,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.7.0";
 /** Where the project lives, printed beside the version in the header. */
 const projectUrl = "github.com/dominikwozniak/dw-mc";
 const subcommands = [
@@ -5504,6 +5864,7 @@ const subcommands = [
 	rerun,
 	resolve,
 	merge,
+	forgetCommand,
 	sweepCommand,
 	status,
 	stampCommand,