playthrough 0.3.0 → 0.4.0

package/INSTRUCTIONS.md

@@ -3,7 +3,7 @@ to its end; each command then says what's next.
 
   playthrough start <review> "<title>" "<what was asked>"
                                      start a review: a title for the change, and what was asked, in the person's words
-  playthrough start <review>             once its flows are written, record Before: the app as it is
+  playthrough start <review>             once its flows are written, try the setup and keep Before: the app as it is
   playthrough record <review>            record the round being worked on, every flow, the way a person would use it
   playthrough wait <review>              hand the round over, then wait for the notes to answer
   playthrough walk <review>              walk the person's steps in the app again, on the app as it is now
@@ -14,19 +14,22 @@ THE LOOP
 1. Start a review with a title, as you'd title its pull request, and what was asked, word for word: it's what the person
    judges each round against. Before you change anything, write its flows, one for each thing a person does that the
    task touches, from the task, not from the code.
-2. Run playthrough start <review> again. It records Before: each flow on the app as it is, as far as it can go. There,
-   what a flow expects of the finished work only waits a moment; the flow stops only at a step the app can't do yet.
+2. Run playthrough start <review> again. It tries the app's setup, then keeps the app as it is as Before, for the person
+   to compare each round with. Nothing's recorded yet: the flows are written for the work.
 3. Change the app. Keep each flow's name, and each step's while it does the same job: they're matched across rounds by
    name. Once the work is done, add a flow for each choice you made that the person can see and didn't ask for.
-4. playthrough record <review> records the round and compares it with every round before it. In the round's round.json,
+4. playthrough record <review> records the round, and each flow new to the review on Before too, doing what the round
+   does as far as the app as it was can, then compares the round with every round before it. In the round's round.json,
    say why each change since the round before is there, under "accounts" by its id: { "line": "<why, in your words>" },
-   { "note": "<the note it was made for>" }, or { "notReal": "<why nothing really changed>" }.
+   { "note": "<the id of the note it was made for>" }, or { "notReal": "<why nothing really changed>" }. What only the
+   pictures show is the person's to look at, and asks nothing of you, unless you made it for a note: then say so.
 5. playthrough wait <review> hands the round over and waits for the notes, which can take hours: run it in the
    background, so you're told when it ends. Each note comes with a picture of what it's on, or what the person did in
-   the app. Change the app, record the next round, and answer each note in its round.json, under "replies". Where the
-   answer moves, like an animation, add "watch": "<the title of the step it's seen in>". For a note made in the app,
-   record walks the person's steps again and puts your answer where they lead: answer it in words, not with a new flow,
-   and check your fix with playthrough walk <review>. Where their steps stop short, fix that, or say why they changed.
+   the app. Change the app, record the next round, and answer each note in its round.json, under "replies", in its
+   "words": its "on" is where Playthrough found the note's thing on this round, so leave it. Where the answer moves,
+   like an animation, add "watch": "<the title of the step it's seen in>". For a note made in the app, record walks the
+   person's steps again and puts your answer where they lead: answer it in words, not with a new flow, and check your
+   fix with playthrough walk <review>. Where their steps stop short, fix that, or say why they changed.
 
 The person can only judge what the flows show, so keep them true to how a person uses the app.
 
@@ -38,10 +41,9 @@ playthrough/app.json says how to start the app, and is committed so every review
 
 Flows run several at once. Where a page shows what every run made, as a blog's index lists every post, add
 "oneAtATime": true. Every round is recorded on whatever serves that url, and Playthrough starts the app only when nothing
-does: leave a server you didn't start running, and let it follow the working copy, as a dev server does. A flow recorded
-on Before later sets your work aside with git stash for a minute, puts the app as it was in its place, with playthrough/
-as it is now, and puts your work back after, even when Playthrough is stopped. Until round 1 is handed over, Before
-follows what you fix: a flow whose file changes is recorded on it again, and so is every flow once playthrough/ changes.
+does: leave a server you didn't start running, and let it follow the working copy, as a dev server does. Recording on
+Before sets your work aside with git stash for a minute, puts the app as it was in its place, with playthrough/ as it is
+now, and puts your work back after, even when Playthrough is stopped.
 
 FLOWS
 
@@ -63,7 +65,7 @@ name is the flow's:
 Act on the page as a person would, by role and label. Playthrough glides the pointer, types a key at a time, and reads
 the page once it rests after each step. A dialog the browser shows is recorded, and answered No unless the flow says Yes
 first: page.once("dialog", (dialog) => dialog.accept()). A flow that fails stops the round: record names it and the
-step, and keeps the page it failed on in .playthrough/<review>/failed/, as Before does where each flow stops.
+step, and keeps the page it failed on in .playthrough/<review>/failed/.
 
 While the person watches, Playthrough runs the flow again in the background, so taking it over is quick. If its steps do
 something outside the app that mustn't happen again, like sending an email, say so, and it runs only when taken over:
@@ -91,15 +93,16 @@ tells tests by (the screen, language and time zone are Playthrough's):
 
   export async function after({ request, setup }: { request: APIRequestContext; baseURL: string; setup: Record<string, any> }) {
     const removed = await request.delete(`/api/test/accounts/${setup.account}`);
-    if (!removed.ok()) throw new Error(`Removing the account failed: ${removed.status()}`);
+    if (!removed.ok() && removed.status() !== 404) throw new Error(`Removing the account failed: ${removed.status()}`);
   }
 
 Each run makes its own: what the app needs unique, like an email, of its own, and what the page shows, like a name, the
-same every run. Check what each request answers, so one that fails says so. Avoid what can't be given back, like an
-email sent: test keys, a mail catcher. Use what the project has (a test account, seed data, its own fixtures), make data
-through the API or database rather than on screen, and stub what you can't control at the network. Sign in with
-page.request, not request: it shares the page's cookies, so a person who takes the flow over is signed in too. Dates
-the server works out don't follow the page's clock: fix them through the app's own test hook if it has one.
+same every run. Check what each request answers, so one that fails says so. An after that fails is tried again whole by
+the next command, so it takes what's gone already as given back. Avoid what can't be given back, like an email sent:
+test keys, a mail catcher. Use what the project has (a test account, seed data, its own fixtures), make data through the
+API or database rather than on screen, and stub what you can't control at the network. Sign in with page.request, not
+request: it shares the page's cookies, so a person who takes the flow over is signed in too. Dates the server works out
+don't follow the page's clock: fix them through the app's own test hook if it has one.
 
 Whenever app.json or setup.ts changes, Playthrough tries the setup by itself first, twice for each of the app's people,
 and shows a picture of where each starts. Fix what the pictures show and run the command again. It's the person's app:

package/README.md

@@ -7,8 +7,8 @@ Playthrough records your coding agent's change the way a person would use it, be
 ## How a review goes
 
 1. You ask your agent for a change, and to show it to you with Playthrough.
-2. Before it touches the code, the agent writes a flow for each thing a person does that the change touches, and Playthrough records them on the app as it is: Before.
-3. The agent makes the change, and Playthrough records every flow again. It finds what changed itself, including what the agent didn't mention, and the agent says why each change is there.
+2. Before it touches the code, the agent writes a flow for each thing a person does that the change touches, and Playthrough keeps the app as it is: Before.
+3. The agent makes the change, and Playthrough records every flow, on the app as it is now and on Before, as far as the app went before. It finds what changed itself, including what the agent didn't mention, and the agent says why each change is there.
 4. You watch. Leave a note on what's wrong, where it's wrong; compare with Before; take over and try it yourself. Then send.
 5. The agent answers each note in the next round, on the spot the note is on. You check its answers, and accept once every flow looks good.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playthrough",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Review an AI agent's work on a web app by watching recordings of it.",
   "type": "module",
   "license": "Apache-2.0",
@@ -13,7 +13,7 @@
     "node": ">=24"
   },
   "bin": {
-    "playthrough": "./src/playthrough.js"
+    "playthrough": "src/playthrough.js"
   },
   "exports": {
     "./test": {

package/src/{flows-Dt7fcPLt.js → flows-BkG0TgHA.js}

@@ -1,13 +1,13 @@
-import { O as list, b as Refused, g as readingsOf, k as quote, m as glimpsesOf, p as firstLine, x as Reviews } from "./reporter-4C_7joIm.js";
+import { A as list, b as Refused, g as readingsOf, j as quote, m as glimpsesOf, p as firstLine, x as Reviews } from "./reporter-DE8aueAO.js";
 import * as modules from "node:module";
 import { createRequire } from "node:module";
 import { existsSync, watch } from "node:fs";
 import { spawn } from "node:child_process";
 import { mkdir, mkdtemp, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
 import { constants, tmpdir } from "node:os";
 import { dirname, join, relative } from "node:path";
 import { chromium, request } from "@playwright/test";
-import { createHash, randomUUID } from "node:crypto";
 import { fileURLToPath, pathToFileURL } from "node:url";
 // ../review/src/steps.ts
 function inStep(at, from, to, clicks) {
@@ -268,7 +268,7 @@ async function giveBack(after, file, baseURL, setup) {
 		await rm(file, { force: true });
 		return true;
 	} catch (error) {
-		console.log(`playthrough/setup.ts's after couldn't give back what a run made: ${firstLine(String(error?.message ?? error))}. It's tried again by the next command.`);
+		console.log(`playthrough/setup.ts's after couldn't give back what a run made: ${firstLine(String(error?.message ?? error))}. The next command tries it again, whole, so it should take what's gone already as given back.`);
 		return false;
 	} finally {
 		giving.delete(file);
@@ -730,7 +730,7 @@ function placeIn(place, from, to) {
 	};
 	if (place.point) return {
 		...moment,
-		point: place.point
+		point: besideOn(place.point, place.at, from, to) ?? place.point
 	};
 	const there = (element) => {
 		const found = foundIn(from.readings, element, place.at, to.readings);
@@ -744,6 +744,36 @@ function placeIn(place, from, to) {
 		...alike?.length && { alike }
 	} : moment;
 }
+const HOLDING = /^(dialog|alertdialog|group|radiogroup|table|grid|treegrid|listbox|menu)$/;
+function besideIn(read, at, point) {
+	const reading = read.reduce((best, next) => !best || Math.abs(next.at - at) < Math.abs(best.at - at) ? next : best, void 0);
+	if (!reading) return void 0;
+	const x = point.x * reading.screen.width;
+	const y = point.y * reading.screen.height;
+	const inside = (thing) => x >= thing.box.x && x <= thing.box.x + thing.box.width && y >= thing.box.y && y <= thing.box.y + thing.box.height;
+	const area = (thing) => thing.box.width * thing.box.height;
+	const room = reading.things.filter((thing) => (thing.role === "box" || HOLDING.test(thing.role) && !/^(table|grid|treegrid)$/.test(thing.role)) && inside(thing)).sort((a, b) => area(a) - area(b))[0];
+	const within = (thing) => {
+		for (let holder = thing.holder; holder !== void 0; holder = reading.things[holder]?.holder) if (reading.things[holder] === room) return true;
+		return false;
+	};
+	const gap = (thing) => Math.hypot(Math.max(thing.box.x - x, 0, x - thing.box.x - thing.box.width), Math.max(thing.box.y - y, 0, y - thing.box.y - thing.box.height));
+	const thing = reading.things.filter((thing) => thing.name && thing.role !== "box" && !HOLDING.test(thing.role) && (!room || within(thing)) && gap(thing) <= 80).sort((a, b) => gap(a) - gap(b) || area(a) - area(b))[0];
+	return thing && {
+		reading,
+		thing
+	};
+}
+function besideOn(point, at, from, to) {
+	const beside = besideIn(from.readings, at, point);
+	const found = beside && sameIn(beside, from.readings, to.readings);
+	if (!beside || !found) return void 0;
+	const share = (pixels, of) => Math.min(1, Math.max(0, pixels / of));
+	return {
+		x: share(point.x * beside.reading.screen.width + found.thing.box.x - beside.thing.box.x, found.reading.screen.width),
+		y: share(point.y * beside.reading.screen.height + found.thing.box.y - beside.thing.box.y, found.reading.screen.height)
+	};
+}
 function foundIn(from, element, at, to) {
 	const shown = shownAt(from, element, at);
 	return shown && sameIn(shown, from, to);
@@ -791,11 +821,13 @@ function changesAt(then, now, unsteady = /* @__PURE__ */ new Set(), shown = {
 	const others = own.filter((difference) => !isMove(difference));
 	const caused = grownByWhatsInside(moment, own);
 	const along = /* @__PURE__ */ new Map();
-	const { reordered, left } = rowsReordered(moment, own.filter(isMove));
+	const items = itemsReordered(moment, own.filter(isMove));
+	const { reordered, left } = rowsReordered(moment, items.left);
 	const { shifts, loose } = layoutShifts(left, carried);
 	moment.shifts = shifts.map((shift) => shift.by);
 	const widened = widenedTogether(others, caused, along);
 	const told = [
+		...items.reordered,
 		...reordered,
 		...swappedOrMoved(moment, loose),
 		...causesOfShifts(moment, shifts, widened, others, caused, along)
@@ -907,6 +939,76 @@ function grownByWhatsInside(moment, own) {
 	}
 	return caused;
 }
+function itemsReordered(moment, moves) {
+	const { then, now } = moment;
+	const pairs = pairItems(moment);
+	const reordered = [];
+	let left = moves;
+	for (const [, paired] of groupBy([...pairs], ([, b]) => now.items[b].list)) {
+		const byThen = [...paired].sort((p, q) => p[0] - q[0]);
+		const byNow = [...paired].sort((p, q) => p[1] - q[1]);
+		const placeThen = new Map(byThen.map(([a], i) => [a, i]));
+		const kept = longestRising(byNow.map(([a]) => placeThen.get(a)));
+		const way = (a, b) => {
+			const went = moveOf(asThing(then.items[a], a), asThing(now.items[b], b));
+			return Math.abs(went.y) >= Math.abs(went.x) ? went.y > 0 ? "down" : "up" : went.x > 0 ? "right" : "left";
+		};
+		const moved = byNow.flatMap(([a, b], i) => kept.has(i) ? [] : [{
+			thing: asThing(now.items[b], b),
+			way: way(a, b),
+			places: Math.abs(i - placeThen.get(a))
+		}]);
+		if (!moved.length) continue;
+		const changed = byNow.filter(([a], i) => placeThen.get(a) !== i);
+		const first = now.items[byNow[0][1]];
+		const of = `${first.role} of ${listOf(now, first)}`;
+		const holder = first.holder === void 0 ? void 0 : now.things[first.holder];
+		if (changed.length === 2) {
+			const both = changed.map(([, b]) => asThing(now.items[b], b));
+			reordered.push({
+				what: "swapped",
+				thing: both[0],
+				in: now,
+				words: `${together(both)} have swapped places`,
+				key: `${of}: ${both.map((thing) => thing.words).join(" / ")}`
+			});
+		} else if (moved.length <= 2) for (const { thing, way, places } of moved) reordered.push({
+			what: "moved",
+			thing,
+			in: now,
+			words: `${called$1(thing)} moved ${way} ${places} ${places > 1 ? "places" : "place"}`,
+			key: `${of}: ${thing.words}`
+		});
+		else {
+			const order = byNow.slice(0, 3).map(([, b]) => called$1(asThing(now.items[b], b)));
+			const words = first.role === "row" ? `Rows in ${holder ? the(holder) : "the table"} are in a new order` : `What's in ${holder ? the(holder) : "the list"} is in a new order: ${order.join(", ")}${byNow.length > 3 ? "…" : ""}`;
+			reordered.push({
+				what: "reordered",
+				thing: holder ?? moved[0].thing,
+				in: now,
+				words,
+				key: of
+			});
+		}
+		const inList = new Set(paired.map(([, b]) => b));
+		left = left.filter((move) => !(move.now.item !== void 0 && inList.has(move.now.item) && move.then.item !== void 0 && pairs.get(move.then.item) === move.now.item));
+	}
+	return {
+		reordered,
+		left
+	};
+}
+function longestRising(sequence) {
+	const best = sequence.map(() => 1);
+	const before = sequence.map(() => -1);
+	for (let i = 0; i < sequence.length; i++) for (let j = 0; j < i; j++) if (sequence[j] < sequence[i] && best[j] + 1 > best[i]) {
+		best[i] = best[j] + 1;
+		before[i] = j;
+	}
+	const kept = /* @__PURE__ */ new Set();
+	for (let i = best.indexOf(Math.max(...best)); i >= 0; i = before[i]) kept.add(i);
+	return kept;
+}
 function rowsReordered(moment, moves) {
 	const reordered = [];
 	let left = moves;
@@ -1229,8 +1331,10 @@ function identityOf({ in: reading, thing, what }, moment) {
 	if (!item) return identity(reading, thing);
 	const kind = reading.things.filter((other) => other.item === thing.item && other.role === thing.role && other.column === thing.column);
 	const place = `${thing.role} ${kind.indexOf(thing) + 1}${thing.column ? ` under ${thing.column}` : ""}`;
-	const was = what === "reworded" && moment.was.get(thing);
-	return `${place} in a ${item.role} of ${listOf(reading, item)}${was ? `: ${shapeOf(was.words, thing.words)}` : ""}`;
+	const was = /^(reworded|moved)$/.test(what) ? moment.was.get(thing) : void 0;
+	const went = was && what === "moved" && moveOf(was, thing);
+	const how = went ? `, ${wayOf(near(went.x, 0) ? 0 : went.x, near(went.y, 0) ? 0 : went.y)}` : was ? `: ${shapeOf(was.words, thing.words)}` : "";
+	return `${place} in a ${item.role} of ${listOf(reading, item)}${how}`;
 }
 const listOf = (reading, item) => item.holder === void 0 ? "the page" : identity(reading, reading.things[item.holder], 0);
 function pairItems({ then, now, was }) {
@@ -1455,9 +1559,10 @@ async function picturesAt(page, then, now, pictures) {
 		if (patch.nudged && found.length) continue;
 		if (patch.moved && [...changedInside].some((holder) => contains(holder.box, patch, 8))) continue;
 		const on = whatsThere(now, patch);
-		const by = patch.moved && Math.max(Math.abs(patch.moved.x), Math.abs(patch.moved.y));
-		const words = patch.moved ? `${on.called} moved ${wayOf(patch.moved.x, patch.moved.y)}, ${by}px` : `${on.called} looks different`;
-		const id = idOf(on.identity ?? `place:${Math.round(patch.x / 32)},${Math.round(patch.y / 32)}`, patch.moved ? "moved" : "looks different");
+		const moved = on.identity && !on.identity.startsWith("near ") ? void 0 : patch.moved;
+		const by = moved && Math.max(Math.abs(moved.x), Math.abs(moved.y));
+		const words = moved ? `${on.called} moved ${wayOf(moved.x, moved.y)}, ${by}px` : `${on.called} looks different`;
+		const id = idOf(on.identity ?? `place:${Math.round(patch.x / 32)},${Math.round(patch.y / 32)}`, moved ? "moved" : "looks different");
 		const same = told.get(id);
 		told.set(id, {
 			words,
@@ -1722,16 +1827,20 @@ function unsteadyIn(flows) {
 async function comparing(page, earlier, round, unsteady = () => /* @__PURE__ */ new Set()) {
 	const changes = /* @__PURE__ */ new Map();
 	const pieces = /* @__PURE__ */ new Map();
-	const see = ({ id, words, place, of = [id] }) => {
+	const see = ({ id, words, place, of = [id], pictureOnly }) => {
 		if (unsteady(place.flow).has(id)) return;
 		const change = changes.get(id);
 		for (const piece of of) (pieces.get(id) ?? pieces.set(id, /* @__PURE__ */ new Set()).get(id)).add(piece);
 		if (!change) changes.set(id, {
 			id,
 			words,
-			seen: [place]
+			seen: [place],
+			...pictureOnly && { pictureOnly }
 		});
-		else if (!change.seen.some((seen) => seen.flow === place.flow)) change.seen.push(place);
+		else {
+			if (!change.seen.some((seen) => seen.flow === place.flow)) change.seen.push(place);
+			if (!pictureOnly) delete change.pictureOnly;
+		}
 	};
 	for (const flow of round.flows) {
 		const before = earlier.flows.find((kept) => kept.name === flow.name);
@@ -1769,7 +1878,8 @@ async function compareFlow(page, earlier, before, round, flow, unsteady) {
 			then: around(glimpsed.then, before, was.step),
 			now: around(glimpsed.now, flow, reading.step)
 		};
-		for (const found of [...changesAt(was, reading, unsteady, shown), ...await picturesAt(page, was, reading, pictures)]) {
+		const pictured = await picturesAt(page, was, reading, pictures);
+		for (const found of [...changesAt(was, reading, unsteady, shown), ...pictured]) {
 			const on = found.element ? {
 				element: found.element,
 				...found.alike && { alike: found.alike }
@@ -1782,7 +1892,8 @@ async function compareFlow(page, earlier, before, round, flow, unsteady) {
 					at: reading.at,
 					...on
 				},
-				of: found.pieces
+				of: found.pieces,
+				...pictured.includes(found) && { pictureOnly: true }
 			});
 		}
 	}
@@ -1880,12 +1991,12 @@ async function trySetup(repo, again) {
 	console.log(`\n${line("The app", startedIn === void 0 ? `running already at ${app.url}` : `started with ${quote(app.start)}, answering at ${app.url} in ${seconds(startedIn)}`)}`);
 	for (const { who, did, took, at, refused, picture } of tried) console.log(line(who, `${did}${did === "nothing made" ? "" : ` in ${seconds(took)}`}, then at ${at}${refused ? `, which the app answered with ${refused}` : ""}: ${repo.show(picture)}`));
 	const missing = [];
-	if (!setup.after && tried.some(({ made }) => made)) missing.push("playthrough/setup.ts has no after, so what each run makes stays in the app: one for each flow recorded, two for a new one, and one each time the person pauses a recording, as it's made ready to take over.");
-	else if (tried.some(({ givenBack }) => !givenBack)) missing.push("playthrough/setup.ts's after couldn't give back what it made, for the reason above.");
+	if (!setup.after && tried.some(({ made }) => made)) missing.push("playthrough/setup.ts has no after, so what each run makes stays in the app: one for each flow recorded, three for a new one, and one each time the person pauses a recording, as it's made ready to take over.");
 	const slowest = Math.max(...tried.map(({ took }) => took));
 	if (slowest > SLOW) missing.push(`Setup took ${seconds(slowest)}: each flow waits that long before its first step, and so does each moment taken over.`);
 	console.log(`
 Look at ${tried.length > 1 ? "each picture: it's where their flows start" : "the picture: it's where every flow starts"}. One that shows a sign-in page for someone who should be signed in, or anything a flow shouldn't start from, is for playthrough/setup.ts.`);
+	if (tried.some(({ givenBack }) => !givenBack)) console.log(`\nplaythrough/setup.ts's after couldn't give back what it made, for the reason above: that's for setup.ts too.`);
 	if (missing.length) console.log(`
 ${missing.map((said) => `- ${said}`).join("\n")}
 
@@ -1995,16 +2106,20 @@ function howToWriteFlows(repo, id) {
 The test's name is the flow's, and steps are matched across rounds by their names. What every flow starts from, like
 the account it opens, is made in playthrough/setup.ts${missing}`;
 }
-async function runFlows(repo, id, round, { later, first }) {
+async function flowsOf(repo, id) {
 	const flows = repo.flows(id);
 	if (!(await readdir(flows).catch(() => [])).some(isFlow)) throw new Refused([`${id} has no flows yet. ${howToWriteFlows(repo, id)}`]);
 	await makeFlowsFolder(repo, id);
+	return flows;
+}
+async function runFlows(repo, id, round, { before, first = () => false }) {
+	const flows = await flowsOf(repo, id);
 	const app = await repo.app();
-	if (!later) await trySetup(repo, round === 0 ? `playthrough start ${id}` : `playthrough record ${id}`);
+	if (!before) await trySetup(repo, `playthrough record ${id}`);
 	const { started, rounds } = await repo.reviews.get(id);
 	const recorder = join(dirname(createRequire(import.meta.url).resolve("@rrweb/record")), "record.umd.min.cjs");
 	const longest = (rounds.filter((kept) => kept.number < round).at(-1)?.flows ?? []).toSorted((a, b) => b.length - a.length).map((flow) => flow.name);
-	const run = (only, results, stops) => runOnce({
+	const run = (only, results) => runOnce({
 		flows,
 		only,
 		longest,
@@ -2012,16 +2127,20 @@ async function runFlows(repo, id, round, { later, first }) {
 		app,
 		root: repo.root,
 		recorder,
-		before: round === 0,
-		taken: later?.taken ?? [],
+		before: !!before,
+		taken: before?.taken ?? [],
 		started,
-		stops
+		...before && { doneInRound: before.doneInRound }
 	});
-	const last = round > 0 ? await failedLastTime(repo, id) : [];
+	if (before) {
+		console.log(`Recording ${called(before.flows)} on Before, the app as it was…`);
+		return run(before.flows);
+	}
+	const last = await failedLastTime(repo, id);
 	if (last.length) {
 		console.log(`Running ${called(last)} first: ${last.length > 1 ? "they" : "it"} failed last time…`);
 		const { recorded, failed } = await run(last, repo.failed(id));
-		await keepFailed(repo, id, round, failed);
+		await keepFailed(repo, id, failed);
 		const [one] = failed;
 		if (failed.length > 1) throw new Refused([
 			`\nThese flows failed again, so the other flows weren't run:`,
@@ -2032,20 +2151,15 @@ async function runFlows(repo, id, round, { later, first }) {
 		const gone = !recorded.length;
 		console.log(`\n${last.length > 1 ? gone ? "They aren't flows any more" : "They pass now" : gone ? "It isn't a flow any more" : "It passes now"}, so every flow is recorded.\n`);
 	}
-	console.log(later ? `Recording ${called(later.flows)} on Before, the app as it was…` : round === 0 ? `Recording Before: each flow of ${id} on the app as it is…` : `Recording round ${round} of ${id}…`);
-	const once = await run(later?.flows, repo.failed(id));
-	await keepFailed(repo, id, round, once.failed);
+	console.log(`Recording round ${round} of ${id}…`);
+	const once = await run(void 0, repo.failed(id));
+	await keepFailed(repo, id, once.failed);
 	const again = once.recorded.filter(({ flow }) => first(flow.name));
-	if (!again.length || round > 0 && once.failed.length) return once;
+	if (!again.length || once.failed.length) return once;
 	console.log(`\nRecording ${called(again.map(({ flow }) => flow.name))} again, to see what changes by itself…`);
-	const stops = Object.fromEntries(once.failed.flatMap(({ flow, at }) => at ? [[flow, at]] : []));
-	const results = once.failed.length ? void 0 : repo.failed(id);
-	const twice = await run(again.map(({ flow }) => flow.name), results, stops);
-	if (results) await keepFailed(repo, id, round, twice.failed);
-	const unlike = again.filter(({ flow }) => {
-		const failed = (ran) => ran.failed.find((failure) => failure.flow === flow.name)?.at;
-		return !twice.recorded.some((kept) => kept.flow.name === flow.name) || failed(once) !== failed(twice);
-	});
+	const twice = await run(again.map(({ flow }) => flow.name), repo.failed(id));
+	await keepFailed(repo, id, twice.failed);
+	const unlike = again.filter(({ flow }) => !twice.recorded.some((kept) => kept.flow.name === flow.name));
 	if (unlike.length) throw new Refused([
 		`\n${list(unlike.map(({ flow }) => quote(flow.name)))} didn't go the same way twice on the same app:`,
 		...unlike.map(({ flow }) => `  ${quote(flow.name)}: the first time, ${went(once, flow.name)}; the second, ${went(twice, flow.name)}.`),
@@ -2071,7 +2185,7 @@ function went(ran, name) {
 	const because = failure.why ? `, where Playwright says “${failure.why}”` : "";
 	return failure.at ? `it stopped at ${quote(failure.at)}${because}` : `it stopped before its first step${because}`;
 }
-async function keepFailed(repo, id, round, failed) {
+async function keepFailed(repo, id, failed) {
 	const folder = repo.failed(id);
 	if (!failed.length) return rm(folder, {
 		recursive: true,
@@ -2081,7 +2195,6 @@ async function keepFailed(repo, id, round, failed) {
 		const path = join(folder, entry);
 		if (entry === ".last-run.json" || !(await readdir(path)).length) await rm(path, { recursive: true });
 	}
-	if (round === 0) return;
 	await mkdir(folder, { recursive: true });
 	await writeFile(join(folder, FAILED), JSON.stringify(failed.map(({ flow }) => flow)));
 }
@@ -2117,13 +2230,12 @@ async function runOnce(run) {
 			written: {}
 		};
 		if (!ran && !failed.length) throw new Refused(["\nThe flows didn't run, for the reason Playwright gives above. Fix that and run this again."]);
-		const withFiles = ({ flow, files, wrote }) => Promise.all(files.map(async (name) => ({
+		const withFiles = ({ files, ...recorded }) => Promise.all(files.map(async (name) => ({
 			name,
 			bytes: await readFile(join(folder, name))
 		}))).then((files) => ({
-			flow,
-			files,
-			...wrote && { wrote }
+			...recorded,
+			files
 		}));
 		return {
 			recorded: await Promise.all(recorded.map(withFiles)),
@@ -2206,4 +2318,4 @@ async function playwright(run) {
 		});
 	});
 }
-export { make as C, pausedAt as D, repo as E, giveBackLeft as S, setupIn as T, keepRunning as _, failedAt as a, changes as b, makeFlowsFolder as c, walkFork as d, whereItStopped as f, shownAt as g, placeIn as h, called as i, runFlows as l, compareWithEarlier as m, REACHES_OUTSIDE as n, howToWriteFlows as o, trySetup as p, WALKED as r, isFlow as s, ALONGSIDE as t, waitsFor as u, serves as v, personIn as w, firstOf$1 as x, stopApp as y };
+export { firstOf$1 as C, setupIn as D, personIn as E, repo as O, changes as S, make as T, placeIn as _, failedAt as a, serves as b, isFlow as c, waitsFor as d, walkFork as f, compareWithEarlier as g, writtenNow as h, called as i, pausedAt as k, makeFlowsFolder as l, trySetup as m, REACHES_OUTSIDE as n, flowsOf as o, whereItStopped as p, WALKED as r, howToWriteFlows as s, ALONGSIDE as t, runFlows as u, shownAt as v, giveBackLeft as w, stopApp as x, keepRunning as y };