v0.8.0.4 — take the test server's name back out of the tracked files

Both repositories allow anonymous clone — checked rather than assumed: info/refs
for git-upload-pack answers 200 for each, git-receive-pack answers 401. So
everything committed here is public, and tracked files are supposed to carry
placeholders rather than real hosts.

Ten mentions added while building v0.8.0 are now "the test server" or "the target
hardware", across CHANGELOG.md, the common-board plan's three deferral banners,
sim/pacing.ts, and two test files. Prose and comments only, no behaviour; the
quotes are untouched, because what was said about bot pacing is the part worth
keeping.

Left alone deliberately: nineteen older mentions in entries about v0.7.5, v0.7.6
and v0.7.8 and in TODO.md, since rewriting a changelog after the fact makes the
record less true; and scripts/deploy-web.ts, where the host is the functional
default for FB_URL rather than prose — turning that into a required variable
changes how deploying works and wants deciding on its own.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01X6cF1iYvJ1kNmzYBzu4QX6

CHANGELOG.md

@@ -19,9 +19,152 @@ page as `v0.1.0 · <sha> · <date>`, so what is deployed can always be identifie
 
 ---
 
+## 0.8.0.4 — 2026-09-09
+
+**Housekeeping: the test server's name is out of the ten places this session put it.**
+
+Both of this project's repositories allow anonymous clone — checked, not assumed: `info/refs` for
+`git-upload-pack` answers 200 for `station-master` and for `station-master-startos` alike, while
+`git-receive-pack` answers 401. So everything committed here is public, and the standing rule is that
+tracked files carry placeholders rather than real hosts.
+
+Ten mentions added while building v0.8.0 are now "the test server" or "the target hardware":
+`CHANGELOG.md`, `docs/plans/jitsi-common-board.md` (three identical deferral banners), `sim/pacing.ts`,
+`test/pacing.test.ts` and `test/step-queue.test.ts`. Prose and comments only — no behaviour, and the
+quotes they carry are unchanged, because what a player said about bot pacing is the part worth
+keeping.
+
+**What is deliberately left, and why it is not an oversight:**
+
+- **Nineteen older mentions**, in entries about v0.7.5, v0.7.6 and v0.7.8 and in `TODO.md`. Rewriting
+  a changelog after the fact makes the record less true, and these describe verification that
+  genuinely happened on that machine.
+- **`scripts/deploy-web.ts` is FUNCTIONAL, not prose.** It carries the host as the default for
+  `FB_URL`, so a placeholder there would break the deploy for the person the default exists to serve.
+  Same for the public address it publishes to. If those should move to required environment variables
+  with no default, that is a change to how deploying works and wants deciding on its own rather than
+  being smuggled in beside a comment sweep.
+
+---
+
+## 0.8.0.3 — 2026-09-09
+
+Three things from playing v0.8.0.2, all of them about the row rather than the mechanism.
+
+### Skip was at the wrong end of the row
+
+Jesse: *"the skip button should be on the far left, in front of where it says [the count], so it's
+always close to where people are looking."* It was on the far right, and a player's eye is on the
+countdown. Moved.
+
+### The caption said what, but never who
+
+*"I saw 2 behind, 1 behind, and then it was caught up, but it didn't tell me what the actual action
+was, like who I was waiting on or what they were doing. I knew I was behind, but I wasn't sure what I
+was supposed to be looking for."*
+
+The caption was there. It was the wrong half of the sentence. **Measured over 40 turns of a real
+3-seat game, half the waiting is automatic phases** — 21.0s of phases against 21.7s of other players —
+and a phase narrates as "Mainline", which is accurate and no answer at all to "who am I waiting on".
+A phase now introduces itself: **"The Division: ▸ Mainline phase"**. A player's move already carries
+its name from `record()`, so it is left alone rather than stuttering it twice.
+
+**And the row was hiding a step early.** It was shown only while `behind > 0` — which goes false the
+moment the LAST step of a burst goes up, so the one step a player was most likely to be reading about
+lost its caption. It now stays up while the queue is still showing something, and reads "catching up"
+once nothing is queued behind.
+
+### The speed control was stretching the clock, not just the other players
+
+*"After my turn, when I actually execute my turn, I'm still subject to that same delay before it
+moves on. That makes no sense. Since I've just done my turn, I don't need to wait after it."*
+
+He was right, and it was not his move being replayed — own moves have cost nothing since v0.8.0.1. It
+was the automatic phases behind it, which were scaling with `pace` along with everything else. At 5×
+that put **105 seconds of clock-ticking** into the game, all of it after a player's own move and none
+of it anything to watch.
+
+**`pace` now scales a player's move and leaves a phase at its tabled beat.** The control is labelled
+as how long another player's move is held, and that is now what it does. A phase still gets its beat
+(TODO #18) and still vanishes entirely at `pace = 0`, because off has to mean off.
+
+---
+
+## 0.8.0.2 — 2026-09-09
+
+Two things found by playing v0.8.0.1 on the test server, neither of them in the mechanism itself.
+
+### `?pace=` never worked, and a whole game was played at the wrong speed
+
+Jesse: *"I'm playing at pace = 7, and the bots are still moving too fast for me to follow."* At 7×
+a switching move holds for seven seconds, so that could not be calibration — and it was not. **He was
+at 1× the entire time.**
+
+`index.html`'s two doors are `./play.html?lobby` and `./play.html?solitaire`. Arriving through the
+splash therefore **replaces** the query string, and `location.search` on the play page is `?lobby` —
+so `PACE_OVERRIDE` was null and it fell back to the stored setting of 1. v0.8.0 shipped `?pace=` as
+the only way to change speed and the game's own front door destroyed it. Verified rather than
+assumed: the queue at pace 7 holds a bot's turn for 32.9s with the bot's district up for 24.5s, so
+the mechanism was right and the value never arrived.
+
+Fixed twice over, because one of them is the durable answer:
+
+- **A speed control on the play screen**, beside zoom — `− 1× +`, persisted per viewer, reading
+  through to the queue on the very next move. `PACE_LEVELS` is `0, 0.5, 1, 2, 3, 5, 7, 10`: off is
+  the first rung (TODO #18's "a player who has seen it a hundred times will want it off") and the
+  ladder reaches the speeds people actually reach for. At the top, a six-move switching turn takes a
+  full minute to watch.
+- **The doors now carry `pace` through**, so the URL lever is honest for handing two playtesters
+  different speeds — the only thing it was ever for. When one is present the control says
+  `7× (URL)` and disables itself rather than showing buttons that do nothing.
+
+`PACE_LEVELS` lives in `sim/pacing.ts` with `DWELL` and `MAX_PACE`, not in `main.ts` — the whole
+tuning surface in one file, and testable, which a constant inside the page entry point is not.
+
+**The committed default is unchanged at 1×.** What it should be is a question for a game played at a
+speed that actually took effect.
+
+### "0 today, 2 in all" — the Day-end dialog contradicted itself Jesse, at the end of a Day 1 with
+two collisions in it: *"It shows a total of two collisions, but zero today. Since we just finished day
+one, that does seem to be a contradiction."* Unrelated to v0.8.0 — this has been wrong since the
+dialog was built for Gitea#10, and nobody had played a Day with a collision in it and then read the
+summary.
+
+#### One line of ordering
+
+`advance.ts`, at the rollover:
+
+```ts
+s.clock.day += 1;
+s.collisionsToday = 0;
+```
+
+And `noteDayEnd()` fires when `f.day` goes UP — so the dialog reporting the Day that just finished is
+drawn from the very frame in which that Day's count was zeroed. It printed the *new* Day's zero beside
+a running total that could not possibly agree with it. Reproduced on four of five seeds before
+touching anything: Day 1 ended with `today=3 total=3`, and the dialog read `today=0 total=3`.
+
+**Not derivable on the client, which is why the fix is in the engine.** A Day turns over inside the
+phases that run themselves, so in multiplayer the push announcing the new Day is the same push that
+carries the reset — a client may never see the ended Day's final count to remember it. So
+`collisionsPrevDay` is captured in state at the rollover, immediately before the reset, and rides on
+the frame like the other two counts.
+
+#### And "today" was the wrong word anyway
+
+Even with the right number, a dialog headed "Day 1 has ended" should not say "today" — by then
+"today" is Day 2. It now names the Day: **"Collisions: 2 on Day 1, 2 in all."** The end-of-game
+results screen passes no Day and keeps "today", where the Day has not turned over and the word is
+accurate.
+
+`test/redaction.test.ts`'s allow-list did its job on the way through: adding a public property failed
+the suite until it was declared out loud.
+
+---
+
 ## 0.8.0.1 — 2026-09-09
 
-**Bot play was way too fast.** v0.8.0 was installed on `phoenix.local` and played within the hour;
+**Bot play was way too fast.** v0.8.0 was installed on the test server and played within the hour;
 Jesse: *"I briefly saw that it was the bot's office area then their turn was done and it pointed back
 to my office area"*, and the countdown row appeared "very briefly". Everything else looked right —
 the bots were visibly doing things — so this is calibration and one real bug, not a redesign.

docs/plans/jitsi-common-board.md

@@ -361,14 +361,15 @@ Introduce dedicated allow-listed types. Do not derive them with `Omit<Frame, ...
 > **Read those two, not this**, when building steps 2-7. The differences that matter:
 >
 > - **The shape is FLAT, not grouped.** There is no `clock`, `config`, `scoring` or `deckCounts`
->   object. Their contents sit at the top level. **All 37 properties, which is the same list as
+>   object. Their contents sit at the top level. **All 38 properties, which is the same list as
 >   `test/redaction.test.ts`'s allow-list** — `day`, `stage`, `clock` (a time string), `phase`,
 >   `phaseKey`, `actor`, `superintendent`, `deck`, `departments`, `departmentsWhat`,
 >   `departmentDepth`, `salvage`, `yards`, `timetable`, `timetableWhat`, `houseRules`, `mode`,
 >   `optionalRules`, `days`, `minCombinedRevenue`, `maxCollisionsPerDay`, `maxCollisionsTotal`,
->   `collisionsToday`, `collisionsTotal`, `status`, `outcome`, `extraDays`, `extensionVotes`,
+>   `collisionsToday`, `collisionsPrevDay`, `collisionsTotal`, `status`, `outcome`, `extraDays`,
+>   `extensionVotes`,
 >   `official`, `tally`, `players`, `openingRolls`, `trains`, `crewTrays`, `queued`, `division`,
->   `districts`. The first 35 come from `projectSharedTable`; `division` and `districts` are added
+>   `districts`. The first 36 come from `projectSharedTable`; `division` and `districts` are added
 >   by `PublicFrame` itself.
 > - **`protocolVersion` was NOT built** and exists nowhere in the repo. **Decided 2026-09-09: add it
 >   in step 2.** `display.json` carries its own `schemaVersion`, and the SSE wire format is a second,
@@ -887,7 +888,7 @@ Cover:
 ## Step 5 — Minimal visual-only Jitsi engine
 
 > **v0.9.0 — DEFERRED (2026-09-09).** Steps 5-7 are the Jitsi publisher and are explicitly held
-> off until 0.8.0 ships and Chromium has been measured on `phoenix.local`. Nothing below has been
+> off until 0.8.0 ships and Chromium has been measured on the target hardware. Nothing below has been
 > re-verified against the current code; it was written 2026-08-27. Two things will have moved by
 > the time it is picked up: the control channel is **SSE + POST, not a WebSocket** (§ THE RELEASE
 > SPLIT), and adding Chromium takes the `.s9pk` from 63 MB to several hundred against a package
@@ -1027,7 +1028,7 @@ Port/adapt the sibling repository’s proven tests for:
 ## Step 6 — Chromium publisher supervisor
 
 > **v0.9.0 — DEFERRED (2026-09-09).** Steps 5-7 are the Jitsi publisher and are explicitly held
-> off until 0.8.0 ships and Chromium has been measured on `phoenix.local`. Nothing below has been
+> off until 0.8.0 ships and Chromium has been measured on the target hardware. Nothing below has been
 > re-verified against the current code; it was written 2026-08-27. Two things will have moved by
 > the time it is picked up: the control channel is **SSE + POST, not a WebSocket** (§ THE RELEASE
 > SPLIT), and adding Chromium takes the `.s9pk` from 63 MB to several hundred against a package
@@ -1160,7 +1161,7 @@ Use fake child processes and fake control sockets to test:
 ## Step 7 — Configuration, lifecycle, packaging, and observability
 
 > **v0.9.0 — DEFERRED (2026-09-09).** Steps 5-7 are the Jitsi publisher and are explicitly held
-> off until 0.8.0 ships and Chromium has been measured on `phoenix.local`. Nothing below has been
+> off until 0.8.0 ships and Chromium has been measured on the target hardware. Nothing below has been
 > re-verified against the current code; it was written 2026-08-27. Two things will have moved by
 > the time it is picked up: the control channel is **SSE + POST, not a WebSocket** (§ THE RELEASE
 > SPLIT), and adding Chromium takes the `.s9pk` from 63 MB to several hundred against a package

package.json

@@ -1,6 +1,6 @@
 {
   "name": "station-master",
-  "version": "0.8.0.1",
+  "version": "0.8.0.4",
   "private": true,
   "type": "module",
   "description": "Station Master — a railroad operations game",

src/engine/advance.ts

@@ -1638,6 +1638,9 @@ function shiftChange(s: GameState, events: GameEvent[]): AdvanceResult {
 
     s.clock.day += 1;
     s.clock.stage = 1;
+    // Captured BEFORE the reset: the Day-end dialog reports the Day that just finished, and it is
+    // drawn from the frame this rollover produces. See `collisionsPrevDay` in `state.ts`.
+    s.collisionsPrevDay = s.collisionsToday;
     s.collisionsToday = 0;
     events.push({ type: 'stageBegan', day: s.clock.day, stage: 1 });
     rotateSeats(s, events);

src/engine/setup.ts

@@ -431,6 +431,7 @@ export function createGame(opts: SetupOptions): GameState {
     turns: freshTurns(playerCount, MOVES_PER_LOCAL_OPS),
     movedThisPhase: new Set(),
     collisionsToday: 0,
+    collisionsPrevDay: 0,
     collisionsTotal: 0,
     status: 'active',
     outcome: null,

src/engine/state.ts

@@ -1119,6 +1119,20 @@ export type GameState = {
   movedThisPhase: Set<TrayId>;
   /** §3.4 — resets at the start of each Day; checked against `config.maxCollisionsPerDay`. */
   collisionsToday: number;
+  /**
+   * What `collisionsToday` held for the Day that just ENDED — captured at the rollover, immediately
+   * before the reset.
+   *
+   * The Day-end dialog exists to report the Day that finished, and it is drawn from the frame AFTER
+   * the rollover, because that is the frame whose `day` went up. So it read `collisionsToday` as 0 no
+   * matter what had happened: Jesse, 2026-09-09, at the end of a Day 1 with two collisions in it —
+   * "it shows a total of two collisions, but zero today ... that does seem to be a contradiction".
+   *
+   * NOT DERIVABLE ON THE CLIENT. A Day turns over inside the phases that run themselves, so in
+   * multiplayer the push that reports the new Day is the same push that reports the reset — a client
+   * may never see the ended Day's final count to remember it.
+   */
+  collisionsPrevDay: number;
   /** §3.4 — never reset; checked against `config.maxCollisionsTotal`. */
   collisionsTotal: number;
   /**

src/sim/pacing.ts

@@ -54,7 +54,7 @@ export const DWELL: Record<StepKind, number> = {
    *
    * WAS 250ms, WHICH WAS WRONG, and wrong in the way that mattered most: an early-game bot turn has
    * no switching in it at all, so it was six steps of 250ms and 0ms — **750ms for a whole turn**.
-   * Jesse, from the first real play on `phoenix.local`: *"bot play was way too fast. I briefly saw
+   * Jesse, from the first real play on the test server: *"bot play was way too fast. I briefly saw
    * that it was the bot's office area then their turn was done."* His instruction had been "start at
    * 1s and tune down", and that was applied only to switching while this number was invented.
    */
@@ -148,6 +148,18 @@ export function kindOf(cause: StepCause): StepKind {
  */
 export const MAX_PACE = 10;
 
+/**
+ * The speeds the on-screen control offers, slowest last.
+ *
+ * `0` is off: every move is drawn at once, as it was before v0.8.0 — TODO #18's "a player who has
+ * seen it a hundred times will want it off". The ladder runs well past 1 because that is what the
+ * first real play asked for: Jesse reached for 7×, and although the `?pace=` he used never took
+ * effect (the splash replaces the query string, so the play page only ever saw `?lobby`), the wish
+ * was real. Watching a bot shunt cars is the point of this feature, and it is worth as long as it
+ * takes.
+ */
+export const PACE_LEVELS = [0, 0.5, 1, 2, 3, 5, 7, 10] as const;
+
 /**
  * How long to show one step, in ms, at a given speed.
  *
@@ -170,10 +182,25 @@ export function dwellFor(cause: StepCause, pace = 1): number {
  * have to import `DisplayStep` back from the module that imports `StepCause` from it.
  */
 export function dwellForStep(
-  step: { cause: StepCause; lines: readonly unknown[]; frame: { table: object } },
+  step: { cause: StepCause; player: number | null; lines: readonly unknown[]; frame: { table: object } },
   pace = 1,
 ): number {
-  if (step.lines.length > 0) return dwellFor(step.cause, pace);
+  // Off means off, for the clock as much as for anybody's move.
+  if (pace <= 0) return 0;
+  /**
+   * THE SPEED CONTROL IS ABOUT OTHER PEOPLE, NOT ABOUT THE CLOCK.
+   *
+   * A phase keeps its tabled beat at every speed. Measured over 40 turns of a real 3-seat game, the
+   * waiting split almost evenly — 21.0s of other players against 21.0s of phases turning over — so
+   * scaling both put 105 seconds of clock-ticking into a 5× game, all of it after the player's own
+   * move and none of it anything to watch. Jesse, from that game: *"after my turn, when I actually
+   * execute my turn, I'm still subject to that same delay before it moves on. That makes no sense."*
+   *
+   * The phase still gets its beat (TODO #18) — it just does not get longer because somebody wanted
+   * to watch a bot shunt cars.
+   */
+  const speed = step.player === null ? 1 : pace;
+  if (step.lines.length > 0) return dwellFor(step.cause, speed);
   /**
    * A SILENT STEP EARNS A BEAT ONLY WHEN THE CLOCK TURNED OVER — which is TODO #18 exactly: "give
    * every phase a visible beat", for New Train, the Mainline and the shift change.
@@ -182,12 +209,11 @@ export function dwellForStep(
    * silently killed #18: a phase can move trains without saying anything, and those steps were being
    * flashed past. "Anything that changed the board" is wrong the other way: `submit()` steps
    * `advance()` about 4.6 times per intent and most of those merely hand the turn on, so beating on
-   * all of them would cost a quarter of an hour a game. The phase turning over is the thing a player
-   * is being shown, and there are about 180 of those in a full game.
+   * all of them would cost a quarter of an hour a game.
    */
   const table = step.frame.table as Record<string, unknown>;
   const turned = 'phase' in table || 'phaseKey' in table || 'stage' in table || 'day' in table;
-  return turned ? dwellFor(step.cause, pace) : 0;
+  return turned ? dwellFor(step.cause, speed) : 0;
 }
 
 /**

src/sim/view.ts

@@ -437,6 +437,8 @@ export type Frame = {
   maxCollisionsPerDay: number;
   maxCollisionsTotal: number;
   collisionsToday: number;
+  /** What the Day that just ended finished on — see `collisionsPrevDay` in `engine/state.ts`. */
+  collisionsPrevDay: number;
   collisionsTotal: number;
   status: GameState['status'];
   outcome: GameState['outcome'];
@@ -1594,6 +1596,7 @@ export function projectSharedTable(s: GameState) {
     maxCollisionsPerDay: s.config.maxCollisionsPerDay,
     maxCollisionsTotal: s.config.maxCollisionsTotal,
     collisionsToday: s.collisionsToday,
+    collisionsPrevDay: s.collisionsPrevDay,
     collisionsTotal: s.collisionsTotal,
     status: s.status,
     outcome: s.outcome,

src/web/main.ts

@@ -26,6 +26,7 @@ import { createLocalSession, createRemoteSession } from './session.ts';
 import type { PlayerIndex } from '../engine/state.ts';
 import type { PublicDistrict } from '../sim/view.ts';
 import { createStepQueue } from './step-queue.ts';
+import { PACE_LEVELS } from '../sim/pacing.ts';
 import { notice, prefillCode, runLobby } from './lobby.ts';
 import type { LobbyReady } from './lobby.ts';
 import {
@@ -53,6 +54,7 @@ const REMOTE_KEY = 'station-master.remote.v1';
 /** Preset board zoom levels — a fraction applied to the rendered SVG's own pixel dimensions. */
 const ZOOM_LEVELS = [0.75, 1, 1.25, 1.5] as const;
 
+
 /**
  * Small persisted preferences, kept in a `localStorage` key of their own — separate from
  * `SAVE_KEY`. A save is the seed plus the intents and has to stay portable; none of this belongs
@@ -199,17 +201,23 @@ function drainIntoQueue(): void {
  * drawn — from `PublicDistrict`, which `officeSvg` can render as-is because it takes board data and
  * has never needed a private viewer.
  */
-function renderWatching(): void {
+function renderWatching(f?: Frame): void {
   const behind = stepQueue.behind();
   const row = $('watching');
-  // Collapsed whenever the board is level with the game — which in solitaire is nearly always, and
-  // between turns in multiplayer too. A row that is always there would be a row nobody reads.
-  if (behind === 0) {
+  /**
+   * VISIBLE WHILE THE BOARD IS BEHIND **OR** STILL SHOWING SOMETHING.
+   *
+   * It used to hide the moment `behind` hit zero — which is the moment the LAST step of a burst goes
+   * up, so the one step a player was most likely to be reading about lost its caption. Collapsed
+   * otherwise: in solitaire that is nearly always, and between turns in multiplayer too, and a row
+   * that is always there is a row nobody reads.
+   */
+  if (behind === 0 && !stepQueue.busy()) {
     row.hidden = true;
     return;
   }
   row.hidden = false;
-  $('watching-behind').textContent = `${behind} behind`;
+  $('watching-behind').textContent = behind === 0 ? 'catching up' : `${behind} behind`;
   /**
    * THE CAPTION IS #15, and this is where that item lands rather than as a line of its own.
    *
@@ -218,8 +226,29 @@ function renderWatching(): void {
    * The queue IS that, so the caption simply names the step being shown, and the counter beside it
    * says how much of the wait is left.
    */
+  /**
+   * WHO, THEN WHAT — Jesse, 2026-09-09: *"it didn't tell me what the actual action was, like who I
+   * was waiting on or what they were doing. I knew I was behind, but I wasn't sure what I was
+   * supposed to be looking for."*
+   *
+   * The caption was there; it was the wrong half of the sentence. Half the waiting is automatic
+   * phases, whose narration reads "Mainline" — accurate, and no answer at all to "who am I waiting
+   * on". So the name goes first, and a phase says so in as many words rather than leaving the reader
+   * to infer that nobody is acting.
+   *
+   * The narrated line is used as it stands otherwise, because `record()` already prefixes it with the
+   * player — "Player Bot 1 moved Train 3 (−1,−2) → (−1,1)" — so a second name would stutter.
+   */
   const showing = stepQueue.showing();
-  $('watching-what').textContent = showing?.lines[0]?.text ?? '';
+  const said = showing?.lines[0]?.text ?? '';
+  const who =
+    showing === null || showing === undefined
+      ? ''
+      : showing.player === null
+        ? 'The Division'
+        : (f?.players[showing.player]?.name ?? `Seat ${seatLabel(showing.player)}`);
+  // A player action already names its actor; a phase does not, so it is introduced.
+  $('watching-what').textContent = showing?.player === null && said !== '' ? `${who}: ${said}` : said;
   /**
    * SKIP COSTS THE ANIMATION AND NEVER THE INFORMATION.
    *
@@ -1262,7 +1291,7 @@ function render(): void {
 
   renderTurnChart(f);
   renderPresence(f);
-  renderWatching();
+  renderWatching(f);
   $('revenue').textContent = String(f.revenue);
   /**
    * THE OBJECTIVE, WITHOUT THE COMMENTARY.
@@ -2603,6 +2632,52 @@ function runSolitaireSetup(params: URLSearchParams, hasSave = false, live: Frame
   dealBtn.onclick = () => commitNewGame(ss, seedField?.value ?? '');
 }
 
+/**
+ * PLAYBACK SPEED — v0.8.0.3, TODO #13.
+ *
+ * Persisted per viewer in `Settings`, so it survives the navigation that was eating `?pace=`. The
+ * queue reads `settings.pace` through a closure on every step, so a change here takes effect on the
+ * very next move rather than the next game.
+ */
+const paceSlowerBtn = document.getElementById('paceslower') as HTMLButtonElement | null;
+const paceFasterBtn = document.getElementById('pacefaster') as HTMLButtonElement | null;
+const paceLabel = document.getElementById('pacelabel');
+if (paceSlowerBtn && paceFasterBtn && paceLabel) {
+  const nearestPace = (): number => {
+    // A saved or URL value need not be on the ladder — `?pace=7` and a hand-edited setting are both
+    // legitimate — so the buttons step from whichever preset is closest rather than refusing to move.
+    const want = PACE_OVERRIDE ?? settings.pace;
+    return PACE_LEVELS.reduce((best, p) => (Math.abs(p - want) < Math.abs(best - want) ? p : best), PACE_LEVELS[0]);
+  };
+  const paintPace = (): void => {
+    const p = PACE_OVERRIDE ?? settings.pace;
+    paceLabel.textContent = p === 0 ? 'off' : `${p}×`;
+    const i = PACE_LEVELS.indexOf(nearestPace() as (typeof PACE_LEVELS)[number]);
+    paceSlowerBtn.disabled = i >= PACE_LEVELS.length - 1;
+    paceFasterBtn.disabled = i <= 0;
+    // A `?pace=` in the URL wins over the setting, so say so rather than showing dead buttons.
+    if (PACE_OVERRIDE !== null) {
+      paceSlowerBtn.disabled = true;
+      paceFasterBtn.disabled = true;
+      paceLabel.textContent = `${PACE_OVERRIDE}× (URL)`;
+    }
+  };
+  const stepPace = (by: number): void => {
+    const i = PACE_LEVELS.indexOf(nearestPace() as (typeof PACE_LEVELS)[number]);
+    const next = PACE_LEVELS[Math.min(PACE_LEVELS.length - 1, Math.max(0, i + by))];
+    if (next === undefined) return;
+    saveSettings({ pace: next });
+    paintPace();
+    // The row's countdown is measured in steps that will dwell, so a change to 0 empties it at once.
+    renderWatching();
+  };
+  // Slower is a BIGGER multiplier, so "−" walks up the ladder. Labelled by what it does to the game,
+  // not to the number: a player pressing "slower" wants to watch for longer.
+  paceSlowerBtn.onclick = () => stepPace(1);
+  paceFasterBtn.onclick = () => stepPace(-1);
+  paintPace();
+}
+
 const zoomOutBtn = document.getElementById('zoomout') as HTMLButtonElement | null;
 const zoomInBtn = document.getElementById('zoomin') as HTMLButtonElement | null;
 const zoomLabel = document.getElementById('zoomlabel');

src/web/panels.ts

@@ -180,7 +180,7 @@ export function dayEndHtml(f: Frame): string {
     ahead +
     standingsHtml(f) +
     targetHtml(f) +
-    collisionsHtml(f)
+    collisionsHtml(f, ended)
   );
 }
 
@@ -238,13 +238,28 @@ function targetHtml(f: Frame): string {
  * its config and enforces neither, so reporting a collision budget there would put a rule on
  * screen that this game does not have.
  */
-function collisionsHtml(f: Frame): string {
+function collisionsHtml(f: Frame, endedDay?: number): string {
   const scoredOnCollisions =
     (f.mode === 'competitive' || f.mode === 'coop') &&
     (f.maxCollisionsTotal > 0 || f.maxCollisionsPerDay > 0);
-  return scoredOnCollisions
-    ? `<p>Collisions: <b>${f.collisionsToday}</b> today, <b>${f.collisionsTotal}</b> in all.</p>`
-    : '';
+  if (!scoredOnCollisions) return '';
+  /**
+   * "TODAY" IS THE WRONG WORD IN A DAY-END DIALOG, and it read as a contradiction.
+   *
+   * That dialog is drawn from the frame whose `day` went UP — which is the same frame in which
+   * `collisionsToday` was reset — so it reported 0 however many there had been. Jesse, 2026-09-09,
+   * at the end of a Day 1 with two collisions in it: "it shows a total of two collisions, but zero
+   * today ... that does seem to be a contradiction."
+   *
+   * So when the caller knows which Day just ended it says so by name, and reads the count captured at
+   * the rollover. The end-of-game results screen passes nothing and keeps "today", where the Day has
+   * not turned over and the word is accurate.
+   */
+  const [count, when] =
+    endedDay === undefined
+      ? [f.collisionsToday, 'today']
+      : [f.collisionsPrevDay, `on Day ${endedDay}`];
+  return `<p>Collisions: <b>${count}</b> ${when}, <b>${f.collisionsTotal}</b> in all.</p>`;
 }
 
 /**

src/web/play.html

@@ -125,6 +125,7 @@ section{background:var(--panel);border:1px solid var(--line);border-radius:7px;
 .wbehind{font-variant-numeric:tabular-nums;font-weight:700;color:#c9cee0;
   background:#22263a;border:1px solid #343a52;border-radius:10px;padding:1px 8px;white-space:nowrap}
 #watching-skip{font-size:11px;padding:2px 10px;border-color:#e0b060;color:#e0b060;flex:none}
+#watching-who{color:#c9cee0;font-weight:700}
 #presence:empty{display:none}
 /* division strip */
 #division{display:flex;gap:7px;overflow-x:auto;padding-bottom:4px}
@@ -872,6 +873,14 @@ ul.blocked li{padding:2px 0}
   <span class="zoom" title="Zoom the Division map and your Office Area. Both already scroll — this only changes their size.">
     <button id="zoomout" aria-label="Zoom out">−</button><span id="zoomlabel">100%</span><button id="zoomin" aria-label="Zoom in">+</button>
   </span>
+  <!-- HOW FAST OTHER PLAYERS' TURNS PLAY BACK — v0.8.0.3, TODO #13.
+       A CONTROL RATHER THAN ONLY A URL PARAMETER. `?pace=` shipped first and is unreachable through
+       the front door: `index.html`'s two doors are `play.html?lobby` and `play.html?solitaire`, so
+       arriving from the splash REPLACES the query string and any pace with it. Jesse played a whole
+       game believing he was at 7x when he was at 1x. -->
+  <span class="zoom" title="How long another player's or a bot's move is held on screen before the next one. Yours are never delayed. Off draws every move at once, as it did before v0.8.0.">
+    <button id="paceslower" aria-label="Slower playback">−</button><span id="pacelabel">1×</span><button id="pacefaster" aria-label="Faster playback">+</button>
+  </span>
   <button id="undo" title="Take the last action back. The save is the seed plus the moves made, so this replays the game without the last one — as far back as you like.">Undo</button>
   <button id="savefile" title="Download this game as a save file you can replay or share">Save replay</button>
   <button id="newgame" title="Set up a fresh game — the seed, the table, the opening hand and what the three economies pay. Opens the same screen a new solitaire game starts from, with your current rules filled in; your game in progress is kept until you press Deal, and Continue puts it straight back.">New game</button>
@@ -906,9 +915,12 @@ ul.blocked li{padding:2px 0}
      and Skip. Empty and collapsed whenever the board is level with the game, which in solitaire is
      almost always. -->
 <div id="watching" hidden>
+  <!-- SKIP FIRST, on the left. It sat on the far right and a player's eye is on the countdown, not at
+       the other end of the row — Jesse, 2026-09-09: "the skip button should be on the far left, in
+       front of where it says [the count], so it's always close to where people are looking." -->
+  <button id="watching-skip" class="ghost" type="button" title="Stop animating and jump the board to where the game actually is. Nothing is lost — every line is already in the History panel.">Skip</button>
   <span id="watching-behind" class="wbehind"></span>
   <span id="watching-what"></span>
-  <button id="watching-skip" class="ghost" type="button" title="Stop animating and jump the board to where the game actually is. Nothing is lost — every line is already in the History panel.">Skip</button>
 </div>
 
 <main>

src/web/splash.ts

@@ -40,6 +40,29 @@ if (heroImage && lightbox) {
  * other way costs a click and a lobby that says it cannot reach a server — which is legible, and
  * recoverable. So a slow or flaky probe leaves the door alone; only a definite answer closes it.
  */
+/**
+ * CARRY `?pace=` THROUGH THE DOORS — v0.8.0.3.
+ *
+ * Both doors are static hrefs that REPLACE the query string (`play.html?lobby`,
+ * `play.html?solitaire`), so a `pace` typed on this page was silently dropped on the way in: Jesse
+ * played a whole game believing he was at 7× when the play page had only ever seen `?lobby`. The
+ * durable answer is the speed control on the play screen, which persists per viewer — this keeps the
+ * URL lever honest for handing two playtesters different speeds, which is the only thing it was ever
+ * for.
+ */
+try {
+  const pace = new URLSearchParams(location.search).get('pace');
+  if (pace !== null) {
+    for (const door of Array.from(document.querySelectorAll('a.door'))) {
+      const href = door.getAttribute('href');
+      // Only the doors into the game, and only ones that have not been disabled above.
+      if (href?.startsWith('./play.html?')) door.setAttribute('href', `${href}&pace=${encodeURIComponent(pace)}`);
+    }
+  }
+} catch {
+  // A door that keeps its own href is the status quo, not a broken page.
+}
+
 const mpDoor = document.getElementById('door-multiplayer');
 if (mpDoor) {
   const close = (): void => {

test/pacing.test.ts

@@ -14,7 +14,7 @@ import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { DWELL, MAX_PACE, dwellFor, dwellForStep, kindOf, watchableCount } from '../src/sim/pacing.ts';
+import { DWELL, MAX_PACE, PACE_LEVELS, dwellFor, dwellForStep, kindOf, watchableCount } from '../src/sim/pacing.ts';
 import type { StepKind } from '../src/sim/pacing.ts';
 import type { Intent } from '../src/engine/intents.ts';
 
@@ -52,7 +52,7 @@ describe('pacing — dwell by kind', () => {
     assert.equal(kindOf('switch.end'), 'bookkeeping');
     /**
      * `localOps.choose` IS AN ANNOUNCEMENT, not bookkeeping — moved 2026-09-09 after the first real
-     * play on `phoenix.local`. It is the line reading "Player Bot 1 chose to SWITCH", the heading for
+     * play on the test server. It is the line reading "Player Bot 1 chose to SWITCH", the heading for
      * everything that follows, and at zero dwell a bot's turn began with no sign of what it was about
      * to do.
      */
@@ -120,6 +120,31 @@ describe('pacing — dwell by kind', () => {
     assert.equal(watchableCount(queue, 0), 0, 'with animation off, nothing is behind');
   });
 
+  it('offers speeds a player actually reached for, and none the code would clamp', () => {
+    /**
+     * Jesse played a whole game believing he was at 7× and was in fact at 1×: `?pace=` shipped as the
+     * only lever, and `index.html`'s doors are `play.html?lobby` / `play.html?solitaire`, so arriving
+     * from the splash REPLACES the query string. Hence a real control on the play screen, and hence
+     * this ladder — which must reach the speeds people ask for and must not offer one that
+     * `dwellFor` would silently clamp.
+     */
+    assert.equal(PACE_LEVELS[0], 0, 'off must be the first rung — #18 wants it turned off');
+    assert.ok(PACE_LEVELS.includes(1), 'the default must be on the ladder');
+    assert.ok(PACE_LEVELS.includes(7), '7x was asked for by name');
+    for (const p of PACE_LEVELS) {
+      assert.ok(p <= MAX_PACE, `${p}x is past MAX_PACE, so the control would lie about it`);
+      assert.equal(dwellFor('switch.move', p), Math.round(DWELL.switching * p));
+    }
+    // Strictly increasing, so stepping the control always changes the speed.
+    for (let i = 1; i < PACE_LEVELS.length; i++) {
+      assert.ok(PACE_LEVELS[i]! > PACE_LEVELS[i - 1]!, 'the ladder must be strictly increasing');
+    }
+    // The slowest rung has to be slow enough to be worth having: six switching moves at the top of
+    // the ladder is a full minute, which is the "watch them struggle" case.
+    const slowest = dwellFor('switch.move', PACE_LEVELS[PACE_LEVELS.length - 1]!) * 6;
+    assert.ok(slowest >= 60_000, `the slowest a switching turn can be watched is ${slowest}ms`);
+  });
+
   it('a silent step beats only when the clock turns over — TODO #18', () => {
     /**
      * Both obvious rules were wrong, so both are pinned. "No narration, no dwell" flashed past
@@ -127,18 +152,37 @@ describe('pacing — dwell by kind', () => {
      * that changed the board" beat on every turn hand-off — `submit()` steps `advance()` about 4.6
      * times per intent — which came to a quarter of an hour a game.
      */
-    const silent = { cause: 'phase' as const, lines: [] as string[] };
+    const silent = { cause: 'phase' as const, player: null, lines: [] as string[] };
     assert.equal(dwellForStep({ ...silent, frame: { table: { actor: 2 } } }), 0, 'a turn hand-off shows nothing');
     assert.equal(dwellForStep({ ...silent, frame: { table: {} } }), 0, 'a step that changed nothing shows nothing');
     assert.equal(dwellForStep({ ...silent, frame: { table: { phase: 'mainline' } } }), DWELL.phase);
     assert.equal(dwellForStep({ ...silent, frame: { table: { stage: 4 } } }), DWELL.phase);
     // Narration always earns the dwell of whatever caused it, clock or no clock.
     assert.equal(
-      dwellForStep({ cause: 'switch.move', lines: ['moved'], frame: { table: {} } }),
+      dwellForStep({ cause: 'switch.move', player: 1, lines: ['moved'], frame: { table: {} } }),
       DWELL.switching,
     );
   });
 
+  it('the speed control stretches other people, not the clock', () => {
+    /**
+     * Jesse, from a real 5× game: *"after my turn, when I actually execute my turn, I'm still subject
+     * to that same delay before it moves on. That makes no sense."* It was not his move being
+     * replayed — it was the automatic phases behind it, which were scaling with `pace` along with
+     * everything else. Measured over 40 turns, the waiting split almost evenly between other players
+     * and phases turning over, so a 5× game spent 105 seconds on the clock alone.
+     */
+    const phase = { cause: 'phase' as const, player: null, lines: ['New Train'], frame: { table: { phase: 'newTrain' } } };
+    const theirs = { cause: 'switch.move' as const, player: 1, lines: ['moved'], frame: { table: {} } };
+    for (const pace of [1, 3, 5, 7]) {
+      assert.equal(dwellForStep(phase, pace), DWELL.phase, `a phase beat grew at ${pace}x`);
+      assert.equal(dwellForStep(theirs, pace), DWELL.switching * pace);
+    }
+    // Off still means off, for the clock as much as for anybody's move.
+    assert.equal(dwellForStep(phase, 0), 0);
+    assert.equal(dwellForStep(theirs, 0), 0);
+  });
+
   it('a real switching turn is watchable in a few seconds, not tens of them', () => {
     // Six moves is the engine's cap per crew ("N of 6 Moves left"), so this is the worst ordinary
     // case for one crew: the announcement, six moves, and an end that shows nothing.
@@ -155,7 +199,7 @@ describe('pacing — dwell by kind', () => {
 
   it("a bot's ordinary turn is followable, which is what the first real play was not", () => {
     /**
-     * MEASURED FROM A REAL GAME, then pinned. Jesse, after installing v0.8.0 on `phoenix.local`:
+     * MEASURED FROM A REAL GAME, then pinned. Jesse, after installing v0.8.0 on the test server:
      * *"bot play was way too fast. I briefly saw that it was the bot's office area then their turn
      * was done."* This is the shape that turn actually had — no switching in it at all, because
      * switching is not legal until there is track down — and under the original values it came to

test/redaction.test.ts

@@ -524,6 +524,9 @@ describe('#91 — nothing private survives serialisation, in any state', () => {
       // The rules the game was dealt under, and the score.
       'houseRules', 'mode', 'optionalRules', 'days', 'minCombinedRevenue',
       'maxCollisionsPerDay', 'maxCollisionsTotal', 'collisionsToday', 'collisionsTotal',
+      // What the Day that just ended finished on. Public for the same reason the running counts are:
+      // a collision happens on the Mainline in front of everybody.
+      'collisionsPrevDay',
       'status', 'outcome', 'extraDays', 'extensionVotes', 'official', 'tally',
       // Names, seats, revenue and HAND SIZE — never hand contents.
       'players',

test/step-queue.test.ts

@@ -179,7 +179,7 @@ describe('the step queue', () => {
      * REGRESSION. `busy()` was `pending.length > 0`, so the instant the final step of a burst was
      * shown the queue reported idle: the animation loop stopped and the district panel snapped back
      * to the viewer's own board without that step ever being looked at. Jesse, from the first real
-     * play on `phoenix.local`: *"I briefly saw that it was the bot's office area then their turn was
+     * play on the test server: *"I briefly saw that it was the bot's office area then their turn was
      * done and it pointed back to my office area"*, and the countdown row appeared "very briefly".
      *
      * The panel follows `busy()`, so this is the property that keeps somebody else's board on screen

test/web.test.ts

@@ -3614,6 +3614,46 @@ describe('the Day rolling over says so (Gitea#10)', () => {
     assert.ok(html.includes('3 Days left'), `the Days remaining are wrong:\n${html}`);
   });
 
+  it('reports the ENDED Day\'s collisions, not the fresh Day\'s zero', () => {
+    /**
+     * Jesse, 2026-09-09, at the end of a Day 1 with two collisions in it: *"It shows a total of two
+     * collisions, but zero today. Since we just finished day one, that does seem to be a
+     * contradiction."*
+     *
+     * The cause is a one-line ordering fact: `advance.ts` increments the Day and then zeroes
+     * `collisionsToday`, and this dialog is drawn from the frame whose Day went UP — so it read the
+     * fresh Day's zero and printed it beside a running total that could not agree with it. The count
+     * is captured at the rollover now, and the dialog names the Day rather than saying "today".
+     */
+    const s = createEngineGame({
+      id: 'collide',
+      seed: 5,
+      config: {
+        mode: 'competitive',
+        days: 5,
+        minCombinedRevenue: 60,
+        maxCollisionsPerDay: 3,
+        maxCollisionsTotal: 10,
+        pvpCardsAllowed: false,
+        optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
+      },
+      playerNames: ['Joe', 'Bot 1'],
+    });
+    // The state as the rollover out of Day 1 leaves it: two collisions happened, `today` is reset.
+    s.clock.day = 2;
+    s.collisionsPrevDay = 2;
+    s.collisionsToday = 0;
+    s.collisionsTotal = 2;
+
+    const html = dayEndHtml(snapshot(s, [], null));
+    assert.ok(html.includes('Day 1 has ended'), `wrong Day named:\n${html}`);
+    assert.ok(html.includes('<b>2</b> on Day 1'), `the ended Day's collisions are wrong:\n${html}`);
+    assert.ok(html.includes('<b>2</b> in all'), `the running total is wrong:\n${html}`);
+    assert.doesNotMatch(html, /<b>0<\/b> today/, `still reporting the fresh Day's zero:\n${html}`);
+    // The contradiction itself: a Day-end dialog must never claim fewer in all than on that Day.
+    assert.doesNotMatch(html, /<b>0<\/b> on Day 1/, 'reported no collisions on a Day that had two');
+  });
+
   it('counts the last Day as the last Day rather than promising more', () => {
     const html = dayEndHtml(frameAt(6));
     assert.ok(html.includes('Day 5 has ended'), 'the final Day is misnamed');