dw-mc 0.4.0 → 0.5.0

package/dist/bin.js

@@ -112,13 +112,21 @@ const encodeYaml = (value) => {
 	return `${out.join("\n")}\n`;
 };
 //#endregion
-//#region src/adapters/config.ts
+//#region src/terms/review.ts
+/**
+* The words a review run is described in.
+*
+* What a run opens on and how much it spends are facts about Claude Code, and
+* how much a finding weighs is a rule of mine, but all three are read on both
+* sides of the adapter seam: the domain writes the turn and weighs the
+* findings, the adapter spawns the turn and is held to the same words.
+*/
 /**
 * How much a review run spends, in the words the slash command takes.
 *
-* The set is Claude Code's and not this tool's, so it is wider than the three
-* words a review used to be held to: a run that would be worth `max` is one I
-* should be able to ask for without spelling the whole command out.
+* The set is Claude Code's and not this tool's, so it is wider than three
+* words: a run that would be worth `max` is one I should be able to ask for
+* without spelling the whole command out.
 */
 const Effort = Schema.Literals([
 	"low",
@@ -133,6 +141,8 @@ const Severity = Schema.Literals([
 	"warning",
 	"info"
 ]);
+//#endregion
+//#region src/adapters/config.ts
 /**
 * What one section of the file may say. Every key is optional: what the file
 * leaves out is inherited rather than reset, so `defaults` and a repository's
@@ -657,6 +667,71 @@ const tidy = Effect.fn("store.tidy")(function* (directory, upTo) {
 		at = path.dirname(at);
 	}
 });
+//#endregion
+//#region src/adapters/heartbeat.ts
+/** The frames of the spinner, in the order they turn. */
+const frames = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+/** How long one frame is on the screen. */
+const frameFor = Duration.millis(120);
+/** A stretch of time as a terminal says it: `1m12s`, or `9s` under the minute. */
+const elapsed = (millis) => {
+	const seconds = Math.floor(millis / 1e3);
+	return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m${String(seconds % 60).padStart(2, "0")}s`;
+};
+/**
+* Runs `use` while one line says the work is still going, and hands `use` the
+* way to say how that line reads.
+*
+* Work that takes seconds and prints nothing while it does is work I stop
+* trusting. What the screen showed instead was either silence or a line per
+* step, and a wall of `· Bash` says as little as silence did. This keeps one
+* line and rewrites it: the spinner says the work is alive, the words say how
+* far it has got, and the line is gone when the work is over, so what stays on
+* the screen is the report.
+*
+* What the line counts is the command's and not this module's business. A
+* review counts tools, a sweep counts pull requests, and a command reading two
+* guards counts nothing at all - and a screen that worded any of them here
+* would need the words a command already has.
+*
+* Where there is no screen to measure - a pipe, a CI log, a test - a rewritten
+* line would be a mess of half-drawn ones, so nothing is drawn. What goes out
+* instead is whatever `aside` the command gives, one to a line, and where it
+* gives none the output is what it was before there was a heartbeat at all.
+* `columns` is zero exactly there.
+*/
+const beating = Effect.fnUntraced(function* (from, use) {
+	const terminal = yield* Terminal.Terminal;
+	const columns = yield* terminal.columns;
+	if (columns === 0) return yield* use((_, aside) => aside === void 0 ? Effect.void : Console.log(aside));
+	const started = yield* Clock.currentTimeMillis;
+	const draw = (text) => Effect.ignore(terminal.display(`\r${text.slice(0, columns - 1).padEnd(columns - 1)}`));
+	let reads = from;
+	let at = 0;
+	/** The line as it stands: this frame of the spinner, and the latest wording. */
+	const paint = Effect.flatMap(Clock.currentTimeMillis, (now) => draw(`${frames[at % frames.length]} ${reads(elapsed(now - started))}`));
+	const says = (next) => Effect.andThen(Effect.sync(() => void (reads = next)), paint);
+	yield* paint;
+	const beat = yield* Effect.forkChild(Effect.gen(function* () {
+		for (;;) {
+			yield* Effect.sleep(frameFor);
+			at = at + 1;
+			yield* paint;
+		}
+	}));
+	return yield* Effect.onExit(use(says), () => Effect.flatMap(Fiber.interrupt(beat), () => Effect.ignore(terminal.display(`\r${" ".repeat(columns - 1)}\r`))));
+});
 new TextEncoder();
 /** A program that ran but ended badly. */
 var CommandFailed = class extends Schema.TaggedError()("CommandFailed", {
@@ -739,41 +814,56 @@ var WorktreeHeld = class extends Schema.TaggedError()("WorktreeHeld", {
 * The head comes from the pull request's ref rather than from what a sweep last
 * saw, so what is cut is the commit the run really reads.
 */
+/**
+* How the heartbeat of a cut reads.
+*
+* The stages are named apart because a first clone and a hundredth fetch take
+* wildly different times, and the line is what explains the difference: a
+* `cloning` that sits there for two minutes is a large repository arriving
+* once, not a tool that has hung.
+*/
+const cutting = (what, repo) => (since) => `${what} ${repo} · ${since}`;
 const whereToCut = Effect.fn("git.whereToCut")(function* (repo, number, cut) {
 	const path = yield* Path.Path;
 	const state = yield* stateDirectory;
 	const clone = path.join(state, clonesIn, `${repo}.git`);
-	if ((yield* Effect.orElseSucceed(git([
+	const bare = yield* Effect.orElseSucceed(git([
 		"-C",
 		clone,
 		"rev-parse",
 		"--is-bare-repository"
-	]), () => "")) !== "true") yield* git([
-		"clone",
-		"--bare",
-		"--filter=blob:none",
-		`https://github.com/${repo}.git`,
-		clone
-	]);
+	]), () => "");
 	const pullRef = `refs/dw-mc/pr/${number}`;
-	yield* git([
-		"-C",
-		clone,
-		"fetch",
-		"--no-tags",
-		"--force",
-		"origin",
-		`+refs/pull/${number}/head:${pullRef}`,
-		"+refs/heads/*:refs/heads/*"
-	]);
 	return {
 		clone,
-		head: yield* git([
-			"-C",
-			clone,
-			"rev-parse",
-			pullRef
-		]),
+		head: yield* beating(cutting(bare === "true" ? "fetching" : "cloning", repo), (says) => Effect.gen(function* () {
+			if (bare !== "true") {
+				yield* git([
+					"clone",
+					"--bare",
+					"--filter=blob:none",
+					`https://github.com/${repo}.git`,
+					clone
+				]);
+				yield* says(cutting("fetching", repo));
+			}
+			yield* git([
+				"-C",
+				clone,
+				"fetch",
+				"--no-tags",
+				"--force",
+				"origin",
+				`+refs/pull/${number}/head:${pullRef}`,
+				"+refs/heads/*:refs/heads/*"
+			]);
+			return yield* git([
+				"-C",
+				clone,
+				"rev-parse",
+				pullRef
+			]);
+		})),
 		directory: path.join(state, cut, repo, String(number))
 	};
 });
@@ -798,7 +888,7 @@ const withWorktree = Effect.fn("git.withWorktree")(function* (repo, number, use)
 		"--force",
 		directory
 	]));
-	return yield* Effect.acquireUseRelease(Effect.flatMap(remove, () => git([
+	return yield* Effect.acquireUseRelease(beating(cutting("cutting a worktree of", repo), () => Effect.flatMap(remove, () => git([
 		"-C",
 		clone,
 		"worktree",
@@ -806,7 +896,7 @@ const withWorktree = Effect.fn("git.withWorktree")(function* (repo, number, use)
 		"--detach",
 		directory,
 		head
-	])), () => use({
+	]))), () => use({
 		directory,
 		head
 	}), () => remove);
@@ -950,7 +1040,7 @@ const standingWorktree = Effect.fn("git.standingWorktree")(function* (repo, numb
 	]);
 	yield* perWorktreeConfig(clone);
 	if (session === "rebase") yield* reuseResolutions(clone);
-	yield* git([
+	yield* beating(cutting("cutting a worktree of", repo), () => git([
 		"-C",
 		clone,
 		"worktree",
@@ -959,7 +1049,7 @@ const standingWorktree = Effect.fn("git.standingWorktree")(function* (repo, numb
 		branch,
 		directory,
 		head
-	]);
+	]));
 	yield* git([
 		"-C",
 		clone,
@@ -1482,7 +1572,7 @@ const lines$3 = (it, state, path, paint) => {
 const cleanup = Command.make("cleanup", { yes: yesFlag }, Effect.fn("cleanup")(function* ({ yes }) {
 	const path = yield* Path.Path;
 	const paint = yield* Paint;
-	const found = yield* inventory;
+	const found = yield* beating((since) => `measuring the state directory · ${since}`, () => inventory);
 	const it = plan(found);
 	if (empty(it)) {
 		yield* Console.log(`Nothing to take back in ${found.directory}.`);
@@ -1925,7 +2015,15 @@ const isSame = (self, other) => self === null || other === null ? self === other
 /** The latest of many, or never when there are none. */
 const newest = (moments) => moments.reduce(later, null);
 //#endregion
-//#region src/domain/bucket.ts
+//#region src/terms/pr.ts
+/**
+* What GitHub says about a pull request, in this tool's words.
+*
+* The three of them are here because both sides need the same one: `gh` and the
+* checks adapter answer in these words, and the bucket rules decide on them. A
+* union restated on each side is a case that goes unreachable the day the other
+* side gains a member.
+*/
 /** How far GitHub has got towards letting a tracked PR merge. */
 const Mergeability = Schema.Literals([
 	"mergeable",
@@ -1946,6 +2044,8 @@ const ChecksState = Schema.Literals([
 	"pending",
 	"none"
 ]);
+//#endregion
+//#region src/domain/bucket.ts
 /**
 * Everything the bucket rules are allowed to know about a tracked PR.
 *
@@ -2161,6 +2261,20 @@ const swept = Effect.fn("pr.swept")(function* (repo, number) {
 	if (Option.isNone(facts)) return yield* new CliError.UserError({ cause: `Nothing is known about ${repo}#${number} yet. Run dw-mc sweep first.` });
 	return facts.value;
 });
+/**
+* The guard reads of one command, under a heartbeat.
+*
+* Every command that acts on a pull request reads its guards live rather than
+* off the last sweep, because each of them is about the pull request as it is
+* now. That read is a second or two against GitHub before a word can be
+* printed, and it used to be spent on a blank screen.
+*
+* There is nothing to count here - two or three calls, and a number counting to
+* three says less than the words do - so the line is what is being read and how
+* long it has taken. It gives the heartbeat no aside, so a piped command prints
+* what it always printed.
+*/
+const reading = (where, read) => beating((since) => `reading ${where} · ${since}`, () => read);
 //#endregion
 //#region src/cli/row.ts
 /**
@@ -2885,7 +2999,7 @@ const short = (head) => head.slice(0, 7);
 * Where a run is kept: one key per head, so a run and the code it read cannot
 * drift apart, and a re-review replaces the run before it.
 */
-const runKey = (repo, number, head) => `${repo}#${number}@${head}`;
+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`;
 /**
@@ -2899,7 +3013,7 @@ const reportKey = (repo, number, head) => `${runKey(repo, number, head)}.md`;
 */
 const LastReviewed = Schema.Struct({ head: Schema.String });
 /** Where that head is kept. No head is spelled `latest`, so nothing collides. */
-const latestKey = (repo, number) => `${repo}#${number}@latest`;
+const latestKey = (repo, number) => `${prKey(repo, number)}@latest`;
 /**
 * The run at one head, or none where nothing has reviewed it.
 *
@@ -3010,11 +3124,11 @@ const blockingIn = (run, blocksOn) => {
 * 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 reviewedAt = Effect.fn("review.reviewedAt")(function* (repo, number, head, settings) {
+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, settings.stamp.blocks_on).length
+		blockingFindings: blockingIn(run, blocksOn).length
 	};
 });
 //#endregion
@@ -3037,7 +3151,7 @@ const sweepPr = Effect.fn("sweep.pullRequest")(function* (store, me, found, sett
 	const newestHumanCommentAt = newest(byHumansOtherThan(comments, me));
 	const key = prKey(found.repo, found.number);
 	const previous = Option.getOrUndefined(yield* Effect.orElseSucceed(store.get(key), () => Option.none()));
-	const reviewed = yield* reviewedAt(found.repo, found.number, view.headRefOid, settings);
+	const reviewed = yield* reviewedAt(found.repo, found.number, view.headRefOid, settings.stamp.blocks_on);
 	const quiet = previous !== void 0 && isQuiet(pulseOf(previous), {
 		head: view.headRefOid,
 		checks,
@@ -3083,14 +3197,26 @@ const gather = (attempts) => ({
 });
 /** How many reads of GitHub are in flight at once. */
 const concurrency = 4;
+/** `n` repositories, which `count` cannot say: the plural is not the noun plus s. */
+const repositories = (n) => n === 1 ? "1 repository" : `${n} repositories`;
+/** How the heartbeat of a sweep reads, wherever a command turns one. */
+const saying$1 = (swept) => (since) => [
+	"sweeping",
+	swept._tag === "searching" ? `${swept.done} of ${repositories(swept.of)}` : `${swept.done} of ${count(swept.of, "pull request")}`,
+	since
+].join(" · ");
 /**
 * One pass over every tracked PR, 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
 * failed comes back beside the facts rather than instead of them.
+*
+* `report` is told how far the pass has got, every time it gets further. What
+* that is worth saying is the caller's, which is why it is handed a count and
+* not a sentence.
 */
-const sweep = Effect.gen(function* () {
+const sweep = Effect.fn("sweep")(function* (report) {
 	const file = Option.getOrElse(yield* read, () => ({}));
 	const repos = Object.keys(file.repos ?? {}).toSorted();
 	if (repos.length === 0) return {
@@ -3100,14 +3226,48 @@ const sweep = Effect.gen(function* () {
 	};
 	const store = yield* storeFor("prs", Facts);
 	const me = yield* viewer;
-	const found = gather(yield* Effect.forEach(repos, (repo) => attempt(repo, searchPrs(repo)), { concurrency }));
-	const swept = gather(yield* Effect.forEach(found.got, (pr) => attempt(`${pr.repo}#${pr.number}`, Effect.map(sweepPr(store, me, pr, settingsFor(file, pr.repo)), (facts) => [facts])), { concurrency }));
+	let searched = 0;
+	yield* report({
+		_tag: "searching",
+		done: 0,
+		of: repos.length
+	});
+	const found = gather(yield* Effect.forEach(repos, (repo) => Effect.tap(attempt(repo, searchPrs(repo)), () => {
+		searched = searched + 1;
+		return report({
+			_tag: "searching",
+			done: searched,
+			of: repos.length
+		});
+	}), { concurrency }));
+	let read$1 = 0;
+	yield* report({
+		_tag: "reading",
+		done: 0,
+		of: found.got.length
+	});
+	const swept = gather(yield* Effect.forEach(found.got, (pr) => Effect.tap(attempt(`${pr.repo}#${pr.number}`, Effect.map(sweepPr(store, me, pr, settingsFor(file, pr.repo)), (facts) => [facts])), () => {
+		read$1 = read$1 + 1;
+		return report({
+			_tag: "reading",
+			done: read$1,
+			of: found.got.length
+		});
+	}), { concurrency }));
 	return {
 		repos,
 		facts: swept.got,
 		troubles: [...found.troubles, ...swept.troubles]
 	};
-}).pipe(Effect.withSpan("sweep"));
+});
+/**
+* A sweep under its heartbeat, which is how every command that sweeps runs one.
+*
+* The three of them want the same line, so they say it once here rather than
+* three times over. It gives the heartbeat no aside, so a piped `dw-mc status`
+* prints exactly what it printed before there was a heartbeat at all.
+*/
+const sweeping = beating((since) => `sweeping · ${since}`, (says) => sweep((swept) => says(saying$1(swept))));
 /**
 * The failures a sweep can hit before it has a single row, which are the ones
 * worth a sentence: a machine or a file that needs fixing says what to fix
@@ -3135,7 +3295,7 @@ const printTroubles = Effect.fn("sweep.printTroubles")(function* (troubles) {
 * warming the state directory, or seeing what GitHub would not answer.
 */
 const sweepCommand = Command.make("sweep", {}, Effect.fn("sweep.command")(function* () {
-	const report = yield* sweep;
+	const report = yield* sweeping;
 	yield* Console.log(report.repos.length === 0 ? "No repositories registered. Run dw-mc init inside a repository to register it." : `Swept ${count(report.facts.length, "pull request")} across ${report.repos.length === 1 ? "1 repository" : `${report.repos.length} repositories`}`);
 	yield* printTroubles(report.troubles);
 }, Effect.catchTag(userFacing, asUserError))).pipe(Command.withDescription("Refresh what mission control knows about every tracked pull request"));
@@ -3256,7 +3416,7 @@ const comments = Command.make("comments", {
 	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
 	const facts = yield* swept(repo, number);
 	const paint = yield* Paint;
-	const view = shown(yield* prConversation(repo, number), {
+	const view = shown(yield* reading(`${repo}#${number}`, prConversation(repo, number)), {
 		since: later(facts.myLastCommentAt, facts.myLastCommitAt),
 		all
 	});
@@ -3842,7 +4002,7 @@ const fix = Command.make("fix", {
 	const found = yield* whatItFound(run);
 	yield* Console.log(header$1(run, found, settings.stamp.blocks_on));
 	if (found.findings.length === 0) return;
-	const view = yield* prView(repo, number);
+	const view = yield* reading(`${repo}#${number}`, prView(repo, number));
 	yield* fixable(number, run.head, view.headRefOid);
 	const picked = yield* choose("Which findings does the session carry?", choicesOf$1(found, yield* width));
 	const chosen = yield* Effect.catchTag(noted(Option.getOrElse(picked, () => [])), "QuitError", () => Effect.succeed([]));
@@ -4132,8 +4292,7 @@ const merge = Command.make("merge", { pr: prArgument }, Effect.fn("merge")(funct
 	const file = Option.getOrElse(yield* read, () => ({}));
 	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
 	const settings = settingsFor(file, repo);
-	const view = yield* prView(repo, number);
-	const me = yield* viewer;
+	const [view, me] = yield* reading(`${repo}#${number}`, Effect.all([prView(repo, number), viewer]));
 	const head = view.headRefOid;
 	yield* refuse(decide$2({
 		repo,
@@ -4144,7 +4303,7 @@ const merge = Command.make("merge", { pr: prArgument }, Effect.fn("merge")(funct
 		reviewDecision: reviewDecisionOf(view.reviewDecision),
 		checks: rollupState(view.statusCheckRollup, settings.ci.ignore),
 		mergeable: mergeabilityOf(view.mergeable),
-		...yield* reviewedAt(repo, number, head, settings),
+		...yield* reviewedAt(repo, number, head, settings.stamp.blocks_on),
 		withdrawnAt: yield* withdrawnAt(repo, number)
 	}));
 	yield* mergePr(repo, number);
@@ -4370,7 +4529,7 @@ const where = (facts) => `${facts.repo}#${facts.number}`;
 * and a merge must never cost only that (ADR 0008).
 */
 const picker = (dispatch) => Effect.fn("pick")(function* () {
-	const report = yield* sweep;
+	const report = yield* sweeping;
 	if (report.repos.length === 0) {
 		yield* Console.log("No repositories registered. Run dw-mc init inside a repository to register it.");
 		return;
@@ -4436,9 +4595,11 @@ const rebase = Command.make("rebase", { pr: prArgument }, Effect.fn("rebase")(fu
 	const file = Option.getOrElse(yield* read, () => ({}));
 	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
 	const settings = settingsFor(file, repo);
-	const view = yield* prView(repo, number);
-	const open = yield* openPrs(repo);
-	const me = yield* viewer;
+	const [view, open, me] = yield* reading(`${repo}#${number}`, Effect.all([
+		prView(repo, number),
+		openPrs(repo),
+		viewer
+	]));
 	yield* refuse(decide$3({
 		repo,
 		number,
@@ -4497,8 +4658,7 @@ const rerun = Command.make("rerun", { pr: prArgument }, Effect.fn("rerun")(funct
 	const file = Option.getOrElse(yield* read, () => ({}));
 	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
 	const settings = settingsFor(file, repo);
-	const view = yield* prView(repo, number);
-	const me = yield* viewer;
+	const [view, me] = yield* reading(`${repo}#${number}`, Effect.all([prView(repo, number), viewer]));
 	const unclassified = {
 		repo,
 		number,
@@ -4616,9 +4776,11 @@ const resolve = Command.make("resolve", {
 }, Effect.fn("resolve")(function* ({ pr, print }) {
 	const file = Option.getOrElse(yield* read, () => ({}));
 	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
-	const view = yield* prView(repo, number);
-	const open = yield* openPrs(repo);
-	const me = yield* viewer;
+	const [view, open, me] = yield* reading(`${repo}#${number}`, Effect.all([
+		prView(repo, number),
+		openPrs(repo),
+		viewer
+	]));
 	const conflict = yield* conflictFor(repo, number);
 	yield* allowed({
 		repo,
@@ -4701,73 +4863,6 @@ const announce = Effect.fn("notify.announce")(function* (title, message) {
 	yield* Effect.ignore(capture("osascript", ["-e", `display notification ${quoted(message)} with title ${quoted(title)}`]));
 });
 //#endregion
-//#region src/adapters/progress.ts
-/** The frames of the spinner, in the order they turn. */
-const frames = [
-	"⠋",
-	"⠙",
-	"⠹",
-	"⠸",
-	"⠼",
-	"⠴",
-	"⠦",
-	"⠧",
-	"⠇",
-	"⠏"
-];
-/** How long one frame is on the screen. */
-const frameFor = Duration.millis(120);
-/** A stretch of time as a terminal says it: `1m12s`, or `9s` under the minute. */
-const elapsed = (millis) => {
-	const seconds = Math.floor(millis / 1e3);
-	return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m${String(seconds % 60).padStart(2, "0")}s`;
-};
-/**
-* Runs `use` while the screen says it is still going, and hands `use` the way
-* to report what the run reached for.
-*
-* A review takes minutes, and a terminal that prints nothing for minutes is one
-* I stop trusting. What it printed instead was a line per tool call, which is a
-* wall of `· Bash` that says as little as silence did. This keeps one line and
-* rewrites it: the spinner says the run is alive, the counts say how far it has
-* got, and the line is gone when the run is over, so what stays on the screen is
-* the report.
-*
-* How that line reads is `reads` and not this module's business. What a count
-* is worth saying belongs to the command that is counting, and a screen that
-* worded it here would need the words a command already has.
-*
-* Where there is no screen to measure - a pipe, a CI log, a test - the counts
-* would be a mess of half-drawn lines, so the tools go out one to a line as
-* they did before. `columns` is zero exactly there.
-*/
-const spinning = Effect.fnUntraced(function* (reads, use) {
-	const terminal = yield* Terminal.Terminal;
-	const columns = yield* terminal.columns;
-	if (columns === 0) return yield* use((tool) => Console.log(`  · ${tool}`));
-	let doing = {
-		tools: 0,
-		subagents: 0
-	};
-	const onTool = (tool) => Effect.sync(() => {
-		doing = {
-			tools: doing.tools + 1,
-			subagents: doing.subagents + (tool === "Agent" ? 1 : 0)
-		};
-	});
-	const started = yield* Clock.currentTimeMillis;
-	const draw = (text) => Effect.ignore(terminal.display(`\r${text.slice(0, columns - 1).padEnd(columns - 1)}`));
-	const frame = (since, turn) => `${frames[turn % frames.length]} ${reads(doing, elapsed(since))}`;
-	yield* draw(frame(0, 0));
-	const turning = yield* Effect.forkChild(Effect.gen(function* () {
-		for (let turn = 1;; turn = turn + 1) {
-			yield* Effect.sleep(frameFor);
-			yield* draw(frame((yield* Clock.currentTimeMillis) - started, turn));
-		}
-	}));
-	return yield* Effect.onExit(use(onTool), () => Effect.flatMap(Fiber.interrupt(turning), () => Effect.ignore(terminal.display(`\r${" ".repeat(columns - 1)}\r`))));
-});
-//#endregion
 //#region src/domain/persona.ts
 /**
 * The reviewer persona, derived from Addy Osmani's `code-reviewer` agent
@@ -4859,8 +4954,8 @@ const turnFor = (review, about) => review.command === null ? {
 };
 //#endregion
 //#region src/cli/review.ts
-/** What the spinner says a run has got through, while it is still going. */
-const saying = (doing, since) => [
+/** What the heartbeat says a run has got through, while it is still going. */
+const saying = (doing) => (since) => [
 	"reviewing",
 	count(doing.tools, "tool"),
 	doing.subagents === 0 ? null : count(doing.subagents, "subagent"),
@@ -4925,13 +5020,23 @@ const spending = (turn, model) => [
 */
 const reviewOn = Effect.fn("review.reviewOn")(function* (options) {
 	const { directory, launcher, model, turn } = options;
-	const run = yield* spinning(saying, (onTool) => reviewTurns({
+	let doing = {
+		tools: 0,
+		subagents: 0
+	};
+	const run = yield* beating(saying(doing), (says) => reviewTurns({
 		launcher,
 		directory,
 		turn,
 		model,
 		jsonSchema,
-		onTool
+		onTool: (tool) => {
+			doing = {
+				tools: doing.tools + 1,
+				subagents: doing.subagents + (tool === "Agent" ? 1 : 0)
+			};
+			return says(saying(doing), `  · ${tool}`);
+		}
 	}));
 	const answered = Result.isFailure(run.findings) ? Effect.fail(run.findings.failure) : Effect.succeed(run.findings.success);
 	const reported = yield* Effect.result(Effect.flatMap(answered, (output) => Schema.decodeUnknownEffect(Reported)(output)));
@@ -5157,7 +5262,7 @@ const lines = (grouped, stamped, paint) => {
 * It sweeps first, every time: a table I read is never one I forgot to refresh.
 */
 const status = Command.make("status", {}, Effect.fn("status")(function* () {
-	const report = yield* sweep;
+	const report = yield* sweeping;
 	if (report.repos.length === 0) {
 		yield* Console.log("No repositories registered. Run dw-mc init inside a repository to register it.");
 		return;
@@ -5249,7 +5354,7 @@ const uninstall = Command.make("uninstall", {
 * Running from source leaves the constant undeclared rather than undefined, so
 * the check has to be `typeof` and the fallback is what a test reads.
 */
-const version = "0.4.0";
+const version = "0.5.0";
 /** Where the project lives, printed beside the version in the header. */
 const projectUrl = "github.com/dominikwozniak/dw-mc";
 const subcommands = [