dw-mc 0.3.0 → 0.5.0

package/dist/bin.js

@@ -112,26 +112,28 @@ const encodeYaml = (value) => {
 	return `${out.join("\n")}\n`;
 };
 //#endregion
-//#region src/adapters/config.ts
+//#region src/terms/review.ts
 /**
-* What a review run executes: the agent's own review command, or the tool's own
-* review prompt on one of the two agent CLIs.
+* The words a review run is described in.
 *
-* `builtin` and `prompt` run on the launcher, which is Claude Code. `codex`
-* runs the same prompt on the Codex CLI, and is the second opinion: configured
-* beside one of the others, its findings inform me without gating my bar.
+* 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 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 runners = [
-	"builtin",
-	"prompt",
-	"codex"
-];
-const Runner = Schema.Literals(runners);
-/** How much a built-in review run spends. */
 const Effort = Schema.Literals([
 	"low",
 	"medium",
-	"high"
+	"high",
+	"xhigh",
+	"max"
 ]);
 /** How much a finding weighs. */
 const Severity = Schema.Literals([
@@ -139,10 +141,8 @@ const Severity = Schema.Literals([
 	"warning",
 	"info"
 ]);
-const PathInstruction = Schema.Struct({
-	path: Schema.String,
-	instructions: Schema.String
-});
+//#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
@@ -151,12 +151,11 @@ const PathInstruction = Schema.Struct({
 const SettingsPatch = Schema.Struct({
 	base: Schema.optionalKey(Schema.NullOr(Schema.String)),
 	review: Schema.optionalKey(Schema.Struct({
-		runners: Schema.optionalKey(Schema.Array(Runner)),
-		effort: Schema.optionalKey(Effort),
+		command: Schema.optionalKey(Schema.NullOr(Schema.String)),
+		effort: Schema.optionalKey(Schema.NullOr(Effort)),
+		prompt: Schema.optionalKey(Schema.NullOr(Schema.String)),
 		model: Schema.optionalKey(Schema.NullOr(Schema.String)),
-		skill: Schema.optionalKey(Schema.NullOr(Schema.String)),
-		docs_only: Schema.optionalKey(Schema.Array(Schema.String)),
-		path_instructions: Schema.optionalKey(Schema.Array(PathInstruction))
+		docs_only: Schema.optionalKey(Schema.Array(Schema.String))
 	})),
 	ci: Schema.optionalKey(Schema.Struct({
 		ignore: Schema.optionalKey(Schema.Array(Schema.String)),
@@ -164,16 +163,12 @@ const SettingsPatch = Schema.Struct({
 	})),
 	fix: Schema.optionalKey(Schema.Struct({ commits: Schema.optionalKey(Schema.Boolean) })),
 	rebase: Schema.optionalKey(Schema.Struct({ enabled: Schema.optionalKey(Schema.Boolean) })),
-	stamp: Schema.optionalKey(Schema.Struct({
-		blocks_on: Schema.optionalKey(Severity),
-		supporting_blocks: Schema.optionalKey(Schema.Boolean)
-	}))
+	stamp: Schema.optionalKey(Schema.Struct({ blocks_on: Schema.optionalKey(Severity) }))
 });
-/** How this machine starts a runner, where it does not start `claude` itself. */
+/** How this machine starts Claude Code, where it does not start `claude` itself. */
 const LauncherPatch = Schema.Struct({
 	command: Schema.optionalKey(Schema.Array(Schema.String).pipe(Schema.check(Schema.isMinLength(1, { message: "Expected the launcher command to name a program" })))),
-	fix_args: Schema.optionalKey(Schema.Array(Schema.String)),
-	codex: Schema.optionalKey(Schema.Array(Schema.String).pipe(Schema.check(Schema.isMinLength(1, { message: "Expected the codex command to name a program" }))))
+	fix_args: Schema.optionalKey(Schema.Array(Schema.String))
 });
 /** A repository, as `gh` spells it: `owner/name`. */
 const Repo = Schema.String.pipe(Schema.check(Schema.isPattern(/^[^\s/]+\/[^\s/]+$/, { message: "Expected a repository as owner/name" })));
@@ -187,12 +182,11 @@ const ConfigFile = Schema.Struct({
 const builtIn = {
 	base: null,
 	review: {
-		runners: ["builtin"],
+		command: "/code-review",
 		effort: "low",
+		prompt: null,
 		model: null,
-		skill: null,
-		docs_only: ["**/*.md", "docs/**"],
-		path_instructions: []
+		docs_only: ["**/*.md", "docs/**"]
 	},
 	ci: {
 		ignore: [],
@@ -200,16 +194,12 @@ const builtIn = {
 	},
 	fix: { commits: false },
 	rebase: { enabled: false },
-	stamp: {
-		blocks_on: "error",
-		supporting_blocks: false
-	}
+	stamp: { blocks_on: "error" }
 };
-/** `claude` and `codex` themselves, which is what a machine that spawns them directly needs. */
+/** `claude` itself, which is what a machine that spawns it directly needs. */
 const builtInLauncher = {
 	command: ["claude"],
-	fix_args: [],
-	codex: ["codex"]
+	fix_args: []
 };
 /**
 * The patch's value where it has one, the inherited value otherwise. A key the
@@ -220,12 +210,11 @@ const over = (patch, inherited) => patch === void 0 ? inherited : patch;
 const apply = (settings, patch) => patch === void 0 ? settings : {
 	base: over(patch.base, settings.base),
 	review: {
-		runners: over(patch.review?.runners, settings.review.runners),
+		command: over(patch.review?.command, settings.review.command),
 		effort: over(patch.review?.effort, settings.review.effort),
+		prompt: over(patch.review?.prompt, settings.review.prompt),
 		model: over(patch.review?.model, settings.review.model),
-		skill: over(patch.review?.skill, settings.review.skill),
-		docs_only: over(patch.review?.docs_only, settings.review.docs_only),
-		path_instructions: over(patch.review?.path_instructions, settings.review.path_instructions)
+		docs_only: over(patch.review?.docs_only, settings.review.docs_only)
 	},
 	ci: {
 		ignore: over(patch.ci?.ignore, settings.ci.ignore),
@@ -233,10 +222,7 @@ const apply = (settings, patch) => patch === void 0 ? settings : {
 	},
 	fix: { commits: over(patch.fix?.commits, settings.fix.commits) },
 	rebase: { enabled: over(patch.rebase?.enabled, settings.rebase.enabled) },
-	stamp: {
-		blocks_on: over(patch.stamp?.blocks_on, settings.stamp.blocks_on),
-		supporting_blocks: over(patch.stamp?.supporting_blocks, settings.stamp.supporting_blocks)
-	}
+	stamp: { blocks_on: over(patch.stamp?.blocks_on, settings.stamp.blocks_on) }
 };
 /**
 * `delta` over `patch`, keeping every key `delta` does not mention.
@@ -290,18 +276,16 @@ const withRepo = (file, repo, patch) => ({
 	}
 });
 /**
-* What this machine starts a runner with: the file's launcher over `claude`.
+* What this machine starts Claude Code with: the file's launcher over `claude`.
 *
 * It is no repository's business. What spawns the agent CLI is a fact of the
 * machine, which is why it sits beside `defaults` rather than inside it.
 */
 const launcherOf = (file) => {
 	const [program = builtInLauncher.command[0], ...prefix] = file.launcher?.command ?? [];
-	const [codex = builtInLauncher.codex[0], ...codexPrefix] = file.launcher?.codex ?? [];
 	return {
 		command: [program, ...prefix],
-		fix_args: file.launcher?.fix_args ?? builtInLauncher.fix_args,
-		codex: [codex, ...codexPrefix]
+		fix_args: file.launcher?.fix_args ?? builtInLauncher.fix_args
 	};
 };
 /** What `repo` is worth: its own overrides over the global defaults. */
@@ -349,6 +333,43 @@ var ConfigMalformed = class extends Schema.TaggedError()("ConfigMalformed", {
 	}
 };
 const reasonOf = (cause) => cause instanceof Error ? cause.message : String(cause);
+/** The keys an earlier version had, read off a file loosely enough to find them. */
+const LegacySection = Schema.Struct({
+	review: Schema.optionalKey(Schema.Struct({
+		runners: Schema.optionalKey(Schema.Unknown),
+		skill: Schema.optionalKey(Schema.Unknown),
+		path_instructions: Schema.optionalKey(Schema.Unknown)
+	})),
+	stamp: Schema.optionalKey(Schema.Struct({ supporting_blocks: Schema.optionalKey(Schema.Unknown) }))
+});
+const Legacy = Schema.Struct({
+	launcher: Schema.optionalKey(Schema.Struct({ codex: Schema.optionalKey(Schema.Unknown) })),
+	defaults: Schema.optionalKey(LegacySection),
+	repos: Schema.optionalKey(Schema.Record(Schema.String, LegacySection))
+});
+const asLegacy = Schema.decodeUnknownOption(Legacy);
+/**
+* What a file from an earlier version says, and what to do about each of it.
+*
+* The excess-property error names a key and stops there, which is enough for a
+* key that is simply gone and not enough for one that moved: `review.skill` is
+* `review.prompt` now, and a file quietly stripped of it is a review brief lost.
+* This is here to be deleted once no file has those keys left.
+*/
+const legacyIn = (decided) => {
+	const legacy = asLegacy(decided);
+	if (Option.isNone(legacy)) return null;
+	const sections = [legacy.value.defaults, ...Object.values(legacy.value.repos ?? {})];
+	const spelled = (says) => sections.some((section) => section !== void 0 && says(section) !== void 0);
+	const said = [
+		legacy.value.launcher?.codex === void 0 ? null : "launcher.codex is gone: reviews run on Claude Code alone.",
+		spelled((section) => section.review?.runners) ? "review.runners is gone: a head carries one review run, which review.command configures." : null,
+		spelled((section) => section.review?.skill) ? "review.skill is review.prompt now, unchanged in what it does - move the text across rather than losing it." : null,
+		spelled((section) => section.review?.path_instructions) ? "review.path_instructions is gone: nothing ever read it." : null,
+		spelled((section) => section.stamp?.supporting_blocks) ? "stamp.supporting_blocks is gone: there is no second opinion to let through." : null
+	].filter((sentence) => sentence !== null);
+	return said.length === 0 ? null : `it names keys this version does not have.\n${said.join("\n")}`;
+};
 /**
 * The configuration file, or `None` when this machine has none yet.
 *
@@ -368,6 +389,8 @@ const read = Effect.gen(function* () {
 		try: () => Yaml.parse(raw),
 		catch: (cause) => malformed(reasonOf(cause))
 	})) ?? {};
+	const legacy = legacyIn(decided);
+	if (legacy !== null) return yield* malformed(legacy);
 	return Option.some(yield* Schema.decodeUnknownEffect(ConfigFile)(decided, {
 		onExcessProperty: "error",
 		errors: "all"
@@ -381,17 +404,16 @@ const mapping = (entries) => {
 const settingsDocument = (patch) => mapping([
 	["base", patch.base],
 	["review", patch.review === void 0 ? void 0 : mapping([
-		["runners", patch.review.runners],
+		["command", patch.review.command],
 		["effort", patch.review.effort],
+		["prompt", patch.review.prompt],
 		["model", patch.review.model],
-		["skill", patch.review.skill],
-		["docs_only", patch.review.docs_only],
-		["path_instructions", patch.review.path_instructions]
+		["docs_only", patch.review.docs_only]
 	])],
 	["ci", patch.ci === void 0 ? void 0 : mapping([["ignore", patch.ci.ignore], ["flaky_patterns", patch.ci.flaky_patterns]])],
 	["fix", patch.fix === void 0 ? void 0 : mapping([["commits", patch.fix.commits]])],
 	["rebase", patch.rebase === void 0 ? void 0 : mapping([["enabled", patch.rebase.enabled]])],
-	["stamp", patch.stamp === void 0 ? void 0 : mapping([["blocks_on", patch.stamp.blocks_on], ["supporting_blocks", patch.stamp.supporting_blocks]])]
+	["stamp", patch.stamp === void 0 ? void 0 : mapping([["blocks_on", patch.stamp.blocks_on]])]
 ]);
 /**
 * The file as a YAML document, in the order of the schema.
@@ -400,11 +422,7 @@ const settingsDocument = (patch) => mapping([
 * keeps the file stable across runs, so a rewrite shows only what changed.
 */
 const fileDocument = (file) => mapping([
-	["launcher", file.launcher === void 0 ? void 0 : mapping([
-		["command", file.launcher.command],
-		["fix_args", file.launcher.fix_args],
-		["codex", file.launcher.codex]
-	])],
+	["launcher", file.launcher === void 0 ? void 0 : mapping([["command", file.launcher.command], ["fix_args", file.launcher.fix_args]])],
 	["defaults", file.defaults === void 0 ? void 0 : settingsDocument(file.defaults)],
 	["repos", file.repos === void 0 ? void 0 : mapping(Object.entries(file.repos).map(([name, patch]) => [name, settingsDocument(patch)]))]
 ]);
@@ -649,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", {
@@ -731,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))
 	};
 });
@@ -790,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",
@@ -798,7 +896,7 @@ const withWorktree = Effect.fn("git.withWorktree")(function* (repo, number, use)
 		"--detach",
 		directory,
 		head
-	])), () => use({
+	]))), () => use({
 		directory,
 		head
 	}), () => remove);
@@ -942,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",
@@ -951,7 +1049,7 @@ const standingWorktree = Effect.fn("git.standingWorktree")(function* (repo, numb
 		branch,
 		directory,
 		head
-	]);
+	]));
 	yield* git([
 		"-C",
 		clone,
@@ -1474,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}.`);
@@ -1917,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",
@@ -1938,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.
 *
@@ -2032,7 +2140,7 @@ const readyReason = (facts) => {
 * This is the single place the bucket rules exist. Every tracked PR lands in
 * exactly one bucket, so the rules are tried in priority order and the first
 * that claims the PR wins: a PR that both needs a review run and has changes
-* requested is mine to move, not the runner's.
+* requested is mine to move, not the review's.
 *
 * Ready does not insist on an approval, because a repository that requires no
 * reviewer never produces one. What it insists on is that nobody else has been
@@ -2153,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
 /**
@@ -2732,11 +2854,12 @@ const recordConflict = Effect.fn("rebase.recordConflict")(function* (repo, numbe
 /** Whether a review run found anything at all. */
 const Verdict = Schema.Literals(["clean", "findings"]);
 /**
-* Every severity word a runner may answer with.
+* Every severity word a review may answer with.
 *
-* The first three are ours, and the only ones a runner is asked for. The rest
-* are the persona the `prompt` runner carries, which grades in its own words:
-* a turn that comes back in them is worth reading rather than throwing away.
+* The first three are ours, and the only ones a run is asked for. The rest are
+* the persona a run with no slash command carries, which grades in its own
+* words: a turn that comes back in them is worth reading rather than throwing
+* away.
 */
 const Spelling = Schema.Literals([
 	"error",
@@ -2809,9 +2932,9 @@ const jsonSchema = JSON.stringify(SchemaRepresentation.toJsonSchemaDocument(Sche
 /**
 * The findings as the Markdown a report is written in.
 *
-* It is what the `prompt` runner's report says: with a schema in force a runner
-* answers in findings and not in prose, so the report kept beside the run is
-* written from the findings themselves rather than left empty.
+* It is what a schema-held run's report says: with a schema in force a run
+* answers in findings and not in prose, so the report kept beside it is written
+* from the findings themselves rather than left empty.
 */
 const asMarkdown = (found) => found.findings.length === 0 ? "Clean: the run found nothing to report." : found.findings.map((finding) => `- \`${finding.file}:${finding.line}\` ${finding.severity}: ${finding.summary}`).join("\n");
 /** Where each severity sits against the others, so the bar can be compared with it. */
@@ -2842,7 +2965,7 @@ const Outcome = Schema.Union([Schema.TaggedStruct("reported", {
 	findings: Schema.Array(Finding)
 }), Schema.TaggedStruct("failed", { detail: Schema.String })]);
 /**
-* One execution of a runner against a tracked PR at a specific head commit.
+* One review run against a tracked PR at a specific head commit.
 *
 * It is a schema because a review run outlives the command that started it: the
 * state directory is where the next sweep learns that this head has been
@@ -2853,13 +2976,18 @@ const ReviewRun = Schema.Struct({
 	number: Schema.Int,
 	/** The head the run covers. A run never vouches for code it did not see. */
 	head: Schema.String,
-	runner: Runner,
-	effort: Effort,
+	/**
+	* The slash command line the run opened on, or null where it opened on the
+	* tool's own prompt. A report found months later says what it was asked, and a
+	* record an earlier version wrote carries no such field and is forgotten.
+	*/
+	command: Schema.NullOr(Schema.String),
+	effort: Schema.NullOr(Effort),
 	/**
 	* The agent session the run happened in, or null where it never reached one.
 	*
-	* A runner that would not start or exited before it said anything has no
-	* session, and the run is still recorded: a failure is recorded as what it is.
+	* A run that would not start or exited before it said anything has no session,
+	* and the run is still recorded: a failure is recorded as what it is.
 	*/
 	sessionId: Schema.NullOr(Schema.String),
 	ranAt: Schema.DateTimeUtcFromString,
@@ -2868,17 +2996,12 @@ const ReviewRun = Schema.Struct({
 /** A head as it is read out loud: the seven characters git itself abbreviates to. */
 const short = (head) => head.slice(0, 7);
 /**
-* Where a run is kept: one key per head and runner, so a run and the code it
-* read cannot drift apart, and a re-review on the same runner replaces the run
-* before it.
-*
-* The runner is in the key because a head can carry two opinions: the review
-* that is my bar and the second one beside it. Without it the second opinion
-* would overwrite the first and the stamp would rest on whichever ran last.
+* 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, runner) => `${repo}#${number}@${head}:${runner}`;
+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, runner) => `${runKey(repo, number, head, runner)}.md`;
+const reportKey = (repo, number, head) => `${runKey(repo, number, head)}.md`;
 /**
 * Which head a pull request was last reviewed at: an index beside `runKey` and
 * `reportKey` rather than a thing the glossary names.
@@ -2890,35 +3013,27 @@ const reportKey = (repo, number, head, runner) => `${runKey(repo, number, head,
 */
 const LastReviewed = Schema.Struct({ head: Schema.String });
 /** Where that head is kept. No head is spelled `latest`, so nothing collides. */
-const latestKey = (repo, number, runner) => `${repo}#${number}@latest:${runner}`;
+const latestKey = (repo, number) => `${prKey(repo, number)}@latest`;
 /**
-* The last review run of one runner on a pull request, or none where it has had
-* none.
+* The run at one head, or none where nothing has reviewed it.
 *
-* It is per runner because the re-run rule is: a second opinion that has never
-* seen this pull request is not skipped because the primary review saw it.
+* A head is where the question is asked - the stamp, the bucket and `dw-mc
+* findings` all ask about one commit - and one read off the disk answers it
+* without an index to keep in step.
 *
 * A run this version cannot read is a run another version of this record wrote,
 * and the state directory is a cache of work that can be done again: forgetting
 * it costs one review, where failing here would cost me the command I asked for.
 */
-const lastRun = Effect.fn("review.lastRun")(function* (repo, number, runner) {
-	const heads = yield* storeFor("runs", LastReviewed);
-	const at = yield* Effect.orElseSucceed(heads.get(latestKey(repo, number, runner)), () => Option.none());
-	if (Option.isNone(at)) return Option.none();
+const runAt = Effect.fn("review.runAt")(function* (repo, number, head) {
 	const runs = yield* storeFor("runs", ReviewRun);
-	return yield* Effect.orElseSucceed(runs.get(runKey(repo, number, at.value.head, runner)), () => Option.none());
+	return yield* Effect.orElseSucceed(runs.get(runKey(repo, number, head)), () => Option.none());
 });
-/**
-* Every runner's run at one head, in the order the runners are named.
-*
-* A head is where the question is asked - the stamp, the bucket and `dw-mc
-* findings` all ask about one commit - and a head may carry a run from each
-* runner. Three reads off the disk answer it without an index to keep in step.
-*/
-const runsAt = Effect.fn("review.runsAt")(function* (repo, number, head) {
-	const runs = yield* storeFor("runs", ReviewRun);
-	return (yield* Effect.forEach(runners, (runner) => Effect.orElseSucceed(runs.get(runKey(repo, number, head, runner)), () => Option.none()))).flatMap((run) => Option.isSome(run) ? [run.value] : []);
+/** The last review run on a pull request, or none where it has had none. */
+const lastRun = Effect.fn("review.lastRun")(function* (repo, number) {
+	const heads = yield* storeFor("runs", LastReviewed);
+	const at = yield* Effect.orElseSucceed(heads.get(latestKey(repo, number)), () => Option.none());
+	return Option.isNone(at) ? Option.none() : yield* runAt(repo, number, at.value.head);
 });
 /**
 * What a run reported, or null where it reported nothing at all.
@@ -2964,73 +3079,38 @@ const skippedSince = (asked, docsOnly) => {
 	const changed = asked.last.head === asked.head ? [] : asked.changed;
 	return changed === null || worthRerunning(changed, docsOnly) ? null : asked.last.head;
 };
+/** What a run was opened on, as the report says it. */
+const askedOf$1 = (run) => run.command === null ? "the tool's own prompt" : [run.command, run.effort].filter((part) => part !== null).join(" ");
 /**
-* The report as it is written down: what it is of, then what the runner said.
+* The report as it is written down: what it is of, then what the run said.
 *
 * The heading is the whole point of writing it rather than storing the prose
 * alone - a file found months later says which pull request, which commit and
-* how much the run spent, without anything else having to be open.
+* what the run was asked, without anything else having to be open.
 */
 const reportDocument = (run, title, prose) => [
 	`# ${run.repo}#${run.number} ${title}`,
 	"",
 	`- head: ${run.head}`,
-	`- runner: ${run.runner}, effort ${run.effort}`,
+	`- run: ${askedOf$1(run)}`,
 	`- ran: ${DateTime.formatIso(run.ranAt)}`,
 	"",
 	prose.trim(),
 	""
 ].join("\n");
 /**
-* The runners one review run executes, in the order the file names them and
-* without repeats.
+* Whether `head` has the review it needs.
 *
-* The order is the precedence everything downstream reads: it is the order the
-* runners run in, and the first of them is the run `dw-mc findings` and a fix
-* session reach for when I do not name one.
+* A run that reported nothing does not count, which is the same rule
+* `reportedBy` draws everywhere else: a failure has found nothing, not found
+* nothing wrong.
 */
-const runnersFor = (configured) => [...new Set(configured)];
-/** Which agent CLI a runner reaches. `builtin` and `prompt` are Claude Code's. */
-const onCodex = (runner) => runner === "codex";
-/**
-* The configured runners that are a second opinion rather than my bar.
-*
-* Codex is supporting because something else is the review: a machine that
-* configured Codex alone did not ask for a second opinion, it asked for a
-* review, and nothing there could ever earn a stamp if this called it
-* supporting.
-*/
-const supportingIn = (configured) => {
-	const all = runnersFor(configured);
-	return all.some((runner) => !onCodex(runner)) ? all.filter(onCodex) : [];
-};
-/**
-* The configured runners whose findings decide the stamp.
-*
-* A second opinion informs me without gating my bar, which is what
-* `stamp.supporting_blocks` turns off: set, every configured runner decides.
-*/
-const decidingIn = (configured, supportingBlocks) => {
-	const all = runnersFor(configured);
-	if (supportingBlocks) return all;
-	const supporting = supportingIn(configured);
-	return all.filter((runner) => !supporting.includes(runner));
-};
-/**
-* Whether `head` has the review it needs: every deciding runner has reported on
-* it.
-*
-* Every rather than any, because a pull request reviewed by half of what I
-* configured is one that still waits on the other half. A run that reported
-* nothing does not count, which is the same rule `reportedBy` draws everywhere
-* else: a failure has found nothing, not found nothing wrong.
-*/
-const reviewedBy = (runs, deciding) => deciding.length > 0 && deciding.every((runner) => runs.some((run) => run.runner === runner && reportedBy(run) !== null));
-/** The findings at one head that withhold the stamp, from the runners that decide it. */
-const blockingIn = (runs, deciding, blocksOn) => runs.filter((run) => deciding.includes(run.runner)).flatMap((run) => {
-	const found = reportedBy(run);
+const reviewedBy = (run) => run !== null && reportedBy(run) !== null;
+/** The findings at one head that withhold the stamp. */
+const blockingIn = (run, blocksOn) => {
+	const found = run === null ? null : reportedBy(run);
 	return found === null ? [] : blocking(found.findings, blocksOn);
-});
+};
 /**
 * What the review runs on `head` say about it, for the stamp to rest on.
 *
@@ -3040,20 +3120,15 @@ const blockingIn = (runs, deciding, blocksOn) => runs.filter((run) => deciding.i
 * report findings does not count either: its verdict is what takes a pull
 * request out of Needs review run, and it reached none.
 *
-* A head may carry a run from each configured runner, and it is reviewed once
-* every runner that decides my bar has reported on it. A second opinion's
-* findings are read here only where `stamp.supporting_blocks` lets them block.
-*
 * It is one function because the two callers are a sweep and `dw-mc merge`, and
 * the second exists to land what the first only describes: two spellings of
 * this would be two answers to whether a head has been reviewed.
 */
-const reviewedAt = Effect.fn("review.reviewedAt")(function* (repo, number, head, settings) {
-	const deciding = decidingIn(settings.review.runners, settings.stamp.supporting_blocks);
-	const runs = yield* runsAt(repo, number, head);
+const reviewedAt = Effect.fn("review.reviewedAt")(function* (repo, number, head, blocksOn) {
+	const run = Option.getOrNull(yield* runAt(repo, number, head));
 	return {
-		reviewRunHead: reviewedBy(runs, deciding) ? head : null,
-		blockingFindings: blockingIn(runs, deciding, settings.stamp.blocks_on).length
+		reviewRunHead: reviewedBy(run) ? head : null,
+		blockingFindings: blockingIn(run, blocksOn).length
 	};
 });
 //#endregion
@@ -3076,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,
@@ -3122,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 {
@@ -3139,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
@@ -3174,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"));
@@ -3247,9 +3368,8 @@ const separated = (blocks) => blocks.flatMap((lines, index) => index === 0 ? lin
 * The conversation on screen: people first, then a rule, then the bots.
 *
 * The rule is there so the two are never read as one list. A bot's comment is
-* observed and never answered, which is the same asymmetry between a deciding
-* and a supporting runner the glossary already draws, and the bucket rules
-* ignore bots for exactly this reason.
+* observed and never answered, and the bucket rules ignore bots for exactly
+* this reason.
 *
 * A bot is cut at the same moment I am measured against, because the window is
 * what has happened since I last acted rather than what is owed an answer. A
@@ -3296,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
 	});
@@ -3312,7 +3432,6 @@ const comments = Command.make("comments", {
 //#region src/cli/findings.ts
 /** The findings as the JSON the schema defines, rather than as this file spells it. */
 const asJson$2 = Schema.encodeEffect(Schema.fromJsonString(Findings));
-const runnerFlag$1 = Flag.Literals("runner", [...runners]).pipe(Flag.withDescription("Which runner's findings to print, over the first the repository configured"), Flag.optional);
 const jsonFlag = Flag.Boolean("json").pipe(Flag.withDefault(false), Flag.withDescription("Print the findings as the JSON a fix session is handed"));
 /** What a run's findings come to in one line, against the bar that blocks. */
 const summary = (found, blocksOn) => {
@@ -3321,10 +3440,10 @@ const summary = (found, blocksOn) => {
 	return `${count(found.findings.length, "finding")}, ${blocked} blocking`;
 };
 /** Which run these findings are, and what they come to: the line above the list. */
-const header$1 = (run, found, blocksOn) => `${run.repo}#${run.number}  ${short(run.head)}  ${run.runner}  ${summary(found, blocksOn)}`;
+const header$1 = (run, found, blocksOn) => `${run.repo}#${run.number}  ${short(run.head)}  ${summary(found, blocksOn)}`;
 /**
-* The findings one to a line, in the order the runner reported them, ruled so
-* the three columns read apart.
+* The findings one to a line, in the order the run reported them, ruled so the
+* three columns read apart.
 */
 const lines$1 = (found) => table(found.findings.map((finding) => [
 	`${finding.file}:${finding.line}`,
@@ -3339,17 +3458,10 @@ const lines$1 = (found) => table(found.findings.map((finding) => [
 * off the state directory rather than worked out from GitHub: this command is
 * one I run inside a fix session, where another round trip to GitHub buys
 * nothing the run it is about to fix does not already say.
-*
-* Which run, where a head carries more than one, is the first of `runners` that
-* has one - the order the repository names them in, unless I name one myself.
-* A second opinion is worth reading and is not what I fix by default.
 */
-const currentRun = Effect.fn("findings.currentRun")(function* (repo, number, configured) {
-	for (const runner of runnersFor(configured)) {
-		const run = yield* lastRun(repo, number, runner);
-		if (Option.isSome(run)) return run.value;
-	}
-	return yield* asUserError(`No review run on ${repo}#${number}. Run dw-mc review ${number} first.`);
+const currentRun = Effect.fn("findings.currentRun")(function* (repo, number) {
+	const run = yield* lastRun(repo, number);
+	return Option.isSome(run) ? run.value : yield* asUserError(`No review run on ${repo}#${number}. Run dw-mc review ${number} first.`);
 });
 /**
 * What the run reported, or the sentence saying it reported nothing at all.
@@ -3374,16 +3486,12 @@ const whatItFound = (run) => {
 */
 const findings = Command.make("findings", {
 	pr: prArgument,
-	runner: runnerFlag$1,
 	json: jsonFlag
-}, Effect.fn("findings")(function* ({ json, pr, runner }) {
+}, Effect.fn("findings")(function* ({ json, pr }) {
 	const file = Option.getOrElse(yield* read, () => ({}));
 	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
 	const settings = settingsFor(file, repo);
-	const run = yield* currentRun(repo, number, Option.match(runner, {
-		onNone: () => settings.review.runners,
-		onSome: (only) => [only]
-	}));
+	const run = yield* currentRun(repo, number);
 	const found = yield* whatItFound(run);
 	if (json) {
 		yield* Console.log(yield* asJson$2(found));
@@ -3395,19 +3503,20 @@ const findings = Command.make("findings", {
 //#endregion
 //#region src/adapters/agent.ts
 /**
-* How one turn of an agent CLI is spawned and given up on, and what a turn of
-* the tool's own review prompt comes back with.
+* How one turn of Claude Code is spawned and given up on, and what a turn that
+* answers against a schema comes back with.
 *
-* Both agent CLIs are reached this way, so the spawn, the patience and the one
-* failure they can end in live here rather than once per CLI.
+* Every turn is reached this way, so the spawn, the patience and the one failure
+* they can end in live here rather than once per turn.
 */
 /** A review run that would not start, would not finish, or finished badly. */
-var RunnerFailed = class extends Schema.TaggedError()("RunnerFailed", {
-	runner: Schema.String,
+var AgentFailed = class extends Schema.TaggedError()("AgentFailed", {
+	/** The program that was spawned, which is what a search for it has to name. */
+	program: Schema.String,
 	detail: Schema.String
 }) {
 	get message() {
-		return `The ${this.runner} review run failed: ${this.detail}`;
+		return `The ${this.program} review run failed: ${this.detail}`;
 	}
 };
 /**
@@ -3417,15 +3526,15 @@ var RunnerFailed = class extends Schema.TaggedError()("RunnerFailed", {
 * program that would not start or exited badly, and saying `claude` sends the
 * search to the wrong process.
 */
-const failedBy = (program) => (detail) => new RunnerFailed({
-	runner: program,
+const failedBy = (program) => (detail) => new AgentFailed({
+	program,
 	detail
 });
 /**
 * How long each turn gets before it is given up on.
 *
 * The review is the turn that thinks, and a high-effort one that fans out to
-* subagents takes real minutes, so its limit is there to catch a runner that has
+* subagents takes real minutes, so its limit is there to catch a run that has
 * stopped rather than one that is slow. The second turn reads no code and
 * decides nothing - the review it reports on is already in the session it
 * resumes - and every run of it by hand came back in seconds.
@@ -3442,9 +3551,9 @@ const patience = {
 *
 * The launcher's own arguments go in front of the turn's, because they are what
 * gets `claude` started at all. The two output streams are drained together,
-* because draining one to the end first can block a runner that is still writing
-* to the other. Every way a turn can fail to finish comes back from here as a
-* `RunnerFailed`, so a caller is left with the turn's own answer and nothing else
+* because draining one to the end first can block a run that is still writing to
+* the other. Every way a turn can fail to finish comes back from here as a
+* `AgentFailed`, so a caller is left with the turn's own answer and nothing else
 * to translate - a turn that never comes back included.
 */
 const turn = Effect.fnUntraced(function* (options) {
@@ -3454,7 +3563,7 @@ const turn = Effect.fnUntraced(function* (options) {
 	const running = Effect.gen(function* () {
 		const handle = yield* Effect.mapError(spawner.spawn(ChildProcess.make(program, [...prefix, ...options.args], {
 			cwd: options.directory,
-			stdin: options.stdin ?? "pipe"
+			stdin: "pipe"
 		})), (error) => failed(error.message));
 		const [got, stderr] = yield* Effect.mapError(Effect.all([options.read(handle.stdout), Stream.mkString(Stream.decodeText(handle.stderr))], { concurrency: 2 }), (error) => failed(error.message));
 		const exitCode = yield* Effect.mapError(handle.exitCode, (error) => failed(error.message));
@@ -3467,118 +3576,10 @@ const turn = Effect.fnUntraced(function* (options) {
 	});
 });
 //#endregion
-//#region src/adapters/codex.ts
-/**
-* The events of a `codex exec --json` run this reads, as it really writes them.
-*
-* Every other field and every other event is ignored, the same way the Claude
-* Code transcript is read: a run carries reasoning, tool results and a usage
-* report, and a Codex version that adds another event must not stop a run from
-* being read.
-*/
-const CodexEvent = Schema.Struct({
-	type: Schema.String,
-	/** On `thread.started`: the session the run happens in. */
-	thread_id: Schema.optionalKey(Schema.String),
-	item: Schema.optionalKey(Schema.Struct({
-		type: Schema.String,
-		/** On an `agent_message`: what the run answered, which the schema makes JSON. */
-		text: Schema.optionalKey(Schema.String)
-	}))
-});
-const asCodexEvent = Schema.decodeUnknownOption(Schema.fromJsonString(CodexEvent));
-/**
-* What Codex reached for, as the item types it reports it in.
-*
-* A run says it is alive by what it does, and what Codex does is run shell
-* commands, change files and call tools. Its own words for those are what the
-* progress line prints, so nothing here has to pretend Codex is Claude Code.
-*/
-const codexTool = {
-	command_execution: "shell",
-	file_change: "edit",
-	mcp_tool_call: "tool",
-	web_search: "search"
-};
-/**
-* One review run of the same prompt on the Codex CLI, in `directory`.
-*
-* This is the second opinion, so it answers the same schema and is recorded as
-* the same review run: everything downstream - the stamp, the buckets, `dw-mc
-* findings`, a fix session - cannot tell which CLI read the code.
-*
-* Codex takes its schema as a file and never inline, which is the mirror image
-* of Claude Code, so the schema is written to a temporary file that lives as
-* long as the run. Standard input is closed because `codex exec` reads it to
-* the end and appends it to the prompt. The sandbox is read-only: a review
-* reads, and a review run of mine has no business writing in the worktree it
-* was cut into.
-*
-* There is no prose: with a schema in force every message Codex sends is the
-* JSON the schema describes, so what it found is all there is, and the report
-* kept beside the run is written from the findings themselves.
-*/
-const codexReview = Effect.fn("runner.codexReview")(function* (options) {
-	const [program] = options.launcher.codex;
-	const failed = failedBy(program);
-	const fs = yield* FileSystem.FileSystem;
-	const schemaFile = yield* Effect.mapError(fs.makeTempFileScoped({
-		prefix: "dw-mc-findings-",
-		suffix: ".json"
-	}), (error) => failed(error.message));
-	yield* Effect.mapError(fs.writeFileString(schemaFile, options.jsonSchema), (error) => failed(error.message));
-	const run = yield* turn({
-		command: options.launcher.codex,
-		directory: options.directory,
-		patience: {
-			turn: "the review",
-			duration: patience.reviewing
-		},
-		stdin: "ignore",
-		args: [
-			"exec",
-			"--json",
-			"--output-schema",
-			schemaFile,
-			"--sandbox",
-			"read-only",
-			...options.model === null ? [] : ["--model", options.model],
-			options.prompt
-		],
-		read: (stdout) => stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.mapEffect((line) => {
-			const event = asCodexEvent(line);
-			const reached = Option.isSome(event) && event.value.type === "item.started" ? codexTool[event.value.item?.type ?? ""] : void 0;
-			return Effect.as(reached === void 0 ? Effect.void : options.onTool(reached), event);
-		}), Stream.runFold(() => ({
-			thread: Option.none(),
-			said: []
-		}), (soFar, event) => {
-			if (Option.isNone(event)) return soFar;
-			const { item, thread_id, type } = event.value;
-			const said = type === "item.completed" && item?.type === "agent_message" && item.text !== void 0 ? [...soFar.said, item.text] : soFar.said;
-			return {
-				thread: Option.orElse(Option.fromUndefinedOr(thread_id), () => soFar.thread),
-				said
-			};
-		}))
-	});
-	if (Option.isNone(run.thread)) return yield* failed("the run never said which thread it was in");
-	const answer = run.said.at(-1);
-	if (answer === void 0) return yield* failed("the run came back with no structured output");
-	return {
-		findings: yield* Effect.try({
-			try: () => JSON.parse(answer),
-			catch: () => failed("the run answered in something that is not JSON")
-		}),
-		sessionId: run.thread.value,
-		prose: null
-	};
-}, Effect.scoped);
-//#endregion
-//#region src/adapters/runner.ts
+//#region src/adapters/claude.ts
 /**
-* Claude Code as a runner: its own review command, the tool's own prompt, and
-* the sessions I steer.
+* Claude Code: a review on a slash command, a review on the tool's own prompt,
+* and the sessions I steer.
 */
 /**
 * The two events of a stream-json run this reads, as the runner really writes
@@ -3594,7 +3595,7 @@ const Working = Schema.Struct({
 		text: Schema.optionalKey(Schema.String)
 	})) })
 });
-const Result$1 = Schema.Struct({
+const Ended = Schema.Struct({
 	type: Schema.Literal("result"),
 	subtype: Schema.String,
 	is_error: Schema.Boolean,
@@ -3604,7 +3605,7 @@ const Result$1 = Schema.Struct({
 	structured_output: Schema.optionalKey(Schema.Unknown)
 });
 const asWorking = Schema.decodeUnknownOption(Schema.fromJsonString(Working));
-const asResult = Schema.decodeUnknownOption(Schema.fromJsonString(Result$1));
+const asResult = Schema.decodeUnknownOption(Schema.fromJsonString(Ended));
 const heardIn = (line) => {
 	const blocks = Option.match(asWorking(line), {
 		onNone: () => [],
@@ -3618,7 +3619,7 @@ const heardIn = (line) => {
 /**
 * The result a turn ended on, or the failure it really was.
 *
-* A turn that said nothing this can read and a turn the runner itself calls an
+* A turn that said nothing this can read and a turn Claude Code itself calls an
 * error are both failures: `subtype` is where a run that hit its turn limit or
 * lost its connection says so, and its `result` is the only word on why.
 */
@@ -3633,8 +3634,8 @@ const ended = (program, result) => {
 * to `onTool` while the run is still going, and what it said and how it ended
 * are what comes back.
 *
-* Both of Claude Code's runners read a turn the same way, so the fold is here
-* rather than once per runner.
+* Both shapes of review read a turn the same way, so the fold is here rather
+* than once per shape.
 */
 const transcript = (onTool) => (stdout) => stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.mapEffect((line) => {
 	const heard = heardIn(line);
@@ -3650,30 +3651,38 @@ const transcript = (onTool) => (stdout) => stdout.pipe(Stream.decodeText(), Stre
 	result: Option.orElse(asResult(line), () => soFar.result)
 })));
 /**
-* One review run of Claude Code's own code review, headless, in `directory`.
+* One review run on a slash command, headless, in `directory`.
 *
 * The run is in the foreground and says what it is doing as it does it, which
 * is what `onTool` is for: a review takes minutes, and a terminal that prints
 * nothing for minutes is one I stop trusting.
 *
+* `--json-schema` is never passed here: verified by running it, the flag beside
+* `/code-review` breaks the run, which is why a slash command costs a second
+* turn that resumes the session and asks for the findings. My own instructions
+* ride on `--append-system-prompt` rather than on the command's own line,
+* because what a slash command does with its arguments is its business and not
+* this tool's.
+*
 * `--comment` is the flag that makes the built-in review post on the pull
-* request, and it is never passed (ADR 0002). The report is everything the
-* runner said on its own turns rather than the `result` alone: verified by
-* running it, a repository whose review command fans out to subagents can end
-* on a remark about them, and the report is the turn before that. The follow-up
-* turn is what turns the prose into findings, and it needs this run's session.
+* request, and it is never passed either (ADR 0002). The report is everything
+* the run said on its own turns rather than the `result` alone: verified by
+* running it, a repository whose review command fans out to subagents can end on
+* a remark about them, and the report is the turn before that.
 */
-const builtinReview = Effect.fn("runner.builtinReview")(function* (options) {
+const commandReview = Effect.fn("claude.commandReview")(function* (options) {
 	const [program] = options.launcher.command;
 	const run = yield* turn({
 		command: options.launcher.command,
 		directory: options.directory,
 		args: [
 			"-p",
-			`/code-review ${options.effort}`,
+			options.line,
 			"--output-format",
 			"stream-json",
-			"--verbose"
+			"--verbose",
+			...options.instructions === null ? [] : ["--append-system-prompt", options.instructions],
+			...options.model === null ? [] : ["--model", options.model]
 		],
 		patience: {
 			turn: "the review",
@@ -3712,12 +3721,12 @@ const reportFindings = [
 * is what makes it cheap and what makes it accurate - verified by running it,
 * the line numbers it reports beat the ones the prose gives. The output is
 * handed on as it arrived: what the findings must look like belongs to the
-* domain, and the schema the runner is held to comes in from there too.
+* domain, and the schema the run is held to comes in from there too.
 *
-* Every way this can end badly ends as a `RunnerFailed`, because a review run
+* Every way this can end badly ends as an `AgentFailed`, because a review run
 * that could not report is a failure and never a clean verdict.
 */
-const builtinFindings = Effect.fn("runner.builtinFindings")(function* (options) {
+const findingsTurn = Effect.fn("claude.findingsTurn")(function* (options) {
 	const [program] = options.launcher.command;
 	const printed = yield* turn({
 		command: options.launcher.command,
@@ -3743,19 +3752,15 @@ const builtinFindings = Effect.fn("runner.builtinFindings")(function* (options)
 	return structured_output;
 }, Effect.scoped);
 /**
-* One review run of the tool's own review prompt on Claude Code, in `directory`.
-*
-* It is one turn rather than two: verified by running it, `--json-schema`
-* beside an ordinary prompt gives both the prose the run wrote and the
-* `structured_output` it validated, where the same flag on the built-in
-* `/code-review` breaks the run. The schema arrives as inline JSON and never as
-* a path - a path is where Claude Code reports `--json-schema is not valid
-* JSON`.
+* One review run of the tool's own review prompt, in `directory`.
 *
-* `review.model` reaches the run here, and nowhere in the built-in runner: the
-* prompt is the tool's, so which model reads the code is mine to choose.
+* It is one turn rather than two: verified by running it, `--json-schema` beside
+* an ordinary prompt gives both the prose the run wrote and the
+* `structured_output` it validated, where the same flag on a slash command
+* breaks the run. The schema arrives as inline JSON and never as a path - a path
+* is where Claude Code reports `--json-schema is not valid JSON`.
 */
-const promptReview = Effect.fn("runner.promptReview")(function* (options) {
+const promptReview = Effect.fn("claude.promptReview")(function* (options) {
 	const [program] = options.launcher.command;
 	const run = yield* turn({
 		command: options.launcher.command,
@@ -3786,13 +3791,53 @@ const promptReview = Effect.fn("runner.promptReview")(function* (options) {
 	};
 }, Effect.scoped);
 /**
-* The tool's own review prompt, on whichever CLI the runner names.
+* One review run, in whichever shape it was configured in.
 *
-* The two CLIs are spawned differently and answer differently, and which of
-* them a runner means is the adapter's knowledge: a caller hands over the
-* runner and gets the same `Reported` back either way.
+* A slash command takes two turns and the tool's own prompt takes one, which is
+* Claude Code's doing and nobody else's: a caller hands over the turn and gets
+* the same answer back either way.
+*
+* The second turn's failure is kept beside the first turn's prose rather than
+* replacing it. A review that ran and could not report is still worth reading,
+* and it is recorded as the failure it is.
 */
-const promptRun = (options) => options.runner === "codex" ? codexReview(options) : promptReview(options);
+const reviewTurns = Effect.fn("claude.reviewTurns")(function* (options) {
+	const { directory, jsonSchema, launcher, model, onTool } = options;
+	if (options.turn._tag === "prompt") {
+		const run = yield* promptReview({
+			launcher,
+			directory,
+			prompt: options.turn.text,
+			model,
+			jsonSchema,
+			onTool
+		});
+		return {
+			sessionId: run.sessionId,
+			prose: run.prose,
+			findings: Result.succeed(run.findings)
+		};
+	}
+	const run = yield* commandReview({
+		launcher,
+		directory,
+		line: options.turn.line,
+		instructions: options.turn.instructions,
+		model,
+		onTool
+	});
+	const findings = yield* Effect.result(findingsTurn({
+		launcher,
+		directory,
+		sessionId: run.sessionId,
+		jsonSchema
+	}));
+	return {
+		sessionId: run.sessionId,
+		prose: run.report,
+		findings
+	};
+});
 /**
 * An interactive `claude` in `directory`, opened on `prompt`, with my terminal
 * handed straight to it.
@@ -3802,7 +3847,7 @@ const promptRun = (options) => options.runner === "codex" ? codexReview(options)
 * no headless review turn wants. They sit in front of the
 * prompt, because `claude` takes its flags before its positional argument.
 *
-* This is the one place a runner is not read: the three streams are inherited,
+* This is the one place a run is not read: the three streams are inherited,
 * so what is on the screen is the session itself and not a transcript of it,
 * and what I type reaches it. The child is not detached for the same reason -
 * a detached child sits outside the terminal's foreground process group, where
@@ -3815,7 +3860,7 @@ const promptRun = (options) => options.runner === "codex" ? codexReview(options)
 * Ctrl-C ended badly for `claude` and not for me, so this reports it rather
 * than failing on it; only a `claude` that would not start at all is a failure.
 */
-const steeredSession = Effect.fn("runner.steeredSession")(function* (options) {
+const steeredSession = Effect.fn("claude.steeredSession")(function* (options) {
 	const [program, ...prefix] = options.launcher.command;
 	const failed = failedBy(program);
 	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
@@ -3860,7 +3905,7 @@ const asJson$1 = Schema.encodeEffect(Schema.fromJsonString(Selection));
 *
 * The findings go in verbatim rather than described, because a re-description
 * is where a file, a line or my own note quietly changes. A note outranks the
-* finding it is on: the finding is what a runner thought, the note is what I
+* finding it is on: the finding is what the review thought, the note is what I
 * think, and I am the one who picked it.
 *
 * Pushing is mine either way, and `commits` says whether committing is too.
@@ -3953,11 +3998,11 @@ const fix = Command.make("fix", {
 	const file = Option.getOrElse(yield* read, () => ({}));
 	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
 	const settings = settingsFor(file, repo);
-	const run = yield* currentRun(repo, number, settings.review.runners);
+	const run = yield* currentRun(repo, number);
 	const found = yield* whatItFound(run);
 	yield* Console.log(header$1(run, found, settings.stamp.blocks_on));
 	if (found.findings.length === 0) return;
-	const view = yield* prView(repo, number);
+	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([]));
@@ -3995,105 +4040,64 @@ const fix = Command.make("fix", {
 	...userFacing,
 	"GitFailed",
 	"WorktreeHeld",
-	"RunnerFailed"
+	"AgentFailed"
 ], asUserError))).pipe(Command.withDescription("Pick findings from the current review run and open a fix session on them"));
 //#endregion
 //#region src/cli/init.ts
-const runnerFlag = Flag.Literals("runner", [...runners]).pipe(Flag.withDescription("Which runner is my bar, on this machine"), Flag.optional);
-const codexFlag = Flag.Boolean("codex").pipe(Flag.withDescription("Ask Codex for a second opinion beside the runner that is my bar"), Flag.optional);
 const effortFlag$1 = Flag.Literals("effort", [
 	"low",
 	"medium",
-	"high"
-]).pipe(Flag.withDescription("How much a built-in review run spends on this repository"), Flag.optional);
+	"high",
+	"xhigh",
+	"max"
+]).pipe(Flag.withDescription("How much a review run spends on this repository"), Flag.optional);
 const baseFlag = Flag.String("base").pipe(Flag.withDescription("The branch this repository's pull requests target, over the default one"), Flag.optional);
-const askRunner = Prompt.Select({
-	message: "Which runner is your bar?",
-	choices: [
-		{
-			title: "builtin",
-			value: "builtin",
-			description: "Claude Code's own code review"
-		},
-		{
-			title: "prompt",
-			value: "prompt",
-			description: "The tool's own review prompt, on Claude Code"
-		},
-		{
-			title: "codex",
-			value: "codex",
-			description: "The tool's own review prompt, on the Codex CLI"
-		}
-	]
-});
-/**
-* The second question, and only where the first did not already answer it.
-*
-* Codex is the second opinion, so it is not one more thing in the list of what
-* my bar could be: it is a runner that runs beside it. A machine whose bar is
-* Codex has nothing left to ask.
-*/
-const askSecondOpinion = Prompt.Confirm({
-	message: "Also ask Codex for a second opinion on every review run?",
-	initial: false
-});
-/**
-* What the file should name: the runner that is my bar, and Codex beside it
-* where I asked for one.
-*
-* Codex alone is the review rather than a second opinion, which is the rule
-* `#domain/review.ts` draws too, so it is never listed twice.
-*/
-const listing = (bar, secondOpinion) => bar === "codex" || !secondOpinion ? [bar] : [bar, "codex"];
-const noRunnerChosen = "No runner chosen, so nothing was written. Pass --runner builtin, --runner prompt or --runner codex to choose without the prompt, and --codex for a second opinion beside it.";
 /** The settings the flags asked for, and only those. */
 const asked = (base, effort) => ({
 	...Option.isSome(base) ? { base: base.value } : {},
 	...Option.isSome(effort) ? { review: { effort: effort.value } } : {}
 });
+/** What a review will open on, as the setup prints it back. */
+const opening = (defaults) => {
+	const review = {
+		...builtIn.review,
+		...defaults.review
+	};
+	return review.command === null ? "my own prompt" : [review.command, review.effort].filter((part) => part !== null).join(" ");
+};
 const row = (label, value) => `${label.padEnd(12)}${value}`;
 /**
 * Both the machine setup and the repository registration: there is deliberately
 * no separate `setup` command.
 *
-* The first run on a machine checks `gh`, settles the runner and spells the
-* defaults out in the configuration file. Run inside a repository, it also
-* registers that `owner/repo`, taking the name from `gh` so I never type it.
-* Run again, it changes what the flags name, keeps every other setting the file
-* already had, and leaves the file untouched where nothing was decided
-* differently.
+* The first run on a machine checks `gh` and spells the defaults out in the
+* configuration file. Run inside a repository, it also registers that
+* `owner/repo`, taking the name from `gh` so I never type it. Run again, it
+* changes what the flags name, keeps every other setting the file already had,
+* and leaves the file untouched where nothing was decided differently.
+*
+* It asks nothing. Reviews run on Claude Code, and what a run opens on is
+* `review.command` and `review.prompt` - a line and a paragraph that belong in
+* the file rather than in a terminal prompt.
 *
-* `--runner` is a choice about this machine, so it lands in the global
-* defaults. `--effort` and `--base` are about one repository, so they land on
-* the repository this ran in, or in the defaults when it ran outside one.
+* `--effort` and `--base` are about one repository, so they land on the
+* repository this ran in, or in the defaults when it ran outside one.
 */
 const init = Command.make("init", {
-	runner: runnerFlag,
-	codex: codexFlag,
 	effort: effortFlag$1,
 	base: baseFlag
-}, Effect.fn("init")(function* ({ base, codex, effort, runner }) {
+}, Effect.fn("init")(function* ({ base, effort }) {
 	yield* requireAuth;
 	const config = yield* ConfigStore;
 	const before = yield* read;
 	const file = Option.getOrElse(before, () => ({}));
-	const firstRun = file.defaults?.review?.runners === void 0;
-	const chosen = Option.isSome(runner) ? Option.some(runner.value) : firstRun ? Option.some(yield* askRunner) : Option.none();
-	const listed = file.defaults?.review?.runners ?? builtIn.review.runners;
-	const bar = Option.getOrElse(chosen, () => listed.find((it) => it !== "codex") ?? "builtin");
-	const secondOpinion = firstRun && bar !== "codex" && Option.isNone(runner) && Option.isNone(codex) ? Option.some(yield* askSecondOpinion) : codex;
-	const decided = Option.isSome(chosen) || Option.isSome(secondOpinion);
-	const beside = Option.getOrElse(secondOpinion, () => listed.includes("codex"));
-	const inherited = firstRun ? merge$1(builtIn, file.defaults ?? {}) : file.defaults ?? {};
-	const defaults = merge$1(inherited, decided ? { review: { runners: listing(bar, beside) } } : {});
+	const defaults = file.defaults === void 0 ? merge$1(builtIn, file.defaults ?? {}) : file.defaults ?? {};
 	const state = yield* stateDirectory;
 	const repo = yield* currentRepo.pipe(Effect.asSome, Effect.catchTag("NoRepository", () => Effect.succeedNone));
 	const overrides = asked(base, effort);
 	const written = Option.isSome(repo) ? withRepo(withDefaults(file, defaults), repo.value, overrides) : withDefaults(file, merge$1(defaults, overrides));
 	if (encode(written) !== encode(file) || Option.isNone(before)) yield* write(written);
-	const settled = written.defaults?.review?.runners ?? builtIn.review.runners;
-	yield* Console.log(row("runner", settled.join(", ")));
+	yield* Console.log(row("review", opening(written.defaults ?? {})));
 	yield* Console.log(row("config", config.path));
 	yield* Console.log(row("state", state));
 	yield* Console.log(Option.isNone(repo) ? row("repository", "none here - run dw-mc init inside a repository to register it") : row("repository", `${repo.value} (${file.repos?.[repo.value] === void 0 ? "registered" : "already registered"})`));
@@ -4101,12 +4105,8 @@ const init = Command.make("init", {
 	"ConfigMalformed",
 	"GhUnauthenticated",
 	"GhUnavailable",
-	"GhUnreadable",
-	"QuitError"
-], (cause) => Effect.fail(cause._tag === "QuitError" ? new CliError.UserError({
-	cause,
-	userMessage: noRunnerChosen
-}) : new CliError.UserError({ cause }))))).pipe(Command.withDescription("Set this machine up and register the repository I am in"));
+	"GhUnreadable"
+], asUserError))).pipe(Command.withDescription("Set this machine up and register the repository I am in"));
 //#endregion
 //#region src/domain/stamp.ts
 /**
@@ -4292,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,
@@ -4304,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);
@@ -4530,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;
@@ -4596,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,
@@ -4657,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,
@@ -4776,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,
@@ -4840,7 +4842,7 @@ const resolve = Command.make("resolve", {
 	...userFacing,
 	"GitFailed",
 	"WorktreeHeld",
-	"RunnerFailed"
+	"AgentFailed"
 ], asUserError))).pipe(Command.withDescription("Open a session on the conflict that stopped a rebase, in a worktree of my own"));
 //#endregion
 //#region src/adapters/notify.ts
@@ -4861,83 +4863,8 @@ 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 review prompt the `prompt` runner owns.
-*
-* Where `builtin` drives the agent's own review command, this is a prompt the
-* tool carries, so my bar is not one agent's idea of a code review. It is the
-* same prompt on either CLI: what differs is how each one is handed the schema,
-* which belongs to the runner adapter and not here.
-*/
-/**
 * The reviewer persona, derived from Addy Osmani's `code-reviewer` agent
 * (`addyosmani/agent-skills`, MIT, see `NOTICE.md`).
 *
@@ -4983,18 +4910,18 @@ the task or the pull request description before the code. Every Critical and Req
 specific fix in its summary. Where you are uncertain, say so in the summary and say what would settle
 it, rather than guessing.`;
 /**
-* The prompt one `prompt` review run opens on.
+* The prompt a review run with no slash command opens on.
 *
 * It says what to review and how to answer, and nothing about how the answer is
-* validated: the schema arrives beside the prompt on both CLIs, so describing it
-* here would be the same shape written twice.
+* validated: the schema arrives beside the prompt, so describing it here would
+* be the same shape written twice.
 *
-* `review.skill` is a passthrough and goes in first, spelled exactly as the file
-* spells it. A repository that has its own review skill gets that skill's review
-* with the persona behind it, and the tool does not try to interpret the value.
+* `review.prompt` is a passthrough and goes in first, spelled exactly as the
+* file spells it. A repository with its own instructions gets its review with
+* the persona behind it, and the tool does not try to interpret the value.
 */
 const reviewPrompt = (reviewing) => [
-	...reviewing.skill === null ? [] : [reviewing.skill, ""],
+	...reviewing.prompt === null ? [] : [reviewing.prompt, ""],
 	persona,
 	"",
 	`The change is ${reviewing.repo}#${reviewing.number}, "${reviewing.title}".`,
@@ -5005,103 +4932,114 @@ const reviewPrompt = (reviewing) => [
 	"line it is at, its severity and a one-sentence summary. The verdict is clean when there is",
 	"nothing to report, and findings otherwise."
 ].join("\n");
+/**
+* What one review run opens on, decided by what the repository configured.
+*
+* A slash command is the review, so the persona stays out of its way and my own
+* instructions ride beside it. Without one the review is the tool's own, and my
+* instructions go in front of the persona. The effort word follows the command
+* because that is where a slash command takes its arguments; a repository that
+* spells its own arguments out sets `review.effort` to null and keeps the line.
+*/
+const turnFor = (review, about) => review.command === null ? {
+	_tag: "prompt",
+	text: reviewPrompt({
+		...about,
+		prompt: review.prompt
+	})
+} : {
+	_tag: "command",
+	line: [review.command, review.effort].filter((part) => part !== null).join(" "),
+	instructions: review.prompt
+};
 //#endregion
 //#region src/cli/review.ts
-/** What the spinner says a run has got through, while it is still going. */
-const saying = (runner) => (doing, since) => [
-	`${runner} reviewing`,
+/** 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"),
 	since
 ].filter((part) => part !== null).join(" · ");
+const commandFlag = Flag.String("command").pipe(Flag.withDescription("The slash command this run opens on, over what the repository configured"), Flag.optional);
+const promptFlag = Flag.String("prompt").pipe(Flag.withDescription("The review instructions this run carries, over what the repository configured"), Flag.optional);
 const effortFlag = Flag.Literals("effort", [
 	"low",
 	"medium",
-	"high"
+	"high",
+	"xhigh",
+	"max"
 ]).pipe(Flag.withDescription("How much this run spends, over what the repository configured"), Flag.optional);
+const modelFlag = Flag.String("model").pipe(Flag.withDescription("The model this run reads the code on, over what the repository configured"), Flag.optional);
+const promptOnlyFlag = Flag.Boolean("prompt-only").pipe(Flag.withDefault(false), Flag.withDescription("Review on the prompt alone, whatever slash command the repository configured"));
+const commandOnlyFlag = Flag.Boolean("command-only").pipe(Flag.withDefault(false), Flag.withDescription("Review on the slash command alone, whatever instructions the repository configured"));
 const forceFlag$1 = Flag.Boolean("force").pipe(Flag.withDefault(false), Flag.withDescription("Review even where the re-run rule would skip it"));
-/** The runners a review run executes, or the sentence saying there are none. */
-const runnersOf = (configured) => {
-	const runners = runnersFor(configured);
-	return runners.length === 0 ? Effect.fail(new CliError.UserError({ cause: "This repository reviews on no runner at all. Set review.runners to one or more of builtin, prompt and codex." })) : Effect.succeed(runners);
+/** A flag that names a value beside the flag that clears it: one of the two, never both. */
+const opposite = (flag, given, only) => Option.isSome(given) ? [`--${flag} and --${only} say opposite things. Pass one.`] : [];
+/** What this run is asked, once the flags have had their say over the file. */
+const asking = (options) => {
+	const clash = [...options.promptOnly ? opposite("command", options.command, "prompt-only") : [], ...options.commandOnly ? opposite("prompt", options.prompt, "command-only") : []];
+	if (clash.length > 0) return Effect.fail(new CliError.UserError({ cause: clash.join(" ") }));
+	const { review } = options.settings;
+	return Effect.succeed({
+		command: options.promptOnly ? null : Option.getOrElse(options.command, () => review.command),
+		effort: Option.getOrElse(options.effort, () => review.effort),
+		prompt: options.commandOnly ? null : Option.getOrElse(options.prompt, () => review.prompt),
+		model: Option.getOrElse(options.model, () => review.model)
+	});
 };
 /**
 * What the re-run rule is asked about, read before anything is cut or spawned:
 * the whole point of the rule is not paying for the run.
 *
-* It is asked per runner, because a second opinion that has never seen this
-* pull request is not skipped for the head the primary review already read.
-*
 * GitHub is asked what changed only where there is a run to measure from and a
 * different head to measure to. Neither is the rule deciding anything - there is
 * simply nothing to compare - and a comparison GitHub would not answer comes
 * back as nothing known rather than as a failure of the command.
 */
-const askedOf = Effect.fn("review.askedOf")(function* (repo, number, head, runner) {
-	const last = Option.getOrNull(yield* lastRun(repo, number, runner));
+const askedOf = Effect.fn("review.askedOf")(function* (repo, number, head) {
+	const last = Option.getOrNull(yield* lastRun(repo, number));
 	return {
 		last,
 		head,
 		changed: last === null || last.head === head ? null : Option.getOrNull(yield* Effect.option(comparedFiles(repo, last.head, head)))
 	};
 });
+/** How a run reads on the line above it: what it opens on, and on which model. */
+const spending = (turn, model) => [
+	turn._tag === "command" ? turn.line : "the tool's own prompt",
+	turn._tag === "command" && turn.instructions !== null ? "with my own instructions" : null,
+	model === null ? null : `model ${model}`
+].filter((part) => part !== null).join(", ");
 /**
-* How a run reads on the line above it: which runner, and what it was told to
-* spend.
-*
-* `review.effort` drives the built-in review command and nothing else, and
-* `review.model` drives the prompt the tool owns, so each run says the one that
-* decided anything about it.
-*/
-const spending = (runner, effort, model) => {
-	if (runner === "builtin") return `${runner}, effort ${effort}`;
-	return model === null ? runner : `${runner}, model ${model}`;
-};
-/**
-* One runner's review of the head in the worktree.
-*
-* `builtin` is two turns of one session: the agent's own review as prose, then
-* the same review reported as findings. `prompt` and `codex` are one turn on
-* the tool's own prompt, which carries the schema with it, so the findings are
-* what the run answers with.
+* The review of the head in the worktree.
 *
 * Whatever the reporting comes to is a value and not a failure: the review is
 * already worth keeping, and a turn that could not report is recorded as the
 * failure it is rather than lost with it.
 */
 const reviewOn = Effect.fn("review.reviewOn")(function* (options) {
-	const said = saying(options.runner);
-	const { directory, launcher, settings } = options;
-	if (options.runner === "builtin") {
-		const turn = yield* spinning(said, (onTool) => builtinReview({
-			launcher,
-			directory,
-			effort: options.effort,
-			onTool
-		}));
-		const reported = yield* Effect.result(Effect.flatMap(builtinFindings({
-			launcher,
-			directory,
-			sessionId: turn.sessionId,
-			jsonSchema
-		}), (output) => Schema.decodeUnknownEffect(Reported)(output)));
-		return {
-			sessionId: turn.sessionId,
-			prose: turn.report,
-			reported
-		};
-	}
-	const prompt = reviewPrompt(options.about);
-	const run = yield* spinning(said, (onTool) => promptRun({
-		runner: options.runner,
+	const { directory, launcher, model, turn } = options;
+	let doing = {
+		tools: 0,
+		subagents: 0
+	};
+	const run = yield* beating(saying(doing), (says) => reviewTurns({
 		launcher,
 		directory,
-		prompt,
-		model: settings.review.model,
+		turn,
+		model,
 		jsonSchema,
-		onTool
+		onTool: (tool) => {
+			doing = {
+				tools: doing.tools + 1,
+				subagents: doing.subagents + (tool === "Agent" ? 1 : 0)
+			};
+			return says(saying(doing), `  · ${tool}`);
+		}
 	}));
-	const reported = yield* Effect.result(Schema.decodeUnknownEffect(Reported)(run.findings));
+	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)));
 	return {
 		sessionId: run.sessionId,
 		prose: run.prose,
@@ -5109,12 +5047,12 @@ const reviewOn = Effect.fn("review.reviewOn")(function* (options) {
 	};
 });
 /**
-* What a runner's review comes to on disk: the findings it reported, or the
-* failure it reached instead.
+* What the review comes to on disk: the findings it reported, or the failure it
+* reached instead.
 *
-* A runner that would not start is as much a failure as a turn that answered in
-* a shape that does not validate, and both are recorded: the head has been
-* tried and nothing was found, which is not the same as nothing being wrong.
+* A run that would not start is as much a failure as a turn that answered in a
+* shape that does not validate, and both are recorded: the head has been tried
+* and nothing was found, which is not the same as nothing being wrong.
 */
 const ranBy = (got) => {
 	if (Result.isFailure(got)) return {
@@ -5146,20 +5084,14 @@ const ranBy = (got) => {
 	};
 };
 /**
-* The command's own failure where a runner that decides my bar reported
-* nothing, and nothing where they all reported.
+* The command's own failure where the review reported nothing.
 *
-* Every run is written down either way; what the exit code says is whether the
-* review I asked for is one to trust. A second opinion that could not report is
-* said out loud and no more: it informs me, so its silence is not my command
-* failing.
+* The run is written down either way; what the exit code says is whether the
+* review I asked for is one to trust.
 */
-const unreported = (recorded, deciding, number) => {
-	const failed = recorded.flatMap((run) => {
-		const detail = detailOf(run);
-		return deciding.includes(run.runner) && detail !== null ? [`${run.runner}: ${detail}`] : [];
-	});
-	return failed.length === 0 ? Effect.void : Effect.fail(new CliError.UserError({ cause: `The review ran and its findings did not: ${failed.join("; ")}. Run dw-mc review ${number} --force to run it again.` }));
+const unreported = (run, number) => {
+	const detail = detailOf(run);
+	return detail === null ? Effect.void : Effect.fail(new CliError.UserError({ cause: `The review ran and its findings did not: ${detail}. Run dw-mc review ${number} --force to run it again.` }));
 };
 /**
 * One review run, started by hand, in the foreground.
@@ -5169,109 +5101,102 @@ const unreported = (recorded, deciding, number) => {
 * the one who decides to spend it.
 *
 * The run happens in a throwaway worktree of the tool's own clone, so what is
-* reviewed is the pull request's head rather than whatever I have open. Every
-* configured runner reviews in that one worktree, one after the other: the
-* cutting is the expensive part that they can share, and a second opinion is
-* worth nothing if it read different code.
+* reviewed is the pull request's head rather than whatever I have open.
 *
-* What they found is kept against that head, one record per runner, which is
-* what takes the pull request out of Needs review run and what a blocking
-* finding later puts into Needs me.
+* What it found is kept against that head, which is what takes the pull request
+* out of Needs review run and what a blocking finding later puts into Needs me.
 *
 * The report is printed as well as kept. A run I waited minutes for should not
 * need a second command to read.
 */
 const review = Command.make("review", {
 	pr: prArgument,
+	command: commandFlag,
+	prompt: promptFlag,
 	effort: effortFlag,
+	model: modelFlag,
+	promptOnly: promptOnlyFlag,
+	commandOnly: commandOnlyFlag,
 	force: forceFlag$1
-}, Effect.fn("review")(function* ({ effort, force, pr }) {
+}, Effect.fn("review")(function* ({ command, commandOnly, effort, force, model, pr, prompt, promptOnly }) {
 	const file = Option.getOrElse(yield* read, () => ({}));
 	const { number, repo } = yield* named(pr, Object.keys(file.repos ?? {}).toSorted());
 	const settings = settingsFor(file, repo);
 	const launcher = launcherOf(file);
-	const configured = yield* runnersOf(settings.review.runners);
-	const deciding = decidingIn(configured, settings.stamp.supporting_blocks);
-	const spend = Option.getOrElse(effort, () => settings.review.effort);
+	const asked = yield* asking({
+		settings,
+		command,
+		prompt,
+		effort,
+		model,
+		promptOnly,
+		commandOnly
+	});
 	const view = yield* prView(repo, number);
 	yield* Console.log(`${repo}#${number}  ${view.title}`);
-	const asked = yield* Effect.forEach(configured, (runner) => Effect.map(force ? Effect.succeed(null) : Effect.map(askedOf(repo, number, view.headRefOid, runner), (it) => skippedSince(it, settings.review.docs_only)), (since) => ({
-		runner,
-		since
-	})));
-	for (const { runner, since } of asked) if (since !== null) yield* Console.log(`  ${runner}: only documentation changed since ${short(since)}, so this run is skipped. Pass --force to review it anyway.`);
-	const running = asked.filter((it) => it.since === null).map((it) => it.runner);
-	if (running.length === 0) return;
+	const since = force ? null : skippedSince(yield* askedOf(repo, number, view.headRefOid), settings.review.docs_only);
+	if (since !== null) {
+		yield* Console.log(`  only documentation changed since ${short(since)}, so this run is skipped. Pass --force to review it anyway.`);
+		return;
+	}
 	const about = {
 		repo,
 		number,
 		title: view.title,
 		base: view.baseRefName,
-		skill: settings.review.skill
+		prompt: asked.prompt
 	};
+	const turn = turnFor(asked, about);
 	yield* Effect.gen(function* () {
 		const ran = yield* withWorktree(repo, number, (worktree) => Effect.gen(function* () {
-			const done = [];
-			for (const runner of running) {
-				yield* Console.log(`  head ${short(worktree.head)}  ${spending(runner, spend, settings.review.model)}`);
-				const got = yield* Effect.result(reviewOn({
-					runner,
-					launcher,
-					directory: worktree.directory,
-					effort: spend,
-					settings,
-					about
-				}));
-				done.push({
-					runner,
-					ran: ranBy(got)
-				});
-			}
+			yield* Console.log(`  head ${short(worktree.head)}  ${spending(turn, asked.model)}`);
+			const got = yield* Effect.result(reviewOn({
+				launcher,
+				directory: worktree.directory,
+				turn,
+				model: asked.model
+			}));
 			return {
 				head: worktree.head,
-				done
+				ran: ranBy(got)
 			};
 		}));
 		const ranAt = yield* DateTime.now;
 		const runs = yield* storeFor("runs", ReviewRun);
 		const latest = yield* storeFor("runs", LastReviewed);
 		const reports = yield* textStoreFor("runs");
-		const recorded = [];
-		for (const { ran: got, runner } of ran.done) {
-			const run = {
-				repo,
-				number,
-				head: ran.head,
-				runner,
-				effort: spend,
-				sessionId: got.sessionId,
-				ranAt,
-				outcome: got.outcome
-			};
-			yield* runs.set(runKey(repo, number, run.head, runner), run);
-			yield* latest.set(latestKey(repo, number, runner), { head: run.head });
-			yield* reports.set(reportKey(repo, number, run.head, runner), reportDocument(run, view.title, got.prose ?? ""));
-			recorded.push(run);
-			yield* Console.log("");
-			if (ran.done.length > 1) yield* Console.log(`${runner}:`);
-			const detail = detailOf(run);
-			if (detail !== null) {
-				yield* Console.log(`  reported nothing: ${detail}`);
-				continue;
-			}
+		const got = ran.ran;
+		const run = {
+			repo,
+			number,
+			head: ran.head,
+			command: asked.command,
+			effort: asked.command === null ? null : asked.effort,
+			sessionId: got.sessionId,
+			ranAt,
+			outcome: got.outcome
+		};
+		yield* runs.set(runKey(repo, number, run.head), run);
+		yield* latest.set(latestKey(repo, number), { head: run.head });
+		yield* reports.set(reportKey(repo, number, run.head), reportDocument(run, view.title, got.prose ?? ""));
+		yield* Console.log("");
+		const detail = detailOf(run);
+		if (detail !== null) yield* Console.log(`  reported nothing: ${detail}`);
+		else {
 			const found = reportedBy(run);
-			if (found === null) continue;
-			if (got.prose !== null) {
-				yield* Console.log(got.prose);
-				yield* Console.log("");
+			if (found !== null) {
+				if (got.prose !== null) {
+					yield* Console.log(got.prose);
+					yield* Console.log("");
+				}
+				yield* Console.log(summary(found, settings.stamp.blocks_on));
+				for (const line of lines$1(found)) yield* Console.log(`  ${line}`);
 			}
-			yield* Console.log(summary(found, settings.stamp.blocks_on));
-			for (const line of lines$1(found)) yield* Console.log(`  ${line}`);
 		}
 		yield* Console.log(`Recorded against ${short(ran.head)} in ${yield* stateDirectory}`);
-		yield* unreported(recorded, deciding, number);
+		yield* unreported(run, number);
 	}).pipe(Effect.onExit((exit) => announce("dw-mc review", `${repo}#${number} ${Exit.isSuccess(exit) ? "reviewed" : "could not be reviewed"}`)));
-}, Effect.catchTag([...userFacing, "GitFailed"], asUserError))).pipe(Command.withDescription("Review one pull request on the configured runners, in a throwaway worktree"));
+}, Effect.catchTag([...userFacing, "GitFailed"], asUserError))).pipe(Command.withDescription("Review one pull request on Claude Code, in a throwaway worktree"));
 //#endregion
 //#region src/cli/stamp.ts
 const withdrawFlag = Flag.Boolean("withdraw").pipe(Flag.withDefault(false), Flag.withDescription("Take the stamp off this pull request, until its head changes"));
@@ -5337,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;
@@ -5429,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.3.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 = [