diff --git a/.changeset/expo-verify-evidence.md b/.changeset/expo-verify-evidence.md
new file mode 100644
index 00000000000..a845151cc84
--- /dev/null
+++ b/.changeset/expo-verify-evidence.md
@@ -0,0 +1,2 @@
+---
+---
diff --git a/.claude/skills/verify-clerk-expo/SKILL.md b/.claude/skills/verify-clerk-expo/SKILL.md
index c56cb94920a..39121b1c946 100644
--- a/.claude/skills/verify-clerk-expo/SKILL.md
+++ b/.claude/skills/verify-clerk-expo/SKILL.md
@@ -20,7 +20,7 @@ The test app links `@clerk/expo`, `@clerk/expo-native-components`, `@clerk/expo-
 Set up each machine once.
 
 1. Install Node 24, at 24.8.0 or newer. For a local iOS device, install Xcode with an iOS simulator runtime. For a local Android device, install Android Studio with the SDK, the emulator, and Java 21. The CLI looks for the SDK in `ANDROID_HOME`, `ANDROID_SDK_ROOT`, and `~/Library/Android/sdk`.
-2. Create the iOS template simulator, which the CLI clones to make each simulator it drives, for example with `xcrun simctl clone "iPhone Air" "Clerk Verify Template iOS"`. Android needs no template: the first `up --platform android` writes the `Clerk_Verify_Pixel` AVD.
+2. Create the iOS template simulator, which the CLI clones to make each simulator it drives, with `xcrun simctl create "Clerk Verify Template iOS" "iPhone Air"`. That makes a new simulator that holds only the system's apps. Do not clone a simulator you already use: a clone holds every app of the original, and those apps show on the home screen at the start of a video. Boot the template once and shut it down: a clone of a template that never booted takes about twenty seconds longer to boot. `doctor` says when a system HTTPS proxy needs its CA trusted there. Android needs no template: the first `up --platform android` writes the `Clerk_Verify_Pixel` AVD.
 3. Give the machine the team's Clerk Platform API key. Set `CLERK_PLATFORM_API_KEY` to the key. Or set `CLERK_PLATFORM_API_KEY_FILE` to a file that holds it and that only you can read (mode 0600). Or set `VERIFY_PLATFORM_KEY_REFERENCE` to the key's 1Password secret reference, which the 1Password CLI reads once a person approves the request in the 1Password app, within 60 seconds. Never put the key or the reference in a file inside a repository.
 
 Then, in each worktree:
@@ -181,7 +181,7 @@ Every `run` writes `.verify/runs/<run-id>/` and prints its path.
 | File                      | What it holds                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `run.json`                | The record: `results` per spec, `platform`, `backend`, `gitHead`, `dirty`, `build`, `device`, `identities`, `settings`, and `tainted`                                                                                                                                                                                                                                                                                                                          |
-| `video.mp4`               | The whole run, from `simctl io recordVideo` on iOS or `adb shell screenrecord` on Android                                                                                                                                                                                                                                                                                                                                                                      |
+| `video.mp4`               | The run, from the first `host.launch` to the end, recorded by `simctl io recordVideo` on iOS or `adb shell screenrecord` on Android. Just before that launch, `run` closes the app and starts the recorder, so the video opens on the device's home screen for a moment and then on the app being launched. A run in which no test calls `host.launch` has no video, and `run` prints a `video` line that says so                                              |
 | `screenshots/<label>.png` | Every `host.screenshot(label)`                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `app.log`                 | Device log lines. On Android they include the app's `[verify]` console lines. On a local iOS device they are native lines only, and the `[verify]` lines are in `.verify/runtime/metro-<port>.log`. The test app writes one `[verify]` line each time its screen, user, session, or launch error changes, with the `launchId` that a failed `host.launch` names. No spec reads these lines. They are for diagnosing a failure that the screen does not explain |
 | `e2e/`, `e2e.log`         | e2e's `report.json` and `junit.xml`, its failure pages, and its console output                                                                                                                                                                                                                                                                                                                                                                                 |
@@ -195,25 +195,41 @@ After a run, the CLI searches the run directory for every secret the run used: t
 A remote run writes the same files. The runner records the video, and the CLI downloads it into the run directory. `run.json` also has `remote`, with `provider`, `runner`, and `builtSha`, the commit the session built.
 
 ```console
-$ integration/expo-native/bin/control-clerk-expo attach <run-id> --pr <n>                       # the video and every screenshot
-$ integration/expo-native/bin/control-clerk-expo attach <run-id> --pr <n> --screenshot profile  # the video and one screenshot
+$ integration/expo-native/bin/control-clerk-expo attach <run-id> --pr <n> --screenshot profile                    # a still change that is new
+$ integration/expo-native/bin/control-clerk-expo attach <run-id> --pr <n> --screenshot profile --before <run-id>  # a still change to something that exists
+$ integration/expo-native/bin/control-clerk-expo attach <run-id> --pr <n> --video                                 # a flow that is new
+$ integration/expo-native/bin/control-clerk-expo attach <run-id> --pr <n> --video --before <run-id>               # a change to a flow that exists
 ```
 
-`attach` puts the video and the screenshots in the description of the pull request with `gh pr edit --attach`. It writes one block for the platform of the run: a line that names the run, the device, and the commit, then the files, between the comments `<!-- verify-evidence:ios -->` and `<!-- /verify-evidence:ios -->`, or the same two with `android`. The first `attach` of a platform adds its block after the description. A later `attach` of that platform replaces its block, so the description holds the latest run of each platform and the media does not pile up. `attach` changes nothing outside the block. Keep both comments of a block or remove both: `attach` refuses a description that has one without the other, or either one twice. A comment counts only when it is a whole line outside a code fence, so a description can quote one in a sentence or show a whole block as an example.
+`attach` posts what you choose, and with neither `--screenshot` nor `--video` it fails with a usage error. Make two choices.
 
-`attach` reads the description again just before it writes, and builds on the newer text once if it changed. It cannot see an edit that someone saves while the files upload, and that edit is lost, so do not edit the description while `attach` runs.
+Choose screenshots or the video by what changed. A still change, such as wording, shows in screenshots, so pass `--screenshot <label>` once for each `host.screenshot(label)` to show. A change to behavior, to movement or animation, or to a flow shows in the video, so pass `--video`. One kind is usually enough. Use your judgment, and pass both flags when one kind alone does not show the change.
 
-On a machine whose `gh` can attach, `attach` edits the description itself and prints `posted`. That needs gh 2.99.0 or newer, whose `gh pr edit` has `--attach`. It uploads a run to a PR once, and a second `attach` of the same run and PR prints `already posted`.
+Choose before and after, or after only, by whether the thing existed. A change to something that exists shows what it replaced, so add `--before <run-id>`. Something new has no before, so leave the flag out.
 
-`attach` always tries `gh pr edit --attach` itself first, on every kind of machine, and hands off only when that cannot work. On a machine whose `gh` cannot attach, such as a cloud sandbox, it hands the files of a remote run to the session's runner and prints `handed off`. Run it before `down`. The evidence reaches the description after `down` ends the session, when the `verify-attach` workflow publishes it. Its line says that the session reported the result, links the session's run, and names the account that started the session and the commit the run was made at. That workflow publishes only to the open pull request of the session's branch, and only when the commit the session started on and the commit of the run are both commits of that pull request. So open the pull request before `up`. A later push does not lose the evidence: the line then says that the pull request has newer commits. To show the newer commit, `run` and `attach` again, which replaces the block. `attach` checks the pull request first, and fails with the reason when the workflow would refuse it. Each platform has its own session, so `attach` the run of each platform before the `down` that ends its session.
+To make the before run, `run` the spec of your change on the build without the change, before you make the change, on the platform of the run it goes with. That run can fail, and a failed run is a good before: a spec that expects the new wording fails on the old build. `attach` pairs each screenshot with the screenshot of the same label in the before run. When the before run failed before it took that screenshot, `attach` uses that run's failure screenshot. With `--video` it pairs the two videos. The before run must be in `.verify/runs/` of this checkout, and `attach` fails with a usage error when it is a run of the other platform.
+
+`attach` puts the files in the description of the pull request with `gh pr edit --attach`. It writes one block for the platform of the run, between the comments `<!-- verify-evidence:ios -->` and `<!-- /verify-evidence:ios -->`, or the same two with `android`. The block is a line and one or two tables. The line leads with the result and names the run, the device, the commit, and how many tests passed. With `--before` it also names the before run, its commit, and how many of its tests passed. With `--before`, a table has a `Before` and an `After` column and one row for each screenshot. Without it, the screenshots are two across, each under its label in code font. Each screenshot is 280 pixels wide. The video is in a table of its own under the screenshots.
+
+The first `attach` of a platform adds its block after the description. A later `attach` of that platform replaces its block, so the description holds the latest run of each platform and the media does not pile up. `attach` changes nothing outside the block. Keep both comments of a block or remove both: `attach` refuses a description that has one without the other, or either one twice. A comment counts only when it is a whole line outside a code fence, so a description can quote one in a sentence or show a whole block as an example.
+
+`attach` writes the description twice. `gh` puts the address of an upload only where the description names the file as a markdown image, and a markdown image has no width. So the first write uploads the files as a list, and the second replaces the list with the tables. If the block changes between the two writes, the list stays and `attach` fails and says so. Run `attach` again.
+
+`attach` reads the description again just before each write, and builds on the newer text once if it changed. It cannot see an edit that someone saves while the files upload, and that edit is lost, so do not edit the description while `attach` runs.
+
+On a machine whose `gh` can attach, `attach` edits the description itself and prints `posted`. That needs gh 2.99.0 or newer, whose `gh pr edit` has `--attach`. It reads the description first. When the description already holds the block that this `attach` would write, it uploads nothing and prints `already posted`. When the block there is of another run or another choice of files, or there is none, it uploads the files and writes the block.
+
+`attach` always tries `gh pr edit --attach` itself first, on every kind of machine, and hands off only when that cannot work. On a machine whose `gh` cannot attach, such as a cloud sandbox, it hands the files of a remote run to the session's runner and prints `handed off`. With `--before`, the files of the before run go with them, from that run's directory in this checkout. Run it before `down`. The evidence reaches the description after `down` ends the session, when the `verify-attach` workflow publishes it, in the same tables. Its line says that the session reported the result, links the session's run, and names the account that started the session and the commit the run was made at. With `--before`, the line says that the session reports the before run, and it links that run's commit. That workflow publishes only to the open pull request of the session's branch, and only when the commit the session started on and the commit of the run are both commits of that pull request. The commit of the before run must be the commit of the run or a commit before it in its history, such as the one the branch started from. So open the pull request before `up`. A later push does not lose the evidence: the line then says that the pull request has newer commits. To show the newer commit, `run` and `attach` again, which replaces the block. `attach` checks the pull request first, and fails with the reason when the workflow would refuse it. Each platform has its own session, so `attach` the run of each platform before the `down` that ends its session.
 
 When this machine cannot attach and there is no session to hand the files to, or the hand-off fails, `attach` fails and says which. Then name the run id in the PR and say that the evidence was not attached. A run on a local device has no session, so its fix is a newer `gh`. [Remote devices](references/remote.md) has what the repository needs before a hand-off can be published, and its limits.
 
-`attach` refuses a run that is tainted, that has a failing spec or no passing one, or whose `app.log` names a user that the run did not create.
+`attach` writes only to an open pull request, and fails on one that is closed or merged. It refuses a run that is tainted, that has a failing spec or no passing one, or whose `app.log` names a user that the run did not create. A before run can have failing specs. `attach` refuses a before run that is tainted, that was never sealed, or whose `app.log` names a user that the run did not create.
+
+On a local device, work in this order: `run` the spec on the build without your change when the change is to something that exists, make the change, commit, `run` the spec, `git push`, open the pull request, `attach`, then `down`. Commit before the second `run`, so that the line `attach` writes names a commit the pull request holds. In the pull request, name the run id and the specs you ran, and say what you did not run.
 
-On a local device, work in this order: commit, `run` the spec of your change, `git push`, open the pull request, `attach`, then `down`. Commit first, so that the line `attach` writes names a commit the pull request holds. In the pull request, name the run id and the specs you ran, and say what you did not run.
+On a remote session, make the before run before you push the change. A session builds the commit it was started on and later commits of the branch, and never an earlier one. When the branch has a pushed commit that does not hold the change, such as the commit that adds the spec, one session does both runs: open the pull request, `up`, `run` the spec, push the change, `run` the spec again, `attach` with `--before`, then `down`. When the change is the only commit, it takes two sessions, because the workflow publishes only for a session that started on a commit of the pull request: push the branch, `up`, `run` the spec, `down`, push the change, open the pull request, `up`, `run` the spec again, `attach` with `--before`, then `down`.
 
-Attach the run of your own change. Run your new or changed spec on its own and attach that run, so the PR video shows only the behavior the change is about. You do not owe a regression run: PR CI (`.github/workflows/verify-e2e.yml`) runs every golden spec on the pull request and reports them there. If you ran other golden specs anyway, cite that run's id in the PR and leave its video in `.verify/runs/`.
+Attach the run of your own change. Run your new or changed spec on its own and attach that run, so the screenshots or the video show only what the change is about. You do not owe a regression run: PR CI (`.github/workflows/verify-e2e.yml`) runs every golden spec on the pull request and reports them there. If you ran other golden specs anyway, cite that run's id in the PR and leave its video in `.verify/runs/`.
 
 ## Cleanup
 
@@ -256,6 +272,6 @@ For a remote device, `down` ends the runner job and waits for it to finish, and
 - `run --github-report` hands the results of the run to `@e2e-dev/github` as one report. The reporter writes the report to the job summary. With a `GITHUB_TOKEN` that may write pull request comments, it also posts one comment on the pull request and updates that comment on later runs. The reporter never changes the exit code, and nothing is reported for a run with a tainted file.
 - `.github/workflows/verify-e2e.yml`, the `Verify end-to-end tests` workflow, runs `up --backend local`, `run --all --retries 1 --github-report`, and `down` on a runner for each platform, with a device and a Clerk application for each. It starts on a pull request to `main` that changes the package, the test app, or one of the four packages the test app links. It runs for a pull request that is not a draft, and a draft or a pull request from a fork gets a notice instead. Start it by hand with `gh workflow run verify-e2e.yml --ref <branch>`. A failing spec shows on the pull request and is not required for a merge, and a test that fails and then passes on its one retry is `flaky` and does not fail the job. The runners are GitHub-hosted, `macos-26` and `ubuntu-24.04`, and the repository variables `VERIFY_CI_RUNNER_IOS` and `VERIFY_CI_RUNNER_ANDROID` name other labels. The Platform API key comes from the `MOBILE_VERIFICATION_PLATFORM_API_KEY` repository secret. The workflow sets `VERIFY_LOCAL_BUILD=standalone` and `VERIFY_NATIVE_CACHE` ([freshness.md](references/freshness.md)). It uploads each run's `run.json`, app log, driver logs, video, screenshots, and e2e's `report.json`, `junit.xml`, summary, and failure pages for three days, and only when no secret is found in the run. `bin/boot-ios-simulators.sh wait` waits until a booted simulator is ready, and this workflow and `.github/workflows/verify-remote.yml` call it.
 - The `Expo` workflow, `.github/workflows/expo-native-build.yml`, runs nothing on a device. It builds the test app as a Release app on Expo SDK 54, 55, and 57 for each platform, and runs the Android unit tests of `@clerk/expo-biometrics`.
-- `.github/workflows/verify-attach.yml` publishes the evidence that `attach` hands to a session's runner, with `scripts/verify-attach.mjs`. It reads the manifest that `src/core/remote/handoff.ts` writes. It and `src/core/publish.ts` each replace the block the other wrote, and each applies the same rules to the comments and to the start of the line. So a change to the manifest, the comments, or those rules is a change in both places. `scripts/verify-attach.test.mjs` has its tests.
+- `.github/workflows/verify-attach.yml` publishes the evidence that `attach` hands to a session's runner, with `scripts/verify-attach.mjs`. It reads the manifest that `src/core/remote/handoff.ts` writes. It and `src/core/publish.ts` each replace the block the other wrote, each applies the same rules to the comments and to the start of the line, and each lays the files out in the same tables. The script is checked out alone, so it imports nothing from the package. So a change to the manifest, the comments, those rules, or the tables is a change in both places. `scripts/verify-attach.test.mjs` has its tests.
 - A remote session runs in `.github/workflows/verify-remote.yml`. `src/platform/session-device.ts` holds the steps that the session runs on its device, and `src/core/remote/` is the code on both ends of it. The runner installs the package with `npm ci`. A session keeps the code under `src/core/` from the commit it started on, so after a change to a file that `src/core/MANIFEST` lists, commit, push, `down`, then `up`.
 - `SKILL.md`, `references/`, and `features/` are in `.claude/skills/verify-clerk-expo/`. `.cursor/skills/verify-clerk-expo` is a symlink to that directory, so edit only the `.claude` copy.
diff --git a/.claude/skills/verify-clerk-expo/features/README.md b/.claude/skills/verify-clerk-expo/features/README.md
index 4c853acc330..29b18196b3e 100644
--- a/.claude/skills/verify-clerk-expo/features/README.md
+++ b/.claude/skills/verify-clerk-expo/features/README.md
@@ -34,7 +34,7 @@ The iOS identifiers come from `Sources/ClerkKitUI/Components/Auth/ClerkAccessibi
 ## Proof and skip reporting
 
 - A proof is a passing `run` whose run directory holds `video.mp4`, `screenshots/`, `app.log`, and `e2e/report.json`. The video and the screenshots are the proof on both platforms.
-- Name the run id, the platform, and the specs in the PR. Attach the run with `attach <run-id> --pr <n>`.
+- Name the run id, the platform, and the specs in the PR. Attach the run with `attach <run-id> --pr <n>` and `--screenshot <label>` for a still change or `--video` for behavior or a flow. Add `--before <run-id>` when the change is to something that exists. `SKILL.md` has the choice under Evidence.
 - A spec limited to one platform reports as skipped on the other. Say which platform, and local or remote device, each proof ran on.
 
 ## Feature entry contract
diff --git a/.claude/skills/verify-clerk-expo/references/remote.md b/.claude/skills/verify-clerk-expo/references/remote.md
index eff63ae4700..bcab9ce7e3b 100644
--- a/.claude/skills/verify-clerk-expo/references/remote.md
+++ b/.claude/skills/verify-clerk-expo/references/remote.md
@@ -76,9 +76,9 @@ Each checkout has a random id in `.verify/remote/owner`, and its sessions carry
 
 ## Evidence from a machine that cannot attach
 
-`attach` always tries `gh pr edit --attach` itself first, on every kind of machine, and hands off only when that cannot work. The hand-off sends the evidence of a remote run to the session's runner. It sends the video and the screenshots from the sealed run directory, with a manifest that names the run, the pull request, the device, the commit, and each file's size and SHA-256. The files travel over the session's tunnel, with the session's token, in pieces of 1 MiB. The session job keeps them in one directory and uploads that directory as the artifact `verify-evidence` when the job ends. The artifact holds nothing else of the session.
+`attach` always tries `gh pr edit --attach` itself first, on every kind of machine, and hands off only when that cannot work. The hand-off sends the evidence of a remote run to the session's runner. It sends the files that the flags of `attach` chose from the sealed run directory, with a manifest that names the run, the pull request, the device, the commit, and each file's size and SHA-256. With `--before`, the manifest also names the before run, its commit, and its counts, and the hand-off carries one file of the before run for each file of the run. Those files come from the before run's directory in this checkout, whichever session made that run. When that directory is gone, as it is in a new sandbox, `attach` fails with `USAGE` before it sends anything, and its fix is to attach without `--before` and name the before run in the PR. The files travel over the session's tunnel, with the session's token, in pieces of 1 MiB. The session job keeps them in one directory and uploads that directory as the artifact `verify-evidence` when the job ends. The artifact holds nothing else of the session.
 
-`.github/workflows/verify-attach.yml` then runs, from the default branch. It downloads the artifact, checks every file against the manifest and against its own limits, and puts the block of the run's platform in the description with `gh pr edit --attach`. It never runs anything from the branch or from the artifact. The workflow did not run the tests, so the line it writes says that the session reported the result, links the session's run in the Actions tab, and names the account that started that run, as GitHub records it.
+`.github/workflows/verify-attach.yml` then runs, from the default branch. It downloads the artifact, checks every file against the manifest and against its own limits, and puts the block of the run's platform in the description with `gh pr edit --attach`. It holds a file of the before run to the same checks as a file of the run. It writes the description twice, as `attach` does: the first write uploads the files as a list, and the second lays them out in the tables that `SKILL.md` describes under Evidence. For the second write it reads the addresses of the uploads from the block, and takes only addresses of GitHub uploads. If the pull request or the block changed between the two writes, it leaves the list and says so in its run. A rerun of that job uploads the files again and lays them out. The tables take about twice the characters of the list, so in a description near GitHub's limit of 65,536 characters the second write can fail after the first one succeeded. The job then fails, and the list stays until the description is shorter and the job runs again. It never runs anything from the branch or from the artifact. The workflow did not run the tests, so the line it writes says that the session reported the result, links the session's run in the Actions tab, and names the account that started that run, as GitHub records it. With a before run, the line says that the session reports that run, and it links the commit of that run so that a reader can open it.
 
 The repository needs this set up once:
 
@@ -98,15 +98,20 @@ The workflow publishes only when all of these hold. Otherwise it prints the reas
 - Its branch is the branch the session was started on.
 - The commit the run was made at is one of the pull request's commits.
 - The commit that branch had when `up` started the session is one of them too. GitHub lists the first 250 commits of a pull request, and the workflow reads no further. When a longer pull request has either commit past the first 250, the workflow says so and publishes nothing. Squash or rebase the branch to 250 commits or fewer, or attach from a machine whose `gh` can attach.
+- With `--before`, the commit of the before run is the commit of the run or a commit before it in its history. The workflow asks GitHub to compare the two commits.
 - The hand-off has at least one file.
 - The description has the two evidence comments of the platform once each, or neither.
 - A description without the comments does not end inside a code fence that is never closed.
 
 `attach` checks the same rules before it sends anything, and fails with the reason.
 
+A before run is the build without the change, so its commit is often the one the branch started from, which is no commit of the pull request. The workflow therefore does not look for that commit among the commits of the pull request. It asks GitHub whether that commit is the commit of the run or a commit before it in its history, and it publishes nothing when the answer is no. After a rebase that rewrote the commit of the before run, `run` the spec again on a commit that the branch still has, and pass that run as `--before`. The workflow cannot check that the files of the before run came from a build of that commit, which is why the line says that the session reports the before run.
+
+The manifest of a hand-off has a version, and the workflow publishes only the version of the script on the default branch. A branch whose verify code is older than the default branch's hands off a manifest that the workflow refuses. The refusal names both versions in the run of `verify-attach`, and nothing on the pull request shows it. Merge the default branch into the branch before you `attach`, then `down`, `up`, `run`, and `attach`. A session takes only the version of its own code. When the checkout changed version after `up`, `attach` fails, names both versions, and says to `down` and `up`.
+
 A push after the run does not lose the evidence. The line in the block names the commit the run was made at, and when the pull request has moved on it ends with "The pull request has newer commits." To show the newer commit, `run` again and `attach` again in the same session, which replaces the block. The session builds the new commit, and no new session is needed. After a rewrite of the branch's history that removes either commit, `down` and `up` before the next `run`.
 
-A hand-off holds one video of up to 100 MiB and screenshots of up to 10 MiB each, with at most 50 files and 150 MiB in all. A session keeps one hand-off, and a later `attach` in the same session replaces it. `down` gives a session that holds evidence up to five minutes to upload it before it cancels the run.
+A hand-off holds one video of up to 100 MiB and screenshots of up to 10 MiB each, with at most 50 files and 150 MiB in all. A before run adds one more video and as many screenshots as the run has, and its files count toward the 50 files and the 150 MiB. A session keeps one hand-off, and a later `attach` in the same session replaces it. `down` gives a session that holds evidence up to five minutes to upload it before it cancels the run.
 
 The runs of `verify-attach` for one branch take turns, and each one publishes.
 
diff --git a/integration/expo-native/specs/fixtures.ts b/integration/expo-native/specs/fixtures.ts
index 650e86b25f3..8126e640c71 100644
--- a/integration/expo-native/specs/fixtures.ts
+++ b/integration/expo-native/specs/fixtures.ts
@@ -5,7 +5,7 @@ import { test as base } from '@e2e-dev/mobile';
 import { expect, type Locator } from 'e2e';
 import { app as testApp } from './app.ts';
 import { busyWaits, onceTheRunnerIsFree, type BusyWait } from './support/busy-runner.ts';
-import { testUsers } from './support/clerk.ts';
+import { aboutToLaunch, testUsers } from './support/clerk.ts';
 import { ASSERTION_TIMEOUT_MS, PACKAGE_DIR } from './support/config.ts';
 import { agentDevice, deviceCommand } from './support/device.ts';
 import { fillField } from './support/fill.ts';
@@ -74,6 +74,7 @@ export const test = base.extend<{ host: HostFixture }>({
       {
         installApp: (path) => device.installApp(path),
         signInTicket: users.signInTicket,
+        aboutToLaunch: () => aboutToLaunch(clerk.access),
         openApp: (id, options) => (options === undefined ? device.openApp(id) : device.openApp(id, { relaunch: true, launchArguments: [...options.launchArguments] })),
         adb: (args) => adb(target, args),
       },
diff --git a/integration/expo-native/specs/support/clerk.ts b/integration/expo-native/specs/support/clerk.ts
index 870be6168ec..02e41c83ed5 100644
--- a/integration/expo-native/specs/support/clerk.ts
+++ b/integration/expo-native/specs/support/clerk.ts
@@ -16,6 +16,8 @@ export const BACKEND_CALLS = {
 
 export type BackendCall = keyof typeof BACKEND_CALLS;
 
+export const ABOUT_TO_LAUNCH = { method: 'POST', path: '/about_to_launch' } as const;
+
 export const TICKET_SECONDS = 120;
 
 // Node gives each address of a host 250 ms to connect before it tries the next, and fails the request when
@@ -90,6 +92,17 @@ function endpoint(access: ClerkAccess): { readonly baseUrl: string; readonly bea
   return { baseUrl: access.url, bearer: new Secret('stand-in-token', readFileSync(access.tokenFile, 'utf8')) };
 }
 
+export async function aboutToLaunch(access: ClerkAccess, fetchImpl: typeof fetch = fetch): Promise<void> {
+  if (access.kind !== 'stand-in') return;
+  const { baseUrl, bearer } = endpoint(access);
+  const response = await bearer.use('bapi-authorization', (plain) =>
+    fetchImpl(`${baseUrl}${ABOUT_TO_LAUNCH.path}`, { method: ABOUT_TO_LAUNCH.method, headers: { Authorization: `Bearer ${plain}` }, signal: AbortSignal.timeout(60_000) }),
+  );
+  if (response.ok) return;
+  const said = errorsOf({ status: response.status, json: await response.json().catch(() => null) }).map((error) => error.long_message ?? error.message ?? error.code);
+  throw new Error(`the verify CLI was not ready for the app to launch: ${said.join('; ') || `it answered ${response.status}`}`);
+}
+
 export function testUsers(clerk: ClerkInstance, run: RunId, fetchImpl: typeof fetch = fetch): TestUsers {
   runPassword(run);
   const handedOut = new Set<TestPhone>();
diff --git a/integration/expo-native/specs/support/launch.ts b/integration/expo-native/specs/support/launch.ts
index dde2a655619..90068dcd7c9 100644
--- a/integration/expo-native/specs/support/launch.ts
+++ b/integration/expo-native/specs/support/launch.ts
@@ -115,6 +115,7 @@ export interface LaunchedApp {
 export interface LaunchDriver extends AppStartDriver {
   installApp(path: string): Promise<unknown>;
   signInTicket(user: SeededUser): Promise<SecretLike>;
+  aboutToLaunch(): Promise<void>;
 }
 
 export function appLauncher(app: LaunchedApp, driver: LaunchDriver, installedBuilds: Set<string>, newId: () => string): (options: LaunchOptions) => Promise<LaunchId> {
@@ -140,7 +141,9 @@ export function appLauncher(app: LaunchedApp, driver: LaunchDriver, installedBui
         ...(options.debugLogs === true ? { verifyLogLevel: 'debug' as const } : {}),
         ...(ticket === undefined ? {} : { verifySignInTicket: ticket }),
       });
-      return appStart(app.platform, app.id, app.entry, launchArguments);
+      const start = appStart(app.platform, app.id, app.entry, launchArguments);
+      await driver.aboutToLaunch();
+      return start;
     };
     await performAppStart(nextStart, app.id, driver);
     if (latest.launchId === undefined) throw new Error('the app start never minted a launch id');
diff --git a/integration/expo-native/src/core/MANIFEST b/integration/expo-native/src/core/MANIFEST
index fb7a3a7a6d9..21de99791be 100644
--- a/integration/expo-native/src/core/MANIFEST
+++ b/integration/expo-native/src/core/MANIFEST
@@ -1,27 +1,27 @@
 0ec17d3e3a153410d40bd6cc57ddb259745c77403fa681c6670a3aa6456aa826  e2e.config.ts
-f1ac21eeca82c1f04cbb42f0b77d51c798c71842a5a0b97a4660c3265ab601b6  specs/fixtures.ts
+e563089e9dcaf8a1edda603b7816d313ca634db078289829e21f5db4d7f1ce3f  specs/fixtures.ts
 38e8e99663059810b616b591dfd79bdcc7781f72b7269875294f3702b3edde84  specs/support/agent.ts
 6d1ef7700a89e19d0b1214d5a6815ba757d02857c555b8bf108f2e0c9a64aad3  specs/support/busy-runner.ts
-b272dcd59155f0beff1eb1bc5ce7e3e2283d9e0e16e0639ef7eb6d8edbde9b3f  specs/support/clerk.ts
+153cda5ccf3ad0e38a35e238a52c64633a9b8de9e2086ff060ddb661a2438b1d  specs/support/clerk.ts
 6c658e254cb6ad8ba9f3d05638941e0809e6709f0abb8096340559b2f81b156a  specs/support/config.ts
 be45e0eb42f715d603c179c7a86750949ff2ee3cc0da73082179801fe1b8f2ab  specs/support/device.ts
 cec7a42bf8d35e174fd3387cbcc638c01bacda74fc15ea1b14eda8abaa200d34  specs/support/fill.ts
 7415ccd89f715d40ca74796a5b235aab02e640c8674d457d3912955ab67146e1  specs/support/inputs.ts
-1772127f0a42d10003f16e5a59197180f4731837e0a00d2d1717f0b0f1bdfe8b  specs/support/launch.ts
+27a69309a568e90dc06b8d04abfb6efe7dadd16f4374a19f61d0ebf0a99a87fc  specs/support/launch.ts
 2065bc90a33659fd8f5a6e54e8b0fa57a50edc415063d4ac7e0dab744972e1b7  specs/support/secret.ts
 7446b59792b957f2ace72e6c2eceb305bde25378d1f879e2884706c3d7f9f3a4  specs/support/tapping.ts
 df955a42a2bd4ca1780f56837ebb9c832c68e97f74a35764d42a32e44b28286b  specs/support/types.ts
 7bdb018b337d923e96ada265abfebafd75c6fd07188ab313117effdc893e32d7  specs/support/typing.ts
 10bcf31d87a05655fc263ed810a0e10c0b63a77265720d7f22f3720052f67c38  specs/support/waiting.ts
 792ec6414c7e95446346abe2db850f6e4cc865a7c83a21892166fae969654277  src/core/agent.ts
-1b144b8f7362be2019f578bbdf94b7e6fe3196440de5c79d4f790fa8394374e3  src/core/broker.ts
+d56c29efc8061adfd65b89f0f02465af3234ecd52289ef6d9f338483afeadeb5  src/core/broker.ts
 7c741449c755524bba80f1ce314554293003a34f7f7c30696015ba1c0c3dc1ab  src/core/claims.ts
 1fc59d13e7197e6c7099c0467744b978d498d1fe409c88254d44e2f99913a7b5  src/core/clerk.ts
-51f330273bb083139ff2f5f7ee3a7b616ba614c83cd050c188d5f224631050d6  src/core/cli.ts
+4b8f5d87af69b85cd0bd5e729de238ccdb39f42e54d2e38af9ca43c2f172a433  src/core/cli.ts
 4aeacea985f5ef80001e5695feec53182abb9695eb07130898568743755fc8af  src/core/devices.ts
 3ae461d6aa75a2cefac0392a9ad124aec4105ac25b9320371743e2ea90fe2202  src/core/driver.ts
 b59071aaefeec02dea89bd25615f8ada0da0a51e805a2523011b8b591e7435d3  src/core/e2e.ts
-8c0ae6c44155105ce15011176bc630c59d6b4a2d2aa050f3fad4aa9674386ad8  src/core/evidence.ts
+c9a29e27eb835d9c3fc9b0bd394ff55b5f1fcc2b2fc0d96da51197e5e7bca003  src/core/evidence.ts
 27bfd4ce59937aa8c97d9fd6849cf52f3da05626fbc9388385f4b5e684577d36  src/core/exec.ts
 e2075f17f52ded8dea64d8a2473820396ca5ac1a22db59f21a092da28e55911f  src/core/github-report.ts
 721453f519bba1374dcf11aaae58f7af06e5555be756df6d3beaf52a9c2a2eda  src/core/instances/base.json
@@ -34,19 +34,19 @@ cf6aa68be73e4abaf3b63d5d84c2e9eee6197412f607ec53d0f05f7b058db420  src/core/insta
 098d3eef9d2521054f235f47e8658efb71d482087b927645489fc2240a03f5e8  src/core/launch.mjs
 a0ee9e4bfd34d4659685108e5e54eb1ec2aff6248236c358e6d3b14b2e2ff6a0  src/core/ledgers.ts
 afab94a970286c40d6857b03ae4fa39ec59786274beacf6f1e77f6530bf46c54  src/core/manifest.ts
-c8f71088aa30904b8c69196f6df9bae968a5de16d2007d7e5e569feef3ff8246  src/core/publish.ts
-0f016cc412897b66038f56ce4c15b5b633bf8ca2c29eda05dbe28bf17fb29fd2  src/core/remote/backend.ts
+7294bbab3d892f0d9aee1e863f84e32a7f5dc3c467a7b6177be7e4ff2f29fecc  src/core/publish.ts
+76de0f98013b8a5d011dee8cf51cce63fcb3d7e68acfee51945fa5cecf2e7763  src/core/remote/backend.ts
 37fc42707be7d8bd5f0313a664a8465287ebb0970c520c0e0617f6ff6c9a614e  src/core/remote/github.ts
-2ed83b089a07969efe4369e027b8840f4c4b7b8fe055058fb22f44cf289618d6  src/core/remote/handoff.ts
+cbd837689f2e0eff48205709a8c99508a0bcd0bea76f2647a93faa8866a76ae0  src/core/remote/handoff.ts
 2ec436b2c53b34269e0b62ab54e41e4d9a55146cccc46f0f31591db05cdbf5c1  src/core/remote/preflight.ts
 bb69fe1f3581942285894c0901d02889c08b4293e4d9db77934fe3cdd2d4a399  src/core/remote/protocol.ts
 5a4ee0e7ed20feaeb711b1527083299b432d3fc0b7f428b636678a8a2f57581f  src/core/remote/recipe.ts
 bbb997d036c320257783f9c576497e4f02cde99a9cc8d164c4dfde40f76e4421  src/core/remote/session-agent.ts
-12df6d34398f8d1dce753839be00a0dc50f2c6de00638e4e4a43f8570912b403  src/core/remote/session.ts
+9cb8ac8bdae263362b9e8a3f24592f20cc80fb367417ac0d2ed34fb3f383021b  src/core/remote/session.ts
 d614ee5c98a85d15037b744a67404496273f62985fd7d6a049cacfd5ab335503  src/core/remote/settings.ts
 e734336ea3b345057b69193790e2efce9a662c67ec5b4a426c811f999b45ccdb  src/core/remote/tunnel.ts
 685eabf010c7f63d076cfd3da1a681b5cc8024720538c1bf3a99792b563d8b60  src/core/slot.ts
 a8838aaf1fa9e4a6bc4e350ea674079201da76c5962656039b96db2505591aed  src/core/state.ts
-5d9bd1c8120b1ae77a1c42c40248f3b73cb1fce4c61e8c78ae21778a8ec3b39d  src/core/types.ts
-e0be9be1adfbfeec510d86a97e75d4b18b032712b6653daf2674458051ae6254  src/core/verbs.ts
+c9900be2f1097ed0395018531bed554064440f57962afac1daa794040b1b2c28  src/core/types.ts
+79b822b663c1ac1748cf3c8ec390ef9204378f4c97531f4da9b0bf5736a20d36  src/core/verbs.ts
 9be1816773216373548ec9933978b53ace3d3bfdba17b72c1e5ed6d8aef80f62  src/core/workspace.ts
diff --git a/integration/expo-native/src/core/broker.ts b/integration/expo-native/src/core/broker.ts
index 46932884a1b..c3c28925967 100644
--- a/integration/expo-native/src/core/broker.ts
+++ b/integration/expo-native/src/core/broker.ts
@@ -2,7 +2,7 @@ import { randomBytes, timingSafeEqual } from 'node:crypto';
 import { writeFileSync } from 'node:fs';
 import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
 import { join } from 'node:path';
-import { BACKEND_API_URL, BACKEND_CALLS, TICKET_SECONDS, parseTestEmail, parseTestPhone, runEmailPrefix, typedPassword, type BackendCall } from '../../specs/support/clerk.ts';
+import { ABOUT_TO_LAUNCH, BACKEND_API_URL, BACKEND_CALLS, TICKET_SECONDS, parseTestEmail, parseTestPhone, runEmailPrefix, typedPassword, type BackendCall } from '../../specs/support/clerk.ts';
 import { protect } from '../../specs/support/secret.ts';
 import { ownKeyRefused, userLimitReached } from './clerk.ts';
 import type { InstanceKeys } from './keys.ts';
@@ -16,6 +16,7 @@ const BODY_LIMIT_BYTES = 64 * 1024;
 export interface BrokerDeps {
   readonly keys: () => InstanceKeys;
   readonly fetch: typeof fetch;
+  readonly beforeLaunch: () => Promise<void>;
 }
 
 export interface Broker {
@@ -139,8 +140,18 @@ export async function startBroker(run: RunId, workspace: Workspace, scratch: Scr
     return { status: response.status, body: await response.text() };
   }
 
+  async function readyToLaunch(): Promise<Answer> {
+    try {
+      await deps.beforeLaunch();
+      return { status: 200, body: '{}' };
+    } catch (error) {
+      return error instanceof VerifyFailure ? failure(503, 'verify_not_ready_to_launch', error) : clerkError(503, 'verify_not_ready_to_launch', (error as Error).message ?? String(error));
+    }
+  }
+
   async function answer(request: IncomingMessage): Promise<Answer> {
     const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+    if (request.method === ABOUT_TO_LAUNCH.method && url.pathname === `${STAND_IN_PATH}${ABOUT_TO_LAUNCH.path}`) return readyToLaunch();
     const guard = guardFor(request.method, url.pathname);
     if (guard === undefined) return clerkError(404, 'verify_stand_in_unknown_call', `the verify CLI's stand-in for the Backend API has no ${request.method} ${url.pathname}; the tests make ${Object.values(BACKEND_CALLS).map((call) => `${call.method} ${call.path}`).join(', ')}`);
     let text = '';
diff --git a/integration/expo-native/src/core/cli.ts b/integration/expo-native/src/core/cli.ts
index 372289cb6f2..61c0dba0007 100644
--- a/integration/expo-native/src/core/cli.ts
+++ b/integration/expo-native/src/core/cli.ts
@@ -33,13 +33,20 @@ const USAGE_FIX = [
   '{cli} up [--platform p] [--backend auto|local|remote] [--runner <label>] [--wait <seconds>]',
   '{cli} run <feature|feature/spec|path.e2e.ts>... | --all [--platform p] [--backend auto|local|remote] [--runner <label>] [--grep re] [--retries <n>] [--github-report] [--no-video] [--wait <seconds>]',
   '{cli} screen [--platform p] [--png]',
-  '{cli} attach <run-id> --pr <n> [--screenshot label]...',
+  '{cli} attach <run-id> --pr <n> [--screenshot <label>]... [--video] [--before <run-id>], with at least one of --screenshot and --video',
   '{cli} down [--platform p] [--stale] [--dry-run]',
   'every verb takes --json',
 ].join('; ');
 
 const usage = (message: string) => new VerifyFailure('USAGE', message, USAGE_FIX);
 
+const nothingToShow = () =>
+  new VerifyFailure(
+    'USAGE',
+    '{cli} attach posts what you choose and nothing by default: screenshots show a still change such as wording, and the video shows behavior, movement or a flow',
+    '{cli} attach <run-id> --pr <n> --screenshot <label> [--screenshot <label>]..., or {cli} attach <run-id> --pr <n> --video; add --before <run-id> to either when the change is to something that already exists, and pass both flags only when one kind does not show the change',
+  );
+
 type FlagSpec = Readonly<Record<string, 'value' | 'bool' | 'list'>>;
 
 const FLAGS: Readonly<Record<Verb, FlagSpec>> = {
@@ -47,7 +54,7 @@ const FLAGS: Readonly<Record<Verb, FlagSpec>> = {
   up: { platform: 'value', backend: 'value', runner: 'value', wait: 'value' },
   run: { platform: 'value', backend: 'value', runner: 'value', all: 'bool', grep: 'value', retries: 'value', 'github-report': 'bool', 'no-video': 'bool', wait: 'value' },
   screen: { platform: 'value', png: 'bool' },
-  attach: { pr: 'value', screenshot: 'list' },
+  attach: { pr: 'value', screenshot: 'list', video: 'bool', before: 'value' },
   down: { platform: 'value', stale: 'bool', 'dry-run': 'bool' },
 };
 
@@ -156,8 +163,12 @@ export function parseArgv(argv: readonly string[]): Invocation {
       break;
     case 'attach': {
       if (positionals.length !== 1) throw usage('{cli} attach takes exactly one run id');
-      const shots = lists.get('screenshot');
-      command = { verb, run: parseRunId(positionals[0]!), pr: positiveInt('pr', values.get('pr'), undefined), screenshots: shots ?? 'all' };
+      const run = parseRunId(positionals[0]!);
+      const pr = positiveInt('pr', values.get('pr'), undefined);
+      const media = { screenshots: lists.get('screenshot') ?? [], video: bools.has('video') };
+      if (media.screenshots.length === 0 && !media.video) throw nothingToShow();
+      const before = values.get('before');
+      command = { verb, run, pr, media, before: before === undefined ? null : parseRunId(before) };
       break;
     }
     case 'down':
diff --git a/integration/expo-native/src/core/evidence.ts b/integration/expo-native/src/core/evidence.ts
index 6147aeb2f62..d67af7491ce 100644
--- a/integration/expo-native/src/core/evidence.ts
+++ b/integration/expo-native/src/core/evidence.ts
@@ -61,20 +61,27 @@ export function loggedUserIds(dir: EvidencePath): readonly string[] {
   return [...new Set([...readFileSync(file, 'utf8').matchAll(/"userId"\s*:\s*"([^"]+)"/g)].map((match) => match[1]!))];
 }
 
+export type Showable = Brand<EvidenceRecord, 'Showable' | 'Publishable'>;
 export type Publishable = Brand<EvidenceRecord, 'Publishable'>;
 
-export function assertPublishable(record: EvidenceRecord, loggedUsers: readonly string[]): Publishable {
-  const refuse = (message: string, fix: string): never => {
-    throw new VerifyFailure('EVIDENCE_UNSAFE', message, fix);
-  };
+const refuse = (message: string, fix: string): never => {
+  throw new VerifyFailure('EVIDENCE_UNSAFE', message, fix);
+};
+
+export function assertShowable(record: EvidenceRecord, loggedUsers: readonly string[]): Showable {
   if (record.tainted.length > 0) refuse(`run ${record.run} has secret values in ${record.tainted.join(', ')}`, 'do not attach this run; rerun and attach the new run');
+  const own = new Set(record.identities.flatMap((i) => (i.userId === null ? [] : [i.userId])));
+  const foreign = loggedUsers.filter((userId) => !own.has(userId));
+  if (foreign.length > 0) refuse(`the app log of run ${record.run} names user(s) the run did not create: ${foreign.join(', ')}`, 'sign in only users from host.seedUser or host.newEmail');
+  return record as Showable;
+}
+
+export function assertPublishable(record: EvidenceRecord, loggedUsers: readonly string[]): Publishable {
+  assertShowable(record, loggedUsers);
   const failed = record.results.filter((r) => r.status === 'failed' || r.status === 'interrupted');
-  if (failed.length > 0) refuse(`run ${record.run} has ${failed.length} failing spec(s)`, 'fix the failures and attach a passing run');
+  if (failed.length > 0) refuse(`run ${record.run} has ${failed.length} failing spec(s)`, 'fix the failures and attach a passing run; a failing run can only be the --before of a passing one');
   const incomplete = record.settings.filter((group) => group.held === false || group.e2eReport === null);
   if (incomplete.length > 0) refuse(`run ${record.run} has ${count(incomplete.length, 'group')} that did not run in full on its settings: ${incomplete.map((group) => group.label).join('; ')}`, 'attach a run in which every group ran on the settings it declares');
   if (!record.results.some((r) => r.status === 'passed' || r.status === 'flaky')) refuse(`run ${record.run} passed no specs`, 'attach a run whose specs ran and passed');
-  const own = new Set(record.identities.flatMap((i) => (i.userId === null ? [] : [i.userId])));
-  const foreign = loggedUsers.filter((userId) => !own.has(userId));
-  if (foreign.length > 0) refuse(`the app log of run ${record.run} names user(s) the run did not create: ${foreign.join(', ')}`, 'sign in only users from host.seedUser or host.newEmail');
   return record as Publishable;
 }
diff --git a/integration/expo-native/src/core/publish.ts b/integration/expo-native/src/core/publish.ts
index adf77ff70e5..339d0413af3 100644
--- a/integration/expo-native/src/core/publish.ts
+++ b/integration/expo-native/src/core/publish.ts
@@ -1,22 +1,12 @@
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { constants, copyFileSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { basename, join, relative, sep } from 'node:path';
+import { basename, extname, join } from 'node:path';
 import { run as defaultRunner, type Runner } from './exec.ts';
-import type { Publishable } from './evidence.ts';
-import { VerifyFailure, type AttachResult, type EvidencePath, type EvidenceSummary, type HostAdapter, type Platform } from './types.ts';
+import type { Publishable, Showable } from './evidence.ts';
+import { VerifyFailure, everyFile, type AttachResult, type EvidenceBundle, type EvidencePath, type EvidenceSummary, type HostAdapter, type MediaChoice, type Platform } from './types.ts';
 
-interface Posted {
-  readonly pr: number;
-  readonly prUrl: string;
-  readonly posted: readonly EvidencePath[];
-}
-
-export interface EvidenceMedia {
-  readonly alt: string;
-  readonly ref: string;
-}
-
-export function summarize(evidence: Publishable): EvidenceSummary {
+export function summarize(evidence: Showable): EvidenceSummary {
   return {
     run: evidence.run,
     platform: evidence.platform,
@@ -33,14 +23,43 @@ export const evidenceMarkers = (platform: Platform): { readonly start: string; r
   end: `<!-- /verify-evidence:${platform} -->`,
 });
 
-const BLOCK_LINE_START = 'verify run `';
+const BLOCK_LINE_START = '**Verified on ';
+const A_BLOCK_STARTS = /^(\*\*Verified on |verify run `)/;
+const WHERE: Readonly<Record<Platform, string>> = { ios: 'an iOS simulator', android: 'an Android emulator' };
 
-// GitHub plays a video only from a URL that is alone in its paragraph, and `gh pr edit --attach` rewrites a reference to that URL only there.
-export function evidenceBlock(summary: EvidenceSummary, media: readonly EvidenceMedia[]): string {
+const counted = (summary: EvidenceSummary): string => `${summary.passed} of ${summary.total} passed${summary.flaky === 0 ? '' : `, ${summary.flaky} flaky (passed only on a retry)`}`;
+const short = (commit: string): string => commit.slice(0, 12);
+
+export function evidenceBlock(summary: EvidenceSummary, before: EvidenceSummary | null, media: readonly string[]): string {
   const { start, end } = evidenceMarkers(summary.platform);
-  const flaky = summary.flaky === 0 ? '' : `, ${summary.flaky} flaky (passed only on a retry)`;
-  const line = `${BLOCK_LINE_START}${summary.run}\` on \`${summary.device}\` at \`${summary.commit.slice(0, 12)}\`, ${summary.passed} of ${summary.total} passed${flaky}.`;
-  return [start, '', line, ...media.flatMap((m) => ['', `![${m.alt}](${m.ref})`]), '', end].join('\n');
+  const was = before === null ? '' : ` Before is run \`${before.run}\` at \`${short(before.commit)}\`, ${counted(before)}.`;
+  const line = `${BLOCK_LINE_START}${WHERE[summary.platform]}.** Run \`${summary.run}\` on \`${summary.device}\` at \`${short(summary.commit)}\`, ${counted(summary)}.${was}`;
+  return [start, '', line, ...media.flatMap((part) => ['', part]), '', end].join('\n');
+}
+
+const IMAGE_WIDTH = 280;
+const ACROSS = 2;
+
+const isVideo = (name: string): boolean => name.endsWith('.mp4');
+const stem = (name: string): string => name.replace(/\.[a-z0-9]+$/, '');
+const table = (header: readonly string[], rows: readonly (readonly string[])[]): string => [header, header.map(() => ':---:'), ...rows].map((cells) => `| ${cells.join(' | ')} |`).join('\n');
+
+// `gh pr edit --attach` rewrites only a markdown reference to a file, so the files go up as a list first, and the tables are written from the addresses GitHub gave them.
+export const mediaList = (names: readonly string[], onDisk: readonly string[]): readonly string[] => names.map((name, at) => `![${isVideo(name) ? name : stem(name)}](./${onDisk[at]})`);
+
+export function mediaTables(files: readonly string[], hasBefore: boolean, uploaded: readonly string[]): readonly string[] {
+  const shown = files.map((name, at) => {
+    const label = stem(name);
+    const cell = (url: string, alt: string): string => (isVideo(name) ? url : `<img src="${url}" width="${IMAGE_WIDTH}" alt="${alt}">`);
+    return { video: isVideo(name), label, after: cell(uploaded[at]!, hasBefore ? `After: ${label}` : label), before: hasBefore ? cell(uploaded[files.length + at]!, `Before: ${label}`) : '' };
+  });
+  return [false, true].flatMap((video) => {
+    const some = shown.filter((item) => item.video === video);
+    if (some.length === 0) return [];
+    if (hasBefore) return [table(['Before', 'After'], some.map((item) => [item.before, item.after]))];
+    const rows = Array.from({ length: Math.ceil(some.length / ACROSS) }, (_, row) => some.slice(row * ACROSS, (row + 1) * ACROSS));
+    return rows.map((row) => table(row.map((item) => `\`${item.label}\``), [row.map((item) => item.after)]));
+  });
 }
 
 export class CannotPostHere extends VerifyFailure {
@@ -107,7 +126,7 @@ export function withEvidenceBlock(body: string, platform: Platform, lines: strin
   }
   if (starts.length !== 1 || ends.length !== 1) return { ok: false, why: `has \`${start}\` ${starts.length} times and \`${end}\` ${ends.length} times`, fix: ONE_PAIR_OF_MARKERS };
   if (ends[0]! < starts[0]!) return { ok: false, why: `has \`${end}\` before \`${start}\``, fix: ONE_PAIR_OF_MARKERS };
-  if (!body.slice(starts[0]! + start.length, ends[0]!).trimStart().startsWith(BLOCK_LINE_START)) return { ok: false, why: `has text between \`${start}\` and \`${end}\` that is not an evidence block`, fix: ONE_PAIR_OF_MARKERS };
+  if (!A_BLOCK_STARTS.test(body.slice(starts[0]! + start.length, ends[0]!).trimStart())) return { ok: false, why: `has text between \`${start}\` and \`${end}\` that is not an evidence block`, fix: ONE_PAIR_OF_MARKERS };
   return { ok: true, body: `${body.slice(0, starts[0]!)}${block}${body.slice(ends[0]! + end.length)}`, was: 'replaced' };
 }
 
@@ -119,76 +138,116 @@ export async function missingAttach(runner: Runner): Promise<{ readonly why: str
   return { why: help.code === 0 ? 'this gh has no `gh pr edit --attach`' : 'gh is not installed', fix: ATTACH_FIX };
 }
 
-export function chooseFiles(evidence: Publishable, screenshots: 'all' | readonly string[]): { readonly videos: readonly EvidencePath[]; readonly shots: Publishable['screenshots'] } {
-  if (screenshots === 'all') return { videos: evidence.videos, shots: evidence.screenshots };
-  const shots = screenshots.map((label) => {
-    const shot = evidence.screenshots.find((s) => s.label === label);
-    if (shot === undefined) {
-      throw new VerifyFailure('USAGE', `run ${evidence.run} has no screenshot labelled ${label}`, `use one of: ${evidence.screenshots.map((s) => s.label).join(', ') || '(none)'}`);
-    }
-    return shot;
-  });
-  return { videos: evidence.videos, shots };
+export function chooseEvidence(pr: number, evidence: Publishable, before: Showable | null, media: MediaChoice): EvidenceBundle {
+  const missing = (what: string, fix: string): never => {
+    throw new VerifyFailure('USAGE', what, fix);
+  };
+  const shots = media.screenshots.map(
+    (label) => evidence.screenshots.find((s) => s.label === label) ?? missing(`run ${evidence.run} has no screenshot labelled ${label}`, `use one of: ${evidence.screenshots.map((s) => s.label).join(', ') || '(none)'}`),
+  );
+  const noVideo = (run: string): string => `run ${run} has no video: a run records one from the first time a test launches the app, unless it has --no-video`;
+  const video = media.video ? [evidence.videos[0] ?? missing(noVideo(evidence.run), '{cli} run a spec that calls host.launch, without --no-video, and attach that run, or attach this one with --screenshot <label>')] : [];
+  const files = [...shots.map((shot) => shot.path), ...video].map((path) => ({ name: basename(path), path }));
+  const summary = summarize(evidence);
+  if (before === null) return { pr, summary, files, before: null };
+
+  const failure = before.results.find((r) => r.status === 'failed' && r.failureScreenshot !== null)?.failureScreenshot;
+  const was = [
+    ...shots.map(
+      ({ label }) =>
+        before.screenshots.find((s) => s.label === label)?.path ??
+        failure ??
+        missing(`run ${before.run} has no screenshot labelled ${label}, and no failure screenshot to show in its place`, `call host.screenshot('${label}') in the spec and run it on the build without the change, or attach without --before`),
+    ),
+    ...video.map(() => before.videos[0] ?? missing(noVideo(before.run), '{cli} run it again without --no-video, or attach without --video or without --before')),
+  ];
+  return { pr, summary, files, before: { summary: summarize(before), files: was.map((path, at) => ({ name: `before-${files[at]!.name}`, path })) } };
+}
+
+const UPLOADED = /https:\/\/github\.com\/user-attachments\/assets\/[0-9a-f-]{36}/g;
+
+function blockIn(body: string, platform: Platform): string | null {
+  const { start, end } = evidenceMarkers(platform);
+  const starts = linesThatAre(body, start);
+  const ends = linesThatAre(body, end);
+  if (starts.length !== 1 || ends.length !== 1 || ends[0]! < starts[0]!) return null;
+  return body.slice(starts[0]!, ends[0]! + end.length).replaceAll('\r\n', '\n');
+}
+
+function uploadedIn(body: string, platform: Platform, run: string): readonly string[] {
+  const block = blockIn(body, platform);
+  return block === null || !block.includes(`\`${run}\``) ? [] : (block.match(UPLOADED) ?? []);
 }
 
 async function readDescription(runner: Runner, repo: string, pr: number): Promise<{ readonly body: string; readonly url: string }> {
-  const viewed = await runner('gh', ['pr', 'view', String(pr), '--repo', repo, '--json', 'body,url']);
+  const viewed = await runner('gh', ['pr', 'view', String(pr), '--repo', repo, '--json', 'body,url,state']);
   if (viewed.code !== 0) throw new CannotPostHere('gh pr view failed', `gh pr view failed: ${viewed.stderr.trim()}`, 'check `gh auth status` and that the PR exists');
-  const parsed = JSON.parse(viewed.stdout) as { readonly body?: string | null; readonly url?: string };
+  const parsed = JSON.parse(viewed.stdout) as { readonly body?: string | null; readonly url?: string; readonly state?: string };
+  if (parsed.state !== 'OPEN') {
+    throw new VerifyFailure('USAGE', `PR #${pr} of ${repo} is ${parsed.state?.toLowerCase() ?? 'not known to be open'}, and attach writes only to an open pull request`, `pass the number of an open pull request as --pr, or reopen PR #${pr}, then rerun {cli} attach`);
+  }
   return { body: parsed.body ?? '', url: parsed.url ?? '' };
 }
 
-export async function postToPullRequest(
-  evidence: Publishable,
-  dir: EvidencePath,
-  host: HostAdapter,
-  pr: number,
-  screenshots: 'all' | readonly string[],
-  runner: Runner = defaultRunner,
-): Promise<AttachResult> {
-  const postedFile = join(dir, `posted-${pr}.json`);
-  if (existsSync(postedFile)) {
-    const previous = JSON.parse(readFileSync(postedFile, 'utf8')) as Posted;
-    return { verb: 'attach', via: 'gh', prUrl: previous.prUrl, posted: previous.posted, alreadyPosted: true };
-  }
-  const { videos, shots } = chooseFiles(evidence, screenshots);
-  const files = [...videos, ...shots.map((s) => s.path)];
-  const missing = files.length === 0 ? null : await missingAttach(runner);
-  if (missing !== null) throw new CannotPostHere(missing.why, `${missing.why}, so the video and screenshots of run ${evidence.run} cannot be posted`, missing.fix);
+export async function postToPullRequest(bundle: EvidenceBundle, host: HostAdapter, runner: Runner = defaultRunner): Promise<AttachResult> {
+  const { pr, summary } = bundle;
+  const { run, platform } = summary;
+  const before = bundle.before?.summary ?? null;
+  const files = everyFile(bundle);
+  const paths = files.map((file) => file.path);
+  const missing = await missingAttach(runner);
+  if (missing !== null) throw new CannotPostHere(missing.why, `${missing.why}, so the video and screenshots of run ${run} cannot be posted`, missing.fix);
 
-  const ref = (file: EvidencePath): string => `./${relative(dir, file).split(sep).join('/')}`;
-  const block = evidenceBlock(summarize(evidence), [
-    ...videos.map((video) => ({ alt: basename(video), ref: ref(video) })),
-    ...shots.map((shot) => ({ alt: shot.label, ref: ref(shot.path) })),
-  ]);
+  const prefix = `evidence-${randomBytes(8).toString('hex')}`;
+  const onDisk = files.map((file, at) => `${prefix}-${at + 1}${extname(file.name)}`);
+  const listed = evidenceBlock(summary, before, mediaList(files.map((file) => file.name), onDisk));
+  const laidOutWith = (uploaded: readonly string[]): string => evidenceBlock(summary, before, mediaTables(bundle.files.map((file) => file.name), before !== null, uploaded));
 
   let current = await readDescription(runner, host.githubRepo, pr);
+  const there = blockIn(current.body, platform);
+  const anUpload = 'https://github.com/user-attachments/assets/00000000-0000-0000-0000-000000000000';
+  if (there !== null && there.match(UPLOADED)?.length === files.length && there.replace(UPLOADED, anUpload) === laidOutWith(files.map(() => anUpload))) {
+    return { verb: 'attach', via: 'gh', prUrl: current.url, posted: paths, alreadyPosted: true };
+  }
   let next: string | null = null;
   for (let attempt = 0; attempt < 2 && next === null; attempt += 1) {
-    const edit = withEvidenceBlock(current.body, evidence.platform, block);
+    const edit = withEvidenceBlock(current.body, platform, listed);
     if (!edit.ok) {
-      throw new VerifyFailure('NOT_READY', `the description of PR #${pr} ${edit.why}, so the evidence of run ${evidence.run} has no one place to go`, `${edit.fix}, then rerun`);
+      throw new VerifyFailure('NOT_READY', `the description of PR #${pr} ${edit.why}, so the evidence of run ${run} has no one place to go`, `${edit.fix}, then rerun`);
     }
     const again = await readDescription(runner, host.githubRepo, pr);
     if (again.body === current.body) next = edit.body;
     else current = again;
   }
   if (next === null) {
-    throw new VerifyFailure('NOT_READY', `the description of PR #${pr} changed twice while the evidence of run ${evidence.run} was being placed, so nothing was written`, 'rerun {cli} attach once nobody is editing the description');
+    throw new VerifyFailure('NOT_READY', `the description of PR #${pr} changed twice while the evidence of run ${run} was being placed, so nothing was written`, 'rerun {cli} attach once nobody is editing the description');
   }
 
   const scratch = mkdtempSync(join(tmpdir(), 'verify-attach-'));
   try {
+    files.forEach((file, at) => copyFileSync(file.path, join(scratch, onDisk[at]!), constants.COPYFILE_FICLONE));
     const bodyFile = join(scratch, 'body.md');
-    writeFileSync(bodyFile, next);
-    const result = await runner('gh', ['pr', 'edit', String(pr), '--repo', host.githubRepo, '--body-file', bodyFile, ...files.flatMap((f) => ['--attach', ref(f)])], { cwd: dir });
-    if (result.code !== 0) {
-      throw new CannotPostHere('gh pr edit failed', `gh pr edit failed: ${result.stderr.trim()}`, 'check `gh auth status` and that you can edit the PR; a file that did upload is in the description already');
+    const edit = (body: string, attach: readonly string[]) => {
+      writeFileSync(bodyFile, body);
+      return runner('gh', ['pr', 'edit', String(pr), '--repo', host.githubRepo, '--body-file', bodyFile, ...attach.flatMap((name) => ['--attach', `./${name}`])], { cwd: scratch });
+    };
+    const sent = await edit(next, onDisk);
+    if (sent.code !== 0) {
+      throw new CannotPostHere('gh pr edit failed', `gh pr edit failed: ${sent.stderr.trim()}`, 'check `gh auth status` and that you can edit the PR; a file that did upload is in the description already');
     }
-    const prUrl = /https:\/\/github\.com\/\S+/.exec(result.stdout)?.[0] ?? current.url;
-    const posted: Posted = { pr, prUrl, posted: files };
-    writeFileSync(postedFile, `${JSON.stringify(posted, null, 2)}\n`);
-    return { verb: 'attach', via: 'gh', prUrl, posted: files, alreadyPosted: false };
+    const prUrl = /https:\/\/github\.com\/\S+/.exec(sent.stdout)?.[0] ?? current.url;
+
+    const notLaidOut = (why: string): VerifyFailure =>
+      new VerifyFailure('NOT_READY', `the files of run ${run} are in the description of PR #${pr} as a list, one under the other, and were not laid out: ${why}`, 'rerun {cli} attach once nobody is editing the description');
+    const listedNow = (await readDescription(runner, host.githubRepo, pr)).body;
+    const uploaded = uploadedIn(listedNow, platform, run);
+    if (uploaded.length !== files.length) throw notLaidOut(`the block there now does not show run ${run} with the ${files.length} addresses GitHub gave its files`);
+    const laidOut = withEvidenceBlock(listedNow, platform, laidOutWith(uploaded));
+    if (!laidOut.ok) throw notLaidOut(`the description ${laidOut.why}`);
+    const arranged = await edit(laidOut.body, []);
+    if (arranged.code !== 0) throw notLaidOut(`gh pr edit failed: ${arranged.stderr.trim()}`);
+
+    return { verb: 'attach', via: 'gh', prUrl, posted: paths, alreadyPosted: false };
   } finally {
     rmSync(scratch, { recursive: true, force: true });
   }
diff --git a/integration/expo-native/src/core/remote/backend.ts b/integration/expo-native/src/core/remote/backend.ts
index 54316f040b8..23a839c923f 100644
--- a/integration/expo-native/src/core/remote/backend.ts
+++ b/integration/expo-native/src/core/remote/backend.ts
@@ -4,7 +4,7 @@ import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import type { ReadableStream } from 'node:stream/web';
 import { run, sleep } from '../exec.ts';
-import { VerifyFailure, type AcquireRequest, type DeviceBackend, type EvidencePath, type Recording, type RemoteLease } from '../types.ts';
+import { VerifyFailure, everyFile, type AcquireRequest, type DeviceBackend, type EvidenceFile, type EvidencePath, type Recording, type RemoteLease } from '../types.ts';
 import { apiMessage, currentBranch, endSession, liveRuns, openGitHub, startRun, viewRun, waitForStep, waitReporter, type GitHub } from './github.ts';
 import { HANDOFF_VERSION, HandoffRefused, describeFile, parseHandoffManifest, pullRequestMismatch, type HandoffManifest } from './handoff.ts';
 import { coreVersion } from '../manifest.ts';
@@ -251,17 +251,31 @@ export function remoteBackend(settings: RemoteSettings, deps: RemoteDeps = { env
         { repo: settings.repo, headBranch: started.head_branch, startedOn: started.head_sha, runCommit: bundle.summary.commit },
       );
       if (mismatch !== null) throw wouldNot(mismatch.why, mismatch.fix);
+      if (bundle.before !== null) {
+        const was = bundle.before.summary;
+        const compared = await hub.api('GET', `/compare/${was.commit}...${bundle.summary.commit}?per_page=1`);
+        if (compared.status !== 200 && compared.status !== 404) throw new VerifyFailure('NOT_READY', `could not compare the commit of run ${was.run} with the commit of run ${run}: ${apiMessage(compared)}`, 'retry {cli} attach');
+        const status = (compared.json as { readonly status?: string } | null)?.status;
+        if (status !== 'ahead' && status !== 'identical') {
+          throw wouldNot(
+            `the before run ${was.run} was made at ${was.commit.slice(0, 12)}, which is not the commit of the run or a commit before it in its history`,
+            `{cli} run the spec at a commit that ${bundle.summary.commit.slice(0, 12)} still has in its history and does not hold the change, and pass that run as --before, or attach without --before and name the before run in the PR`,
+          );
+        }
+      }
       const place = withEvidenceBlock(pr.body ?? '', bundle.summary.platform, '');
       if (!place.ok) throw wouldNot(`its description ${place.why}, so the evidence has no one place to go`, `${place.fix}, then rerun {cli} attach`);
       let manifest: HandoffManifest;
       try {
-        manifest = parseHandoffManifest(JSON.stringify({ v: HANDOFF_VERSION, pr: bundle.pr, ...bundle.summary, files: bundle.files.map((file) => describeFile(file.name, file.path)) }));
+        const described = (files: readonly EvidenceFile[]) => files.map((file) => describeFile(file.name, file.path));
+        const was = bundle.before === null ? null : { run: bundle.before.summary.run, commit: bundle.before.summary.commit, passed: bundle.before.summary.passed, flaky: bundle.before.summary.flaky, total: bundle.before.summary.total, files: described(bundle.before.files) };
+        manifest = parseHandoffManifest(JSON.stringify({ v: HANDOFF_VERSION, pr: bundle.pr, ...bundle.summary, files: described(bundle.files), before: was }));
       } catch (error) {
         if (!(error instanceof HandoffRefused)) throw error;
-        throw new VerifyFailure('NOT_READY', `the evidence of run ${run} cannot be handed to the runner: ${error.message}`, 'attach fewer or smaller files with --screenshot, or rerun with --no-video');
+        throw new VerifyFailure('NOT_READY', `the evidence of run ${run} cannot be handed to the runner: ${error.message}`, 'attach fewer or smaller files: fewer --screenshot labels, or no --video');
       }
       try {
-        await sendEvidence(lease, manifest, new Map(bundle.files.map((file) => [file.name, file.path])), progress);
+        await sendEvidence(lease, manifest, new Map(everyFile(bundle).map((file) => [file.name, file.path])), progress);
       } catch (error) {
         if (error instanceof VerifyFailure) throw error;
         throw new VerifyFailure('NOT_READY', `the hand-off of run ${run} failed: ${(error as Error).message}`, 'run {cli} attach again while the session is up');
diff --git a/integration/expo-native/src/core/remote/handoff.ts b/integration/expo-native/src/core/remote/handoff.ts
index 05bc2d9b31f..b923a6dd128 100644
--- a/integration/expo-native/src/core/remote/handoff.ts
+++ b/integration/expo-native/src/core/remote/handoff.ts
@@ -1,9 +1,9 @@
 import { createHash } from 'node:crypto';
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import type { Platform } from '../types.ts';
+import { everyFile, type Platform } from '../types.ts';
 
-export const HANDOFF_VERSION = 1 as const;
+export const HANDOFF_VERSION = 2 as const;
 
 export const HANDOFF = {
   artifact: 'verify-evidence',
@@ -33,6 +33,15 @@ export interface HandoffFile {
   readonly sha256: string;
 }
 
+export interface HandoffBefore {
+  readonly run: string;
+  readonly commit: string;
+  readonly passed: number;
+  readonly flaky: number;
+  readonly total: number;
+  readonly files: readonly HandoffFile[];
+}
+
 export interface HandoffManifest {
   readonly v: typeof HANDOFF_VERSION;
   readonly pr: number;
@@ -44,6 +53,7 @@ export interface HandoffManifest {
   readonly flaky: number;
   readonly total: number;
   readonly files: readonly HandoffFile[];
+  readonly before: HandoffBefore | null;
 }
 
 const SHAPE = {
@@ -54,7 +64,8 @@ const SHAPE = {
   fileName: /^[A-Za-z0-9][A-Za-z0-9._-]{0,95}\.(png|jpg|mp4)$/,
 } as const;
 
-const MANIFEST_KEYS = ['v', 'pr', 'run', 'platform', 'device', 'commit', 'passed', 'flaky', 'total', 'files'];
+const MANIFEST_KEYS = ['v', 'pr', 'run', 'platform', 'device', 'commit', 'passed', 'flaky', 'total', 'files', 'before'];
+const BEFORE_KEYS = ['run', 'commit', 'passed', 'flaky', 'total', 'files'];
 const FILE_KEYS = ['name', 'bytes', 'sha256'];
 
 export class HandoffRefused extends Error {
@@ -71,13 +82,18 @@ const refuse = (message: string): never => {
   throw new HandoffRefused(400, message);
 };
 
-function record(value: unknown, keys: readonly string[], what: string): Record<string, unknown> {
+function anObject(value: unknown, what: string): Record<string, unknown> {
   if (typeof value !== 'object' || value === null || Array.isArray(value)) return refuse(`${what} is not an object`);
-  const extra = Object.keys(value).filter((key) => !keys.includes(key));
-  if (extra.length > 0 || Object.keys(value).length !== keys.length) return refuse(`${what} must have exactly the keys ${keys.join(', ')}`);
   return value as Record<string, unknown>;
 }
 
+function record(value: unknown, keys: readonly string[], what: string): Record<string, unknown> {
+  const raw = anObject(value, what);
+  const extra = Object.keys(raw).filter((key) => !keys.includes(key));
+  if (extra.length > 0 || Object.keys(raw).length !== keys.length) return refuse(`${what} must have exactly the keys ${keys.join(', ')}`);
+  return raw;
+}
+
 function whole(value: unknown, min: number, max: number, what: string): number {
   if (typeof value !== 'number' || !Number.isInteger(value) || value < min || value > max) return refuse(`${what} must be a whole number from ${min} to ${max}`);
   return value;
@@ -90,6 +106,33 @@ function shaped(value: unknown, pattern: RegExp, what: string): string {
 
 export const isVideo = (name: string): boolean => name.endsWith('.mp4');
 
+function parseFiles(list: unknown, what: string): HandoffFile[] {
+  if (!Array.isArray(list) || list.length < 1 || list.length > HANDOFF_LIMITS.files) return refuse(`${what} must be a list of 1 to ${HANDOFF_LIMITS.files}`);
+  const files = (list as unknown[]).map((entry, i): HandoffFile => {
+    const file = record(entry, FILE_KEYS, `file ${i + 1}`);
+    const name = shaped(file.name, SHAPE.fileName, `the name of file ${i + 1}`);
+    return { name, bytes: whole(file.bytes, 1, isVideo(name) ? HANDOFF_LIMITS.videoBytes : HANDOFF_LIMITS.imageBytes, `the size of ${name}`), sha256: shaped(file.sha256, SHAPE.sha256, `the sha256 of ${name}`) };
+  });
+  if (files.filter((file) => isVideo(file.name)).length > HANDOFF_LIMITS.videos) refuse(`at most ${HANDOFF_LIMITS.videos} video`);
+  return files;
+}
+
+function parseBefore(value: unknown, run: unknown, files: readonly HandoffFile[]): HandoffBefore {
+  const raw = record(value, BEFORE_KEYS, 'before');
+  const before: HandoffBefore = {
+    run: shaped(raw.run, SHAPE.run, 'the run of before'),
+    commit: shaped(raw.commit, SHAPE.commit, 'the commit of before'),
+    passed: whole(raw.passed, 0, HANDOFF_LIMITS.tests, 'passed of before'),
+    flaky: whole(raw.flaky, 0, HANDOFF_LIMITS.tests, 'flaky of before'),
+    total: whole(raw.total, 1, HANDOFF_LIMITS.tests, 'total of before'),
+    files: parseFiles(raw.files, 'the files of before'),
+  };
+  if (before.run === run) refuse('before is the run itself');
+  if (before.passed + before.flaky > before.total) refuse('passed and flaky of before must count at most total');
+  if (before.files.length !== files.length || before.files.some((file, i) => isVideo(file.name) !== isVideo(files[i]!.name))) refuse('before must have one file for each file, of the same kind');
+  return before;
+}
+
 export function parseHandoffManifest(text: string): HandoffManifest {
   if (Buffer.byteLength(text) > HANDOFF_LIMITS.manifestBytes) refuse(`the manifest is over ${HANDOFF_LIMITS.manifestBytes} bytes`);
   let parsed: unknown;
@@ -98,18 +141,19 @@ export function parseHandoffManifest(text: string): HandoffManifest {
   } catch {
     return refuse('the manifest is not JSON');
   }
+  const { v } = anObject(parsed, 'the manifest');
+  if (v !== HANDOFF_VERSION) {
+    const found = typeof v === 'number' && Number.isInteger(v) && v >= 0 && v <= 999 ? `version ${v}` : 'of no version this session knows';
+    refuse(`the manifest is ${found}, and this session takes only version ${HANDOFF_VERSION}`);
+  }
   const raw = record(parsed, MANIFEST_KEYS, 'the manifest');
-  if (raw.v !== HANDOFF_VERSION) refuse(`manifest version ${String(raw.v)} is not ${HANDOFF_VERSION}`);
   if (raw.platform !== 'ios' && raw.platform !== 'android') refuse('platform must be ios or android');
-  if (!Array.isArray(raw.files) || raw.files.length < 1 || raw.files.length > HANDOFF_LIMITS.files) refuse(`files must be a list of 1 to ${HANDOFF_LIMITS.files}`);
-  const files = (raw.files as unknown[]).map((entry, i): HandoffFile => {
-    const file = record(entry, FILE_KEYS, `file ${i + 1}`);
-    const name = shaped(file.name, SHAPE.fileName, `the name of file ${i + 1}`);
-    return { name, bytes: whole(file.bytes, 1, isVideo(name) ? HANDOFF_LIMITS.videoBytes : HANDOFF_LIMITS.imageBytes, `the size of ${name}`), sha256: shaped(file.sha256, SHAPE.sha256, `the sha256 of ${name}`) };
-  });
-  if (new Set(files.map((file) => file.name.toLowerCase())).size !== files.length) refuse('two files have the same name');
-  if (files.filter((file) => isVideo(file.name)).length > HANDOFF_LIMITS.videos) refuse(`at most ${HANDOFF_LIMITS.videos} video`);
-  if (files.reduce((sum, file) => sum + file.bytes, 0) > HANDOFF_LIMITS.totalBytes) refuse(`the files are over ${HANDOFF_LIMITS.totalBytes} bytes in all`);
+  const files = parseFiles(raw.files, 'files');
+  const before = raw.before === null ? null : parseBefore(raw.before, raw.run, files);
+  const all = everyFile({ files, before });
+  if (all.length > HANDOFF_LIMITS.files) refuse(`at most ${HANDOFF_LIMITS.files} files in all`);
+  if (new Set(all.map((file) => file.name.toLowerCase())).size !== all.length) refuse('two files have the same name');
+  if (all.reduce((sum, file) => sum + file.bytes, 0) > HANDOFF_LIMITS.totalBytes) refuse(`the files are over ${HANDOFF_LIMITS.totalBytes} bytes in all`);
   const manifest: HandoffManifest = {
     v: HANDOFF_VERSION,
     pr: whole(raw.pr, 1, HANDOFF_LIMITS.pr, 'pr'),
@@ -121,6 +165,7 @@ export function parseHandoffManifest(text: string): HandoffManifest {
     flaky: whole(raw.flaky, 0, HANDOFF_LIMITS.tests, 'flaky'),
     total: whole(raw.total, 1, HANDOFF_LIMITS.tests, 'total'),
     files,
+    before,
   };
   if (manifest.passed + manifest.flaky < 1 || manifest.passed + manifest.flaky > manifest.total) refuse('passed and flaky must count at least one test and at most total');
   return manifest;
@@ -186,7 +231,7 @@ export function evidenceReceiver(work: string): EvidenceReceiver {
       rmSync(staging, { recursive: true, force: true });
       mkdirSync(staging, { recursive: true });
       writeFileSync(join(staging, HANDOFF.manifestFile), `${JSON.stringify(manifest)}\n`);
-      receiving = { manifest, sizes: new Map(manifest.files.map((file) => [file.name, 0])) };
+      receiving = { manifest, sizes: new Map(everyFile(manifest).map((file) => [file.name, 0])) };
       return { ok: true };
     },
 
@@ -199,7 +244,7 @@ export function evidenceReceiver(work: string): EvidenceReceiver {
       } catch (error) {
         throw error instanceof HandoffRefused ? error : new HandoffRefused(400, 'the chunk is not JSON');
       }
-      const declared = receiving.manifest.files.find((file) => file.name === raw.name);
+      const declared = everyFile(receiving.manifest).find((file) => file.name === raw.name);
       if (declared === undefined) throw new HandoffRefused(400, 'the manifest names no such file');
       const have = receiving.sizes.get(declared.name)!;
       if (raw.offset !== have) throw new HandoffRefused(409, `${declared.name} is at ${have} bytes`, have);
@@ -215,7 +260,8 @@ export function evidenceReceiver(work: string): EvidenceReceiver {
     commit() {
       if (receiving === null) throw new HandoffRefused(409, 'no hand-off has begun');
       const { manifest, sizes } = receiving;
-      for (const file of manifest.files) {
+      const files = everyFile(manifest);
+      for (const file of files) {
         if (sizes.get(file.name) !== file.bytes) throw new HandoffRefused(409, `${file.name} has ${sizes.get(file.name)} of ${file.bytes} bytes`);
         if (sha256File(join(staging, file.name)) !== file.sha256) throw new HandoffRefused(409, `${file.name} does not have the sha256 its manifest declares`);
       }
@@ -223,7 +269,7 @@ export function evidenceReceiver(work: string): EvidenceReceiver {
       renameSync(staging, kept);
       receiving = null;
       heldRun = manifest.run;
-      return { ok: true, run: manifest.run, files: manifest.files.length, bytes: manifest.files.reduce((sum, file) => sum + file.bytes, 0) };
+      return { ok: true, run: manifest.run, files: files.length, bytes: files.reduce((sum, file) => sum + file.bytes, 0) };
     },
 
     held: () => (heldRun !== null && existsSync(kept) ? heldRun : null),
diff --git a/integration/expo-native/src/core/remote/session.ts b/integration/expo-native/src/core/remote/session.ts
index 2f19eb5aa7a..2a371550220 100644
--- a/integration/expo-native/src/core/remote/session.ts
+++ b/integration/expo-native/src/core/remote/session.ts
@@ -1,7 +1,7 @@
 import { closeSync, openSync, readFileSync, readSync } from 'node:fs';
 import { sleep } from '../exec.ts';
 import { Secret } from '../../../specs/support/secret.ts';
-import { VerifyFailure } from '../types.ts';
+import { VerifyFailure, everyFile } from '../types.ts';
 import { HANDOFF_LIMITS, type HandoffManifest } from './handoff.ts';
 import type { SessionHealth } from './protocol.ts';
 import { TUNNEL, isTunnelHost } from './tunnel.ts';
@@ -80,8 +80,11 @@ export async function sendEvidence(ref: SessionRef, manifest: HandoffManifest, p
   const refused = (what: string, answer: EvidenceAnswer) => new Error(`the session did not take ${what}: ${answer.status === 0 ? answer.error : `${answer.status} ${answer.error}`}`);
 
   const began = await post('begin', manifest);
+  if (began.status === 400) {
+    throw new VerifyFailure('NOT_READY', `the session refused the manifest of run ${manifest.run}: ${began.error}`, '{cli} down, then {cli} up, so that the session runs the verify code of this checkout, then {cli} run again and attach');
+  }
   if (began.status !== 200) throw refused('the manifest', began);
-  for (const file of manifest.files) {
+  for (const file of everyFile(manifest)) {
     const fd = openSync(paths.get(file.name)!, 'r');
     try {
       const buffer = Buffer.alloc(HANDOFF_LIMITS.chunkBytes);
diff --git a/integration/expo-native/src/core/types.ts b/integration/expo-native/src/core/types.ts
index dac87578c74..f9beb03efe5 100644
--- a/integration/expo-native/src/core/types.ts
+++ b/integration/expo-native/src/core/types.ts
@@ -69,7 +69,7 @@ export type Command =
       readonly waitSeconds: number;
     }
   | { readonly verb: 'screen'; readonly platform?: Platform; readonly png: boolean }
-  | { readonly verb: 'attach'; readonly run: RunId; readonly pr: number; readonly screenshots: 'all' | readonly string[] }
+  | { readonly verb: 'attach'; readonly run: RunId; readonly pr: number; readonly media: MediaChoice; readonly before: RunId | null }
   | { readonly verb: 'down'; readonly platform?: Platform; readonly stale: boolean; readonly dryRun: boolean };
 
 export type Verb = Command['verb'];
@@ -189,12 +189,25 @@ export interface EvidenceSummary {
   readonly total: number;
 }
 
+export interface MediaChoice {
+  readonly screenshots: readonly string[];
+  readonly video: boolean;
+}
+
+export interface EvidenceFile {
+  readonly name: string;
+  readonly path: EvidencePath;
+}
+
 export interface EvidenceBundle {
   readonly pr: number;
   readonly summary: EvidenceSummary;
-  readonly files: readonly { readonly name: string; readonly path: EvidencePath }[];
+  readonly files: readonly EvidenceFile[];
+  readonly before: { readonly summary: EvidenceSummary; readonly files: readonly EvidenceFile[] } | null;
 }
 
+export const everyFile = <F>(evidence: { readonly files: readonly F[]; readonly before: { readonly files: readonly F[] } | null }): readonly F[] => [...evidence.files, ...(evidence.before?.files ?? [])];
+
 export interface HandOffReceipt {
   readonly sessionRun: string;
   readonly sessionRunUrl: string;
diff --git a/integration/expo-native/src/core/verbs.ts b/integration/expo-native/src/core/verbs.ts
index 4c2a6c36ccc..5d690fe8853 100644
--- a/integration/expo-native/src/core/verbs.ts
+++ b/integration/expo-native/src/core/verbs.ts
@@ -1,5 +1,5 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { basename, dirname, join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { isOrphaned, readClaims } from './claims.ts';
 import { check, type AppliedInstance, type Instances } from './instances/instances.ts';
 import { STANDARD, SettingsRefused, planGroups, readSpecText, settingsFileOf, sourceHash, straySettingsFile, type SettingsGroup } from './instances/settings.ts';
@@ -15,17 +15,18 @@ import { backendFor, computeBuildKey, describeChoice, deviceOf, ensureLease, lea
 import { assertSomethingRan, collectScreenshots, e2eOutputDir, invokeE2E, parseE2EReport, planE2E, resolveSpecs } from './e2e.ts';
 import { startBroker, type Broker } from './broker.ts';
 import { watchDriver, type DriverWatch } from './driver.ts';
-import { assertPublishable, loggedUserIds, readRecord, sealEvidence } from './evidence.ts';
+import { assertPublishable, assertShowable, loggedUserIds, readRecord, sealEvidence, type Showable } from './evidence.ts';
 import { protectGitHubTokens, reportToGitHub } from './github-report.ts';
 import { isRunning, type Runner } from './exec.ts';
 import { ledgerAgentDeviceDaemon, processesIn, readDaemonInfo, stopProcesses, type ProcessEntry } from './ledgers.ts';
 import { SHARED_ROOTS, manifestDrift } from './manifest.ts';
-import { CannotPostHere, chooseFiles, missingAttach, postToPullRequest, summarize } from './publish.ts';
+import { CannotPostHere, chooseEvidence, missingAttach, postToPullRequest } from './publish.ts';
 import { redact } from '../../specs/support/secret.ts';
 import { count } from './state.ts';
 import { newEntryId, parseRunId, type Workspace } from './workspace.ts';
 import {
   VerifyFailure,
+  everyFile,
   type AttachResult,
   type BackendKind,
   type Command,
@@ -178,6 +179,13 @@ async function startRuntime(deps: Deps, lease: Lease): Promise<string | null> {
 }
 
 const agentDeviceSession = (workspace: Workspace, platform: Platform) => `verify-${platform}-${workspace.worktreeId}`;
+const CLOSE_BEFORE_RECORDING_MS = 30_000;
+
+function agentDeviceFor(deps: Deps, lease: Lease, platform: Platform) {
+  const target = agentDeviceOn(deviceOf(lease), platform);
+  const env = { ...withoutClerkKeys(deps.env), AGENT_DEVICE_STATE_DIR: deps.workspace.agentDeviceDir, ...target.env };
+  return { selector: target.selector, call: (args: readonly string[], limit: { readonly timeoutMs?: number } = {}) => deps.runner(join(deps.workspace.packageDir, 'node_modules', '.bin', 'agent-device'), args, { env, ...limit }) };
+}
 
 const targetOf = (deps: Deps, outcome: RuntimeOutcome): Target => ({
   platform: outcome.lease.platform,
@@ -246,7 +254,7 @@ export function nextStep(run: RunId, dir: EvidencePath, results: readonly SpecRe
   const failed = results.filter((r) => r.status === 'failed' || r.status === 'interrupted');
   if (failed.length > 0) return failed[0]?.failurePage ?? join(dir, 'e2e.log');
   if (ran === 'all-left-out') return 'nothing ran: every selected spec was left out by platform, so the run proves nothing to post';
-  return `{cli} attach ${run} --pr <n>`;
+  return `{cli} attach ${run} --pr <n> --screenshot <label> for a still change, or --video for behavior or a flow; add --before <run-id> when the change is to something that exists`;
 }
 
 export async function leaseForRun<T>(deps: Deps, platform: Platform, command: Extract<Command, { verb: 'run' }>, instances: { readonly willChange: boolean }, drive: (outcome: RuntimeOutcome) => Promise<T>): Promise<T> {
@@ -273,6 +281,11 @@ export async function leaseForRun<T>(deps: Deps, platform: Platform, command: Ex
   );
 }
 
+interface Recorder {
+  readonly recording: Recording;
+  readonly recorderEntry: string | null;
+}
+
 interface GroupRun {
   readonly run: RunId;
   readonly dir: EvidencePath;
@@ -437,30 +450,40 @@ export async function runVerb(deps: Deps, command: Extract<Command, { verb: 'run
         if (declaration !== null) writeFileSync(join(dir, settingsFileOf(spec.path)), declaration);
       }
 
-      const broker = await startBroker(run, workspace, scratch, { keys: () => deps.instances.keys(), fetch: deps.fetch ?? fetch });
+      let recorder = null as Promise<Recorder> | null;
+      const startRecorder = async (): Promise<Recorder> => {
+        const device = agentDeviceFor(deps, lease, platform);
+        const closed = await device.call(['close', host.appId(platform), ...device.selector, '--session', agentDeviceSession(workspace, platform)], { timeoutMs: CLOSE_BEFORE_RECORDING_MS });
+        if (closed.code !== 0) deps.progress(`video   the app could not be closed before the recording, so the video may open on the screen it was showing: ${redact(closed.stderr.trim() || closed.stdout.trim())}`);
+        const recording = await backend.startRecording(lease, dir);
+        if (recording.process === null) return { recording, recorderEntry: null };
+        const recorderEntry = newEntryId();
+        workspace.append({ id: recorderEntry, kind: 'process', what: 'recorder', pid: recording.process.pid, startedAt: new Date(recording.process.startedAt).toISOString(), platform });
+        return { recording, recorderEntry };
+      };
+      const broker = await startBroker(run, workspace, scratch, {
+        keys: () => deps.instances.keys(),
+        fetch: deps.fetch ?? fetch,
+        beforeLaunch: async () => {
+          if (command.video) await (recorder ??= startRecorder());
+        },
+      });
 
-      let recording: Recording | null = null;
-      let recorderEntry: string | null = null;
       const outcomes: GroupOutcome[] = [];
       let endFailure: unknown = null;
       try {
-        if (command.video) {
-          recording = await backend.startRecording(lease, dir);
-          if (recording.process !== null) {
-            recorderEntry = newEntryId();
-            workspace.append({ id: recorderEntry, kind: 'process', what: 'recorder', pid: recording.process.pid, startedAt: new Date(recording.process.startedAt).toISOString(), platform });
-          }
-        }
         const the: GroupRun = { run, dir, log: join(dir, 'e2e.log') as EvidencePath, target: targetOf(deps, outcome), broker, driver, command, agent };
         for (const [index, group] of groups.entries()) {
           const stopped = outcomes.find((done) => done.stopsTheRun)?.failure ?? null;
           outcomes.push(await runGroup(deps, the, group, index, outcomes.flatMap((done) => done.identities), stopped));
         }
       } finally {
-        await endRun(workspace, { recording, recorderEntry, broker, scratch })
+        const started = (await recorder?.catch(() => null)) ?? { recording: null, recorderEntry: null };
+        await endRun(workspace, { ...started, broker, scratch })
           .catch((error: unknown) => void (endFailure = error))
           .finally(() => deps.instances.stopDriving());
       }
+      if (command.video && recorder === null) deps.progress('video   no test launched the app, so this run has no video');
 
       driver.collect();
       const appLog = join(dir, 'app.log') as EvidencePath;
@@ -546,13 +569,9 @@ async function screen(deps: Deps, command: Extract<Command, { verb: 'screen' }>)
   const platform = platformOf(deps.host, command.platform);
   const { lease, backend } = heldLease(deps, platform);
   if ((await backend.check(lease)) === 'lost') throw new VerifyFailure('LEASE_LOST', `${backend.describe(lease)} is gone`, '{cli} up');
-  const env = withoutClerkKeys(deps.env);
-  const target = agentDeviceOn(deviceOf(lease), platform);
-  const agentDevice = (args: readonly string[]) =>
-    deps.runner(join(deps.workspace.packageDir, 'node_modules', '.bin', 'agent-device'), args, { env: { ...env, AGENT_DEVICE_STATE_DIR: deps.workspace.agentDeviceDir, ...target.env } });
+  const { selector, call: agentDevice } = agentDeviceFor(deps, lease, platform);
   const screenWait = { seconds: 10, busyFix: 'let the run in this worktree finish, then rerun {cli} screen' };
   return deps.workspace.withDevice(platform, screenWait, async () => {
-    const selector = target.selector;
     const session = ['--session', `${agentDeviceSession(deps.workspace, platform)}-screen`];
     const attachedWithoutRelaunch = await agentDevice(['open', deps.host.appId(platform), '--json', ...selector, ...session]);
     if (attachedWithoutRelaunch.code !== 0) throw new VerifyFailure('NOT_READY', `agent-device open failed: ${redact(attachedWithoutRelaunch.stdout.trim() || attachedWithoutRelaunch.stderr.trim())}`, '{cli} up, then retry');
@@ -580,18 +599,17 @@ export async function attach(deps: Deps, command: Extract<Command, { verb: 'atta
   if (!existsSync(dir)) throw new VerifyFailure('USAGE', `no run ${run} in ${deps.workspace.root}/runs`, 'pass a run id that `{cli} run` printed');
   const record = readRecord(dir);
   const publishable = assertPublishable(record, loggedUserIds(dir));
+  const bundle = chooseEvidence(command.pr, publishable, command.before === null ? null : beforeRun(deps, command.before, record), command.media);
   try {
-    return await postToPullRequest(publishable, dir, deps.host, command.pr, command.screenshots, deps.runner);
+    return await postToPullRequest(bundle, deps.host, deps.runner);
   } catch (error) {
     if (!(error instanceof CannotPostHere) || record.backend !== 'remote') throw error;
     const unattached = `name run ${run} in the PR and say that the evidence was not attached`;
     const session = sessionToHandOffTo(deps, record);
     if (typeof session === 'string') throw new VerifyFailure('NOT_READY', `${error.message}, and ${session}`, `${unattached}; to attach it, {cli} run again and {cli} attach before {cli} down`);
-    const { videos, shots } = chooseFiles(publishable, command.screenshots);
-    const files = [...videos, ...shots.map((shot) => shot.path)];
     try {
-      const receipt = await session.handOff({ pr: command.pr, summary: summarize(publishable), files: files.map((path) => ({ name: basename(path), path })) }, deps.progress);
-      return { verb: 'attach', via: 'runner', pr: command.pr, handedOff: files, because: error.why, ...receipt };
+      const receipt = await session.handOff(bundle, deps.progress);
+      return { verb: 'attach', via: 'runner', pr: command.pr, handedOff: everyFile(bundle).map((file) => file.path), because: error.why, ...receipt };
     } catch (failure) {
       if (!(failure instanceof VerifyFailure)) throw failure;
       throw new VerifyFailure(failure.code, `${error.message}, and ${failure.message}`, `${failure.fix}; until then, ${unattached}`);
@@ -599,6 +617,18 @@ export async function attach(deps: Deps, command: Extract<Command, { verb: 'atta
   }
 }
 
+function beforeRun(deps: Deps, run: RunId, after: EvidenceRecord): Showable {
+  const dir = deps.workspace.runDir(run);
+  const without = 'attach without --before, and name the before run in the PR';
+  if (run === after.run) throw new VerifyFailure('USAGE', `--before names run ${run} itself`, `pass the run of the same spec on the build without the change, or ${without}`);
+  if (!existsSync(dir)) {
+    throw new VerifyFailure('USAGE', `no run ${run} in ${deps.workspace.root}/runs, so its files cannot be shown as the before`, `pass a run that \`{cli} run\` made in this checkout, whose directory is still there, or ${without}`);
+  }
+  const record = readRecord(dir);
+  if (record.platform !== after.platform) throw new VerifyFailure('USAGE', `run ${run} is an ${record.platform} run and run ${after.run} is an ${after.platform} run`, `pass a before run of the same platform, or ${without}`);
+  return assertShowable(record, loggedUserIds(dir));
+}
+
 function sessionToHandOffTo(deps: Deps, record: EvidenceRecord): { readonly handOff: (bundle: EvidenceBundle, progress: (line: string) => void) => Promise<HandOffReceipt> } | string {
   const lease = deps.workspace.readLease(record.platform);
   if (lease === null || lease.backend !== 'remote') return `this worktree holds no session now, so nothing can take the evidence to a runner`;
diff --git a/integration/expo-native/src/platform/ios/local.ts b/integration/expo-native/src/platform/ios/local.ts
index b2b8fe1f26d..4420b8f143e 100644
--- a/integration/expo-native/src/platform/ios/local.ts
+++ b/integration/expo-native/src/platform/ios/local.ts
@@ -18,6 +18,7 @@ import {
 import { recordVideo, showLogs } from './simulator.ts';
 
 const TEMPLATE_NAME = 'Clerk Verify Template iOS';
+const CREATE_TEMPLATE = `xcrun simctl create "${TEMPLATE_NAME}" "iPhone Air"`;
 const LANE_NAME = /^verify-ios-(\d+)$/;
 
 interface Simulator {
@@ -104,7 +105,7 @@ export function localIosBackend(options: { readonly os?: NodeJS.Platform } = {})
     async acquire(request) {
       const template = (await listSimulators()).find((d) => d.name === TEMPLATE_NAME);
       if (template === undefined) {
-        throw new VerifyFailure('NOT_READY', `no simulator named ${TEMPLATE_NAME}`, `xcrun simctl clone "iPhone Air" "${TEMPLATE_NAME}"`);
+        throw new VerifyFailure('NOT_READY', `no simulator named ${TEMPLATE_NAME}`, CREATE_TEMPLATE);
       }
       if (template.state !== 'Shutdown') {
         throw new VerifyFailure('NOT_READY', `${TEMPLATE_NAME} is ${template.state}; it can only be cloned while shut down`, `xcrun simctl shutdown "${TEMPLATE_NAME}"`);
@@ -231,7 +232,7 @@ export function localIosBackend(options: { readonly os?: NodeJS.Platform } = {})
       const template = xcode.code === 0 ? (await listSimulators()).find((d) => d.name === TEMPLATE_NAME) : undefined;
       const device: DoctorCheck[] = [
         template === undefined
-          ? { id: 'template', ok: false, detail: `no simulator named ${TEMPLATE_NAME}`, fix: `xcrun simctl clone "iPhone Air" "${TEMPLATE_NAME}", then boot it once, trust your proxy CA, and shut it down` }
+          ? { id: 'template', ok: false, detail: `no simulator named ${TEMPLATE_NAME}`, fix: `${CREATE_TEMPLATE}, then boot it once, trust your proxy CA, and shut it down` }
           : template.state === 'Shutdown'
             ? { id: 'template', ok: true, detail: `${TEMPLATE_NAME} (${template.runtime.replace(/^.*SimRuntime\./, '')})` }
             : { id: 'template', ok: false, detail: `${TEMPLATE_NAME} is ${template.state}; lanes clone it only while it is shut down`, fix: `xcrun simctl shutdown "${TEMPLATE_NAME}"` },
diff --git a/integration/expo-native/test/app-start.test.ts b/integration/expo-native/test/app-start.test.ts
index a60e27dba5b..f45c595123c 100644
--- a/integration/expo-native/test/app-start.test.ts
+++ b/integration/expo-native/test/app-start.test.ts
@@ -120,19 +120,21 @@ describe('a launch the host fixture starts', () => {
 
   function device(app: LaunchedApp = E2E_HOST, installedBuilds = new Set<string>()) {
     const calls: string[] = [];
+    const said: string[][] = [];
     let ids = 0;
     const launch = appLauncher(
       app,
       {
         installApp: async (path) => void calls.push(`install ${path}`),
         signInTicket: async (who) => (calls.push(`ticket for ${who.id}`), new Secret('ticket', `ticket_of_${who.id}`)),
+        aboutToLaunch: async () => void said.push([...calls]),
         openApp: async (appId, options) => void calls.push(options === undefined ? `open ${appId}` : `open ${appId} ${options.launchArguments.join(' ')}`),
         adb: async (args) => void calls.push(`adb ${args.join(' ')}`),
       },
       installedBuilds,
       () => `id${(ids += 1)}`,
     );
-    return { calls, launch };
+    return { calls, said, launch };
   }
 
   const always = `-verifyPublishableKey ${SAMPLE_PUBLISHABLE_KEY} -verifyRunId ${SAMPLE_RUN}`;
@@ -177,6 +179,7 @@ describe('a launch the host fixture starts', () => {
       {
         installApp: async () => {},
         signInTicket: async () => new Secret('ticket', `ticket_${(tickets += 1)}`),
+        aboutToLaunch: async () => {},
         openApp: async (appId, options) => {
           calls.push(`open ${appId} ${options?.launchArguments.join(' ')}`);
           if ((opens += 1) === 1) throw new Error('xcrun timed out');
@@ -193,6 +196,28 @@ describe('a launch the host fixture starts', () => {
     ]);
   });
 
+  it('says the app is about to launch again before the second try of a failed open, after the new sign-in ticket of that try', async () => {
+    const calls: string[] = [];
+    let tickets = 0;
+    const launch = appLauncher(
+      E2E_HOST,
+      {
+        installApp: async () => {},
+        signInTicket: async () => (calls.push(`ticket ${(tickets += 1)}`), new Secret('ticket', `ticket_${tickets}`)),
+        aboutToLaunch: async () => void calls.push('about to launch'),
+        openApp: async () => {
+          calls.push('open');
+          if (calls.filter((call) => call === 'open').length === 1) throw new Error('xcrun timed out');
+        },
+        adb: async () => {},
+      },
+      new Set<string>(),
+      () => 'id',
+    );
+    await launch({ signedInAs: user });
+    assert.deepEqual(calls, ['ticket 1', 'about to launch', 'open', 'ticket 2', 'about to launch', 'open']);
+  });
+
   it('installs the build the settings name before the first launch of a worker, and not again', async () => {
     const installedBuilds = new Set<string>();
     const named = { ...E2E_HOST, buildPath: '/builds/E2EHost.app' };
@@ -205,13 +230,24 @@ describe('a launch the host fixture starts', () => {
     await nextTest.launch({});
     assert.deepEqual(nextTest.calls.map((call) => call.split(' ')[0]), ['open']);
     const afterAFailure = new Set<string>();
-    const failing = appLauncher(named, { installApp: async () => Promise.reject(new Error('install failed')), signInTicket: async () => assert.fail('no ticket'), openApp: async () => assert.fail('opened'), adb: async () => {} }, afterAFailure, () => 'id');
+    const failing = appLauncher(named, { installApp: async () => Promise.reject(new Error('install failed')), signInTicket: async () => assert.fail('no ticket'), aboutToLaunch: async () => assert.fail('about to launch'), openApp: async () => assert.fail('opened'), adb: async () => {} }, afterAFailure, () => 'id');
     await assert.rejects(failing({}), /install failed/);
     const retry = device(named, afterAFailure);
     await retry.launch({});
     assert.deepEqual(retry.calls.map((call) => call.split(' ')[0]), ['install', 'open'], 'a build that failed to install is installed at the next launch');
   });
 
+  it('says the app is about to launch once everything before the launch is done, on every launch, and not for a launch that cannot start', async () => {
+    const { calls, said, launch } = device({ ...E2E_HOST, buildPath: '/builds/E2EHost.app' });
+    await launch({ signedInAs: user });
+    await launch({});
+    assert.deepEqual(said, [['install /builds/E2EHost.app', 'ticket for user_1'], [calls[0], calls[1], calls[2]]]);
+    assert.equal(calls.length, 4);
+    const unstartable = device({ ...E2E_HOST, entry: devClient });
+    await assert.rejects(unstartable.launch({}), /cannot use openLink yet/);
+    assert.deepEqual(unstartable.said, []);
+  });
+
   it('starts a dev client through adb on Android with the same launch inputs', async () => {
     const { calls, launch } = device({ ...E2E_HOST, platform: 'android', id: 'com.clerk.expo', entry: devClient });
     await launch({ authMode: 'signIn' });
diff --git a/integration/expo-native/test/broker.test.ts b/integration/expo-native/test/broker.test.ts
index 13e3407c80a..3c534db0e0f 100644
--- a/integration/expo-native/test/broker.test.ts
+++ b/integration/expo-native/test/broker.test.ts
@@ -5,11 +5,11 @@ import net from 'node:net';
 import { networkInterfaces, tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { describe, it } from 'node:test';
-import { TEST_PHONES, newTestEmail, runEmailPrefix, testUsers } from '../specs/support/clerk.ts';
+import { TEST_PHONES, aboutToLaunch, newTestEmail, runEmailPrefix, testUsers } from '../specs/support/clerk.ts';
 import { Secret, usedSecretValues } from '../specs/support/secret.ts';
 import { startBroker, type Broker } from '../src/core/broker.ts';
 import { REPLACE_AT_USERS } from '../src/core/clerk.ts';
-import type { PublishableKey, RunId } from '../src/core/types.ts';
+import { VerifyFailure, type PublishableKey, type RunId } from '../src/core/types.ts';
 import { openWorkspace } from '../src/core/workspace.ts';
 
 const SECRET_KEY = 'sk_test_standInUnitTest0123456789';
@@ -33,7 +33,7 @@ const emptyClerk: Clerk = (request) => {
   return { status: 200, body: { object: 'user', id: 'user_created_1', email_addresses: [{ email_address: 'private@example.com' }] } };
 };
 
-async function standIn(clerk: Clerk = emptyClerk) {
+async function standIn(clerk: Clerk = emptyClerk, beforeLaunch: () => Promise<void> = async () => undefined) {
   const dir = mkdtempSync(join(tmpdir(), 'verify-stand-in-'));
   const workspace = openWorkspace({ packageDir: dir, worktree: dir, home: join(dir, 'home') });
   const { run, scratch } = workspace.newRun();
@@ -50,14 +50,15 @@ async function standIn(clerk: Clerk = emptyClerk) {
     const answer = clerk(request);
     return new Response(JSON.stringify(answer.body), { status: answer.status });
   }) as typeof fetch;
-  const broker = await startBroker(run, workspace, scratch, { keys: () => keys, fetch: bapi });
+  const broker = await startBroker(run, workspace, scratch, { keys: () => keys, fetch: bapi, beforeLaunch });
   const ask = async (method: string, path: string, body?: unknown, token: string = readFileSync(broker.tokenFile, 'utf8')) => {
     const response = await fetch(`${broker.url}${path}`, { method, headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' }, ...(body === undefined ? {} : { body: typeof body === 'string' ? body : JSON.stringify(body) }) });
     const text = await response.text();
     return { status: response.status, json: (text === '' ? null : JSON.parse(text)) as { errors?: { code: string; long_message: string }[] } & Record<string, unknown> };
   };
-  const users = testUsers({ publishableKey: keys.pk, access: { kind: 'stand-in', url: broker.url, tokenFile: broker.tokenFile } }, run);
-  return { broker, workspace, run, forwarded, ask, users };
+  const access = { kind: 'stand-in', url: broker.url, tokenFile: broker.tokenFile } as const;
+  const users = testUsers({ publishableKey: keys.pk, access }, run);
+  return { broker, workspace, run, forwarded, ask, users, access };
 }
 
 const stopping = async <T>(broker: Broker, body: () => Promise<T>): Promise<T> => {
@@ -130,6 +131,48 @@ describe("the CLI's stand-in for the Backend API", () => {
     });
   });
 
+  it('lets the CLI get ready each time a test is about to launch the app, answers when it is, and sends Clerk nothing', async () => {
+    const launches: string[] = [];
+    const s = await standIn(emptyClerk, async () => {
+      launches.push('asked');
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      launches.push('ready');
+    });
+    await stopping(s.broker, async () => {
+      await aboutToLaunch(s.access);
+      launches.push('launch 1');
+      await aboutToLaunch(s.access);
+      launches.push('launch 2');
+      assert.deepEqual(launches, ['asked', 'ready', 'launch 1', 'asked', 'ready', 'launch 2']);
+      assert.equal((await s.ask('POST', '/about_to_launch', undefined, 'not-the-token')).status, 401);
+      assert.equal(launches.length, 6, 'a process without the run token starts nothing');
+      assert.deepEqual(s.forwarded, []);
+    });
+  });
+
+  it('stops the launch with the reason and the fix when the CLI could not get ready', async () => {
+    const s = await standIn(emptyClerk, async () => Promise.reject(new VerifyFailure('NOT_READY', 'simctl recordVideo exited 1: no such device', 'rerun with --no-video')));
+    await stopping(s.broker, async () => {
+      await assert.rejects(aboutToLaunch(s.access), { message: 'the verify CLI was not ready for the app to launch: simctl recordVideo exited 1: no such device (fix: rerun with --no-video)' });
+    });
+    const other = await standIn(emptyClerk, async () => Promise.reject(new Error('spawn xcrun ENOENT')));
+    await stopping(other.broker, async () => {
+      await assert.rejects(aboutToLaunch(other.access), { message: 'the verify CLI was not ready for the app to launch: spawn xcrun ENOENT' });
+    });
+  });
+
+  it('asks nothing of anyone before a launch in a run by hand, which has a secret key and no CLI', async () => {
+    const asked: string[] = [];
+    const recording = (async (url: string | URL, init?: RequestInit) => (asked.push(`${init?.method} ${String(url)} ${new Headers(init?.headers).get('authorization')}`), new Response('{}'))) as typeof fetch;
+    await aboutToLaunch({ kind: 'secret-key', key: new Secret('clerk-secret-key', SECRET_KEY) }, recording);
+    assert.deepEqual(asked, []);
+    const s = await standIn();
+    await stopping(s.broker, async () => {
+      await aboutToLaunch(s.access, recording);
+      assert.deepEqual(asked, [`POST ${s.broker.url}/about_to_launch Bearer ${readFileSync(s.broker.tokenFile, 'utf8')}`]);
+    });
+  });
+
   it('refuses a fourth kind of call: nothing but create a user, mint a ticket, and look a phone up reaches Clerk', async () => {
     const s = await standIn();
     await stopping(s.broker, async () => {
diff --git a/integration/expo-native/test/cli.test.ts b/integration/expo-native/test/cli.test.ts
index 5bc681792b5..0ef5bc06d8e 100644
--- a/integration/expo-native/test/cli.test.ts
+++ b/integration/expo-native/test/cli.test.ts
@@ -52,14 +52,32 @@ describe('parseArgv', () => {
       verb: 'attach',
       run: 'r20261002-141210-7c1e',
       pr: 412,
-      screenshots: ['a', 'b'],
+      media: { screenshots: ['a', 'b'], video: false },
+      before: null,
     });
-    assert.deepEqual(parseArgv(['attach', 'r20261002-141210-7c1e', '--pr=7']).command, { verb: 'attach', run: 'r20261002-141210-7c1e', pr: 7, screenshots: 'all' });
+    assert.deepEqual(parseArgv(['attach', 'r20261002-141210-7c1e', '--pr=7', '--video', '--before', 'r20261002-140000-0a1b']).command, {
+      verb: 'attach',
+      run: 'r20261002-141210-7c1e',
+      pr: 7,
+      media: { screenshots: [], video: true },
+      before: 'r20261002-140000-0a1b',
+    });
+    assert.deepEqual((parseArgv(['attach', 'r20261002-141210-7c1e', '--pr=7', '--video', '--screenshot', 'a']).command as Extract<Command, { verb: 'attach' }>).media, { screenshots: ['a'], video: true });
     assert.deepEqual(parseArgv(['down', '--stale', '--dry-run']).command, { verb: 'down', stale: true, dryRun: true });
   });
 
+  it('makes attach choose what to show, and says how to choose when it is given neither --screenshot nor --video', () => {
+    const neither = usageError(['attach', 'r20261002-141210-7c1e', '--pr', '412']);
+    assert.equal(neither.message, '{cli} attach posts what you choose and nothing by default: screenshots show a still change such as wording, and the video shows behavior, movement or a flow');
+    assert.equal(
+      neither.fix,
+      '{cli} attach <run-id> --pr <n> --screenshot <label> [--screenshot <label>]..., or {cli} attach <run-id> --pr <n> --video; add --before <run-id> to either when the change is to something that already exists, and pass both flags only when one kind does not show the change',
+    );
+    assert.equal(usageError(['attach', 'r20261002-141210-7c1e', '--pr', '412', '--before', 'r20261002-140000-0a1b']).message, neither.message);
+  });
+
   it('reads --json on every verb', () => {
-    for (const argv of [['doctor'], ['up'], ['run', 'x'], ['screen'], ['attach', 'r20261002-141210-7c1e', '--pr', '1'], ['down']]) {
+    for (const argv of [['doctor'], ['up'], ['run', 'x'], ['screen'], ['attach', 'r20261002-141210-7c1e', '--pr', '1', '--video'], ['down']]) {
       assert.equal(parseArgv([...argv, '--json']).json, true, argv[0]);
       assert.equal(parseArgv(argv).json, false, argv[0]);
     }
@@ -77,9 +95,11 @@ describe('parseArgv', () => {
       ['run', 'x', '--all'],
       ['run', 'x', '--video'],
       ['screen', 'extra'],
-      ['attach', 'r20261002-141210-7c1e'],
-      ['attach', 'not-a-run', '--pr', '1'],
-      ['attach', 'r20261002-141210-7c1e', '--pr', 'abc'],
+      ['attach', 'r20261002-141210-7c1e', '--video'],
+      ['attach', 'not-a-run', '--pr', '1', '--video'],
+      ['attach', 'r20261002-141210-7c1e', '--pr', 'abc', '--video'],
+      ['attach', 'r20261002-141210-7c1e', '--pr', '1', '--video', '--before', 'the-run-before'],
+      ['attach', 'r20261002-141210-7c1e', '--pr', '1', '--video=yes'],
       ['down', '--platform', 'windows'],
       ['up', '--backend', 'cloud'],
       ['up', '--wait'],
diff --git a/integration/expo-native/test/evidence.test.ts b/integration/expo-native/test/evidence.test.ts
index 152f8efb4c3..0080b214127 100644
--- a/integration/expo-native/test/evidence.test.ts
+++ b/integration/expo-native/test/evidence.test.ts
@@ -8,7 +8,7 @@ import { describe, it } from 'node:test';
 import { newTestEmail } from '../specs/support/clerk.ts';
 import { assertPublishable, loggedUserIds, sealEvidence } from '../src/core/evidence.ts';
 import type { Runner } from '../src/core/exec.ts';
-import { evidenceBlock, evidenceMarkers, postToPullRequest, summarize, withEvidenceBlock } from '../src/core/publish.ts';
+import { evidenceBlock, evidenceMarkers, summarize, withEvidenceBlock } from '../src/core/publish.ts';
 import { Secret } from '../specs/support/secret.ts';
 import { attach } from '../src/core/verbs.ts';
 import { newRunId } from '../specs/support/inputs.ts';
@@ -119,16 +119,16 @@ describe('assertPublishable', () => {
 
 describe('the evidence block of a pull request description', () => {
   const summary: EvidenceSummary = { run: 'r20261008-052713-253e' as RunId, platform: 'ios', device: 'iPhone Air on xcode-27', commit: '0f50b597b1c2d3e4f5a60718293a4b5c6d7e8f90', passed: 3, flaky: 0, total: 3 };
-  const media = [{ alt: 'video.mp4', ref: './video.mp4' }, { alt: 'profile', ref: './profile.png' }];
-  const block = evidenceBlock(summary, media);
+  const media = ['![video.mp4](./video.mp4)', '![profile](./profile.png)'];
+  const block = evidenceBlock(summary, null, media);
 
-  it('is one line built from the run, then each file alone in its own paragraph, between the markers of its platform', () => {
+  it('leads with the result in bold, names the run, the device, the commit and the count on one line, then holds each part in its own paragraph, between the markers of its platform', () => {
     assert.equal(
       block,
       [
         '<!-- verify-evidence:ios -->',
         '',
-        'verify run `r20261008-052713-253e` on `iPhone Air on xcode-27` at `0f50b597b1c2`, 3 of 3 passed.',
+        '**Verified on an iOS simulator.** Run `r20261008-052713-253e` on `iPhone Air on xcode-27` at `0f50b597b1c2`, 3 of 3 passed.',
         '',
         '![video.mp4](./video.mp4)',
         '',
@@ -137,7 +137,16 @@ describe('the evidence block of a pull request description', () => {
         '<!-- /verify-evidence:ios -->',
       ].join('\n'),
     );
-    assert.match(evidenceBlock({ ...summary, passed: 1, flaky: 1, total: 2 }, []), /, 1 of 2 passed, 1 flaky \(passed only on a retry\)\.$/m);
+    assert.match(evidenceBlock({ ...summary, passed: 1, flaky: 1, total: 2 }, null, []), /, 1 of 2 passed, 1 flaky \(passed only on a retry\)\.$/m);
+    assert.match(evidenceBlock({ ...summary, platform: 'android' }, null, []), /^\*\*Verified on an Android emulator\.\*\* Run /m);
+  });
+
+  it('says which run and commit the before is, and how that run went', () => {
+    const before: EvidenceSummary = { ...summary, run: 'r20261008-051500-0a1b' as RunId, commit: '5e126375065188df5bec4e4e75d61db03834f395', passed: 0, total: 1 };
+    assert.equal(
+      evidenceBlock(summary, before, []).split('\n')[2],
+      '**Verified on an iOS simulator.** Run `r20261008-052713-253e` on `iPhone Air on xcode-27` at `0f50b597b1c2`, 3 of 3 passed. Before is run `r20261008-051500-0a1b` at `5e1263750651`, 0 of 1 passed.',
+    );
   });
 
   it('counts a test that passed only on a retry apart from the passed ones', () => {
@@ -161,14 +170,14 @@ describe('the evidence block of a pull request description', () => {
   it('replaces the block that is there and keeps every byte before and after it', () => {
     const before = '## Summary\r\n\r\nText above.  \n\n';
     const after = '\n\n- [x] a checklist\r\n<!-- /verify-evidence:android -->\ttrailing\n';
-    const old = evidenceBlock({ ...summary, run: 'r20261007-010101-aaaa' as RunId }, [{ alt: 'old', ref: 'https://github.com/user-attachments/assets/1' }]);
+    const old = evidenceBlock({ ...summary, run: 'r20261007-010101-aaaa' as RunId }, null, ['![old](https://github.com/user-attachments/assets/1)']);
     const edit = withEvidenceBlock(`${before}${old}${after}`, 'ios', block);
     assert.deepEqual(edit, { ok: true, body: `${before}${block.replaceAll('\n', '\r\n')}${after}`, was: 'replaced' });
     assert.equal(edit.ok && edit.body.includes('r20261007-010101-aaaa'), false);
   });
 
   it('keeps the block of the other platform', () => {
-    const android = evidenceBlock({ ...summary, platform: 'android', device: 'Pixel 9' }, []);
+    const android = evidenceBlock({ ...summary, platform: 'android', device: 'Pixel 9' }, null, []);
     const edit = withEvidenceBlock(`intro\n\n${android}\n`, 'ios', block);
     assert.deepEqual(edit, { ok: true, body: `intro\n\n${android}\n\n${block}`, was: 'added' });
   });
@@ -187,7 +196,7 @@ describe('the evidence block of a pull request description', () => {
 
   it('writes the block with the line endings of the description, added or replaced', () => {
     const crlf = block.replaceAll('\n', '\r\n');
-    const old = evidenceBlock({ ...summary, run: 'r20261007-010101-aaaa' as RunId }, media);
+    const old = evidenceBlock({ ...summary, run: 'r20261007-010101-aaaa' as RunId }, null, media);
     const oldCrlf = old.replaceAll('\n', '\r\n');
     assert.deepEqual(withEvidenceBlock(`intro\r\n\r\n${oldCrlf}\r\noutro`, 'ios', block), { ok: true, body: `intro\r\n\r\n${crlf}\r\noutro`, was: 'replaced' });
     assert.equal(bodyAfter('intro\r\n'), `intro\r\n\r\n${crlf}`);
@@ -216,8 +225,8 @@ describe('the evidence block of a pull request description', () => {
   });
 
   it('takes no marker from inside a code fence, so a description may show a whole example block', () => {
-    const example = evidenceBlock({ ...summary, run: 'r20261007-010101-aaaa' as RunId }, media);
-    const later = evidenceBlock({ ...summary, run: 'r20261009-020202-bbbb' as RunId }, media);
+    const example = evidenceBlock({ ...summary, run: 'r20261007-010101-aaaa' as RunId }, null, media);
+    const later = evidenceBlock({ ...summary, run: 'r20261009-020202-bbbb' as RunId }, null, media);
     const fences = [['```', '```'], ['```markdown', '```'], ['~~~~', '~~~~~'], ['   ```', '```  '], ['```\n```not the end, it has text after the ticks', '```'], ['```\n~~~', '```'], ['````\n```', '````']] as const;
     for (const [open, close] of fences) {
       const documented = `The block looks like this:\n\n${open}\n${example}\n${close}\n`;
@@ -229,14 +238,14 @@ describe('the evidence block of a pull request description', () => {
   });
 
   it('still takes a marker after a fence that closed, and one beside a line that only looks like a fence', () => {
-    const real = evidenceBlock({ ...summary, run: 'r20261007-010101-aaaa' as RunId }, media);
+    const real = evidenceBlock({ ...summary, run: 'r20261007-010101-aaaa' as RunId }, null, media);
     for (const before of ['```\ncode\n```\n\n', 'Use ```three ticks``` inline.\n\n', '```three ticks``` that open a line are inline code too.\n\n', '    ```\n\n', '``\n\n']) {
       assert.deepEqual(withEvidenceBlock(`${before}${real}\n`, 'ios', block), { ok: true, body: `${before}${block}\n`, was: 'replaced' }, JSON.stringify(before));
     }
   });
 
   it('opens no fence at a fence line inside an HTML comment, so the next attach finds the block it wrote', () => {
-    const later = evidenceBlock({ ...summary, run: 'r20261009-020202-bbbb' as RunId }, media);
+    const later = evidenceBlock({ ...summary, run: 'r20261009-020202-bbbb' as RunId }, null, media);
     for (const hidden of ['<!--\n```\n-->\n\nintro\n', '<!-- a note\r\n~~~\r\nstill the note -->\r\n', 'intro\n   <!--\n```\n']) {
       const again = withEvidenceBlock(bodyAfter(hidden), 'ios', later);
       assert.equal(again.ok && again.was, 'replaced', JSON.stringify(hidden));
@@ -249,7 +258,7 @@ describe('the evidence block of a pull request description', () => {
     for (const unclosed of ['intro\n\n```\ncode\n', 'intro\r\n~~~~ js\r\ncode', '```']) {
       assert.deepEqual(withEvidenceBlock(unclosed, 'ios', block), { ok: false, why: 'ends inside a code fence that is never closed', fix: 'close that code fence' }, JSON.stringify(unclosed));
     }
-    const earlier = evidenceBlock({ ...summary, run: 'r20261007-010101-aaaa' as RunId }, media);
+    const earlier = evidenceBlock({ ...summary, run: 'r20261007-010101-aaaa' as RunId }, null, media);
     assert.equal(bodyAfter(`intro\n\n${earlier}\n\n~~~\ncode\n`), `intro\n\n${block}\n\n~~~\ncode\n`, 'a block before the open fence is still replaced');
   });
 
@@ -281,117 +290,426 @@ describe('assertPublishable and the groups of a run', () => {
 describe('attach', () => {
   const host = { repo: 'clerk-ios', githubRepo: 'clerk/clerk-ios' } as HostAdapter;
   const PR_URL = 'https://github.com/clerk/clerk-ios/pull/9';
+  const DESCRIPTION = '## Summary\n\nFixes the button.\n';
+  const AFTER_COMMIT = '606639a634488fdd6cf3f7ca956213f781e04f24';
+  const BEFORE_COMMIT = '5e126375065188df5bec4e4e75d61db03834f395';
+  const asset = (n: number): string => `https://github.com/user-attachments/assets/00000000-0000-4000-8000-${String(n).padStart(12, '0')}`;
+
+  interface Edit {
+    readonly args: readonly string[];
+    readonly cwd: string | undefined;
+    readonly bodyFile: string;
+    readonly attached: readonly string[];
+  }
 
-  function fakeGh(options: { readonly attachFlag?: boolean; readonly body?: string; readonly onView?: (views: number, pr: { body: string }) => void } = {}) {
-    const pr = { body: options.body ?? '## Summary\n\nFixes the button.\n' };
-    const edits: { readonly args: readonly string[]; readonly cwd: string | undefined; readonly bodyFile: string }[] = [];
+  function fakeGh(options: { readonly attachFlag?: boolean; readonly body?: string; readonly onView?: (views: number, pr: { body: string; state: string }) => void; readonly upload?: (reference: string, address: string) => string } = {}) {
+    const pr = { body: options.body ?? DESCRIPTION, state: 'OPEN' };
+    const edits: Edit[] = [];
     let views = 0;
+    let uploads = 0;
     const runner: Runner = async (command, args, runOptions) => {
       assert.equal(command, 'gh');
       if (args.includes('--help')) return { code: 0, stdout: options.attachFlag === false ? '  -b, --body text   Set the new body.\n' : '      --attach file   Attach a file\n', stderr: '' };
       if (args[1] === 'view') {
         views += 1;
         options.onView?.(views, pr);
-        return { code: 0, stdout: JSON.stringify({ body: pr.body, url: PR_URL }), stderr: '' };
+        return { code: 0, stdout: JSON.stringify({ body: pr.body, url: PR_URL, state: pr.state }), stderr: '' };
       }
       const bodyFile = readFileSync(args[args.indexOf('--body-file') + 1]!, 'utf8');
-      edits.push({ args, cwd: runOptions?.cwd, bodyFile });
-      pr.body = bodyFile.replace(/\]\(\.\/[^)]+\)/g, '](https://github.com/user-attachments/assets/uploaded)');
+      const attached = args.filter((_, i) => args[i - 1] === '--attach').map((file) => readFileSync(join(runOptions!.cwd!, file), 'utf8'));
+      edits.push({ args, cwd: runOptions?.cwd, bodyFile, attached });
+      pr.body = bodyFile.replace(/!\[([^\]]*)\]\(\.\/([^)]+)\)/g, (reference, alt: string, file: string) => {
+        const address = asset((uploads += 1));
+        return options.upload?.(reference, address) ?? (file.endsWith('.mp4') ? address : `![${alt}](${address})`);
+      });
       return { code: 0, stdout: `${PR_URL}\n`, stderr: '' };
     };
     return { runner, pr, edits };
   }
 
-  function publishableRun() {
-    const { dir, run } = runDir();
-    return { dir, run, publishable: assertPublishable(sealEvidence(dir, partialRecord(dir, run), []), [OWN_USER]) };
+  function checkout(gh: { readonly runner: Runner } = fakeGh()) {
+    const packageDir = mkdtempSync(join(tmpdir(), 'verify-attach-'));
+    const workspace = openWorkspace({ packageDir, worktree: packageDir, home: join(packageDir, 'home') });
+    const deps = { host, workspace, runner: gh.runner, env: {}, progress: () => undefined, instances: heldInstances() };
+    const sealed = (shape: { readonly called: string; readonly shots?: readonly string[]; readonly video?: boolean; readonly failed?: boolean; readonly failureShot?: boolean; readonly change?: Partial<EvidenceRecord>; readonly log?: string }) => {
+      const { run, dir } = workspace.newRun();
+      mkdirSync(join(dir, 'screenshots'), { recursive: true });
+      const file = (name: string, holds: string): EvidencePath => (writeFileSync(join(dir, name), holds), join(dir, name) as EvidencePath);
+      const base = partialRecord(dir, run);
+      const failureScreenshot = shape.failureShot === true ? file('001-failure.png', `${shape.called} failure`) : null;
+      file('app.log', shape.log ?? hostLogLine(OWN_USER));
+      sealEvidence(
+        dir,
+        {
+          ...base,
+          gitHead: shape.failed === true ? BEFORE_COMMIT : AFTER_COMMIT,
+          results: [{ ...base.results[0]!, status: shape.failed === true ? 'failed' : 'passed', failureScreenshot }],
+          videos: shape.video === false ? [] : [file('video.mp4', `${shape.called} video`)],
+          screenshots: (shape.shots ?? ['profile']).map((label) => ({ label, path: file(join('screenshots', `${label}.png`), `${shape.called} ${label}`) })),
+          ...shape.change,
+        },
+        [],
+      );
+      return { run, dir };
+    };
+    return { deps, sealed };
   }
 
+  const block = (...lines: readonly string[]): string => [`${DESCRIPTION}`, '<!-- verify-evidence:ios -->', '', ...lines, '', '<!-- /verify-evidence:ios -->'].join('\n');
+  const still = { screenshots: ['profile'], video: false };
+  const flow = { screenshots: [], video: true };
+
   it('never calls gh for a run that fails the gate', async () => {
-    const packageDir = mkdtempSync(join(tmpdir(), 'verify-attach-'));
-    const workspace = openWorkspace({ packageDir, worktree: packageDir, home: join(packageDir, 'home') });
-    const { run, dir } = workspace.newRun();
-    writeFileSync(join(dir, 'video.mp4'), 'x');
-    writeFileSync(join(dir, 'app.log'), hostLogLine('user_foreign'));
-    sealEvidence(dir, partialRecord(dir, run), []);
     const calls: string[] = [];
-    const runner: Runner = async (command) => (calls.push(command), { code: 0, stdout: '', stderr: '' });
-    const deps = { host, workspace, runner, env: {}, progress: () => undefined, instances: heldInstances() };
-    await assert.rejects(attach(deps, { verb: 'attach', run, pr: 9, screenshots: 'all' }), { code: 'EVIDENCE_UNSAFE' });
+    const { deps, sealed } = checkout({ runner: async (command) => (calls.push(command), { code: 0, stdout: '', stderr: '' }) });
+    const { run } = sealed({ called: 'after', log: hostLogLine('user_foreign') });
+    await assert.rejects(attach(deps, { verb: 'attach', run, pr: 9, media: still, before: null }), { code: 'EVIDENCE_UNSAFE' });
     assert.equal(calls.length, 0);
   });
 
-  it('puts the block after the description with gh pr edit, from the run directory, and uploads a run only once', async () => {
-    const { dir, run, publishable } = publishableRun();
+  it('shows a still change to something that exists as before and after screenshots, side by side at a fixed width, and no video', async () => {
     const gh = fakeGh();
-    const first = await postToPullRequest(publishable, dir, host, 9, 'all', gh.runner);
-    const second = await postToPullRequest(publishable, dir, host, 9, 'all', gh.runner);
-    assert.equal(gh.edits.length, 1);
-    const edit = gh.edits[0]!;
-    assert.deepEqual(edit.args.slice(0, 5), ['pr', 'edit', '9', '--repo', 'clerk/clerk-ios']);
-    assert.deepEqual(edit.args.filter((_, i) => edit.args[i - 1] === '--attach'), ['./video.mp4', './screenshots/profile.png']);
-    assert.equal(edit.cwd, dir);
+    const { deps, sealed } = checkout(gh);
+    const before = sealed({ called: 'before', failed: true });
+    const after = sealed({ called: 'after' });
+    await attach(deps, { verb: 'attach', run: after.run, pr: 9, media: still, before: before.run });
+    assert.equal(
+      gh.pr.body,
+      block(
+        `**Verified on an iOS simulator.** Run \`${after.run}\` on \`verify-ios-1\` at \`606639a63448\`, 1 of 1 passed. Before is run \`${before.run}\` at \`5e1263750651\`, 0 of 1 passed.`,
+        '',
+        '| Before | After |',
+        '| :---: | :---: |',
+        `| <img src="${asset(2)}" width="280" alt="Before: profile"> | <img src="${asset(1)}" width="280" alt="After: profile"> |`,
+      ),
+    );
+    assert.deepEqual(gh.edits[0]!.attached, ['after profile', 'before profile']);
+  });
+
+  it('shows a still change that is new as its screenshots alone, two across under their labels', async () => {
+    const gh = fakeGh();
+    const { deps, sealed } = checkout(gh);
+    const { run } = sealed({ called: 'after', shots: ['start', 'profile', 'security'] });
+    await attach(deps, { verb: 'attach', run, pr: 9, media: { screenshots: ['start', 'profile', 'security'], video: false }, before: null });
+    assert.equal(
+      gh.pr.body,
+      block(
+        `**Verified on an iOS simulator.** Run \`${run}\` on \`verify-ios-1\` at \`606639a63448\`, 1 of 1 passed.`,
+        '',
+        '| `start` | `profile` |',
+        '| :---: | :---: |',
+        `| <img src="${asset(1)}" width="280" alt="start"> | <img src="${asset(2)}" width="280" alt="profile"> |`,
+        '',
+        '| `security` |',
+        '| :---: |',
+        `| <img src="${asset(3)}" width="280" alt="security"> |`,
+      ),
+    );
+    assert.deepEqual(gh.edits[0]!.attached, ['after start', 'after profile', 'after security']);
+  });
+
+  it('shows a change to a flow that exists as the before and after videos, side by side, and no screenshot', async () => {
+    const gh = fakeGh();
+    const { deps, sealed } = checkout(gh);
+    const before = sealed({ called: 'before', failed: true });
+    const after = sealed({ called: 'after' });
+    await attach(deps, { verb: 'attach', run: after.run, pr: 9, media: flow, before: before.run });
+    assert.equal(
+      gh.pr.body,
+      block(
+        `**Verified on an iOS simulator.** Run \`${after.run}\` on \`verify-ios-1\` at \`606639a63448\`, 1 of 1 passed. Before is run \`${before.run}\` at \`5e1263750651\`, 0 of 1 passed.`,
+        '',
+        '| Before | After |',
+        '| :---: | :---: |',
+        `| ${asset(2)} | ${asset(1)} |`,
+      ),
+    );
+    assert.deepEqual(gh.edits[0]!.attached, ['after video', 'before video']);
+  });
+
+  it('shows a flow that is new as its video alone, in a table that keeps it from the full width', async () => {
+    const gh = fakeGh();
+    const { deps, sealed } = checkout(gh);
+    const { run } = sealed({ called: 'after' });
+    await attach(deps, { verb: 'attach', run, pr: 9, media: flow, before: null });
+    assert.equal(gh.pr.body, block(`**Verified on an iOS simulator.** Run \`${run}\` on \`verify-ios-1\` at \`606639a63448\`, 1 of 1 passed.`, '', '| `video` |', '| :---: |', `| ${asset(1)} |`));
+    assert.deepEqual(gh.edits[0]!.attached, ['after video']);
+  });
+
+  it('shows both kinds when asked for both: the screenshots first, then the video, each laid out as it is alone', async () => {
+    const gh = fakeGh();
+    const { deps, sealed } = checkout(gh);
+    const before = sealed({ called: 'before', failed: true });
+    const after = sealed({ called: 'after' });
+    const both = { screenshots: ['profile'], video: true };
+    await attach(deps, { verb: 'attach', run: after.run, pr: 9, media: both, before: before.run });
+    assert.equal(
+      gh.pr.body,
+      block(
+        `**Verified on an iOS simulator.** Run \`${after.run}\` on \`verify-ios-1\` at \`606639a63448\`, 1 of 1 passed. Before is run \`${before.run}\` at \`5e1263750651\`, 0 of 1 passed.`,
+        '',
+        '| Before | After |',
+        '| :---: | :---: |',
+        `| <img src="${asset(3)}" width="280" alt="Before: profile"> | <img src="${asset(1)}" width="280" alt="After: profile"> |`,
+        '',
+        '| Before | After |',
+        '| :---: | :---: |',
+        `| ${asset(4)} | ${asset(2)} |`,
+      ),
+    );
+    assert.deepEqual(gh.edits[0]!.attached, ['after profile', 'after video', 'before profile', 'before video']);
+
+    await attach(deps, { verb: 'attach', run: after.run, pr: 9, media: both, before: null });
     assert.equal(
-      edit.bodyFile,
-      `## Summary\n\nFixes the button.\n\n<!-- verify-evidence:ios -->\n\nverify run \`${run}\` on \`verify-ios-1\` at \`abc\`, 1 of 1 passed.\n\n![video.mp4](./video.mp4)\n\n![profile](./screenshots/profile.png)\n\n<!-- /verify-evidence:ios -->`,
+      gh.pr.body,
+      block(
+        `**Verified on an iOS simulator.** Run \`${after.run}\` on \`verify-ios-1\` at \`606639a63448\`, 1 of 1 passed.`,
+        '',
+        '| `profile` |',
+        '| :---: |',
+        `| <img src="${asset(5)}" width="280" alt="profile"> |`,
+        '',
+        '| `video` |',
+        '| :---: |',
+        `| ${asset(6)} |`,
+      ),
+    );
+  });
+
+  it('pairs a screenshot with the one of the same label in the before run, and with the failure screenshot of a before run that failed before it took one', async () => {
+    const gh = fakeGh();
+    const { deps, sealed } = checkout(gh);
+    const before = sealed({ called: 'before', failed: true, failureShot: true, shots: ['start'] });
+    const after = sealed({ called: 'after', shots: ['start', 'profile'] });
+    await attach(deps, { verb: 'attach', run: after.run, pr: 9, media: { screenshots: ['start', 'profile'], video: false }, before: before.run });
+    assert.deepEqual(gh.edits[0]!.attached, ['after start', 'after profile', 'before start', 'before failure']);
+    assert.deepEqual(gh.pr.body.split('\n').slice(10, 12), [
+      `| <img src="${asset(3)}" width="280" alt="Before: start"> | <img src="${asset(1)}" width="280" alt="After: start"> |`,
+      `| <img src="${asset(4)}" width="280" alt="Before: profile"> | <img src="${asset(2)}" width="280" alt="After: profile"> |`,
+    ]);
+  });
+
+  it('posts nothing when the before run has nothing to pair with what was asked for, and says what to do', async () => {
+    const gh = fakeGh();
+    const { deps, sealed } = checkout(gh);
+    const after = sealed({ called: 'after' });
+    const passedWithoutIt = sealed({ called: 'before', shots: ['start'] });
+    await assert.rejects(attach(deps, { verb: 'attach', run: after.run, pr: 9, media: still, before: passedWithoutIt.run }), {
+      code: 'USAGE',
+      message: `run ${passedWithoutIt.run} has no screenshot labelled profile, and no failure screenshot to show in its place`,
+      fix: "call host.screenshot('profile') in the spec and run it on the build without the change, or attach without --before",
+    });
+    const noVideo = sealed({ called: 'before', failed: true, video: false });
+    await assert.rejects(attach(deps, { verb: 'attach', run: after.run, pr: 9, media: flow, before: noVideo.run }), {
+      code: 'USAGE',
+      message: `run ${noVideo.run} has no video: a run records one from the first time a test launches the app, unless it has --no-video`,
+      fix: '{cli} run it again without --no-video, or attach without --video or without --before',
+    });
+    const neverLaunched = sealed({ called: 'after', video: false });
+    await assert.rejects(attach(deps, { verb: 'attach', run: neverLaunched.run, pr: 9, media: flow, before: null }), {
+      code: 'USAGE',
+      message: `run ${neverLaunched.run} has no video: a run records one from the first time a test launches the app, unless it has --no-video`,
+      fix: '{cli} run a spec that calls host.launch, without --no-video, and attach that run, or attach this one with --screenshot <label>',
+    });
+    assert.deepEqual(gh.edits, []);
+  });
+
+  it('takes a before run that failed, and refuses one that is unsafe to show, is the run itself, is of the other platform, or is not in this checkout', async () => {
+    const gh = fakeGh();
+    const { deps, sealed } = checkout(gh);
+    const after = sealed({ called: 'after' });
+    const withBefore = (before: RunId) => attach(deps, { verb: 'attach', run: after.run, pr: 9, media: still, before });
+
+    const foreign = sealed({ called: 'before', failed: true, log: hostLogLine('user_foreign') });
+    await assert.rejects(withBefore(foreign.run), { code: 'EVIDENCE_UNSAFE', message: `the app log of run ${foreign.run} names user(s) the run did not create: user_foreign` });
+    const tainted = sealed({ called: 'before', failed: true });
+    const record = JSON.parse(readFileSync(join(tainted.dir, 'run.json'), 'utf8')) as EvidenceRecord;
+    writeFileSync(join(tainted.dir, 'run.json'), JSON.stringify({ ...record, tainted: [join(tainted.dir, 'e2e.log')] }));
+    await assert.rejects(withBefore(tainted.run), { code: 'EVIDENCE_UNSAFE', message: `run ${tainted.run} has secret values in ${join(tainted.dir, 'e2e.log')}` });
+    const unsealed = sealed({ called: 'before', failed: true });
+    rmSync(join(unsealed.dir, 'run.json'));
+    await assert.rejects(withBefore(unsealed.run), { code: 'EVIDENCE_UNSAFE', message: /has no run\.json, so it was never sealed$/ });
+
+    await assert.rejects(withBefore(after.run), { code: 'USAGE', message: `--before names run ${after.run} itself` });
+    const android = sealed({ called: 'before', failed: true, change: { platform: 'android' } });
+    await assert.rejects(withBefore(android.run), { code: 'USAGE', message: `run ${android.run} is an android run and run ${after.run} is an ios run` });
+    await assert.rejects(withBefore('r20260101-000000-0000' as RunId), {
+      code: 'USAGE',
+      message: `no run r20260101-000000-0000 in ${deps.workspace.root}/runs, so its files cannot be shown as the before`,
+      fix: 'pass a run that `{cli} run` made in this checkout, whose directory is still there, or attach without --before, and name the before run in the PR',
+    });
+    assert.deepEqual(gh.edits, []);
+
+    await withBefore(sealed({ called: 'before', failed: true }).run);
+    assert.equal(gh.edits.length, 2);
+  });
+
+  it('uploads the files as a list under names the description could not have guessed, then writes the tables from the addresses GitHub gave them', async () => {
+    const gh = fakeGh();
+    const { deps, sealed } = checkout(gh);
+    const { run, dir } = sealed({ called: 'after' });
+    const result = await attach(deps, { verb: 'attach', run, pr: 9, media: { screenshots: ['profile'], video: true }, before: null });
+    const [upload, layout] = gh.edits;
+    assert.equal(gh.edits.length, 2);
+    assert.deepEqual(upload!.args.slice(0, 5), ['pr', 'edit', '9', '--repo', 'clerk/clerk-ios']);
+    const names = upload!.args.filter((_, i) => upload!.args[i - 1] === '--attach');
+    const prefix = /^\.\/(evidence-[0-9a-f]{16})-1\.png$/.exec(names[0]!)?.[1];
+    assert.deepEqual(names, [`./${prefix}-1.png`, `./${prefix}-2.mp4`]);
+    assert.equal(
+      upload!.bodyFile,
+      block(`**Verified on an iOS simulator.** Run \`${run}\` on \`verify-ios-1\` at \`606639a63448\`, 1 of 1 passed.`, '', `![profile](./${prefix}-1.png)`, '', `![video.mp4](./${prefix}-2.mp4)`),
     );
-    assert.equal(existsSync(edit.args[edit.args.indexOf('--body-file') + 1]!), false, 'the copy of the description is not kept');
-    assert.deepEqual(first, { verb: 'attach', via: 'gh', prUrl: PR_URL, posted: [join(dir, 'video.mp4'), join(dir, 'screenshots', 'profile.png')], alreadyPosted: false });
-    assert.deepEqual(second, { ...first, alreadyPosted: true });
-    assert.ok(existsSync(join(dir, 'posted-9.json')));
-    await postToPullRequest(publishable, dir, host, 10, 'all', gh.runner);
-    assert.equal(gh.edits[1]!.args[2], '10');
+    assert.equal(layout!.args.includes('--attach'), false);
+    assert.equal(layout!.bodyFile, gh.pr.body);
+    assert.equal(existsSync(upload!.cwd!), false, 'the copies of the files and of the description are not kept');
+    assert.deepEqual(result, { verb: 'attach', via: 'gh', prUrl: PR_URL, posted: [join(dir, 'screenshots', 'profile.png'), join(dir, 'video.mp4')], alreadyPosted: false });
+  });
+
+  it('leaves the list in the description and says so when the addresses of the files cannot be read back, or the block names another run by then', async () => {
+    const gh = fakeGh({ upload: (reference) => reference });
+    const { deps, sealed } = checkout(gh);
+    const { run } = sealed({ called: 'after' });
+    const notLaidOut = {
+      code: 'NOT_READY',
+      message: `the files of run ${run} are in the description of PR #9 as a list, one under the other, and were not laid out: the block there now does not show run ${run} with the 1 addresses GitHub gave its files`,
+      fix: 'rerun {cli} attach once nobody is editing the description',
+    };
+    await assert.rejects(attach(deps, { verb: 'attach', run, pr: 9, media: still, before: null }), notLaidOut);
+    assert.equal(gh.edits.length, 1);
+
+    const renamed = { run: '' };
+    const otherRun = fakeGh({ onView: (views, pr) => void (views === 3 && (pr.body = pr.body.replace(renamed.run, 'r20261009-020202-bbbb'))) });
+    const elsewhere = checkout(otherRun);
+    renamed.run = elsewhere.sealed({ called: 'after' }).run;
+    await assert.rejects(attach(elsewhere.deps, { verb: 'attach', run: renamed.run as RunId, pr: 9, media: still, before: null }), { code: 'NOT_READY', message: notLaidOut.message.replaceAll(run, renamed.run) });
+    assert.equal(otherRun.edits.length, 1);
+    assert.ok(otherRun.pr.body.endsWith(`Run \`r20261009-020202-bbbb\` on \`verify-ios-1\` at \`606639a63448\`, 1 of 1 passed.\n\n![profile](${asset(1)})\n\n<!-- /verify-evidence:ios -->`), 'the list that names another run is left as it is');
+  });
+
+  it('says already posted for a repeated attach with a before run, with screenshots alone and with a video too', async () => {
+    const gh = fakeGh();
+    const { deps, sealed } = checkout(gh);
+    const before = sealed({ called: 'before', failed: true });
+    const { run } = sealed({ called: 'after' });
+    const pair = () => attach(deps, { verb: 'attach', run, pr: 9, media: still, before: before.run });
+    const first = await pair();
+    assert.equal(gh.edits.length, 2);
+    assert.deepEqual(await pair(), { ...first, alreadyPosted: true });
+    assert.equal(gh.edits.length, 2);
+
+    const both = () => attach(deps, { verb: 'attach', run, pr: 9, media: { screenshots: ['profile'], video: true }, before: before.run });
+    const withVideo = await both();
+    assert.equal(gh.edits.length, 4);
+    assert.deepEqual(await both(), { ...withVideo, alreadyPosted: true });
+    assert.equal(gh.edits.length, 4);
   });
 
-  it('replaces the block of an earlier run, so a second run does not pile up media', async () => {
-    const earlier = publishableRun();
-    const later = publishableRun();
+  it('says already posted only while the description holds the block it would write, and writes when the block there is another one or is gone', async () => {
     const gh = fakeGh();
-    await postToPullRequest(earlier.publishable, earlier.dir, host, 9, 'all', gh.runner);
-    gh.pr.body += '\nReviewer note added below the block.\n';
-    await postToPullRequest(later.publishable, later.dir, host, 9, ['profile'], gh.runner);
-    assert.equal(gh.pr.body.split('<!-- verify-evidence:ios -->').length, 2);
-    assert.equal(gh.pr.body.includes(earlier.run), false);
-    assert.ok(gh.pr.body.includes(later.run));
-    assert.ok(gh.pr.body.startsWith('## Summary\n\nFixes the button.\n\n<!-- verify-evidence:ios -->'));
-    assert.ok(gh.pr.body.endsWith('<!-- /verify-evidence:ios -->\nReviewer note added below the block.\n'));
+    const { deps, sealed } = checkout(gh);
+    const before = sealed({ called: 'before', failed: true });
+    const { run } = sealed({ called: 'after' });
+    const stills = () => attach(deps, { verb: 'attach', run, pr: 9, media: still, before: null });
+    const shows = (n: number) => block(`**Verified on an iOS simulator.** Run \`${run}\` on \`verify-ios-1\` at \`606639a63448\`, 1 of 1 passed.`, '', '| `profile` |', '| :---: |', `| <img src="${asset(n)}" width="280" alt="profile"> |`);
+
+    const first = await stills();
+    assert.equal(first.via === 'gh' && first.alreadyPosted, false);
+    assert.equal(gh.pr.body, shows(1));
+    assert.deepEqual(await stills(), { ...first, alreadyPosted: true });
+    gh.pr.body = gh.pr.body.replaceAll('\n', '\r\n');
+    assert.deepEqual(await stills(), { ...first, alreadyPosted: true }, 'the same block with the line endings of the web editor');
+    assert.equal(gh.edits.length, 2);
+    assert.equal(gh.pr.body, shows(1).replaceAll('\n', '\r\n'));
+
+    await attach(deps, { verb: 'attach', run, pr: 9, media: still, before: before.run });
+    assert.equal(gh.edits.length, 4);
+    assert.deepEqual(await stills(), { ...first, alreadyPosted: false }, 'the block of another choice replaced it');
+    assert.equal(gh.edits.length, 6);
+    assert.equal(gh.pr.body, shows(4).replaceAll('\n', '\r\n'));
+
+    gh.pr.body = DESCRIPTION;
+    assert.deepEqual(await stills(), { ...first, alreadyPosted: false }, 'the block is gone');
+    assert.equal(gh.pr.body, shows(5));
+
+    gh.pr.body = gh.pr.body.replace(`<img src="${asset(5)}" width="280" alt="profile">`, `![profile](${asset(5)})`);
+    assert.deepEqual(await stills(), { ...first, alreadyPosted: false }, 'the block was never laid out');
+    assert.equal(gh.pr.body, shows(6));
+
+    gh.pr.body = gh.pr.body.replace(asset(6), 'https://example.com/other.png');
+    assert.deepEqual(await stills(), { ...first, alreadyPosted: false }, 'the block does not show an upload');
+    assert.equal(gh.pr.body, shows(7));
+    assert.equal(gh.edits.length, 12);
+  });
+
+  it('replaces the block of an earlier run, in the layout of this version or of the one before it, so a second run does not pile up media', async () => {
+    const older = '<!-- verify-evidence:ios -->\n\nverify run `r20261007-010101-aaaa` on `verify-ios-1` at `abc`, 1 of 1 passed.\n\n![profile](https://github.com/user-attachments/assets/1)\n\n<!-- /verify-evidence:ios -->';
+    for (const start of [undefined, `${DESCRIPTION}\n${older}`]) {
+      const gh = fakeGh(start === undefined ? {} : { body: start });
+      const { deps, sealed } = checkout(gh);
+      const earlier = sealed({ called: 'earlier' });
+      const later = sealed({ called: 'later' });
+      if (start === undefined) await attach(deps, { verb: 'attach', run: earlier.run, pr: 9, media: still, before: null });
+      gh.pr.body += '\nReviewer note added below the block.\n';
+      await attach(deps, { verb: 'attach', run: later.run, pr: 9, media: still, before: null });
+      assert.equal(gh.pr.body.split('<!-- verify-evidence:ios -->').length, 2);
+      assert.equal(/r20261007-010101-aaaa/.test(gh.pr.body) || gh.pr.body.includes(earlier.run), false);
+      assert.ok(gh.pr.body.includes(later.run));
+      assert.ok(gh.pr.body.startsWith(`${DESCRIPTION}\n<!-- verify-evidence:ios -->`));
+      assert.ok(gh.pr.body.endsWith('<!-- /verify-evidence:ios -->\nReviewer note added below the block.\n'));
+    }
+  });
+
+  it('writes nothing to a pull request that is closed or merged, whether it was so before attach started or became so before the write, and says what to do', async () => {
+    const refusal = (state: string) => ({
+      code: 'USAGE',
+      message: `PR #9 of clerk/clerk-ios is ${state}, and attach writes only to an open pull request`,
+      fix: 'pass the number of an open pull request as --pr, or reopen PR #9, then rerun {cli} attach',
+    });
+    for (const [state, closesAtView] of [['CLOSED', 1], ['MERGED', 1], ['CLOSED', 2]] as const) {
+      const gh = fakeGh({ onView: (views, pr) => void (views === closesAtView && (pr.state = state)) });
+      const { deps, sealed } = checkout(gh);
+      const { run } = sealed({ called: 'after' });
+      await assert.rejects(attach(deps, { verb: 'attach', run, pr: 9, media: still, before: null }), refusal(state.toLowerCase()));
+      assert.deepEqual(gh.edits, []);
+    }
   });
 
   it('posts nothing and names the fix when gh pr edit has no --attach', async () => {
-    const { dir, run, publishable } = publishableRun();
     const gh = fakeGh({ attachFlag: false });
-    await assert.rejects(postToPullRequest(publishable, dir, host, 9, 'all', gh.runner), {
+    const { deps, sealed } = checkout(gh);
+    const { run, dir } = sealed({ called: 'after' });
+    await assert.rejects(attach(deps, { verb: 'attach', run, pr: 9, media: still, before: null }), {
       code: 'NOT_READY',
       message: `this gh has no \`gh pr edit --attach\`, so the video and screenshots of run ${run} cannot be posted`,
       fix: 'install gh 2.99.0 or newer, whose `gh pr edit` has --attach',
     });
     assert.deepEqual(gh.edits, []);
-    assert.equal(existsSync(join(dir, 'posted-9.json')), false);
   });
 
   it('builds on the newer description when someone edits it between the read and the write', async () => {
-    const { dir, publishable } = publishableRun();
     const gh = fakeGh({ onView: (views, pr) => void (views === 2 && (pr.body = 'Rewritten by a reviewer.\n')) });
-    await postToPullRequest(publishable, dir, host, 9, 'all', gh.runner);
-    assert.equal(gh.edits.length, 1);
-    assert.ok(gh.edits[0]!.bodyFile.startsWith('Rewritten by a reviewer.\n\n<!-- verify-evidence:ios -->'));
+    const { deps, sealed } = checkout(gh);
+    await attach(deps, { verb: 'attach', run: sealed({ called: 'after' }).run, pr: 9, media: still, before: null });
+    assert.equal(gh.edits.length, 2);
+    for (const edit of gh.edits) assert.ok(edit.bodyFile.startsWith('Rewritten by a reviewer.\n\n<!-- verify-evidence:ios -->'));
   });
 
   it('writes nothing when the description changes twice, and says so', async () => {
-    const { dir, run, publishable } = publishableRun();
     const gh = fakeGh({ onView: (views, pr) => void (pr.body = `edit ${views}\n`) });
-    await assert.rejects(postToPullRequest(publishable, dir, host, 9, 'all', gh.runner), {
+    const { deps, sealed } = checkout(gh);
+    const { run, dir } = sealed({ called: 'after' });
+    await assert.rejects(attach(deps, { verb: 'attach', run, pr: 9, media: still, before: null }), {
       code: 'NOT_READY',
       message: `the description of PR #9 changed twice while the evidence of run ${run} was being placed, so nothing was written`,
     });
     assert.deepEqual(gh.edits, []);
-    assert.equal(existsSync(join(dir, 'posted-9.json')), false);
   });
 
   it('writes nothing to a description whose markers are broken, and says which', async () => {
-    const { dir, run, publishable } = publishableRun();
     const gh = fakeGh({ body: 'text\n<!-- verify-evidence:ios -->\nthe end marker was deleted\n' });
-    await assert.rejects(postToPullRequest(publishable, dir, host, 9, 'all', gh.runner), {
+    const { deps, sealed } = checkout(gh);
+    const { run } = sealed({ called: 'after' });
+    await assert.rejects(attach(deps, { verb: 'attach', run, pr: 9, media: still, before: null }), {
       code: 'NOT_READY',
       message: `the description of PR #9 has \`<!-- verify-evidence:ios -->\` 1 times and \`<!-- /verify-evidence:ios -->\` 0 times, so the evidence of run ${run} has no one place to go`,
       fix: 'leave one pair of those markers in the description, or none, then rerun',
diff --git a/integration/expo-native/test/handoff.test.ts b/integration/expo-native/test/handoff.test.ts
index 2a8bfaa737b..310667604c1 100644
--- a/integration/expo-native/test/handoff.test.ts
+++ b/integration/expo-native/test/handoff.test.ts
@@ -23,7 +23,7 @@ const VIDEO = Buffer.from('a video that is longer than one chunk of five bytes')
 const SHOT = Buffer.from('png bytes');
 
 const good: HandoffManifest = {
-  v: 1,
+  v: 2,
   pr: 669,
   run: 'r20261008-052713-253e',
   platform: 'ios',
@@ -36,8 +36,25 @@ const good: HandoffManifest = {
     { name: 'video.mp4', bytes: VIDEO.length, sha256: sha256(VIDEO) },
     { name: 'profile.png', bytes: SHOT.length, sha256: sha256(SHOT) },
   ],
+  before: null,
 };
 
+const BEFORE_COMMIT = '5e126375065188df5bec4e4e75d61db03834f395';
+const WAS_VIDEO = Buffer.from('the video of the run before the change');
+const WAS_SHOT = Buffer.from('png bytes before');
+const goodBefore = {
+  run: 'r20261008-051500-0a1b',
+  commit: BEFORE_COMMIT,
+  passed: 0,
+  flaky: 0,
+  total: 3,
+  files: [
+    { name: 'before-video.mp4', bytes: WAS_VIDEO.length, sha256: sha256(WAS_VIDEO) },
+    { name: 'before-profile.png', bytes: WAS_SHOT.length, sha256: sha256(WAS_SHOT) },
+  ],
+};
+const withBefore: HandoffManifest = { ...good, before: goodBefore };
+
 describe('the hand-off manifest', () => {
   const parse = (change: Record<string, unknown>) => parseHandoffManifest(JSON.stringify({ ...good, ...change }));
   const file = (change: Record<string, unknown>) => parse({ files: [{ ...good.files[1]!, ...change }] });
@@ -54,7 +71,7 @@ describe('the hand-off manifest', () => {
     const refused: readonly [string, () => unknown][] = [
       ['text that is not JSON', () => parseHandoffManifest('{')],
       ['a list', () => parseHandoffManifest('[]')],
-      ['another version', () => parse({ v: 2 })],
+      ['another version', () => parse({ v: 1 })],
       ['a key the schema does not have', () => parse({ note: 'free text' })],
       ['a missing key', () => parseHandoffManifest(JSON.stringify({ ...good, device: undefined }))],
       ['a run id of another shape', () => parse({ run: 'r20261008-052713-253e; rm -rf /' })],
@@ -89,6 +106,58 @@ describe('the hand-off manifest', () => {
     for (const [what, attempt] of refused) assert.throws(attempt, HandoffRefused, what);
   });
 
+  it('refuses a manifest of another version before it reads anything else of it, and names both versions', () => {
+    const refusal = (manifest: unknown): string => {
+      try {
+        parseHandoffManifest(JSON.stringify(manifest));
+      } catch (error) {
+        if (error instanceof HandoffRefused && error.status === 400) return error.message;
+        throw error;
+      }
+      return 'accepted';
+    };
+    const { before: _, ...versionOne } = { ...good, v: 1 };
+    assert.equal(refusal(versionOne), 'the manifest is version 1, and this session takes only version 2');
+    assert.equal(refusal({ ...good, v: 3, layout: 'a key of a later version' }), 'the manifest is version 3, and this session takes only version 2');
+    for (const v of ['2', 2.5, -1, 1000, null, 'x'.repeat(4000)]) assert.equal(refusal({ ...good, v }), 'the manifest is of no version this session knows, and this session takes only version 2', JSON.stringify(v).slice(0, 20));
+    assert.equal(refusal({ device: 'x' }), 'the manifest is of no version this session knows, and this session takes only version 2');
+  });
+
+  it('accepts a before run, which may have passed nothing, with one file of the same kind for each file of the run', () => {
+    assert.deepEqual(parseHandoffManifest(JSON.stringify(withBefore)), withBefore);
+  });
+
+  it('refuses a before run that is malformed, is the run itself, or does not pair with the files of the run', () => {
+    const before = (change: Record<string, unknown>) => parse({ before: { ...goodBefore, ...change } });
+    const refused: readonly [string, () => unknown, RegExp][] = [
+      ['a missing before', () => parseHandoffManifest(JSON.stringify({ ...good, before: undefined })), /the manifest must have exactly the keys/],
+      ['a before that is text', () => parse({ before: goodBefore.run }), /before is not an object/],
+      ['a before with a key the schema does not have', () => before({ device: 'iPhone Air' }), /before must have exactly the keys run, commit, passed, flaky, total, files/],
+      ['a before run id of another shape', () => before({ run: 'the run before' }), /the run of before is missing or malformed/],
+      ['a before that is the run itself', () => before({ run: good.run }), /before is the run itself/],
+      ['a short before commit', () => before({ commit: 'abc1234' }), /the commit of before is missing or malformed/],
+      ['more passing before tests than tests', () => before({ passed: 3, flaky: 1 }), /passed and flaky of before must count at most total/],
+      ['a before count that is not whole', () => before({ total: 1.5 }), /total of before must be a whole number from 1 to 10000/],
+      ['a before with no files', () => before({ files: [] }), /the files of before must be a list of 1 to 50/],
+      ['a before with fewer files than the run', () => before({ files: [goodBefore.files[0]] }), /before must have one file for each file, of the same kind/],
+      ['a before screenshot where the run has a video', () => before({ files: [goodBefore.files[1], goodBefore.files[0]] }), /before must have one file for each file, of the same kind/],
+      ['a before file named as a file of the run is', () => before({ files: [goodBefore.files[0], { ...goodBefore.files[1], name: 'Profile.png' }] }), /two files have the same name/],
+      ['a before file with a path in its name', () => before({ files: [goodBefore.files[0], { ...goodBefore.files[1], name: '../before-profile.png' }] }), /the name of file 2 is missing or malformed/],
+      ['a before image over its cap', () => before({ files: [goodBefore.files[0], { ...goodBefore.files[1], bytes: HANDOFF_LIMITS.imageBytes + 1 }] }), /the size of before-profile\.png must be a whole number/],
+    ];
+    for (const [what, attempt, why] of refused) assert.throws(attempt, (error: unknown) => error instanceof HandoffRefused && why.test(error.message), what);
+  });
+
+  it('counts the files of the before run toward the cap on files and the cap on bytes', () => {
+    const shots = (prefix: string, count: number, bytes = 1) => Array.from({ length: count }, (_, i) => ({ name: `${prefix}${i}.png`, bytes, sha256: sha256('x') }));
+    const half = HANDOFF_LIMITS.files / 2;
+    assert.equal(parse({ files: shots('s', half), before: { ...goodBefore, files: shots('before-s', half) } }).before?.files.length, half);
+    assert.throws(() => parse({ files: shots('s', half + 1), before: { ...goodBefore, files: shots('before-s', half + 1) } }), /at most 50 files in all/);
+    assert.throws(() => parse({ files: shots('s', 8, HANDOFF_LIMITS.imageBytes), before: { ...goodBefore, files: shots('before-s', 8, HANDOFF_LIMITS.imageBytes) } }), /over 157286400 bytes in all/);
+    const video = (name: string) => ({ name, bytes: HANDOFF_LIMITS.videoBytes, sha256: sha256('x') });
+    assert.throws(() => parse({ files: [video('video.mp4')], before: { ...goodBefore, files: [video('before-video.mp4')] } }), /over 157286400 bytes in all/);
+  });
+
   it('refuses files that are within their own caps and over the total', () => {
     const images = Array.from({ length: 6 }, (_, i) => ({ name: `s${i}.png`, bytes: HANDOFF_LIMITS.imageBytes, sha256: sha256('x') }));
     assert.throws(() => parse({ files: [{ ...good.files[0]!, bytes: HANDOFF_LIMITS.videoBytes }, ...images] }), /over 157286400 bytes in all/);
@@ -169,6 +238,21 @@ describe('the receiver in the session job', () => {
     assert.equal(receiver.held(), good.run);
   });
 
+  it('takes the files of a before run beside the files of the run, and keeps nothing until each of them is whole', () => {
+    const work = mkdtempSync(join(tmpdir(), 'verify-handoff-'));
+    const receiver = evidenceReceiver(work);
+    receiver.begin(JSON.stringify(withBefore));
+    receiver.chunk(chunk('video.mp4', 0, VIDEO));
+    receiver.chunk(chunk('profile.png', 0, SHOT));
+    receiver.chunk(chunk('before-video.mp4', 0, WAS_VIDEO));
+    assert.throws(() => receiver.commit(), (error: HandoffRefused) => error.status === 409 && error.message === `before-profile.png has 0 of ${WAS_SHOT.length} bytes`);
+    receiver.chunk(chunk('before-profile.png', 0, WAS_SHOT));
+    assert.deepEqual(receiver.commit(), { ok: true, run: good.run, files: 4, bytes: VIDEO.length + SHOT.length + WAS_VIDEO.length + WAS_SHOT.length });
+    assert.deepEqual(readdirSync(join(work, 'evidence')).sort(), ['before-profile.png', 'before-video.mp4', 'manifest.json', 'profile.png', 'video.mp4']);
+    assert.deepEqual(readFileSync(join(work, 'evidence', 'before-profile.png')), WAS_SHOT);
+    assert.deepEqual(JSON.parse(readFileSync(join(work, 'evidence', 'manifest.json'), 'utf8')), withBefore);
+  });
+
   it('refuses a chunk for a file the manifest does not name, so no request chooses a path', () => {
     const { work, receiver } = received();
     for (const name of ['../agent.log', '/etc/passwd', 'other.png', 'manifest.json']) assert.equal(status(() => receiver.chunk(chunk(name, 0, SHOT))), 400, name);
@@ -272,26 +356,29 @@ function remoteRun(options: { readonly backend?: EvidenceRecord['backend']; read
   return { deps, run, dir, bundles, ghCalls };
 }
 
+const BOTH = { screenshots: ['profile'], video: true };
+
 describe('attach on a machine whose gh cannot attach', () => {
   it('hands the sealed files of a borrowed-device run to the session, and says what happens next', async () => {
     const { deps, run, dir, bundles, ghCalls } = remoteRun();
-    const result = await attach(deps, { verb: 'attach', run, pr: 669, screenshots: 'all' });
+    const result = await attach(deps, { verb: 'attach', run, pr: 669, media: BOTH, before: null });
     assert.deepEqual(ghCalls, ['pr edit --help'], 'gh was asked first, and it cannot attach');
     assert.deepEqual(bundles, [
       {
         pr: 669,
         summary: { run, platform: 'ios', device: 'iPhone Air on xcode-27', commit: COMMIT, passed: 1, flaky: 0, total: 1 },
         files: [
-          { name: 'video.mp4', path: join(dir, 'video.mp4') },
           { name: 'profile.png', path: join(dir, 'screenshots', 'profile.png') },
+          { name: 'video.mp4', path: join(dir, 'video.mp4') },
         ],
+        before: null,
       },
     ]);
     assert.deepEqual(result, {
       verb: 'attach',
       via: 'runner',
       pr: 669,
-      handedOff: [join(dir, 'video.mp4'), join(dir, 'screenshots', 'profile.png')],
+      handedOff: [join(dir, 'screenshots', 'profile.png'), join(dir, 'video.mp4')],
       because: 'this gh has no `gh pr edit --attach`',
       sessionRun: '37731397352',
       sessionRunUrl: 'https://github.com/clerk/clerk-ios/actions/runs/37731397352',
@@ -299,21 +386,28 @@ describe('attach on a machine whose gh cannot attach', () => {
     let out = '';
     createOutput(false, '/tmp', 'bin/control-x', { write: (text: string) => (out += text) }, { write: () => true }).result(result);
     assert.deepEqual(out.trimEnd().split('\n'), [
-      "handed off  video.mp4, profile.png  to the session's runner (https://github.com/clerk/clerk-ios/actions/runs/37731397352), because this gh has no `gh pr edit --attach`",
+      "handed off  profile.png, video.mp4  to the session's runner (https://github.com/clerk/clerk-ios/actions/runs/37731397352), because this gh has no `gh pr edit --attach`",
       'next        bin/control-x down ends the session; the verify-attach workflow then puts the evidence in the description of PR #669',
     ]);
   });
 
-  const ghThatHasAttach = (edit: { readonly code: number; readonly stdout: string; readonly stderr: string }, view = { code: 0, stdout: JSON.stringify({ body: 'A description.\n', url: 'https://github.com/clerk/clerk-ios/pull/669' }), stderr: '' }) => (args: readonly string[]) => {
+  const ghThatHasAttach = (edit: { readonly code: number; readonly stdout: string; readonly stderr: string }, view = { code: 0, stdout: JSON.stringify({ body: 'A description.\n', url: 'https://github.com/clerk/clerk-ios/pull/669', state: 'OPEN' }), stderr: '' }) => (args: readonly string[]) => {
     if (args.includes('--help')) return { code: 0, stdout: '      --attach file   Attach a file\n', stderr: '' };
     return args[1] === 'view' ? view : edit;
   };
 
   it('tries gh pr edit --attach itself first for a borrowed-device run, and hands nothing off when that works', async () => {
-    const { deps, run, dir, bundles, ghCalls } = remoteRun({ gh: ghThatHasAttach({ code: 0, stdout: 'https://github.com/clerk/clerk-ios/pull/669\n', stderr: '' }) });
-    const result = await attach(deps, { verb: 'attach', run, pr: 669, screenshots: 'all' });
-    assert.deepEqual(result, { verb: 'attach', via: 'gh', prUrl: 'https://github.com/clerk/clerk-ios/pull/669', posted: [join(dir, 'video.mp4'), join(dir, 'screenshots', 'profile.png')], alreadyPosted: false });
-    assert.deepEqual(ghCalls, ['pr edit --help', 'pr view 669', 'pr view 669', 'pr edit --attach']);
+    let body = 'A description.\n';
+    const gh = (args: readonly string[]) => {
+      if (args.includes('--help')) return { code: 0, stdout: '      --attach file   Attach a file\n', stderr: '' };
+      if (args[1] === 'view') return { code: 0, stdout: JSON.stringify({ body, url: 'https://github.com/clerk/clerk-ios/pull/669', state: 'OPEN' }), stderr: '' };
+      body = readFileSync(args[args.indexOf('--body-file') + 1]!, 'utf8').replace(/\(\.\/[^)]+\)/g, '(https://github.com/user-attachments/assets/00000000-0000-4000-8000-000000000001)');
+      return { code: 0, stdout: 'https://github.com/clerk/clerk-ios/pull/669\n', stderr: '' };
+    };
+    const { deps, run, dir, bundles, ghCalls } = remoteRun({ gh });
+    const result = await attach(deps, { verb: 'attach', run, pr: 669, media: BOTH, before: null });
+    assert.deepEqual(result, { verb: 'attach', via: 'gh', prUrl: 'https://github.com/clerk/clerk-ios/pull/669', posted: [join(dir, 'screenshots', 'profile.png'), join(dir, 'video.mp4')], alreadyPosted: false });
+    assert.deepEqual(ghCalls, ['pr edit --help', 'pr view 669', 'pr view 669', 'pr edit --attach', 'pr view 669', 'pr edit --attach']);
     assert.deepEqual(bundles, [], 'nothing went to the session');
   });
 
@@ -324,7 +418,7 @@ describe('attach on a machine whose gh cannot attach', () => {
       gh: (args) => (order.push(args.includes('--attach') ? 'gh pr edit --attach' : 'gh'), refusedUpload(args)),
       handOff: async () => (order.push('hand-off'), { sessionRun: '1', sessionRunUrl: 'https://github.com/clerk/clerk-ios/actions/runs/1' }),
     });
-    const result = await attach(deps, { verb: 'attach', run, pr: 669, screenshots: 'all' });
+    const result = await attach(deps, { verb: 'attach', run, pr: 669, media: BOTH, before: null });
     assert.equal(result.via === 'runner' && result.because, 'gh pr edit failed');
     assert.equal(ghCalls.at(-1), 'pr edit --attach');
     assert.deepEqual(order.slice(-2), ['gh pr edit --attach', 'hand-off']);
@@ -332,21 +426,62 @@ describe('attach on a machine whose gh cannot attach', () => {
 
   it('hands off when gh cannot read the pull request, as it cannot where GraphQL is blocked', async () => {
     const { deps, run, bundles, ghCalls } = remoteRun({ gh: ghThatHasAttach({ code: 0, stdout: '', stderr: '' }, { code: 1, stdout: '', stderr: 'GraphQL: blocked\n' }) });
-    const result = await attach(deps, { verb: 'attach', run, pr: 669, screenshots: 'all' });
+    const result = await attach(deps, { verb: 'attach', run, pr: 669, media: BOTH, before: null });
     assert.equal(result.via === 'runner' && result.because, 'gh pr view failed');
     assert.deepEqual(ghCalls, ['pr edit --help', 'pr view 669']);
     assert.equal(bundles.length, 1);
   });
 
-  it('hands off only the screenshots that were asked for', async () => {
+  it('hands off only the kind of file that was asked for', async () => {
     const { deps, run, bundles } = remoteRun();
-    await attach(deps, { verb: 'attach', run, pr: 669, screenshots: [] });
-    assert.deepEqual(bundles[0]!.files.map((file) => file.name), ['video.mp4']);
+    await attach(deps, { verb: 'attach', run, pr: 669, media: { screenshots: [], video: true }, before: null });
+    await attach(deps, { verb: 'attach', run, pr: 669, media: { screenshots: ['profile'], video: false }, before: null });
+    assert.deepEqual(bundles.map((bundle) => bundle.files.map((file) => file.name)), [['video.mp4'], ['profile.png']]);
+  });
+
+  it('hands off the files of a before run from its directory in this checkout, whichever session made that run', async () => {
+    const { deps, run, dir, bundles } = remoteRun();
+    const before = deps.workspace.newRun();
+    mkdirSync(join(before.dir, 'screenshots'));
+    writeFileSync(join(before.dir, 'video.mp4'), WAS_VIDEO);
+    writeFileSync(join(before.dir, 'screenshots', 'profile.png'), WAS_SHOT);
+    const record = JSON.parse(readFileSync(join(dir, 'run.json'), 'utf8')) as EvidenceRecord;
+    writeFileSync(
+      join(before.dir, 'run.json'),
+      JSON.stringify({
+        ...record,
+        run: before.run,
+        startedAt: '2026-10-08T04:00:00.000Z',
+        gitHead: BEFORE_COMMIT,
+        results: record.results.map((result) => ({ ...result, status: 'failed' })),
+        videos: [join(before.dir, 'video.mp4')],
+        screenshots: [{ label: 'profile', path: join(before.dir, 'screenshots', 'profile.png') }],
+      }),
+    );
+    const result = await attach(deps, { verb: 'attach', run, pr: 669, media: BOTH, before: before.run });
+    assert.deepEqual(bundles[0]!.before, {
+      summary: { run: before.run, platform: 'ios', device: 'iPhone Air on xcode-27', commit: BEFORE_COMMIT, passed: 0, flaky: 0, total: 1 },
+      files: [
+        { name: 'before-profile.png', path: join(before.dir, 'screenshots', 'profile.png') },
+        { name: 'before-video.mp4', path: join(before.dir, 'video.mp4') },
+      ],
+    });
+    assert.deepEqual(result.via === 'runner' && result.handedOff, [join(dir, 'screenshots', 'profile.png'), join(dir, 'video.mp4'), join(before.dir, 'screenshots', 'profile.png'), join(before.dir, 'video.mp4')]);
+  });
+
+  it('hands nothing off when the directory of the before run is not in this checkout, and says what to do', async () => {
+    const { deps, run, bundles, ghCalls } = remoteRun();
+    await assert.rejects(attach(deps, { verb: 'attach', run, pr: 669, media: BOTH, before: 'r20261008-040000-0000' as RunId }), {
+      code: 'USAGE',
+      message: `no run r20261008-040000-0000 in ${deps.workspace.root}/runs, so its files cannot be shown as the before`,
+      fix: 'pass a run that `{cli} run` made in this checkout, whose directory is still there, or attach without --before, and name the before run in the PR',
+    });
+    assert.deepEqual([bundles, ghCalls], [[], []]);
   });
 
   const failure = async (deps: Deps, run: RunId): Promise<VerifyFailure> => {
     try {
-      await attach(deps, { verb: 'attach', run, pr: 669, screenshots: 'all' });
+      await attach(deps, { verb: 'attach', run, pr: 669, media: BOTH, before: null });
     } catch (error) {
       if (error instanceof VerifyFailure) return error;
       throw error;
@@ -401,16 +536,20 @@ describe('the remote backend before it sends evidence', () => {
     readonly commits?: readonly string[];
     readonly health?: unknown;
     readonly files?: EvidenceBundle['files'];
+    readonly before?: string;
+    readonly compared?: { readonly status: number; readonly json: unknown };
   }
 
   async function handOff(options: Case = {}) {
     const dir = mkdtempSync(join(tmpdir(), 'verify-handoff-backend-'));
     writeFileSync(join(dir, 'token'), 'b'.repeat(64));
     writeFileSync(join(dir, 'video.mp4'), VIDEO);
+    writeFileSync(join(dir, 'before.mp4'), WAS_VIDEO);
     const bundle: EvidenceBundle = {
       pr: 669,
       summary: { run: good.run as RunId, platform: 'ios', device: good.device, commit: COMMIT, passed: 3, flaky: 0, total: 3 },
       files: options.files ?? [{ name: 'video.mp4', path: join(dir, 'video.mp4') as EvidencePath }],
+      before: options.before === undefined ? null : { summary: { run: goodBefore.run as RunId, platform: 'ios', device: good.device, commit: options.before, passed: 0, flaky: 0, total: 3 }, files: [{ name: 'before-video.mp4', path: join(dir, 'before.mp4') as EvidencePath }] },
     };
     const commits = options.commits ?? [STARTED_ON, COMMIT];
     const asked: string[] = [];
@@ -422,23 +561,26 @@ describe('the remote backend before it sends evidence', () => {
         asked.push(path);
         const page = /^\/pulls\/669\/commits\?per_page=100&page=(\d+)$/.exec(path);
         if (page !== null) return { status: 200, json: commits.slice((Number(page[1]) - 1) * 100, Number(page[1]) * 100).map((sha) => ({ sha })), headers: new Headers() };
+        if (path.startsWith('/compare/')) return { ...(options.compared ?? { status: 200, json: { status: 'ahead' } }), headers: new Headers() };
         return { status: 200, json: path.startsWith('/pulls/') ? (options.pull ?? OPEN) : { head_branch: 'feature/change', head_sha: STARTED_ON }, headers: new Headers() };
       },
     };
     const sent: string[] = [];
     const health = options.health === undefined ? { ending: null } : options.health;
     const realFetch = globalThis.fetch;
-    globalThis.fetch = async (input) => {
+    const manifests: unknown[] = [];
+    globalThis.fetch = async (input, init) => {
       const path = new URL(String(input)).pathname;
       if (path === '/__sim/health') return health === null ? new Response('gone', { status: 502 }) : Response.json(health);
       sent.push(path);
+      if (path === '/__sim/evidence/begin') manifests.push(JSON.parse(String(init?.body)));
       return Response.json({ ok: true });
     };
     try {
       const receipt = await remoteBackend(settings, { env: {}, runner: realRunner, github: async () => hub }).handOffEvidence!({ ...LEASE, tokenFile: join(dir, 'token') }, bundle, () => undefined);
-      return { receipt, error: null, sent, asked };
+      return { receipt, error: null, sent, asked, manifests };
     } catch (error) {
-      if (error instanceof VerifyFailure) return { receipt: null, error, sent, asked };
+      if (error instanceof VerifyFailure) return { receipt: null, error, sent, asked, manifests };
       throw error;
     } finally {
       globalThis.fetch = realFetch;
@@ -458,6 +600,34 @@ describe('the remote backend before it sends evidence', () => {
     assert.deepEqual(receipt, { sessionRun: '37731397352', sessionRunUrl: 'https://github.com/clerk/clerk-ios/actions/runs/37731397352' });
   });
 
+  it('sends the before run in the manifest and its files after the files of the run, though its commit is the one the branch started from and no commit of the pull request', async () => {
+    const { error, sent, manifests, asked } = await handOff({ before: BEFORE_COMMIT });
+    assert.equal(error, null);
+    assert.deepEqual(asked.filter((path) => path.startsWith('/compare/')), [`/compare/${BEFORE_COMMIT}...${COMMIT}?per_page=1`]);
+    assert.deepEqual(sent, ['/__sim/evidence/begin', '/__sim/evidence/chunk', '/__sim/evidence/chunk', '/__sim/evidence/commit']);
+    assert.deepEqual(manifests, [
+      {
+        ...good,
+        files: [good.files[0]],
+        before: { run: goodBefore.run, commit: BEFORE_COMMIT, passed: 0, flaky: 0, total: 3, files: [goodBefore.files[0]] },
+      },
+    ]);
+  });
+
+  it('sends nothing when the commit of the before run is not the commit of the run or one before it in its history, as the workflow would refuse it', async () => {
+    const message = `${wouldNot}the before run ${goodBefore.run} was made at 5e1263750651, which is not the commit of the run or a commit before it in its history`;
+    const fix = '{cli} run the spec at a commit that 0f50b597b1c2 still has in its history and does not hold the change, and pass that run as --before, or attach without --before and name the before run in the PR';
+    for (const compared of [{ status: 200, json: { status: 'behind' } }, { status: 200, json: { status: 'diverged' } }, { status: 200, json: null }, { status: 404, json: { message: 'Not Found' } }]) {
+      const refused = await refusal({ before: BEFORE_COMMIT, compared });
+      assert.deepEqual({ code: refused.error.code, message: refused.error.message, fix: refused.error.fix, sent: refused.sent }, { code: 'NOT_READY', message, fix, sent: [] }, JSON.stringify(compared));
+    }
+    assert.equal((await handOff({ before: COMMIT, compared: { status: 200, json: { status: 'identical' } } })).error, null);
+    const unread = await refusal({ before: BEFORE_COMMIT, compared: { status: 502, json: { message: 'Bad Gateway' } } });
+    assert.match(unread.error.message, new RegExp(`^could not compare the commit of run ${goodBefore.run} with the commit of run ${good.run}: `));
+    assert.deepEqual(unread.sent, []);
+    assert.deepEqual((await handOff()).asked.filter((path) => path.startsWith('/compare/')), [], 'a run with no before run asks for no comparison');
+  });
+
   it('sends a run whose pull request has moved on to newer commits', async () => {
     const newer = 'b'.repeat(40);
     const { error, sent } = await handOff({ pull: { ...OPEN, head: { ...OPEN.head, sha: newer } }, commits: [STARTED_ON, COMMIT, newer] });
diff --git a/integration/expo-native/test/instances.test.ts b/integration/expo-native/test/instances.test.ts
index 22c5a093e85..f28d6521753 100644
--- a/integration/expo-native/test/instances.test.ts
+++ b/integration/expo-native/test/instances.test.ts
@@ -1575,7 +1575,7 @@ describe('the broker of a run', () => {
     const w = world();
     await w.instances.ensure(NOTHING_NEW, quiet);
     const { run, scratch } = w.workspace.newRun();
-    const broker = await startBroker(run, w.workspace, scratch as ScratchPath, { keys: () => w.instances.keys(), fetch: w.clerk.fetch });
+    const broker = await startBroker(run, w.workspace, scratch as ScratchPath, { keys: () => w.instances.keys(), fetch: w.clerk.fetch, beforeLaunch: async () => undefined });
     const create = async () => {
       const response = await fetch(`${broker.url}/users`, { method: 'POST', headers: { Authorization: `Bearer ${readFileSync(broker.tokenFile, 'utf8')}` }, body: JSON.stringify({ email_address: [newTestEmail(run)], skip_password_requirement: true }) });
       return { status: response.status, json: (await response.json()) as Record<string, unknown> };
diff --git a/integration/expo-native/test/run-groups.test.ts b/integration/expo-native/test/run-groups.test.ts
index 17eabb24a54..f0edd6fbdc7 100644
--- a/integration/expo-native/test/run-groups.test.ts
+++ b/integration/expo-native/test/run-groups.test.ts
@@ -1,18 +1,19 @@
 import '../testing/git-env.ts';
 import assert from 'node:assert/strict';
 import { execFileSync } from 'node:child_process';
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { appendFileSync, chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { describe, it } from 'node:test';
 import { exitCodeFor } from '../src/core/cli.ts';
 import { assertPublishable, readRecord } from '../src/core/evidence.ts';
+import type { Runner } from '../src/core/exec.ts';
 import { createInstances } from '../src/core/instances/instances.ts';
 import { SettingsRefused, settingsFileOf } from '../src/core/instances/settings.ts';
 import { summarize } from '../src/core/publish.ts';
 import { runVerb, type Deps } from '../src/core/verbs.ts';
 import { openWorkspace } from '../src/core/workspace.ts';
-import { VerifyFailure, type BuildKey, type Command, type DeviceBackend, type HostAdapter, type InstanceSettings, type LocalLease, type ScratchPath } from '../src/core/types.ts';
+import { VerifyFailure, type BuildKey, type Command, type DeviceBackend, type EvidencePath, type HostAdapter, type InstanceSettings, type LocalLease, type ScratchPath } from '../src/core/types.ts';
 import { PLATFORM_KEY, fakeClerk, type FakeClerkOptions } from '../testing/fake-clerk.ts';
 import { LEFT_OUT, linesLeftOut, watchDriver } from '../src/core/driver.ts';
 import { readAgent } from '../specs/support/agent.ts';
@@ -36,6 +37,7 @@ const output = args[args.indexOf('--output') + 1];
 const specs = args.slice(1, args.indexOf('--config'));
 const plan = JSON.parse(fs.readFileSync('fake-e2e.json', 'utf8'));
 fs.appendFileSync('invocations.jsonl', JSON.stringify({ specs, output, args }) + '\\n');
+fs.appendFileSync('order.log', 'e2e opens the app with no arguments\\n');
 (async () => {
   const token = fs.readFileSync(process.env.CLERK_E2E_API_TOKEN_FILE, 'utf8');
   const [, runTime, runTag] = process.env.CLERK_E2E_RUN_ID.split('-');
@@ -84,6 +86,16 @@ fs.appendFileSync('invocations.jsonl', JSON.stringify({ specs, output, args }) +
   for (const [index, file] of specs.entries()) {
     console.log('fake e2e runs ' + file);
     if ((plan.silent || []).includes(file)) continue;
+    let launchRefused = null;
+    if (plan.launches) {
+      const ready = await fetch(process.env.CLERK_E2E_API_URL + '/about_to_launch', { method: 'POST', headers: { Authorization: 'Bearer ' + token } });
+      launchRefused = ready.ok ? null : (await ready.json()).errors[0].long_message;
+      fs.appendFileSync('order.log', (launchRefused === null ? 'launches for ' : 'does not launch for ') + path.basename(file) + '\\n');
+    }
+    if (plan.retriesTheOpen) {
+      const again = await fetch(process.env.CLERK_E2E_API_URL + '/about_to_launch', { method: 'POST', headers: { Authorization: 'Bearer ' + token } });
+      fs.appendFileSync('order.log', 'retries the open for ' + path.basename(file) + ', answered ' + again.status + ' ' + (await again.text()) + '\\n');
+    }
     const password = require('node:crypto').randomBytes(12).toString('hex') + 'Aa1!';
     const seeded = await fetch(process.env.CLERK_E2E_API_URL + '/users', { method: 'POST', headers: { Authorization: 'Bearer ' + token }, body: JSON.stringify({ email_address: [emailOf()], ...(plan.password === true ? { password, bypass_client_trust: true } : { skip_password_requirement: true }) }) });
     const body = await seeded.json();
@@ -94,7 +106,8 @@ fs.appendFileSync('invocations.jsonl', JSON.stringify({ specs, output, args }) +
       fs.writeFileSync(path.join(output, 'trace.txt'), 'fill ' + password);
       body.message = 'the field shows ' + password;
     }
-    const passed = seeded.ok && !plan.password;
+    const passed = seeded.ok && !plan.password && launchRefused === null;
+    if (launchRefused !== null) body.message = launchRefused;
     const shot = 'ios/' + index + '/attempt-0/screenshots/001-home.png';
     fs.mkdirSync(path.dirname(path.join(output, 'artifacts', shot)), { recursive: true });
     fs.writeFileSync(path.join(output, 'artifacts', shot), path.basename(output));
@@ -119,6 +132,8 @@ interface FakeE2EPlan {
   readonly edit?: string;
   readonly exitCode?: number;
   readonly password?: boolean;
+  readonly launches?: boolean;
+  readonly retriesTheOpen?: boolean;
   readonly driver?: {
     readonly refusesALeftoverRegistration?: boolean;
     readonly daemonFailsToStartIn?: readonly string[];
@@ -218,6 +233,106 @@ describe('a run whose spec files declare different settings', () => {
     }
   });
 
+  describe('with video', () => {
+    function recorded(plan: FakeE2EPlan, specs: Readonly<Record<string, InstanceSettings | null>> = { [AUTH_START]: null }) {
+      const w = world({ specs, plan });
+      const note = (line: string) => appendFileSync(join(w.dir, 'order.log'), `${line}\n`);
+      const deps = w.deps();
+      const backend = deps.host.backends[0] as { startRecording: DeviceBackend['startRecording'] };
+      backend.startRecording = async (_lease, into) => {
+        note('recorder starts');
+        return { process: null, stop: async () => (writeFileSync(join(into, 'video.mp4'), 'frames'), join(into, 'video.mp4') as EvidencePath) };
+      };
+      const runner: Runner = async (command, args) => {
+        if (command === join(w.dir, 'node_modules', '.bin', 'agent-device')) note(`agent-device ${args.join(' ')}`);
+        return { code: 0, stdout: '', stderr: '' };
+      };
+      const close = `agent-device close com.clerk.E2EHost --platform ios --udid UDID-1 --session verify-ios-${w.workspace.worktreeId}`;
+      const order = () => readFileSync(join(w.dir, 'order.log'), 'utf8').trim().split('\n');
+      const videoLines = () => w.lines.filter((line) => line.startsWith('video'));
+      return { w, deps: { ...deps, runner }, backend, close, order, videoLines };
+    }
+
+    it('records from the first time a test launches the app, after it closes the app that e2e opened, and once for all the groups of the run', async () => {
+      const r = recorded({ launches: true }, { [AUTH_START]: null, [CHOOSE_ORG]: FORCED_ORG });
+      const { record, dir } = await runVerb(r.deps, { ...RUN_ALL, video: true });
+      assert.deepEqual(r.order(), [
+        'e2e opens the app with no arguments',
+        r.close,
+        'recorder starts',
+        'launches for auth-start.e2e.ts',
+        'e2e opens the app with no arguments',
+        'launches for choose-organization.e2e.ts',
+      ]);
+      assert.deepEqual(record.videos, [join(dir, 'video.mp4')]);
+      assert.deepEqual(r.videoLines(), []);
+    });
+
+    it('keeps the one recording when a test opens the app a second time after a failed open: it closes nothing and starts no second recorder', async () => {
+      const r = recorded({ launches: true, retriesTheOpen: true });
+      const { record, dir } = await runVerb(r.deps, { ...RUN_ALL, video: true });
+      assert.deepEqual(r.order(), ['e2e opens the app with no arguments', r.close, 'recorder starts', 'launches for auth-start.e2e.ts', 'retries the open for auth-start.e2e.ts, answered 200 {}']);
+      assert.deepEqual(record.videos, [join(dir, 'video.mp4')]);
+      assert.deepEqual(r.videoLines(), []);
+    });
+
+    it('records nothing and says so in one line when no test launches the app', async () => {
+      const r = recorded({});
+      const { record } = await runVerb(r.deps, { ...RUN_ALL, video: true });
+      assert.deepEqual(r.order(), ['e2e opens the app with no arguments']);
+      assert.deepEqual(record.videos, []);
+      assert.deepEqual(r.videoLines(), ['video   no test launched the app, so this run has no video']);
+    });
+
+    it('lets the app launch at once, as it was left, in a run with --no-video', async () => {
+      const r = recorded({ launches: true });
+      const { record } = await runVerb(r.deps, RUN_ALL);
+      assert.deepEqual(r.order(), ['e2e opens the app with no arguments', 'launches for auth-start.e2e.ts']);
+      assert.deepEqual(record.videos, []);
+      assert.deepEqual(r.videoLines(), []);
+    });
+
+    it('records all the same when the app could not be closed, and says what the video may open on', async () => {
+      const r = recorded({ launches: true });
+      const refusing: Runner = async (command, args) => (command.endsWith('agent-device') ? { code: 1, stdout: '', stderr: 'DEVICE_IN_USE\n' } : r.deps.runner(command, args));
+      await runVerb({ ...r.deps, runner: refusing }, { ...RUN_ALL, video: true });
+      assert.deepEqual(r.order(), ['e2e opens the app with no arguments', 'recorder starts', 'launches for auth-start.e2e.ts']);
+      assert.deepEqual(r.videoLines(), ['video   the app could not be closed before the recording, so the video may open on the screen it was showing: DEVICE_IN_USE']);
+    });
+
+    it('gives the close before the recording 30 seconds, and records all the same when it runs out', async () => {
+      const r = recorded({ launches: true });
+      const limits: (number | undefined)[] = [];
+      const hanging: Runner = async (command, args, options) => {
+        if (!command.endsWith('agent-device')) return r.deps.runner(command, args, options);
+        limits.push(options?.timeoutMs);
+        return { code: 124, stdout: '', stderr: 'timed out after 30000ms\n' };
+      };
+      await runVerb({ ...r.deps, runner: hanging }, { ...RUN_ALL, video: true });
+      assert.deepEqual(limits, [30_000]);
+      assert.deepEqual(r.order(), ['e2e opens the app with no arguments', 'recorder starts', 'launches for auth-start.e2e.ts']);
+      assert.deepEqual(r.videoLines(), ['video   the app could not be closed before the recording, so the video may open on the screen it was showing: timed out after 30000ms']);
+    });
+
+    it('launches nothing when the recorder cannot start: each test that would launch fails with the reason and the fix, and the recorder is tried once', async () => {
+      const r = recorded({ launches: true }, { [AUTH_START]: null, [SIGN_UP]: null });
+      let tries = 0;
+      r.backend.startRecording = async () => {
+        tries += 1;
+        throw new VerifyFailure('NOT_READY', 'simctl recordVideo exited 1: no such device', 'rerun with --no-video');
+      };
+      const { record } = await runVerb(r.deps, { ...RUN_ALL, video: true });
+      assert.deepEqual(r.order(), ['e2e opens the app with no arguments', r.close, 'does not launch for auth-start.e2e.ts', 'does not launch for complete.e2e.ts']);
+      assert.deepEqual(record.results.map((result) => [result.status, result.error]), [
+        ['failed', 'simctl recordVideo exited 1: no such device (fix: rerun with --no-video)'],
+        ['failed', 'simctl recordVideo exited 1: no such device (fix: rerun with --no-video)'],
+      ]);
+      assert.equal(tries, 1);
+      assert.deepEqual(record.videos, []);
+      assert.deepEqual(r.videoLines(), []);
+    });
+  });
+
   it('drives each group on one application, in one e2e invocation each, and records what it did', async () => {
     const w = world();
     const result = await runVerb(w.deps(), RUN_ALL);
diff --git a/integration/expo-native/test/session-agent.test.ts b/integration/expo-native/test/session-agent.test.ts
index 9c5dec0266b..36d9881de5f 100644
--- a/integration/expo-native/test/session-agent.test.ts
+++ b/integration/expo-native/test/session-agent.test.ts
@@ -9,7 +9,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { after, describe, it } from 'node:test';
 import { coreVersion } from '../src/core/manifest.ts';
-import { HANDOFF_LIMITS, parseHandoffManifest } from '../src/core/remote/handoff.ts';
+import { HANDOFF_LIMITS, parseHandoffManifest, type HandoffManifest } from '../src/core/remote/handoff.ts';
 import { sendEvidence } from '../src/core/remote/session.ts';
 import { plan } from '../src/core/remote/session-agent.ts';
 import { sha256Hex, type SessionHealth, type SessionRequest } from '../src/core/remote/protocol.ts';
@@ -410,7 +410,7 @@ describe('session agent', () => {
     writeFileSync(join(dir, 'token'), token);
     const sha256 = (data: Buffer) => createHash('sha256').update(data).digest('hex');
     const manifest = parseHandoffManifest(
-      JSON.stringify({ v: 1, pr: 669, run: 'r20261008-052713-253e', platform: 'ios', device: 'Test Phone on test-runner', commit: 'a'.repeat(40), passed: 1, flaky: 0, total: 1, files: [{ name: 'video.mp4', bytes: video.length, sha256: sha256(video) }, { name: 'profile.png', bytes: shot.length, sha256: sha256(shot) }] }),
+      JSON.stringify({ v: 2, before: null, pr: 669, run: 'r20261008-052713-253e', platform: 'ios', device: 'Test Phone on test-runner', commit: 'a'.repeat(40), passed: 1, flaky: 0, total: 1, files: [{ name: 'video.mp4', bytes: video.length, sha256: sha256(video) }, { name: 'profile.png', bytes: shot.length, sha256: sha256(shot) }] }),
     );
     for (const step of ['begin', 'chunk', 'commit']) assert.equal((await agent.call(`/__sim/evidence/${step}`, { method: 'POST', bearer: null, body: '{}' })).status, 403, step);
     assert.equal((await agent.call('/__sim/evidence/begin', { method: 'POST', body: JSON.stringify({ ...manifest, run: 'nope' }) })).status, 400);
@@ -430,7 +430,17 @@ describe('session agent', () => {
       return response;
     };
     try {
-      await sendEvidence({ baseUrl: 'https://fake-session-host.trycloudflare.com', tokenFile: join(dir, 'token') }, manifest, new Map([['video.mp4', join(dir, 'video.mp4')], ['profile.png', join(dir, 'profile.png')]]), (line) => void lines.push(line), 10);
+      const session = { baseUrl: 'https://fake-session-host.trycloudflare.com', tokenFile: join(dir, 'token') };
+      const paths = new Map([['video.mp4', join(dir, 'video.mp4')], ['profile.png', join(dir, 'profile.png')]]);
+      const { before: _, ...versionOne } = { ...manifest, v: 1 };
+      await assert.rejects(sendEvidence(session, versionOne as unknown as HandoffManifest, paths, (line) => void lines.push(line), 10), {
+        code: 'NOT_READY',
+        message: 'the session refused the manifest of run r20261008-052713-253e: the manifest is version 1, and this session takes only version 2',
+        fix: '{cli} down, then {cli} up, so that the session runs the verify code of this checkout, then {cli} run again and attach',
+      });
+      assert.equal(lines.length, 0, 'no file was sent');
+      assert.equal(existsSync(join(agent.work, 'evidence.partial')), false, 'a refused manifest starts no hand-off');
+      await sendEvidence(session, manifest, paths, (line) => void lines.push(line), 10);
     } finally {
       globalThis.fetch = realFetch;
     }
diff --git a/integration/expo-native/test/something-ran.test.ts b/integration/expo-native/test/something-ran.test.ts
index a7586c823fe..84f764f90bb 100644
--- a/integration/expo-native/test/something-ran.test.ts
+++ b/integration/expo-native/test/something-ran.test.ts
@@ -42,6 +42,9 @@ describe('a run in which nothing executed', () => {
   });
 
   it('suggests attach after a run with a passing spec', () => {
-    assert.match(nextStep(run, dir, results([{ status: 'passed' }]), 'auth-start'), /^\{cli\} attach r20261003-000000-abcd/);
+    assert.equal(
+      nextStep(run, dir, results([{ status: 'passed' }]), 'auth-start'),
+      '{cli} attach r20261003-000000-abcd --pr <n> --screenshot <label> for a still change, or --video for behavior or a flow; add --before <run-id> when the change is to something that exists',
+    );
   });
 });
diff --git a/scripts/verify-attach.mjs b/scripts/verify-attach.mjs
index 5409fc12d09..29a7285256f 100644
--- a/scripts/verify-attach.mjs
+++ b/scripts/verify-attach.mjs
@@ -22,7 +22,7 @@ const LIMITS = {
 const ARTIFACT = 'verify-evidence';
 const MANIFEST_FILE = 'manifest.json';
 const SESSION_WORKFLOW = '.github/workflows/verify-remote.yml';
-const MANIFEST_VERSION = 1;
+const MANIFEST_VERSION = 2;
 
 const SHAPE = {
   run: /^r\d{8}-\d{6}-[0-9a-f]{4}$/,
@@ -35,7 +35,8 @@ const SHAPE = {
   actor: /^[A-Za-z0-9][A-Za-z0-9_-]{0,99}(\[bot\])?$/,
 };
 
-const MANIFEST_KEYS = ['v', 'pr', 'run', 'platform', 'device', 'commit', 'passed', 'flaky', 'total', 'files'];
+const MANIFEST_KEYS = ['v', 'pr', 'run', 'platform', 'device', 'commit', 'passed', 'flaky', 'total', 'files', 'before'];
+const BEFORE_KEYS = ['run', 'commit', 'passed', 'flaky', 'total', 'files'];
 const FILE_KEYS = ['name', 'bytes', 'sha256'];
 
 class Refused extends Error {}
@@ -47,6 +48,8 @@ function refuse(message) {
 
 const isVideo = name => name.endsWith('.mp4');
 
+const everyFile = manifest => [...manifest.files, ...(manifest.before?.files ?? [])];
+
 function sessionRunMismatch(run, repo) {
   if (run.event !== 'workflow_dispatch') {
     return 'it was not started by a dispatch';
@@ -200,11 +203,15 @@ function readEntry(zip, entry, directoryAt) {
   return data;
 }
 
-function record(value, keys, what) {
+function anObject(value, what) {
   if (typeof value !== 'object' || value === null || Array.isArray(value)) {
     refuse(`${what} is not an object`);
   }
-  const own = Object.keys(value);
+  return value;
+}
+
+function record(value, keys, what) {
+  const own = Object.keys(anObject(value, what));
   if (own.length !== keys.length || own.some(key => !keys.includes(key))) {
     refuse(`${what} must have exactly the keys ${keys.join(', ')}`);
   }
@@ -225,6 +232,50 @@ function shaped(value, pattern, what) {
   return value;
 }
 
+function parseFiles(list, what) {
+  if (!Array.isArray(list) || list.length < 1 || list.length > LIMITS.files) {
+    refuse(`${what} must be a list of 1 to ${LIMITS.files}`);
+  }
+  const files = list.map((entry, i) => {
+    const file = record(entry, FILE_KEYS, `file ${i + 1}`);
+    const name = shaped(file.name, SHAPE.fileName, `the name of file ${i + 1}`);
+    return {
+      name,
+      bytes: whole(file.bytes, 1, isVideo(name) ? LIMITS.videoBytes : LIMITS.imageBytes, `the size of file ${i + 1}`),
+      sha256: shaped(file.sha256, SHAPE.sha256, `the sha256 of file ${i + 1}`),
+    };
+  });
+  if (files.filter(file => isVideo(file.name)).length > LIMITS.videos) {
+    refuse(`at most ${LIMITS.videos} video`);
+  }
+  return files;
+}
+
+function parseBefore(value, run, files) {
+  const raw = record(value, BEFORE_KEYS, 'before');
+  const before = {
+    run: shaped(raw.run, SHAPE.run, 'the run of before'),
+    commit: shaped(raw.commit, SHAPE.commit, 'the commit of before'),
+    passed: whole(raw.passed, 0, LIMITS.tests, 'passed of before'),
+    flaky: whole(raw.flaky, 0, LIMITS.tests, 'flaky of before'),
+    total: whole(raw.total, 1, LIMITS.tests, 'total of before'),
+    files: parseFiles(raw.files, 'the files of before'),
+  };
+  if (before.run === run) {
+    refuse('before is the run itself');
+  }
+  if (before.passed + before.flaky > before.total) {
+    refuse('passed and flaky of before must count at most total');
+  }
+  if (
+    before.files.length !== files.length ||
+    before.files.some((file, i) => isVideo(file.name) !== isVideo(files[i].name))
+  ) {
+    refuse('before must have one file for each file, of the same kind');
+  }
+  return before;
+}
+
 function parseManifest(text) {
   if (Buffer.byteLength(text) > LIMITS.manifestBytes) {
     refuse(`the manifest is over ${LIMITS.manifestBytes} bytes`);
@@ -235,32 +286,25 @@ function parseManifest(text) {
   } catch {
     return refuse('the manifest is not JSON');
   }
-  const raw = record(parsed, MANIFEST_KEYS, 'the manifest');
-  if (raw.v !== MANIFEST_VERSION) {
-    refuse(`the manifest is not version ${MANIFEST_VERSION}`);
+  const { v } = anObject(parsed, 'the manifest');
+  if (v !== MANIFEST_VERSION) {
+    const found = Number.isInteger(v) && v >= 0 && v <= 999 ? `version ${v}` : 'of no version this script knows';
+    refuse(`the manifest is ${found}, and this script publishes only version ${MANIFEST_VERSION}`);
   }
+  const raw = record(parsed, MANIFEST_KEYS, 'the manifest');
   if (raw.platform !== 'ios' && raw.platform !== 'android') {
     refuse('platform must be ios or android');
   }
-  if (!Array.isArray(raw.files) || raw.files.length < 1 || raw.files.length > LIMITS.files) {
-    refuse(`files must be a list of 1 to ${LIMITS.files}`);
+  const files = parseFiles(raw.files, 'files');
+  const before = raw.before === null ? null : parseBefore(raw.before, raw.run, files);
+  const all = everyFile({ files, before });
+  if (all.length > LIMITS.files) {
+    refuse(`at most ${LIMITS.files} files in all`);
   }
-  const files = raw.files.map((entry, i) => {
-    const file = record(entry, FILE_KEYS, `file ${i + 1}`);
-    const name = shaped(file.name, SHAPE.fileName, `the name of file ${i + 1}`);
-    return {
-      name,
-      bytes: whole(file.bytes, 1, isVideo(name) ? LIMITS.videoBytes : LIMITS.imageBytes, `the size of file ${i + 1}`),
-      sha256: shaped(file.sha256, SHAPE.sha256, `the sha256 of file ${i + 1}`),
-    };
-  });
-  if (new Set(files.map(file => file.name.toLowerCase())).size !== files.length) {
+  if (new Set(all.map(file => file.name.toLowerCase())).size !== all.length) {
     refuse('two files have the same name');
   }
-  if (files.filter(file => isVideo(file.name)).length > LIMITS.videos) {
-    refuse(`at most ${LIMITS.videos} video`);
-  }
-  if (files.reduce((sum, file) => sum + file.bytes, 0) > LIMITS.totalBytes) {
+  if (all.reduce((sum, file) => sum + file.bytes, 0) > LIMITS.totalBytes) {
     refuse(`the files are over ${LIMITS.totalBytes} bytes in all`);
   }
   const manifest = {
@@ -274,6 +318,7 @@ function parseManifest(text) {
     flaky: whole(raw.flaky, 0, LIMITS.tests, 'flaky'),
     total: whole(raw.total, 1, LIMITS.tests, 'total'),
     files,
+    before,
   };
   if (manifest.passed + manifest.flaky < 1 || manifest.passed + manifest.flaky > manifest.total) {
     refuse('passed and flaky must count at least one test and at most total');
@@ -301,10 +346,10 @@ function validateBundle(zip) {
     refuse(`the archive has no ${MANIFEST_FILE}`);
   }
   const manifest = parseManifest(readEntry(zip, manifestEntry, directoryAt).toString('utf8'));
-  if (entries.length !== manifest.files.length + 1) {
+  if (entries.length !== everyFile(manifest).length + 1) {
     refuse('the archive and its manifest name different files');
   }
-  const files = manifest.files.map((file, i) => {
+  const files = everyFile(manifest).map((file, i) => {
     const entry = entries.find(candidate => candidate.name === file.name);
     if (entry === undefined) {
       return refuse('the archive and its manifest name different files');
@@ -352,26 +397,85 @@ const evidenceMarkers = platform => ({
   end: `<!-- /verify-evidence:${platform} -->`,
 });
 
-const BLOCK_LINE_START = 'verify run `';
+const BLOCK_LINE_START = '**Verified on ';
+const A_BLOCK_STARTS = /^(\*\*Verified on |verify run `)/;
+const WHERE = { ios: 'an iOS simulator', android: 'an Android emulator' };
 const NEWER_COMMITS = 'The pull request has newer commits.';
+const UPLOADED = /https:\/\/github\.com\/user-attachments\/assets\/[0-9a-f-]{36}/g;
+const IMAGE_WIDTH = 280;
+const ACROSS = 2;
+const CENTERED = ':---:';
 
 const sessionRunUrl = (repo, runId) => `https://github.com/${repo}/actions/runs/${runId}`;
+const commitUrl = (repo, commit) => `https://github.com/${repo}/commit/${commit}`;
+
+const stem = name => name.replace(/\.[a-z0-9]+$/, '');
+const counted = run =>
+  `${run.passed} of ${run.total} passed${run.flaky === 0 ? '' : `, ${run.flaky} flaky (passed only on a retry)`}`;
+const table = (header, rows) =>
+  [header, header.map(() => CENTERED), ...rows].map(cells => `| ${cells.join(' | ')} |`).join('\n');
+const inTables = block => block.includes(CENTERED);
+
+function mediaTables(files, hasBefore, uploaded) {
+  const shown = files.map((name, at) => {
+    const label = stem(name);
+    const cell = (url, alt) => (isVideo(name) ? url : `<img src="${url}" width="${IMAGE_WIDTH}" alt="${alt}">`);
+    return {
+      video: isVideo(name),
+      label,
+      after: cell(uploaded[at], hasBefore ? `After: ${label}` : label),
+      before: hasBefore ? cell(uploaded[files.length + at], `Before: ${label}`) : '',
+    };
+  });
+  return [false, true].flatMap(video => {
+    const some = shown.filter(item => item.video === video);
+    if (some.length === 0) {
+      return [];
+    }
+    if (hasBefore) {
+      return [
+        table(
+          ['Before', 'After'],
+          some.map(item => [item.before, item.after]),
+        ),
+      ];
+    }
+    const rows = Array.from({ length: Math.ceil(some.length / ACROSS) }, (_, row) =>
+      some.slice(row * ACROSS, (row + 1) * ACROSS),
+    );
+    return rows.map(row =>
+      table(
+        row.map(item => `\`${item.label}\``),
+        [row.map(item => item.after)],
+      ),
+    );
+  });
+}
 
-function evidenceBlock(manifest, session, onDisk = file => file.name) {
+// `gh pr edit --attach` rewrites only a markdown reference to a file, so the files go up as a list first, and the tables are written from the addresses GitHub gave them.
+function evidenceBlock(manifest, session, onDisk = file => file.name, uploaded = null) {
   const { start, end } = evidenceMarkers(manifest.platform);
-  const flaky = manifest.flaky === 0 ? '' : `, ${manifest.flaky} flaky (passed only on a retry),`;
+  const { before } = manifest;
+  const was =
+    before === null
+      ? ''
+      : ` The session reports the before as run \`${before.run}\` at [\`${before.commit.slice(0, 12)}\`](${commitUrl(session.repo, before.commit)}), ${counted(before)}.`;
   const since = session.pullHead === manifest.commit ? '' : ` ${NEWER_COMMITS}`;
-  const line = `${BLOCK_LINE_START}${manifest.run}\`, as reported by [the session](${sessionRunUrl(session.repo, session.runId)}) that \`${session.actor}\` started: ${manifest.passed} of ${manifest.total} passed${flaky} on \`${manifest.device}\` at \`${manifest.commit.slice(0, 12)}\`.${since}`;
-  const media = manifest.files.flatMap(file => [
-    '',
-    `![${isVideo(file.name) ? file.name : file.name.replace(/\.[a-z0-9]+$/, '')}](./${onDisk(file)})`,
-  ]);
-  return [start, '', line, ...media, '', end].join('\n');
+  const line = `${BLOCK_LINE_START}${WHERE[manifest.platform]}**, as reported by [the session](${sessionRunUrl(session.repo, session.runId)}) that \`${session.actor}\` started. Run \`${manifest.run}\` on \`${manifest.device}\` at \`${manifest.commit.slice(0, 12)}\`, ${counted(manifest)}.${was}${since}`;
+  const media =
+    uploaded === null
+      ? everyFile(manifest).map(file => `![${isVideo(file.name) ? file.name : stem(file.name)}](./${onDisk(file)})`)
+      : mediaTables(
+          manifest.files.map(file => file.name),
+          before !== null,
+          uploaded,
+        );
+  return [start, '', line, ...media.flatMap(part => ['', part]), '', end].join('\n');
 }
 
 function withNewerCommitsNote(old, { start, end }) {
   const lines = old.replaceAll('\r\n', '\n').split('\n');
-  const at = lines.findIndex(line => line.trimStart().startsWith(BLOCK_LINE_START));
+  const at = lines.findIndex(line => A_BLOCK_STARTS.test(line.trimStart()));
   lines[at] = `${lines[at].trimEnd()} ${NEWER_COMMITS}`;
   return `${start}${lines.join('\n')}${end}`;
 }
@@ -441,7 +545,7 @@ function withEvidenceBlock(body, platform, lines) {
     return { ok: false, why: 'has the end marker before the start marker' };
   }
   const old = body.slice(starts[0] + start.length, ends[0]);
-  if (!old.trimStart().startsWith(BLOCK_LINE_START)) {
+  if (!A_BLOCK_STARTS.test(old.trimStart())) {
     return { ok: false, why: 'has text between the markers that is not an evidence block' };
   }
   return {
@@ -462,13 +566,15 @@ function settings(env) {
   return { repo, runId, work, filesDir: path.join(work, 'files'), manifestFile: path.join(work, MANIFEST_FILE) };
 }
 
+const apiHeaders = token => ({
+  Accept: 'application/vnd.github+json',
+  'X-GitHub-Api-Version': '2022-11-28',
+  'User-Agent': 'verify-attach',
+  Authorization: `Bearer ${token}`,
+});
+
 async function downloadArtifact({ fetch, api, token, repo, runId }) {
-  const headers = {
-    Accept: 'application/vnd.github+json',
-    'X-GitHub-Api-Version': '2022-11-28',
-    'User-Agent': 'verify-attach',
-    Authorization: `Bearer ${token}`,
-  };
+  const headers = apiHeaders(token);
   const listed = await fetch(`${api}/repos/${repo}/actions/runs/${runId}/artifacts?name=${ARTIFACT}&per_page=100`, {
     headers,
   });
@@ -501,6 +607,24 @@ async function downloadArtifact({ fetch, api, token, repo, runId }) {
   return Buffer.concat(chunks);
 }
 
+async function assertBeforeCommitInHistory({ fetch, api, token, repo }, { before, commit }) {
+  const compared = await fetch(`${api}/repos/${repo}/compare/${before.commit}...${commit}?per_page=1`, {
+    headers: apiHeaders(token),
+  });
+  if (compared.status === 404) {
+    refuse('the commit of before, or the commit of the run, is not a commit of this repository');
+  }
+  if (compared.status !== 200) {
+    throw new Failed(
+      `GitHub answered ${compared.status} to the comparison of the commit of before with the commit of the run`,
+    );
+  }
+  const status = (await compared.json())?.status;
+  if (status !== 'ahead' && status !== 'identical') {
+    refuse('the commit of before is not the commit of the run or a commit before it in its history');
+  }
+}
+
 async function fetchStep({ env, say, fetch, zipFile }) {
   const { repo, runId, work, filesDir, manifestFile } = settings(env);
   const mismatch = sessionRunMismatch({ event: env.RUN_EVENT, path: env.RUN_PATH, headRepo: env.RUN_HEAD_REPO }, repo);
@@ -511,21 +635,21 @@ async function fetchStep({ env, say, fetch, zipFile }) {
     );
     return false;
   }
-  const zip =
-    zipFile !== undefined
-      ? fs.readFileSync(zipFile)
-      : await downloadArtifact({
-          fetch,
-          api: (env.GITHUB_API_URL ?? 'https://api.github.com').replace(/\/$/, ''),
-          token: env.GITHUB_TOKEN ?? '',
-          repo,
-          runId,
-        });
+  const github = {
+    fetch,
+    api: (env.GITHUB_API_URL ?? 'https://api.github.com').replace(/\/$/, ''),
+    token: env.GITHUB_TOKEN ?? '',
+    repo,
+  };
+  const zip = zipFile !== undefined ? fs.readFileSync(zipFile) : await downloadArtifact({ ...github, runId });
   if (zip === null) {
     say('notice', `Run ${runId} handed off no evidence.`);
     return false;
   }
   const { manifest, files } = validateBundle(zip);
+  if (manifest.before !== null) {
+    await assertBeforeCommitInHistory(github, manifest);
+  }
   if (fs.existsSync(work) && fs.readdirSync(work).length > 0) {
     throw new Failed('WORK must be a new or empty directory');
   }
@@ -589,9 +713,10 @@ function publishStep({ env, say, gh = realGh, dryRun = false, pullFile, commitsF
     refuse('HEAD_BRANCH is missing');
   }
   const manifest = parseManifest(fs.readFileSync(manifestFile, 'utf8'));
+  const files = everyFile(manifest);
   const prefix = `evidence-${nonce()}`;
-  const onDisk = file => `${prefix}-${manifest.files.indexOf(file) + 1}${path.extname(file.name)}`;
-  for (const file of manifest.files) {
+  const onDisk = file => `${prefix}-${files.indexOf(file) + 1}${path.extname(file.name)}`;
+  for (const file of files) {
     const stat = fs.lstatSync(path.join(filesDir, file.name));
     if (!stat.isFile() || stat.size !== file.bytes) {
       refuse('a file is not the one the first step wrote');
@@ -680,7 +805,7 @@ function publishStep({ env, say, gh = realGh, dryRun = false, pullFile, commitsF
     }
     const held =
       edit.old !== null &&
-      !edit.old.includes('](./') &&
+      inTables(edit.old) &&
       edit.old.includes(`\`${manifest.run}\``) &&
       edit.old.includes(`(${sessionRunUrl(repo, runId)})`);
     const lacksTheNote = held && head !== manifest.commit && !edit.old.includes(NEWER_COMMITS);
@@ -697,7 +822,7 @@ function publishStep({ env, say, gh = realGh, dryRun = false, pullFile, commitsF
           ).body,
           files: [],
         }
-      : { body: edit.body, files: manifest.files };
+      : { body: edit.body, files };
     pull = readPull();
     const movedSince = pullRequestMismatch(pull, session);
     if (movedSince !== null) {
@@ -715,16 +840,8 @@ function publishStep({ env, say, gh = realGh, dryRun = false, pullFile, commitsF
 
   const bodyFile = path.join(work, 'body.md');
   fs.writeFileSync(bodyFile, next.body, { mode: 0o600 });
-  const args = [
-    'pr',
-    'edit',
-    String(manifest.pr),
-    '--repo',
-    repo,
-    '--body-file',
-    bodyFile,
-    ...next.files.flatMap(file => ['--attach', `./${onDisk(file)}`]),
-  ];
+  const editBody = ['pr', 'edit', String(manifest.pr), '--repo', repo, '--body-file', bodyFile];
+  const args = [...editBody, ...next.files.flatMap(file => ['--attach', `./${onDisk(file)}`])];
   if (dryRun) {
     say('plain', `would run, in ${filesDir}:\ngh ${args.map(quoted).join(' ')}`);
     return 'dry run';
@@ -740,9 +857,28 @@ function publishStep({ env, say, gh = realGh, dryRun = false, pullFile, commitsF
     );
     return 'noted';
   }
+  pull = readPull();
+  const listed = withEvidenceBlock(bodyOf(pull), manifest.platform, '');
+  const list = (listed.ok && listed.old) || '';
+  const uploaded = list.includes(`\`${manifest.run}\``) ? (list.match(UPLOADED) ?? []) : [];
+  if (pullRequestMismatch(pull, session) !== null || uploaded.length !== files.length) {
+    say(
+      'notice',
+      `Put verify run ${manifest.run} in the description of pull request #${manifest.pr} as a list of ${files.length} files. The pull request changed before they could be laid out. A rerun of this job uploads them again and lays them out.`,
+    );
+    return 'listed';
+  }
+  const laidOut = evidenceBlock(manifest, { repo, runId, actor, pullHead: pull.head.sha }, onDisk, uploaded);
+  fs.writeFileSync(bodyFile, withEvidenceBlock(bodyOf(pull), manifest.platform, laidOut).body, { mode: 0o600 });
+  const arranged = gh(editBody, { cwd: filesDir });
+  if (arranged.status !== 0) {
+    throw new Failed(
+      `gh pr edit failed to lay out the files in pull request #${manifest.pr}\n${printable(arranged.stderr)}`,
+    );
+  }
   say(
     'notice',
-    `Put verify run ${manifest.run} in the description of pull request #${manifest.pr}: ${manifest.files.length} files.`,
+    `Put verify run ${manifest.run} in the description of pull request #${manifest.pr}: ${files.length} files.`,
   );
   return 'published';
 }
diff --git a/scripts/verify-attach.test.mjs b/scripts/verify-attach.test.mjs
index 79b85c8d85a..237a1d8bb74 100644
--- a/scripts/verify-attach.test.mjs
+++ b/scripts/verify-attach.test.mjs
@@ -37,7 +37,7 @@ const JPG = Buffer.concat([Buffer.from([0xff, 0xd8, 0xff, 0xe0]), Buffer.from('t
 const MP4 = Buffer.concat([Buffer.from([0, 0, 0, 0x18]), Buffer.from('ftypmp42'), Buffer.alloc(4096, 'v')]);
 
 const manifestFor = (files, change = {}) => ({
-  v: 1,
+  v: 2,
   pr: 669,
   run: 'r20261008-052713-253e',
   platform: 'ios',
@@ -47,6 +47,7 @@ const manifestFor = (files, change = {}) => ({
   flaky: 0,
   total: 3,
   files: files.map(([name, data]) => ({ name, bytes: data.length, sha256: sha256(data) })),
+  before: null,
   ...change,
 });
 
@@ -136,6 +137,24 @@ const refusal = attempt => {
   return null;
 };
 
+const BEFORE_COMMIT = '5e126375065188df5bec4e4e75d61db03834f395';
+const WAS_MP4 = Buffer.concat([MP4, Buffer.from('before')]);
+const WAS_PNG = Buffer.concat([PNG, Buffer.from('before')]);
+const WAS_MEDIA = [
+  ['before-video.mp4', WAS_MP4],
+  ['before-profile.png', WAS_PNG],
+];
+const beforeFor = (files, change = {}) => ({
+  run: 'r20261008-051500-0a1b',
+  commit: BEFORE_COMMIT,
+  passed: 0,
+  flaky: 0,
+  total: 3,
+  files: files.map(([name, data]) => ({ name, bytes: data.length, sha256: sha256(data) })),
+  ...change,
+});
+const WITH_BEFORE = manifestFor(MEDIA, { before: beforeFor(WAS_MEDIA) });
+
 describe('the archive of a session', () => {
   it('accepts a manifest with the files it names, deflated or stored, and returns their bytes', () => {
     for (const method of [8, 0]) {
@@ -339,6 +358,38 @@ describe('the archive of a session', () => {
     );
   });
 
+  it('accepts the files of a before run beside the files of the run, and holds them to the same checks', () => {
+    const accepted = validateBundle(bundle(WITH_BEFORE, [...MEDIA, ...WAS_MEDIA]));
+    assert.deepEqual(accepted.manifest, WITH_BEFORE);
+    assert.deepEqual(
+      accepted.files,
+      [...MEDIA, ...WAS_MEDIA].map(([name, data]) => ({ name, data })),
+    );
+    assert.match(
+      refusal(() => validateBundle(bundle(WITH_BEFORE, MEDIA))),
+      /name different files/,
+    );
+    assert.match(
+      refusal(() => validateBundle(bundle(WITH_BEFORE, [...MEDIA, WAS_MEDIA[0], ['before-profile.png', PNG]]))),
+      /file 4 is not the size its manifest declares/,
+    );
+    const sameSize = Buffer.concat([PNG, Buffer.from('BEFORE')]);
+    assert.match(
+      refusal(() => validateBundle(bundle(WITH_BEFORE, [...MEDIA, WAS_MEDIA[0], ['before-profile.png', sameSize]]))),
+      /file 4 does not have the sha256 its manifest declares/,
+    );
+    const notAnImage = [
+      ['before-video.mp4', WAS_MP4],
+      ['before-profile.png', Buffer.from('<svg onload=alert(1)>')],
+    ];
+    assert.match(
+      refusal(() =>
+        validateBundle(bundle(manifestFor(MEDIA, { before: beforeFor(notAnImage) }), [...MEDIA, ...notAnImage])),
+      ),
+      /file 4 does not start with the bytes of its type/,
+    );
+  });
+
   it('refuses an archive with no manifest, with a file the manifest does not name, and without a file it does name', () => {
     assert.match(
       refusal(() => validateBundle(zip([{ name: 'video.mp4', data: MP4 }]))),
@@ -439,7 +490,6 @@ describe('the manifest', () => {
   const refused = [
     ['text that is not JSON', () => parseManifest('{')],
     ['a list', () => parseManifest('[]')],
-    ['another version', () => parse({ v: 2 })],
     ['a key the schema does not have', () => parse({ note: 'free text for the description' })],
     ['a missing key', () => parseManifest(JSON.stringify({ ...GOOD, device: undefined }))],
     ['a run id of another shape', () => parse({ run: 'r20261008-052713-253e`; rm -rf /' })],
@@ -502,6 +552,164 @@ describe('the manifest', () => {
       assert.throws(attempt, Refused);
     });
   }
+
+  it('refuses a manifest of another version before it reads anything else of it, and names both versions', () => {
+    const { before: _, ...versionOne } = { ...GOOD, v: 1 };
+    assert.equal(
+      refusal(() => parseManifest(JSON.stringify(versionOne))),
+      'the manifest is version 1, and this script publishes only version 2',
+    );
+    assert.equal(
+      refusal(() => parseManifest(JSON.stringify({ ...GOOD, v: 3, layout: 'a key of a later version' }))),
+      'the manifest is version 3, and this script publishes only version 2',
+    );
+    for (const v of ['2', 2.5, -1, 1000, null, '<img src=x>\n::error::pwned']) {
+      assert.equal(
+        refusal(() => parse({ v })),
+        'the manifest is of no version this script knows, and this script publishes only version 2',
+        JSON.stringify(v),
+      );
+    }
+    assert.equal(
+      refusal(() => parseManifest(JSON.stringify({ device: 'x' }))),
+      'the manifest is of no version this script knows, and this script publishes only version 2',
+    );
+  });
+
+  it('accepts a before run, which may have passed nothing, with one file of the same kind for each file of the run', () => {
+    assert.deepEqual(parseManifest(JSON.stringify(WITH_BEFORE)), WITH_BEFORE);
+  });
+
+  const before = change => parse({ before: { ...WITH_BEFORE.before, ...change } });
+  const [wasVideo, wasShot] = WITH_BEFORE.before.files;
+  const refusedBefore = [
+    [
+      'a manifest with no before key',
+      () => parseManifest(JSON.stringify({ ...GOOD, before: undefined })),
+      /the manifest must have exactly the keys/,
+    ],
+    ['a before that is text', () => parse({ before: 'r20261008-051500-0a1b' }), /before is not an object/],
+    [
+      'a before with a key the schema does not have',
+      () => before({ note: '<img src=x>' }),
+      /before must have exactly the keys run, commit, passed, flaky, total, files/,
+    ],
+    [
+      'a before run id with markdown in it',
+      () => before({ run: 'r20261008-051500-0a1b` [x](http://evil) `' }),
+      /the run of before is missing or malformed/,
+    ],
+    ['a before that is the run itself', () => before({ run: GOOD.run }), /before is the run itself/],
+    ['a short before commit', () => before({ commit: 'abc1234' }), /the commit of before is missing or malformed/],
+    [
+      'a negative before count',
+      () => before({ passed: -1 }),
+      /passed of before must be a whole number from 0 to 10000/,
+    ],
+    [
+      'a before count past the cap',
+      () => before({ total: LIMITS.tests + 1 }),
+      /total of before must be a whole number from 1 to 10000/,
+    ],
+    [
+      'more passing before tests than tests',
+      () => before({ passed: 3, flaky: 1 }),
+      /passed and flaky of before must count at most total/,
+    ],
+    ['a before with no files', () => before({ files: [] }), /the files of before must be a list of 1 to 50/],
+    [
+      'a before with fewer files than the run',
+      () => before({ files: [wasVideo] }),
+      /before must have one file for each file, of the same kind/,
+    ],
+    [
+      'a before screenshot where the run has a video',
+      () => before({ files: [wasShot, wasVideo] }),
+      /before must have one file for each file, of the same kind/,
+    ],
+    [
+      'a before file named as a file of the run is',
+      () => before({ files: [wasVideo, { ...wasShot, name: 'PROFILE.png' }] }),
+      /two files have the same name/,
+    ],
+    [
+      'a before file with a path in its name',
+      () => before({ files: [wasVideo, { ...wasShot, name: '../before-profile.png' }] }),
+      /the name of file 2 is missing or malformed/,
+    ],
+    [
+      'a before file of another type',
+      () => before({ files: [wasVideo, { ...wasShot, name: 'before-profile.svg' }] }),
+      /the name of file 2 is missing or malformed/,
+    ],
+    [
+      'a before image over its cap',
+      () => before({ files: [wasVideo, { ...wasShot, bytes: LIMITS.imageBytes + 1 }] }),
+      /the size of file 2 must be a whole number/,
+    ],
+    [
+      'a before file with a key the schema does not have',
+      () => before({ files: [wasVideo, { ...wasShot, path: '/etc/passwd' }] }),
+      /file 2 must have exactly the keys name, bytes, sha256/,
+    ],
+  ];
+  for (const [what, attempt, why] of refusedBefore) {
+    it(`refuses ${what}`, () => {
+      assert.throws(attempt, error => error instanceof Refused && why.test(error.message));
+    });
+  }
+
+  it('refuses a run id or a commit, of the run or of the before run, with any character of markup in any place', () => {
+    const MARKUP = ['|', '"', '<', '>', "'", '&', '`', '@', ':', ';', '$', '{', '}', '[', ']', '(', ')', '*', '_', '!'];
+    const OTHER = [' ', '\n', '\r', '\t', '\0', '\\', '/', '#', '.', 'é', 'G', 'R'];
+    const fields = [
+      ['run', GOOD.run, run => parse({ run })],
+      ['commit', GOOD.commit, commit => parse({ commit })],
+      ['the run of before', WITH_BEFORE.before.run, run => before({ run })],
+      ['the commit of before', WITH_BEFORE.before.commit, commit => before({ commit })],
+    ];
+    for (const [what, good, attempt] of fields) {
+      assert.equal(
+        refusal(() => attempt(good)),
+        null,
+        what,
+      );
+      for (const char of [...MARKUP, ...OTHER]) {
+        const hostile = [
+          ...Array.from(good, (_, at) => `${good.slice(0, at)}${char}${good.slice(at + 1)}`),
+          `${good}${char}`,
+          `${char}${good}`,
+          `${good}-->`,
+        ];
+        for (const value of hostile) {
+          assert.equal(
+            refusal(() => attempt(value)),
+            `${what} is missing or malformed`,
+            JSON.stringify(value),
+          );
+        }
+      }
+    }
+  });
+
+  it('counts the files of the before run toward the cap on files and the cap on bytes', () => {
+    const shots = (prefix, count, bytes = 1) =>
+      Array.from({ length: count }, (_, i) => ({ name: `${prefix}${i}.png`, bytes, sha256: sha256('x') }));
+    const paired = (count, bytes) =>
+      parse({
+        files: shots('s', count, bytes),
+        before: { ...WITH_BEFORE.before, files: shots('before-s', count, bytes) },
+      });
+    assert.equal(paired(LIMITS.files / 2).before.files.length, LIMITS.files / 2);
+    assert.throws(() => paired(LIMITS.files / 2 + 1), /at most 50 files in all/);
+    assert.throws(() => paired(8, LIMITS.imageBytes), /the files are over 157286400 bytes in all/);
+    const video = name => ({ name, bytes: LIMITS.videoBytes, sha256: sha256('x') });
+    assert.throws(
+      () =>
+        parse({ files: [video('video.mp4')], before: { ...WITH_BEFORE.before, files: [video('before-video.mp4')] } }),
+      /the files are over 157286400 bytes in all/,
+    );
+  });
 });
 
 describe('which runs and which pull request', () => {
@@ -557,26 +765,35 @@ describe('which runs and which pull request', () => {
 
 const SESSION = { repo: REPO, runId: '37731397352', actor: 'octocat', pullHead: COMMIT };
 const blockOf = (manifest, onDisk) => evidenceBlock(manifest, SESSION, onDisk);
-const LOCAL_BLOCK = [
-  '<!-- verify-evidence:ios -->',
-  '',
+const localBlock = line =>
+  [
+    '<!-- verify-evidence:ios -->',
+    '',
+    line,
+    '',
+    '| `profile` |',
+    '| :---: |',
+    '| <img src="https://github.com/user-attachments/assets/1" width="280" alt="profile"> |',
+    '',
+    '<!-- /verify-evidence:ios -->',
+  ].join('\n');
+const LOCAL_BLOCK = localBlock(
+  '**Verified on an iOS simulator.** Run `r20261007-010101-aaaa` on `iPhone 17 Pro` at `0f50b597b1c2`, 3 of 3 passed.',
+);
+const OLDER_BLOCK = localBlock(
   'verify run `r20261007-010101-aaaa` on `iPhone 17 Pro` at `0f50b597b1c2`, 3 of 3 passed.',
-  '',
-  '![video.mp4](https://github.com/user-attachments/assets/1)',
-  '',
-  '<!-- /verify-evidence:ios -->',
-].join('\n');
+);
 
 describe('the evidence block of a pull request description', () => {
   const block = blockOf(GOOD);
 
-  it('is one line that says the session reported the result, links its run and names who started it, then each file alone in its own paragraph, between the markers of its platform', () => {
+  it('is one line that leads with the result in bold, says in the same sentence that the session reported it, links its run and names who started it, then each file alone in its own paragraph, between the markers of its platform', () => {
     assert.equal(
       block,
       [
         '<!-- verify-evidence:ios -->',
         '',
-        'verify run `r20261008-052713-253e`, as reported by [the session](https://github.com/clerk/clerk-ios/actions/runs/37731397352) that `octocat` started: 3 of 3 passed on `iPhone Air on xcode-27` at `0f50b597b1c2`.',
+        '**Verified on an iOS simulator**, as reported by [the session](https://github.com/clerk/clerk-ios/actions/runs/37731397352) that `octocat` started. Run `r20261008-052713-253e` on `iPhone Air on xcode-27` at `0f50b597b1c2`, 3 of 3 passed.',
         '',
         '![video.mp4](./video.mp4)',
         '',
@@ -587,13 +804,30 @@ describe('the evidence block of a pull request description', () => {
     );
     assert.match(
       blockOf(manifestFor(MEDIA, { passed: 1, flaky: 1, total: 2 })),
-      / started: 1 of 2 passed, 1 flaky \(passed only on a retry\), on `iPhone Air on xcode-27` at `0f50b597b1c2`\.$/m,
+      / started\. Run `r20261008-052713-253e` on `iPhone Air on xcode-27` at `0f50b597b1c2`, 1 of 2 passed, 1 flaky \(passed only on a retry\)\.$/m,
+    );
+    assert.match(
+      blockOf(manifestFor(MEDIA, { platform: 'android' })),
+      /^\*\*Verified on an Android emulator\*\*, as reported by /m,
+    );
+  });
+
+  it('says that the before run is what the session reports, links its commit so a reader can open it, and says how that run went, ahead of the note about newer commits', () => {
+    const line = block => block.split('\n')[2];
+    assert.equal(
+      line(blockOf(WITH_BEFORE)),
+      '**Verified on an iOS simulator**, as reported by [the session](https://github.com/clerk/clerk-ios/actions/runs/37731397352) that `octocat` started. Run `r20261008-052713-253e` on `iPhone Air on xcode-27` at `0f50b597b1c2`, 3 of 3 passed. The session reports the before as run `r20261008-051500-0a1b` at [`5e1263750651`](https://github.com/clerk/clerk-ios/commit/5e126375065188df5bec4e4e75d61db03834f395), 0 of 3 passed.',
+    );
+    assert.ok(
+      line(evidenceBlock(WITH_BEFORE, { ...SESSION, repo: 'clerk/clerk-android', pullHead: 'b'.repeat(40) })).endsWith(
+        ' The session reports the before as run `r20261008-051500-0a1b` at [`5e1263750651`](https://github.com/clerk/clerk-android/commit/5e126375065188df5bec4e4e75d61db03834f395), 0 of 3 passed. The pull request has newer commits.',
+      ),
     );
   });
 
   it('says that the pull request has newer commits when its head is not the commit of the run', () => {
     const moved = evidenceBlock(GOOD, { ...SESSION, pullHead: 'b'.repeat(40) });
-    assert.match(moved, / at `0f50b597b1c2`\. The pull request has newer commits\.$/m);
+    assert.match(moved, / at `0f50b597b1c2`, 3 of 3 passed\. The pull request has newer commits\.$/m);
     assert.equal(block.includes('newer commits'), false);
   });
 
@@ -606,14 +840,15 @@ describe('the evidence block of a pull request description', () => {
     });
     assert.ok(
       elsewhere.includes(
-        '](https://github.com/clerk/clerk-android/actions/runs/41) that `someone-else` started: 3 of 3 passed',
+        '](https://github.com/clerk/clerk-android/actions/runs/41) that `someone-else` started. Run `r20261008-052713-253e`',
       ),
     );
     assert.equal(/actions\/runs|octocat|someone-else/.test(JSON.stringify(GOOD)), false);
   });
 
-  it('replaces the block that attach writes from a machine whose gh can attach', () => {
+  it('replaces the block that attach writes from a machine whose gh can attach, in the layout of this version or of the one before it', () => {
     assert.equal(withEvidenceBlock(`intro\n\n${LOCAL_BLOCK}\n`, 'ios', block).body, `intro\n\n${block}\n`);
+    assert.equal(withEvidenceBlock(`intro\n\n${OLDER_BLOCK}\n`, 'ios', block).body, `intro\n\n${block}\n`);
   });
 
   it('goes after a description that has no block, and leaves that description as it was', () => {
@@ -783,6 +1018,7 @@ const ENV = {
   HEAD_SHA: COMMIT,
   RUN_ACTOR: 'octocat',
 };
+const beforeIsInTheHistory = () => Promise.resolve(Response.json({ status: 'ahead' }));
 
 describe('the step that fetches the evidence', () => {
   const artifact = (id, change = {}) => ({
@@ -860,11 +1096,61 @@ describe('the step that fetches the evidence', () => {
     assert.deepEqual(fs.readdirSync(work).sort(), ['files', 'manifest.json']);
     assert.deepEqual(fs.readdirSync(path.join(work, 'files')).sort(), ['profile.png', 'video.mp4']);
     assert.deepEqual(fs.readFileSync(path.join(work, 'files', 'video.mp4')), MP4);
+    const withBefore = workDir();
+    fs.writeFileSync(zipFile, bundle(WITH_BEFORE, [...MEDIA, ...WAS_MEDIA]));
+    await fetchStep({ env: { ...ENV, WORK: withBefore }, say: () => undefined, fetch: beforeIsInTheHistory, zipFile });
+    assert.deepEqual(fs.readdirSync(path.join(withBefore, 'files')).sort(), [
+      'before-profile.png',
+      'before-video.mp4',
+      'profile.png',
+      'video.mp4',
+    ]);
+    assert.deepEqual(fs.readFileSync(path.join(withBefore, 'files', 'before-profile.png')), WAS_PNG);
     assert.deepEqual(said, [
       'notice: Run 37731397352 handed off the evidence of verify run r20261008-052713-253e for pull request #669: 2 files.',
     ]);
   });
 
+  it('takes a before run only when GitHub says its commit is the commit of the run or one before it in its history', async () => {
+    const zipFile = path.join(path.dirname(workDir()), 'evidence.zip');
+    const attempt = async (answer, media = [...MEDIA, ...WAS_MEDIA], manifest = WITH_BEFORE) => {
+      fs.writeFileSync(zipFile, bundle(manifest, media));
+      const work = workDir();
+      const asked = [];
+      const fetch = (url, init) => {
+        asked.push(`${init.headers.Authorization} ${url}`);
+        return Promise.resolve(answer());
+      };
+      const env = { ...ENV, WORK: work, GITHUB_TOKEN: 'actions-token', GITHUB_API_URL: 'https://api.github.test/' };
+      const outcome = await fetchStep({ env, say: () => undefined, fetch, zipFile }).then(
+        found => `found ${found}`,
+        error => `${error instanceof Refused ? 'refused' : 'failed'}: ${error.message}`,
+      );
+      return { outcome, asked, wrote: fs.existsSync(work) };
+    };
+    const compared = status => () => Response.json({ status });
+    const comparison =
+      'Bearer actions-token https://api.github.test/repos/clerk/clerk-ios/compare/5e126375065188df5bec4e4e75d61db03834f395...0f50b597b1c2d3e4f5a60718293a4b5c6d7e8f90?per_page=1';
+
+    assert.deepEqual(await attempt(compared('ahead')), { outcome: 'found true', asked: [comparison], wrote: true });
+    assert.deepEqual(await attempt(compared('identical')), { outcome: 'found true', asked: [comparison], wrote: true });
+    const outside = 'refused: the commit of before is not the commit of the run or a commit before it in its history';
+    for (const answer of [compared('behind'), compared('diverged'), compared(undefined), () => Response.json(null)]) {
+      assert.deepEqual(await attempt(answer), { outcome: outside, asked: [comparison], wrote: false });
+    }
+    assert.deepEqual(await attempt(() => Response.json({ message: 'Not Found' }, { status: 404 })), {
+      outcome: 'refused: the commit of before, or the commit of the run, is not a commit of this repository',
+      asked: [comparison],
+      wrote: false,
+    });
+    assert.deepEqual(await attempt(() => Response.json({ status: 'ahead' }, { status: 502 })), {
+      outcome: 'failed: GitHub answered 502 to the comparison of the commit of before with the commit of the run',
+      asked: [comparison],
+      wrote: false,
+    });
+    assert.deepEqual(await attempt(compared('behind'), MEDIA, GOOD), { outcome: 'found true', asked: [], wrote: true });
+  });
+
   it('writes only into a directory that is new or empty', async () => {
     const work = workDir();
     fs.mkdirSync(work);
@@ -920,12 +1206,22 @@ describe('the step that edits the description', () => {
     const work = workDir();
     const zipFile = path.join(path.dirname(work), 'evidence.zip');
     fs.writeFileSync(zipFile, bundle(manifest, media));
-    await fetchStep({ env: { ...ENV, WORK: work }, say: () => undefined, zipFile });
+    await fetchStep({ env: { ...ENV, WORK: work }, say: () => undefined, fetch: beforeIsInTheHistory, zipFile });
     return { ...ENV, WORK: work };
   }
 
+  const asset = n =>
+    `https://github.com/user-attachments/assets/00000000-0000-4000-8000-${String(n).padStart(12, '0')}`;
+
   function fakeGh(pull = PULL, onRead = () => undefined, commits = COMMITS) {
-    const state = { pull: structuredClone(pull), reads: 0, calls: [], writtenBody: null };
+    const state = {
+      pull: structuredClone(pull),
+      reads: 0,
+      calls: [],
+      writtenBody: null,
+      laidOutBody: null,
+      uploads: 0,
+    };
     const gh = (args, options) => {
       state.calls.push({ args, cwd: options.cwd });
       const page = /\/commits\?per_page=100&page=(\d+)$/.exec(args[1] ?? '');
@@ -940,7 +1236,12 @@ describe('the step that edits the description', () => {
         fs.writeFileSync(options.stdoutFile, JSON.stringify(state.pull));
         return { status: 0, stderr: '' };
       }
-      state.writtenBody = fs.readFileSync(args[args.indexOf('--body-file') + 1], 'utf8');
+      const body = fs.readFileSync(args[args.indexOf('--body-file') + 1], 'utf8');
+      state[state.writtenBody === null ? 'writtenBody' : 'laidOutBody'] = body;
+      state.pull.body = body.replace(/!\[([^\]]*)\]\(\.\/([^)]+)\)/g, (_, alt, file) => {
+        state.uploads += 1;
+        return file.endsWith('.mp4') ? asset(state.uploads) : `![${alt}](${asset(state.uploads)})`;
+      });
       return { status: 0, stderr: '' };
     };
     return { gh, state };
@@ -960,6 +1261,22 @@ describe('the step that edits the description', () => {
   const onDisk = manifest => file => `evidence-n0nce-${manifest.files.indexOf(file) + 1}${path.extname(file.name)}`;
   const PLACED = blockOf(GOOD, onDisk(GOOD));
   const COMMITS = [{ sha: 'a'.repeat(40) }, { sha: COMMIT }];
+  const SAID =
+    '**Verified on an iOS simulator**, as reported by [the session](https://github.com/clerk/clerk-ios/actions/runs/37731397352) that `octocat` started. Run `r20261008-052713-253e` on `iPhone Air on xcode-27` at `0f50b597b1c2`, 3 of 3 passed.';
+  const WAS =
+    ' The session reports the before as run `r20261008-051500-0a1b` at [`5e1263750651`](https://github.com/clerk/clerk-ios/commit/5e126375065188df5bec4e4e75d61db03834f395), 0 of 3 passed.';
+  const laidOut = (...lines) =>
+    ['<!-- verify-evidence:ios -->', '', ...lines, '', '<!-- /verify-evidence:ios -->'].join('\n');
+  const AFTER_ONLY = [
+    '',
+    '| `profile` |',
+    '| :---: |',
+    `| <img src="${asset(2)}" width="280" alt="profile"> |`,
+    '',
+    '| `video` |',
+    '| :---: |',
+    `| ${asset(1)} |`,
+  ];
 
   it('adds the block after the description and attaches the files from their own directory, under names the description could not have guessed', async () => {
     const env = await fetched();
@@ -973,6 +1290,8 @@ describe('the step that edits the description', () => {
         'api repos/clerk/clerk-ios/pulls/669/commits?per_page=100&page=1',
         'api repos/clerk/clerk-ios/pulls/669',
         'pr edit',
+        'api repos/clerk/clerk-ios/pulls/669',
+        'pr edit',
       ],
     );
     const edit = fake.state.calls[3];
@@ -995,6 +1314,9 @@ describe('the step that edits the description', () => {
     assert.ok(
       PLACED.includes('![video.mp4](./evidence-n0nce-1.mp4)') && PLACED.includes('![profile](./evidence-n0nce-2.png)'),
     );
+    assert.deepEqual(fake.state.calls[5].args, edit.args.slice(0, 7));
+    assert.equal(fake.state.calls[5].cwd, edit.cwd);
+    assert.equal(fake.state.laidOutBody, `${PULL.body}\r\n${laidOut(SAID, ...AFTER_ONLY).replaceAll('\n', '\r\n')}`);
     assert.deepEqual(said, [
       'notice: Put verify run r20261008-052713-253e in the description of pull request #669: 2 files.',
     ]);
@@ -1006,6 +1328,10 @@ describe('the step that edits the description', () => {
     const fake = fakeGh({ ...PULL, body: `intro\r\n\r\n${earlier}\r\n\r\noutro` });
     assert.equal(publish(env, fake).outcome, 'published');
     assert.equal(fake.state.writtenBody, `intro\r\n\r\n${PLACED.replaceAll('\n', '\r\n')}\r\n\r\noutro`);
+    assert.equal(
+      fake.state.laidOutBody,
+      `intro\r\n\r\n${laidOut(SAID, ...AFTER_ONLY).replaceAll('\n', '\r\n')}\r\n\r\noutro`,
+    );
   });
 
   it('names no file the way a description can name one, so gh rewrites no reference outside the block', async () => {
@@ -1058,10 +1384,271 @@ describe('the step that edits the description', () => {
     );
   });
 
+  const SHOT = [['profile.png', PNG]];
+  const WAS_SHOT = [['before-profile.png', WAS_PNG]];
+  const CLIP = [['video.mp4', MP4]];
+  const WAS_CLIP = [['before-video.mp4', WAS_MP4]];
+  const published = async (media, wasMedia) => {
+    const manifest = manifestFor(media, wasMedia === undefined ? {} : { before: beforeFor(wasMedia) });
+    const fake = fakeGh({ ...PULL, body: '' });
+    const { outcome } = publish(await fetched(manifest, [...media, ...(wasMedia ?? [])]), fake);
+    assert.equal(outcome, 'published');
+    return fake.state.pull.body;
+  };
+
+  it('lays out a still change to something that exists as before and after screenshots, side by side at a fixed width', async () => {
+    assert.equal(
+      await published(SHOT, WAS_SHOT),
+      laidOut(
+        `${SAID}${WAS}`,
+        '',
+        '| Before | After |',
+        '| :---: | :---: |',
+        `| <img src="${asset(2)}" width="280" alt="Before: profile"> | <img src="${asset(1)}" width="280" alt="After: profile"> |`,
+      ),
+    );
+  });
+
+  it('lays out a still change that is new as its screenshots alone, two across under their names', async () => {
+    assert.equal(
+      await published([
+        ['start.png', PNG],
+        ['profile.jpg', JPG],
+        ['security.png', PNG],
+      ]),
+      laidOut(
+        SAID,
+        '',
+        '| `start` | `profile` |',
+        '| :---: | :---: |',
+        `| <img src="${asset(1)}" width="280" alt="start"> | <img src="${asset(2)}" width="280" alt="profile"> |`,
+        '',
+        '| `security` |',
+        '| :---: |',
+        `| <img src="${asset(3)}" width="280" alt="security"> |`,
+      ),
+    );
+  });
+
+  it('lays out a change to a flow that exists as the before and after videos, side by side', async () => {
+    assert.equal(
+      await published(CLIP, WAS_CLIP),
+      laidOut(`${SAID}${WAS}`, '', '| Before | After |', '| :---: | :---: |', `| ${asset(2)} | ${asset(1)} |`),
+    );
+  });
+
+  it('lays out a flow that is new as its video alone, in a table that keeps it from the full width', async () => {
+    assert.equal(await published(CLIP), laidOut(SAID, '', '| `video` |', '| :---: |', `| ${asset(1)} |`));
+  });
+
+  it('lays out both kinds when the hand-off holds both: the screenshots first, then the video, each as it is alone', async () => {
+    assert.equal(
+      await published([...CLIP, ...SHOT], [...WAS_CLIP, ...WAS_SHOT]),
+      laidOut(
+        `${SAID}${WAS}`,
+        '',
+        '| Before | After |',
+        '| :---: | :---: |',
+        `| <img src="${asset(4)}" width="280" alt="Before: profile"> | <img src="${asset(2)}" width="280" alt="After: profile"> |`,
+        '',
+        '| Before | After |',
+        '| :---: | :---: |',
+        `| ${asset(3)} | ${asset(1)} |`,
+      ),
+    );
+    assert.equal(await published([...CLIP, ...SHOT]), laidOut(SAID, ...AFTER_ONLY));
+  });
+
+  const ASCII = Array.from({ length: 128 }, (_, code) => String.fromCharCode(code));
+  const ADDRESS = 'https://github\\.com/user-attachments/assets/[0-9a-f-]{36}';
+  const LABEL = '[A-Za-z0-9._-]+';
+  const COUNTS = '\\d+ of \\d+ passed(, \\d+ flaky \\(passed only on a retry\\))?';
+  const CELL = `(${ADDRESS}|<img src="${ADDRESS}" width="280" alt="((Before|After): )?${LABEL}">)`;
+  const TEMPLATE = [
+    /^$/,
+    /^<!-- \/?verify-evidence:ios -->$/,
+    new RegExp(
+      `^\\*\\*Verified on an iOS simulator\\*\\*, as reported by \\[the session\\]\\(https://github\\.com/clerk/clerk-ios/actions/runs/\\d+\\) that \`[A-Za-z0-9_-]+\` started\\. Run \`r[0-9a-f-]+\` on \`[A-Za-z0-9 ._()-]+\` at \`[0-9a-f]{12}\`, ${COUNTS}\\.( The session reports the before as run \`r[0-9a-f-]+\` at \\[\`[0-9a-f]{12}\`\\]\\(https://github\\.com/clerk/clerk-ios/commit/[0-9a-f]{40}\\), ${COUNTS}\\.)?$`,
+    ),
+    new RegExp(`^\\| (Before \\| After|\`${LABEL}\`( \\| \`${LABEL}\`)?) \\|$`),
+    /^\| :---: (\| :---: )?\|$/,
+    new RegExp(`^\\| ${CELL}( \\| ${CELL})? \\|$`),
+  ];
+  const outsideTheTemplate = body => body.split('\n').filter(line => !TEMPLATE.some(pattern => pattern.test(line)));
+  const publishedWith = async (manifest, media) => {
+    let env;
+    try {
+      env = await fetched(manifest, media);
+    } catch (error) {
+      if (error instanceof Refused) {
+        return null;
+      }
+      throw error;
+    }
+    const fake = fakeGh({ ...PULL, body: '' });
+    assert.equal(publish(env, fake).outcome, 'published');
+    return fake.state.pull.body;
+  };
+
+  it('writes nothing but its template around a file name, and takes in a name only letters, digits, a dot, an underscore and a dash', async () => {
+    const taken = [];
+    for (const char of ASCII) {
+      const media = [
+        [`a${char}b.png`, PNG],
+        [`c${char}d.mp4`, MP4],
+      ];
+      const wasMedia = media.map(([name, data]) => [`before-${name}`, data]);
+      const alone = await publishedWith(manifestFor(media), media);
+      const paired = await publishedWith(manifestFor(media, { before: beforeFor(wasMedia) }), [...media, ...wasMedia]);
+      assert.equal(alone === null, paired === null, JSON.stringify(char));
+      if (alone !== null) {
+        taken.push(char);
+        assert.deepEqual(outsideTheTemplate(alone), [], JSON.stringify(char));
+        assert.deepEqual(outsideTheTemplate(paired), [], JSON.stringify(char));
+        assert.ok(
+          alone.includes(`| \`a${char}b\` |`) && paired.includes(`alt="Before: a${char}b">`),
+          JSON.stringify(char),
+        );
+      }
+    }
+    assert.equal(taken.join(''), '-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz');
+  });
+
+  it('writes nothing but its template around a device, and takes in a device only letters, digits, a space, a dot, an underscore, parentheses and a dash', async () => {
+    const taken = [];
+    for (const char of ASCII) {
+      const body = await publishedWith(manifestFor(MEDIA, { device: `a${char}b` }), MEDIA);
+      if (body !== null) {
+        taken.push(char);
+        assert.deepEqual(outsideTheTemplate(body), [], JSON.stringify(char));
+        assert.ok(body.includes(` on \`a${char}b\` at `), JSON.stringify(char));
+      }
+    }
+    assert.equal(taken.join(''), ' ()-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz');
+  });
+
+  it('counts as outside its template a line that markup in a name or a device would make', () => {
+    const made = [
+      '| `a|b` |',
+      '| a |',
+      '| www.evil.example |',
+      '| <img src="https://github.com/user-attachments/assets/00000000-0000-4000-8000-000000000001" width="280" alt="a" onerror="alert(1)"> |',
+      '| <img src="https://evil.example/user-attachments/assets/00000000-0000-4000-8000-000000000001" width="280" alt="a"> |',
+      SAID.replace('`iPhone Air on xcode-27`', '`iPhone` [approved](https://evil.example) `Air`'),
+      '<!-- /verify-evidence:ios --> text after the marker',
+    ];
+    assert.deepEqual(outsideTheTemplate(made.join('\n')), made);
+    assert.deepEqual(outsideTheTemplate(laidOut(`${SAID}${WAS}`, ...AFTER_ONLY)), []);
+  });
+
+  it('attaches the files of the before run after the files of the run, under the same unguessable names, though the commit of the before run is no commit of the pull request', async () => {
+    const env = await fetched(WITH_BEFORE, [...MEDIA, ...WAS_MEDIA]);
+    const fake = fakeGh();
+    const { said } = publish(env, fake);
+    const names = ['evidence-n0nce-1.mp4', 'evidence-n0nce-2.png', 'evidence-n0nce-3.mp4', 'evidence-n0nce-4.png'];
+    assert.deepEqual(
+      fake.state.calls[3].args.filter((_, i, args) => args[i - 1] === '--attach'),
+      names.map(name => `./${name}`),
+    );
+    assert.deepEqual(fs.readdirSync(path.join(env.WORK, 'files')).sort(), names);
+    assert.deepEqual(fs.readFileSync(path.join(env.WORK, 'files', names[3])), WAS_PNG);
+    assert.ok(
+      fake.state.writtenBody.endsWith('![before-profile](./evidence-n0nce-4.png)\r\n\r\n<!-- /verify-evidence:ios -->'),
+    );
+    assert.deepEqual(said, [
+      'notice: Put verify run r20261008-052713-253e in the description of pull request #669: 4 files.',
+    ]);
+  });
+
+  const changedBeforeTheLayout = [
+    ['the block is gone from the description', state => void (state.pull.body = 'Rewritten by a reviewer.\n')],
+    [
+      'the block names another run',
+      state => void (state.pull.body = state.pull.body.replace(GOOD.run, 'r20261009-020202-bbbb')),
+    ],
+    [
+      'the block shows one address fewer',
+      state => void (state.pull.body = state.pull.body.replace(asset(1), 'removed')),
+    ],
+    [
+      'the block shows an address that is not an upload',
+      state =>
+        void (state.pull.body = state.pull.body.replace(asset(2), 'https://example.com/x.png" onerror="alert(1)')),
+    ],
+    ...[
+      ['on another host', asset(2).replace('github.com', 'evil.example')],
+      ['on a host that only starts like GitHub', asset(2).replace('github.com', 'github.com.evil.example')],
+      ['under another path of GitHub', asset(2).replace('user-attachments/assets', 'evil/user-attachments/assets')],
+      ['with an id one character short', asset(2).slice(0, -1)],
+      ['with a capital in its id', asset(2).replace('4000', 'A000')],
+    ].map(([how, address]) => [
+      `the block shows an upload address ${how}`,
+      state => void (state.pull.body = state.pull.body.replace(asset(2), address)),
+    ]),
+    ['the markers are broken', state => void (state.pull.body += '\n<!-- verify-evidence:ios -->\n')],
+    ['the pull request is closed', state => void (state.pull.state = 'closed')],
+  ];
+  for (const [what, change] of changedBeforeTheLayout) {
+    it(`leaves the files as a list, writes nothing more and says so, when ${what} after the upload`, async () => {
+      const fake = fakeGh(PULL, state => void (state.reads === 3 && change(state)));
+      const { outcome, said } = publish(await fetched(), fake);
+      assert.equal(outcome, 'listed');
+      assert.equal(fake.state.laidOutBody, null);
+      assert.equal(fake.state.calls.filter(call => call.args[0] === 'pr').length, 1);
+      assert.deepEqual(said, [
+        'notice: Put verify run r20261008-052713-253e in the description of pull request #669 as a list of 2 files. The pull request changed before they could be laid out. A rerun of this job uploads them again and lays them out.',
+      ]);
+    });
+  }
+
+  it('writes an upload address as its 36 characters of id and nothing that follows them', async () => {
+    for (const tail of ['f', '-0', '" onerror="alert(1)', '?download=1', '/../../evil', '#x']) {
+      const fake = fakeGh(
+        PULL,
+        state =>
+          void (state.reads === 3 && (state.pull.body = state.pull.body.replace(asset(2), `${asset(2)}${tail}`))),
+      );
+      assert.equal(publish(await fetched(), fake).outcome, 'published', tail);
+      assert.equal(
+        fake.state.laidOutBody,
+        `${PULL.body}\r\n${laidOut(SAID, ...AFTER_ONLY).replaceAll('\n', '\r\n')}`,
+        tail,
+      );
+    }
+  });
+
+  it('keeps an edit that someone saves outside the block between the upload and the layout', async () => {
+    const fake = fakeGh(
+      PULL,
+      state =>
+        void (
+          state.reads === 3 && (state.pull.body = `Reviewed.\r\n\r\n${state.pull.body}\r\nA note under the block.`)
+        ),
+    );
+    assert.equal(publish(await fetched(), fake).outcome, 'published');
+    assert.equal(
+      fake.state.laidOutBody,
+      `Reviewed.\r\n\r\n${PULL.body}\r\n${laidOut(SAID, ...AFTER_ONLY).replaceAll('\n', '\r\n')}\r\nA note under the block.`,
+    );
+  });
+
+  it('fails with what gh said when the write that lays the files out fails', async () => {
+    const env = await fetched();
+    const fake = fakeGh();
+    const failing = {
+      gh: (args, options) =>
+        args[0] === 'pr' && !args.includes('--attach') ? { status: 1, stderr: 'HTTP 502\n' } : fake.gh(args, options),
+    };
+    assert.throws(
+      () => publish(env, failing),
+      error => error.message === 'gh pr edit failed to lay out the files in pull request #669\ngh: HTTP 502',
+    );
+  });
+
   it('names the person the workflow says started the session, and publishes nothing under a name that is not a login', async () => {
     const fake = fakeGh();
     publish({ ...(await fetched()), RUN_ACTOR: 'hubot-9[bot]' }, fake);
-    assert.match(fake.state.writtenBody, /\/actions\/runs\/37731397352\) that `hubot-9\[bot\]` started: 3 of 3 passed/);
+    assert.match(fake.state.writtenBody, /\/actions\/runs\/37731397352\) that `hubot-9\[bot\]` started\. Run `/);
     for (const name of [undefined, '', 'mallory` [approved](https://example.com) `', 'a\nb', 'a b']) {
       const refusing = fakeGh();
       const env = { ...(await fetched()), RUN_ACTOR: name };
@@ -1086,7 +1673,14 @@ describe('the step that edits the description', () => {
     const fake = fakeGh({ ...PULL, head: { ...PULL.head, sha: NEWER } }, undefined, [{ sha: COMMIT }, { sha: NEWER }]);
     const { outcome } = publish(await fetched(), fake);
     assert.equal(outcome, 'published');
-    assert.match(fake.state.writtenBody, / at `0f50b597b1c2`\. The pull request has newer commits\.\r\n/);
+    assert.match(
+      fake.state.writtenBody,
+      / at `0f50b597b1c2`, 3 of 3 passed\. The pull request has newer commits\.\r\n/,
+    );
+    assert.match(
+      fake.state.laidOutBody,
+      /, 3 of 3 passed\. The pull request has newer commits\.\r\n\r\n\| `profile` \|/,
+    );
   });
 
   it('says that the pull request has newer commits when its head moves while the evidence is being placed', async () => {
@@ -1099,7 +1693,7 @@ describe('the step that edits the description', () => {
     assert.equal(publish(await fetched(), fake).outcome, 'published');
     assert.match(
       fake.state.writtenBody,
-      /^Edited\.\n\n<!-- verify-evidence:ios -->\n\nverify run .* newer commits\.\n/,
+      /^Edited\.\n\n<!-- verify-evidence:ios -->\n\n\*\*Verified on .* newer commits\.\n/,
     );
   });
 
@@ -1110,16 +1704,22 @@ describe('the step that edits the description', () => {
       { sha: NEWER },
     ]);
     assert.equal(publish(await fetched(), fake).outcome, 'published');
-    assert.equal(fake.state.reads, 3);
-    assert.match(fake.state.writtenBody, / at `0f50b597b1c2`\. The pull request has newer commits\.\r\n/);
+    assert.equal(fake.state.reads, 4);
+    assert.match(
+      fake.state.writtenBody,
+      / at `0f50b597b1c2`, 3 of 3 passed\. The pull request has newer commits\.\r\n/,
+    );
+    assert.match(
+      fake.state.laidOutBody,
+      /, 3 of 3 passed\. The pull request has newer commits\.\r\n\r\n\| `profile` \|/,
+    );
   });
 
   it('adds that the pull request has newer commits to a run it already published, and uploads nothing again', async () => {
     const NEWER = 'b'.repeat(40);
-    const uploaded = blockOf(GOOD).replaceAll('./', 'https://github.com/user-attachments/assets/');
     const moved = {
       ...PULL,
-      body: `intro\r\n\r\n${uploaded.replaceAll('\n', '\r\n')}\r\noutro`,
+      body: `intro\r\n\r\n${laidOut(SAID, ...AFTER_ONLY).replaceAll('\n', '\r\n')}\r\noutro`,
       head: { ...PULL.head, sha: NEWER },
     };
     const fake = fakeGh(moved, undefined, [{ sha: COMMIT }, { sha: NEWER }]);
@@ -1127,7 +1727,7 @@ describe('the step that edits the description', () => {
     assert.equal(outcome, 'noted');
     assert.equal(
       fake.state.writtenBody,
-      moved.body.replace('at `0f50b597b1c2`.', 'at `0f50b597b1c2`. The pull request has newer commits.'),
+      moved.body.replace('3 of 3 passed.', '3 of 3 passed. The pull request has newer commits.'),
     );
     assert.equal(fake.state.calls.at(-1).args.includes('--attach'), false);
     assert.deepEqual(said, [
@@ -1151,12 +1751,8 @@ describe('the step that edits the description', () => {
       assert.equal(outcome, 'published', head);
       assert.equal(fake.state.writtenBody.includes('/actions/runs/11111111111)'), false, head);
       assert.equal(fake.state.writtenBody.includes('mallory'), false, head);
-      assert.match(
-        fake.state.writtenBody,
-        /\/actions\/runs\/37731397352\) that `octocat` started: 3 of 3 passed/,
-        head,
-      );
-      assert.equal(fake.state.calls.at(-1).args.includes('--attach'), true, head);
+      assert.match(fake.state.writtenBody, /\/actions\/runs\/37731397352\) that `octocat` started\. Run `/, head);
+      assert.equal(fake.state.calls.at(-3).args.includes('--attach'), true, head);
     }
   });
 
@@ -1265,11 +1861,8 @@ describe('the step that edits the description', () => {
     assert.equal(fake.state.writtenBody, null);
   });
 
-  it('does not upload a run that the description already holds', async () => {
-    const fake = fakeGh({
-      ...PULL,
-      body: `intro\n\n${blockOf(GOOD).replaceAll('./', 'https://github.com/user-attachments/assets/')}\n`,
-    });
+  it('does not upload a run that the description already holds in its tables', async () => {
+    const fake = fakeGh({ ...PULL, body: `intro\n\n${laidOut(SAID, ...AFTER_ONLY)}\n` });
     const { outcome, said } = publish(await fetched(), fake);
     assert.equal(outcome, 'already there');
     assert.equal(fake.state.writtenBody, null);
@@ -1278,6 +1871,21 @@ describe('the step that edits the description', () => {
     ]);
   });
 
+  it('uploads a run again and lays it out when an earlier publish left its files as a list', async () => {
+    const leftAsAList = fakeGh(PULL, state => void (state.reads === 3 && (state.pull.state = 'closed')));
+    assert.equal(publish(await fetched(), leftAsAList).outcome, 'listed');
+    const list = leftAsAList.state.pull.body;
+    assert.ok(list.endsWith(`\r\n${asset(1)}\r\n\r\n![profile](${asset(2)})\r\n\r\n<!-- /verify-evidence:ios -->`));
+
+    const rerun = fakeGh({ ...PULL, body: list });
+    assert.equal(publish(await fetched(), rerun).outcome, 'published');
+    assert.deepEqual(
+      rerun.state.calls.filter(call => call.args[0] === 'pr').map(call => call.args.includes('--attach')),
+      [true, false],
+    );
+    assert.equal(rerun.state.pull.body, `${PULL.body}\r\n${laidOut(SAID, ...AFTER_ONLY).replaceAll('\n', '\r\n')}`);
+  });
+
   it('uploads a run again when an earlier upload left a file reference that was never rewritten', async () => {
     const halfUploaded = blockOf(GOOD).replace('./video.mp4', 'https://github.com/user-attachments/assets/1');
     const fake = fakeGh({ ...PULL, body: `intro\n\n${halfUploaded}\n` });
@@ -1288,8 +1896,9 @@ describe('the step that edits the description', () => {
   it('builds on the newer description when someone edits it between the read and the write', async () => {
     const fake = fakeGh(PULL, state => void (state.reads === 2 && (state.pull.body = 'Rewritten by a reviewer.\n')));
     assert.equal(publish(await fetched(), fake).outcome, 'published');
-    assert.equal(fake.state.reads, 3);
+    assert.equal(fake.state.reads, 4);
     assert.equal(fake.state.writtenBody, `Rewritten by a reviewer.\n\n${PLACED}`);
+    assert.equal(fake.state.laidOutBody, `Rewritten by a reviewer.\n\n${laidOut(SAID, ...AFTER_ONLY)}`);
   });
 
   it('writes nothing when the description changes twice, and says so', async () => {