dw-mc 0.5.1 → 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",
@@ -708,6 +759,92 @@ const tidy = Effect.fn("store.tidy")(function* (directory, upTo) {
 	}
 });
 //#endregion
+//#region src/adapters/picker.ts
+/**
+* Turns quitting into an answer rather than a failure.
+*
+* Bailing out of a prompt gives `None`, so no caller has to catch an error to
+* learn that I walked away. The prompt itself decides what a `Some` carries.
+*/
+const orNone = (prompt) => Effect.catchTag(prompt, "QuitError", () => Effect.succeedNone);
+/**
+* What a prompt looks like in this tool: the marker the rows already use, and
+* the same colour for the choice I am standing on.
+*
+* It is set here rather than at each prompt, because this module is the only
+* thing that opens one and four prompts that themed themselves would be four
+* looks.
+*/
+const theme = (paint) => paint === plain ? {
+	prefix: "▸",
+	pointer: "●"
+} : {
+	prefix: "▸",
+	pointer: "●",
+	primaryColor: "cyan",
+	mutedColor: "gray"
+};
+/**
+* What the keyboard does, said under the question.
+*
+* It rides in the message rather than being printed above the prompt, so it
+* leaves with the prompt: a hint that outlives the answer is scrollback I did
+* not ask for.
+*/
+const moves = "↑↓ move · enter choose · q quit";
+const asked$1 = (paint, message) => `${message}\n${paint.dim(moves)}`;
+/** Asks which one of `choices` to act on. */
+const pick = (message, choices) => Effect.flatMap(Paint, (paint) => orNone(Effect.asSome(Prompt.Select({
+	message: asked$1(paint, message),
+	choices,
+	theme: theme(paint)
+}))));
+/**
+* Asks which of `choices` to act on, as many as I like.
+*
+* Nothing is selected to begin with, so what reaches the caller is what I
+* picked rather than what I failed to unpick. Quitting is not the same as
+* picking nothing: it gives `None`.
+*/
+const choose = (message, choices) => Effect.flatMap(Paint, (paint) => orNone(Effect.asSome(Prompt.MultiSelect({
+	message: `${message}\n${paint.dim("↑↓ move · space pick · enter confirm · q quit")}`,
+	choices,
+	theme: theme(paint)
+}))));
+/**
+* Asks a yes-or-no question about something that cannot be taken back.
+*
+* It starts on no, and walking away is no as well: the answer this returns is
+* the one I typed, and every other way out of the prompt leaves the thing
+* undone. A confirmation that defaulted to yes would be one keystroke, which is
+* exactly what it exists to stop being.
+*/
+const confirm = (message) => Effect.flatMap(Paint, (paint) => Effect.map(orNone(Effect.asSome(Prompt.Confirm({
+	message,
+	initial: false,
+	theme: theme(paint)
+}))), Option.getOrElse(() => false)));
+/**
+* Asks for a line of prose, where having nothing to say is the ordinary answer.
+*
+* An empty line is no note, and that is not a failure: the prompt is optional
+* by design. Quitting is the one thing it does not swallow. Ctrl-C part way
+* through a list of notes means I want out of the whole command, and a prompt
+* that turned it into "no note" would walk me through the rest of the list and
+* then act on findings I was no longer sure about.
+*/
+const note = (message) => Effect.map(Prompt.String({ message }), (text) => text.trim() === "" ? Option.none() : Option.some(text.trim()));
+/**
+* How wide the screen is, or zero where there is no screen to measure.
+*
+* A prompt has to fit its row on one line: a row that wraps takes the list's
+* alignment with it. Nothing is piping into a prompt, so zero means the writing
+* is going somewhere that does not wrap either.
+*/
+const width = Effect.gen(function* () {
+	return yield* (yield* Terminal.Terminal).columns;
+});
+//#endregion
 //#region src/adapters/heartbeat.ts
 /** The frames of the spinner, in the order they turn. */
 const frames = [
@@ -1373,92 +1510,6 @@ const prune = Effect.fn("git.prune")(function* (clone) {
 	]));
 });
 //#endregion
-//#region src/adapters/picker.ts
-/**
-* Turns quitting into an answer rather than a failure.
-*
-* Bailing out of a prompt gives `None`, so no caller has to catch an error to
-* learn that I walked away. The prompt itself decides what a `Some` carries.
-*/
-const orNone = (prompt) => Effect.catchTag(prompt, "QuitError", () => Effect.succeedNone);
-/**
-* What a prompt looks like in this tool: the marker the rows already use, and
-* the same colour for the choice I am standing on.
-*
-* It is set here rather than at each prompt, because this module is the only
-* thing that opens one and four prompts that themed themselves would be four
-* looks.
-*/
-const theme = (paint) => paint === plain ? {
-	prefix: "▸",
-	pointer: "●"
-} : {
-	prefix: "▸",
-	pointer: "●",
-	primaryColor: "cyan",
-	mutedColor: "gray"
-};
-/**
-* What the keyboard does, said under the question.
-*
-* It rides in the message rather than being printed above the prompt, so it
-* leaves with the prompt: a hint that outlives the answer is scrollback I did
-* not ask for.
-*/
-const moves = "↑↓ move · enter choose · q quit";
-const asked$1 = (paint, message) => `${message}\n${paint.dim(moves)}`;
-/** Asks which one of `choices` to act on. */
-const pick = (message, choices) => Effect.flatMap(Paint, (paint) => orNone(Effect.asSome(Prompt.Select({
-	message: asked$1(paint, message),
-	choices,
-	theme: theme(paint)
-}))));
-/**
-* Asks which of `choices` to act on, as many as I like.
-*
-* Nothing is selected to begin with, so what reaches the caller is what I
-* picked rather than what I failed to unpick. Quitting is not the same as
-* picking nothing: it gives `None`.
-*/
-const choose = (message, choices) => Effect.flatMap(Paint, (paint) => orNone(Effect.asSome(Prompt.MultiSelect({
-	message: `${message}\n${paint.dim("↑↓ move · space pick · enter confirm · q quit")}`,
-	choices,
-	theme: theme(paint)
-}))));
-/**
-* Asks a yes-or-no question about something that cannot be taken back.
-*
-* It starts on no, and walking away is no as well: the answer this returns is
-* the one I typed, and every other way out of the prompt leaves the thing
-* undone. A confirmation that defaulted to yes would be one keystroke, which is
-* exactly what it exists to stop being.
-*/
-const confirm = (message) => Effect.flatMap(Paint, (paint) => Effect.map(orNone(Effect.asSome(Prompt.Confirm({
-	message,
-	initial: false,
-	theme: theme(paint)
-}))), Option.getOrElse(() => false)));
-/**
-* Asks for a line of prose, where having nothing to say is the ordinary answer.
-*
-* An empty line is no note, and that is not a failure: the prompt is optional
-* by design. Quitting is the one thing it does not swallow. Ctrl-C part way
-* through a list of notes means I want out of the whole command, and a prompt
-* that turned it into "no note" would walk me through the rest of the list and
-* then act on findings I was no longer sure about.
-*/
-const note = (message) => Effect.map(Prompt.String({ message }), (text) => text.trim() === "" ? Option.none() : Option.some(text.trim()));
-/**
-* How wide the screen is, or zero where there is no screen to measure.
-*
-* A prompt has to fit its row on one line: a row that wraps takes the list's
-* alignment with it. Nothing is piping into a prompt, so zero means the writing
-* is going somewhere that does not wrap either.
-*/
-const width = Effect.gen(function* () {
-	return yield* (yield* Terminal.Terminal).columns;
-});
-//#endregion
 //#region src/cli/table.ts
 /**
 * The rows of a table, padded so the columns line up and with the trailing
@@ -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.
 *
@@ -1545,7 +1598,7 @@ const plan = (inventory) => {
 	};
 };
 /** What the whole state directory weighs: the clones, the checkouts and the records. */
-const everything = (inventory) => sum([
+const everything$1 = (inventory) => sum([
 	...inventory.clones.map((it) => it.size),
 	...inventory.cuttings.map((it) => it.size),
 	inventory.records.size
@@ -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
@@ -1772,6 +1825,10 @@ const PrView = Schema.fromJsonString(Schema.Struct({
 	reviewDecision: Schema.String,
 	statusCheckRollup: Schema.NullOr(Schema.Array(CheckEntry))
 }));
+/**
+* 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:
@@ -1962,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,
@@ -1979,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() === "" ? [] : [{
@@ -2151,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",
@@ -2189,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.
@@ -2199,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;
 };
 /**
@@ -2536,7 +2606,7 @@ const skippedSince = (asked, docsOnly) => {
 	return changed === null || worthRerunning(changed, docsOnly) ? null : asked.last.head;
 };
 /** What a run was opened on, as the report says it. */
-const askedOf$1 = (run) => run.command === null ? "the tool's own prompt" : [run.command, run.effort].filter((part) => part !== null).join(" ");
+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.
 *
@@ -2548,7 +2618,7 @@ const reportDocument = (run, title, prose) => [
 	`# ${run.repo}#${run.number} ${title}`,
 	"",
 	`- head: ${run.head}`,
-	`- run: ${askedOf$1(run)}`,
+	`- run: ${askedOf$2(run)}`,
 	`- ran: ${DateTime.formatIso(run.ranAt)}`,
 	"",
 	prose.trim(),
@@ -2721,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,
@@ -2733,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.
@@ -2750,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.
@@ -2809,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 = Flag.Boolean("all").pipe(Flag.withDefault(false), Flag.withDescription("Print the whole conversation, including what is resolved, outdated and already answered"));
+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}`;
 /**
@@ -2857,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
-}, 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. */
@@ -3484,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",
@@ -3920,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);
@@ -3940,8 +4178,48 @@ 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
+const one = (repo, registered) => ({
+	_tag: "covers",
+	repos: [repo],
+	leftOut: registered.length - 1
+});
+/**
+* The repositories a sweep covers.
+*
+* Standing in a registered repository is asking for that one, because that is
+* the table I want while I work there. Standing anywhere else asks for nothing
+* in particular, so it gets every registered repository, as it would have
+* before a sweep could be narrowed at all.
+*
+* `here` is the repository the working directory is in, and is only read when
+* neither flag decides.
+*/
+const covered = (asked, here, registered) => {
+	if (asked.repo !== void 0 && asked.all) return {
+		_tag: "refused",
+		why: "--repo names one repository and --all asks for every one. Pass one of them."
+	};
+	if (asked.repo !== void 0) {
+		if (registered.includes(asked.repo)) return one(asked.repo, registered);
+		return {
+			_tag: "refused",
+			why: registered.length === 0 ? `${asked.repo} is not registered. Run dw-mc init inside it to register it.` : `${asked.repo} is not registered. Name one of ${registered.join(", ")}, or run dw-mc init inside it.`
+		};
+	}
+	if (!asked.all && here !== void 0 && registered.includes(here)) return one(here, registered);
+	return {
+		_tag: "covers",
+		repos: registered,
+		leftOut: 0
+	};
+};
+/** Whether the working directory decides the coverage, which is the one case worth asking `gh` where it is. */
+const asksWhereIAm = (asked, registered) => asked.repo === void 0 && !asked.all && registered.length > 0;
+//#endregion
 //#region src/domain/flaky.ts
 /**
 * The failures that are flaky wherever they appear: a machine, a network or a
@@ -4233,6 +4511,13 @@ const recordConflict = Effect.fn("rebase.recordConflict")(function* (repo, numbe
 });
 //#endregion
 //#region src/cli/sweep.ts
+/** What the picker asks a sweep for: every registered repository, wherever I stand. */
+const everything = {
+	repo: void 0,
+	all: true
+};
+/** The repository I stand in, or none where the working directory is not one. */
+const whereIAm = currentRepo.pipe(Effect.asSome, Effect.catchTag("NoRepository", () => Effect.succeedNone), Effect.map(Option.getOrUndefined));
 const writtenBy = (comments, login) => comments.filter((comment) => comment.login === login).map((comment) => comment.at);
 const byHumansOtherThan = (comments, login) => comments.filter((comment) => !comment.bot && comment.login !== login).map((comment) => comment.at);
 /**
@@ -4275,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);
@@ -4306,7 +4592,8 @@ const saying$1 = (swept) => (since) => [
 	since
 ].join(" · ");
 /**
-* One pass over every tracked PR, and nothing else: a sweep only ever reads.
+* One pass over the tracked PRs of the repositories `asked` covers, and nothing
+* else: a sweep only ever reads.
 *
 * Every repository and every pull request is read on its own, so one of them
 * failing costs me its rows and leaves the rest of the table standing. What
@@ -4316,11 +4603,15 @@ const saying$1 = (swept) => (since) => [
 * that is worth saying is the caller's, which is why it is handed a count and
 * not a sentence.
 */
-const sweep = Effect.fn("sweep")(function* (report) {
+const sweep = Effect.fn("sweep")(function* (asked, report) {
 	const file = Option.getOrElse(yield* read, () => ({}));
-	const repos = Object.keys(file.repos ?? {}).toSorted();
+	const registered = Object.keys(file.repos ?? {}).toSorted();
+	const coverage = covered(asked, asksWhereIAm(asked, registered) ? yield* whereIAm : void 0, registered);
+	if (coverage._tag === "refused") return yield* new CliError.UserError({ cause: coverage.why });
+	const { repos, leftOut } = coverage;
 	if (repos.length === 0) return {
 		repos,
+		leftOut,
 		facts: [],
 		troubles: []
 	};
@@ -4356,6 +4647,7 @@ const sweep = Effect.fn("sweep")(function* (report) {
 	}), { concurrency }));
 	return {
 		repos,
+		leftOut,
 		facts: swept.got,
 		troubles: [...found.troubles, ...swept.troubles]
 	};
@@ -4367,7 +4659,25 @@ const sweep = Effect.fn("sweep")(function* (report) {
 * three times over. It gives the heartbeat no aside, so a piped `dw-mc status`
 * prints exactly what it printed before there was a heartbeat at all.
 */
-const sweeping = beating((since) => `sweeping · ${since}`, (says) => sweep((swept) => says(saying$1(swept))));
+const sweeping = (asked) => beating((since) => `sweeping · ${since}`, (says) => sweep(asked, (swept) => says(saying$1(swept))));
+/** `--repo`, for a command that sweeps: the one registered repository to cover. */
+const repoFlag = Flag.String("repo").pipe(Flag.withDescription("Cover this registered repository only, as owner/name, wherever I stand"), Flag.optional);
+/** `--all`, for a command that sweeps: every registered repository, even from inside one. */
+const allFlag = Flag.Boolean("all").pipe(Flag.withDefault(false), Flag.withDescription("Cover every registered repository, and not only the one I stand in"));
+/** What the two flags ask a sweep to cover. */
+const askedOf$1 = (flags) => ({
+	repo: Option.getOrUndefined(flags.repo),
+	all: flags.all
+});
+/**
+* The word a narrowed report owes me about what it left out, so a table of one
+* repository is not read as the whole picture.
+*/
+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.`);
+});
 /** 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;
@@ -4376,16 +4686,20 @@ const printTroubles = Effect.fn("sweep.printTroubles")(function* (troubles) {
 	for (const trouble of troubles) yield* Console.log(`  ${trouble.where}  ${trouble.detail}`);
 });
 /**
-* Refreshes what mission control knows about every tracked PR.
+* Refreshes what mission control knows about the tracked PRs it covers.
 *
 * `dw-mc status` does this too, so this command is for the pass on its own:
 * warming the state directory, or seeing what GitHub would not answer.
 */
-const sweepCommand = Command.make("sweep", {}, Effect.fn("sweep.command")(function* () {
-	const report = yield* sweeping;
+const sweepCommand = Command.make("sweep", {
+	repo: repoFlag,
+	all: allFlag
+}, Effect.fn("sweep.command")(function* (flags) {
+	const report = yield* sweeping(askedOf$1(flags));
 	yield* Console.log(report.repos.length === 0 ? "No repositories registered. Run dw-mc init inside a repository to register it." : `Swept ${count(report.facts.length, "pull request")} across ${repositories(report.repos.length)}`);
+	yield* printLeftOut(report);
 	yield* printTroubles(report.troubles);
-}, Effect.catchTag(userFacing, asUserError))).pipe(Command.withDescription("Refresh what mission control knows about every tracked pull request"));
+}, Effect.catchTag(userFacing, asUserError))).pipe(Command.withDescription("Refresh what mission control knows about the tracked pull requests of the repository I stand in, or of every one"));
 //#endregion
 //#region src/domain/pick.ts
 /**
@@ -4522,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;
@@ -4547,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.
 *
@@ -4560,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] ?? "",
@@ -4603,7 +5025,7 @@ const where = (facts) => `${facts.repo}#${facts.number}`;
 * and a merge must never cost only that (ADR 0008).
 */
 const picker = (dispatch) => Effect.fn("pick")(function* () {
-	const report = yield* sweeping;
+	const report = yield* sweeping(everything);
 	if (report.repos.length === 0) {
 		yield* Console.log("No repositories registered. Run dw-mc init inside a repository to register it.");
 		return;
@@ -4623,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)));
@@ -5290,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.
 *
@@ -5297,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);
@@ -5307,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
 		];
 	});
 };
@@ -5316,17 +5752,23 @@ const lines = (grouped, stamped, paint) => {
 *
 * It sweeps first, every time: a table I read is never one I forgot to refresh.
 */
-const status = Command.make("status", {}, Effect.fn("status")(function* () {
-	const report = yield* sweeping;
+const status = Command.make("status", {
+	repo: repoFlag,
+	all: allFlag
+}, Effect.fn("status")(function* (flags) {
+	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.");
 		return;
 	}
 	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 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"));
@@ -5382,7 +5824,7 @@ const uninstall = Command.make("uninstall", {
 	}] : [])).pipe(Effect.map((found_) => found_.flat()));
 	yield* Effect.forEach(removes({
 		directory: found.directory,
-		size: weight(everything(found))
+		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));
@@ -5409,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.5.1";
+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 = [
@@ -5422,6 +5864,7 @@ const subcommands = [
 	rerun,
 	resolve,
 	merge,
+	forgetCommand,
 	sweepCommand,
 	status,
 	stampCommand,