v0.8.0.13 — the board on screen is the board you can act on

Nine reports from the Day 1-2 playtest of v0.8.0.12. One moved a car, one was a
rule working correctly with nothing on screen to say so, and the rest are things
the table could not see.

The real bug: the Division Yard chips stayed lit and clickable while the board
was catching up. `renderActions` puts the action list away while the queue is
behind — a move offered against a position that has already moved on is a move
made blind — but the make-up wiring sat outside that guard. A chip was clicked
during a bot's make-up, a coach left the yard, and the train ended up with three
cars: a real intent submitted against a board several moves stale. The chips now
follow the queue like every other control, and the yard COUNTS are drawn from the
shown board rather than the live game — they were the one panel still reporting a
future the player had not been shown.

The Office Area picker had a button per opponent and none for yourself, so the
one player who could not reach their own district was the player waiting on
everybody else. Your own seat is in the row now, and the row is ordered by SEAT,
west to east as the Division map draws it, rather than by join order — sorted
from the Frame's own `seat` on every render, so it rotates with Employee Rotation
instead of having to be told.

§5's handover of the Fedora rode on `actorChanged`, which is turn bookkeeping and
which `record()` drops as noise, so the one moment it carried that a player needed
went past in silence. It is its own event now, narrated and announced. The phase
keeps its name: the Supervisor Shift refreshes every Laborer and Porter EVERY
Stage and the Fedora moves only every third.

A collision now names whose Office it was and who paid the 5 Revenue, which rode
in a separate `revenueChanged`; a Mainline collision is phrased differently
because §10 makes it the Superintendent's.

Passengers, reported as a bug and ruled not one after replaying the save: the
Depot's capacity and modifiers were fine, and §6.3 stocking wants a LOADED coach
out of the Division Yard, which held none while six sat in Classification. The
shortage stays — running out is part of the game, the same ruling Gitea#2 got —
but the blocked panel says so now instead of the action being silently absent.

Smaller: "working left" is "working eastward" in the make-up panel and the New
Train tip, because the map runs west to east and the table does not; the history
panel keeps 90 lines instead of 60 in the same 230px box.

`git diff v0.8.0.12..v0.8.0.13 -- src/engine/` is NOT empty this time:
`events.ts` declares `superintendentChanged` and `advance.ts` emits it. Both are
additive — `check()`, `legal.ts` and every predicate are untouched, and events are
derived by replaying a save rather than stored — so no once-legal move became
illegal and games in progress resume.

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

.gitignore

@@ -50,3 +50,9 @@ __pycache__/
 # one that is worth publishing.
 /playtests/*
 !/playtests/README.md
+
+# The Jitsi harness is NOT scrubbed — four of its files carry a real domain and real
+# participant names (workspace AGENTS.local.md). Ignored so that a `git add -A` cannot sweep it
+# into a history that would be permanently exposed if this repo is ever made public. When it is
+# promoted in Phase 1, scrub it FIRST, then `git add -f tools/`.
+tools/

README.md

@@ -35,8 +35,19 @@ deliberately no longer names one: it went stale for six releases.
   reload; anybody may leave and the host may clear a chair; and the four transient signals that make
   a game feel alive — sound, the timetable flash, an announcement, the badge on the card you just
   drew — reach a remote client, which they did not before v0.7.0. What is still open is in `TODO.md`
-  under Multiplayer — chiefly that **a player cannot see what the others did**, and that a lost
+  under Multiplayer — chiefly that a lost
   session token still locks someone out of a running game from a genuinely fresh browser.
+- **Watching the table — v0.8.0.** Every accepted move, and every automatic phase that does
+  anything, becomes an ordered **presentation step**: the board replays other people's turns instead
+  of arriving already rearranged. This is what closes "a player cannot see what the others did",
+  which stood open through v0.7.x. A bot's whole switching turn used to land in one push, because
+  `driveBots()` plays it out before the push goes back; now it arrives as a run of steps, the
+  district panel follows whoever is acting, and a `[N behind] … [Skip]` row says how far the board is
+  from the game. Dwell is assigned **by kind** — a switching move holds the screen, turn bookkeeping
+  costs nothing — and is tunable per viewer without a rebuild. Solitaire runs the same path, which is
+  where its automatic phases finally get a visible beat.
+  **Not yet checked in a browser:** the mechanism is proven server-side against a live SSE stream and
+  the page is proven not to throw, but nobody has watched a bot switch on screen.
 - **Not built** — the opponent-directed cards (the Action and Space-use categories, held out of every
   deck until they have an implementation, along with the defensive cards whose only purpose is to
   answer them), and real audio. No screen offers a control for the opponent cards any more: the
@@ -45,7 +56,8 @@ deliberately no longer names one: it went stale for six releases.
 Balance is *not* where it should be, and this file no longer quotes a figure for it. It used to say
 "the developer bot averages 7.0 Revenue against a target of 20", which stopped being true the moment
 the transit rule it names was defaulted to off — that rule was worth ~5.4 of the 7.0, for traffic
-nobody had to work. Measured at the current defaults the bot means about **zero**.
+nobody had to work. Measured at the current defaults the bot meant about **zero** until it began
+planning its switching turns (2026-09-14), which put it near **2.8**.
 
 The three rates — passenger per coach, freight per load, train per transit — are **settings fixed when
 the game is dealt**, along with the opening hand and where an Extra may start, so the economy can be
@@ -91,7 +103,8 @@ separate thing: it assembles the static SITE into `dist/`.)
 
 ```sh
 npm install
-npm test          # node --test
+npm test          # node --test, everything except the bot simulations — run after every change
+npm run test:sim  # test/sim.test.ts, the bot simulations (~7 min) — run after a bot or balance change
 npm run typecheck # tsc --noEmit
 ```
 
@@ -131,7 +144,45 @@ is the thing this machinery exists to prevent.
   and they do not reconstruct the position. The phase driver mutates state and then describes it, so
   roughly a third of the event types are never reduced at all. Anything that needs to rebuild a game
   replays the intents.
+- **A save is only guaranteed to replay on the version that wrote it.** This is the cost of the
+  property above and is not a bug to be fixed case by case: a save is a list of moves, so it reopens
+  by being *re-played through the current rules*. Any rules change that makes a once-legal move
+  illegal will stop an older save at that move — **a change to the deck is the likeliest breaker**,
+  since a history that names a card the deck no longer deals has no legal answer at all, but any
+  narrowing of what is permitted does it. It fails safe in every case: the load is declined, the
+  offending move is named, and the file is left untouched, so nothing a player has is destroyed.
+  Assume an older save may not open, tell players so wherever a build is announced, and read "this
+  save will not load" in a bug report as this before treating it as a fault. **Versioned, migratable
+  replays are a post-1.0 question** — deliberately not worth the effort while the rules are still
+  moving this fast, since every migration would have to be written against rules that changed again
+  next release.
 - **Never call `Math.random()`.** One ambient random call silently breaks replay.
+- **The Mainline Phase can stop and ask, and there are three questions it asks.** §8.1's clearance
+  ruling goes to the Superintendent; the Yard Office offer and the Red Flag prompt go to the owner of
+  the district a train is arriving at. `pendingDecision` is a discriminated union and `decisionActor`
+  is the single place that maps a question to whoever must answer it — a new question adds a case
+  there and nowhere else. **Ask before the move is committed:** returning `needsClearance` unwinds
+  the whole phase and the driver re-enters from the top, so anything already mutated is applied
+  twice or left half-done.
+- **A game ends by PAUSING, and the first ending is the real one.** Running out of Days, or closing
+  short of the combined Revenue floor, puts the game in `awaitingExtension` rather than `finished`:
+  the table is asked whether to play one more Day, unanimously, and asked again at the end of every
+  Day it grants. `state.official` is written at the first ending and never rewritten, so the winner
+  is always the one decided at `config.days` however long play carries on — `config.days` itself
+  never moves, and `state.extraDays` counts the borrowed ones. A §3.4 collision breach is the
+  exception and finishes outright, during an extended Day exactly as during the scheduled game.
+  Because a save is a replay, the vote is an intent (`game.extend`), and it is the one intent that
+  **carries its own player**: every seat may vote in any order, so a replay cannot derive who did.
+- **Statistics are folded, not recorded.** `state.tally` counts what the event stream says happened —
+  trains through the Division and how many of them did any switching, loads made up and broken — and
+  is hooked
+  at the two boundaries every event crosses exactly once, `applyIntent` and `advance`. It is not
+  hooked in `reduce`, which never sees the phase driver's events at all. Nothing in the rules reads
+  it, so adding a counter is always safe; it rides the `Frame`, so a multiplayer client gets the same
+  numbers as solitaire from one implementation. **What it cannot count is anything the events do not
+  say.** `trainStoodStill` fires once per game for the X18 Circus alone, so "the longest an engine sat
+  on a siding" has no signal behind it — see `TODO.md` #36 rather than assuming an event means what
+  its name suggests.
 - **A game is one of four TYPES, and a type is a set of defaults rather than a ruleset.** Co-op,
   Competitive, Cutthroat and Solitaire (`src/web/presets.ts`) each name an opening hand, an Extra
   rule, three revenue rates and the victory conditions; picking one fills the form, and changing any

docs/architecture/lobby-and-sessions.md

@@ -36,6 +36,34 @@ and `<ip>:<port>` are both expected — and browser storage is scoped to the ori
 at one address must come back to that address, or they are a stranger with no token. Say so in the
 UI at join time rather than letting someone discover it when they cannot get back in.
 
+**A lost token is recoverable, administratively** (Gitea#33). Everything above makes the token the
+single point of failure: it lives in one browser's storage, and a cleared profile, a private window or
+a different browser ends the seat with the game still running and the session still on disk. Seen at a
+real table — the returning player met an empty lobby while their token sat intact in `sessions.json`,
+and the only way back was an administrator reading the file off the volume and the player pasting it
+into a devtools console.
+
+So there is a supported path, in two halves that are gated differently on purpose:
+
+```
+POST /api/games/<id>/claim  { player }   →  { code, expiresAt, … }   admin secret
+POST /api/claim             { code }     →  { token, gameId, player, gameCode }
+```
+
+**The link carries the code, never the token** — which is the rule three paragraphs up, applied. A
+recovery link is exactly the sort of thing that gets pasted into a chat, so what travels in the URL is
+single-use and expires in thirty minutes (`server/claims.ts`), and the page trades it for the real
+token over a POST as it loads (`?claim=` in `web/main.ts`, which strips it from the address bar either
+way). A leaked code is worthless once spent; a leaked token is the seat for the rest of the game.
+
+**Minting is administrative; spending is not.** Deciding that a particular person has lost a
+particular seat is a judgement no route can make safely — anyone able to mint their own code could
+take any chair at the table. Spending needs no secret because the player following the link is the one
+person in the story who holds none; the code *is* the authorisation, and it is the same shape
+(unguessable, one-time) as the token it hands back. The codes are held in memory: they are minted on
+demand and spent within minutes, so a restart dropping them is the right failure, and persisting them
+would put a credential-equivalent on the volume to solve a problem measured in seconds.
+
 Real accounts can be layered on later without touching the rules engine, which is exactly why
 [`overview.md`](overview.md) keeps that boundary sharp.
 

docs/rules/as-built.md

@@ -0,0 +1,260 @@
+# Station Master — the cards as built
+
+> **Generated from `src/engine/content.ts` by `scripts/build-card-reference.ts`. Do not edit by
+> hand** — `npm run build:cards` rewrites it, and `test/card-reference.test.ts` fails if this file
+> and the code disagree.
+
+This is the one file in `docs/rules/` that describes the game **as it currently is**. Everything
+else in this directory is a historical record and marked as such: [`rules-v0.1.md`](rules-v0.1.md)
+transcribes the prototype PDFs, [`open-questions.md`](open-questions.md) tracks how the gaps in
+them were decided, and [`rules-v0.2.md`](rules-v0.2.md) and
+[`card-reference.md`](card-reference.md) both describe superseded card sets. Read those for the
+reasoning; read this for the numbers.
+
+The engine instantiates from the same constants this is emitted from, so a disagreement between
+this page and the game is a bug in the generator, not a stale table.
+
+**No card counts appear here, deliberately** (TODO #15a, Jesse 2026-08-22): the counts move with
+play balance, so a document that prints them is answering a question that will have a different
+answer next retune. Where a count matters it is a yes/no — whether the deck deals the card at
+all — which is a fact about the design rather than about the current tuning.
+
+---
+
+## Trains
+
+12 timetabled and 10 Extras, 22 in all.
+Odd numbers run west, even run east; a pair shares a class and is the same card face in two
+directions. A Crew Tray holds four pieces and a caboose counts toward the four, which is why no
+train with a caboose carries more than three revenue cars.
+
+### Timetabled
+
+| # | Class | Speed | Runs | Consist | Printed rules |
+| ---: | --- | --- | --- | --- | --- |
+| 1 | Crack Limited | fast | west | 2 coaches (2 pieces) | terminals only; no switching; expedite; *"Stop at Terminals only."* |
+| 2 | Crack Limited | fast | east | 2 coaches (2 pieces) | terminals only; no switching; expedite; *"Stop at Terminals only."* |
+| 3 | Express | fast | west | 2 freight (2 pieces) | one freight per location; expedite; *"May drop or pick up one freight car at every location."* |
+| 4 | Express | fast | east | 2 freight (2 pieces) | one freight per location; expedite; *"May drop or pick up one freight car at every location."* |
+| 5 | The Sparrow | fast | west | 3 coaches (3 pieces) | no switching; expedite |
+| 6 | The Sparrow | fast | east | 3 coaches (3 pieces) | no switching; expedite |
+| 7 | Local | slow | west | 1 freight + 1 coach (2 pieces) | coach stays on station track; *"Maximum one freight, one coach."* |
+| 8 | Local | slow | east | 1 freight + 1 coach (2 pieces) | coach stays on station track; *"Maximum one freight, one coach."* |
+| 9 | Heavy Freight | slow | west | 3 freight + 1 caboose (4 pieces) | — |
+| 10 | Heavy Freight | slow | east | 3 freight + 1 caboose (4 pieces) | — |
+| 11 | Drag Freight | slow | west | 2 freight + 1 caboose (3 pieces) | — |
+| 12 | Drag Freight | slow | east | 2 freight + 1 caboose (3 pieces) | — |
+
+### Extras
+
+| # | Class | Speed | Runs | Consist | Printed rules |
+| ---: | --- | --- | --- | --- | --- |
+| X13 | Appleseed Extra | slow | player's choice | 3 freight + 1 caboose (4 pieces), empties only | drop only; *"May drop MTs but not pick up anything."* |
+| X14 | Fruit Growers Express | fast | player's choice | 2 reefers + 1 caboose (3 pieces) | expedite; *"Reefers only. May pick up one extra loaded reefer."* |
+| X15 | Yard Xfer | slow | player's choice | 2 freight + 1 caboose (3 pieces) | — |
+| X16 | Light Engine Move | fast | player's choice | engine only | no switching; *"No cars at all."* |
+| X17 | Campaign Train | fast | player's choice | 1 coach (1 piece) | no switching; stop then expedite; stop earns point; must run loaded; *"One turn at station (speeches) then expedite. Earns a point per Office Area if the candidate is aboard."* |
+| X18 | Circus Train | slow | player's choice | 2 freight + 1 coach + 1 caboose (4 pieces) | no switching; stop earns point; must run loaded; *"One turn stopped in an Office Area (circus set-up) earns 1 point, once per Area, if fully loaded."* |
+| X19 | Military Train | slow | player's choice | 1 freight + 2 coaches (3 pieces) | no switching; no passenger work; expedite; must run loaded; *"Troops and materiel: runs loaded where the yard can supply it."* |
+| X20 | Director's private car | slow | player's choice | 2 freight + 1 coach (3 pieces) | no passenger work |
+| X21 | Freight Extra | slow | player's choice | 3 freight + 1 caboose (4 pieces) | — |
+| X22 | Pee-Dee | slow | player's choice | 1 caboose (1 piece) | pick up empties only; *"Per-diem train. May only pick up MTs."* |
+
+---
+
+## Mainline cards
+
+A card is divided into **regions**, and a train advances one region per Stage — so the regions a
+card prints are what it costs to cross. Where a train *enters* is what the rules move: a fast
+train on Hilly, a Heavy Grade with Helpers, or a card whose back region is a siding rather than
+part of the road all change the entry point rather than the card's length.
+
+| Card | Regions | Default entry | Fast / slow entry | Trains may pass | Sorts cars |
+| --- | ---: | ---: | --- | :---: | :---: |
+| Plains | 1 | 0 | — | — | — |
+| Curves | 2 | 0 | — | — | — |
+| Hilly | 2 | 0 | 1 / 0 | — | — |
+| Heavy Grade | 3 | 0 | — | — | — |
+| Double Track | 1 | 0 | — | yes | — |
+| Uncontrolled Siding | 2 | 1 | — | — | — |
+| Tunnel | 2 | 0 | — | — | — |
+| Trestle | 1 | 0 | — | — | — |
+| Interchange | 2 | 1 | — | — | yes |
+
+The Mainline deck is 10 cards; the two Division Points are the fixed ends of
+the Division and are not dealt. What each card does, in the words the game uses on screen:
+
+- **Plains** — 1 region — one Stage each. · 1 Stage for every train. · One train at a time — anything following has to wait for it to clear.
+- **Curves** — 2 regions — one Stage each. · 2 Stages for every train. · One train at a time — anything following has to wait for it to clear.
+- **Hilly** — 2 regions — one Stage each. · This card reads the train's FAST/SLOW rating: a fast train starts further along and crosses in 1 Stage, a slow one in 2 Stages. No other card cares which it is. · One train at a time — anything following has to wait for it to clear.
+- **Heavy Grade** — 3 regions — one Stage each. · A grade, climbing eastward. 3 Stages to climb it and 3 Stages to run down, before help. Helpers start an UPHILL train a region further on; Brakeman does the same DOWNHILL and Airbrakes another again, and Airbrakes cannot be played without Brakeman. Never less than one Stage. · One train at a time — anything following has to wait for it to clear.
+- **Double Track** — 1 region — one Stage each. · 1 Stage for every train. · TRAINS MAY PASS — two trains may stand on this card at once, so a following train is not held behind a slower one.
+- **Uncontrolled Siding** — 2 regions — one Stage each. · A train with the card to itself starts past the back region and is across in 1 Stage. · UNCONTROLLED SIDING — arrive to find a train already here and you take the siding, a region behind it. You are not in the same place, so you do not run into it; it costs you the extra Stage instead. · One train at a time — anything following has to wait for it to clear.
+- **Tunnel** — 2 regions — one Stage each. · 2 Stages for every train. · One train at a time — anything following has to wait for it to clear.
+- **Trestle** — 1 region — one Stage each. · 1 Stage for every train. · One train at a time — anything following has to wait for it to clear.
+- **Interchange** — 2 regions — one Stage each. · A train with the card to itself starts past the back region and is across in 1 Stage. · An Extra beginning its run here starts in the back region and takes the extra Stage. · One train at a time — anything following has to wait for it to clear. · Cars may be sorted into any new order here.
+
+---
+
+## Office cards
+
+Upgrades are strictly sequential — no skipping a tier — so a Terminal needs all three cards in
+order. Green slots are outbound passengers, red are inbound, and the design gives slots **equal**
+to Porters rather than one more.
+
+| Office | Control point | Passenger facility | A/D tracks | Porters | Green | Red |
+| --- | :---: | :---: | ---: | ---: | ---: | ---: |
+| Whistle Post | — | — | 1 | 0 | 0 | 0 |
+| Depot | yes | yes | 2 | 1 | 1 | 1 |
+| Station | yes | yes | 3 | 2 | 2 | 2 |
+| Terminal | yes | yes | 4 | 3 | 3 | 3 |
+
+Whistle Posts are a fixed supply of 4 outside the deck, and Limits signs a
+supply of 8.
+
+---
+
+## Freight facilities
+
+Each lists the car types it works, which way its traffic flows, and the industries it may not sit
+beside. **Every lockout pair is a producer and the consumer of the same commodity** — you may
+build one end of a chain or the other, never both, which is what forces traffic to run between
+districts rather than in circles inside one. No two of the same industry may share an Office Area,
+and that rule is enforced for every kind rather than repeated in each row.
+
+| Industry | Cars | Flow | Green | Red | Laborers | Locked out with |
+| --- | --- | --- | ---: | ---: | ---: | --- |
+| Freight House | boxcar | both | 1 | 1 | 1 | Grocer's Warehouse |
+| Mine Tipple | hopper | outbound | 1 | 0 | 1 | Power Plant |
+| Refinery | tank | outbound | 1 | 0 | 1 | Power Plant |
+| Power Plant | hopper, tank | inbound | 0 | 1 | 1 | Mine Tipple, Refinery |
+| Packing Sheds | reefer | outbound | 1 | 0 | 1 | Grocer's Warehouse |
+| Grocer's Warehouse | boxcar, reefer | inbound | 0 | 1 | 1 | Packing Sheds, Freight House |
+
+---
+
+## Modifier cards
+
+Each sits beside a host and raises one of its capacities. `office` as a host means any Passenger
+Facility — so a modifier that adds a green slot to an Office adds nothing to a Whistle Post, which
+is not one.
+
+| Modifier | Hosts | +Green | +Red | +Laborers | +Porters |
+| --- | --- | ---: | ---: | ---: | ---: |
+| Waiting area | any Passenger Facility | 1 | — | — | 1 |
+| Restaurant | any Passenger Facility | 1 | — | — | 1 |
+| Hotel | any Passenger Facility | 1 | — | — | 1 |
+| Truck dock | Freight House, Packing Sheds, Grocer's Warehouse | — | 1 | — | — |
+| Railroad Express Agency | Freight House | 1 | — | 1 | — |
+| Forklifts | Freight House, Packing Sheds | 1 | — | 1 | — |
+| Prep Plant | Mine Tipple | 1 | — | 1 | — |
+| Coal Piles | Mine Tipple | 1 | — | 1 | — |
+| Conveyor Belts | Mine Tipple | 1 | — | 1 | — |
+| Pipelines | Refinery | 1 | — | 1 | — |
+| Oil Depot | Refinery | 1 | — | 1 | — |
+| Viscosity breakers | Refinery | 1 | — | 1 | — |
+| Transmission lines | Power Plant | — | — | 1 | — |
+| Rotary Dumps | Power Plant | — | — | 1 | — |
+| Steam Turbines | Power Plant | — | — | 1 | — |
+| Ice House | Packing Sheds, Grocer's Warehouse | 1 | — | 1 | — |
+| Local small groceries | Grocer's Warehouse | — | — | 1 | — |
+
+---
+
+## Track cards
+
+Track is **in the Home Office deck** and is drawn and played like any other card — not a separate
+per-player supply. Operational Rail is the flag that says a train may stop on the card; a turnout
+may be run through but not stopped on.
+
+| Track | Geometry | Hand | Operational rail | Move cost | Dealt |
+| --- | --- | --- | :---: | ---: | :---: |
+| Straight track | straight | none | yes | 1 | yes |
+| Curved track (right) | curved | right | yes | 1 | yes |
+| Curved track (left) | curved | left | yes | 1 | yes |
+| Sharp Curved Track (right) | sharpCurved | right | yes | 2 | no |
+| Sharp Curved Track (left) | sharpCurved | left | yes | 2 | no |
+| Turnout (right) | turnout | right | — | 1 | yes |
+| Turnout (left) | turnout | left | — | 1 | yes |
+
+A row marked "no" is a shape the engine understands but the deck does not currently print.
+
+---
+
+## Enhancements
+
+The column that only the implementation can fill in: **whether the printed effect actually
+resolves yet.** `live` is read during play; `dormantSolo` is implemented at the point of attack
+but the attack is an opponent-directed card held out of every deck, so nothing reaches it in a
+solitaire game; `unbuilt` means the effect is recorded and nothing reads it. A transcription
+cannot carry this column, which is the argument for generating the page rather than writing it.
+
+| Enhancement | Placement | Requires | Effect resolves |
+| --- | --- | --- | :---: |
+| Interlocking | runningTrackStraight | — | **live** |
+| Facing Point Locks | onCard | interlocking in the district | **dormantSolo** |
+| Yard office | secondaryTrackStraight | — | **live** |
+| Small yard | secondaryTrackStraight | — | **live** |
+| Water column | runningTrackStraight | — | **dormantSolo** |
+| Overpass | onCard | — | **unbuilt** |
+| Telegraph | runningTrackStraight | — | **live** |
+| Telephone | onCard | telegraph on the same card | **live** |
+| Radio | onCard | telephone on the same card | **live** |
+| ABS Signals | mainlineCard | — | **live** |
+
+---
+
+## Opponent-directed cards, and what answers them
+
+**None of these is dealt in any deck today.** A card that can only be played at another player
+has no legal target in a solitaire game, and a defence with nothing to defend against is as dead
+a draw as the attack — so both halves are held out until the attacks are implemented. They are
+listed because they are the design, and because what a defence answers is the only record of why
+it exists.
+
+### Action cards — opponent-directed
+
+| Card | Played on | Effect | Answers |
+| --- | --- | --- | --- |
+| Derail | a moving train in the Local Phase | That train must stop for the remainder of the turn. | — |
+| Broken coupler | a moving train in the Mainline Phase | That train must stop and not move. | — |
+| Railroad crossing | any Secondary Track Straight | May not be used as a stop point for switching. May not become an Industry. | — |
+| Per Diem inventory | another player | Lose one point per 2 empty cars on Secondary Tracks. | — |
+| Demurrage charge | another player | Lose one point per 2 loaded freight cars on Secondary Tracks. | — |
+| Customer complaints | another player | Lose one point per 2 coaches in loading boxes. | — |
+| Vandalism | another player | A train passing a Hobo Jungle has a boxcar looted (converted to empty). | — |
+| Hotbox | another player | A train just arrived must set one car (chooser’s pick) onto Secondary Track until it departs. | — |
+| Outlawed | another player | A train just arrived may not depart for one turn — the crew’s hours have expired. | — |
+
+### Space-use cards — opponent-directed
+
+| Card | Played on | Effect | Answers |
+| --- | --- | --- | --- |
+| Bean house | adjacent to any straight, curve, turnout, Limit | Burns tablespace. | — |
+| Flop house | adjacent to any straight, curve, turnout | Burns tablespace. | — |
+| Watertower | adjacent to any straight, turnout on Running Track | Burns tablespace. | — |
+| Hobo Jungle | adjacent to any straight, turnout, Limit on Running Track | Burns tablespace. Vandalism can loot a boxcar passing it. | — |
+| Section House | adjacent to any straight, curve, turnout | Burns tablespace. | — |
+| City blocks | adjacent to any straight, curve, turnout, Limit | Burns tablespace. | — |
+| Engine Shops | adjacent to any straight, curve, turnout | Burns tablespace. | — |
+| Tenderloin District | adjacent to any straight, curve, turnout, Limit | Burns tablespace. | — |
+| Engineer cemetery | adjacent to any straight, curve, turnout, Limit | Burns tablespace. | — |
+
+### Maneuver cards
+
+| Card | Played on | Effect | Answers |
+| --- | --- | --- | --- |
+| Red Flags | any time | A stopped train is prevented from being hit; the approaching train is prevented from moving. | — |
+| Flying Switch | any time | Break a cut of cars away from behind the engine and roll them into an industry. | — |
+| Poling | any time | TBD in the source. | — |
+
+Mainline modifier cards, for completeness — these ARE dealt:
+
+| Card | Played on | Effect | Answers |
+| --- | --- | --- | --- |
+| Brakeman | a GRADE Mainline card | Faster passage downhill. | — |
+| Airbrakes | a GRADE Mainline card | Faster passage downhill. Brakeman must be in effect. | — |
+| Helpers | a GRADE Mainline card | Faster passage uphill. | — |
+| Realignment | a Mainline card | Convert one Mainline type to another. Not while a train is on it. | — |
+| Facing Point Locks | adjacent to Interlocking | Prevents Derail being played on you. | Derail |
+

docs/rules/card-reference.md

@@ -4,6 +4,11 @@
 > 2026-07-30 in `docs/Deck cards2.xlsx`, `Trains3.pdf` and `Mainline Cards.pdf`, and is transcribed
 > in `src/engine/content.ts`. See [`implications.md`](implications.md) for the full comparison.
 >
+> **For what the cards say today, read [`as-built.md`](as-built.md)** — generated from
+> `content.ts` and checked against it by the test suite, so it cannot fall behind the way this file
+> did. For several releases `content.ts` named *this* page as the current reference while the banner
+> here said otherwise, and a reader following the code landed on the v0.4.5 deck.
+>
 > Kept for the reasoning it records — the economy analysis in §7 was how we knew what questions to
 > ask the design. **Do not use its numbers.**
 

docs/rules/implications.md

@@ -40,8 +40,9 @@ All nine answers are implemented, **170 tests passing**:
 
 | Answer | Implemented as |
 | --- | --- |
-| Q1 crossing time | `crossingStages()` — a 60 card takes 1 Stage, a 30 takes 2. Mainline nodes now carry a **terrain type** dealt at setup, and trains count down Stages instead of stepping through regions. The `Region` model is gone. |
-| Q2 Fast/Slow | Slow adds one Stage to every card. Hilly reads the consist (any coach = passenger). |
+| ~~Q1 crossing time~~ | **SUPERSEDED 2026-08-26 — see Q1a below.** Was: a 60 card takes 1 Stage, a 30 takes 2. |
+| ~~Q2 Fast/Slow~~ | **SUPERSEDED 2026-08-26 — see Q1a below.** Was: Slow adds one Stage to every card; Hilly reads the consist. |
+| Q1a crossing time | `crossingStages()` — a card costs one Stage per **region printed on it**, and where a train STARTS is what varies. Plains 1, Double Track 1, Trestle 1, Curves 2, Tunnel 2, Heavy Grade 3. The printed mph are scenery. Fast/Slow is read on Hilly and nowhere else. |
 | Q3 Expedite | An expedited train departs the Stage it arrives — it gets a second `moveTrain` in the same Mainline Phase, still subject to §8.1 clearance. |
 | Q4 Lockouts | `isLockedOut()` rejects the placement with `FACILITY_LOCKED`. |
 | Q5 Run-around | Nothing to do — reachability is geometric, so a built bypass already works. |
@@ -76,6 +77,39 @@ Crossing time never falls below one Stage — a train cannot cross in no time.
 there is nothing to build. A test asserts it remains TBD, to stop anyone "fixing" it by inventing
 an effect; a silent no-op would be worse than a rejection.
 
+**Q1a, answered by RAR 2026-08-26 (Gitea#3), and it replaces Q1 and Q2 together.**
+
+> "Ignore speed signs. They are just graphics. Regions shown on cards indicate how many stages it
+> takes to cross. Plains is 1. Double track is 1, tunnel is 2, curves is 2, heavy grade is 3 unless
+> you have help… Some cards say fast / slow. This is an indication that if on the train card, the
+> train is listed as fast or slow, that's starting position / how many stages it takes to traverse
+> the card. Fast / Slow does not apply to every card — just those that say fast / slow on them.
+> Currently this is only hilly."
+
+What this changes, against what was recorded before:
+
+- **The printed 60/30 mean nothing.** Q1 read them as crossing time; they are ambiance.
+- **Fast/Slow is not a global penalty.** Q2 added a Stage to every card for a Slow train, which is
+  what made a Slow train take two Stages to clear Double Track — the report that opened the issue.
+  It now applies on Hilly alone, where a fast train starts in the second region.
+- **Hilly no longer reads the consist.** RAR: "I notice that you are basing stages in mainline cards
+  off coach/non-coach. Actually, all trains are rated as FAST and SLOW."
+- **Heavy Grade is three regions, not two**, and the modifiers move the START rather than cutting the
+  clock: Helpers start an uphill train a region on, Brakeman a downhill one, Airbrakes another again.
+- **The Uncontrolled Siding and the Interchange print a back region** that is not part of the road. A
+  train running through starts past it; a train arriving to find the siding occupied takes it and
+  runs a region behind, which is what keeps the two apart, and an Extra beginning its run at an
+  Interchange starts there too.
+- **ABS holds a train off the card** rather than letting it collide, on any Mainline card.
+
+Measured consequence, replacing the one recorded under Q2: on a **3-player Division the Mainline
+cards themselves now cost a fast train ~5.6 Stages and a slow train ~6.0**, against ~5.4 and ~9.4
+before. Fast traffic is unchanged; **slow traffic is about a third quicker**, and the Fast/Slow gap
+across a whole Division collapses from roughly four Stages to less than one. The Q2 note that "every
+Slow train is still on the road when the next Day begins, holding its Crew Tray" no longer holds, so
+the `players + 3` tray count is due a re-examination — RAR's own closing worry: "been worried about
+the time it takes to cross the division. More thunking on this is needed."
+
 **Q11, answered from the source.** The Heavy Grade card prints **"(Up)"** and **"Player sets
 orientation"**, so which way it climbs is a property of the placed card, not a fixed compass
 direction. `DivisionNode.gradeUp` records the direction a train travels when **climbing**; a train

package.json

@@ -1,6 +1,6 @@
 {
   "name": "station-master",
-  "version": "0.7.1",
+  "version": "0.8.0.13",
   "private": true,
   "type": "module",
   "description": "Station Master — a railroad operations game",
@@ -9,11 +9,14 @@
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "pretest": "node scripts/build-web.ts",
-    "test": "node --test test/*.test.ts test/**/*.test.ts",
+    "pretest": "tsc --noEmit && node scripts/build-web.ts",
+    "test": "node --test $(ls test/*.test.ts test/**/*.test.ts | grep -v '^test/sim.test.ts$')",
+    "pretest:sim": "tsc --noEmit",
+    "test:sim": "node --test test/sim.test.ts",
     "build:web": "node scripts/build-web.ts",
     "serve:web": "node scripts/build-web.ts && npx --yes http-server dist -p 8080 -c-1",
-    "deploy:web": "node scripts/deploy-web.ts"
+    "deploy:web": "node scripts/deploy-web.ts",
+    "build:cards": "node scripts/build-card-reference.ts"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",

scripts/build-card-reference.ts

@@ -0,0 +1,268 @@
+/**
+ * Generate `docs/rules/as-built.md` — what the cards say, as the code actually has them.
+ *
+ * WHY THIS IS GENERATED RATHER THAN WRITTEN.
+ *
+ * Every other file in `docs/rules/` is a historical record and says so: `rules-v0.1.md` is a
+ * faithful transcription of the prototype PDFs, `open-questions.md` is the gap tracker,
+ * `rules-v0.2.md` and `card-reference.md` both carry SUPERSEDED banners. None of them describes the
+ * game as built, and none of them should be edited to — the record is worth more intact than
+ * patched.
+ *
+ * So there was no current reference at all, and `content.ts` spent several releases pointing at
+ * `card-reference.md` as "the place that now carries what the cards say" while that file's own
+ * banner said "do not use its numbers". A reader following the code's advice landed on the v0.4.5
+ * deck: twelve numbered trains, "3 / 4 Mail-Express, 3 coaches", against a `content.ts` whose train
+ * 3 is the Express with two freight cars and a per-location freight rule.
+ *
+ * A HAND-WRITTEN REPLACEMENT WOULD HAVE DRIFTED THE SAME WAY, and for the same reason: nothing
+ * fails when a table falls behind a constant. So the reference is emitted from the same exported
+ * catalogues the engine instantiates from, and `test/card-reference.test.ts` re-runs this generator
+ * and asserts the checked-in file matches byte for byte. Change a card face and the suite goes red
+ * until the doc is regenerated — which is the only mechanism this project has found that keeps a
+ * document honest.
+ *
+ * `npm run build:cards` writes it. Nothing at runtime reads it; it is for people.
+ */
+
+import { writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+  ACTION_CARDS, ALL_TRAINS, ENHANCEMENT_CARDS, ENHANCEMENT_RULES, EXTRA_TRAINS, INDUSTRY_PROFILES,
+  LIMITS_SUPPLY, MAINLINE_DECK, MAINLINE_MODIFIER_CARDS, MAINLINE_PROFILES, MANEUVER_CARDS,
+  MODIFIER_PROFILES, OFFICE_PROFILES, SPACE_USE_CARDS, TIMETABLED_TRAINS, TRACK_CARDS,
+  WHISTLE_POST_SUPPLY, consistSize, isOpponentOnly, mainlineDescription,
+} from '../src/engine/content.ts';
+import type { ConsistSpec, SimpleCard, TrainProfile, TrainRules } from '../src/engine/content.ts';
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..');
+
+/** Title Case a camelCase key, so `oneFreightPerLocation` reads as a rule rather than an identifier. */
+const words = (k: string): string => k.replace(/([A-Z])/g, ' $1').toLowerCase().trim();
+
+const consistOf = (c: ConsistSpec): string => {
+  const parts: string[] = [];
+  if (c.freight > 0) {
+    const kinds = c.freightTypes ? c.freightTypes.join(' or ') : 'freight';
+    parts.push(`${c.freight} ${kinds}${c.freight === 1 ? '' : c.freightTypes ? 's' : ''}`);
+  }
+  if (c.coach > 0) parts.push(`${c.coach} coach${c.coach === 1 ? '' : 'es'}`);
+  if (c.caboose > 0) parts.push(`${c.caboose} caboose`);
+  if (!parts.length) return 'engine only';
+  const n = consistSize(c);
+  // "Empties only" qualifies the whole consist rather than adding to it, so it reads after the count.
+  return `${parts.join(' + ')} (${n} piece${n === 1 ? '' : 's'})${c.emptiesOnly ? ', empties only' : ''}`;
+};
+
+const rulesOf = (r: TrainRules): string => {
+  const out: string[] = [];
+  for (const [k, v] of Object.entries(r)) {
+    if (k === 'note' || v === false || v === undefined) continue;
+    out.push(words(k));
+  }
+  if (typeof r.note === 'string') out.push(`*"${r.note}"*`);
+  return out.length ? out.join('; ') : '—';
+};
+
+const trainRow = (t: TrainProfile): string =>
+  `| ${t.isExtra ? 'X' : ''}${t.number} | ${t.name} | ${t.speed} | ` +
+  `${t.direction === 'playerChoice' ? "player's choice" : t.direction} | ${consistOf(t.consist)} | ${rulesOf(t.rules)} |`;
+
+const lines: string[] = [];
+const w = (s = ''): void => void lines.push(s);
+
+w('# Station Master — the cards as built');
+w();
+w('> **Generated from `src/engine/content.ts` by `scripts/build-card-reference.ts`. Do not edit by');
+w('> hand** — `npm run build:cards` rewrites it, and `test/card-reference.test.ts` fails if this file');
+w('> and the code disagree.');
+w();
+w('This is the one file in `docs/rules/` that describes the game **as it currently is**. Everything');
+w('else in this directory is a historical record and marked as such: [`rules-v0.1.md`](rules-v0.1.md)');
+w('transcribes the prototype PDFs, [`open-questions.md`](open-questions.md) tracks how the gaps in');
+w('them were decided, and [`rules-v0.2.md`](rules-v0.2.md) and');
+w('[`card-reference.md`](card-reference.md) both describe superseded card sets. Read those for the');
+w('reasoning; read this for the numbers.');
+w();
+w('The engine instantiates from the same constants this is emitted from, so a disagreement between');
+w('this page and the game is a bug in the generator, not a stale table.');
+w();
+w('**No card counts appear here, deliberately** (TODO #15a, Jesse 2026-08-22): the counts move with');
+w('play balance, so a document that prints them is answering a question that will have a different');
+w('answer next retune. Where a count matters it is a yes/no — whether the deck deals the card at');
+w('all — which is a fact about the design rather than about the current tuning.');
+w();
+w('---');
+w();
+
+w('## Trains');
+w();
+w(`${TIMETABLED_TRAINS.length} timetabled and ${EXTRA_TRAINS.length} Extras, ${ALL_TRAINS.length} in all.`);
+w('Odd numbers run west, even run east; a pair shares a class and is the same card face in two');
+w('directions. A Crew Tray holds four pieces and a caboose counts toward the four, which is why no');
+w('train with a caboose carries more than three revenue cars.');
+w();
+w('### Timetabled');
+w();
+w('| # | Class | Speed | Runs | Consist | Printed rules |');
+w('| ---: | --- | --- | --- | --- | --- |');
+for (const t of TIMETABLED_TRAINS) w(trainRow(t));
+w();
+w('### Extras');
+w();
+w('| # | Class | Speed | Runs | Consist | Printed rules |');
+w('| ---: | --- | --- | --- | --- | --- |');
+for (const t of EXTRA_TRAINS) w(trainRow(t));
+w();
+w('---');
+w();
+
+w('## Mainline cards');
+w();
+w('A card is divided into **regions**, and a train advances one region per Stage — so the regions a');
+w('card prints are what it costs to cross. Where a train *enters* is what the rules move: a fast');
+w('train on Hilly, a Heavy Grade with Helpers, or a card whose back region is a siding rather than');
+w('part of the road all change the entry point rather than the card\'s length.');
+w();
+w('| Card | Regions | Default entry | Fast / slow entry | Trains may pass | Sorts cars |');
+w('| --- | ---: | ---: | --- | :---: | :---: |');
+for (const m of MAINLINE_PROFILES) {
+  const ss = m.speedStarts ? `${m.speedStarts.fast} / ${m.speedStarts.slow}` : '—';
+  w(`| ${m.name} | ${m.regions} | ${m.defaultStart} | ${ss} | ${m.trainsMayPass ? 'yes' : '—'} | ${m.sortsCars ? 'yes' : '—'} |`);
+}
+w();
+w(`The Mainline deck is ${MAINLINE_DECK.length} cards; the two Division Points are the fixed ends of`);
+w('the Division and are not dealt. What each card does, in the words the game uses on screen:');
+w();
+for (const m of MAINLINE_PROFILES) w(`- **${m.name}** — ${mainlineDescription(m.kind)}`);
+w();
+w('---');
+w();
+
+w('## Office cards');
+w();
+w('Upgrades are strictly sequential — no skipping a tier — so a Terminal needs all three cards in');
+w('order. Green slots are outbound passengers, red are inbound, and the design gives slots **equal**');
+w('to Porters rather than one more.');
+w();
+w('| Office | Control point | Passenger facility | A/D tracks | Porters | Green | Red |');
+w('| --- | :---: | :---: | ---: | ---: | ---: | ---: |');
+for (const o of OFFICE_PROFILES) {
+  w(`| ${o.name} | ${o.isControlPoint ? 'yes' : '—'} | ${o.isPassengerFacility ? 'yes' : '—'} | ` +
+    `${o.adTracks} | ${o.porters} | ${o.passengerOut} | ${o.passengerIn} |`);
+}
+w();
+w(`Whistle Posts are a fixed supply of ${WHISTLE_POST_SUPPLY} outside the deck, and Limits signs a`);
+w(`supply of ${LIMITS_SUPPLY}.`);
+w();
+w('---');
+w();
+
+w('## Freight facilities');
+w();
+w('Each lists the car types it works, which way its traffic flows, and the industries it may not sit');
+w('beside. **Every lockout pair is a producer and the consumer of the same commodity** — you may');
+w('build one end of a chain or the other, never both, which is what forces traffic to run between');
+w('districts rather than in circles inside one. No two of the same industry may share an Office Area,');
+w('and that rule is enforced for every kind rather than repeated in each row.');
+w();
+w('| Industry | Cars | Flow | Green | Red | Laborers | Locked out with |');
+w('| --- | --- | --- | ---: | ---: | ---: | --- |');
+for (const f of INDUSTRY_PROFILES) {
+  const lo = f.lockouts.length
+    ? f.lockouts.map((k) => INDUSTRY_PROFILES.find((p) => p.kind === k)?.name ?? k).join(', ')
+    : '—';
+  w(`| ${f.name} | ${f.carTypes.join(', ')} | ${f.flow} | ${f.baseOut} | ${f.baseIn} | ${f.baseLoaders} | ${lo} |`);
+}
+w();
+w('---');
+w();
+
+w('## Modifier cards');
+w();
+w('Each sits beside a host and raises one of its capacities. `office` as a host means any Passenger');
+w('Facility — so a modifier that adds a green slot to an Office adds nothing to a Whistle Post, which');
+w('is not one.');
+w();
+w('| Modifier | Hosts | +Green | +Red | +Laborers | +Porters |');
+w('| --- | --- | ---: | ---: | ---: | ---: |');
+for (const m of MODIFIER_PROFILES) {
+  const hosts = m.hosts
+    .map((h) => (h === 'office' ? 'any Passenger Facility' : INDUSTRY_PROFILES.find((p) => p.kind === h)?.name ?? h))
+    .join(', ');
+  w(`| ${m.name} | ${hosts} | ${m.addOut || '—'} | ${m.addIn || '—'} | ${m.addLoaders || '—'} | ${m.addPorters || '—'} |`);
+}
+w();
+w('---');
+w();
+
+w('## Track cards');
+w();
+w('Track is **in the Home Office deck** and is drawn and played like any other card — not a separate');
+w('per-player supply. Operational Rail is the flag that says a train may stop on the card; a turnout');
+w('may be run through but not stopped on.');
+w();
+w('| Track | Geometry | Hand | Operational rail | Move cost | Dealt |');
+w('| --- | --- | --- | :---: | ---: | :---: |');
+for (const t of TRACK_CARDS) {
+  w(`| ${t.name} | ${t.geometry} | ${t.hand} | ${t.isOperationalRail ? 'yes' : '—'} | ${t.moveCost} | ${t.copiesInDeck ? 'yes' : 'no'} |`);
+}
+w();
+w('A row marked "no" is a shape the engine understands but the deck does not currently print.');
+w();
+w('---');
+w();
+
+w('## Enhancements');
+w();
+w('The column that only the implementation can fill in: **whether the printed effect actually');
+w('resolves yet.** `live` is read during play; `dormantSolo` is implemented at the point of attack');
+w('but the attack is an opponent-directed card held out of every deck, so nothing reaches it in a');
+w('solitaire game; `unbuilt` means the effect is recorded and nothing reads it. A transcription');
+w('cannot carry this column, which is the argument for generating the page rather than writing it.');
+w();
+w('| Enhancement | Placement | Requires | Effect resolves |');
+w('| --- | --- | --- | :---: |');
+for (const r of ENHANCEMENT_RULES) {
+  const card = ENHANCEMENT_CARDS.find((c) => c.key === r.key);
+  const needs = r.requiresOnSameCard
+    ? `${r.requiresOnSameCard} on the same card`
+    : r.requiresInDistrict
+      ? `${r.requiresInDistrict} in the district`
+      : '—';
+  w(`| ${card?.name ?? r.key} | ${r.placement} | ${needs} | **${r.effect}** |`);
+}
+w();
+w('---');
+w();
+
+w('## Opponent-directed cards, and what answers them');
+w();
+w('**None of these is dealt in any deck today.** A card that can only be played at another player');
+w('has no legal target in a solitaire game, and a defence with nothing to defend against is as dead');
+w('a draw as the attack — so both halves are held out until the attacks are implemented. They are');
+w('listed because they are the design, and because what a defence answers is the only record of why');
+w('it exists.');
+w();
+const pvp = (title: string, cards: readonly SimpleCard[], category: string): void => {
+  w(`### ${title}${isOpponentOnly(category) ? ' — opponent-directed' : ''}`);
+  w();
+  w('| Card | Played on | Effect | Answers |');
+  w('| --- | --- | --- | --- |');
+  for (const c of cards) w(`| ${c.name} | ${c.placement} | ${c.effect} | ${c.answers ?? '—'} |`);
+  w();
+};
+pvp('Action cards', ACTION_CARDS, 'action');
+pvp('Space-use cards', SPACE_USE_CARDS, 'spaceUse');
+pvp('Maneuver cards', MANEUVER_CARDS, 'maneuver');
+w('Mainline modifier cards, for completeness — these ARE dealt:');
+w();
+w('| Card | Played on | Effect | Answers |');
+w('| --- | --- | --- | --- |');
+for (const c of MAINLINE_MODIFIER_CARDS) w(`| ${c.name} | ${c.placement} | ${c.effect} | ${c.answers ?? '—'} |`);
+w();
+
+writeFileSync(join(root, 'docs/rules/as-built.md'), `${lines.join('\n')}\n`);
+console.log(`built -> docs/rules/as-built.md (${lines.length} lines)`);

scripts/build-web.ts

@@ -60,7 +60,27 @@ execFileSync(
  */
 function buildStamp(): string {
   const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')) as { version: string };
-  let git = 'nogit';
+  /**
+   * THE FALLBACK HAS TO BE UNIQUE PER BUILD, because this string is also the cache-bust key.
+   *
+   * It used to be the literal `nogit`, which is exactly what the `.s9pk` build produces — the
+   * Dockerfile copies the working tree in without `.git`, so `git rev-parse` fails there every time.
+   * Every packaged release therefore published `?v=nogit`, byte-identical to the release before it,
+   * and a returning player's browser had no reason to refetch a single module. v0.7.5's setup screen
+   * and v0.7.6's fix to it both shipped correctly to `phoenix.local` and neither reached the browser
+   * that asked for them (Jesse, twice, 2026-08-29 — "setup did not work").
+   *
+   * A marker plus the build's own timestamp is always distinct, needs nothing from the environment,
+   * and stays honest: two builds of the same commit ARE two deploys, and a cache key that says so
+   * costs one refetch, while one that lies costs a release nobody receives.
+   *
+   * NOT THE VERSION, which is what this used to lead with. The stamp below already begins with
+   * `v${pkg.version}`, so on exactly the builds that take this path — every `.s9pk`, which has no
+   * `.git` — the header read "v0.8.0.10 · 0.8.0.10-mfq2p1 · …" and the version appeared twice
+   * (Jesse, playtest 2026-09-16). The timestamp alone carries the uniqueness; the version is
+   * already said once, properly, at the front.
+   */
+  let git = `nogit-${Date.now().toString(36)}`;
   try {
     const sha = execFileSync('git', ['rev-parse', '--short', 'HEAD'], { cwd: root })
       .toString()

src/engine/advance.ts

@@ -23,23 +23,25 @@ import {
   enhancementRule,
   crossingStages,
   trainProfile,
+  startRegion,
   MOVES_PER_LOCAL_OPS,
   MOVES_PER_LOCAL_OPS_NIGHT,
   STAGES_PER_DAY,
   STAGES_PER_SHIFT,
   houseRules,
   officeProfile,
-  REGIONS_PER_MAINLINE_CARD,
   mainlineProfile,
 } from './content.ts';
-import type { Direction } from './content.ts';
+import type { Direction, MainlineEntry, MainlineKind } from './content.ts';
 import type { GameEvent } from './events.ts';
 // `trainNeedingCars` lives in apply.ts beside `check`'s copy of the same question, so the phase and
 // the legality test cannot disagree about which train is being assembled.
-import { areaAtSeat, areaOf, trainNeedingCars } from './apply.ts';
+import { areaAtSeat, areaOf, occupancyFor, trainNeedingCars } from './apply.ts';
 import { legalActions } from './legal.ts';
-import type { CrewTray, DivisionNode, GameState, PlayerIndex, RollingStock, SeatIndex, TrayId } from './state.ts';
-import { coordKey, freshTurns, playerAtSeat, playerLeftOf, pooled, subdivisions, totalRevenue, turnOf } from './state.ts';
+import type { CrewTray, DivisionNode, GameState, GridCoord, Outcome, PlayerIndex, RollingStock, SeatIndex, TrayId } from './state.ts';
+import { cloneTally, coordKey, freshTurns, isExtendable, playerAtSeat, playerLeftOf, pooled, railFacingOf, subdivisions, totalRevenue, turnOf } from './state.ts';
+import { reachableDestinations } from './track.ts';
+import { tallyEvent } from './tally.ts';
 
 export type AdvanceResult = {
   events: GameEvent[];
@@ -49,6 +51,31 @@ export type AdvanceResult = {
 
 const NIGHT_STAGES = new Set([1, 2, 3, 11, 12]);
 
+/**
+ * IS EVERY CAR ON THIS TRAIN LOADED? (Gitea#13)
+ *
+ * "You only get credit for a circus or campaign train (one point per stop) if you have it fully
+ * loaded. Not much of a circus if all the cars are empty."
+ *
+ * A COACH COUNTS AS LOADED WHEN IT IS OCCUPIED, which is what makes this the right test for the
+ * Campaign Train: X17 carries one coach and no freight, so "fully loaded" is precisely "the
+ * candidate is aboard" (Jesse's ruling, 2026-08-29). The engine already models an occupied coach
+ * as `loaded`, so no second notion is introduced here.
+ *
+ * A CABOOSE IS EXEMPT, and it costs nothing to say so: every caboose in `ROLLING_STOCK_SUPPLY` is
+ * minted `loaded: true` — there is no empty one — so including it would change no outcome today.
+ * It is excluded anyway because a caboose is crew space rather than payload, and a supply table
+ * that grew an empty caboose should not silently start voiding circus points.
+ *
+ * AN EMPTY TRAIN IS NOT FULLY LOADED. A Circus that departed short and carries nothing at all earns
+ * nothing: `every` on an empty list is vacuously true, which would pay the emptiest train of the
+ * lot, so the length is tested first.
+ */
+function fullyLoaded(tray: CrewTray): boolean {
+  const payload = tray.consist.filter((c) => c.type !== 'caboose');
+  return payload.length > 0 && payload.every((c) => c.loaded);
+}
+
 function movesForStage(s: GameState): number {
   return s.config.optionalRules.reducedVisibility && NIGHT_STAGES.has(s.clock.stage)
     ? MOVES_PER_LOCAL_OPS_NIGHT
@@ -67,14 +94,74 @@ function nodeIndexOfOffice(s: GameState, seat: SeatIndex): number {
 
 const step = (d: Direction): number => (d === 'east' ? 1 : -1);
 
+/** The Division node a train is standing on — its Office, its Mainline card, or its Division Point. */
+function nodeIndexOfTray(s: GameState, tray: CrewTray): number | null {
+  const at = tray.position;
+  if (at.at === 'grid') return nodeIndexOfOffice(s, at.seat);
+  if (at.at === 'mainline') return at.index;
+  if (at.at === 'divisionPoint') {
+    const side = at.side;
+    return s.division.nodes.findIndex((n) => n.kind === 'divisionPoint' && n.side === side);
+  }
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // advance
 // ---------------------------------------------------------------------------
 
+/**
+ * The phase driver, plus the two things that have to happen around EVERY batch of events it
+ * produces. `advanceInner` below is the driver itself, unchanged.
+ *
+ * ORDER IS THE WHOLE POINT of this wrapper, and it is the one subtle thing in Gitea#16.
+ * `checkVictory` runs deep inside the driver, so if the official result froze a copy of the Tally
+ * from in there it would freeze it BEFORE this batch's events had been counted — and the batch that
+ * ends a game is exactly the one carrying the last Day's work. So the Tally is folded first and the
+ * result frozen second, both out here where the whole batch is in hand.
+ *
+ * Safe because both endings `return` the moment they fire: no scoring event is emitted after a game
+ * has ended within a single batch, so "everything in this batch" and "everything up to the ending"
+ * are the same set of events. `test/tally.test.ts` pins that.
+ */
 export function advance(s: GameState): AdvanceResult {
+  const r = advanceInner(s);
+  for (const e of r.events) tallyEvent(s, e);
+  freezeOfficial(s);
+  return r;
+}
+
+/**
+ * THE OFFICIAL RESULT, written once (Gitea#11).
+ *
+ * "The winner is based upon the original game length" — so the first ending is the real one and
+ * every later evaluation is informational. Idempotent by construction: it does nothing once
+ * `official` is set, which is what stops an extended Day, or a §3.4 breach during one, from
+ * rewriting a recorded win.
+ */
+function freezeOfficial(s: GameState): void {
+  if (s.official !== null || s.outcome === null) return;
+  s.official = {
+    day: s.config.days,
+    outcome: { ...s.outcome },
+    revenues: s.players.map((p) => p.revenue),
+    collisionsTotal: s.collisionsTotal,
+    tally: cloneTally(s.tally),
+  };
+}
+
+function advanceInner(s: GameState): AdvanceResult {
   const events: GameEvent[] = [];
   if (s.status === 'finished') return { events, needsInput: false };
 
+  /**
+   * §3.3 (Gitea#11) — the timetable has run out and the table is being asked whether to play one
+   * more Day. Nothing runs itself while that question is open, so this is `needsInput` rather than
+   * an ending: `pump` stops here, the server keeps the game in memory, and the only intent the
+   * rules will take is `game.extend`.
+   */
+  if (s.status === 'awaitingExtension') return { events, needsInput: true };
+
   // The Superintendent's clearance ruling interrupts the Mainline Phase (§8.1).
   if (s.clock.pendingDecision !== null) return { events, needsInput: true };
 
@@ -371,33 +458,45 @@ function mainlinePhase(s: GameState, events: GameEvent[]): AdvanceResult {
     const where = tray.position;
     const moved = moveTrain(s, id, tray, events);
     /**
-     * X18 CIRCUS TRAIN — "one turn stopped on any track (circus set-up) earns 1 point".
+     * X18 CIRCUS / X17 CAMPAIGN — a Stage spent set up in somebody's Office Area earns a point.
      *
-     * The flag was declared on the profile and read NOWHERE, so the one card in the deck that pays
+     * The flag was declared on the profile and read NOWHERE, so the one card in the deck that paid
      * for standing still paid nothing: reported from a playtest where TX18 sat on a siding for a
-     * full Stage and no point arrived. Claimed once — an Extra runs once and is gone.
+     * full Stage and no point arrived.
+     *
+     * ONCE PER OFFICE AREA (Gitea#13, Jesse 2026-08-29): "once per stop in an office area. In a
+     * multiplayer game, each player could score if the circus stops in their area." So a Circus
+     * touring three districts is paid three times and one parked in the same district all game is
+     * paid once, which `stopPointSeats` records per seat.
+     *
+     * ONLY IN AN OFFICE AREA. It used to pay for standing on the Mainline or at a Division Point
+     * too, and misattributed both: `playerAtSeat` needs a seat, and off the grid there is none, so
+     * the fallback handed the point to PLAYER 0 wherever the train happened to be. Scoping the rule
+     * to Office Areas is what Jesse's ruling says and it removes that bug rather than patching it.
+     *
+     * FULLY LOADED, or nothing. "Not much of a circus if all the cars are empty" — see
+     * `fullyLoaded` below for what that means for a train whose only car is a coach.
      *
      * "Stopped" is measured against the Mainline Phase: the train attempted to move and stayed where
      * it was. A train that is still in the district when the phase runs has not moved either, which
      * is the circus setting up on a siding rather than crossing the Division.
      */
-    if (!tray.stopPointClaimed && trainProfile(tray.trainNumber ?? 0, tray.trainIsExtra)?.rules.stopEarnsPoint) {
+    if (trainProfile(tray.trainNumber ?? 0, tray.trainIsExtra)?.rules.stopEarnsPoint) {
       const stillThere =
         tray.position.at === where.at &&
         (tray.position.at !== 'mainline' || where.at !== 'mainline' || tray.position.index === where.index) &&
         (tray.position.at !== 'grid' ||
           where.at !== 'grid' ||
           (tray.position.coord.row === where.coord.row && tray.position.coord.col === where.coord.col));
-      if (stillThere) {
-        tray.stopPointClaimed = true;
+      // Bound as one value so the grid case narrows: `tray.position` is a union, and testing a
+      // `seat` extracted from it does not tell the compiler which member it came from.
+      const at = tray.position.at === 'grid' ? tray.position : null;
+      const alreadyPaidHere = at !== null && (tray.stopPointSeats ?? []).includes(at.seat);
+      if (stillThere && at !== null && !alreadyPaidHere && fullyLoaded(tray)) {
+        tray.stopPointSeats = [...(tray.stopPointSeats ?? []), at.seat];
         // The point goes to whoever is SITTING in the district it stopped in.
-        const owner = tray.position.at === 'grid' ? playerAtSeat(s, tray.position.seat) : 0;
-        const label =
-          tray.position.at === 'grid'
-            ? `(${tray.position.coord.col},${tray.position.coord.row})`
-            : tray.position.at === 'mainline'
-              ? `Mainline card ${tray.position.index}`
-              : `the ${tray.position.side} Division Point`;
+        const owner = playerAtSeat(s, at.seat);
+        const label = `(${at.coord.col},${at.coord.row})`;
         events.push({ type: 'trainStoodStill', trainNumber: tray.trainNumber ?? 0, where: label });
         const p = s.players[owner];
         if (p) {
@@ -407,7 +506,7 @@ function mainlinePhase(s: GameState, events: GameEvent[]): AdvanceResult {
             player: owner,
             delta: 1,
             total: p.revenue,
-            reason: 'circus set-up — a Stage spent standing still',
+            reason: 'set up in the district — a Stage spent standing still, fully loaded',
           });
         }
       }
@@ -435,8 +534,11 @@ type MoveOutcome = 'moved' | 'held' | 'needsClearance';
  *
  * This is reachable purely through switching. A train arrives made up, and only comes apart because
  * the player took cars onto the nose or picked up a cut in a run-around.
+ *
+ * Exported for the switching planner (`sim/switch-planner.ts`), which has to know whether a plan
+ * leaves a train unable to run — and must ask this rule rather than keep a copy of it.
  */
-function badlyMadeUp(tray: CrewTray): string | null {
+export function badlyMadeUp(tray: CrewTray): string | null {
   const n = tray.consist.length;
   if (n === 0) return null;
   const pulling = tray.engineAt === 0;
@@ -451,6 +553,104 @@ function badlyMadeUp(tray: CrewTray): string | null {
   return caboose === rear ? null : 'not made up — the caboose must be at the rear of the train';
 }
 
+/**
+ * WHICH REGION OF A MAINLINE CARD A TRAIN IS STANDING IN (Gitea#3).
+ *
+ * A card is `regions` boxes wide and a train advances one per Stage, so what it has LEFT to run says
+ * where it is: enter with `regions` still to go and you are at the beginning; enter with one to go
+ * and you are in the last box.
+ *
+ * This used to be derived from a single global `REGIONS_PER_MAINLINE_CARD = 2`, with an entry term
+ * that put a one-Stage train in region 1 of a two-region card — a fast train did not traverse a fast
+ * card, it appeared at the far half of it. Cards carry their own region count now, so the position
+ * is simply the count minus what is left.
+ */
+export function regionOfTransit(card: MainlineKind, stagesRemaining: number): number {
+  const regions = mainlineProfile(card).regions;
+  return Math.min(regions - 1, Math.max(0, regions - stagesRemaining));
+}
+
+/** The entry a train would make onto this card, before occupancy is taken into account. */
+function entryFor(
+  node: Extract<DivisionNode, { kind: 'mainline' }>,
+  tray: CrewTray,
+  startsAtBack = false,
+): MainlineEntry {
+  const profile = trainProfile(tray.trainNumber ?? 0, tray.trainIsExtra);
+  return {
+    trainSpeed: profile?.speed ?? 'slow',
+    direction: tray.direction,
+    gradeUp: node.gradeUp ?? 'east',
+    modifiers: node.modifiers ?? [],
+    ...(startsAtBack ? { startsAtBack: true } : {}),
+  };
+}
+
+/**
+ * THE UNCONTROLLED SIDING RULE (Gitea#3): "if a train already exists when you arrive, you go in the
+ * second stage back — you are in the siding and are one behind the other train. This prevents a
+ * collision, since you are not in same exact location."
+ *
+ * So arriving at an occupied siding is not a collision and not a hold; it is a different, slower
+ * entry. Anywhere else this returns false and the ordinary start applies.
+ */
+function takesTheSiding(node: Extract<DivisionNode, { kind: 'mainline' }>): boolean {
+  return node.card === 'uncontrolledSiding' && node.transits.length > 0;
+}
+
+/**
+ * IS MOVING ONTO THIS CARD A COLLISION? (Gitea#3)
+ *
+ * A card can be ONE region wide — Plains, Double Track and Trestle all are — so a following train
+ * granted clearance arrives in the same region as the train ahead the moment it enters. There was no
+ * test for that at all: the catch-up check lives inside `stagesRemaining > 1`, which a one-Stage
+ * crossing never reaches, so entering behind another train on a Plains was silently free.
+ *
+ * ABS is the card that answers it, in RAR's words: "This is played on a mainline card to prevent
+ * collisions. If a collision would normally occur, the train moving onto the card is instead held
+ * back." Held, not waved through — it tries again next Stage.
+ *
+ * The Uncontrolled Siding never conflicts on entry, because `takesTheSiding` has already moved this
+ * train a region back; that is the whole point of the card.
+ */
+function entryConflict(
+  s: GameState,
+  node: Extract<DivisionNode, { kind: 'mainline' }>,
+  id: TrayId,
+  tray: CrewTray,
+  events: GameEvent[],
+  startsAtBack = false,
+): 'collided' | 'held' | null {
+  if (mainlineProfile(node.card).trainsMayPass) return null;
+  const start = startRegion(node.card, entryFor(node, tray, startsAtBack || takesTheSiding(node)));
+  const ahead = node.transits.find(
+    (t) =>
+      t.tray !== id &&
+      t.direction === tray.direction &&
+      regionOfTransit(node.card, t.stagesRemaining) === start,
+  );
+  if (!ahead) return null;
+
+  /**
+   * A BACKSTOP, not the main path. `evaluateClearance` already refuses to clear a train onto a card
+   * carrying ABS, so in the ordinary run of things nothing reaches here with signals up. It stays
+   * because the two rules answer to different questions — clearance looks at the whole Subdivision,
+   * this looks at one region — and a card that promises no rear-enders should not depend on the
+   * wider check happening to fire first.
+   */
+  if (node.absSignals) {
+    events.push({
+      type: 'trainHeld',
+      trainNumber: tray.trainNumber ?? 0,
+      reason: 'ABS Signals — held short of the train ahead',
+    });
+    return 'held';
+  }
+  // §10 — the Superintendent cleared it into an occupied region, so it is the Superintendent's fault.
+  collide(s, s.clock.superintendent, [id, ahead.tray], events, 'ran into the train ahead', 'the Mainline');
+  return 'collided';
+}
+
 /** Puts a train onto a Mainline card with its crossing time already computed. */
 function enterMainline(
   s: GameState,
@@ -458,17 +658,9 @@ function enterMainline(
   id: TrayId,
   tray: CrewTray,
   index: number,
+  startsAtBack = false,
 ): void {
-  const profile = trainProfile(tray.trainNumber ?? 0, tray.trainIsExtra);
-  const carriesPassengers = tray.consist.some((c) => c.type === 'coach');
-  const stages = crossingStages(
-    node.card,
-    profile?.speed ?? 'slow',
-    carriesPassengers,
-    node.modifiers ?? [],
-    tray.direction,
-    node.gradeUp ?? 'east',
-  );
+  const stages = crossingStages(node.card, entryFor(node, tray, startsAtBack || takesTheSiding(node)));
   node.transits.push({ tray: id, stagesRemaining: stages, stagesTotal: stages, direction: tray.direction });
   tray.position = { at: 'mainline', index };
   // It is running now, so it is no longer being assembled (state.ts). A train at a Division Point
@@ -511,8 +703,16 @@ function spendDispatchBonus(
   const mine = tray.trainNumber ?? 99;
   const theirs = other.trainNumber ?? 99;
 
-  // The Fedora is held by a PLAYER, and the dispatch devices are installed in an Office Area, which
-  // is keyed by SEAT. Indexing one with the other is right only while seating is the identity map.
+  /**
+   * The Fedora is held by a PLAYER; the devices are installed in an Office Area, which is keyed by
+   * SEAT. `areaOf` is what reconciles the two — it resolves through `seatOf` — so this is correct
+   * under Employee Rotation and not only while seating happens to be the identity map.
+   *
+   * This comment used to say the opposite, warning that indexing one with the other was safe only
+   * while seating was identity. It read as a live bug and was not one: `areaOf(s, player)` IS
+   * `areaAtSeat(s, seatOf(s, player))`. Pinned by test rather than asserted here — see #101's
+   * "spends the Superintendent's own devices under non-identity seating".
+   */
   const area = areaOf(s, s.clock.superintendent);
 
   // Best device first — Radio (+12) beats Telephone (+8) beats Telegraph (+4).
@@ -550,7 +750,11 @@ function spendDispatchBonus(
  * the speeches are made, and every arrival after that is expedited. `speechMade` is set on that first
  * stop, so the train is exempt once and subject to the fault thereafter.
  */
-function isExpedited(tray: CrewTray): boolean {
+export function isExpedited(tray: {
+  trainNumber: number | null;
+  trainIsExtra: boolean;
+  speechMade?: boolean;
+}): boolean {
   const rules = trainProfile(tray.trainNumber ?? 0, tray.trainIsExtra)?.rules;
   if (!rules) return false;
   if (rules.expedite) return true;
@@ -577,6 +781,10 @@ function moveTrain(s: GameState, id: TrayId, tray: CrewTray, events: GameEvent[]
     if (clearance === 'blocked') return 'held';
     if (clearance === 'ask') return 'needsClearance';
 
+    const conflict = entryConflict(s, node, id, tray, events);
+    if (conflict === 'held') return 'held';
+    if (conflict === 'collided') return 'moved';
+
     enterMainline(s, node, id, tray, target);
     const dp = s.division.nodes[dpIndex];
     if (dp?.kind === 'divisionPoint') dp.holding = dp.holding.filter((t) => t !== id);
@@ -636,6 +844,11 @@ function moveTrain(s: GameState, id: TrayId, tray: CrewTray, events: GameEvent[]
       if (clearance === 'blocked') return 'held';
       if (clearance === 'ask') return 'needsClearance';
 
+      const conflict = entryConflict(s, node, id, tray, events);
+      if (conflict === 'held') return 'held';
+      // The wreck's A/D track is released by `collide` itself, which is why it has to be.
+      if (conflict === 'collided') return 'moved';
+
       enterMainline(s, node, id, tray, target);
       area.adOccupancy = area.adOccupancy.filter((t) => t !== id);
       events.push({
@@ -696,8 +909,19 @@ function moveTrain(s: GameState, id: TrayId, tray: CrewTray, events: GameEvent[]
       }
       if (clearance === 'ask') return 'needsClearance';
 
+      /**
+       * AN EXTRA PULLING OUT OF THE INTERCHANGE STARTS IN THE BACK REGION (Gitea#3) — "interchange
+       * has new extras show up in second region (like uncontrolled siding)", and earlier, "Plains is
+       * 1 stage for ALL trains. So are interlockings, with a second stage for incoming extras to hold
+       * at." A train running THROUGH the Interchange starts past that region and crosses in one
+       * Stage; one that began its run here has the holding region to clear first.
+       */
+      const conflict = entryConflict(s, node, id, tray, events, true);
+      if (conflict === 'held') return 'held';
+      if (conflict === 'collided') return 'moved';
+
       node.holding = node.holding.filter((t) => t !== id);
-      enterMainline(s, node, id, tray, index);
+      enterMainline(s, node, id, tray, index, true);
       events.push({
         type: 'trainHighballed',
         trainNumber: tray.trainNumber ?? 0,
@@ -729,21 +953,22 @@ function moveTrain(s: GameState, id: TrayId, tray: CrewTray, events: GameEvent[]
        *
        * ABS Signals does what it says instead: the follower stops SHORT of the collision and holds.
        */
-      const regionOf = (t: { stagesTotal: number; stagesRemaining: number }): number => {
-        const entry = REGIONS_PER_MAINLINE_CARD - t.stagesTotal;
-        const elapsed = t.stagesTotal - t.stagesRemaining;
-        return Math.min(REGIONS_PER_MAINLINE_CARD - 1, Math.max(0, entry + elapsed));
-      };
-      // NOT on a card that prints "trains may pass". Double Track and Uncontrolled Siding hold two
-      // trains because they HAVE two roads, so a train catching another there goes past it — that
-      // is what the card is for. Without this the mechanic fired 0.41 times a game while the bot
-      // never once granted clearance, which is the tell: those were all passing cards.
+      // NOT on a card that prints "trains may pass" — Double Track holds two trains because it HAS
+      // two roads, so a train catching another there goes past it. That is what the card is for.
+      //
+      // The Uncontrolled Siding used to be in that set and no longer is: it keeps two trains apart
+      // by putting the second one in the siding a region back (`takesTheSiding`), not by letting
+      // them share a place. Marking it "may pass" skipped this test entirely and made the siding do
+      // nothing at all.
       const mayPass = mainlineProfile(node.card).trainsMayPass;
-      const next = regionOf({ stagesTotal: transit.stagesTotal, stagesRemaining: transit.stagesRemaining - 1 });
+      const next = regionOfTransit(node.card, transit.stagesRemaining - 1);
       const ahead = mayPass
         ? undefined
         : node.transits.find(
-            (t) => t.tray !== id && t.direction === transit.direction && regionOf(t) === next,
+            (t) =>
+              t.tray !== id &&
+              t.direction === transit.direction &&
+              regionOfTransit(node.card, t.stagesRemaining) === next,
           );
 
       if (ahead) {
@@ -768,9 +993,30 @@ function moveTrain(s: GameState, id: TrayId, tray: CrewTray, events: GameEvent[]
     // Off the end of the card: into the adjoining Limit, then straight to the Office (§8.2).
     const target = index + dir;
     const dest = s.division.nodes[target];
+
+    /**
+     * §11 (Gitea#5) — the Yard Office offer is put BEFORE the train leaves the Mainline card, for
+     * the same reason §8.1's clearance is: `needsClearance` unwinds the whole phase and the driver
+     * re-enters here from the top, so anything already mutated is mutated twice or, worse, left
+     * half-applied. Asking after the `transits` filter below cost the train its place on the card
+     * and it was never seen again — the question was asked and the answer had nowhere to land.
+     */
+    if (dest?.kind === 'office') {
+      /**
+       * §Q, RED FLAGS (Gitea#19) — asked and answered before the train leaves the card, for exactly
+       * the reason the Yard Office offer is (see below): `needsClearance` unwinds the phase.
+       *
+       * Order matters. A flag stops the train OUTSIDE the Limits, so it never reaches the point
+       * where the Yard Office would be offered — flagging is about keeping a train out altogether.
+       */
+      const flagged = redFlagStop(s, id, tray, dest, events);
+      if (flagged === 'ask') return 'needsClearance';
+      if (flagged === 'held') return 'held';
+
+      if (yardOfficeQuestion(s, id, tray, dest.seat, events) === 'ask') return 'needsClearance';
+    }
+
     node.transits = node.transits.filter((t) => t.tray !== id);
-    // Red Flags protect a train while it is stopped here; once it rolls, the flags come in.
-    if (node.redFlagged) node.redFlagged = node.redFlagged.filter((t) => t !== id);
 
     if (!dest) return 'held';
 
@@ -806,10 +1052,10 @@ function evaluateClearance(
 ): 'clear' | 'blocked' | 'ask' {
   // A ruling already given for this train is consumed here — this is what stops the driver from
   // re-asking the same question every time it re-evaluates the train.
-  const ruling = s.clock.clearanceRuling;
-  if (ruling && ruling.train === id) {
-    s.clock.clearanceRuling = null;
-    return ruling.allow ? 'clear' : 'blocked';
+  const answer = s.clock.decisionAnswer;
+  if (answer && answer.kind === 'clearance' && answer.train === id) {
+    s.clock.decisionAnswer = null;
+    return answer.allow ? 'clear' : 'blocked';
   }
 
   const node = s.division.nodes[targetIndex];
@@ -833,10 +1079,27 @@ function evaluateClearance(
    * constrained. Each Office upgrade to a Control Point splits one in two and buys capacity.
    */
   const subdivision = subdivisions(s).find((group) => group.includes(targetIndex)) ?? [targetIndex];
+  /**
+   * ONLY WHAT IS AHEAD (Gitea#26). §8.1 asks about a train the considered train would FOLLOW, and one
+   * moving TOWARDS it — both of which are ahead of it. A Subdivision runs the length of every Whistle
+   * Post between two Control Points, so it can hold a train BEHIND the one departing: in the reported
+   * game X15 highballed west from an Office while X18, also westbound, was still crossing the card to its
+   * east. Counting X18 put a meaningless ruling to the Superintendent; holding X15 kept the Whistle Post's
+   * one A/D track full, and X18 arrived into it and was destroyed. A train behind and moving away is no
+   * threat at all.
+   *
+   * "Behind" is strictly behind the card the departing train stands on. A train on that same card is still
+   * counted, exactly as before: which of two trains sharing a card is in front is `entryConflict`'s region
+   * question, and this is not the place to answer it.
+   */
+  const from = nodeIndexOfTray(s, tray);
+  const behind = (onCard: number): boolean =>
+    from !== null && from >= 0 && (tray.direction === 'east' ? onCard < from : onCard > from);
   const occupants: { tray: TrayId; onCard: number }[] = [];
   for (const i of subdivision) {
     const n = s.division.nodes[i];
     if (!n || n.kind !== 'mainline') continue;
+    if (behind(i)) continue;
     for (const t of n.transits) if (t.tray) occupants.push({ tray: t.tray, onCard: i });
   }
 
@@ -877,24 +1140,239 @@ function evaluateClearance(
     // from moving". Flagging is per-train rather than per-card, so it protects one specific train
     // where ABS Signals protects everything on the card.
     //
-    // Both of these read the card the OTHER train is standing on rather than the card being
-    // entered. They were the same card while this only looked one card ahead; across a Subdivision
-    // they are not, and the protection belongs where the train it protects actually is.
-    if (onNode?.kind === 'mainline' && (onNode.redFlagged ?? []).includes(other)) return 'blocked';
+    // Red Flags used to protect a stopped train here as well. Gitea#19 replaced that rule outright
+    // (Jesse, 2026-08-29): a flag is now planted on a district's Limits and holds trains coming from
+    // one direction, so it never applies out on the Mainline. ABS Signals is what protects a train
+    // standing on a Mainline card now, and it always did the job better.
 
-    // ABS Signals — "trains on this card will not rear-end each other; they stop short of a
-    // collision". With signals in place a following train simply holds, and the Superintendent has
-    // no judgment call to make. This is the amendment to Gap 2's unconditional collisions.
-    if (onNode?.kind === 'mainline' && onNode.absSignals) return 'blocked';
+    /**
+     * ABS Signals — "this is played on a mainline card to prevent collisions. If a collision would
+     * normally occur, the train moving onto the card is instead held back" (RAR, Gitea#3).
+     *
+     * With signals in place a following train simply holds and the Superintendent has no judgment
+     * call to make, which is the amendment to Gap 2's unconditional collisions. It is caught HERE
+     * rather than at the entry itself, so the train never gets as far as the card.
+     *
+     * IT USED TO HOLD SILENTLY. A blocked clearance emits nothing on the Office and Division Point
+     * paths, so the one card whose entire purpose is to stop a wreck did its job invisibly: the
+     * train simply did not move, Stage after Stage, with nothing on screen saying why. The card is
+     * unplayable to reason about without this line.
+     */
+    if (onNode?.kind === 'mainline' && onNode.absSignals) {
+      events.push({
+        type: 'trainHeld',
+        trainNumber: tray.trainNumber ?? 0,
+        reason: 'ABS Signals — held short of the train ahead',
+      });
+      return 'blocked';
+    }
 
     // Same direction — the Superintendent must rule (§8.1, fourth condition).
-    s.clock.pendingDecision = { train: id, occupiedBy: other };
+    s.clock.pendingDecision = { kind: 'clearance', train: id, occupiedBy: other };
     events.push({ type: 'clearanceRequested', trainId: id, occupiedBy: other });
     return 'ask';
   }
   return 'clear';
 }
 
+/**
+ * CAN THIS TRAIN REACH THE YARD OFFICE, AND IS THE LEAD CLEAR? (Gitea#5)
+ *
+ * Three answers, because Jesse's ruling (2026-08-29) splits two failures his issue describes
+ * separately: "if the Yard Office is not accessible in one move, you should not get the option"
+ * and "cars on the tracks you use to get in result in a crash".
+ *
+ *   - `clear`  — a route exists and nothing is standing on it. Offer it; taking it is safe.
+ *   - `fouled` — a route exists and there are cars on it. Offer it; taking it collides.
+ *   - `none`   — no route in one move. Do not offer it, and say why in the history.
+ *
+ * WALKED WITH THE ENGINE'S OWN MOVE RULES rather than a bespoke adjacency test. `exploreMoves`
+ * already means exactly what the card's "in one move" means — any distance without changing
+ * direction, finishing on Operational Rail (§2.4, §A.1) — so using it is what makes the code and
+ * the card agree, which was the whole complaint.
+ *
+ * THE FOULING SIGNAL IS `couples`. The walk does not treat standing cars as obstructions: it
+ * COUPLES them, because that is what a switching move does (§A.4). An arriving train is not
+ * switching, so anything it would have coupled is instead something it is about to hit — the same
+ * reading §8.3 already applies to the Running Track.
+ *
+ * The walk starts at the Office square, where a standard arrival puts the train, and leaves by the
+ * way the train is already facing. Reversing is a separate Move (§A.5), so a Yard Office that can
+ * only be reached by backing up is correctly "not in one move".
+ */
+/**
+ * The flag comes down as it stops the train — one card, one train (Gitea#19).
+ *
+ * MUTATES RATHER THAN EMITTING A REDUCED EVENT, because this is the phase driver: `advance.ts`
+ * changes state directly and then describes what it did, and roughly a third of the event types are
+ * never reduced at all (`README.md`, and `tally.ts` on the same asymmetry). A `redFlagSpent`
+ * reducer case looked right and never fired — the flag stayed up and held every train that came.
+ */
+function spendFlag(
+  office: Extract<DivisionNode, { kind: 'office' }>,
+  tray: CrewTray,
+  side: Direction,
+  events: GameEvent[],
+): 'held' {
+  delete office.redFlag;
+  events.push({ type: 'redFlagSpent', seat: office.seat, side, trainNumber: tray.trainNumber ?? 0 });
+  events.push({
+    type: 'trainHeld',
+    trainNumber: tray.trainNumber ?? 0,
+    reason: 'Red Flags — held short of the Limits',
+  });
+  return 'held';
+}
+
+/**
+ * §Q, RED FLAGS (Gitea#19) — does a flag stop this train, and should its owner be offered one?
+ *
+ * Two jobs, because they are the same moment seen twice: a flag already planted stops the train
+ * outright, and a train about to run into trouble is the cue to offer a flag to somebody holding
+ * the card. "You can play the card normally or out of phase, but only if you need it."
+ *
+ *   - `held`    — a flag was up on the side this train is coming from. It loses this Mainline
+ *                 Phase and the flag comes down with it: one card, one train (Jesse, 2026-08-29).
+ *   - `ask`     — entering would collide and the district's owner holds a Red Flags card.
+ *   - `proceed` — neither.
+ *
+ * WHICH SIDE. A train running WEST arrives from the east, so `FLAG EAST` is what holds it — which
+ * is the example the issue gives, and the reason the flag names a side rather than a heading.
+ */
+function redFlagStop(
+  s: GameState,
+  id: TrayId,
+  tray: CrewTray,
+  dest: Extract<DivisionNode, { kind: 'office' }>,
+  events: GameEvent[],
+): 'held' | 'ask' | 'proceed' {
+  const from: Direction = tray.direction === 'east' ? 'west' : 'east';
+
+  // The answer to a prompt already put. Consumed here so the driver cannot ask twice.
+  const answer = s.clock.decisionAnswer;
+  if (answer && answer.kind === 'redFlag' && answer.train === id) {
+    s.clock.decisionAnswer = null;
+    if (!answer.flag) return 'proceed';
+    // The card was spent planting the flag; it stops this train and comes down again at once.
+    return spendFlag(dest, tray, from, events);
+  }
+
+  if (dest.redFlag === from) return spendFlag(dest, tray, from, events);
+
+  /**
+   * "In actual cases of danger… if there is a train or cars on the track and there will be a
+   * collision, then you break in with a dialog." The two ways an arrival collides are §8.3's own:
+   * no free A/D track, and cars fouling the Running Track. Asked only of a player who can actually
+   * answer — offering a flag to somebody holding no card is a prompt with one button.
+   */
+  const owner = playerAtSeat(s, dest.seat);
+  const holdsFlag = (s.decks.hands.get(owner) ?? []).some((cid) => {
+    const c = s.cards.get(cid);
+    return c?.kind.kind === 'maneuver' && c.kind.key === 'redFlags';
+  });
+  if (!holdsFlag) return 'proceed';
+  if (!arrivalWouldCollide(s, id, tray, dest.seat)) return 'proceed';
+
+  s.clock.pendingDecision = { kind: 'redFlag', train: id, seat: dest.seat, from };
+  return 'ask';
+}
+
+/**
+ * Would this arrival collide? §8.3's two triggers, asked before the train commits.
+ *
+ * Deliberately a READ of the same conditions `arriveAtOffice` enforces rather than a second rule:
+ * if these two ever diverge, the prompt offers a flag against a collision that will not happen, or
+ * stays silent before one that will.
+ */
+function arrivalWouldCollide(s: GameState, id: TrayId, tray: CrewTray, seat: SeatIndex): boolean {
+  const area = areaAtSeat(s, seat);
+  const hasInterlocking = [...area.grid.values()].some((c) => c.enhancements.includes('interlocking'));
+  const full = area.adOccupancy.length >= officeProfile(area.tier).adTracks;
+  // Interlocking turns a full Office into a hold rather than a collision, so it is not danger.
+  if (full && !hasInterlocking) return true;
+
+  // A coach may legally stand at the Office while its engine switches (§A.4's carve-out), so it is
+  // not a hazard to the next arrival. Anything else on the Running Track is.
+  const officeCard = area.grid.get(coordKey(area.officeCoord));
+  return officeCard !== undefined && officeCard.standing.some((c) => c.type !== 'coach');
+}
+
+/**
+ * §11 (Gitea#5) — should the district's owner be asked about the Yard Office, and is there
+ * anything to ask about?
+ *
+ * Returns `ask` only when the offer is real: a coachless train, a Yard Office card in the district,
+ * and a route to it in one move. Everything else is `proceed`, which means the ordinary arrival.
+ *
+ * ALSO THE PLACE THE HISTORY LEARNS WHY NOT. Jesse, 2026-08-29: "make sure this is logged in
+ * history — why can't move so user knows why they can't get to yard." A qualifying train that is
+ * simply never offered the choice looks exactly like the feature being broken, which is how the
+ * missing reachability check went unnoticed for so long.
+ */
+function yardOfficeQuestion(
+  s: GameState,
+  id: TrayId,
+  tray: CrewTray,
+  seat: SeatIndex,
+  events: GameEvent[],
+): 'ask' | 'proceed' {
+  // Already answered: `arriveAtOffice` consumes it. Asking again would loop the phase for ever.
+  const answer = s.clock.decisionAnswer;
+  if (answer && answer.kind === 'yardOffice' && answer.train === id) return 'proceed';
+
+  if (tray.consist.some((c) => c.type === 'coach')) return 'proceed';
+  const area = areaAtSeat(s, seat);
+  if (![...area.grid.values()].some((c) => c.enhancements.includes('yardOffice'))) return 'proceed';
+
+  const route = yardOfficeRoute(s, seat, id, tray);
+  if (route.kind === 'none') {
+    events.push({
+      type: 'trainDiverted',
+      trainNumber: tray.trainNumber ?? 0,
+      to: 'the Office',
+      reason: `the Yard Office could not be offered — ${route.why}`,
+    });
+    return 'proceed';
+  }
+
+  s.clock.pendingDecision = { kind: 'yardOffice', train: id, seat };
+  return 'ask';
+}
+
+type YardOfficeRoute =
+  | { kind: 'clear' | 'fouled'; coord: GridCoord }
+  | { kind: 'none'; why: string };
+
+function yardOfficeRoute(s: GameState, seat: SeatIndex, id: TrayId, tray: CrewTray): YardOfficeRoute {
+  const area = areaAtSeat(s, seat);
+  const target = [...area.grid.entries()].find(([, card]) => card.enhancements.includes('yardOffice'));
+  if (!target) return { kind: 'none', why: 'there is no Yard Office in this district' };
+  const [key] = target;
+  const [row, col] = key.split(',').map(Number);
+  const coord = { row: row!, col: col! };
+
+  const player = playerAtSeat(s, seat);
+  const facing = railFacingOf(tray);
+  const found = reachableDestinations(
+    {
+      area,
+      occupancy: occupancyFor(s, player, id),
+      consistSize: tray.consist.length,
+      self: id,
+    },
+    area.officeCoord,
+    facing,
+  ).find((d) => d.coord.row === coord.row && d.coord.col === coord.col);
+
+  if (!found) {
+    return {
+      kind: 'none',
+      why: 'it cannot be reached from the Office in one move, running the way this train is facing',
+    };
+  }
+  return { kind: found.couples.length > 0 ? 'fouled' : 'clear', coord };
+}
+
 /**
  * §8.3 — arriving at an Office. Collisions here are AUTOMATIC (Gap 2a): if the trigger holds,
  * the collision happens, with no die roll and no judgment.
@@ -911,22 +1389,51 @@ function arriveAtOffice(
   const hasEnhancement = (key: string): boolean =>
     [...area.grid.values()].some((c) => c.enhancements.includes(key));
 
-  // Yard Office — "an inbound train with NO COACHES that can make a single move to the yard office
-  // track may arrive there, not at the Train Order Office". It sidesteps the A/D track entirely.
-  const noCoaches = !tray.consist.some((c) => c.type === 'coach');
-  if (noCoaches && hasEnhancement('yardOffice')) {
-    for (const [key, card] of area.grid) {
-      if (!card.enhancements.includes('yardOffice')) continue;
-      const [row, col] = key.split(',').map(Number);
-      tray.position = { at: 'grid', seat, coord: { row: row!, col: col! } };
+  /**
+   * §11, THE YARD OFFICE (Gitea#5) — offered, not imposed.
+   *
+   * "Trains that are only freight (cabooses ok, no coaches allowed) that arrive in a player's area
+   * who has the yard office card get an extra ability. On the turn (mainline phase) that the train
+   * arrives the game will offer that player the option to have that train go directly to the yard
+   * office card instead of the standard office. They can of course still choose to have the train
+   * go to the standard office."
+   *
+   * WHAT THIS USED TO DO, and why all three of the rule's conditions were missing: a qualifying
+   * train was TELEPORTED onto the Yard Office card. The player was never asked, no route was ever
+   * computed — so the card's own printed text, "that can reach the yard office in one move", was
+   * unenforced — and because nothing was walked, nothing was ever met on the way in.
+   *
+   * The answer comes back through `pendingDecision`, so this returns `needsClearance` and is
+   * re-entered once the player has answered. `yardOfficeOffer` below is where the route is walked.
+   */
+  /**
+   * The answer to the offer `yardOfficeQuestion` put before the train left the Mainline card.
+   * Absent — because the train has no Yard Office, or no route to it, or carries coaches — this
+   * falls straight through to the ordinary arrival below.
+   */
+  const answer = s.clock.decisionAnswer;
+  if (answer && answer.kind === 'yardOffice' && answer.train === id) {
+    s.clock.decisionAnswer = null;
+    const route = answer.take ? yardOfficeRoute(s, seat, id, tray) : { kind: 'none' as const };
+    if (route.kind !== 'none') {
+      tray.position = { at: 'grid', seat, coord: route.coord };
       events.push({
         type: 'trainDiverted',
         trainNumber: tray.trainNumber ?? 0,
         to: 'the Yard Office',
         reason: 'no coaches, so it need not occupy the Train Order Office',
       });
+      /**
+       * Cars on the lead are a COLLISION, not a coupling — the same §8.3 rule that governs the
+       * Running Track, and the third of the three things this implementation was missing. An
+       * arriving train is at speed and is not expecting them (§A.4).
+       */
+      if (route.kind === 'fouled') {
+        collide(s, playerAtSeat(s, seat), [id], events, 'cars fouling the lead into the Yard Office', 'the Yard Office');
+      }
       return 'moved';
     }
+    // Declined: fall through to the standard Office, with its own capacity and collision rules.
   }
 
   // Gap 2d — no room at the station is a collision, and it is the local player's fault (§10).
@@ -977,6 +1484,7 @@ function arriveAtOffice(
     trainNumber: tray.trainNumber ?? 0,
     consist: tray.consist.map((c) => ({ ...c })),
     office: officeProfile(area.tier).name,
+    owner: playerAtSeat(s, seat),
     expedited: isExpedited(tray),
   });
 
@@ -1039,7 +1547,18 @@ function collide(
       if (n.kind !== 'mainline') continue;
       n.transits = n.transits.filter((t) => t.tray !== id);
       if (n.holding) n.holding = n.holding.filter((t) => t !== id);
-      if (n.redFlagged) n.redFlagged = n.redFlagged.filter((t) => t !== id);
+    }
+    /**
+     * AND OFF THE A/D TRACK, for exactly the same reason as the transit above.
+     *
+     * It never mattered while every collision happened to a train already out on the road. Gitea#3
+     * adds one that can happen as a train LEAVES — a following train entering an occupied region —
+     * and that train is still standing at the Office when it dies. Without this its A/D track stays
+     * marked forever: the Office reads as permanently full, and every later arrival collides against
+     * a train that no longer exists.
+     */
+    for (const [, area] of s.officeAreas) {
+      area.adOccupancy = area.adOccupancy.filter((t) => t !== id);
     }
   }
 
@@ -1137,6 +1656,13 @@ function shiftChange(s: GameState, events: GameEvent[]): AdvanceResult {
   if (s.clock.stage % STAGES_PER_SHIFT === 0) {
     s.clock.superintendent = playerLeftOf(s, s.clock.superintendent);
     events.push({ type: 'actorChanged', player: s.clock.superintendent });
+    /**
+     * SAID OUT LOUD, as well as recorded. `actorChanged` is turn bookkeeping and the log discards it,
+     * so this — the one time in three Stages that it means the Fedora moved — had no line anywhere
+     * (playtest, 2026-09-16). Emitted alongside rather than instead: `actorChanged` still carries the
+     * cursor, and anything reading it keeps working.
+     */
+    events.push({ type: 'superintendentChanged', player: s.clock.superintendent, stage: s.clock.stage });
   }
 
   // §9.1 — Laborers and Porters reset at the start of each Stage, not each Phase.
@@ -1152,6 +1678,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);
@@ -1162,17 +1691,39 @@ function shiftChange(s: GameState, events: GameEvent[]): AdvanceResult {
     events.push({ type: 'stageBegan', day: s.clock.day, stage: s.clock.stage });
   }
 
-  // §3.4 — every mode but competitive-and-coop-only: a Day's collisions against `maxCollisionsPerDay`
-  // and the game's running total against `maxCollisionsTotal`. `0` disables either check. Flat, not
-  // scaled by player count — Jesse's call, 2026-08-20: more players is more independent chances to
-  // collide, not a bigger shared budget.
-  if (s.config.mode === 'competitive' || s.config.mode === 'coop') {
+  /**
+   * §3.4 — EVERY MODE, SOLITAIRE INCLUDED: a Day's collisions against `maxCollisionsPerDay` and the
+   * game's running total against `maxCollisionsTotal`. `0` disables either check. Flat, not scaled
+   * by player count — Jesse's call, 2026-08-20: more players is more independent chances to collide,
+   * not a bigger shared budget.
+   *
+   * SOLITAIRE WAS EXCLUDED UNTIL 2026-08-30 and nothing said so. The gate here read `mode ===
+   * 'competitive' || mode === 'coop'`, while `SOLO_CONFIG` carried both limits and the New Game
+   * dialog offered them as live settings — so a solitaire player could set a collision limit, read
+   * "the game ends in a loss" beside it, and crash as often as they liked. Found reviewing that
+   * screen's wording (Jesse, 2026-08-30); his ruling is that the settings should do what they say,
+   * so the gate is gone rather than the controls.
+   *
+   * A SOLITAIRE GAME CAN THEREFORE NOW END EARLY, which no measurement in `TODO.md` was taken
+   * under. At the shipped defaults (3 a Day, 5 total) it is a rare ending rather than a common one —
+   * the bot averages 0.06 collisions a game — but any figure quoted from a full-length run predates
+   * it.
+   */
+  {
     const perDayBreach =
       s.config.maxCollisionsPerDay > 0 && s.collisionsToday >= s.config.maxCollisionsPerDay;
     const totalBreach =
       s.config.maxCollisionsTotal > 0 && s.collisionsTotal >= s.config.maxCollisionsTotal;
     if (perDayBreach || totalBreach) {
       s.status = 'finished';
+      /**
+       * NOT EXTENDABLE, AND IT DOES NOT REWRITE A RECORDED RESULT (Gitea#11).
+       *
+       * A breach during an EXTENDED Day ends play at once, exactly as it would during the regular
+       * game — but by then the official result already exists, and a railroad declared unsafe on
+       * Day 9 does not retract who won on Day 5. `freezeOfficial` is what keeps that true: it
+       * writes only when `official` is still null, so assigning `outcome` here is safe.
+       */
       s.outcome = { result: 'loss', winner: null, reason: 'collisionFloor' };
       return { events, needsInput: false };
     }
@@ -1216,28 +1767,55 @@ function rotateSeats(s: GameState, events: GameEvent[]): void {
 
 function checkVictory(s: GameState, _events: GameEvent[]): boolean {
   const daysElapsed = s.clock.day - 1;
-  if (daysElapsed < s.config.days) return false;
+  /**
+   * `extraDays` is Gitea#11. `config.days` is never touched by an extension — it is what the
+   * OFFICIAL result is decided at — so the Day the timetable currently runs to is the sum of the
+   * two. On the first ending they are equal, which is why `freezeOfficial` can record `config.days`
+   * as the official Day without asking anything further.
+   */
+  if (daysElapsed < s.config.days + s.extraDays) return false;
 
-  s.status = 'finished';
+  s.outcome = decideOutcome(s);
+  /**
+   * §3.3, EXTENDED PLAY — an ending the table may play past PAUSES rather than finishing.
+   *
+   * `freezeOfficial` (the `advance` wrapper) records the first of these as the official result, so
+   * by the time a second one is reached the winner is already settled and everything here is
+   * informational. The votes are cleared each time because the question is asked again at the end
+   * of every extended Day: agreeing once does not agree to the rest of the game.
+   */
+  if (isExtendable(s.outcome.reason)) {
+    s.status = 'awaitingExtension';
+    s.extensionVotes = s.players.map(() => null);
+  } else {
+    s.status = 'finished';
+  }
+  return true;
+}
 
+/**
+ * WHO WON, on the evidence as it stands right now.
+ *
+ * Split out of `checkVictory` for Gitea#11: it is asked once per ending, and an extended game has
+ * more than one. Unchanged in substance — the revenue floor, then co-op's shared achievement, then
+ * the highest Revenue — it simply no longer writes to the state it is reasoning about.
+ */
+function decideOutcome(s: GameState): Outcome {
   const combined = totalRevenue(s);
   if (s.config.minCombinedRevenue > 0 && combined < s.config.minCombinedRevenue) {
-    s.outcome = { result: 'loss', winner: null, reason: 'revenueFloor' };
-    return true;
+    return { result: 'loss', winner: null, reason: 'revenueFloor' };
   }
 
   if (s.config.mode === 'coop') {
-    s.outcome = { result: 'win', winner: null, reason: 'daysElapsed' };
-    return true;
+    return { result: 'win', winner: null, reason: 'daysElapsed' };
   }
 
   const best = Math.max(...s.players.map((p) => p.revenue));
-  s.outcome = {
+  return {
     result: 'win',
     winner: s.players.findIndex((p) => p.revenue === best),
     reason: 'daysElapsed',
   };
-  return true;
 }
 
 // ---------------------------------------------------------------------------

src/engine/apply.ts

@@ -16,7 +16,6 @@
 
 import {
   FREIGHT_PROFILES,
-  HAND_LIMIT,
   LABORER_ACTIONS_PER_LOAD,
   MAX_CONSIST,
   REALIGNMENTS,
@@ -52,12 +51,16 @@ import type {
   TrayId,
   TurnoutOrientation,
 } from './state.ts';
+import { tallyEvent } from './tally.ts';
 import { createRng } from './rng.ts';
 import {
   carsOn,
   coordKey,
   cutTowards,
+  decisionActor,
+  officeNodeFor,
   isOperationalRail,
+  overHandLimit,
   playerAtSeat,
   pooled,
   railFacingOf,
@@ -77,6 +80,7 @@ import {
   facilityVariants,
   opposite,
   reachableDestinations,
+  rowEndAt,
   variantsFor,
   withinLimits,
 } from './track.ts';
@@ -122,7 +126,12 @@ function trayCoord(s: GameState, trayId: TrayId): GridCoord | null {
 }
 
 /** A tray sitting on the Office card occupies an A/D track (§2.1). */
-function occupancyFor(s: GameState, player: PlayerIndex, self: TrayId): Occupancy {
+/**
+ * Exported for `advance.ts`'s Yard Office walk (Gitea#5), which has to ask the SAME occupancy
+ * question a switching move asks — a second copy would be free to drift into a different answer
+ * about which cards are free.
+ */
+export function occupancyFor(s: GameState, player: PlayerIndex, self: TrayId): Occupancy {
   const area = areaOf(s, player);
   return {
     trayAt: (c) => {
@@ -331,6 +340,15 @@ function checkTurnoutUpgrade(existing: TrackCard, proto: TrackCard): RejectionCo
 
   if (existing.standing.length > 0) return 'UPGRADE_OCCUPIED';
   if (existing.enhancements.length > 0) return 'UPGRADE_ENHANCED';
+  /**
+   * NOTHING IS ASKED ABOUT THE NEIGHBOURS, deliberately (Gitea#15).
+   *
+   * A turnout adds a 45° leg the card underneath did not have, and that leg may well point into an
+   * occupied square with nothing to meet it. That is legal: RAR ruled (2026-08-26) that a rail may
+   * stop dead against its neighbour, and an upgrade is no different from laying the piece there in
+   * the first place. What must hold either way is that no train can cross the gap, which is
+   * `exploreMoves`' business and is tested in `track.test.ts`.
+   */
   return null;
 }
 
@@ -589,7 +607,8 @@ function freightWorkedKey(trayId: TrayId, at: GridCoord): string {
   return `${trayId}@${coordKey(at)}`;
 }
 
-const isFreight = (c: RollingStock): boolean => c.type !== 'coach' && c.type !== 'caboose';
+/** Exported so the Blocked panel counts a freight car the same way the reducers do (Gitea#21). */
+export const isFreight = (c: RollingStock): boolean => c.type !== 'coach' && c.type !== 'caboose';
 
 /**
  * IS THIS CAR CARRYING A LOAD? A CABOOSE NEVER IS, whatever its `loaded` flag says.
@@ -639,6 +658,20 @@ function switchingRefusal(tray: CrewTray): RejectionCode | null {
   return rulesOf(tray).noSwitching ? 'NO_SWITCHING' : null;
 }
 
+/**
+ * WHETHER TRAINS 3/4's PRINTED RULE IS WHAT IS STOPPING THIS CREW WHERE IT STANDS (Gitea#21).
+ *
+ * Exported for the Blocked panel, which needs to say so — and asks `freightBudgetLeft`, the same
+ * predicate the reducer refuses on, rather than rebuilding the key for itself. `narrate.ts` cannot
+ * then drift from the rule it is describing, which is the whole premise of that panel.
+ */
+export function freightRuleSpentHere(s: GameState, player: PlayerIndex, trayId: TrayId): boolean {
+  const tray = s.trays.get(trayId);
+  if (!tray || !rulesOf(tray).oneFreightPerLocation) return false;
+  if (tray.position.at !== 'grid') return false;
+  return !freightBudgetLeft(s, player, tray, tray.position.coord, 1);
+}
+
 /**
  * Charge freight cars against this train's per-location budget (trains 3/4).
  *
@@ -759,16 +792,64 @@ export function passengerRefusal(
 // ---------------------------------------------------------------------------
 
 export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCode | null {
+  /**
+   * §3.3, EXTENDED PLAY (Gitea#11) — asked ABOVE the status guard, because the whole point of the
+   * vote is that it is the one thing the rules will take from a game that has stopped.
+   *
+   * Out of turn like `mainline.clearance` below, and unlike it open to every seat at once: it is a
+   * table decision rather than a ruling, so there is no actor to be.
+   */
+  if (i.type === 'game.extend') {
+    if (s.status !== 'awaitingExtension') return 'NOT_AWAITING_EXTENSION';
+    // The intent NAMES its voter so that a save can be replayed (`intents.ts`), which makes it a
+    // claim until it is checked against the seat the caller authenticated. One seat may not vote
+    // for another.
+    if (i.player !== player) return 'NOT_YOUR_TURN';
+    if (s.extensionVotes[player] !== null) return 'ALREADY_VOTED';
+    return null;
+  }
+
   if (s.status !== 'active') return 'WRONG_PHASE';
 
   // The clearance ruling is the one intent that arrives out of turn order: it interrupts the
   // automatic Mainline Phase and goes to the Superintendent (§8.1, fourth condition).
   if (i.type === 'mainline.clearance') {
-    if (s.clock.pendingDecision === null) return 'NO_PENDING_DECISION';
+    if (s.clock.pendingDecision?.kind !== 'clearance') return 'NO_PENDING_DECISION';
     if (s.clock.superintendent !== player) return 'NOT_SUPERINTENDENT';
     return null;
   }
 
+  /**
+   * §Q (Gitea#19) — the Red Flag prompt, the third interruption of the Mainline Phase.
+   *
+   * Only ever raised for a player who holds the card, so `flag: true` can always be paid for; the
+   * card is checked again here because `check` is the authority and a hand can change between the
+   * prompt being raised and answered.
+   */
+  if (i.type === 'mainline.redFlag') {
+    if (s.clock.pendingDecision?.kind !== 'redFlag') return 'NO_RED_FLAG_PROMPT';
+    if (decisionActor(s) !== player) return 'NOT_YOUR_TURN';
+    if (!i.flag) return null;
+    const held = (s.decks.hands.get(player) ?? []).find((id) => {
+      const c = s.cards.get(id);
+      return c?.kind.kind === 'maneuver' && c.kind.key === 'redFlags';
+    });
+    if (!held) return 'NO_SUCH_CARD';
+    return null;
+  }
+
+  /**
+   * §11 (Gitea#5) — the Yard Office offer, the second interruption of the Mainline Phase.
+   *
+   * Goes to the district's owner rather than the Superintendent, which is the whole reason
+   * `pendingDecision` became a union. `decisionActor` is the single place that mapping lives.
+   */
+  if (i.type === 'mainline.yardOffice') {
+    if (s.clock.pendingDecision?.kind !== 'yardOffice') return 'NO_YARD_OFFICE_OFFER';
+    if (decisionActor(s) !== player) return 'NOT_YOUR_TURN';
+    return null;
+  }
+
   if (!isActor(s, player)) return 'NOT_YOUR_TURN';
 
   switch (i.type) {
@@ -962,7 +1043,7 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
       if (!node || node.kind !== 'mainline') return 'NO_PLACEMENT';
       const on = node.modifiers ?? [];
       if (on.includes(rule.key)) return 'OPTION_ALREADY_CHOSEN';
-      if (rule.gradeOnly && mainlineProfile(node.card).speed.kind !== 'grade') return 'NOT_A_GRADE';
+      if (rule.gradeOnly && node.card !== 'heavyGrade') return 'NOT_A_GRADE';
       if (rule.requiresOnCard && !on.includes(rule.requiresOnCard)) return 'NOT_CONNECTED';
       // "Not while a train is on it" — realigning under a moving train is exactly the situation the
       // restriction exists to prevent. A train standing in the Interchange's yard counts: it is on
@@ -978,14 +1059,9 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
       const card = s.cards.get(i.cardId);
       if (!card || !(s.decks.hands.get(player) ?? []).includes(i.cardId)) return 'NO_SUCH_CARD';
       if (card.kind.kind !== 'maneuver' || card.kind.key !== 'redFlags') return 'WRONG_INTENT';
-      const tray = s.trays.get(i.trayId);
-      if (!tray) return 'NO_SUCH_TRAY';
-      // "A STOPPED train is prevented from being hit" — it protects a train that is standing on a
-      // Mainline card, which is the only place a rear-ender can happen.
-      if (tray.position.at !== 'mainline') return 'NO_PLACEMENT';
-      const node = s.division.nodes[tray.position.index];
-      if (!node || node.kind !== 'mainline') return 'NO_PLACEMENT';
-      if ((node.redFlagged ?? []).includes(i.trayId)) return 'OPTION_ALREADY_CHOSEN';
+      // §Q (Gitea#19) — a flag goes on your OWN Limits. There is no target train to name and no
+      // placement to find: the district is yours, and the only question is which side.
+      if (officeNodeFor(s, seatOf(s, player))?.redFlag === i.side) return 'ALREADY_FLAGGED';
       return null;
     }
 
@@ -1023,10 +1099,9 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
     case 'draw.end': {
       if (!inPhase(s, 'localOps')) return 'WRONG_PHASE';
       if (turnOf(s, player).option !== 'draw') return 'OPTION_NOT_CHOSEN';
-      // §6.2 — "the player must reduce his hand to no more than three cards".
-      const hand = s.decks.hands.get(player) ?? [];
-      const limit = s.decks.redFlags.get(player) ? HAND_LIMIT + 1 : HAND_LIMIT;
-      return hand.length > limit ? 'HAND_LIMIT' : null;
+      // §6.2 — "the player must reduce his hand to no more than three cards". `overHandLimit`
+      // (state.ts) is the one copy of that test; the Frame and the page ask the same function.
+      return overHandLimit(s, player) ? 'HAND_LIMIT' : null;
     }
 
     // -- Freight Agent --------------------------------------------------------
@@ -1131,7 +1206,7 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
       // This was not enforced at all: any car could be added in any quantity, so Train 9 "Heavy
       // Freight" — a card calling for 3 freight AND a caboose — was made up with four hoppers and
       // no caboose. Fewer is allowed; more, or of the wrong category, is not.
-      return acceptsCar(tray, i.carType) ? null : 'NO_SUITABLE_CAR';
+      return acceptsCar(tray, i.carType, i.loaded, s.yards.divisionYard) ? null : 'NO_SUITABLE_CAR';
     }
 
     case 'newTrain.secondSection': {
@@ -1433,17 +1508,48 @@ export function selectDestination(
   return chosen ?? atTo[0];
 }
 
+/**
+ * ROUTES, WALKED ONCE PER POSITION.
+ *
+ * A route walk (`reachableDestinations`) was a third of all simulation time, and most of it was the
+ * same walk repeated: `legal.ts` walks a tray's routes to list its moves, then `check` walks them again
+ * for every one of those moves, and `applyIntent` walks the chosen one a third time in `execute`.
+ * Profiled 2026-09-14 with inlining off: `reachableDestinations` 34% inclusive, garbage collection 34%.
+ *
+ * So while one position is being examined — a legal-action listing, or the check and execute of one
+ * intent — a walk is kept and reused. Both scopes read the state and never write it, the key names
+ * everything the walk depends on besides that state, and the cache is keyed to the state OBJECT and
+ * cleared when the scope ends, so a hit returns exactly what a fresh walk would have. Nothing may
+ * mutate a returned route; nothing does.
+ */
+let routeCache: { state: GameState; routes: Map<string, MoveDestination[]> } | null = null;
+
+export function withRouteCache<T>(s: GameState, fn: () => T): T {
+  if (routeCache) return fn();
+  routeCache = { state: s, routes: new Map() };
+  try {
+    return fn();
+  } finally {
+    routeCache = null;
+  }
+}
+
 function destinationsFor(
   s: GameState,
   player: PlayerIndex,
   trayId: TrayId,
   from: GridCoord,
   reverse: boolean,
-) {
+): MoveDestination[] {
+  const cache = routeCache?.state === s ? routeCache.routes : null;
+  const key = cache ? `${player}|${trayId}|${from.row},${from.col}|${reverse ? 1 : 0}` : '';
+  const hit = cache?.get(key);
+  if (hit) return hit;
+
   const tray = s.trays.get(trayId)!;
   const facing = facingPort(s, trayId);
   const exit: Port = reverse ? reversePort(s, player, from, facing) : facing;
-  return reachableDestinations(
+  const routes = reachableDestinations(
     {
       area: areaOf(s, player),
       occupancy: occupancyFor(s, player, trayId),
@@ -1453,6 +1559,8 @@ function destinationsFor(
     from,
     exit,
   );
+  cache?.set(key, routes);
+  return routes;
 }
 
 /**
@@ -1470,7 +1578,7 @@ export function ownCutFor(s: GameState, player: PlayerIndex, trayId: TrayId, rev
   const facing = facingPort(s, trayId);
   const exit: Port = reverse ? reversePort(s, player, here, facing) : facing;
   const card = areaOf(s, player).grid.get(coordKey(here)) ?? emptyCard();
-  return cutTowards(card, carsOn(card), exit);
+  return cutTowards(card, carsOn(card), rowEndAt(card, exit));
 }
 
 /**
@@ -1522,6 +1630,33 @@ export function movesFor(
 
 function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
   switch (i.type) {
+    /**
+     * §3.3, EXTENDED PLAY (Gitea#11) — the vote, and what it settles.
+     *
+     * Decided HERE rather than in `reduce` because the answer depends on the votes as they stand
+     * BEFORE this one lands, and `execute` is the half that still sees that. Three outcomes:
+     *
+     *   - a refusal ends it immediately. Unanimity means one "no" is decisive, so nobody is made to
+     *     wait on a player who has already said no (Jesse's call, 2026-08-28);
+     *   - the last outstanding "yes" grants the Day — ONE Day, and the question is put again at the
+     *     end of it;
+     *   - anything else is just a vote recorded, and the table waits.
+     */
+    case 'game.extend': {
+      const vote: GameEvent = { type: 'extensionVoted', player, agree: i.agree };
+      if (!i.agree) return [vote, { type: 'playConcluded', declinedBy: player }];
+      const after = s.extensionVotes.map((v, p) => (p === player ? true : v));
+      return after.every((v) => v === true)
+        ? [vote, { type: 'dayExtended', day: s.config.days + s.extraDays + 1 }]
+        : [vote];
+    }
+
+    case 'mainline.yardOffice': {
+      const pending = s.clock.pendingDecision;
+      const trainId = pending?.kind === 'yardOffice' ? pending.train : '';
+      return [{ type: 'yardOfficeRuled', player, trainId, take: i.take }];
+    }
+
     case 'localOps.choose':
       return [{ type: 'localOpsOptionChosen', player, option: i.option }];
 
@@ -1540,6 +1675,7 @@ function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
       const events: GameEvent[] = [
         {
           type: 'trayMoved',
+          player,
           trayId: i.trayId,
           from,
           to: i.to,
@@ -1588,20 +1724,23 @@ function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
          */
         const grid = areaOf(s, player).grid;
         const startCard = grid.get(coordKey(from)) ?? emptyCard();
-        const startCut = cutTowards(startCard, carsOn(startCard), exitPort);
+        const startCut = cutTowards(startCard, carsOn(startCard), rowEndAt(startCard, exitPort));
         const lifted = [
           ...(startCut.length > 0 ? [from] : []),
           ...dest.path.map((step) => step.coord),
           i.to,
         ].filter((c) => carsOn(grid.get(coordKey(c)) ?? emptyCard()).length > 0);
         const sides = standingSides(startCard, carsOn(startCard));
-        const stayed = exitPort === 'e' ? sides.west : exitPort === 'w' ? sides.east : [];
+        // The OTHER end's cut, which stays behind — so it is the other end of the row, not the
+        // other port. A 45° leg is an end of the row too (`rowEndAt`, Gitea#17).
+        const stayed = rowEndAt(startCard, exitPort) === 'e' ? sides.west : sides.east;
         // §A.3 — "engines also have couplers on the front end, so a train can pick cars up onto
         // its nose". Running forward the engine meets cars head-on and takes them in front; backing
         // up, they couple behind. Which end they land on is the whole point of a run-around: it
         // decides which car is next to come off.
         events.push({
           type: 'carsCoupled',
+          player,
           trayId: i.trayId,
           at: i.to,
           stock: dest.couples,
@@ -1622,7 +1761,7 @@ function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
       const stock = i.fromNose
         ? tray.consist.slice(0, i.count)
         : tray.consist.slice(tray.consist.length - i.count);
-      return [{ type: 'carsDropped', trayId: i.trayId, at: here, stock, ...(i.fromNose ? { fromNose: true } : {}) }];
+      return [{ type: 'carsDropped', player, trayId: i.trayId, at: here, stock, ...(i.fromNose ? { fromNose: true } : {}) }];
     }
 
     case 'switch.sortConsist': {
@@ -1631,6 +1770,7 @@ function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
       return [
         {
           type: 'consistSorted',
+          player,
           trayId: i.trayId,
           at: here,
           before: tray.consist.map((c) => ({ ...c })),
@@ -1749,14 +1889,37 @@ function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
           ? REALIGNMENTS.find((r) => r.from === node.card)?.to
           : undefined;
       return [
-        { type: 'mainlineModified', player, cardId: i.cardId, node: i.node, key, ...(became ? { became } : {}) },
+        {
+          type: 'mainlineModified',
+          player,
+          cardId: i.cardId,
+          node: i.node,
+          key,
+          ...(node?.kind === 'mainline' ? { from: node.card } : {}),
+          ...(became ? { became } : {}),
+        },
       ];
     }
 
-    case 'maneuver.redFlags': {
-      const tray = s.trays.get(i.trayId)!;
-      const index = tray.position.at === 'mainline' ? tray.position.index : -1;
-      return [{ type: 'redFlagsSet', player, cardId: i.cardId, trayId: i.trayId, node: index }];
+    case 'maneuver.redFlags':
+      return [{ type: 'redFlagsSet', player, cardId: i.cardId, seat: seatOf(s, player), side: i.side }];
+
+    case 'mainline.redFlag': {
+      const pending = s.clock.pendingDecision;
+      const trainId = pending?.kind === 'redFlag' ? pending.train : '';
+      const seat = pending?.kind === 'redFlag' ? pending.seat : 0;
+      const side = pending?.kind === 'redFlag' ? pending.from : 'east';
+      if (!i.flag) return [{ type: 'redFlagRuled', player, trainId, flag: false }];
+      const cardId =
+        i.cardId ??
+        (s.decks.hands.get(player) ?? []).find((id) => {
+          const c = s.cards.get(id);
+          return c?.kind.kind === 'maneuver' && c.kind.key === 'redFlags';
+        })!;
+      return [
+        { type: 'redFlagsSet', player, cardId, seat, side },
+        { type: 'redFlagRuled', player, trainId, flag: true },
+      ];
     }
 
     case 'maneuver.flyingSwitch': {
@@ -1930,6 +2093,37 @@ function findTimetableSlot(s: GameState, from: number): number | null {
 
 export function reduce(s: GameState, e: GameEvent): void {
   switch (e.type) {
+    // -- §3.3, extended play (Gitea#11)
+    case 'extensionVoted':
+      s.extensionVotes[e.player] = e.agree;
+      break;
+
+    /**
+     * One more Day, and the votes are wiped: agreeing once does not agree to the rest of the game.
+     *
+     * `config.days` is deliberately untouched. It is what the OFFICIAL result was decided at
+     * (`state.ts`'s `FinalReport`), so leaving it alone is what makes "the winner is decided at the
+     * original game length" a fact about the code rather than a comment on it. `outcome` is left
+     * alone too — it is the last evaluation, and it is what the results screen shows while the extra
+     * Day is played.
+     */
+    case 'dayExtended':
+      s.extraDays += 1;
+      s.extensionVotes = s.players.map(() => null);
+      s.status = 'active';
+      break;
+
+    case 'playConcluded':
+      s.status = 'finished';
+      break;
+
+    // §11 (Gitea#5) — the same shape as `clearanceGiven`: clear the question, record the answer for
+    // the arriving train to consume, or the driver asks again for ever.
+    case 'yardOfficeRuled':
+      s.clock.pendingDecision = null;
+      s.clock.decisionAnswer = { kind: 'yardOffice', train: e.trainId, take: e.take };
+      break;
+
     case 'localOpsOptionChosen':
       turnOf(s, e.player).option = e.option;
       break;
@@ -2089,7 +2283,8 @@ export function reduce(s: GameState, e: GameEvent): void {
       // Everything swept comes back as ONE pile, then §4.6-4.7's opening is re-run: three cards
       // turned face up as the Departments, the rest face down as the Home Office deck. The
       // Departments start one deep again, exactly as at setup.
-      s.decks.salvageYard = [];
+      // The spent trains stay where they are; everything else in the Yard has just been swept up.
+      s.decks.salvageYard = s.decks.salvageYard.filter((id) => isSpentTimetabledTrain(s, id));
       s.decks.departments = [[], [], []];
       const order = [...e.order];
       for (const pile of s.decks.departments) {
@@ -2154,14 +2349,23 @@ export function reduce(s: GameState, e: GameEvent): void {
     }
 
     case 'redFlagsSet': {
-      const node = s.division.nodes[e.node];
-      if (node?.kind === 'mainline') {
-        node.redFlagged = [...(node.redFlagged ?? []), e.trayId];
-      }
+      const node = officeNodeFor(s, e.seat);
+      if (node) node.redFlag = e.side;
       spendCard(s, e.player, e.cardId);
       break;
     }
 
+    /**
+     * §Q (Gitea#19) — `redFlagSpent` is NOT reduced, deliberately. It is emitted only by the phase
+     * driver, which mutates state itself and then describes it (`advance.ts`'s `spendFlag`), so a
+     * case here would be dead code that reads as the live one.
+     */
+
+    case 'redFlagRuled':
+      s.clock.pendingDecision = null;
+      s.clock.decisionAnswer = { kind: 'redFlag', train: e.trainId, flag: e.flag };
+      break;
+
     case 'flyingSwitch': {
       const tray = s.trays.get(e.trayId);
       const area = areaOf(s, e.player);
@@ -2311,7 +2515,15 @@ export function reduce(s: GameState, e: GameEvent): void {
     case 'trainScheduled':
       s.timetable[e.slot] = e.trainNumber;
       s.rngState = e.rngState;
-      s.decks.salvageYard.push(`train-${e.trainNumber}`);
+      /**
+       * THE CARD IS ALREADY IN THE SALVAGE YARD — `cardPlayed` put it there, by its real id.
+       *
+       * This used to push a second, SYNTHETIC `train-<number>` beside it, so scheduling four trains
+       * left eight entries in a pile holding four cards. Nothing ever read that id: it inflated the
+       * pile's depth, it displayed as "a card" because no such card exists, and
+       * `reshuffleIfDepleted` would have swept it into the draw deck to be drawn as an id with
+       * nothing behind it. Removed 2026-09-10 (Gitea#23).
+       */
       break;
 
     case 'carPlacedOnTrain': {
@@ -2518,7 +2730,7 @@ export function reduce(s: GameState, e: GameEvent): void {
     case 'clearanceGiven':
       s.clock.pendingDecision = null;
       // Recorded for the asking train to consume; otherwise the driver asks again forever.
-      s.clock.clearanceRuling = { train: e.trainId, allow: e.allow };
+      s.clock.decisionAnswer = { kind: 'clearance', train: e.trainId, allow: e.allow };
       break;
 
     default:
@@ -2531,7 +2743,8 @@ export function reduce(s: GameState, e: GameEvent): void {
  * index is out of range, which `check` reports rather than silently defaulting — a wrong
  * orientation is a different card, not a detail.
  */
-function protoCard(
+/** Exported for the same reason as `extendLimitsIfNeeded`: the bot builds the card a lay would place exactly as the reducer does. */
+export function protoCard(
   kind: { kind: string; geometry?: string; facility?: string; hand?: string },
   variant: number | undefined,
 ): TrackCard | null {
@@ -2768,9 +2981,34 @@ function spendCard(s: GameState, player: PlayerIndex, cardId: CardId): void {
  * that has genuinely used every card ends on `DECK_EMPTY` rather than reshuffling an empty pile.
  * Cards played onto the board are NOT recovered: they are on the table, which is where they belong.
  */
+/**
+ * §6.2, AND THE RULING THAT SETTLES IT — Jesse, 2026-09-10 (Gitea#23).
+ *
+ * "Once you've played a regularly scheduled train and it's in the salvage deck, that train is
+ * already on the timetable. It does not make sense to put that back into a reshuffled home deck to
+ * get played again. By contrast, a regularly scheduled train that's in a discard pile could
+ * potentially get reused later, and so should have that capability. Extras run one time and then
+ * they're done — if they are in the Salvage deck, they should get shuffled back in so that they
+ * could get run again."
+ *
+ * So the test is WHERE the card is, not only what it is. A timetabled train in the SALVAGE YARD was
+ * played: its number is on the timetable and cannot be scheduled twice, so the card is spent and
+ * stays out. The same card sitting in a DEPARTMENT was discarded, never played, and its slot is
+ * still open — so it comes back with everything else. An Extra is a single run rather than a
+ * standing slot, so a played one is free to be run again.
+ */
+function isSpentTimetabledTrain(s: GameState, id: CardId): boolean {
+  return s.cards.get(id)?.kind.kind === 'timetabledTrain';
+}
+
 function reshuffleIfDepleted(s: GameState, taking: number): GameEvent | null {
   if (s.decks.homeOffice.length > taking) return null;
-  const collected = [...s.decks.salvageYard, ...s.decks.departments.flat()];
+  const collected = [
+    // The Salvage Yard, less the trains whose slots are already filled — see above.
+    ...s.decks.salvageYard.filter((id) => !isSpentTimetabledTrain(s, id)),
+    // Every Department in full: a discarded train was never played, so it is still runnable.
+    ...s.decks.departments.flat(),
+  ];
   if (collected.length === 0) return null;
   const rng = createRng(s.rngState);
   return { type: 'deckReshuffled', order: rng.shuffle(collected), rngState: rng.getState() };
@@ -2897,7 +3135,8 @@ function applyModifier(area: OfficeArea, coord: GridCoord, modifier: ModifierKin
  * §8.1 and §10 both reason about "the track between the train and the Limits", Interlocking holds
  * an arrival AT the Limits, and running past a player's Limits is what makes a collision his fault.
  */
-function extendLimitsIfNeeded(area: OfficeArea, placed: GridCoord): void {
+/** Exported so the bot can score a lay on a copy of the district by the engine's own rule, not a copy of it. */
+export function extendLimitsIfNeeded(area: OfficeArea, placed: GridCoord): void {
   if (placed.row !== area.runningRow) return;
 
   if (placed.col <= area.limitsWest.col) {
@@ -2921,7 +3160,20 @@ function extendLimitsIfNeeded(area: OfficeArea, placed: GridCoord): void {
  * this. A second copy stalled the game outright: the phase believed a car could be added while
  * `check` rejected every option, so the Stage never completed.
  */
-export function acceptsCar(tray: CrewTray, carType: CarType): boolean {
+export function acceptsCar(
+  tray: CrewTray,
+  carType: CarType,
+  /**
+   * Whether the car being offered is loaded, and what the Division Yard still holds.
+   *
+   * Both optional so that a caller asking the SHAPE question — "does this card take a car of this
+   * category at all?" — need not answer the loading question. `trainNeedingCars` asks the shape
+   * question of every car in the yard; `check` asks the full one about a specific car a player has
+   * named. Omitting them skips the loading rules rather than guessing at them.
+   */
+  loaded?: boolean,
+  yard?: readonly RollingStock[],
+): boolean {
   const profile = trainProfile(tray.trainNumber ?? 0, tray.trainIsExtra);
   if (!profile) return true;
 
@@ -2944,6 +3196,40 @@ export function acceptsCar(tray: CrewTray, carType: CarType): boolean {
   const types = profile.consist.freightTypes;
   if (adding === 'freight' && types && !types.includes(carType)) return false;
 
+  if (loaded === undefined) return true;
+
+  /**
+   * X13 APPLESEED — "may drop MTs but not pick up anything", and its consist prints EMPTIES ONLY.
+   *
+   * `emptiesOnly` was declared on the card, RENDERED to the player as "(empties only)" by both
+   * `web/game.ts` and `sim/view.ts`, and enforced by nothing: the Appleseed could be made up with
+   * loaded cars while its own card said it could not. Found while building Gitea#13, which is the
+   * same rule pointing the other way, and fixed with it rather than left as the odd one out.
+   *
+   * A caboose is exempt. Every caboose in `ROLLING_STOCK_SUPPLY` is `loaded: true` — there is no
+   * such thing as an empty one — so applying this to the caboose would bar the Appleseed from the
+   * caboose its own consist calls for.
+   */
+  if (profile.consist.emptiesOnly && loaded && adding !== 'caboose') return false;
+
+  /**
+   * MUST RUN LOADED (Gitea#13) — a preference order, not a flat requirement.
+   *
+   * "If not loaded, then empty, and if none available, run without." So an EMPTY is refused only
+   * while the yard can still supply a loaded car this train would accept; once it cannot, the empty
+   * becomes legal and the train may also simply depart short. Asked of the yard rather than
+   * remembered on the tray, because the yard is what the rule is about and it changes under the
+   * train as other consists are built.
+   *
+   * The caboose is exempt for the same reason as above.
+   */
+  if (profile.rules.mustRunLoaded && !loaded && adding !== 'caboose' && yard) {
+    const loadedAvailable = yard.some(
+      (c) => c.loaded && cat(c.type) === adding && acceptsCar(tray, c.type),
+    );
+    if (loadedAvailable) return false;
+  }
+
   return true;
 }
 
@@ -2984,11 +3270,21 @@ export function isBeingMadeUp(tray: CrewTray): boolean {
 export function trainNeedingCars(s: GameState): TrayId | null {
   for (const [id, tray] of s.trays) {
     if (!isBeingMadeUp(tray)) continue;
-    // Consists are specified by CATEGORY — "Freight (2)" is any two freight cars — so any car in
-    // the yard is potentially suitable unless the card narrows it. Ask the SAME predicate `check`
-    // uses: a separate copy of this test stalled the game, because the phase believed a car could
-    // be added while `check` rejected every option, so the Stage never ended.
-    if (s.yards.divisionYard.some((c) => acceptsCar(tray, c.type))) return id;
+    /**
+     * Consists are specified by CATEGORY — "Freight (2)" is any two freight cars — so any car in
+     * the yard is potentially suitable unless the card narrows it. Ask the SAME predicate `check`
+     * uses: a separate copy of this test stalled the game, because the phase believed a car could
+     * be added while `check` rejected every option, so the Stage never ended.
+     *
+     * ASKED PER CAR, WITH ITS LOADED STATE, since Gitea#13. The shape question alone is no longer
+     * the same question `check` answers: an `emptiesOnly` train looking at a yard of nothing but
+     * loaded cars, or a `mustRunLoaded` train offered only empties while loaded ones remain, would
+     * both be told a car was available and then refused every one of them — the very stall this
+     * comment was written about.
+     */
+    if (s.yards.divisionYard.some((c) => acceptsCar(tray, c.type, c.loaded, s.yards.divisionYard))) {
+      return id;
+    }
   }
   return null;
 }
@@ -3034,13 +3330,35 @@ function limitsCard(): TrackCard {
 // Public entry point
 // ---------------------------------------------------------------------------
 
-export function applyIntent(s: GameState, player: PlayerIndex, i: Intent): ApplyResult {
-  const code = check(s, player, i);
-  if (code) return { ok: false, code, message: `${i.type} rejected: ${code}` };
+/**
+ * THE FIRST HALF OF `applyIntent`: decide, without changing anything.
+ *
+ * `check` and `execute` read the same unchanged position, so its routes are walked once between them
+ * (`withRouteCache`). Never writes `s`. Split out for a caller that decides many intents against ONE
+ * position and applies each to a COPY of it — the switching planner — which can then share that
+ * position's routes across every candidate instead of re-walking them on each copy.
+ */
+export function prepareIntent(s: GameState, player: PlayerIndex, i: Intent): ApplyResult {
+  const prepared = withRouteCache(s, (): { code: RejectionCode } | { events: GameEvent[] } => {
+    const code = check(s, player, i);
+    return code ? { code } : { events: execute(s, player, i) };
+  });
+  if ('code' in prepared) return { ok: false, code: prepared.code, message: `${i.type} rejected: ${prepared.code}` };
+  return { ok: true, events: prepared.events };
+}
 
-  const events = execute(s, player, i);
+/** THE SECOND HALF: fold events `prepareIntent` produced into a state equal to the one it read. */
+export function commitEvents(s: GameState, events: readonly GameEvent[]): void {
   for (const e of events) reduce(s, e);
-  return { ok: true, events };
+  // Gitea#16 — the intent half of the fold; `advance` does the phase driver's half. See `tally.ts`
+  // for why it cannot simply live inside `reduce`.
+  for (const e of events) tallyEvent(s, e);
+}
+
+export function applyIntent(s: GameState, player: PlayerIndex, i: Intent): ApplyResult {
+  const r = prepareIntent(s, player, i);
+  if (r.ok) commitEvents(s, r.events);
+  return r;
 }
 
 export { isOperationalRail, destinationsFor };

src/engine/content.ts

@@ -72,6 +72,26 @@ export type TrackProfile = {
  * from `docs/Deck cards2.xlsx`, a fixed document, and stay here as the audit trail for the
  * transcription — they are not claims about what the game deals today.
  *
+ * THE COUNTS BELOW NOW COME FROM `docs/Deck cards5.xlsx` (Gitea#14), which HALVES every track row
+ * against sheet 2: straight 32 → 16, each curve 16 → 8, each turnout 16 → 8. Track is the only
+ * section of that sheet whose numbers moved — every station, industry, modifier and train row is
+ * character-for-character what sheet 2 said — so this is the whole of the deck change it asks for.
+ *
+ * Sheet 5 also deals the sharp curves ZERO, which is where they already were: Jesse took them out
+ * for the reason below, and RAR arrived at the same number independently. Nothing to do, but worth
+ * recording that the two agree rather than leaving it looking like a coincidence.
+ *
+ * IT LANDS ON RAR'S OWN TARGETS, which is the check that matters — the top right of sheet 5 states
+ * the draw rates he is designing to. Against his denominators (start cards counted for track, only
+ * the non-track deck counted for trains): he wants track 48/167 = **28.7%** and trains 22/107 =
+ * **20.6%**; this deck gives 48/170 = **28.2%** and 22/110 = **20.0%**.
+ *
+ * THAT MATCH IS PARTLY A CANCELLATION, and whoever retunes next should know it. The engine holds
+ * ~25 more office and industry cards than the sheet (doubled and tripled, below) and is missing the
+ * ~33 Safety, Event, Inspection and Space-use cards sheet 5 lists, which Gitea#14 defers. The two
+ * errors are opposite and nearly equal today. Build the deferred categories and they stop
+ * cancelling, so the ratios have to be re-measured then rather than assumed to have held.
+ *
  * It matters well beyond bookkeeping. Track competes for the draw with industry, trains and
  * enhancements, so building a district is paid for in cards you did not draw instead — and the
  * hand-of-three is the real constraint on how fast a railroad grows.
@@ -86,9 +106,9 @@ export type TrackProfile = {
  * published replay still plays. Reordering to look tidy would silently re-deal every saved game.
  */
 export const TRACK_CARDS: readonly TrackProfile[] = [
-  { geometry: 'straight', hand: 'none', name: 'Straight track', copiesInDeck: 32, isOperationalRail: true, moveCost: 1 },
-  { geometry: 'curved', hand: 'right', name: 'Curved track (right)', copiesInDeck: 16, isOperationalRail: true, moveCost: 1 },
-  { geometry: 'curved', hand: 'left', name: 'Curved track (left)', copiesInDeck: 16, isOperationalRail: true, moveCost: 1 },
+  { geometry: 'straight', hand: 'none', name: 'Straight track', copiesInDeck: 16, isOperationalRail: true, moveCost: 1 },
+  { geometry: 'curved', hand: 'right', name: 'Curved track (right)', copiesInDeck: 8, isOperationalRail: true, moveCost: 1 },
+  { geometry: 'curved', hand: 'left', name: 'Curved track (left)', copiesInDeck: 8, isOperationalRail: true, moveCost: 1 },
   /**
    * SHARP CURVES ARE DEALT ZERO COPIES — Jesse's call, and the same treatment as Poling.
    *
@@ -103,8 +123,8 @@ export const TRACK_CARDS: readonly TrackProfile[] = [
    */
   { geometry: 'sharpCurved', hand: 'right', name: 'Sharp Curved Track (right)', copiesInDeck: 0, isOperationalRail: true, moveCost: 2 },
   { geometry: 'sharpCurved', hand: 'left', name: 'Sharp Curved Track (left)', copiesInDeck: 0, isOperationalRail: true, moveCost: 2 },
-  { geometry: 'turnout', hand: 'right', name: 'Turnout (right)', copiesInDeck: 16, isOperationalRail: false, moveCost: 1 },
-  { geometry: 'turnout', hand: 'left', name: 'Turnout (left)', copiesInDeck: 16, isOperationalRail: false, moveCost: 1 },
+  { geometry: 'turnout', hand: 'right', name: 'Turnout (right)', copiesInDeck: 8, isOperationalRail: false, moveCost: 1 },
+  { geometry: 'turnout', hand: 'left', name: 'Turnout (left)', copiesInDeck: 8, isOperationalRail: false, moveCost: 1 },
 ];
 
 /** Summed from `copiesInDeck` above, never written down — it moves whenever the deck is retuned. */
@@ -143,29 +163,39 @@ export type OfficeProfile = {
  * passenger modifier cards (Waiting Area, Restaurant, Hotel).
  */
 /**
- * Office cards. Every tier's `copiesInDeck` was **doubled** against the recovered design — Q12.
+ * Office cards, at `docs/Deck cards5.xlsx`'s counts exactly: Depot 4, Station 2, Terminal 1.
  *
- * Players always start at a Whistle Post, which has ONE A/D track, so a second arrival is an
- * automatic collision (§8.3, Gap 2a). Measured at the original density, 25 of 100 games never drew
- * a Depot and never escaped: they averaged **−6.0** revenue against **−0.4** for games that
- * upgraded at least once, and 25 of 26 collisions happened at Whistle Post.
+ * THE Q12 DOUBLING IS GONE (Gitea#14). Every tier used to be dealt at twice the sheet, to remove a
+ * 25% chance of an unwinnable opening deal: players always start at a Whistle Post, which has ONE
+ * A/D track, so a second arrival is an automatic collision (§8.3, Gap 2a), and measured at the
+ * sheet's density 25 of 100 games never drew a Depot and never escaped — averaging **−6.0** revenue
+ * against **−0.4** for games that upgraded at least once, with 25 of 26 collisions at a Whistle
+ * Post.
+ *
+ * That measurement was taken against a deck with 96 track cards in it, and the failure it describes
+ * does not survive the halving of track. RE-MEASURED at the sheet's counts, 100 games: **43 of 100**
+ * never upgrade off a Whistle Post, up from 25 — but they average **−0.2** revenue against **+1.4**
+ * for games that do upgrade, where the gap used to be −6.0 against −0.4. Collisions fell from 26 per
+ * 100 games to **6**, and only 3 of those are in games that never upgraded, against 25 of 26 before.
+ *
+ * So staying at a Whistle Post is now common and survivable rather than rare and fatal, which is the
+ * opposite of the shape Q12 was answering: with fewer trains reaching an Office, a single A/D track
+ * is seldom contested. The doubling was the blunt instrument its own note called it, and at the
+ * sheet's deck size it costs more than it buys — see `TRACK_CARDS` for the whole comparison and
+ * `INDUSTRY_PROFILES` for the other half of the same decision.
  *
  * Upgrades are strictly sequential (Gap 3b, no skipping), so Station and Terminal are rarer than
- * their raw counts imply — Terminal needs all three cards in order. Station and Terminal were
- * doubled with Depot to keep that ladder in proportion rather than making Depot a special case.
+ * their raw counts imply — Terminal needs all three cards in order.
  *
- * PROVISIONAL — re-evaluate. This was chosen to remove a 25% chance of an unwinnable opening deal,
- * not from the recovered design, and it is a blunt instrument: it lifts the whole office ladder and
- * dilutes every other category slightly. Revisit once the victory target is settled and freight is
- * carrying its intended share; the right answer may instead be fewer Terminals, a cheaper first
- * upgrade, or more A/D capacity at Whistle Post. The counts themselves are in the rows below, which
- * is the only place they should be read from.
+ * IF THE OPENING BITES AGAIN, the fix is not to re-double this. The note it replaces already listed
+ * the better options: fewer Terminals, a cheaper first upgrade, or more A/D capacity at a Whistle
+ * Post. Any of those answers the collision without diluting every other category to do it.
  */
 export const OFFICE_PROFILES: readonly OfficeProfile[] = [
   { tier: 'whistlePost', name: 'Whistle Post', isControlPoint: false, isPassengerFacility: false, adTracks: 1, porters: 0, passengerOut: 0, passengerIn: 0, copiesInDeck: 0 },
-  { tier: 'depot', name: 'Depot', isControlPoint: true, isPassengerFacility: true, adTracks: 2, porters: 1, passengerOut: 1, passengerIn: 1, copiesInDeck: 8 },
-  { tier: 'station', name: 'Station', isControlPoint: true, isPassengerFacility: true, adTracks: 3, porters: 2, passengerOut: 2, passengerIn: 2, copiesInDeck: 4 },
-  { tier: 'terminal', name: 'Terminal', isControlPoint: true, isPassengerFacility: true, adTracks: 4, porters: 3, passengerOut: 3, passengerIn: 3, copiesInDeck: 2 },
+  { tier: 'depot', name: 'Depot', isControlPoint: true, isPassengerFacility: true, adTracks: 2, porters: 1, passengerOut: 1, passengerIn: 1, copiesInDeck: 4 },
+  { tier: 'station', name: 'Station', isControlPoint: true, isPassengerFacility: true, adTracks: 3, porters: 2, passengerOut: 2, passengerIn: 2, copiesInDeck: 2 },
+  { tier: 'terminal', name: 'Terminal', isControlPoint: true, isPassengerFacility: true, adTracks: 4, porters: 3, passengerOut: 3, passengerIn: 3, copiesInDeck: 1 },
 ];
 
 export const OFFICE_ORDER: readonly OfficeTier[] = ['whistlePost', 'depot', 'station', 'terminal'];
@@ -202,15 +232,24 @@ export type IndustryProfile = {
 };
 
 /**
- * Industry density (Gap 12). The recovered sheet lists 9 industries in a 115-card deck; the
- * prototype ran 10 in 52. At the sheet's density a game saw 1.6 Freight Facilities, freight was 10%
- * of gross revenue, and `carsCoupled` fired 4 times per 100 games — the freight loop, which is the
- * point of the game, effectively never ran.
+ * Industry density, at `docs/Deck cards5.xlsx`'s counts exactly (Gitea#14).
  *
- * Each industry's `copies` is TRIPLED against the sheet, which restores roughly the prototype's
- * ratio while preserving the sheet's proportions exactly: the outbound/inbound balance and the
- * lockout structure are unchanged, because every kind scales by the same factor. The multiplier is
- * the decision; the resulting totals are in the rows below and move with every retune.
+ * THE GAP-12 TRIPLING IS GONE. The recovered sheet listed 9 industries in a 115-card deck and the
+ * prototype ran 10 in 52; at that density a game saw 1.6 Freight Facilities, freight was 10% of
+ * gross revenue, and `carsCoupled` fired 4 times per 100 games, so the freight loop effectively
+ * never ran. Tripling every kind restored roughly the prototype's ratio.
+ *
+ * ALL OF THAT WAS MEASURED AGAINST A DECK WITH 96 TRACK CARDS. Sheet 5 halves the track, and the
+ * tripling then works backwards: the deck keeps dealing industries while the district stays too
+ * small to reach them. Measured over 300 bot games on identical seeds — 96 track with the multiplier
+ * / 48 track with it / 48 track without — reefer cars set out by a crew went **49 / 0 / 39** and
+ * mean revenue **−0.20 / +0.22 / +0.27**. The middle column is the tripling meeting the halved
+ * deck: it wipes out the reefer chain completely. The sheet's own density is the best of the three
+ * on both counts.
+ *
+ * The sheet's proportions were always preserved by the multiplier, since every kind scaled by the
+ * same factor — so removing it changes the density and nothing else. The outbound/inbound balance
+ * and the lockout structure below are the sheet's, as they always were.
  */
 /**
  * LOCKOUTS, from the sheet's "Lockouts" column verbatim:
@@ -233,8 +272,8 @@ export type IndustryProfile = {
  * enforced for every kind in `isLockedOut`, not repeated in each row here.
  */
 export const INDUSTRY_PROFILES: readonly IndustryProfile[] = [
-  { kind: 'freightHouse', name: 'Freight House', carTypes: ['boxcar'], flow: 'both', baseOut: 1, baseIn: 1, baseLoaders: 1, lockouts: ['grocersWarehouse'], copies: 6 },
-  { kind: 'mineTipple', name: 'Mine Tipple', carTypes: ['hopper'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['powerPlant'], copies: 6 },
+  { kind: 'freightHouse', name: 'Freight House', carTypes: ['boxcar'], flow: 'both', baseOut: 1, baseIn: 1, baseLoaders: 1, lockouts: ['grocersWarehouse'], copies: 2 },
+  { kind: 'mineTipple', name: 'Mine Tipple', carTypes: ['hopper'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['powerPlant'], copies: 2 },
   /**
    * OUTBOUND ONLY. A Refinery ships oil out and receives nothing; reported from playtesting and
    * confirmed by Jesse (v0.4.9e): "only ships out tanks, does not receive anything".
@@ -252,9 +291,9 @@ export const INDUSTRY_PROFILES: readonly IndustryProfile[] = [
    * the game with no way to raise the direction it is supposed to use half its capacity on.
    * `StationMaster-Home-Deck-v0.4.5.md` prints it "Outbound, 1 out / 0 in".
    */
-  { kind: 'refinery', name: 'Refinery', carTypes: ['tank'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['powerPlant'], copies: 3 },
-  { kind: 'powerPlant', name: 'Power Plant', carTypes: ['hopper', 'tank'], flow: 'inbound', baseOut: 0, baseIn: 1, baseLoaders: 1, lockouts: ['mineTipple', 'refinery'], copies: 6 },
-  { kind: 'packingSheds', name: 'Packing Sheds', carTypes: ['reefer'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['grocersWarehouse'], copies: 3 },
+  { kind: 'refinery', name: 'Refinery', carTypes: ['tank'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['powerPlant'], copies: 1 },
+  { kind: 'powerPlant', name: 'Power Plant', carTypes: ['hopper', 'tank'], flow: 'inbound', baseOut: 0, baseIn: 1, baseLoaders: 1, lockouts: ['mineTipple', 'refinery'], copies: 2 },
+  { kind: 'packingSheds', name: 'Packing Sheds', carTypes: ['reefer'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['grocersWarehouse'], copies: 1 },
   /**
    * INBOUND ONLY — the mirror of the Refinery above, and the same correction. Reported from
    * playtesting and confirmed by Jesse (v0.4.9e): "Grocer's Warehouse should be receive only, does
@@ -267,7 +306,7 @@ export const INDUSTRY_PROFILES: readonly IndustryProfile[] = [
    * other example. The Truck Dock (+1 inbound) and Local Small Groceries (+1 Laborer) are the two
    * that do work here.
    */
-  { kind: 'grocersWarehouse', name: "Grocer's Warehouse", carTypes: ['boxcar', 'reefer'], flow: 'inbound', baseOut: 0, baseIn: 1, baseLoaders: 1, lockouts: ['packingSheds', 'freightHouse'], copies: 3 },
+  { kind: 'grocersWarehouse', name: "Grocer's Warehouse", carTypes: ['boxcar', 'reefer'], flow: 'inbound', baseOut: 0, baseIn: 1, baseLoaders: 1, lockouts: ['packingSheds', 'freightHouse'], copies: 1 },
 ];
 
 /** Legacy alias; the engine still reads FREIGHT_PROFILES in places. */
@@ -395,6 +434,19 @@ export type TrainRules = {
   /** X17 Campaign, X18 Circus: a scheduled stop that does something. */
   stopEarnsPoint?: boolean;
   stopThenExpedite?: boolean;
+  /**
+   * MUST RUN LOADED (Gitea#13) — X17 Campaign, X18 Circus, X19 Military.
+   *
+   * "I've redefined some of the extra trains that they have to run full boxcars (not just any crazy
+   * stuff) — military trains, circus trains, etc. If not loaded, then empty, and if none available,
+   * run without." So it is a PREFERENCE ORDER enforced at make-up, not a flat requirement: a loaded
+   * car of an acceptable type must be taken while one is in the Division Yard; only once none is
+   * left may an empty be taken; and a train may still depart short (§8.2 already allows fewer cars
+   * than the card lists).
+   *
+   * Distinct from `ConsistSpec.emptiesOnly`, which is the opposite rule for X13 Appleseed.
+   */
+  mustRunLoaded?: boolean;
   /**
    * `copiesNextScheduled` was here and is DELETED. No train card ever carried it: a Second Section
    * is a Maneuver card played on a train that is due out, and it has its own intent
@@ -429,8 +481,11 @@ export const TIMETABLED_TRAINS: readonly TrainProfile[] = [
    * COACH COUNTS ON 1/2 AND 5/6 WERE SWAPPED BY JESSE (Gitea#7, v0.4.9e playtest): the Crack Limited
    * drops from three coaches to two, and The Sparrow rises from two to three. A change to the card
    * faces themselves, not a transcription fix — `Trains3.pdf` and the tables that transcribe it
-   * still print the old numbers, so `docs/rules/card-reference.md` is the place that now carries
-   * what the cards say.
+   * still print the old numbers, so `docs/rules/as-built.md` is the place that now carries what
+   * the cards say — GENERATED from the constants below by `scripts/build-card-reference.ts`, with
+   * `test/card-reference.test.ts` failing if the two disagree. This comment used to name
+   * `card-reference.md`, which describes the v0.4.5 deck and carries a banner saying not to use its
+   * numbers; the code sent readers to a table it had itself superseded.
    */
   ...pair(1, 'Crack Limited', 'fast', { freight: 0, coach: 2, caboose: 0 },
     { terminalsOnly: true, noSwitching: true, expedite: true, note: 'Stop at Terminals only.' }),
@@ -453,9 +508,9 @@ export const EXTRA_TRAINS: readonly TrainProfile[] = [
   { number: 14, isExtra: true, name: 'Fruit Growers Express', speed: 'fast', direction: 'playerChoice', consist: { freight: 2, coach: 0, caboose: 1, freightTypes: ['reefer'] }, rules: { expedite: true, note: 'Reefers only. May pick up one extra loaded reefer.' } },
   { number: 15, isExtra: true, name: 'Yard Xfer', speed: 'slow', direction: 'playerChoice', consist: { freight: 2, coach: 0, caboose: 1 }, rules: {} },
   { number: 16, isExtra: true, name: 'Light Engine Move', speed: 'fast', direction: 'playerChoice', consist: { freight: 0, coach: 0, caboose: 0 }, rules: { noSwitching: true, note: 'No cars at all.' } },
-  { number: 17, isExtra: true, name: 'Campaign Train', speed: 'fast', direction: 'playerChoice', consist: { freight: 0, coach: 1, caboose: 0 }, rules: { noSwitching: true, stopThenExpedite: true, note: 'One turn at station (speeches) then expedite.' } },
-  { number: 18, isExtra: true, name: 'Circus Train', speed: 'slow', direction: 'playerChoice', consist: { freight: 2, coach: 1, caboose: 1 }, rules: { noSwitching: true, stopEarnsPoint: true, note: 'One turn stopped on any track (circus set-up) earns 1 point.' } },
-  { number: 19, isExtra: true, name: 'Military Train', speed: 'slow', direction: 'playerChoice', consist: { freight: 1, coach: 2, caboose: 0 }, rules: { noSwitching: true, noPassengerWork: true, expedite: true } },
+  { number: 17, isExtra: true, name: 'Campaign Train', speed: 'fast', direction: 'playerChoice', consist: { freight: 0, coach: 1, caboose: 0 }, rules: { noSwitching: true, stopThenExpedite: true, stopEarnsPoint: true, mustRunLoaded: true, note: 'One turn at station (speeches) then expedite. Earns a point per Office Area if the candidate is aboard.' } },
+  { number: 18, isExtra: true, name: 'Circus Train', speed: 'slow', direction: 'playerChoice', consist: { freight: 2, coach: 1, caboose: 1 }, rules: { noSwitching: true, stopEarnsPoint: true, mustRunLoaded: true, note: 'One turn stopped in an Office Area (circus set-up) earns 1 point, once per Area, if fully loaded.' } },
+  { number: 19, isExtra: true, name: 'Military Train', speed: 'slow', direction: 'playerChoice', consist: { freight: 1, coach: 2, caboose: 0 }, rules: { noSwitching: true, noPassengerWork: true, expedite: true, mustRunLoaded: true, note: 'Troops and materiel: runs loaded where the yard can supply it.' } },
   { number: 20, isExtra: true, name: "Director's private car", speed: 'slow', direction: 'playerChoice', consist: { freight: 2, coach: 1, caboose: 0 }, rules: { noPassengerWork: true } },
   { number: 21, isExtra: true, name: 'Freight Extra', speed: 'slow', direction: 'playerChoice', consist: { freight: 3, coach: 0, caboose: 1 }, rules: {} },
   { number: 22, isExtra: true, name: 'Pee-Dee', speed: 'slow', direction: 'playerChoice', consist: { freight: 0, coach: 0, caboose: 1 }, rules: { pickUpEmptiesOnly: true, note: 'Per-diem train. May only pick up MTs.' } },
@@ -504,23 +559,35 @@ export type MainlineKind =
   | 'uncontrolledSiding' | 'tunnel' | 'trestle' | 'interchange';
 
 /**
- * Speed as printed. `60` and `30` appear on the cards; Hilly prints P60/F30, and Heavy Grade prints
- * "G" — no number at all, plus "Player sets orientation", **which the game deliberately does not do**
- * (see `gradeReduction` below, and implications.md §10 Q11).
+ * THE PRINTED SPEEDS ARE GRAPHICS. RAR, 2026-08-26 (Gitea#3): "please ignore the speed signs I put
+ * on the cards — those are nothing but scene-setting graphics that mimic the speed you are
+ * travelling. It's just ambiance, nothing more."
  *
- * WHAT THESE NUMBERS MEAN IS NOT YET SETTLED — see implications.md §10 Q2. Transcribed as data so
- * the answer can be applied without re-reading the cards.
+ * They used to decide everything: a `MainlineSpeed` of 60 meant one Stage and a 30 meant two, plus
+ * one more for a Slow train. Both rules are gone. **What crosses a card is REGIONS** — the boxes
+ * printed on it — one per Stage, and where a train STARTS decides how many it has left to run.
  */
-export type MainlineSpeed =
-  | { kind: 'uniform'; value: number }
-  | { kind: 'byTrainType'; passenger: number; freight: number }
-  | { kind: 'grade' };
-
 export type MainlineProfile = {
   kind: MainlineKind;
   name: string;
-  speed: MainlineSpeed;
-  /** Double Track and Uncontrolled Siding: "Trains may pass". */
+  /** Regions printed on the card. A train advances one per Stage, so a full run costs `regions`. */
+  regions: number;
+  /**
+   * The region an ordinary train enters at. Zero on nearly everything — but the Uncontrolled Siding
+   * and the Interchange print a back region that is a siding or a holding spur rather than part of
+   * the road, so a train running straight through starts past it and crosses in one Stage.
+   */
+  defaultStart: number;
+  /**
+   * Cards that print a FAST and a SLOW start, and the region each begins at. "Some cards say fast /
+   * slow. This is an indication that if on the train card, the train is listed as fast or slow,
+   * that's starting position / how many stages it takes to traverse the card. Fast / Slow does not
+   * apply to every card — just those that say fast / slow on them. Currently this is only hilly."
+   *
+   * So the train's rating is read HERE and nowhere else. It used to add a Stage to every card.
+   */
+  speedStarts?: { fast: number; slow: number };
+  /** Double Track: "Trains may pass". */
   trainsMayPass: boolean;
   /** Interchange: "Sort cars in new order". */
   sortsCars: boolean;
@@ -529,30 +596,56 @@ export type MainlineProfile = {
 };
 
 export const MAINLINE_PROFILES: readonly MainlineProfile[] = [
-  { kind: 'plains', name: 'Plains', speed: { kind: 'uniform', value: 60 }, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
-  { kind: 'curves', name: 'Curves', speed: { kind: 'uniform', value: 30 }, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
-  { kind: 'hilly', name: 'Hilly', speed: { kind: 'byTrainType', passenger: 60, freight: 30 }, trainsMayPass: false, sortsCars: false, entryPoints: ['passenger', 'freight'] },
+  { kind: 'plains', name: 'Plains', regions: 1, defaultStart: 0, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
+  { kind: 'curves', name: 'Curves', regions: 2, defaultStart: 0, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
   /**
-   * `entryPoints` is TRANSCRIBED, NOT READ — nothing anywhere reads this field on any profile, and
-   * the printed start positions are not modelled: `crossingStages` counts Stages instead. Recorded
-   * here because implications.md §6 describes the card as having FIVE distinct starts (plain,
-   * brakemen, airbrakes, plain, helpers) against the four listed, and that discrepancy should be
-   * settled against `Mainline Cards.pdf` if the starts are ever implemented — not quietly "fixed"
-   * now, when nothing depends on it either way.
+   * THE ONLY CARD THAT READS A TRAIN'S FAST/SLOW RATING. A fast train starts in the second region
+   * and is across in one Stage; a slow one starts at the beginning and takes two.
+   *
+   * It used to read the CONSIST instead — any coach aboard made the train "passenger" for this card
+   * — off the printed P60/F30. RAR corrected that directly: "I notice that you are basing stages in
+   * mainline cards off coach/non-coach. Actually, all trains are rated as FAST and SLOW."
    */
-  { kind: 'heavyGrade', name: 'Heavy Grade', speed: { kind: 'grade' }, trainsMayPass: false, sortsCars: false, entryPoints: ['start', 'brakemen', 'airbrakes', 'helpers'] },
-  { kind: 'doubleTrack', name: 'Double Track', speed: { kind: 'uniform', value: 60 }, trainsMayPass: true, sortsCars: false, entryPoints: ['start'] },
-  { kind: 'uncontrolledSiding', name: 'Uncontrolled Siding', speed: { kind: 'uniform', value: 60 }, trainsMayPass: true, sortsCars: false, entryPoints: ['noPass', 'passingTrains'] },
-  { kind: 'tunnel', name: 'Tunnel', speed: { kind: 'uniform', value: 30 }, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
-  { kind: 'trestle', name: 'Trestle', speed: { kind: 'uniform', value: 60 }, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
+  { kind: 'hilly', name: 'Hilly', regions: 2, defaultStart: 0, speedStarts: { fast: 1, slow: 0 }, trainsMayPass: false, sortsCars: false, entryPoints: ['fast', 'slow'] },
   /**
-   * RENAMED FROM "Yard" after play. The card is unchanged — same 60, same "sort cars in new
-   * order", same entry points, same art — but "Yard" collided with the Division Yard, the
-   * Classification Yard, the Salvage Yard, the Yard Office and the Small Yard, none of which are
-   * this. Its own key is renamed with it, so the two never drift apart. Those OTHER yards are
-   * deliberately left alone: they are different things that merely shared a word.
+   * THREE REGIONS, AND THE MODIFIERS MOVE THE START RATHER THAN CUTTING THE TIME — which comes to
+   * the same number of Stages and is how the card is actually printed and played. "If you play the
+   * home deck card 'helpers' against the mainline card heavy grade, it remains there the rest of the
+   * game and helps all trains going up hill by starting 1 region easier — so 2 to traverse, not 3.
+   * Other cards help the other direction, similar idea. Airbrakes is an upgrade from brakemen (which
+   * must be played first)."
+   *
+   * So: Helpers moves an UPHILL train up one region; Brakeman moves a DOWNHILL train up one, and
+   * Airbrakes another on top of it. A fully-equipped grade is one Stage downhill and two up.
    */
-  { kind: 'interchange', name: 'Interchange', speed: { kind: 'uniform', value: 60 }, trainsMayPass: false, sortsCars: true, entryPoints: ['start', 'sortCars'] },
+  { kind: 'heavyGrade', name: 'Heavy Grade', regions: 3, defaultStart: 0, trainsMayPass: false, sortsCars: false, entryPoints: ['start', 'brakemen', 'airbrakes', 'helpers'] },
+  { kind: 'doubleTrack', name: 'Double Track', regions: 1, defaultStart: 0, trainsMayPass: true, sortsCars: false, entryPoints: ['start'] },
+  /**
+   * TWO REGIONS, AND THE BACK ONE IS THE SIDING. A train with the card to itself starts past it and
+   * crosses in one Stage. "Uncontrolled siding: if a train already exists when you arrive, you go in
+   * the second stage back (you are in the siding and are one behind the other train). This prevents
+   * a collision — since you are not in same exact location."
+   *
+   * `trainsMayPass` is FALSE here, and used to be true. Two trains fit, but not by passing: the
+   * second one takes the siding and sits a region behind, which is what keeps them apart. Leaving it
+   * true skipped the collision test altogether and made the siding do nothing at all.
+   */
+  { kind: 'uncontrolledSiding', name: 'Uncontrolled Siding', regions: 2, defaultStart: 1, trainsMayPass: false, sortsCars: false, entryPoints: ['through', 'siding'] },
+  { kind: 'tunnel', name: 'Tunnel', regions: 2, defaultStart: 0, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
+  { kind: 'trestle', name: 'Trestle', regions: 1, defaultStart: 0, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
+  /**
+   * RENAMED FROM "Yard" after play. The card is unchanged — same "sort cars in new order", same art
+   * — but "Yard" collided with the Division Yard, the Classification Yard, the Salvage Yard, the
+   * Yard Office and the Small Yard, none of which are this. Its own key is renamed with it, so the
+   * two never drift apart. Those OTHER yards are deliberately left alone: they are different things
+   * that merely shared a word.
+   *
+   * TWO REGIONS, the back one a holding spur, exactly as the Uncontrolled Siding: "interchange has
+   * new extras show up in second region (like uncontrolled siding)", and earlier, "Plains is 1 stage
+   * for ALL trains. So are interlockings, with a second stage for incoming extras to hold at." A
+   * train running through crosses in one Stage; an Extra beginning its run here starts at the back.
+   */
+  { kind: 'interchange', name: 'Interchange', regions: 2, defaultStart: 1, trainsMayPass: false, sortsCars: true, entryPoints: ['through', 'extraStart'] },
 ];
 
 /**
@@ -579,44 +672,63 @@ export const MAINLINE_DECK: readonly MainlineKind[] = [
 ];
 
 /**
- * How many Stages a train needs to cross a Mainline card.
+ * WHERE A TRAIN ENTERS A MAINLINE CARD, and therefore how long it takes to cross (Gitea#3).
  *
- * Q1 — the printed 60/30 are miles per hour expressed as crossing time: a 60 card takes one Stage,
- * a 30 card takes two. The cells drawn on the cards are decoration.
- * Q2 — a Slow train adds one Stage to every card.
+ * "Regions shown on cards indicate how many stages it takes to cross. Plains is 1. Double track is
+ * 1, tunnel is 2, curves is 2, heavy grade is 3 unless you have help." A train advances one region
+ * per Stage, so the whole of crossing time is `regions - startRegion`.
  *
- * Hilly prints P60/F30, so it reads the consist rather than the speed class: a train carrying any
- * coach is "passenger" for this purpose.
+ * FOUR THINGS MOVE THE START, and nothing else does:
+ *
+ *   1. the card's own `defaultStart` — the Uncontrolled Siding and the Interchange print a back
+ *      region that is not part of the road, so a train running through begins past it;
+ *   2. `speedStarts`, on a card that prints a Fast and a Slow start. Only Hilly does;
+ *   3. the permanent Heavy Grade modifiers, which move a train one region up the hill each;
+ *   4. `takesSiding` / `startsAtBack`, the two occupancy cases below.
+ *
+ * WHAT NO LONGER MOVES IT: the printed mph, which is now scenery, and a train's Fast/Slow rating on
+ * any card but Hilly. That rating used to add a Stage to EVERY card, which is what made a Slow train
+ * cross Double Track in two Stages and produced the report this issue opened with.
  */
-export function crossingStages(
-  kind: MainlineKind,
-  trainSpeed: TrainSpeed,
-  carriesPassengers: boolean,
-  modifiers: readonly string[] = [],
-  direction: Direction = 'east',
-  gradeUp: Direction = 'east',
-): number {
-  const profile = MAINLINE_PROFILES.find((m) => m.kind === kind);
-  if (!profile) throw new Error(`unknown mainline card: ${kind}`);
+export type MainlineEntry = {
+  trainSpeed: TrainSpeed;
+  direction: Direction;
+  gradeUp: Direction;
+  modifiers: readonly string[];
+  /**
+   * The Uncontrolled Siding with a train already on it: this one takes the siding and sits a region
+   * behind, which is what keeps them out of the same place. Also the Interchange, where an Extra
+   * beginning its run starts in the holding region rather than on the road.
+   */
+  startsAtBack?: boolean;
+};
 
-  let mph: number;
-  switch (profile.speed.kind) {
-    case 'uniform':
-      mph = profile.speed.value;
-      break;
-    case 'byTrainType':
-      mph = carriesPassengers ? profile.speed.passenger : profile.speed.freight;
-      break;
-    case 'grade':
-      // Heavy Grade has no printed number; the modifier cards are what improve it, so it is a 30
-      // until one is placed.
-      mph = 30;
-      break;
+export function startRegion(kind: MainlineKind, entry: MainlineEntry): number {
+  const profile = mainlineProfile(kind);
+  if (entry.startsAtBack) return 0;
+
+  const base = profile.speedStarts
+    ? profile.speedStarts[entry.trainSpeed]
+    : profile.defaultStart;
+
+  const climbing = entry.direction === entry.gradeUp;
+  let help = 0;
+  if (kind === 'heavyGrade') {
+    if (climbing) {
+      if (entry.modifiers.includes('helpers')) help++;
+    } else {
+      // Airbrakes is an upgrade on Brakeman and cannot be played without it, so this counts both.
+      if (entry.modifiers.includes('brakeman')) help++;
+      if (entry.modifiers.includes('airbrakes')) help++;
+    }
   }
+  // Never past the last region: a card always costs at least one Stage to cross.
+  return Math.min(profile.regions - 1, base + help);
+}
 
-  const base = mph >= 60 ? 1 : 2;
-  const stages = base + (trainSpeed === 'slow' ? 1 : 0);
-  return Math.max(1, stages - gradeReduction(profile, modifiers, direction, gradeUp));
+/** How many Stages a train needs to cross a Mainline card — the regions it has left to run. */
+export function crossingStages(kind: MainlineKind, entry: MainlineEntry): number {
+  return mainlineProfile(kind).regions - startRegion(kind, entry);
 }
 
 /**
@@ -634,35 +746,60 @@ export function crossingStages(
 export function mainlineDescription(kind: MainlineKind, gradeUp: Direction = 'east'): string {
   const p = mainlineProfile(kind);
   const stages = (n: number): string => `${n} Stage${n === 1 ? '' : 's'}`;
+  const run = (entry: Partial<MainlineEntry>): number =>
+    crossingStages(kind, { trainSpeed: 'fast', direction: 'east', gradeUp, modifiers: [], ...entry });
   const parts: string[] = [];
 
-  if (p.speed.kind === 'byTrainType') {
-    // Hilly. The split is by CONSIST, not by the train's speed class: anything with a coach on it
-    // takes the passenger figure.
+  parts.push(`${p.regions} region${p.regions === 1 ? '' : 's'} — one Stage each.`);
+
+  if (p.speedStarts) {
     parts.push(
-      `P${p.speed.passenger} / F${p.speed.freight} — a train carrying ANY coach crosses as a ` +
-        `${p.speed.passenger} (${stages(crossingStages(kind, 'fast', true))} for a fast train), and a ` +
-        `freight-only train as a ${p.speed.freight} (${stages(crossingStages(kind, 'fast', false))}). ` +
-        `A slow train adds one Stage either way.`,
+      `This card reads the train's FAST/SLOW rating: a fast train starts further along and crosses ` +
+        `in ${stages(run({ trainSpeed: 'fast' }))}, a slow one in ${stages(run({ trainSpeed: 'slow' }))}. ` +
+        `No other card cares which it is.`,
     );
-  } else if (p.speed.kind === 'grade') {
+  } else if (kind === 'heavyGrade') {
     parts.push(
-      `A grade, climbing ${gradeUp === 'east' ? 'eastward' : 'westward'}. It crosses as a 30 — ` +
-        `${stages(crossingStages(kind, 'fast', false, [], gradeUp, gradeUp))} for a fast train, and one ` +
-        `more for a slow one. Brakeman and Airbrakes each take a Stage off a train running DOWNHILL; ` +
-        `Helpers takes one off a train running UPHILL. Never below one Stage.`,
+      `A grade, climbing ${gradeUp === 'east' ? 'eastward' : 'westward'}. ` +
+        `${stages(run({ direction: gradeUp }))} to climb it and ${stages(run({ direction: gradeUp === 'east' ? 'west' : 'east' }))} to run down, ` +
+        `before help. Helpers start an UPHILL train a region further on; Brakeman does the same ` +
+        `DOWNHILL and Airbrakes another again, and Airbrakes cannot be played without Brakeman. ` +
+        `Never less than one Stage.`,
+    );
+  } else if (p.defaultStart > 0) {
+    parts.push(
+      `A train with the card to itself starts past the back region and is across in ` +
+        `${stages(run({}))}.`,
     );
   } else {
+    /**
+     * NOT A WORD ABOUT SPEED HERE — Jesse, playtest 2026-09-16.
+     *
+     * This read "the printed speed is scenery", which sent a player hunting the card for a number
+     * that is not drawn on it. The first rewrite said "fast or slow alike", which is true but raises
+     * the question on thirteen cards in order to answer it. **Exactly one card reads FAST/SLOW**:
+     * Hilly, the only profile with `speedStarts` (see the note above it). So the explanation belongs
+     * on that card, where the branch above already gives it, and everywhere else says nothing —
+     * silence is the honest answer when the rating genuinely does not apply.
+     */
+    parts.push(`${stages(run({}))} for every train.`);
+  }
+
+  if (kind === 'uncontrolledSiding') {
     parts.push(
-      `${p.speed.value} — ${stages(crossingStages(kind, 'fast', false))} for a fast train, ` +
-        `${stages(crossingStages(kind, 'slow', false))} for a slow one.`,
+      'UNCONTROLLED SIDING — arrive to find a train already here and you take the siding, a region ' +
+        'behind it. You are not in the same place, so you do not run into it; it costs you the ' +
+        'extra Stage instead.',
     );
   }
+  if (kind === 'interchange') {
+    parts.push('An Extra beginning its run here starts in the back region and takes the extra Stage.');
+  }
 
   if (p.trainsMayPass) {
     parts.push(
       'TRAINS MAY PASS — two trains may stand on this card at once, so a following train is not held ' +
-        'behind a slower one. Only this and the Double Track allow it.',
+        'behind a slower one.',
     );
   } else {
     parts.push('One train at a time — anything following has to wait for it to clear.');
@@ -672,43 +809,7 @@ export function mainlineDescription(kind: MainlineKind, gradeUp: Direction = 'ea
   return parts.join(' · ');
 }
 
-/**
- * WHICH WAY THE GRADE CLIMBS, AND WHY NO PLAYER CHOOSES IT.
- *
- * Q11, answered from the card: Heavy Grade prints "(Up)" and "Player sets orientation", so the climb
- * is a property of the PLACED CARD rather than a compass constant. `gradeUp` is the direction a train
- * is travelling when it goes UPHILL; a train heading the other way is descending.
- *
- * **The second half of that print is deliberately overridden.** No player sets it — `setup.ts` rolls
- * it from the seed. Settled v0.5.0 and re-confirmed 2026-08-23 after the question was raised again:
- * a Heavy Grade always sits BETWEEN two districts (or beyond an end Division Point next to one),
- * never inside one player's own, so there is no player with a fair claim to the choice — and the
- * choice is not cosmetic, because it decides which of the three modifiers below can ever pay and
- * therefore which direction of traffic is favoured, permanently. Giving it to the Superintendent was
- * considered and rejected in that re-examination: the office rotates every three Stages, the
- * advantage does not. Full reasoning in implications.md §10 Q11.
- *
- * Each applicable card takes a Stage off, never below one: a train cannot cross in no time.
- * Airbrakes only counts when Brakeman is already there, which the placement rule enforces
- * (`MAINLINE_MODIFIER_RULES`, `requiresOnCard`).
- */
-function gradeReduction(
-  profile: MainlineProfile,
-  modifiers: readonly string[],
-  direction: Direction,
-  gradeUp: Direction,
-): number {
-  if (profile.speed.kind !== 'grade') return 0;
-  const downhill = direction !== gradeUp;
-  let n = 0;
-  if (downhill) {
-    if (modifiers.includes('brakeman')) n++;
-    if (modifiers.includes('airbrakes')) n++;
-  } else if (modifiers.includes('helpers')) {
-    n++;
-  }
-  return n;
-}
+
 
 export function mainlineProfile(kind: MainlineKind): MainlineProfile {
   const p = MAINLINE_PROFILES.find((m) => m.kind === kind);
@@ -769,7 +870,8 @@ export const SPACE_USE_CARDS: readonly SimpleCard[] = [
   { key: 'flopHouse', name: 'Flop house', copies: 1, placement: 'adjacent to any straight, curve, turnout', effect: 'Burns tablespace.' },
   { key: 'watertower', name: 'Watertower', copies: 1, placement: 'adjacent to any straight, turnout on Running Track', effect: 'Burns tablespace.' },
   { key: 'hoboJungle', name: 'Hobo Jungle', copies: 1, placement: 'adjacent to any straight, turnout, Limit on Running Track', effect: 'Burns tablespace. Vandalism can loot a boxcar passing it.' },
-  { key: 'sectionHouse', name: 'Section House', copies: 1, placement: 'adjacent to any straight, curve, turnout', effect: 'Burns tablespace.' },
+  // Not in sheet 5 — dealt 0 copies (Jesse, 2026-08-26), the same treatment as the ladder.
+  { key: 'sectionHouse', name: 'Section House', copies: 0, placement: 'adjacent to any straight, curve, turnout', effect: 'Burns tablespace.' },
   { key: 'cityBlocks', name: 'City blocks', copies: 4, placement: 'adjacent to any straight, curve, turnout, Limit', effect: 'Burns tablespace.' },
   { key: 'engineShops', name: 'Engine Shops', copies: 1, placement: 'adjacent to any straight, curve, turnout', effect: 'Burns tablespace.' },
   { key: 'tenderloin', name: 'Tenderloin District', copies: 1, placement: 'adjacent to any straight, curve, turnout, Limit', effect: 'Burns tablespace.' },
@@ -876,16 +978,32 @@ export function enhancementRule(key: string): EnhancementRule | null {
 }
 
 export const ENHANCEMENT_CARDS: readonly SimpleCard[] = [
-  { key: 'interlocking', name: 'Interlocking', copies: 2, placement: 'any Running Track Straight', effect: 'May stop an inbound train on the Limit Track.' },
-  { key: 'facingPointLocks', name: 'Facing Point Locks', copies: 2, placement: 'adjacent to Interlocking', effect: 'Must have Interlocking. Prevents Derail being played on you.', answers: 'Derail' },
+  { key: 'interlocking', name: 'Interlocking', copies: 1, placement: 'any Running Track Straight', effect: 'May stop an inbound train on the Limit Track.' },
+  // Not in sheet 5 — dealt 0 copies (Jesse, 2026-08-26). It answers Derail, which is itself an
+  // Event held out until built, so at zero it defends against nothing that can be dealt anyway.
+  { key: 'facingPointLocks', name: 'Facing Point Locks', copies: 0, placement: 'adjacent to Interlocking', effect: 'Must have Interlocking. Prevents Derail being played on you.', answers: 'Derail' },
   { key: 'yardOffice', name: 'Yard office', copies: 1, placement: 'any Secondary Track Straight', effect: 'An inbound train with no coaches that can reach the yard office in one move may arrive there instead of the Train Order Office.' },
   { key: 'smallYard', name: 'Small yard', copies: 1, placement: 'any Secondary Track Straight', effect: 'A train that spends one move in the yard may sort itself into ANY order, including cars ahead of the engine.' },
-  { key: 'waterColumn', name: 'Water column', copies: 2, placement: 'any Running Track Straight', effect: 'Lets you remove any Watertower in your district.', answers: 'Watertower' },
+  { key: 'waterColumn', name: 'Water column', copies: 1, placement: 'any Running Track Straight', effect: 'Lets you remove any Watertower in your district.', answers: 'Watertower' },
   { key: 'overpass', name: 'Overpass', copies: 1, placement: 'any Railroad Crossing', effect: 'Removes the restrictions of a played Railroad Crossing.', answers: 'Railroad crossing' },
-  { key: 'telegraph', name: 'Telegraph', copies: 3, placement: 'any Running Track Straight', effect: 'Once a day, when dispatching facing trains, add +4 to the other train’s number.' },
-  { key: 'telephone', name: 'Telephone', copies: 2, placement: 'on Telegraph', effect: 'Once a day, add +8 to the other train’s number.' },
-  { key: 'radio', name: 'Radio', copies: 2, placement: 'on Telephone', effect: 'Once a day, add +12 to the other train’s number.' },
-  { key: 'absSignals', name: 'ABS Signals', copies: 2, placement: 'any Mainline card', effect: 'Trains on this card will not rear-end each other; they stop short of a collision.' },
+  /**
+   * THE DISPATCHING LADDER IS OUT OF THE DECK, at 0 copies rather than deleted — the treatment
+   * Poling and the sharp curves already get, and for the same reason.
+   *
+   * `docs/Deck cards5.xlsx` does not list Telegraph, Telephone or Radio at any count, and **Jesse
+   * confirmed (2026-08-26) that the removal is deliberate, not a row that failed to carry across**
+   * from sheet 2. So no copy is dealt, which is what the sheet asks for.
+   *
+   * The rows and `ENHANCEMENT_RULES`' `dispatchBonus` chain stay exactly where they are. The rule
+   * is implemented and tested — `advance.ts` reads the ladder when the Superintendent dispatches
+   * facing trains, best device first — and deleting working machinery to express a count of zero
+   * would throw away the only record of how it worked. At zero copies the code is unreachable: no
+   * card is ever dealt, so nothing ever places one, so the bonus never applies.
+   */
+  { key: 'telegraph', name: 'Telegraph', copies: 0, placement: 'any Running Track Straight', effect: 'Once a day, when dispatching facing trains, add +4 to the other train’s number.' },
+  { key: 'telephone', name: 'Telephone', copies: 0, placement: 'on Telegraph', effect: 'Once a day, add +8 to the other train’s number.' },
+  { key: 'radio', name: 'Radio', copies: 0, placement: 'on Telephone', effect: 'Once a day, add +12 to the other train’s number.' },
+  { key: 'absSignals', name: 'ABS Signals', copies: 1, placement: 'any Mainline card', effect: 'Trains on this card will not rear-end each other; they stop short of a collision.' },
 ];
 
 export const MAINLINE_MODIFIER_CARDS: readonly SimpleCard[] = [
@@ -893,7 +1011,8 @@ export const MAINLINE_MODIFIER_CARDS: readonly SimpleCard[] = [
   { key: 'airbrakes', name: 'Airbrakes', copies: 1, placement: 'a GRADE Mainline card', effect: 'Faster passage downhill. Brakeman must be in effect.' },
   { key: 'helpers', name: 'Helpers', copies: 1, placement: 'a GRADE Mainline card', effect: 'Faster passage uphill.' },
   { key: 'realignment', name: 'Realignment', copies: 2, placement: 'a Mainline card', effect: 'Convert one Mainline type to another. Not while a train is on it.' },
-  { key: 'facingPointLocksMainline', name: 'Facing Point Locks', copies: 2, placement: 'adjacent to Interlocking', effect: 'Prevents Derail being played on you.', answers: 'Derail' },
+  // Not in sheet 5 — dealt 0 copies (Jesse, 2026-08-26); see the Enhancement of the same name.
+  { key: 'facingPointLocksMainline', name: 'Facing Point Locks', copies: 0, placement: 'adjacent to Interlocking', effect: 'Prevents Derail being played on you.', answers: 'Derail' },
 ];
 
 /**
@@ -904,8 +1023,9 @@ export const MAINLINE_MODIFIER_CARDS: readonly SimpleCard[] = [
 export const SECOND_SECTION = { key: 'secondSection', name: 'Second Section', copies: 1 };
 
 export const MANEUVER_CARDS: readonly SimpleCard[] = [
-  { key: 'redFlags', name: 'Red Flags', copies: 5, placement: 'any time', effect: 'A stopped train is prevented from being hit; the approaching train is prevented from moving.' },
-  { key: 'flyingSwitch', name: 'Flying Switch', copies: 1, placement: 'any time', effect: 'Break a cut of cars away from behind the engine and roll them into an industry.' },
+  { key: 'redFlags', name: 'Red Flags', copies: 3, placement: 'any time', effect: 'A stopped train is prevented from being hit; the approaching train is prevented from moving.' },
+  // Not in sheet 5 — dealt 0 copies (Jesse, 2026-08-26). The reducer stays; nothing can reach it.
+  { key: 'flyingSwitch', name: 'Flying Switch', copies: 0, placement: 'any time', effect: 'Break a cut of cars away from behind the engine and roll them into an industry.' },
   // POLING IS OUT OF THE DECK, at 0 copies rather than deleted.
   //
   // It is the one card whose effect the source records as "TBD", so there is nothing to implement
@@ -922,7 +1042,8 @@ export const ACTION_CARDS: readonly SimpleCard[] = [
   { key: 'perDiemInventory', name: 'Per Diem inventory', copies: 1, placement: 'another player', effect: 'Lose one point per 2 empty cars on Secondary Tracks.' },
   { key: 'demurrageCharge', name: 'Demurrage charge', copies: 1, placement: 'another player', effect: 'Lose one point per 2 loaded freight cars on Secondary Tracks.' },
   { key: 'customerComplaints', name: 'Customer complaints', copies: 1, placement: 'another player', effect: 'Lose one point per 2 coaches in loading boxes.' },
-  { key: 'vandalism', name: 'Vandalism', copies: 1, placement: 'another player', effect: 'A train passing a Hobo Jungle has a boxcar looted (converted to empty).' },
+  // Not in sheet 5 — dealt 0 copies (Jesse, 2026-08-26).
+  { key: 'vandalism', name: 'Vandalism', copies: 0, placement: 'another player', effect: 'A train passing a Hobo Jungle has a boxcar looted (converted to empty).' },
   { key: 'hotbox', name: 'Hotbox', copies: 1, placement: 'another player', effect: 'A train just arrived must set one car (chooser’s pick) onto Secondary Track until it departs.' },
   { key: 'outlawed', name: 'Outlawed', copies: 1, placement: 'another player', effect: 'A train just arrived may not depart for one turn — the crew’s hours have expired.' },
 ];
@@ -972,7 +1093,6 @@ export function crewTrayCount(players: number): number {
   return players + 3;
 }
 
-export const REGIONS_PER_MAINLINE_CARD = 2; // provisional, pending §10 Q2
 export const STAGES_PER_DAY = 12;
 export const STAGES_PER_SHIFT = 3;
 export const HAND_LIMIT = 3;

src/engine/events.ts

@@ -28,6 +28,15 @@ export type GameEvent =
   | { type: 'stageBegan'; day: number; stage: number }
   /** Employee Rotation (Appendix B) — every player has moved one chair left for the new Day. */
   | { type: 'seatsRotated'; day: number; seating: PlayerIndex[] }
+  /**
+   * §5 — the Fedora passed, at the end of Stage 3, 6, 9 or 12.
+   *
+   * ITS OWN EVENT RATHER THAN THE `actorChanged` THIS USED TO RIDE ON. That one is turn bookkeeping,
+   * fired every time the cursor moves, and `record()` drops it on the floor as noise — so the one
+   * moment it carried that a player actually needed to see went past in silence. Reported from the
+   * table (2026-09-16): the Supervisor Shift appears in the history and the handover never does.
+   */
+  | { type: 'superintendentChanged'; player: PlayerIndex; stage: number }
   | { type: 'phaseBegan'; phase: string }
   | { type: 'actorChanged'; player: PlayerIndex | null }
   // -- local operations
@@ -37,9 +46,10 @@ export type GameEvent =
    * more than one legal route to `to`, so the history can say which one ran rather than leaving a
    * choice the player made invisible in their own log.
    */
-  | { type: 'trayMoved'; trayId: TrayId; from: GridCoord; to: GridCoord; movesRemaining: number; facing?: 'n' | 's' | 'e' | 'w'; via?: GridCoord }
+  | { type: 'trayMoved'; player: PlayerIndex; trayId: TrayId; from: GridCoord; to: GridCoord; movesRemaining: number; facing?: 'n' | 's' | 'e' | 'w'; via?: GridCoord }
   | {
       type: 'carsCoupled';
+      player: PlayerIndex;
       trayId: TrayId;
       at: GridCoord;
       stock: RollingStock[];
@@ -71,8 +81,8 @@ export type GameEvent =
        */
       recoupled?: { at: GridCoord; stock: RollingStock[] };
     }
-  | { type: 'carsDropped'; trayId: TrayId; at: GridCoord; stock: RollingStock[]; fromNose?: boolean }
-  | { type: 'consistSorted'; trayId: TrayId; at: GridCoord; before: RollingStock[]; after: RollingStock[] }
+  | { type: 'carsDropped'; player: PlayerIndex; trayId: TrayId; at: GridCoord; stock: RollingStock[]; fromNose?: boolean }
+  | { type: 'consistSorted'; player: PlayerIndex; trayId: TrayId; at: GridCoord; before: RollingStock[]; after: RollingStock[] }
   | { type: 'cardDrawn'; player: PlayerIndex; source: 'homeOffice' | 'department'; slot?: number; cardId: CardId }
   /**
    * §6.2 — the Home Office deck ran out, so the Salvage Yard and all three Department decks were
@@ -86,8 +96,19 @@ export type GameEvent =
   | { type: 'deckReshuffled'; order: CardId[]; rngState: number }
   /** `variant` is the chosen orientation (Gap 11); it must be replayable, so it rides the event. */
   | { type: 'cardPlayed'; player: PlayerIndex; cardId: CardId; placement?: GridCoord; variant?: number }
-  | { type: 'mainlineModified'; player: PlayerIndex; cardId: CardId; node: number; key: string; became?: string }
-  | { type: 'redFlagsSet'; player: PlayerIndex; cardId: CardId; trayId: TrayId; node: number }
+  /**
+    * `from` is the card's kind BEFORE the change, carried so the log can say what was realigned
+    * rather than only what it turned into (playtest, 2026-09-15: "it should state that the mainline
+    * card 3 curves was converted to plains"). Events are derived by replaying a save, never stored,
+    * so widening one strands nothing on disk.
+    */
+  | { type: 'mainlineModified'; player: PlayerIndex; cardId: CardId; node: number; key: string; from?: string; became?: string }
+  /** §Q (Gitea#19) — a flag planted on one side of a district's Limits. */
+  | { type: 'redFlagsSet'; player: PlayerIndex; cardId: CardId; seat: SeatIndex; side: Direction }
+  /** §Q (Gitea#19) — the flag stopped a train and came down with it. One card, one train. */
+  | { type: 'redFlagSpent'; seat: SeatIndex; side: Direction; trainNumber: number }
+  /** §Q (Gitea#19) — the district's owner answered the out-of-phase "flag against this train?". */
+  | { type: 'redFlagRuled'; player: PlayerIndex; trainId: TrayId; flag: boolean }
   | {
       type: 'trainsDestroyed';
       player: PlayerIndex;
@@ -147,7 +168,13 @@ export type GameEvent =
    * switched normally like any other arrival, but it has to be back on the Office square before the
    * next Mainline Phase begins, or `expediteFault` fires.
    */
-  | { type: 'trainArrived'; trainNumber: number; consist: RollingStock[]; office: string; expedited: boolean }
+  /**
+   * `owner` is WHOSE Office it reached — the district's player, not whoever is acting. The Mainline
+   * Phase has no actor, so nothing else in the line could name the seat, and the narration said only
+   * "ARRIVED at the Whistle Post" — every seat's Office has a tier, and at a four-seat table three of
+   * them are somebody else's (Jesse, playtest 2026-09-16).
+   */
+  | { type: 'trainArrived'; trainNumber: number; consist: RollingStock[]; office: string; owner: PlayerIndex; expedited: boolean }
   | { type: 'trainDiverted'; trainNumber: number; to: string; reason: string }
   /**
    * The train ran the length of the Division and left it. `side` is the Division Point it left by,
@@ -195,6 +222,25 @@ export type GameEvent =
   | { type: 'unloadBegan'; player: PlayerIndex; at: GridCoord; carType: CarType; carIndex: number }
   // -- consequences
   | { type: 'revenueChanged'; player: PlayerIndex; delta: number; total: number; reason: string }
-  | { type: 'phaseEnded'; player: PlayerIndex; phase: string };
+  | { type: 'phaseEnded'; player: PlayerIndex; phase: string }
+  // -- §3.3, extended play (Gitea#11)
+  /**
+   * One seat's answer to "play one more Day?". Every seat votes; the vote is unanimous, and one
+   * refusal ends it. In the log so that a table can see who is still being waited on, and who
+   * called time.
+   */
+  | { type: 'extensionVoted'; player: PlayerIndex; agree: boolean }
+  /** The table agreed. `day` is the Day the extra one becomes — `config.days + extraDays`. */
+  | { type: 'dayExtended'; day: number }
+  /**
+   * Play is over for good — somebody declined the extension.
+   *
+   * Distinct from the ending itself, which `checkVictory` already announced by way of the result: an
+   * ending that COULD have been played past and was not is a decision the table made, and the log
+   * should say so rather than simply stopping.
+   */
+  | { type: 'playConcluded'; declinedBy: PlayerIndex }
+  /** §11 (Gitea#5) — the district's owner answered the Yard Office offer. */
+  | { type: 'yardOfficeRuled'; player: PlayerIndex; trainId: TrayId; take: boolean };
 
 export type EventType = GameEvent['type'];

src/engine/intents.ts

@@ -120,10 +120,24 @@ export type Intent =
    */
   | { type: 'mainline.modify'; cardId: CardId; node: number }
   /**
-   * Red Flags — protect a stopped train. The flagged train cannot be hit; an approaching train is
-   * held instead of colliding.
+   * §Q, RED FLAGS (Gitea#19) — plant a flag on one side of your own district.
+   *
+   * "If played, asked FLAG EAST or FLAG WEST. That stops all trains from entering your limits from
+   * that direction (i.e. Flag East holds westbound trains). You can do this if you see a problem or
+   * wish to complete switching."
+   *
+   * `side` names the side of the district the flag goes on, so a train arriving from that side is
+   * held. It REPLACES the old rule, which was played on a stopped train out on the Mainline and
+   * protected it from a rear-ender: measured at 4,212 offers and 4 plays across 600 games, a
+   * mechanic nobody used. ABS Signals already protects a train standing on a Mainline card.
    */
-  | { type: 'maneuver.redFlags'; cardId: CardId; trayId: TrayId }
+  | { type: 'maneuver.redFlags'; cardId: CardId; side: Direction }
+  /**
+   * The same card, played OUT OF PHASE at the moment of danger (Gitea#19) — "COLLISION RISK! FLAG
+   * AGAINST T2?". Answers a pending `redFlag` decision; `flag: false` declines and lets the
+   * collision happen. The side is not asked for: the train is already coming from one.
+   */
+  | { type: 'mainline.redFlag'; flag: boolean; cardId?: CardId }
   /**
    * Flying Switch — cut cars off behind the engine and roll them into an adjacent industry, without
    * the engine entering it.
@@ -147,7 +161,37 @@ export type Intent =
   | { type: 'laborer.startLoad'; at: GridCoord }
   | { type: 'laborer.advanceLoad'; at: GridCoord; box: number }
   | { type: 'laborer.beginUnload'; at: GridCoord; carIndex: number }
-  | { type: 'loadUnload.end' };
+  | { type: 'loadUnload.end' }
+  /**
+   * §3.3, EXTENDED PLAY (Gitea#11) — one vote on whether to play one more Day.
+   *
+   * ARRIVES OUT OF TURN, like `mainline.clearance`, and unlike it goes to EVERY seat rather than to
+   * the Superintendent: it is a table decision, not a ruling. Unanimous, and one `agree: false`
+   * ends the game immediately — nobody waits on a player who has already refused.
+   *
+   * It is an intent, rather than a button the client handles by itself, because a save is
+   * `{ seed, config, history }` replayed through the engine: a decision that is not in the history
+   * did not happen, and an extended game would evaporate on the next reload, Undo, or server
+   * restart. This is the record of the table agreeing.
+   *
+   * CARRIES ITS VOTER, uniquely among intents, and it has to. A saved history is a flat `Intent[]`
+   * with no seat recorded against each move: the replay DERIVES who acted from the turn order
+   * (`fromMultiplayerSave`). That works for every other intent, including `mainline.clearance`,
+   * because there is exactly one seat it could have been. Here there is not — every seat may vote,
+   * in any order — so a vote whose voter is not written down cannot be replayed at all, and a
+   * resumed server would refuse the save with `NO_ACTOR`. The server checks this against the seat
+   * it authenticated (`NOT_YOUR_TURN`), so it is a record, never a claim.
+   */
+  | { type: 'game.extend'; player: PlayerIndex; agree: boolean }
+  /**
+   * §11 (Gitea#5) — take the Yard Office, or the standard Office.
+   *
+   * Interrupts the Mainline Phase like `mainline.clearance`, and like it goes to one named player:
+   * whoever sits in the district the train is arriving at. Offered only when a route exists, so
+   * `take: true` always has somewhere to go — though it may still meet cars on the lead and crash,
+   * which is the point of the rule.
+   */
+  | { type: 'mainline.yardOffice'; take: boolean };
 
 export type IntentType = Intent['type'];
 
@@ -276,7 +320,17 @@ export type RejectionCode =
    * §6.2, Jesse's ruling (Gitea#6) — a train card is never discarded. Hold it as long as you like;
    * the only way it leaves your hand is onto the timetable.
    */
-  | 'TRAINS_ARE_NEVER_DISCARDED';
+  | 'TRAINS_ARE_NEVER_DISCARDED'
+  /** §3.3 (Gitea#11) — `game.extend` when the game is not waiting on an extension vote. */
+  | 'NOT_AWAITING_EXTENSION'
+  /** §3.3 (Gitea#11) — this seat has already voted on this extension. */
+  | 'ALREADY_VOTED'
+  /** §11 (Gitea#5) — answering a Yard Office offer that is not open. */
+  | 'NO_YARD_OFFICE_OFFER'
+  /** §Q (Gitea#19) — answering a Red Flag prompt that is not open. */
+  | 'NO_RED_FLAG_PROMPT'
+  /** §Q (Gitea#19) — this district already has a flag on that side. */
+  | 'ALREADY_FLAGGED';
 
 export type Rejection = { code: RejectionCode; message: string };
 

src/engine/legal.ts

@@ -14,7 +14,7 @@
 
 import type { CarType, Hand, TrackGeometry } from './content.ts';
 import { enhancementRule, mainlineProfile } from './content.ts';
-import { check, areaOf, destinationsFor } from './apply.ts';
+import { check, areaOf, destinationsFor, withRouteCache } from './apply.ts';
 import type { Intent } from './intents.ts';
 import type { GameState, GridCoord, PlayerIndex } from './state.ts';
 import { coordKey, seatOf } from './state.ts';
@@ -53,64 +53,18 @@ const CAR_TYPES: readonly CarType[] = ['coach', 'boxcar', 'reefer', 'hopper', 't
 
 /** Every intent `player` may legally submit right now. */
 export function legalActions(s: GameState, player: PlayerIndex): Intent[] {
-  return candidates(s, player).filter((i) => check(s, player, i) === null);
-}
-
-export function isLegal(s: GameState, player: PlayerIndex, i: Intent): boolean {
-  return check(s, player, i) === null;
+  // One position, examined many times over: its routes are walked once (`withRouteCache`).
+  return withRouteCache(s, () => candidates(s, player).filter((i) => check(s, player, i) === null));
 }
 
 /**
- * Candidate generation. Over-generates freely — `check` is the authority, so a candidate that
- * turns out to be illegal simply gets filtered. Being generous here is what stops this module
- * from quietly acquiring rules.
+ * §6.1 — the switching half of the Local Operations candidates, in the order `legalActions` offers
+ * them. Split out so the switching planner (`sim/switch-planner.ts`) can ask for just these without
+ * `check` running over every draw and Freight Agent candidate at each of the thousands of positions it
+ * tries — that was about a quarter of all planning time. Still no rules here: `check` decides.
  */
-function candidates(s: GameState, player: PlayerIndex): Intent[] {
+function switchCandidates(s: GameState, player: PlayerIndex): Intent[] {
   const out: Intent[] = [];
-
-  // The clearance ruling arrives out of turn order and goes to the Superintendent (§8.1).
-  if (s.clock.pendingDecision !== null) {
-    out.push({ type: 'mainline.clearance', allow: true });
-    out.push({ type: 'mainline.clearance', allow: false });
-  }
-
-  switch (s.clock.phase) {
-    case 'localOps':
-      out.push(...localOpsCandidates(s, player));
-      break;
-    case 'newTrain':
-      out.push(...newTrainCandidates(s, player));
-      break;
-    case 'loadUnload':
-      out.push(...loadUnloadCandidates(s, player));
-      break;
-    default:
-      break;
-  }
-
-  // Red Flags — "any time", so they are candidates in every phase, on any train standing out on
-  // the Mainline (the player's own or another's: protecting a train is not an attack).
-  for (const cardId of s.decks.hands.get(player) ?? []) {
-    const k = s.cards.get(cardId)?.kind;
-    if (k?.kind !== 'maneuver' || k.key !== 'redFlags') continue;
-    for (const [trayId] of s.trays) out.push({ type: 'maneuver.redFlags', cardId, trayId });
-  }
-
-  out.push({ type: 'redFlag.play' });
-  return out;
-}
-
-function localOpsCandidates(s: GameState, player: PlayerIndex): Intent[] {
-  const out: Intent[] = [];
-
-  // §6 — the three-way exclusive choice.
-  out.push({ type: 'localOps.choose', option: 'switch' });
-  out.push({ type: 'localOps.choose', option: 'draw' });
-  out.push({ type: 'localOps.choose', option: 'freightAgent' });
-
-  const area = areaOf(s, player);
-
-  // -- switch (§6.1)
   for (const [trayId, tray] of s.trays) {
     if (tray.position.at !== 'grid' || tray.position.seat !== seatOf(s, player)) continue;
     const from = tray.position.coord;
@@ -167,6 +121,97 @@ function localOpsCandidates(s: GameState, player: PlayerIndex): Intent[] {
     }
   }
   out.push({ type: 'switch.end' });
+  return out;
+}
+
+/** The switching intents `player` may legally submit right now — exactly `legalActions`' switching subset. */
+export function legalSwitchingActions(s: GameState, player: PlayerIndex): Intent[] {
+  return withRouteCache(s, () => switchCandidates(s, player).filter((i) => check(s, player, i) === null));
+}
+
+export function isLegal(s: GameState, player: PlayerIndex, i: Intent): boolean {
+  return check(s, player, i) === null;
+}
+
+/**
+ * Candidate generation. Over-generates freely — `check` is the authority, so a candidate that
+ * turns out to be illegal simply gets filtered. Being generous here is what stops this module
+ * from quietly acquiring rules.
+ */
+function candidates(s: GameState, player: PlayerIndex): Intent[] {
+  const out: Intent[] = [];
+
+  /**
+   * §3.3, EXTENDED PLAY (Gitea#11) — the only thing on offer when the timetable has run out and the
+   * table is being asked whether to play on.
+   *
+   * Returned EARLY rather than added to the list, because nothing else is legal in this state and
+   * the phase switch below would otherwise generate a boardful of candidates for `check` to reject
+   * one at a time. It also puts the vote in front of the bot driver through the ordinary path, which
+   * is what lets a bot seat answer without the engine having to know which seats are bots.
+   */
+  if (s.status === 'awaitingExtension') {
+    if (s.extensionVotes[player] === null) {
+      out.push({ type: 'game.extend', player, agree: true });
+      out.push({ type: 'game.extend', player, agree: false });
+    }
+    return out;
+  }
+
+  // The two interruptions of the Mainline Phase. Each goes to one named player — `check` is the
+  // authority on which — so both are generated here and filtered there.
+  if (s.clock.pendingDecision?.kind === 'clearance') {
+    out.push({ type: 'mainline.clearance', allow: true });
+    out.push({ type: 'mainline.clearance', allow: false });
+  }
+  if (s.clock.pendingDecision?.kind === 'yardOffice') {
+    out.push({ type: 'mainline.yardOffice', take: true });
+    out.push({ type: 'mainline.yardOffice', take: false });
+  }
+  if (s.clock.pendingDecision?.kind === 'redFlag') {
+    out.push({ type: 'mainline.redFlag', flag: true });
+    out.push({ type: 'mainline.redFlag', flag: false });
+  }
+
+  switch (s.clock.phase) {
+    case 'localOps':
+      out.push(...localOpsCandidates(s, player));
+      break;
+    case 'newTrain':
+      out.push(...newTrainCandidates(s, player));
+      break;
+    case 'loadUnload':
+      out.push(...loadUnloadCandidates(s, player));
+      break;
+    default:
+      break;
+  }
+
+  // Red Flags — "any time", so they are candidates in every phase, on any train standing out on
+  // the Mainline (the player's own or another's: protecting a train is not an attack).
+  for (const cardId of s.decks.hands.get(player) ?? []) {
+    const k = s.cards.get(cardId)?.kind;
+    if (k?.kind !== 'maneuver' || k.key !== 'redFlags') continue;
+    // §Q (Gitea#19) — a flag goes on one side of your own district, so the only choice is which.
+    for (const side of ['east', 'west'] as const) out.push({ type: 'maneuver.redFlags', cardId, side });
+  }
+
+  out.push({ type: 'redFlag.play' });
+  return out;
+}
+
+function localOpsCandidates(s: GameState, player: PlayerIndex): Intent[] {
+  const out: Intent[] = [];
+
+  // §6 — the three-way exclusive choice.
+  out.push({ type: 'localOps.choose', option: 'switch' });
+  out.push({ type: 'localOps.choose', option: 'draw' });
+  out.push({ type: 'localOps.choose', option: 'freightAgent' });
+
+  const area = areaOf(s, player);
+
+  // -- switch (§6.1)
+  out.push(...switchCandidates(s, player));
 
   // -- draw (§6.2)
   out.push({ type: 'draw.fromHomeOffice' });

src/engine/setup.ts

@@ -43,7 +43,7 @@ import type {
   TrackCard,
   TrayId,
 } from './state.ts';
-import { coordKey, freshTurns } from './state.ts';
+import { coordKey, emptyTally, freshTurns } from './state.ts';
 
 export type SetupOptions = {
   id: string;
@@ -246,7 +246,7 @@ function buildDivision(players: number, rng: Rng): DivisionNode[] {
     if (deck.length === 0) throw new Error('the Mainline deck ran out — too many players for it');
     const card = deck.splice(rng.nextInt(deck.length), 1)[0]!;
     const node: DivisionNode = { kind: 'mainline', card, transits: [] };
-    if (mainlineProfile(card).speed.kind === 'grade') {
+    if (card === 'heavyGrade') {
       /**
        * SETTLED, not provisional (v0.5.0, Jesse's call) — this overrides the card's own printed
        * "Player sets orientation". A Heavy Grade sits on the shared west-to-east chain BETWEEN two
@@ -424,16 +424,21 @@ export function createGame(opts: SetupOptions): GameState {
       phase: 'localOps',
       currentActor: superintendent,
       pendingDecision: null,
-      clearanceRuling: null,
+      decisionAnswer: null,
       superintendent,
       actorOffset: 0,
     },
     turns: freshTurns(playerCount, MOVES_PER_LOCAL_OPS),
     movedThisPhase: new Set(),
     collisionsToday: 0,
+    collisionsPrevDay: 0,
     collisionsTotal: 0,
     status: 'active',
     outcome: null,
+    extraDays: 0,
+    extensionVotes: players.map(() => null),
+    official: null,
+    tally: emptyTally(playerCount),
   };
 }
 

src/engine/state.ts

@@ -17,7 +17,7 @@ import type {
   OfficeTier,
   TrackGeometry,
 } from './content.ts';
-import { MAX_CONSIST, officeProfile } from './content.ts';
+import { HAND_LIMIT, MAX_CONSIST, officeProfile } from './content.ts';
 
 // ---------------------------------------------------------------------------
 // Identifiers
@@ -445,20 +445,27 @@ export type CrewTray = {
   position: NodeRef;
   movesUsed: number;
   /**
-   * X18 Circus Train — "one turn stopped on any track (circus set-up) earns 1 point", claimed once.
+   * X18 Circus / X17 Campaign — Office Areas this train has already been paid for setting up in
+   * (Gitea#13).
    *
-   * Recorded on the tray rather than the player because it is the TRAIN that sets up, and an Extra
-   * runs once and is gone; there is no second visit to claim it on.
+   * "Once per stop in an office area. In a multiplayer game, each player could score if the circus
+   * stops in their area" (Jesse, 2026-08-29). So the claim is per SEAT, not per train: a Circus
+   * touring three districts is paid three times, and one that parks in the same district for six
+   * Stages is paid once.
+   *
+   * Recorded on the tray, which also gives the other half of Jesse's ruling for free — "if the
+   * circus train gets recycled and played a second time as a second extra, then it could again
+   * score points later too". A train is made up onto a FRESH tray object every time, so a re-played
+   * Extra starts with an empty list and no reset code is needed.
    */
-  stopPointClaimed?: boolean;
+  stopPointSeats?: SeatIndex[];
   /**
    * X17 Campaign Train — "one turn at station (speeches) then expedite".
    *
    * It makes its speech at the first Office it reaches: that arrival is an ordinary stop, and from
    * then on the train is expedited — it may be switched normally, but it faults (Q3) if it is left
    * off the Office square when a Mainline Phase begins. Recorded on the tray for the same reason as
-   * `stopPointClaimed` — it is the TRAIN that stops, and an Extra runs once, so there is no later
-   * visit to hang it on.
+   * `stopPointSeats` — it is the TRAIN that stops, and a re-played Extra gets a fresh tray.
    */
   speechMade?: boolean;
 };
@@ -518,10 +525,23 @@ export type DivisionNode =
        * "Player sets orientation", so the direction is chosen when the card is placed.
        */
       gradeUp?: Direction;
-      /** Red Flags protecting a stopped train here, by tray. */
-      redFlagged?: TrayId[];
     }
-  | { kind: 'office'; seat: SeatIndex };
+  | {
+      kind: 'office';
+      seat: SeatIndex;
+      /**
+       * §Q, RED FLAGS (Gitea#19) — the side of this district a flag is planted on.
+       *
+       * "If played, asked FLAG EAST or FLAG WEST. That stops all trains from entering your limits
+       * from that direction (i.e. Flag East holds westbound trains)." So the value names the SIDE,
+       * and a train arriving from that side is held: a westbound train comes from the east.
+       *
+       * SPENT ON THE TRAIN IT STOPS (Jesse's ruling, 2026-08-29). One card, one train — the flag
+       * comes down as it is used, so there is no lifting action to build, nothing to forget, and a
+       * flag cannot quietly strangle the Division.
+       */
+      redFlag?: Direction;
+    };
 
 /** Ordered west to east. For N players: N Office nodes and N+1 Mainline cards. */
 export type Division = { nodes: DivisionNode[] };
@@ -585,10 +605,42 @@ export type Yards = {
 export type Phase = 'localOps' | 'newTrain' | 'mainline' | 'loadUnload' | 'shiftChange';
 
 /** §8.1 fourth condition — the Superintendent rules on a following train. */
-export type SuperintendentClearance = {
-  train: TrayId;
-  occupiedBy: TrayId;
-};
+/**
+ * AN INTERRUPTION TO THE AUTOMATIC MAINLINE PHASE — a question the driver cannot answer itself.
+ *
+ * There was one of these and it was hardcoded to one question asked of one player: the §8.1
+ * clearance ruling, always to the Superintendent. Gitea#5 and Gitea#19 each need to stop the same
+ * phase and ask a DIFFERENT player something different, so the shape is a union and `decisionActor`
+ * below decides who answers.
+ *
+ * Every member names the `train` the question is about, because the answer has to be matched back
+ * to it — see `DecisionAnswer`.
+ */
+export type PendingDecision =
+  /** §8.1 — a following train in the same Subdivision. The Superintendent rules. */
+  | { kind: 'clearance'; train: TrayId; occupiedBy: TrayId }
+  /**
+   * §11 (Gitea#5) — an inbound freight may take the Yard Office instead of the Train Order Office.
+   * Asked of whoever sits in `seat`, on the Mainline Phase the train arrives.
+   */
+  | { kind: 'yardOffice'; train: TrayId; seat: SeatIndex }
+  /**
+   * §Q (Gitea#19) — a train is about to enter this district into a collision, and its owner holds a
+   * Red Flags card. "You can play the card normally or out of phase, but only if you need it."
+   */
+  | { kind: 'redFlag'; train: TrayId; seat: SeatIndex; from: Direction };
+
+/**
+ * The answer, waiting to be consumed by the train that asked.
+ *
+ * Without this the driver would re-evaluate the same train, ask the same question, and never
+ * advance. Keyed by `kind` as well as `train` so an answer can never be mistaken for the reply to a
+ * different question about the same train.
+ */
+export type DecisionAnswer =
+  | { kind: 'clearance'; train: TrayId; allow: boolean }
+  | { kind: 'yardOffice'; train: TrayId; take: boolean }
+  | { kind: 'redFlag'; train: TrayId; flag: boolean };
 
 export type Clock = {
   day: number;
@@ -597,13 +649,10 @@ export type Clock = {
   phase: Phase;
   /** Exactly one player may act at a time. Null during automatic Mainline movement. */
   currentActor: PlayerIndex | null;
-  /** Interrupts the Mainline Phase to ask the Superintendent (§8.1). */
-  pendingDecision: SuperintendentClearance | null;
-  /**
-   * The Superintendent's answer, waiting to be consumed by the train that asked. Without this the
-   * driver would re-evaluate the same train and ask the same question forever.
-   */
-  clearanceRuling: { train: TrayId; allow: boolean } | null;
+  /** Interrupts the Mainline Phase to ask a player something (§8.1, §11). */
+  pendingDecision: PendingDecision | null;
+  /** The answer to `pendingDecision`, waiting to be consumed by the train that asked. */
+  decisionAnswer: DecisionAnswer | null;
   superintendent: PlayerIndex;
   /**
    * How far round the table the current phase has got. Acting order starts at the Superintendent
@@ -684,6 +733,139 @@ export type Outcome = {
   reason: OutcomeReason;
 };
 
+/**
+ * §3.3, EXTENDED PLAY (Gitea#11) — which endings may be played past.
+ *
+ * Both days-based endings offer another Day: running out of timetable, and closing short of the
+ * combined Revenue floor, are the same event seen twice — the last Day ended and this is what the
+ * books say. A `collisionFloor` ending is NOT extendable, and neither is a collision breach that
+ * happens during an extended Day: §3.4 stopped the game because the railroad was declared unsafe,
+ * and carrying on regardless would contradict the rule that stopped it (Jesse's call, 2026-08-28).
+ */
+export function isExtendable(reason: OutcomeReason): boolean {
+  return reason === 'daysElapsed' || reason === 'revenueFloor';
+}
+
+/**
+ * Running counts of everything interesting that has happened, tallied from the event stream
+ * (Gitea#16).
+ *
+ * WHY IT LIVES ON `GameState` rather than being computed by whoever happens to want it. Three
+ * reasons, in ascending order of how much they cost to work around:
+ *
+ *   1. `snapshot()` already takes a `GameState`, so every number here reaches a MULTIPLAYER client
+ *      through the `Frame` it is already being sent — no new server route, no new `Push` field, no
+ *      new `Session` method, and no second implementation that can disagree with the first.
+ *   2. It is REPLAY-EXACT. A save is `{ seed, config, history }` replayed through the engine
+ *      (`web/game.ts`'s `fromSave`), so a tally folded from the events that replay emits is rebuilt
+ *      identically every time — which is what makes Undo and a server restart correct here for free.
+ *   3. The official result freezes a COPY of this at the moment the timetable ran out (`official`
+ *      below), and a frozen copy has to be taken from something that already exists.
+ *
+ * Aggregate counts only. Nothing here is seat-secret — no card ids, no hands — which is why
+ * `test/redaction.test.ts` stays green with the whole thing on the Frame.
+ *
+ * NOT SCORING. Nothing in here feeds a rule; it is read by the results screen and by the badge work
+ * that Gitea#16 leaves to a second pass. Adding a counter is always safe.
+ */
+export type Tally = {
+  /** §8.3 — a train that ran the length of the Division and left it. */
+  trainsCompleted: number;
+  /**
+   * Of those, how many did some switching between being made up and leaving.
+   *
+   * The join Gitea#16 asks for by name ("a player who completes an entire game where every train
+   * that passed through did some switching on"). Counted as the train completes, against whether
+   * that tray has coupled or dropped anything since it was made up — which is why `switchedSince`
+   * below exists rather than this being derivable afterwards.
+   */
+  trainsCompletedWithWork: number;
+  /** §10 — trains lost to a collision, and the cars that went with them. */
+  trainsDestroyed: number;
+  carsDestroyed: number;
+  /** §6 — switching volume, both directions. */
+  carsCoupled: number;
+  carsDropped: number;
+  /** §9.1 — the MEN | AT | WORK pipeline: begun, and carried all the way through. */
+  loadsStarted: number;
+  loadsCompleted: number;
+  unloadsBegun: number;
+  unloadsCompleted: number;
+  /** §9.2 — passenger work. */
+  passengersBoarded: number;
+  passengersDetrained: number;
+  /** Colour, and the vocabulary the badge pass will draw on. */
+  flyingSwitches: number;
+  officeUpgrades: number;
+  dispatchBonusesUsed: number;
+  facilitiesUnjammed: number;
+  expediteFaults: number;
+  trainsHeld: number;
+  trainsDiverted: number;
+  secondSections: number;
+  extrasStarted: number;
+  cardsDrawn: number;
+  cardsPlayed: number;
+  cardsDiscarded: number;
+  clearancesRequested: number;
+  /** §8.1 — rulings that let the other train through. A refusal is a ruling too, but not this one. */
+  clearancesAllowed: number;
+  /**
+   * X18 CIRCUS SET-UPS — a train that spent a Stage standing still and was paid for it (§X18).
+   *
+   * NOT "the longest an engine sat on a siding", which is what Gitea#16 asks for and what the
+   * comment on that issue assumed this was. `trainStoodStill` is emitted ONCE IN A GAME PER SUCH
+   * TRAIN — only for a train whose profile has `stopEarnsPoint`, and `advance.ts` sets
+   * `stopPointClaimed` so it can never fire twice. There is no per-Stage "this train did not move"
+   * signal in the engine at all, so a longest-stand streak cannot be folded from the event stream:
+   * it needs an engine-side signal that does not exist yet. Recorded in `TODO.md` for the badge
+   * pass rather than shipped as a statistic that would read "1 Stage" for ever.
+   */
+  circusStops: { trainNumber: number; where: string }[];
+  /**
+   * Train numbers that have coupled or dropped something since they were made up, for
+   * `trainsCompletedWithWork`. Cleared when the train is made up and when it leaves the Division.
+   */
+  switchedSince: number[];
+  /** Indexed by PLAYER. Only events that name a player reach these. */
+  byPlayer: PlayerTally[];
+};
+
+export type PlayerTally = {
+  loads: number;
+  unloads: number;
+  passengersBoarded: number;
+  passengersDetrained: number;
+  cardsPlayed: number;
+  /** §10 — collisions this player was faulted for, not collisions they were caught in. */
+  collisions: number;
+  /** Revenue gained and Revenue lost, kept apart: the net is already on `players[i].revenue`. */
+  revenueGained: number;
+  revenueLost: number;
+};
+
+/**
+ * THE OFFICIAL RESULT, frozen at the moment the timetable ran out (Gitea#11).
+ *
+ * "The winner is based upon the original game length. In a five-day game, even if it's extended to
+ * eight or nine days, the winner and the official answer is the winner at the end of five days"
+ * (Jesse, 2026-08-28). So this is written ONCE, at the first ending, and never overwritten —
+ * including by a §3.4 collision breach during an extended Day, which ends play without touching it.
+ *
+ * `state.outcome` keeps moving: it is always the CURRENT evaluation, which is what the live game
+ * wants. Once `official` exists, everything after it is informational.
+ */
+export type FinalReport = {
+  /** The Day the game was scheduled to end on — always `config.days`. */
+  day: number;
+  outcome: Outcome;
+  /** Every player's Revenue at that moment, in player order. */
+  revenues: number[];
+  collisionsTotal: number;
+  /** The Tally as it stood when the timetable ran out. */
+  tally: Tally;
+};
+
 /**
  * Per-Stage transient bookkeeping for the acting player. Reset when the actor changes.
  *
@@ -726,6 +908,66 @@ export function freshTurns(players: number, moves: number): Map<PlayerIndex, Tur
   return turns;
 }
 
+/** A Tally with everything at zero — the state every game starts in (Gitea#16). */
+export function emptyTally(players: number): Tally {
+  return {
+    trainsCompleted: 0,
+    trainsCompletedWithWork: 0,
+    trainsDestroyed: 0,
+    carsDestroyed: 0,
+    carsCoupled: 0,
+    carsDropped: 0,
+    loadsStarted: 0,
+    loadsCompleted: 0,
+    unloadsBegun: 0,
+    unloadsCompleted: 0,
+    passengersBoarded: 0,
+    passengersDetrained: 0,
+    flyingSwitches: 0,
+    officeUpgrades: 0,
+    dispatchBonusesUsed: 0,
+    facilitiesUnjammed: 0,
+    expediteFaults: 0,
+    trainsHeld: 0,
+    trainsDiverted: 0,
+    secondSections: 0,
+    extrasStarted: 0,
+    cardsDrawn: 0,
+    cardsPlayed: 0,
+    cardsDiscarded: 0,
+    clearancesRequested: 0,
+    clearancesAllowed: 0,
+    circusStops: [],
+    switchedSince: [],
+    byPlayer: Array.from({ length: players }, () => ({
+      loads: 0,
+      unloads: 0,
+      passengersBoarded: 0,
+      passengersDetrained: 0,
+      cardsPlayed: 0,
+      collisions: 0,
+      revenueGained: 0,
+      revenueLost: 0,
+    })),
+  };
+}
+
+/**
+ * A deep copy, for freezing the official result (`FinalReport`).
+ *
+ * Written out rather than reached for via `structuredClone` because a Tally is a flat bag of numbers
+ * with two containers in it, and spelling the copy out means a field added later that needs deep
+ * copying is a compile error here rather than a shared reference discovered in a results screen.
+ */
+export function cloneTally(t: Tally): Tally {
+  return {
+    ...t,
+    circusStops: t.circusStops.map((c) => ({ ...c })),
+    switchedSince: [...t.switchedSince],
+    byPlayer: t.byPlayer.map((p) => ({ ...p })),
+  };
+}
+
 /**
  * WHICH WAY TO DRAW THE ENGINE — east or west, for every train, everywhere.
  *
@@ -771,22 +1013,25 @@ export function standingSides(
 }
 
 /**
- * The cut a train would run into if it left this card through `exit` — the cars between it and that
- * end of the card.
+ * The cut a train would run into if it left this card by the `exit` END OF THE ROW — the cars
+ * between it and that end. Returned in the order the train MEETS them, nearest first, which is what
+ * `carsCoupled` wants.
  *
- * Only 'e' and 'w' can hold a cut: the array is a west-to-east row, so a train leaving north or
- * south off a curve or a spur is not running along it and meets nothing. Returned in the order the
- * train MEETS them, nearest first, which is what `carsCoupled` wants.
+ * `exit` IS AN END OF THE ROW, NOT A PORT. It used to be a raw `Port`, and answered "you meet
+ * nothing" for north and south on the reasoning that a leg leaving through an edge is not running
+ * along the west-to-east row. It is: a `sw` curve's south leg IS the east end of that row, so a
+ * crew standing on the curve pulled out through the leg and drove away leaving the cars beside it
+ * standing, against §A.4's mandatory coupling (Gitea#17). Callers resolve the leg with `rowEndAt`
+ * (`track.ts`), which lives there because only the card's arc can say which end a leg is — and the
+ * narrowed type is what makes every caller do it.
  */
 export function cutTowards(
   tray: { standingWest?: number | undefined },
   cars: readonly RollingStock[],
-  exit: 'n' | 's' | 'e' | 'w',
+  exit: 'e' | 'w',
 ): RollingStock[] {
   const { west, east } = standingSides(tray, cars);
-  if (exit === 'e') return east;
-  if (exit === 'w') return [...west].reverse();
-  return [];
+  return exit === 'e' ? east : [...west].reverse();
 }
 
 export function turnOf(s: GameState, player: PlayerIndex): TurnState {
@@ -795,6 +1040,19 @@ export function turnOf(s: GameState, player: PlayerIndex): TurnState {
   return t;
 }
 
+/**
+ * §6.2 — IS THIS PLAYER HOLDING MORE THAN THEY MAY? Three cards, or four while a Red Flag is held.
+ *
+ * ONE answer, because there were three of them: `check('draw.end')` refused on it, `snapshot()`
+ * recomputed it inline for the Frame, and `web/game.ts` kept a third for the page. All three agreed
+ * — which is the state a disagreement starts from, and #96 is what that costs when the two halves
+ * are a screen and the server that refuses what the screen offered.
+ */
+export function overHandLimit(s: GameState, player: PlayerIndex): boolean {
+  const hand = s.decks.hands.get(player) ?? [];
+  return hand.length > (s.decks.redFlags.get(player) ? HAND_LIMIT + 1 : HAND_LIMIT);
+}
+
 export function freshTurn(moves: number): TurnState {
   return {
     option: null,
@@ -861,10 +1119,50 @@ 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;
-  status: 'setup' | 'active' | 'finished';
+  /**
+   * `awaitingExtension` is Gitea#11: the timetable has run out, the result is recorded, and the
+   * table is being asked whether to play one more Day. It is a PAUSE, not an ending — `advance`
+   * reports `needsInput` there, the server resumes it like any live game, and the only intent the
+   * rules will accept is `game.extend`.
+   */
+  status: 'setup' | 'active' | 'awaitingExtension' | 'finished';
+  /** The CURRENT evaluation, re-decided at the end of every Day including extended ones. */
   outcome: Outcome | null;
+  /**
+   * §3.3 (Gitea#11) — Days granted beyond `config.days`, one vote at a time.
+   *
+   * `config.days` is deliberately never touched: it is what the official result was decided at, so
+   * leaving it alone is what makes "the winner is decided at the original game length" a fact about
+   * the code rather than a comment on it.
+   */
+  extraDays: number;
+  /**
+   * Per PLAYER, while `awaitingExtension`. `null` means they have not voted yet.
+   *
+   * Unanimous, and one refusal is decisive: nobody is made to wait on a player who has already said
+   * no (Jesse's call, 2026-08-28). Solitaire is the same code with one voter.
+   */
+  extensionVotes: (boolean | null)[];
+  /** Frozen at the FIRST ending and never overwritten. See `FinalReport`. */
+  official: FinalReport | null;
+  /** Gitea#16. Folded from the event stream; see `Tally`. */
+  tally: Tally;
 };
 
 // ---------------------------------------------------------------------------
@@ -909,6 +1207,40 @@ export function playerAtSeat(state: GameState, seat: SeatIndex): PlayerIndex {
   return p;
 }
 
+/** This seat's node on the Division — where its Limits, and any Red Flag on them, live. */
+export function officeNodeFor(
+  state: GameState,
+  seat: SeatIndex,
+): Extract<DivisionNode, { kind: 'office' }> | null {
+  for (const n of state.division.nodes) if (n.kind === 'office' && n.seat === seat) return n;
+  return null;
+}
+
+/**
+ * WHO MUST ANSWER the interruption, or null when nothing is pending.
+ *
+ * The one place that knows which player each kind of question goes to. §8.1's clearance is the
+ * Superintendent's ruling wherever it happens; the Yard Office is offered to whoever sits in the
+ * district the train is arriving at, because it is their card and their yard.
+ */
+export function decisionActor(state: GameState): PlayerIndex | null {
+  const d = state.clock.pendingDecision;
+  if (!d) return null;
+  return d.kind === 'clearance' ? state.clock.superintendent : playerAtSeat(state, d.seat);
+}
+
+/**
+ * WHOSE MOVE IT IS RIGHT NOW — a pending interruption's owner if there is one, else the phase's
+ * own actor.
+ *
+ * Written out six times across the engine, the sim, the web client and the tests as
+ * `pendingDecision !== null ? superintendent : currentActor`, which stopped being right the moment
+ * a second kind of question existed. One copy now, so a new decision kind cannot be half-adopted.
+ */
+export function actingPlayer(state: GameState): PlayerIndex | null {
+  return decisionActor(state) ?? state.clock.currentActor;
+}
+
 /** Where this player is sitting, and therefore which Office Area is theirs. */
 /**
  * The player `n` seats to the LEFT of this one, wrapping round the table.

src/engine/tally.ts

@@ -0,0 +1,201 @@
+/**
+ * The event tally — Gitea#16's statistics, folded from the event stream into `GameState.tally`.
+ *
+ * WHERE IT IS HOOKED, and why it is not in `reduce`. `apply.ts`'s `reduce` sees only the events an
+ * INTENT produced; `advance.ts` mutates state directly and pushes its events without reducing them
+ * at all — and `advance` is where `trainCompleted`, `trainsDestroyed` and `trainStoodStill` come
+ * from, which are exactly the numbers this issue asks for. So the fold is hooked at the two places
+ * every event in the game passes through exactly once on its way to a caller:
+ *
+ *   - `applyIntent` (`apply.ts`), beside its `reduce` loop;
+ *   - `advance` (`advance.ts`), which now wraps the phase driver and folds what it returns.
+ *
+ * Exactly once matters in both directions: an event folded twice inflates a count, and an event
+ * folded nowhere is a statistic that silently reads zero. `test/tally.test.ts` pins both by playing
+ * real games and checking the tally against an independent count over the same event array.
+ *
+ * NOTHING HERE IS A RULE. The tally is read by the results screen and by the badge work Gitea#16
+ * leaves to a second pass; no engine decision consults it. That is what makes adding a counter
+ * always safe.
+ *
+ * WHAT IS NOT COUNTED PER PLAYER, and why. `carsCoupled` and `carsDropped` carry a `trayId` and no
+ * `player` — switching is done BY a crew, and the event says which crew rather than which person.
+ * Rather than guess an owner from whose turn it happened to be, those two are table totals only.
+ * The events that do name a player (`loadCompleted`, `passengersBoarded`, `cardPlayed`,
+ * `revenueChanged`, `trainsDestroyed`) are the ones `byPlayer` reports.
+ */
+
+import type { GameEvent } from './events.ts';
+import type { GameState } from './state.ts';
+
+/**
+ * Fold one event into `s.tally`.
+ *
+ * The switch is deliberately not exhaustive — most of the 49 event types say nothing a player would
+ * want counted, and listing them all to `break` would bury the ones that do. A `default` that does
+ * nothing is the honest shape.
+ */
+export function tallyEvent(s: GameState, e: GameEvent): void {
+  const t = s.tally;
+  const mine = 'player' in e && typeof e.player === 'number' ? t.byPlayer[e.player] : undefined;
+
+  switch (e.type) {
+    /**
+     * §X18 — the Circus train set up and was paid for the Stage it spent standing.
+     *
+     * NOT a "longest stand" streak, which is what Gitea#16 wants and what its comment assumed this
+     * event was. It fires once in a game per such train: only trains whose profile sets
+     * `stopEarnsPoint` emit it at all, and `advance.ts` claims it once with `stopPointClaimed`. So
+     * there is nothing to count a run of, and the honest thing to report is the event itself.
+     */
+    case 'trainStoodStill':
+      t.circusStops.push({ trainNumber: e.trainNumber, where: e.where });
+      break;
+
+    /**
+     * DID THIS TRAIN DO ANY SWITCHING — Gitea#16's "switching master" join, kept as it happens
+     * rather than reconstructed afterwards.
+     *
+     * The two halves of the join are in different currencies: switching events name a `trayId` and
+     * completion names a `trainNumber`, and no event carries both. The tray is looked up in LIVE
+     * state, which is sound precisely here — a crew that has just coupled or dropped is still on the
+     * board — where re-deriving it at completion time would not be, the tray having been released by
+     * then. A lookup that misses costs one train its mark on a statistic; it cannot affect a rule.
+     */
+    case 'carsCoupled':
+      t.carsCoupled += e.stock.length;
+      markSwitched(s, e.trayId);
+      break;
+
+    case 'carsDropped':
+      t.carsDropped += e.stock.length;
+      markSwitched(s, e.trayId);
+      break;
+
+    case 'flyingSwitch':
+      t.flyingSwitches += 1;
+      markSwitched(s, e.trayId);
+      break;
+
+    // A tray is reused run after run, so a fresh train starts with a clean sheet.
+    case 'trainMadeUp':
+      t.switchedSince = t.switchedSince.filter((n) => n !== e.trainNumber);
+      break;
+
+    case 'trainCompleted':
+      t.trainsCompleted += 1;
+      if (t.switchedSince.includes(e.trainNumber)) t.trainsCompletedWithWork += 1;
+      t.switchedSince = t.switchedSince.filter((n) => n !== e.trainNumber);
+      break;
+
+    case 'trainsDestroyed':
+      t.trainsDestroyed += e.trains.length;
+      for (const train of e.trains) t.carsDestroyed += train.consist.length;
+      if (mine) mine.collisions += 1;
+      break;
+
+    case 'officeUpgraded':
+      t.officeUpgrades += 1;
+      break;
+
+    case 'dispatchBonusUsed':
+      t.dispatchBonusesUsed += 1;
+      break;
+
+    case 'facilityUnjammed':
+      t.facilitiesUnjammed += 1;
+      break;
+
+    case 'expediteFault':
+      t.expediteFaults += 1;
+      break;
+
+    case 'trainHeld':
+      t.trainsHeld += 1;
+      break;
+
+    case 'trainDiverted':
+      t.trainsDiverted += 1;
+      break;
+
+    case 'secondSectionOrdered':
+      t.secondSections += 1;
+      break;
+
+    case 'extraStarted':
+      t.extrasStarted += 1;
+      break;
+
+    case 'cardDrawn':
+      t.cardsDrawn += 1;
+      break;
+
+    case 'cardPlayed':
+      t.cardsPlayed += 1;
+      if (mine) mine.cardsPlayed += 1;
+      break;
+
+    case 'cardDiscarded':
+      t.cardsDiscarded += 1;
+      break;
+
+    case 'clearanceRequested':
+      t.clearancesRequested += 1;
+      break;
+
+    // §8.1 — a ruling is given either way; only a YES let the other train through.
+    case 'clearanceGiven':
+      if (e.allow) t.clearancesAllowed += 1;
+      break;
+
+    case 'loadStarted':
+      t.loadsStarted += 1;
+      break;
+
+    case 'loadCompleted':
+      t.loadsCompleted += 1;
+      if (mine) mine.loads += 1;
+      break;
+
+    case 'unloadBegan':
+      t.unloadsBegun += 1;
+      break;
+
+    case 'unloadCompleted':
+      t.unloadsCompleted += 1;
+      if (mine) mine.unloads += 1;
+      break;
+
+    case 'passengersBoarded':
+      t.passengersBoarded += 1;
+      if (mine) mine.passengersBoarded += 1;
+      break;
+
+    case 'passengersDetrained':
+      t.passengersDetrained += 1;
+      if (mine) mine.passengersDetrained += 1;
+      break;
+
+    /**
+     * Gained and lost are kept APART because the net is already on `players[i].revenue`. What the
+     * results screen cannot otherwise say is how much of a modest final score was earned and then
+     * handed back at a grade crossing — which is the whole difference between a quiet game and an
+     * eventful one.
+     */
+    case 'revenueChanged':
+      if (mine) {
+        if (e.delta >= 0) mine.revenueGained += e.delta;
+        else mine.revenueLost += -e.delta;
+      }
+      break;
+
+    default:
+      break;
+  }
+}
+
+function markSwitched(s: GameState, trayId: string): void {
+  const n = s.trays.get(trayId)?.trainNumber;
+  if (n === undefined || n === null) return;
+  if (!s.tally.switchedSince.includes(n)) s.tally.switchedSince.push(n);
+}

src/engine/track.ts

@@ -188,6 +188,40 @@ export function joins(a: TrackCard, p: Port, b: TrackCard): boolean {
   return slopeAt(a, p) === slopeAt(b, opposite(p));
 }
 
+/**
+ * WHICH END OF THE WEST-TO-EAST ROW A PORT SITS AT.
+ *
+ * `TrackCard.standing` is ordered west to east (§A.3), so whether a train meets the row front to
+ * back or back to front depends on which end it enters by — and a port is not always at one of
+ * those two extremes. Every 45° leg leaves through the MIDDLE of its north or south edge, so its
+ * end of the run is whichever end the arc does NOT reach: a `sw` curve's south leg is the EAST end
+ * of the row, and an `se` curve's south leg is the WEST end. Same port, opposite answers, which is
+ * why this has to ask the card rather than read the port.
+ *
+ * Gitea#17 is what both callers looked like without it. `exploreMoves` reversed the row for an 'e'
+ * entry and for nothing else, so backing into a cut through a `sw` curve's south leg coupled it up
+ * back to front — the caboose came out next to the engine, which §8.2 then calls badly made up.
+ * `cutTowards` answered "you meet nothing" for a north or south exit, so a crew standing on a curve
+ * pulled out through the leg and left the cars beside it standing, which §A.4 forbids.
+ *
+ * There is no north-south straight anywhere on the printed sheet (see the module comment), so a run
+ * touching a 45° leg always has an east or west port at its other end and the answer is never
+ * undefined. A TURNOUT is the one card whose row has three ends rather than two — and it is also
+ * the one card no cut can ever stand on, since a train may not stop there (§A.1) and so never sets
+ * anything out there. Its stem answers for it.
+ */
+export function rowEndAt(card: TrackCard, p: Port): 'e' | 'w' {
+  if (p === 'e' || p === 'w') return p;
+  for (const [a, b] of connectionsFor(card)) {
+    const other = a === p ? b : b === p ? a : null;
+    if (other === 'e') return 'w';
+    if (other === 'w') return 'e';
+  }
+  // Not a card the printed sheet can produce. Reading the leg as the west end leaves the row in the
+  // order it is stored rather than inventing a reversal on a card nothing knows the shape of.
+  return 'w';
+}
+
 // ---------------------------------------------------------------------------
 // Orientation (Gap 11)
 // ---------------------------------------------------------------------------
@@ -343,7 +377,7 @@ export function reachableDestinations(
   start: GridCoord,
   initialExit: Port,
 ): MoveDestination[] {
-  return exploreMoves(ctx, start, initialExit).destinations;
+  return exploreMoves(ctx, start, initialExit, false).destinations;
 }
 
 /**
@@ -400,12 +434,19 @@ export function exploreMoves(
   ctx: MoveContext,
   start: GridCoord,
   initialExit: Port,
+  /**
+   * False when only the destinations are wanted (`reachableDestinations`, every legality check): the
+   * rejections are then not recorded at all. They never change a destination, and building them was
+   * pure allocation on the hottest path in the engine.
+   */
+  collectBlocks = true,
 ): { destinations: MoveDestination[]; blocked: MoveBlock[] } {
   const { area, occupancy } = ctx;
   const results: MoveDestination[] = [];
   const blocked: MoveBlock[] = [];
   const noted = new Set<string>();
   const block = (coord: GridCoord, kind: MoveBlockKind, why: string): void => {
+    if (!collectBlocks) return;
     const k = coordKey(coord);
     if (noted.has(k)) return;
     noted.add(k);
@@ -425,10 +466,25 @@ export function exploreMoves(
     couples: RollingStock[];
     /** Coord key each entry in `couples` came off, aligned by index — see `routeOutcomeKey`. */
     origins: string[];
-    /** Cards visited on THIS route, start included. A per-path set, not a global one — see the
-     * module doc comment on `MAX_ENUMERATED_FRONTIER` for why a global one would forbid the very
-     * routes this walk exists to find. */
-    visited: Set<string>;
+  };
+
+  /**
+   * Has THIS route already used `to`? Per-path, not global — see the doc comment on
+   * `MAX_ENUMERATED_FRONTIER` for why a global set would forbid the very routes this walk exists to
+   * find.
+   *
+   * Read off the route's own `path` instead of a Set copied at every step, which was a large share of
+   * the walk's garbage. It answers exactly as that Set did: the start square, then every square
+   * enqueued along the route AFTER the first hop, including this node's own — the first hop's square
+   * was never added, and `path[0]` is that square, so the scan begins at 1.
+   */
+  const onRoute = (node: Frontier, to: GridCoord): boolean => {
+    if (sameCoord(to, start)) return true;
+    if (node.path.length > 0 && sameCoord(to, node.coord)) return true;
+    for (let k = 1; k < node.path.length; k++) {
+      if (sameCoord(node.path[k]!.coord, to)) return true;
+    }
+    return false;
   };
 
   // The very first hop is checked here because `start`'s card is not itself enqueued; every later
@@ -450,7 +506,7 @@ export function exploreMoves(
    *
    * Ordered nearest-first like every other card's, so it simply seeds the accumulator.
    */
-  const ownCut = cutTowards(startCard, carsOn(startCard), initialExit);
+  const ownCut = cutTowards(startCard, carsOn(startCard), rowEndAt(startCard, initialExit));
   const startKey = coordKey(start);
   const queue: Frontier[] = [
     {
@@ -459,13 +515,14 @@ export function exploreMoves(
       path: [],
       couples: ownCut,
       origins: ownCut.map(() => startKey),
-      visited: new Set([startKey]),
     },
   ];
   let enumerated = 1;
 
-  while (queue.length > 0) {
-    const node = queue.shift()!;
+  // FIFO by index rather than `shift()`, which re-packs the array on every pop. Same order.
+  let head = 0;
+  while (head < queue.length) {
+    const node = queue[head++]!;
     const card = cardAt(area, node.coord);
     if (!card) continue;
 
@@ -502,12 +559,15 @@ export function exploreMoves(
      * overfill the tray is illegal, not a move that picks up fewer cars.
      *
      * NEAREST FIRST ALONG THE DIRECTION OF TRAVEL. `carsOn` runs west to east, so a train entering
-     * through the card's EAST port meets them back to front and the row has to be reversed. Without
-     * this the same parked cut produced an identical consist whichever way it was approached, when
-     * the two must mirror — which is the difference between a run-around being worth a Move and
-     * being pointless.
+     * at the row's EAST end meets them back to front and the row has to be reversed. Without this
+     * the same parked cut produced an identical consist whichever way it was approached, when the
+     * two must mirror — which is the difference between a run-around being worth a Move and being
+     * pointless.
+     *
+     * `rowEndAt` rather than `node.entry === 'e'`: a 45° leg is an end of the row too, and which
+     * end it is depends on the card's arc (Gitea#17).
      */
-    const met = node.entry === 'e' ? [...carsOn(card)].reverse() : carsOn(card);
+    const met = rowEndAt(card, node.entry) === 'e' ? [...carsOn(card)].reverse() : carsOn(card);
     const couples = [...node.couples, ...met];
     const nodeKey = coordKey(node.coord);
     const origins = [...node.origins, ...met.map(() => nodeKey)];
@@ -555,17 +615,15 @@ export function exploreMoves(
       // direction; it never says without repeating ground, but a train cannot occupy the same
       // track twice at once either). Per-path, not global — a DIFFERENT route may legitimately
       // pass through a card this one already used.
-      const toKey = coordKey(to);
-      if (node.visited.has(toKey)) continue;
+      if (onRoute(node, to)) continue;
       if (enumerated >= MAX_ENUMERATED_FRONTIER) break;
       enumerated++;
       const step: MoveStep = { coord: node.coord, entry: node.entry, exit };
-      const visited = new Set(node.visited);
-      visited.add(toKey);
-      queue.push({ coord: to, entry: opposite(exit), path: [...node.path, step], couples, origins, visited });
+      queue.push({ coord: to, entry: opposite(exit), path: [...node.path, step], couples, origins });
     }
   }
 
+  if (!collectBlocks) return { destinations: results, blocked };
   // A card that turned out to be reachable after all is not a blocker: the walk may meet a square
   // from a bad angle first and a good one later.
   const reached = new Set(results.map((r) => coordKey(r.coord)));
@@ -658,6 +716,26 @@ export function canPlaceAt(area: OfficeArea, coord: GridCoord, card: TrackCard):
   // into a stub and cutting the Office off from the Limits.
   if (coord.row === area.runningRow && !carriesThroughTrack(card)) return false;
 
+  /**
+   * ONE NEIGHBOUR MUST JOIN. THE OTHERS NEED NOT — AND THIS RULE HAS BEEN BOTH WAYS (Gitea#15).
+   *
+   * A card may be laid with an exit facing a card that has nothing to meet it. The rail stops dead
+   * at that edge, and that is legal.
+   *
+   * The issue was filed the other way round — "if a card is placed in that space, it MUST connect" —
+   * against a right-hand curve laid with its north leg against an Ice House and the turnout below it
+   * pointing at its portless south edge. **RAR reversed it on review (2026-08-26): placing it is
+   * fine, and a stub like that is useful — a siding to park cars on.**
+   *
+   * WHAT MATTERS INSTEAD IS THAT NOTHING CAN DRIVE ACROSS THE GAP, so the real requirement is on
+   * MOVEMENT rather than on placement: two cards touching are not connected, and `exploreMoves` must
+   * refuse the hop. It does — every step is gated on `joins`, never on a bare pair of `hasPort`
+   * calls — and `track.test.ts` pins the reported geometry against exactly that.
+   *
+   * SO DO NOT ADD A PER-EDGE CHECK HERE. One was written and taken out again when the ruling
+   * arrived. What survives is the weaker rule that was always here: the piece must touch the network
+   * SOMEWHERE, which is what stops orphaned track being laid in an empty corner of the board.
+   */
   const ports: Port[] = ['n', 's', 'e', 'w'];
   for (const p of ports) {
     const neighbourCard = cardAt(area, neighbour(coord, p));

src/server/claims.ts

@@ -0,0 +1,83 @@
+/**
+ * SEAT RECOVERY CODES — Gitea#33.
+ *
+ * A session token is the only identity the game has (`lobby-and-sessions.md` §1) and it lives in
+ * exactly one place the player controls: their browser's `localStorage`, scoped to the origin they
+ * joined at. Lose that — a different browser, a cleared profile, a private window — and the seat is
+ * unreachable, because there is nothing else on the server that will accept a claim to it. Seen at a
+ * real table on 2026-09-16: the joining player came back to an empty lobby while their token sat
+ * intact in `sessions.json`, and the only way in was an administrator reading the file off the data
+ * volume and the player pasting it into a devtools console.
+ *
+ * THE CODE IS NOT THE TOKEN, AND THAT IS THE WHOLE POINT. §1 says to keep the token out of URLs so it
+ * is not shoulder-surfed or pasted into a chat — and a recovery link is exactly the kind of thing
+ * that gets pasted into a chat. So an administrator mints a SHORT-LIVED, SINGLE-USE code, the player
+ * opens a link carrying that, and the page trades it for the real token over the same connection it
+ * would have used anyway. A code that leaks after it is spent is worth nothing; a token that leaks is
+ * worth the seat for the rest of the game.
+ *
+ * PURE ON PURPOSE, like `lobby.ts` beside it: no sockets, no filesystem, no clock of its own. `now`
+ * is passed in so expiry is testable without faking timers, which is the only reason this file can be
+ * tested at all — nothing in this repo stands an HTTP server up to make requests against it.
+ *
+ * IN MEMORY, NOT ON DISK, which is a deliberate limit rather than an oversight. A restart drops every
+ * outstanding code, and that is the right failure: the codes are minted on demand and spent within
+ * minutes, the administrator is by definition present, and persisting them would put a credential-
+ * equivalent on the volume to solve a problem measured in seconds.
+ */
+
+import { randomUUID } from 'node:crypto';
+
+/**
+ * Long enough to walk to the other room and read it out; short enough that a link left in a chat
+ * window is useless by the time anyone scrolls back to it.
+ */
+export const CLAIM_TTL_MS = 30 * 60 * 1000;
+
+export type ClaimStore = {
+  /** Mint a code for one seat's token. Returns the code and when it stops working. */
+  mint(token: string, gameId: string, now: number, ttlMs?: number): { code: string; expiresAt: number };
+  /**
+   * Spend a code. Returns the seat it names, or null when the code is unknown, already spent or
+   * expired — deliberately one answer for all three, so a caller cannot probe which it was.
+   */
+  redeem(code: string, now: number): { token: string; gameId: string } | null;
+  /** Outstanding, unexpired codes. For tests and for anything that wants to report the store's size. */
+  outstanding(now: number): number;
+};
+
+export function createClaimStore(): ClaimStore {
+  const claims = new Map<string, { token: string; gameId: string; expiresAt: number }>();
+
+  /** Expiry is lazy: there is no timer to own, start, stop or leak across a server's lifetime. */
+  const prune = (now: number): void => {
+    for (const [code, claim] of claims) if (claim.expiresAt <= now) claims.delete(code);
+  };
+
+  return {
+    mint(token, gameId, now, ttlMs = CLAIM_TTL_MS) {
+      prune(now);
+      // The same primitive the session tokens themselves use (`lobby.ts`), for the same reason: it
+      // has to be unguessable, and inventing a second scheme here would be inventing a weaker one.
+      const code = randomUUID();
+      const expiresAt = now + ttlMs;
+      claims.set(code, { token, gameId, expiresAt });
+      return { code, expiresAt };
+    },
+
+    redeem(code, now) {
+      prune(now);
+      const claim = claims.get(code);
+      if (!claim) return null;
+      // SINGLE USE. Deleted before the caller can do anything with it, so two browsers racing on the
+      // same link cannot both be seated — and a link that stays in someone's history is spent.
+      claims.delete(code);
+      return { token: claim.token, gameId: claim.gameId };
+    },
+
+    outstanding(now) {
+      prune(now);
+      return claims.size;
+    },
+  };
+}

src/server/http.ts

@@ -37,6 +37,7 @@ import {
   writeLobby,
   writeSessions,
 } from './persistence.ts';
+import { createClaimStore } from './claims.ts';
 import { createSession } from './session.ts';
 import type { GameSession, Push } from './session.ts';
 import {
@@ -101,7 +102,13 @@ function sendJson(res: ServerResponse, status: number, body: unknown): void {
   res.end(text);
 }
 
-async function serveStatic(distDir: string, urlPath: string, res: ServerResponse): Promise<void> {
+async function serveStatic(
+  distDir: string,
+  urlPath: string,
+  res: ServerResponse,
+  /** The request's `?v=` build tag, when it has one — see the `Cache-Control` note below. */
+  buildTagged = false,
+): Promise<void> {
   const rel = urlPath === '/' ? '/index.html' : urlPath;
   // `normalize` collapses `..`, and the join is then checked to still be inside `distDir` — a request
   // for `/../../etc/passwd` must not escape the one directory this is allowed to read from.
@@ -113,7 +120,27 @@ async function serveStatic(distDir: string, urlPath: string, res: ServerResponse
   try {
     const info = await stat(full);
     if (!info.isFile()) throw new Error('not a file');
-    res.writeHead(200, { 'Content-Type': MIME[extname(full)] ?? 'application/octet-stream', 'Content-Length': info.size });
+    /**
+     * ONLY A URL CARRYING A BUILD TAG MAY BE CACHED, AND NOTHING ELSE MAY BE.
+     *
+     * Nothing here sent a `Cache-Control` at all before, so a browser applied its own heuristic to
+     * the pages as much as the modules. The pages are the one thing that CANNOT be versioned in
+     * their own URL — a player types the address or follows a bookmark — so a cached `play.html`
+     * pins that player to the entire build it names, including every `?v=` tag inside it. That is
+     * half of why v0.7.5 and v0.7.6 did not reach the browser that asked for them; `build-web.ts`
+     * publishing `?v=nogit` on every packaged release was the other half, and neither is enough on
+     * its own.
+     *
+     * `?v=` is the exact condition rather than "not HTML": `build-web.ts` tags the modules and the
+     * script tags that load them, and tags NOTHING else. An untagged URL — an image, the replay
+     * manifest — has no way to announce a change, so a year of `immutable` on one would outlive
+     * several releases of whatever it holds.
+     */
+    res.writeHead(200, {
+      'Content-Type': MIME[extname(full)] ?? 'application/octet-stream',
+      'Content-Length': info.size,
+      'Cache-Control': buildTagged ? 'public, max-age=31536000, immutable' : 'no-cache',
+    });
     createReadStream(full).pipe(res);
   } catch {
     res.writeHead(404, { 'Content-Type': 'text/plain' });
@@ -144,6 +171,15 @@ export function startServer(opts: ServerOptions): void {
   const games = opts.initialGames;
   const lobbies = opts.initialLobbies;
   const sessions = opts.initialSessions;
+  /**
+   * Outstanding seat recovery codes — Gitea#33, `claims.ts`.
+   *
+   * In memory and not on the volume, deliberately: a code is minted on demand and spent within
+   * minutes with the administrator standing right there, so a restart dropping them all is the right
+   * failure. Persisting them would put a credential-equivalent on disk to solve a problem measured
+   * in seconds.
+   */
+  const claims = createClaimStore();
   const gameCodes = new Map<string, string>(); // gameCode -> gameId, for /api/lobby/join
   for (const [gameId, lobby] of lobbies) gameCodes.set(lobby.gameCode, gameId);
 
@@ -281,7 +317,7 @@ export function startServer(opts: ServerOptions): void {
         // Unset means the routes are not here — indistinguishable from any other unknown path, so
         // nothing advertises an administrative surface to someone probing for one.
         if (!opts.adminSecret) {
-          await serveStatic(opts.distDir, url.pathname, res);
+          await serveStatic(opts.distDir, url.pathname, res, url.searchParams.has('v'));
           return;
         }
         if (req.headers['x-admin-secret'] !== opts.adminSecret) {
@@ -296,6 +332,17 @@ export function startServer(opts: ServerOptions): void {
             gameId,
             gameCode: codes.get(gameId) ?? null,
             state: 'running' as const,
+            /**
+             * WHICH SEATS A PERSON IS SITTING IN — Gitea#33.
+             *
+             * `playerNames` cannot answer it: a bot's name is just a name, and telling the two apart
+             * by matching "Bot 1" would be guessing at a label. `sessions` holds humans and only
+             * humans, so this is the fact rather than an inference — and it is what lets the seat
+             * recovery action offer real players instead of chairs no token was ever issued for.
+             */
+            seatedPlayers: [...sessions.values()]
+              .filter((s) => s.gameId === gameId)
+              .map((s) => s.player),
             ...g.summary(),
           }));
           // A lobby has no game to summarize yet — it is reported as what it is, so an
@@ -314,14 +361,48 @@ export function startServer(opts: ServerOptions): void {
           return;
         }
 
-        const match = /^\/api\/games\/([^/]+)(\/save)?$/.exec(url.pathname);
+        const match = /^\/api\/games\/([^/]+)(\/save|\/claim)?$/.exec(url.pathname);
         const gameId = match?.[1];
+        // Compared explicitly rather than tested for truthiness: with two suffixes in the group, a
+        // bare `match?.[2]` would let a GET on `/claim` fall into the `/save` branch below.
+        const suffix = match?.[2];
         if (!gameId) {
           sendJson(res, 404, { error: 'no such route' });
           return;
         }
 
-        if (match?.[2] && req.method === 'GET') {
+        /**
+         * MINT A SEAT RECOVERY CODE FOR ONE PLAYER — Gitea#33.
+         *
+         * The token is the only identity this game has and it lives in one browser's `localStorage`;
+         * lose it and the seat is unreachable, because nothing else here will accept a claim to it.
+         * This is the supported way back, and it is administrative on purpose: whoever runs the
+         * server decides that a particular player has lost their seat, which is a judgement no
+         * automated route can make safely.
+         *
+         * IT HANDS BACK A CODE, NOT THE TOKEN. §1 says keep the token out of URLs, and the code is
+         * going into one. Short-lived and single-use (`claims.ts`), so a link left in a chat window
+         * is worth nothing by the time anyone finds it.
+         */
+        if (suffix === '/claim' && req.method === 'POST') {
+          const body = (await readJson(req)) as { player?: number };
+          const ps = [...sessions.values()].find((s) => s.gameId === gameId && s.player === body.player);
+          if (!ps) {
+            sendJson(res, 404, { error: 'no such seat' });
+            return;
+          }
+          const { code, expiresAt } = claims.mint(ps.token, gameId, Date.now());
+          sendJson(res, 200, {
+            code,
+            expiresAt,
+            player: ps.player,
+            displayName: ps.displayName,
+            gameCode: codes.get(gameId) ?? null,
+          });
+          return;
+        }
+
+        if (suffix === '/save' && req.method === 'GET') {
           const session = games.get(gameId);
           if (!session) {
             sendJson(res, 404, { error: 'no such game' });
@@ -630,6 +711,57 @@ export function startServer(opts: ServerOptions): void {
         return;
       }
 
+      /**
+       * SPEND A SEAT RECOVERY CODE — Gitea#33, the other half of `/api/games/<id>/claim`.
+       *
+       * NOT GATED BY THE ADMIN SECRET, and it must not be: the player following the link is the one
+       * person in this story who holds no secret at all. The code IS the authorisation — unguessable,
+       * single-use and short-lived — which is the same shape as the session token it hands back, and
+       * why minting one is the administrative act rather than spending one.
+       *
+       * The token travels in the response BODY of a POST, never in a URL (`lobby-and-sessions.md`
+       * §1). One answer for unknown, spent and expired codes, so this cannot be used to probe which.
+       */
+      if (url.pathname === '/api/claim' && req.method === 'POST') {
+        const body = (await readJson(req)) as { code?: string };
+        const claimed = typeof body.code === 'string' ? claims.redeem(body.code, Date.now()) : null;
+        const ps = claimed ? sessions.get(claimed.token) : undefined;
+        const live = ps ? games.get(ps.gameId) : undefined;
+        if (!claimed || !ps || !live) {
+          sendJson(res, 404, { error: 'no such claim' });
+          return;
+        }
+        const codes = new Map((await readIndex(opts.dataDir)).map((e) => [e.gameId, e.gameCode]));
+        sendJson(res, 200, {
+          token: ps.token,
+          gameId: ps.gameId,
+          player: ps.player,
+          gameCode: codes.get(ps.gameId) ?? '',
+        });
+        return;
+      }
+
+      /**
+       * THIS SEAT'S OWN GAME, AS A SAVE (playtest, 2026-09-15: "most of the time, I want to go ahead and
+       * just save it as a JSON file in my Downloads folder").
+       *
+       * The administrative export at `/api/games/<id>/save` is gated on the admin secret, which a player
+       * does not have and should not need: a save is the seed and the moves, and every one of those moves
+       * is already on this player's screen. So the seat's own session token is the gate, exactly as it is
+       * for `/api/stream` and `/api/intent` — it proves which game and which chair, and nothing else is
+       * disclosed. The page turns the JSON into a file (`main.ts`'s `downloadSave`).
+       */
+      if (url.pathname === '/api/save' && req.method === 'GET') {
+        const ps = sessions.get(url.searchParams.get('token') ?? '');
+        const session = ps ? games.get(ps.gameId) : undefined;
+        if (!ps || !session) {
+          sendJson(res, 404, { error: 'no such game' });
+          return;
+        }
+        sendJson(res, 200, { gameId: ps.gameId, save: session.exportSave() });
+        return;
+      }
+
       if (url.pathname === '/api/stream' && req.method === 'GET') {
         const token = url.searchParams.get('token') ?? '';
         const ps = sessions.get(token);
@@ -700,7 +832,7 @@ export function startServer(opts: ServerOptions): void {
         return;
       }
 
-      await serveStatic(opts.distDir, url.pathname, res);
+      await serveStatic(opts.distDir, url.pathname, res, url.searchParams.has('v'));
     })().catch((err: unknown) => {
       sendJson(res, 500, { error: err instanceof Error ? err.message : 'internal error' });
     });

src/server/session.ts

@@ -22,12 +22,14 @@ import { check } from '../engine/apply.ts';
 import { legalActions } from '../engine/legal.ts';
 import type { Intent } from '../engine/intents.ts';
 import type { GameConfig, PlayerIndex } from '../engine/state.ts';
-import { actionMenu, currentActor, fromMultiplayerSave, newMultiplayerGame, submit } from '../web/game.ts';
+import { actionMenu, currentActor, fromMultiplayerSave, isOutOfTurn, newMultiplayerGame, submit } from '../web/game.ts';
 import type { Game, Menu } from '../web/game.ts';
 import { deltaFrame } from '../sim/frame-delta.ts';
 import type { FrameDelta } from '../sim/frame-delta.ts';
-import { snapshot, seatLabel } from '../sim/view.ts';
-import type { Frame } from '../sim/view.ts';
+import { publicSnapshot, snapshot, seatLabel } from '../sim/view.ts';
+import type { Frame, PublicFrame } from '../sim/view.ts';
+import { takeSteps } from '../sim/display-step.ts';
+import type { DisplayStep } from '../sim/display-step.ts';
 import { developerBot } from '../sim/bot.ts';
 
 export type Push = {
@@ -69,6 +71,29 @@ export type Push = {
   scheduled?: number | null;
   announcement?: string | null;
   justDrawn?: string | null;
+  /**
+   * ORDERED PRESENTATION STEPS — v0.8.0, TODO #13.
+   *
+   * A field on `Push` rather than a second SSE event type, following `presence`'s precedent and for
+   * its stated reason (`http.ts`): one message shape for the client to parse. `http.ts` therefore
+   * needs no change at all — `broadcastGame` forwards whatever this file builds.
+   *
+   * IDENTICAL IN EVERY SEAT'S PUSH, because a step carries the PUBLIC board and nothing else. A
+   * player's own hand, menu and objective are not animated: they arrive on the same push, already
+   * coalesced, exactly as they always have. That is what keeps the redaction surface at zero new
+   * area — `test/redaction.test.ts` guards the projection these are built from.
+   */
+  steps?: DisplayStep[];
+  /**
+   * The public board to start a step queue from — sent on a CONNECT, never on an update.
+   *
+   * Steps carry deltas against one chain shared by the whole table, so a client that has just
+   * arrived (or come back) has nothing to merge the next delta onto and `applyPublicDelta` would
+   * rightly throw. This is that baseline: the exact frame the chain has reached, so the next step
+   * lands on it. A reconnecting client resets rather than replaying what it missed — the history
+   * panel is what carries the words, and it is already sent whole on connect (#97).
+   */
+  publicReset?: PublicFrame;
 };
 
 /**
@@ -174,8 +199,17 @@ function buildSession(
   };
   let open: OpenSpan | null = openSpanFor(Date.now());
 
+  /**
+   * A seat's full Frame, with `lines` deliberately EMPTY (#97).
+   *
+   * Narration reaches a client by ONE path — `Push.lines` — because `RemoteSession`
+   * (`web/session.ts`) accumulates from that field alone and its `lines()` returns the accumulator.
+   * Passing `game.log` here serialised the entire log into every frame for every seat, where it grew
+   * all game and was thrown away on arrival, while `linesSince` correctly sent the same text beside
+   * it. The duplicate was not merely waste: it masked the reconnect bug `connect` fixes below.
+   */
   function frameFor(seat: PlayerIndex): Frame {
-    return snapshot(game.state, game.log, null, null, null, false, seat);
+    return snapshot(game.state, [], null, null, null, false, seat);
   }
 
   function linesSince(seat: PlayerIndex): { text: string; tone: string }[] {
@@ -202,11 +236,12 @@ function buildSession(
     return { cues, scheduled, announcement };
   }
 
-  function pushFor(seat: PlayerIndex, moment: Moment | null): Push {
+  function pushFor(seat: PlayerIndex, moment: Moment | null, steps: DisplayStep[] = []): Push {
     const frame = frameFor(seat);
     const delta = deltaFrame(lastFrame.get(seat) ?? null, frame);
     lastFrame.set(seat, frame);
     const push: Push = { frame: delta, menu: menuFor(seat), lines: linesSince(seat) };
+    if (steps.length > 0) push.steps = steps;
     if (moment) {
       if (moment.cues.length > 0) push.cues = moment.cues;
       if (moment.scheduled !== null) push.scheduled = moment.scheduled;
@@ -219,9 +254,13 @@ function buildSession(
 
   function pushesForAll(): Map<PlayerIndex, Push> {
     const moment = takeMoment();
+    // Drained ONCE for the whole broadcast, not per seat: the steps are public and identical, and
+    // `takeSteps` empties the collector, so draining inside the loop would give them to seat 0 and
+    // an empty list to everybody else.
+    const steps = takeSteps(game.display);
     const out = new Map<PlayerIndex, Push>();
     for (let seat = 0; seat < playerNames.length; seat++) {
-      out.set(seat as PlayerIndex, pushFor(seat as PlayerIndex, moment));
+      out.set(seat as PlayerIndex, pushFor(seat as PlayerIndex, moment, steps));
     }
     return out;
   }
@@ -262,6 +301,52 @@ function buildSession(
    * in zero wall-clock time by definition. Called once at construction (a resume could land exactly
    * on a bot's turn) and once after every accepted human intent.
    */
+/**
+   * §3.3, EXTENDED PLAY (Gitea#11) — the bots' half of a unanimous vote.
+   *
+   * "Bots will not disagree with the human. Humans get to vote first. If all humans vote yes, then
+   * bots vote yes too. If a human votes no, it's not unanimous, it ends right then. If only bots are
+   * playing, they never vote to extend" (Jesse, 2026-08-28).
+   *
+   * Which makes a bot's vote a formality rather than a policy decision, performed once the humans
+   * have already settled it, so that the unanimity the engine checks is a real unanimity rather than
+   * a special case carved into the rules for absent players.
+   *
+   * THE ALL-BOT TABLE IS THE CASE TO GET RIGHT, and getting it wrong hung the game. `driveBots`
+   * cannot reach the vote — it loops on `currentActor`, which is null the moment the game stops —
+   * so if this returns early with no humans to follow, nobody votes at all and a bot-only game sits
+   * on the question for ever. It happened: an all-bot session never reached `finished`. With nobody
+   * to follow, the bots' own answer stands, and it is no.
+   */
+  function driveBotVotes(): void {
+    if (game.state.status !== 'awaitingExtension') return;
+    const humans = [...Array(playerNames.length).keys()].filter((p) => !botSeats.has(p));
+    // A human who has voted `false` has already ended the game, so reaching here with humans still
+    // outstanding means the table is genuinely waiting on a person. Bots wait with it.
+    if (humans.length > 0 && !humans.every((p) => game.state.extensionVotes[p] === true)) return;
+    const agree = humans.length > 0;
+    for (const seat of botSeats) {
+      if (game.state.extensionVotes[seat] === null) {
+        submit(game, { type: 'game.extend', player: seat, agree }, seat);
+      }
+    }
+  }
+
+  /**
+   * Bots play, bots vote, and an agreed extension puts them back to playing — so the two drivers
+   * alternate rather than running once each. Bounded because every pass must consume something: a
+   * turn, or a vote that cannot be cast twice.
+   */
+  function driveBotTurns(): void {
+    for (let pass = 0; pass < 1_000; pass++) {
+      const before = game.history.length;
+      driveBots();
+      driveBotVotes();
+      if (game.history.length === before) return;
+    }
+    throw new Error('driveBotTurns: probable infinite loop');
+  }
+
   function driveBots(): void {
     let guard = 0;
     for (;;) {
@@ -281,11 +366,24 @@ function buildSession(
       settleTiming();
     }
   }
-  driveBots();
+  driveBotTurns();
   // Whatever the opening bot turns earned belongs to a game nobody was connected to yet — dropped
   // here rather than fired at the first client to arrive. (It also stops `game.cues` growing without
   // bound on a server, which nothing was draining before this.)
   takeMoment();
+  /**
+   * THE PRESENTATION STEPS THOSE TURNS PRODUCED GO WITH THEM (v0.8.0).
+   *
+   * Left in the collector they would be delivered on the FIRST broadcast after somebody connects —
+   * but that client's `publicReset` is the board as it stands AFTER these very moves, so replaying
+   * them onto it would draw positions the game had already left. The plan says as much: opening bot
+   * moves need no replay, and a later display simply receives the final reset.
+   *
+   * This is the only moment the collector holds anything outside an intent. `pushesForAll()` drains
+   * it synchronously at the end of every `intent()`, so between moves it is always empty — which is
+   * what makes dropping here safe rather than a race with a seat that has not been sent them yet.
+   */
+  takeSteps(game.display);
 
   return {
     playerCount: playerNames.length,
@@ -295,7 +393,19 @@ function buildSession(
       // A (re)connect always starts from a clean slate — no cache to trust across a lost connection
       // (or a server restart, Phase 3) — so the honest thing is a full Frame, not a delta.
       lastFrame.delete(seat);
-      return pushFor(seat, null);
+      // ...and the NARRATION watermark with it (#97). The browser this answers has just reloaded
+      // from an empty accumulator, so a seat told "nothing new since your last push" came back to a
+      // blank history panel mid-game, with the server holding the whole log. `Push.lines` on a
+      // connect IS the history, which is what lets the Frame stop carrying a second copy.
+      sentLines.delete(seat);
+      const push = pushFor(seat, null);
+      /**
+       * The baseline for this client's step queue (v0.8.0). `game.display.last` is the exact frame
+       * the shared delta chain has reached, so the next step merges onto it; before any step has
+       * been collected there is no chain yet and a fresh projection is the same thing.
+       */
+      push.publicReset = game.display.last ?? publicSnapshot(game.state);
+      return push;
     },
 
     intent(seat, seq, i) {
@@ -304,7 +414,17 @@ function buildSession(
       // never applied, so it is worth trying again (see the `lastSeq.set` below: only on success).
       if (lastSeq.get(seat) === seq) return { accepted: true, pushes: new Map(), timing: null };
 
-      if (seat !== currentActor(game)) return { accepted: false, code: 'NOT_YOUR_TURN' };
+      /**
+       * §3.3, EXTENDED PLAY (Gitea#11) — the vote is the one intent with no actor to be.
+       *
+       * `currentActor` is null once the timetable has run out, so this guard would refuse every
+       * vote with NOT_YOUR_TURN. Every seat may vote, and `check` is still the authority on whether
+       * this particular seat may vote right now (it has voted already; the game is not waiting on a
+       * vote at all), so skipping the turn test here gives nothing away.
+       */
+      if (!isOutOfTurn(i) && seat !== currentActor(game)) {
+        return { accepted: false, code: 'NOT_YOUR_TURN' };
+      }
 
       // Checked directly, rather than via `submit`'s boolean, for two reasons: `submit` writes a
       // "that is not allowed" line into the SHARED `game.log` on rejection, which would otherwise
@@ -315,7 +435,7 @@ function buildSession(
       if (code) return { accepted: false, code };
 
       const drawnBefore = game.justDrawn;
-      const applied = submit(game, i);
+      const applied = submit(game, i, isOutOfTurn(i) ? seat : null);
       if (game.justDrawn !== drawnBefore && game.justDrawn !== null) {
         lastDraw = { seat, cardId: game.justDrawn };
       }
@@ -327,8 +447,9 @@ function buildSession(
       const timing = settleTiming();
       // Any bot due to act now plays out entirely before this push goes back — the delta mechanism
       // diffs against whatever was last sent, so it captures the bots' moves along with the human's
-      // in one push regardless of how many turns that took.
-      driveBots();
+      // in one push regardless of how many turns that took. Votes included, since Gitea#11: a human
+      // agreeing to another Day is exactly the move the bots are waiting on to agree themselves.
+      driveBotTurns();
       return { accepted: true, pushes: pushesForAll(), timing };
     },
 
@@ -338,6 +459,8 @@ function buildSession(
         config: game.state.config,
         playerNames: [...playerNames],
         history: [...game.history],
+        // `awaitingExtension` is a game waiting on its table, not a game that is over — so it maps
+        // to 'active' and `server/index.ts` resumes it on a restart like any other (Gitea#11).
         status: game.state.status === 'finished' ? 'finished' : 'active',
         createdAt,
         botSeats: [...botSeats],
@@ -351,6 +474,8 @@ function buildSession(
         playerCount: playerNames.length,
         playerNames: [...playerNames],
         botSeats: [...botSeats],
+        // `awaitingExtension` is a game waiting on its table, not a game that is over — so it maps
+        // to 'active' and `server/index.ts` resumes it on a restart like any other (Gitea#11).
         status: game.state.status === 'finished' ? 'finished' : 'active',
         createdAt,
         lastMoveAt,

src/sim/board-svg.ts

@@ -42,6 +42,12 @@ export type DivisionRoster = {
   actor: number | null;
   /** The player this map is being drawn for. */
   viewer: number;
+  /**
+   * Division nodes to flash — a Mainline card that has just become a different card (Realignment).
+   * Playtest, 2026-09-15: the log said a card had been converted and the map said nothing, so the one
+   * play that changes the Division itself was invisible on the map of it.
+   */
+  flash?: readonly number[];
 };
 
 export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | null): string {
@@ -55,17 +61,41 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
    *
    *   West DP · Mainline · [Limits … Office … Limits] · Mainline · [ … ] · Mainline · East DP
    *
-   * SEATING. Players sit around a table, so the route is laid out the way they do: one row alone,
-   * two rows facing, a horseshoe of three, a square of four. The Division is a LINE and not a loop
-   * — trains enter at one Division Point and leave at the other — so the shape is deliberately left
-   * open, with the two ends drawn as buffer stops facing each other across a marked gap. Closing it
-   * into a ring would promise a connection the rules do not have.
+   * ONE ROW AT EVERY SEAT COUNT (Gitea#18). It used to be laid out the way players sit — two rows
+   * facing, a horseshoe of three, a square of four — and the reasoning for dropping that is at the
+   * layout itself below. The Division is a LINE and not a loop — trains enter at one Division Point
+   * and leave at the other — so the row is deliberately left open, with the two ends drawn as
+   * buffer stops facing outward. Closing it into a ring would promise a connection the rules do
+   * not have.
    *
    * Self-contained on purpose: the replay embeds this by `toString()`, so it may not reach for
    * anything outside its own body.
    */
   const CW = { dp: 118, ml: 152, run: 78 };
-  const CH = 58;
+  /**
+   * TALL ENOUGH FOR TWO REGISTERS OF CHIPS, on every cell so the rail runs level across the row.
+   * Was 58, when a cell held one row of trains.
+   */
+  const CH = 76;
+  /**
+   * EVERY DISTRICT THE SAME WIDTH, sized for four chips two-by-two and NOT for its A/D count.
+   *
+   * Measured over 60 games: one office area holds at most 4 distinct trains, and up to 3 of those
+   * can be crews switching below the Running Track — which do not occupy A/D tracks at all. So a
+   * Whistle Post, with its single A/D track, can still have four trains to show, and sizing the cell
+   * by capacity would overflow it. Sizing by OCCUPANCY is worse still: that is what "The Roster
+   * Pass" fixed, because the cell then resizes as trains come and go and shoves the rest of the map
+   * sideways. A fixed two-by-two block holds the map still all game, upgrades included.
+   */
+  const OFFICE_W = 2 * 54 + 12;
+  /**
+   * THE VERTICAL ANATOMY OF A CELL, so the two chip registers and the rail cannot drift apart.
+   * The rail sits above centre; A/D chips straddle it, and the district register hangs below —
+   * which is where those trains are on the real board (Gitea#18).
+   */
+  const RAIL_Y = 34;
+  const CHIP_Y = RAIL_Y - 10;
+  const BELOW_Y = RAIL_Y + 13;
   const GAP = 6;
   /**
    * ONE FIXED SLOT PER A/D TRACK, so the Office Running Track cell is drawn wide enough to hold
@@ -85,7 +115,6 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
    * this is back to what a buffer stop actually needs.
    */
   const PAD = 22;
-  const SIDE_GAP = 34;
 
   const esc = (t: string): string =>
     String(t).replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' })[c] ?? c);
@@ -108,29 +137,52 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
       region?: number;
       direction?: string;
       stagesLeft?: number;
+      /** Being made up at a Division Point right now, so the map can mark the train you are loading. */
+      beingMadeUp?: boolean;
     }[];
     cap: number | null;
     tip: string;
+    /** Set on a card that has just changed under the players' feet — drawn with a brief pulse. */
+    flash?: boolean;
     /** Which SEAT's district this cell belongs to, or null for Mainline and Division Points. */
     seat: number | null;
     /** Set on an Office cell when a roster was supplied: whose district this is. */
     owner?: { name: string; isTurn: boolean; isYou: boolean } | null;
+    /**
+     * Office cells only: trains in the district that are NOT holding an A/D track — a crew switching
+     * below the Running Track, or a train standing on it away from the Office. Drawn in a second
+     * register under the rail (Gitea#18).
+     */
+    below?: Cell['trains'];
+    /**
+     * Office cells only: a Red Flag standing at this Office's Limits, and which approach it guards
+     * (#94). A token set out ON the board that holds the next train arriving from that side, so it
+     * is drawn like the other things standing on the map rather than left to the log.
+     */
+    redFlag?: string | null;
     /** Mainline cards only: §2.1 divides one into two regions. 0 elsewhere — no bars are drawn. */
     regions: number;
+    /**
+     * Which way a Heavy Grade climbs, or null on every other card. Drawn as a wedge, because the
+     * tooltip said "climbs east" and the card itself showed nothing — so the one card whose
+     * orientation the PLAYER chooses was the one card you had to hover to read (Jesse, 2026-08-30).
+     */
+    gradeUp?: string | null;
     w: number;
     x: number;
     y: number;
   };
   const cells: Cell[] = [];
-  const sides: number[][] = [];
-  let side: number[] = [];
 
   const push = (c: Omit<Cell, 'x' | 'y'>): void => {
-    side.push(cells.length);
     cells.push({ ...c, x: 0, y: 0 });
   };
 
+  // The node's own index, so a cell can be matched against `roster.flash`. `continue` below skips the
+  // rest of the body, never this.
+  let nodeIndex = -1;
   for (const n of nodes) {
+    nodeIndex++;
     if (n.kind === 'office') {
       const cap = n.capacity;
       const ad = n.trains.flat();
@@ -152,47 +204,61 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
           }
         : null;
 
-      for (const rc of n.running ?? []) {
-        const isOffice = rc.kind === 'office';
-        const adLabel = cap === null ? '' : `A/D ${ad.length}/${cap}`;
-        push({
-          kind: 'run',
-          label: isOffice && owner ? owner.name : rc.label,
-          owner: isOffice ? owner : null,
-          // With an owner on the headline the tier would otherwise vanish, so it joins the A/D
-          // count on the line below.
-          sub: isOffice ? (owner ? [rc.label, adLabel].filter(Boolean).join(' · ') : adLabel) : '',
-          /**
-           * A train standing at the Office occupies an A/D track, which is where it is — but it is
-           * ALSO standing on the Office grid card, so it arrives here in both lists and used to be
-           * drawn twice. Reported as two T10 chips on one Office.
-           */
-          trains: isOffice
-            ? [...rc.trains, ...ad.filter((t) => !rc.trains.some((r) => r.label === t.label))]
-            : rc.trains,
-          cap: isOffice ? cap : null,
-          tip: owner && isOffice
-            ? `${owner.name}'s ${rc.label}` +
-              (owner.isYou ? ' — this is your railroad' : '') +
-              // "their move" is wrong when the reader is the one being waited on.
-              (owner.isTurn ? (owner.isYou ? ' — it is your move' : ' — it is their move') : '')
-            : `${rc.label} — ${rc.kind === 'limits' ? 'the end of this district; the Running Track runs between the Limits' : 'Running Track'}`,
-          seat: n.seat ?? null,
-          // No regions inside a district: a crew moves by Moves there, not by Stages, so it
-          // occupies a card outright rather than a part of one.
-          regions: 0,
-          w: isOffice && cap !== null ? Math.max(CW.run, cap * CHIP_W + 12) : CW.run,
-        });
+      /**
+       * ONE CELL PER DISTRICT — NO OFFICE-AREA DETAIL ON THIS MAP (Gitea#18).
+       *
+       * An Office used to expand into its whole Running Track, Limits to Limits, so this map carried
+       * every straight, turnout, facility and Limits sign of every district. Two things were wrong
+       * with that. It is the OFFICE map's job, and it draws all of it properly, with the rails; and
+       * it made the Division map grow sideways as districts were built, shoving everything east of a
+       * district along every time somebody laid a card.
+       *
+       * TRAINS STAY. "Trains within the office area should definitely be represented on the division
+       * map" — at a glance the number and which way it is pointing, and the consist on the tooltip.
+       * They are split into two registers, because a train holding an A/D track and a crew switching
+       * in the district are not the same thing: A/D occupancy is a hard capacity that causes
+       * collisions, switching is not. The split is drawn as POSITION rather than colour — A/D on the
+       * rail, the rest below it — which is where those trains actually are.
+       */
+      const seen = new Set(ad.map((t) => t.label));
+      const below: typeof ad = [];
+      for (const t of [...(n.running ?? []).flatMap((rc) => rc.trains), ...(n.switching ?? [])]) {
+        if (seen.has(t.label)) continue;
+        seen.add(t.label);
+        below.push(t);
       }
-      // A crew below the Running Track has no position ON it, so it is reported against the
-      // district rather than drawn somewhere it is not.
-      const below = n.switching ?? [];
-      if (below.length > 0) {
-        const last = cells[cells.length - 1];
-        if (last) last.sub = `${below.length} switching below`;
-      }
-      sides.push(side);
-      side = [];
+      const adLabel = cap === null ? '' : `A/D ${ad.length}/${cap}`;
+      push({
+        kind: 'run',
+        label: owner ? owner.name : n.label,
+        owner,
+        sub: [owner ? n.label : '', adLabel, below.length > 0 ? `${below.length} switching` : '']
+          .filter(Boolean)
+          .join(' \u00b7 '),
+        trains: ad,
+        below,
+        cap,
+        tip:
+          (owner ? `${owner.name}'s ${n.label}` : n.label) +
+          (owner?.isYou ? ' — this is your railroad' : '') +
+          // "their move" is wrong when the reader is the one being waited on.
+          (owner?.isTurn ? (owner.isYou ? ' — it is your move' : ' — it is their move') : '') +
+          // #94 — first, and in full, because it is the one thing here that CHANGES what a train
+          // may do. Everything below it describes the cell; this describes a rule in force.
+          (n.redFlag === 'east' || n.redFlag === 'west'
+            ? `\n\nRED FLAG set out at the ${n.redFlag === 'east' ? 'East' : 'West'} Limits — the ` +
+              `next train arriving from the ${n.redFlag} is held short, and the flag is spent doing it.`
+            : '') +
+          `\n\nThe district itself is drawn on the Office map — this cell is the whole of it, with the ` +
+          `trains standing in it: those holding an A/D track on the rail, and any crew switching in ` +
+          `the district below it.`,
+        seat: n.seat ?? null,
+        redFlag: n.redFlag ?? null,
+        // No regions in a district: a crew moves by Moves there, not by Stages, so it occupies a
+        // card outright rather than a part of one.
+        regions: 0,
+        w: OFFICE_W,
+      });
       continue;
     }
     const dp = n.kind === 'dp';
@@ -209,6 +275,7 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
     push({
       kind: dp ? 'dp' : 'ml',
       label: n.label,
+      ...(roster?.flash?.includes(nodeIndex) ? { flash: true } : {}),
       sub: n.capacity === null
         ? 'no limit — trains queue'
         : [free, inYard.length > 0 ? `${inYard.length} in the yard` : ''].filter(Boolean).join(' · '),
@@ -226,61 +293,35 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
       seat: null,
       // A Division Point is one region — the queue trains enter and leave the Division through.
       regions: dp ? 1 : (n.regions ?? 0),
+      gradeUp: dp ? null : (n.gradeUp ?? null),
       w: dp ? CW.dp : CW.ml,
     });
   }
-  if (side.length > 0) sides.push(side);
 
-  // Each player's side carries their district and the Mainline card leading into it; whatever is
-  // left over (the last Mainline and the East DP) joins the final side.
-  const seats = Math.max(1, Math.min(4, nodes.filter((n) => n.kind === 'office').length));
-  const lanes: number[][] = [];
-  for (let i = 0; i < seats; i++) lanes.push([]);
-  sides.forEach((grp, i) => {
-    const target = Math.min(i, seats - 1);
-    for (const idx of grp) lanes[target]!.push(idx);
-  });
-
-  // -- lay the sides out around the table -------------------------------------------------------
-  // top → right → bottom (reversed) → left (reversed), which gives a row, two facing rows, a
-  // horseshoe open to the west, and a square broken at the same place.
-  const dir: ('top' | 'right' | 'bottom' | 'left')[] =
-    seats === 1 ? ['top'] : seats === 2 ? ['top', 'bottom'] : seats === 3 ? ['top', 'right', 'bottom'] : ['top', 'right', 'bottom', 'left'];
-
-  const runLen = (idxs: number[]): number =>
-    idxs.reduce((n, i) => n + cells[i]!.w + GAP, -GAP);
-  const widest = Math.max(...lanes.map((l) => runLen(l)), 200);
-  const tall = lanes.length > 1 ? Math.max(...lanes.map((l) => l.length), 1) * (CH + GAP) : CH;
-
-  const vertCount = dir.filter((d) => d === 'right' || d === 'left').length;
-  const boardW = PAD * 2 + widest + (vertCount > 0 ? CW.run + SIDE_GAP : 0);
-  const boardH = PAD * 2 + (dir.includes('bottom') ? CH * 2 + SIDE_GAP + (vertCount ? tall : 0) : CH) + 30;
-
-  lanes.forEach((idxs, i) => {
-    const d = dir[i]!;
-    if (d === 'top' || d === 'bottom') {
-      const y = d === 'top' ? PAD : boardH - PAD - CH - 22;
-      const order = d === 'bottom' ? [...idxs].reverse() : idxs;
-      let x = PAD;
-      for (const idx of order) {
-        const c = cells[idx]!;
-        c.x = x;
-        c.y = y;
-        x += c.w + GAP;
-      }
-    } else {
-      const x = d === 'right' ? boardW - PAD - CW.run : PAD;
-      const order = d === 'left' ? [...idxs].reverse() : idxs;
-      let y = PAD + CH + SIDE_GAP;
-      for (const idx of order) {
-        const c = cells[idx]!;
-        c.x = x;
-        c.y = y;
-        c.w = CW.run;
-        y += CH + GAP;
-      }
-    }
-  });
+  /**
+   * ONE ROW, WEST TO EAST (Gitea#18). The West Division Point is at the far left, the East at the
+   * far right, and nothing wraps.
+   *
+   * IT USED TO BE LAID OUT AROUND A TABLE — one row for a single seat, two facing rows for two, a
+   * horseshoe for three, a square for four — on the reasoning that players sit around a table so the
+   * route should too. That cost more than it bought, and three separate reports came out of it: the
+   * buffer stops pointed the wrong way once the route turned a corner, and, the one that decided it,
+   * **east stopped being to the right**. A player's east could be drawn south, west or north
+   * depending on which lane their district landed in, on a map whose whole job is saying which way
+   * a train is going.
+   *
+   * A row is wider than a square — roughly 1,580px at four players against 842 — and that is
+   * accepted: the map scrolls and zooms, and being able to rely on east meaning right is worth the
+   * scroll.
+   */
+  let x = PAD;
+  for (const c of cells) {
+    c.x = x;
+    c.y = PAD;
+    x += c.w + GAP;
+  }
+  const boardW = x - GAP + PAD;
+  const boardH = PAD * 2 + CH + 30;
 
   // -- draw -------------------------------------------------------------------------------------
   const rail = (x1: number, y: number, x2: number): string => {
@@ -295,20 +336,29 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
     return o;
   };
 
-  // The same rail turned through ninety degrees, for the sides of the table.
-  const railV = (x: number, y1: number, y2: number): string => {
-    let o =
-      `<line class="bs-rail" x1="${x - 2.5}" y1="${y1}" x2="${x - 2.5}" y2="${y2}"/>` +
-      `<line class="bs-rail" x1="${x + 2.5}" y1="${y1}" x2="${x + 2.5}" y2="${y2}"/>`;
-    const n = Math.max(2, Math.floor(Math.abs(y2 - y1) / 9));
-    for (let i = 0; i <= n; i++) {
-      const ty = y1 + ((y2 - y1) * i) / n;
-      o += `<line class="bs-tie" x1="${x - 4.5}" y1="${ty}" x2="${x + 4.5}" y2="${ty}"/>`;
-    }
-    return o;
-  };
-
-  let out = `<svg class="bs bs-div" viewBox="0 0 ${Math.ceil(boardW)} ${Math.ceil(boardH)}" preserveAspectRatio="xMinYMin meet">`;
+  /**
+   * DRAWN AT ITS OWN SIZE, SO IT SCROLLS RATHER THAN SHRINKING (Gitea#18).
+   *
+   * An SVG has a viewBox and a drawn size, and the browser scales one to the other. `.bs` is
+   * `width:100%`, so the map is drawn at whatever the panel is wide — which was harmless while the
+   * Division was 842px and wrapped around a table, and is not now that a single row is 1,580px. At
+   * that width in an 800px panel every label renders at half size, on the map that needs reading
+   * most. Setting the width to the viewBox width makes one unit one pixel, and the containers
+   * already scroll (`#division`, `#vdivision`).
+   *
+   * THE PLAYABLE PAGE DOES NOT NEED THIS — `applyZoom` (`main.ts`) sets exactly the same width from
+   * the same viewBox after every render, and overrides this when the zoom is not 100%. THE REPLAYS
+   * DO: neither `replays.ts` nor the standalone `replay.ts` calls it, so without this they get the
+   * `width:100%` shrink. It is inline rather than in `BOARD_CSS` because only this function knows
+   * how wide the row came out.
+   *
+   * `flex:none` because `#division` is a flex container and a flex item may be shrunk below an
+   * explicit width; there is no point pinning it and then letting the panel squeeze it anyway.
+   */
+  let out =
+    `<svg class="bs bs-div" viewBox="0 0 ${Math.ceil(boardW)} ${Math.ceil(boardH)}" ` +
+    `style="width:${Math.ceil(boardW)}px;flex:none" ` +
+    `preserveAspectRatio="xMinYMin meet">`;
 
   // The joins between consecutive cells, drawn as rail so a connection is rail meeting rail. A join
   // that crosses from one player's side to the next is drawn heavier and labelled: that boundary is
@@ -316,28 +366,12 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
   for (let i = 0; i + 1 < cells.length; i++) {
     const a = cells[i]!;
     const b = cells[i + 1]!;
-    const sameRow = Math.abs(a.y - b.y) < 1;
-    const sameCol = Math.abs(a.x - b.x) < 1;
-    if (sameRow && b.x > a.x) out += rail(a.x + a.w, a.y + CH / 2, b.x);
-    else if (sameRow && b.x < a.x) out += rail(b.x + b.w, a.y + CH / 2, a.x);
-    else if (sameCol) {
-      // Stacked down one side of the table: still one straight run of track, not a turn.
-      const top = Math.min(a.y + CH, b.y + CH);
-      const bot = Math.max(a.y, b.y);
-      out += railV(a.x + a.w / 2, top, bot);
-    } else {
-      // A turn between sides: an elbow, so the route is visibly continuous around the table.
-      const ax = a.x + a.w / 2;
-      const bx = b.x + b.w / 2;
-      const ay = a.y + CH;
-      const by = b.y;
-      out += `<path class="bs-turn" d="M${ax} ${ay} L${ax} ${(ay + by) / 2} L${bx} ${(ay + by) / 2} L${bx} ${by}"/>`;
-    }
+    out += rail(a.x + a.w, a.y + RAIL_Y, b.x);
   }
 
   cells.forEach((c) => {
     const full = c.cap !== null && c.trains.length >= c.cap;
-    out += `<g class="bs-dcell bs-d${c.kind}${full ? ' bs-full' : ''}" data-tip="${esc(c.tip)}">`;
+    out += `<g class="bs-dcell bs-d${c.kind}${full ? ' bs-full' : ''}${c.flash ? ' bs-changed' : ''}" data-tip="${esc(c.tip)}">`;
     out += `<rect x="${c.x}" y="${c.y}" width="${c.w}" height="${CH}" rx="5"/>`;
     /**
      * WHOSE IS IT, IS IT THEIR MOVE, AND IS IT MINE — answered by colour and one suffix rather
@@ -348,15 +382,105 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
     const mark = c.owner ? ` bs-owner${c.owner.isTurn ? ' bs-turn' : ''}${c.owner.isYou ? ' bs-you' : ''}` : '';
     const suffix = c.owner?.isYou ? ' (you)' : '';
     out += `<text class="bs-name${mark}" x="${c.x + 7}" y="${c.y + 14}">${esc(c.label + suffix)}</text>`;
-    out += rail(c.x + 6, c.y + 32, c.x + c.w - 6);
+    out += rail(c.x + 6, c.y + RAIL_Y, c.x + c.w - 6);
     if (c.sub) out += `<text class="bs-cap" x="${c.x + 7}" y="${c.y + CH - 6}">${esc(c.sub)}</text>`;
 
-    // REGIONS. §2.1 divides a Mainline card into two, and §8.2 moves a train one region per Stage.
-    // The bars are the card's DISTANCE and never vary; what varies is how fast a train covers them,
-    // so a 60 card is crossed in one Stage and a slow train on a 30 takes three.
+    // REGIONS. A Mainline card is 1 to 3 of them (Gitea#3) and a train advances one per Stage. The
+    // bars are the card's DISTANCE and never vary; where a train STARTS is what does.
     const RW = c.regions > 0 ? (c.w - 12) / c.regions : 0;
     for (let r = 0; r < c.regions; r++) {
-      out += `<line class="bs-region" x1="${c.x + 6 + RW * r}" y1="${c.y + 20}" x2="${c.x + 6 + RW * r}" y2="${c.y + 44}"/>`;
+      out += `<line class="bs-region" x1="${c.x + 6 + RW * r}" y1="${c.y + RAIL_Y - 14}" x2="${c.x + 6 + RW * r}" y2="${c.y + RAIL_Y + 10}"/>`;
+    }
+
+    /**
+     * A RED FLAG STANDING AT THE LIMITS (#94).
+     *
+     * Drawn at the END IT GUARDS — west on the left, east on the right, since east is right on this
+     * map — because which approach it covers is the whole of the information. A flag in the middle
+     * of the cell would say a flag is out and leave the reader to hover for the half that decides
+     * whether to run a train.
+     *
+     * A staff with a pennant, at rail height, standing clear of the chips: it is beside the rail,
+     * which is where a flag is. Red is otherwise unused on this map (`bs-full` tints a cell, it does
+     * not draw), so the mark does not compete with anything for meaning.
+     */
+    if (c.redFlag === 'east' || c.redFlag === 'west') {
+      const west = c.redFlag === 'west';
+      const fx = west ? c.x + 9 : c.x + c.w - 9;
+      const top = c.y + RAIL_Y - 22;
+      const dir = west ? 1 : -1;
+      out += `<g class="bs-flag">`;
+      out += `<line x1="${fx}" y1="${top}" x2="${fx}" y2="${c.y + RAIL_Y + 4}"/>`;
+      // The pennant flies INTO the cell, so it can never overhang the card edge at either end.
+      out += `<polygon points="${fx},${top} ${fx + dir * 13},${top + 5} ${fx},${top + 10}"/>`;
+      out += `</g>`;
+    }
+
+    /**
+     * WHICH WAY A HEAVY GRADE CLIMBS, drawn rather than only said.
+     *
+     * The tooltip has said "climbs east" since the Frame carried `gradeUp`, and the card showed
+     * nothing — so the one Mainline card whose orientation the PLAYER sets, and the one where a
+     * Helpers or Brakeman modifier means opposite things at opposite ends, was the one you had to
+     * hover to read (Jesse, 2026-08-30).
+     *
+     * A wedge rising toward the climb, with an arrow up its slope. Two cues rather than one: the
+     * wedge alone asks the reader to judge which end is taller, which at eleven pixels of rise is a
+     * comparison rather than a glance. Bottom-right, clear of the left-aligned capacity line and
+     * below the region bars, so it never lands under a train chip.
+     *
+     * `east` is RIGHT on this map and always has been (Gitea#18) — that is what makes a wedge
+     * readable without a compass, and it is why the row layout is worth its width.
+     */
+    if (c.gradeUp === 'east' || c.gradeUp === 'west') {
+      const s = c.gradeUp === 'east' ? 1 : -1;
+      const GW = 58;
+      const RISE = 24;
+      const gx1 = c.x + c.w - 9 - GW;
+      const gx2 = c.x + c.w - 9;
+      const yb = c.y + CH - 6;
+      const peakX = s === 1 ? gx2 : gx1;
+      out += `<polygon class="bs-grade" points="${gx1},${yb} ${gx2},${yb} ${peakX},${yb - RISE}"/>`;
+
+      /**
+       * THE ARROW LIES ALONG THE WEDGE'S OWN SLOPE, CENTRED IN IT (Jesse, 2026-08-30).
+       *
+       * Parallel to the hypotenuse is the shape that fits: the perpendicular gap to the slope is
+       * then CONSTANT along the whole arrow, instead of closing at one end the way a steeper line
+       * does. The earlier 30° pass had to be tucked into the fat half to survive, because 30° is
+       * steeper than this wedge climbs — at 58×24 the slope is 22.5°, and the arrow simply lies on
+       * it.
+       *
+       * Centred on the TRIANGLE'S CENTROID (2/3 along the base, 1/3 up), which is the balance point
+       * of the form rather than of its bounding box — centring on the box would push the arrow into
+       * the thin corner where there is no height for it.
+       *
+       * The wedge grew 50×22 → 58×24 to pay for that: the centroid sits only ~7px from the
+       * hypotenuse, so a centred arrow has less room than an off-centre one and needs a bigger form
+       * to keep it. Sizes are the best fit found by search, clearing every edge by 2.88px;
+       * `web.test.ts` re-derives it and fails under 2px.
+       *
+       * Worked in the wedge's own frame — `u` along the base from the thin corner, `h` up from it —
+       * so a westward climb is one sign on `u` rather than a second set of coordinates.
+       */
+      const L = 20;
+      const HL = 6;
+      const HW = 3.5;
+      const T = 1.4;
+      const A = Math.atan2(RISE, GW);
+      const cos = Math.cos(A);
+      const sin = Math.sin(A);
+      const cu = (2 * GW) / 3;
+      const ch = RISE / 3;
+      const pt = (lx: number, ly: number): string => {
+        const u = cu + lx * cos - ly * sin;
+        const h = ch + lx * sin + ly * cos;
+        return `${s === 1 ? gx1 + u : gx2 - u},${yb - h}`;
+      };
+      const H = L / 2;
+      out +=
+        `<polygon class="bs-gradeup" points="${pt(-H, -T)} ${pt(H - HL, -T)} ${pt(H - HL, -HW)} ` +
+        `${pt(H, 0)} ${pt(H - HL, HW)} ${pt(H - HL, T)} ${pt(-H, T)}"/>`;
     }
 
     /**
@@ -371,53 +495,101 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
      * So this keeps the two things the Division map is actually for — where a train is and which way
      * it is going — and leaves the cars to the tooltip and to the district.
      */
-    c.trains.forEach((t, k) => {
+    /**
+     * A TRAIN IS A CHIP — its number, which way it points, and how many cars.
+     *
+     * It was drawn as a full consist here, matching the Office Area card, and reported as too large
+     * and hard to read. The Office card is where a consist is worth drawing, because that is where
+     * the switching decisions are made and where there is room to read it. So this keeps the two
+     * things the Division map is for — where a train is and which way it is going — and leaves the
+     * cars to the tooltip and to the district.
+     */
+    /**
+     * THE REGION NUMBER IS A PLACE ON THE MAP, NOT A DISTANCE RUN (Gitea#22).
+     *
+     * `view.ts` mirrors a westbound train before it gets here, so this counts boxes west to east
+     * for every train regardless of which way it is going — and the tooltip says so, because
+     * "region 2 of 2" beside "2 Stages still to run" reads as a contradiction otherwise. It is the
+     * second box from the west end; a westbound train in it has its whole crossing ahead of it.
+     */
+    const chip = (t: NonNullable<Cell['trains']>[number], tx: number, ty: number, w: number): void => {
       const cars = t.cars ?? [];
       const arrow = t.facing === 'w' ? '\u25c0' : '\u25b6';
       const loaded = cars.filter((x) => /^loaded/.test(x) || /caboose/.test(x)).length;
       const label = cars.length === 0 ? `${t.label} ${arrow}` : `${t.label} ${arrow}${cars.length}`;
-
-      /**
-       * THE OFFICE RUNNING CELL GETS FIXED SLOTS, ONE PER A/D TRACK — never a centre spread.
-       *
-       * Centred spreading pushes its outer chips outward as MORE trains arrive, and the cell was
-       * sized for the cards it holds, not for its trains — so two chips at a Station used to land at
-       * x 215–267 and 271–316 inside a cell spanning only 230–308, spilling onto the Limits cards
-       * either side. A fixed slot per A/D track cannot overflow the cell at any occupancy, because
-       * the cell was sized for exactly that many slots (see `CHIP_W` above).
-       */
-      const isOfficeRun = c.kind === 'run' && c.cap !== null && c.cap > 0;
-      const slotW = isOfficeRun ? (c.w - 12) / c.cap! : 0;
-      const w = isOfficeRun ? Math.min(slotW - 4, label.length * 6.6 + 12) : Math.min(c.w - 8, label.length * 6.6 + 12);
-      // A train on a Mainline card sits in ITS region; anywhere else it just sits on the card.
+      // THE TRAIN THE MAKE-UP PANEL IS TALKING ABOUT. Amber, because that is what the rest of the
+      // page uses for "this is the thing you are acting on" (Jesse, playtest 2026-09-16).
+      const building = t.beingMadeUp === true;
       const inRegion = c.regions > 1 && typeof t.region === 'number';
-      const tx = isOfficeRun
-        ? c.x + 6 + slotW * (k + 0.5)
-        : (inRegion ? c.x + 6 + RW * (t.region ?? 0) + RW / 2 : c.x + c.w / 2) +
-          (inRegion ? 0 : (k - (c.trains.length - 1) / 2) * (w + 4));
       const dir = t.direction === 'west' ? ' \u25c0 west' : t.direction === 'east' ? ' east \u25b6' : '';
       const stages =
         typeof t.stagesLeft === 'number'
-          ? ` \u00b7 ${t.stagesLeft} Stage${t.stagesLeft === 1 ? '' : 's'} still to run across this card` +
-            ' (Stages, not regions: a card is two regions of fixed distance, and how many Stages a' +
-            ' train takes over them depends on the card speed and the train)'
+          ? ` \u00b7 ${t.stagesLeft} Stage${t.stagesLeft === 1 ? '' : 's'} still to run across this card`
           : '';
-      out += `<g class="bs-train" data-tip="${esc(t.label)} \u2014 carrying ${esc(cars.join(', ') || 'no cars')}${
+      out += `<g class="bs-train${building ? ' bs-building' : ''}" data-tip="${esc(t.label)}${
+        building ? ' \u2014 BEING MADE UP NOW: add cars from the Division Yard' : ''
+      } \u2014 carrying ${esc(cars.join(', ') || 'no cars')}${
         cars.length ? ` (${loaded} loaded)` : ''
-      }${inRegion ? ` \u00b7 region ${(t.region ?? 0) + 1} of ${c.regions}${dir}` : ''}${esc(stages)}${
+      }${inRegion ? ` \u00b7 region ${(t.region ?? 0) + 1} of ${c.regions}, counted west to east${dir}` : ''}${esc(stages)}${
         // What the card prints. A train on the Mainline is exactly where "why did that leave without
         // me?" gets asked, and EXPEDITED is the answer more often than not.
         t.what ? `\n\n${esc(t.what)}` : ''
       }">` +
-        `<rect x="${tx - w / 2}" y="${c.y + 22}" width="${w}" height="19" rx="3"/>` +
-        `<text class="bs-tlab" x="${tx}" y="${c.y + 35}" text-anchor="middle">${esc(label)}</text>`;
+        `<rect x="${tx - w / 2}" y="${ty}" width="${w}" height="19" rx="3"/>` +
+        `<text class="bs-tlab" x="${tx}" y="${ty + 13}" text-anchor="middle">${esc(label)}</text>`;
       out += '</g>';
+    };
+
+    const textW = (t: NonNullable<Cell['trains']>[number]): number =>
+      (`${t.label} \u25b6${(t.cars ?? []).length || ''}`).length * 6.6 + 12;
+
+    /**
+     * TWO CHIPS TO A REGISTER ON A DISTRICT, in fixed slots — never a centre spread.
+     *
+     * Centred spreading pushes its outer chips outward as more trains arrive, which is how two chips
+     * at a Station once landed outside the cell that held them. Fixed slots cannot overflow, because
+     * the cell was sized for exactly that many (`OFFICE_W`).
+     */
+    const isDistrict = c.kind === 'run';
+    const SLOTS = 2;
+    const slotW = (c.w - 12) / SLOTS;
+    c.trains.forEach((t, k) => {
+      if (isDistrict) {
+        // Row-major within the A/D register: two across, then wrap under. A district can hold four
+        // trains and only two fit across it.
+        const col = k % SLOTS;
+        const row = Math.floor(k / SLOTS);
+        chip(t, c.x + 6 + slotW * (col + 0.5), c.y + CHIP_Y + row * 21, Math.min(slotW - 4, textW(t)));
+        return;
+      }
+      // A train on a Mainline card sits in ITS region; anywhere else it just sits on the card.
+      const inRegion = c.regions > 1 && typeof t.region === 'number';
+      const w = Math.min(c.w - 8, textW(t));
+      const tx = (inRegion ? c.x + 6 + RW * (t.region ?? 0) + RW / 2 : c.x + c.w / 2) +
+        (inRegion ? 0 : (k - (c.trains.length - 1) / 2) * (w + 4));
+      chip(t, tx, c.y + CHIP_Y, w);
     });
+
+    /**
+     * THE SECOND REGISTER, under the rail: trains in the district that hold no A/D track (Gitea#18).
+     *
+     * A crew switching below the Running Track and a train standing at an A/D track are different
+     * things — A/D occupancy is a hard capacity that causes collisions, switching is not — and the
+     * difference is drawn as POSITION rather than as a colour to learn, because below the rail is
+     * where those trains actually are.
+     */
+    (c.below ?? []).forEach((t, k) => {
+      const col = k % SLOTS;
+      const row = Math.floor(k / SLOTS);
+      chip(t, c.x + 6 + slotW * (col + 0.5), c.y + BELOW_Y + row * 21, Math.min(slotW - 4, textW(t)));
+    });
+
     out += '</g>';
   });
 
-  // THE ENDS. The route stops at both Division Points; drawing buffer stops and naming the gap is
-  // what stops a seated layout being read as a loop.
+  // THE ENDS. The route stops at both Division Points, and the buffer stops say so — a Division is
+  // a LINE, not a loop. With a single row (Gitea#18) they simply face outward at the two ends, west
+  // on the left and east on the right, which is the bug reported twice against the wrapped layout.
   const first = cells[0];
   const last = cells[cells.length - 1];
   /**
@@ -517,7 +689,17 @@ export function officeSvg(
   const c0 = Math.min(...cols);
   const c1 = Math.max(...cols);
   const width = (c1 - c0 + 1) * (W + PAD);
-  const height = (r1 - r0 + 1) * (H + PAD) + 4;
+  /**
+   * A BAND BENEATH THE BOTTOM ROW FOR THE LIMITS LABELS, and only when there are labels to put in it.
+   *
+   * The bottom card's lower edge lands at `height - 7`, and the label's baseline was `height - 4` —
+   * so its 8px glyphs spanned `height - 12` to `height - 4` and the card's own border ran straight
+   * through the middle of the word (Jesse, playtest 2026-09-16: *"the text is split by the bottom
+   * border of the limits card… it should be printed directly beneath the card"*). Raising the text
+   * instead would have pushed it onto the card, over the rails; the room has to be made below.
+   */
+  const limitBand = limits ? 14 : 0;
+  const height = (r1 - r0 + 1) * (H + PAD) + 4 + limitBand;
 
   // Screen position of a card. Rows count DOWN from the top row, so the Running Track sits highest
   // and the district hangs beneath it, as the rules describe it.
@@ -946,9 +1128,18 @@ export function officeSvg(
       // card, the old y = H-46 baseline printed the label straight along the rail itself.
       // Hover text per enhancement, from the card catalogue — an Interlocking used to be a bare word
       // on the card with nothing to say what it did, or that it does not do it yet.
+      // A SPENT dispatch device is struck through (#101). Telegraph/Telephone/Radio are "once a
+      // day", and the label said the same thing before and after the Superintendent spent one — so
+      // the card advertised a +12 that was not there. Per-`tspan` rather than per-`text` so the
+      // names still read as one row, and `?? []` because `piecePreview` builds a cell literal by
+      // hand and has no flags.
+      const spentFlags = cell.enhancementsSpent ?? [];
+      const names = cell.enhancements
+        .map((n, i) => (spentFlags[i] ? `<tspan class="bs-enh-spent">${esc(n)}</tspan>` : esc(n)))
+        .join(' · ');
       out += `<text class="bs-enh" x="6" y="26" data-tip="${esc(
         (cell.enhancementsWhat ?? []).join(' · '),
-      )}">${esc(cell.enhancements.join(' · '))}</text>`;
+      )}">${names}</text>`;
     }
     if (selectedTrain) {
       /**
@@ -1044,7 +1235,9 @@ export function officeSvg(
   if (limits) {
     const edge = (x: number, side: string): string =>
       `<line class="bs-limitline" x1="${x}" y1="0" x2="${x}" y2="${height}"/>` +
-      `<text class="bs-limitlab" x="${x + (side === 'w' ? 4 : -4)}" y="${height - 4}" ` +
+      // Baseline inside the band below the cards: the glyphs run from `height - 19` to `height - 11`
+      // and the bottom row's edge is at `height - 21`, so the whole word clears the card border.
+      `<text class="bs-limitlab" x="${x + (side === 'w' ? 4 : -4)}" y="${height - 11}" ` +
       `text-anchor="${side === 'w' ? 'start' : 'end'}">LIMITS</text>`;
     out += edge(px(limits.west) - PAD / 2, 'w') + edge(px(limits.east) + W + PAD / 2, 'e');
   }
@@ -1087,9 +1280,29 @@ export const BOARD_CSS = `
    and leave at the other, and a seated layout must not be read as a ring. */
 .bs-stop line{stroke:#e0a060;stroke-width:2.6;stroke-linecap:round}
 .bs-end{fill:#e0a060;font:10px ui-monospace,monospace;letter-spacing:.03em}
-/* The vertical bars a Mainline card is divided into (§2.1). Drawn faint: they are the ruler the
-   train is measured against, not something to look at instead of the train. */
-.bs-region{stroke:#4a5361;stroke-width:1.2;stroke-dasharray:3 3}
+/* A card that has just BECOME a different card (Realignment). The same amber the rest of the page
+   spends on "it is happening here", pulsing only while the step that did it is on screen — so the
+   change is seen on the map rather than only read in the log. */
+.bs-dcell.bs-changed rect{stroke:#e0a060;stroke-width:2.4;animation:bs-changed-pulse 1.1s ease-in-out infinite}
+@keyframes bs-changed-pulse{0%,100%{stroke-opacity:1}50%{stroke-opacity:.35}}
+@media (prefers-reduced-motion: reduce){.bs-dcell.bs-changed rect{animation:none}}
+/* The vertical bars a Mainline card is divided into (§2.1). They are the ruler the train is measured
+   against, not something to look at instead of the train — but they were drawn so faint they could
+   not be made out at all (Jesse, playtest 2026-09-16: "the dividing line is barely visible"). A
+   ruler you cannot read is not restraint, so this is lifted to the tie colour and given a longer
+   dash: still quieter than the rail, and now actually there. */
+.bs-region{stroke:#98a3b2;stroke-width:1.6;stroke-dasharray:4 2}
+/* #94 — the one red mark on the Division map, so it reads as a stop rather than as decoration. */
+.bs-flag line{stroke:#9aa3b0;stroke-width:1.6}
+.bs-flag polygon{fill:#d2453f;stroke:#7d211d;stroke-width:0.8}
+/* THE HEAVY GRADE WEDGE. Terrain, so it is coloured as terrain rather than as a warning.
+   SOLID BROWN, fill and border the same (Jesse, 2026-08-30) — the first pass paired a desaturated
+   fill with an amber arrow and the pair read reddish, which on a map that spends amber on "it is
+   happening here" made a fixed piece of landscape look like a live alert. One flat brown recedes
+   into scenery; the arrow is bone so the DIRECTION, which is the fact being reported, is the part
+   that carries. */
+.bs-grade{fill:#6b5334;stroke:#6b5334;stroke-width:1}
+.bs-gradeup{fill:#f2e8d5}
 .bs-slot{fill:none;stroke:#5f6b7a;stroke-width:1.1;stroke-dasharray:3 2}
 .bs-slot.bs-occ{stroke-dasharray:none;stroke-width:1.6}
 /* CAR TYPE BY COLOUR, LOAD STATE BY FILL — the SAME distinction the train tray draws, because they
@@ -1111,6 +1324,10 @@ export const BOARD_CSS = `
 .bs-slot.bs-car-cch.bs-loaded{fill:rgba(90,169,230,.85)}
 .bs-slot.bs-car-cab.bs-loaded{fill:rgba(192,90,90,.85)}
 .bs-train rect{fill:#2f6b3d;stroke:#8fd6a0;stroke-width:1.2}
+/* The train the New Train phase is loading, in the page's action amber, so the make-up panel on the
+   right and the train on the map at the top left are visibly the same subject. */
+.bs-train.bs-building rect{fill:#4a3a1c;stroke:#c8912f;stroke-width:2}
+.bs-train.bs-building .bs-tlab{fill:#f2d49a}
 .bs-crew rect{fill:#8a6d1f;stroke:#e0c060;stroke-width:1.2}
 /* Each car in the train, in the order it is seated. Loaded is solid, empty is hollow, and the
    engine is the one that carries the arrow — which is what makes "reverse" mean something. */
@@ -1157,7 +1374,10 @@ export const BOARD_CSS = `
 .bs-arrow{fill:#5f6b7a;font:10px ui-monospace,monospace}
 .bs-cn{fill:#e6e9ee;font:600 11px ui-monospace,monospace}
 .bs-coord{fill:#5f6b7a;font:9px ui-monospace,monospace}
-.bs-name{fill:#e6e9ee;font:600 11px ui-monospace,monospace}
+/* stroke:none (Gitea#24). A name takes the class \`bs-turn\` while it is that player's move, and \`.bs-turn\` is
+   also the turn ARROW's rule, which strokes its shape 2.4px grey. Declared after it, this keeps that
+   outline off the letters, which it smeared into an unreadable blur. */
+.bs-name{fill:#e6e9ee;stroke:none;font:600 11px ui-monospace,monospace}
 .bs-name.bs-you{fill:#5aa9e6}
 /* Their move — wins over .bs-you when both apply, because whose turn it is changes every few
    seconds and which railroad is yours never does.
@@ -1173,6 +1393,7 @@ export const BOARD_CSS = `
 .bs-mod{font:10px ui-monospace,monospace}
 text.bs-mod{fill:#c8a04a}
 .bs-enh{fill:#7fb0e6;font:9px ui-monospace,monospace}
+.bs-enh-spent{fill:#5b6b7d;text-decoration:line-through}
 .bs-rowlab{fill:#5f6b7a;font:600 9px ui-monospace,monospace;letter-spacing:.1em}
 /* THE EDGE OF THE DISTRICT. Deliberately quiet — it is a boundary, not an action — and dashed, so it
    reads as a line on the table rather than as rail. Nothing is laid outside it (§2.1). */

src/sim/bot.ts

@@ -22,6 +22,9 @@
 import {
   applyIntent,
   areaOf,
+  extendLimitsIfNeeded,
+  isLockedOut,
+  protoCard,
   canAdvanceLoad,
   destinationsFor,
   facilityCarTypes,
@@ -29,14 +32,15 @@ import {
   ownCutFor,
 } from '../engine/apply.ts';
 import { MAX_CONSIST, nextOfficeTier, officeProfile } from '../engine/content.ts';
-import type { CarType, Hand, TrackGeometry } from '../engine/content.ts';
+import type { CarType, FreightKind, Hand, TrackGeometry } from '../engine/content.ts';
 import type { GameEvent } from '../engine/events.ts';
 import type { Intent } from '../engine/intents.ts';
 import { legalActions } from '../engine/legal.ts';
-import { connectionsFor, exitsFrom, facilityVariants, hasPort, joins, neighbour, opposite, variantsFor } from '../engine/track.ts';
+import { canPlaceAt, connectionsFor, exitsFrom, facilityVariants, hasPort, joins, neighbour, opposite, variantsFor } from '../engine/track.ts';
 import type { Port } from '../engine/track.ts';
-import { coordKey, turnOf } from '../engine/state.ts';
+import { actingPlayer, coordKey, turnOf } from '../engine/state.ts';
 import type { Facility, GameState, GridCoord, OfficeArea, PlayerIndex, RollingStock, TrackCard } from '../engine/state.ts';
+import { planSwitchingTurn, switchFingerprint } from './switch-planner.ts';
 
 export type BotPolicy = {
   name: string;
@@ -106,7 +110,8 @@ function because(reason: string, intent: Intent): Intent {
  * Every flag here turns something OFF. That is the opposite of how this started — the tweaks were
  * candidates to switch on — and it is the right shape once a candidate has been adopted: what a
  * measured heuristic needs afterwards is a way to ask "is this still worth it?" when the deck or
- * the rules move under it. Both of these were worth about +1.5 revenue together when adopted; if a
+ * the rules move under it. The first two were worth about +1.5 revenue together when adopted, and
+ * planning the switching turn (`noPlanSwitching`) +2.89 on its own; if a
  * rebalance changes the economy, that is a claim to re-test rather than to assume.
  *
  * The candidates that did NOT survive are gone rather than left switched off: preferring coaches at
@@ -121,9 +126,78 @@ export type BotTweaks = {
   noTrainCap?: boolean;
   /** Draw whenever nothing is urgent, as the bot did before it preferred operating. */
   noOperateFirst?: boolean;
-
+  /**
+   * Choose switching Moves one at a time from the rule ladder, as the bot did before it planned the
+   * whole turn (`switch-planner.ts`). Measured at adoption, 2026-09-14: planning was worth
+   * +2.89 ± 0.18 revenue a game (t = 15.79) over 1600 paired seeds, 733 better against 21 worse.
+   */
+  noPlanSwitching?: boolean;
+  /**
+   * Take a face-up train or industry card whether or not it could be played, as the bot did before
+   * 2026-09-14. It then took 20.1 trains and 11.9 industries a game off the Departments and discarded
+   * 20.2 and 11.8, retaking the same card 28.8 times a game. Asking first measured +1.52 ± 0.10
+   * (t = 15.59) over 1600 paired seeds — this ablation was worse on 880 of them and better on 211.
+   */
+  noPlayableTakes?: boolean;
+  /**
+   * Choose where track goes by `bestTrackLay`'s piece rules and the fallback's first legal square, as the
+   * bot did before 2026-09-15, instead of by what the district can DO afterwards (`bestValuedLay`).
+   * Scoring the layout measured +0.118 ± 0.029 (t = 4.14) over 6400 paired seeds, and closed run-arounds
+   * in 22 of 60 districts against 9.
+   */
+  noValueLays?: boolean;
+  /**
+   * Let the New Train phase's fallback take `options[0]`, as the bot did before 2026-09-15. Because
+   * `legalActions` lists `newTrain.secondSection` ahead of the Extra starts, all 26 Second Sections the
+   * bot ran in 60 games were that accident, and 6 of the 20 collisions followed one. Taking a car, a pass
+   * or the Extra's start instead measured +0.32 ± 0.09 (t = 3.64) over 400 paired seeds.
+   */
+  noDeliberateNewTrain?: boolean;
 };
 
+/**
+ * A switching turn planned once and then played a step per decision.
+ *
+ * Keyed by the tweaks object, because that is what one policy owns — the server shares a single
+ * `developerBot` across every bot seat, so the plan inside it is kept per player. Each step is
+ * submitted only while the position still matches the fingerprint the plan expected there; anything
+ * else replans. A switching turn has no randomness, so in practice a plan is made once a turn.
+ */
+type ActivePlan = { steps: Intent[]; keys: string[]; next: number; summary: string };
+const activePlans = new WeakMap<BotTweaks, Map<PlayerIndex, ActivePlan>>();
+
+function plannedSwitch(s: GameState, player: PlayerIndex, options: Intent[], tweaks: BotTweaks): Intent | null {
+  let mine = activePlans.get(tweaks);
+  if (!mine) activePlans.set(tweaks, (mine = new Map()));
+  const here = switchFingerprint(s, player);
+  let active = mine.get(player);
+  if (!active || active.keys[active.next] !== here) {
+    const p = planSwitchingTurn(s, player);
+    active = {
+      steps: p.steps,
+      keys: p.keys,
+      next: 0,
+      summary:
+        `position ${p.rootScore.toFixed(2)} → ${p.score.toFixed(2)} over ${p.expanded} positions` +
+        (p.complete ? '' : ', search budget reached'),
+    };
+    mine.set(player, active);
+  }
+  if (active.next >= active.steps.length) {
+    mine.delete(player);
+    const end = options.find((i) => i.type === 'switch.end');
+    return end ? because(`planned switching turn complete — ${active.summary}`, end) : null;
+  }
+  const want = JSON.stringify(active.steps[active.next]);
+  const match = options.find((i) => JSON.stringify(i) === want);
+  if (!match) {
+    mine.delete(player);
+    return null;
+  }
+  active.next++;
+  return because(`step ${active.next} of ${active.steps.length} of a planned switching turn — ${active.summary}`, match);
+}
+
 /** The bot as it plays today. Every knob off. */
 export const developerBot: BotPolicy = makeDeveloperBot({});
 
@@ -138,13 +212,39 @@ export function makeDeveloperBot(tweaks: BotTweaks): BotPolicy {
 
   choose(s, player, options) {
     lastReason = 'no specific reason — first legal option';
+
+    /**
+     * §3.3, EXTENDED PLAY (Gitea#11) — a bot never asks for another Day.
+     *
+     * "If only bots are playing, they never vote to extend" (Jesse, 2026-08-28), which is what keeps
+     * the balance harness and every bot-only game ending at the timetable it was dealt with. It also
+     * makes this the SAFE DEFAULT everywhere else: a bot's agreement in a game with humans in it is
+     * decided by `server/session.ts`, which votes on the bots' behalf only once every human has
+     * already said yes, and never reaches this policy at all.
+     */
+    const extend = options.find((i) => i.type === 'game.extend' && i.agree === false);
+    if (extend) return because('a bot plays the timetable it was dealt and no more', extend);
+
     const clearance = ruleOnClearance(options);
     if (clearance) return because('the Superintendent must rule on a following train', clearance);
 
+    /**
+     * §11 (Gitea#5) — the bot keeps its trains at the Train Order Office.
+     *
+     * A deliberate policy, not an oversight, and the cautious half of a real choice: the Yard Office
+     * frees an A/D track, which is worth something on a busy district, but the lead into it may be
+     * fouled and the bot does not read its own yard well enough to tell (`TODO.md`, Bot
+     * Performance — it cannot spot a car at a stub industry either). Declining is always safe, and
+     * it keeps the balance harness comparable with every measurement taken before this rule existed.
+     * Worth revisiting when the bot can judge the lead.
+     */
+    const yardOffice = options.find((i) => i.type === 'mainline.yardOffice' && i.take === false);
+    if (yardOffice) return because('the bot does not judge the lead into a yard, so it stays at the Office', yardOffice);
+
     // Red Flags come before anything else — protection is only worth playing at the moment the
     // collision is actually pending, and that moment passes.
     const flags = worthFlagging(s, options);
-    if (flags) return because('a train of ours is stopped on a Mainline card with another train on it — Red Flags now or not at all', flags);
+    if (flags) return because('the engine says this arrival collides, and we hold a Red Flag — now or never', flags);
 
     // --- Load/Unload: spend every worker, then end. Each is a point, or a step toward one.
     //
@@ -183,6 +283,13 @@ export function makeDeveloperBot(tweaks: BotTweaks): BotPolicy {
         );
         if (match) return because(`the ${w.loaded ? 'loaded' : 'empty'} ${w.type} is what a facility is short of`, match);
       }
+      if (!tweaks.noDeliberateNewTrain) {
+        const move =
+          pickFirst(options, 'newTrain.placeCar', 'newTrain.passCar', 'newTrain.startExtra') ??
+          options.find((i) => i.type !== 'newTrain.secondSection' && i.type !== 'maneuver.redFlags') ??
+          options[0]!;
+        return because('no car on offer is one our facilities need', move);
+      }
       return because('no car on offer is one our facilities need', pickFirst(options, 'newTrain.placeCar', 'newTrain.passCar') ?? options[0]!);
     }
 
@@ -412,7 +519,7 @@ function topOfDepartment(s: GameState, slot: number): string | undefined {
  * In a competitive game the same call reads the other way round — burying a card a rival wants is an
  * attack — which is why the choice belongs to the discarding player and not to the rules.
  */
-function bestDiscard(s: GameState, player: PlayerIndex, options: Intent[]): Intent | null {
+function bestDiscard(s: GameState, player: PlayerIndex, options: Intent[], tweaks: BotTweaks): Intent | null {
   let best: Intent | null = null;
   let bestScore = -Infinity;
   for (const i of options) {
@@ -422,7 +529,7 @@ function bestDiscard(s: GameState, player: PlayerIndex, options: Intent[]): Inte
     // two showing whatever they happened to start with. Measured over 100 games — spreading 2.87
     // revenue, concentrating on the deepest 2.67, indifferent 2.67.
     const top = topOfDepartment(s, i.toSlot);
-    const wanted = isWorthTaking(s, player, i.toSlot);
+    const wanted = isWorthTaking(s, player, i.toSlot, tweaks);
     const depth = s.decks.departments[i.toSlot]?.length ?? 0;
     const score = (top === undefined ? 6 : wanted ? -10 : 2) - Math.min(depth, 4) * 0.5;
     if (score > bestScore) {
@@ -434,10 +541,39 @@ function bestDiscard(s: GameState, player: PlayerIndex, options: Intent[]): Inte
 }
 
 /** A face-up card worth spending the draw on rather than gambling on the deck. */
-function isWorthTaking(s: GameState, player: PlayerIndex, slot: number): boolean {
-  return takingRank(s, player, slot) > 0;
+function isWorthTaking(s: GameState, player: PlayerIndex, slot: number, tweaks: BotTweaks): boolean {
+  return takingRank(s, player, slot, tweaks) > 0;
 }
 
+/**
+ * Could an industry of this kind be laid anywhere right now? Asked of the engine's own placement
+ * rule (`canPlaceAt`) and lockout (`isLockedOut`) rather than a copy: an industry is plain east-west
+ * track, so the only squares worth asking about are empty ones east or west of a card already down.
+ */
+function industrySiteExists(s: GameState, player: PlayerIndex, kind: FreightKind): boolean {
+  const area = areaOf(s, player);
+  if (isLockedOut(area, kind)) return false;
+  const probe = {
+    geometry: { kind: 'facility', facility: kind },
+    baseOperationalRail: true,
+    standing: [],
+    standingWest: 0,
+    facility: null,
+    modifiers: [],
+    enhancements: [],
+  } as unknown as TrackCard;
+  for (const key of area.grid.keys()) {
+    const [row, col] = key.split(',').map(Number);
+    for (const dc of [1, -1]) {
+      const at = { row: row!, col: col! + dc };
+      if (at.row === area.runningRow || area.grid.has(coordKey(at))) continue;
+      if (canPlaceAt(area, at, probe)) return true;
+    }
+  }
+  return false;
+}
+
+
 /**
  * HOW BADLY the face-up card is wanted. 0 means not worth the draw.
  *
@@ -445,14 +581,18 @@ function isWorthTaking(s: GameState, player: PlayerIndex, slot: number): boolean
  * happened to be scanned first — a coin flip on the card that decides whether the district ever
  * becomes a Passenger Facility at all.
  */
-function takingRank(s: GameState, player: PlayerIndex, slot: number): number {
+function takingRank(s: GameState, player: PlayerIndex, slot: number, tweaks: BotTweaks): number {
   const id = topOfDepartment(s, slot);
   if (!id) return 0;
   const k = s.cards.get(id)?.kind;
   if (!k) return 0;
   if (k.kind === 'office') return nextOfficeTier(areaOf(s, player).tier) === k.tier ? 3 : 0;
-  if (k.kind === 'timetabledTrain' || k.kind === 'extraTrain') return 2;
-  if (k.kind === 'freightFacility') return 1;
+  if (k.kind === 'timetabledTrain' || k.kind === 'extraTrain') {
+    return !tweaks.noPlayableTakes && trainWouldOverfillTheOffice(s, player, tweaks) ? 0 : 2;
+  }
+  if (k.kind === 'freightFacility') {
+    return !tweaks.noPlayableTakes && !industrySiteExists(s, player, k.facility) ? 0 : 1;
+  }
   return 0;
 }
 
@@ -715,6 +855,104 @@ function bestFacilityPlay(s: GameState, player: PlayerIndex, options: Intent[]):
   return best;
 }
 
+/**
+ * WHAT A DISTRICT'S TRACK IS WORTH FOR WHAT IT LETS HAPPEN NEXT — the default since 2026-09-15;
+ * `noValueLays` turns it off.
+ *
+ * `bestTrackLay` scores the PIECE — its shape and where it sits — and cannot tell one that opens an
+ * industry site or closes a run-around from one that merely fills a square. This scores the LAYOUT the
+ * piece would leave, so a lay is worth the difference it makes. Every term is something the rules turn
+ * into play: a site is somewhere a held industry can go; a run-around lets a crew pass its own cars
+ * (§A.5); a way off the main is the only road to either; a Running Track straight is what Interlocking
+ * needs. The weights are a starting point to measure, not a result.
+ */
+function layoutValue(area: OfficeArea): number {
+  let v = 0;
+  const reachable = reachableOffMain(area);
+  v += Math.min(reachable.size, 12) * 0.2;
+
+  let ways = 0;
+  let loops = 0;
+  for (const side of SIDES) {
+    for (const col of waysOff(area, side)) {
+      ways++;
+      if (descendFrom(area, col, side).rejoins.size > 0) loops++;
+    }
+  }
+  v += [0, 1.5, 2, 2.5][Math.min(ways, 3)]!;
+  if (loops > 0) v += 6 + Math.min(loops - 1, 1) * 2;
+
+  // Squares an industry could legally be laid on, joined to track a crew can reach.
+  const probe = protoCard({ kind: 'freightFacility', facility: 'mineTipple' }, 0)!;
+  const tried = new Set<string>();
+  let sites = 0;
+  for (const key of reachable) {
+    const [row, col] = key.split(',').map(Number);
+    for (const dc of [1, -1]) {
+      const at = { row: row!, col: col! + dc };
+      const k = coordKey(at);
+      if (tried.has(k) || area.grid.has(k) || at.row === area.runningRow) continue;
+      tried.add(k);
+      if (canPlaceAt(area, at, probe)) sites++;
+    }
+  }
+  v += [0, 2, 3, 3.5][Math.min(sites, 3)]!;
+
+  let mainStraight = false;
+  for (const [key, card] of area.grid) {
+    if (Number(key.split(',')[0]) !== area.runningRow || card.geometry.kind !== 'track') continue;
+    if (card.geometry.geometry === 'straight') mainStraight = true;
+    // A turnout on the main whose leg joins nothing is a hole in the Running Track with no road behind it.
+    if (card.geometry.geometry === 'turnout') {
+      const col = Number(key.split(',')[1]);
+      for (const side of SIDES) {
+        if (!hasPort(card, legPort(side))) continue;
+        const beyond = area.grid.get(`${area.runningRow + side},${col}`);
+        if (!beyond || !joins(card, legPort(side), beyond)) v -= 0.5;
+      }
+    }
+  }
+  if (mainStraight) v += 1.5;
+  return v;
+}
+
+/**
+ * The track lay worth most by `layoutValue`, placed on a copy of the district exactly as the reducer
+ * places it (`protoCard`, `extendLimitsIfNeeded`). With `mustBuild`, only a lay that gains something is
+ * offered, which is the slot `bestTrackLay` fills; without it, the best of whatever is legal, which is
+ * the slot the "play what is in hand" fallback fills. Ties go to the square nearer the Office.
+ */
+function bestValuedLay(s: GameState, player: PlayerIndex, options: Intent[], mustBuild: boolean): Intent | null {
+  const area = areaOf(s, player);
+  const base = layoutValue(area);
+  let best: Intent | null = null;
+  let bestScore = -Infinity;
+  for (const i of options) {
+    if (i.type !== 'card.play' || i.placement === undefined) continue;
+    const kind = s.cards.get(i.cardId)?.kind;
+    if (kind?.kind !== 'track') continue;
+    const built = protoCard(kind, i.variant);
+    if (!built) continue;
+    const after: OfficeArea = {
+      ...area,
+      grid: new Map(area.grid),
+      limitsWest: { ...area.limitsWest },
+      limitsEast: { ...area.limitsEast },
+    };
+    after.grid.set(coordKey(i.placement), built);
+    extendLimitsIfNeeded(after, i.placement);
+    const gain = layoutValue(after) - base;
+    if (mustBuild && gain <= 0.1) continue;
+    const distance = Math.abs(i.placement.row - area.officeCoord.row) * 2 + Math.abs(i.placement.col - area.officeCoord.col);
+    const score = gain - distance * 0.01;
+    if (score > bestScore) {
+      bestScore = score;
+      best = i;
+    }
+  }
+  return best;
+}
+
 function bestTrackLay(s: GameState, player: PlayerIndex, options: Intent[]): Intent | null {
   const area = areaOf(s, player);
 
@@ -1017,19 +1255,20 @@ function facilityWantsAt(
 }
 
 /**
- * Red Flags — "any time". Worth spending only when a train of ours is stopped out on the Mainline
- * with another train on the same card, which is the situation that becomes a rear-ender.
+ * §Q, RED FLAGS (Gitea#19) — spent only at the moment of danger.
+ *
+ * The card was redefined: it plants a directional flag on your own Limits rather than protecting a
+ * stopped train out on the Mainline, so the old heuristic ("is a train of ours sharing a Mainline
+ * card") no longer describes anything the card does.
+ *
+ * The bot now flags ONLY through the out-of-phase prompt, which the engine raises exactly when an
+ * arrival would collide (`redFlagStop`). That is a better policy than the old one and a much
+ * simpler one: the engine has already established the danger, so there is nothing for the bot to
+ * judge. It never plants a flag speculatively — it cannot tell whether it wants time to switch, and
+ * a flag spent early is a flag not there when a train is actually bearing down.
  */
-function worthFlagging(s: GameState, options: Intent[]): Intent | null {
-  for (const i of options) {
-    if (i.type !== 'maneuver.redFlags') continue;
-    const tray = s.trays.get(i.trayId);
-    if (!tray || tray.position.at !== 'mainline') continue;
-    const node = s.division.nodes[tray.position.index];
-    if (node?.kind !== 'mainline') continue;
-    if (node.transits.length > 1) return i;
-  }
-  return null;
+function worthFlagging(_s: GameState, options: Intent[]): Intent | null {
+  return options.find((i) => i.type === 'mainline.redFlag' && i.flag === true) ?? null;
 }
 
 /** A one-line account of which Load/Unload action was taken, and why it ranked first. */
@@ -1186,7 +1425,7 @@ function followThrough(
       if (!turnOf(s, player).drawnThisTurn) {
         const piles = options.filter(
           (i): i is Extract<Intent, { type: 'draw.fromDepartment' }> =>
-            i.type === 'draw.fromDepartment' && isWorthTaking(s, player, i.slot),
+            i.type === 'draw.fromDepartment' && isWorthTaking(s, player, i.slot, tweaks),
         );
         // Best-ranked pile rather than the first that qualifies: an Office card and a train card
         // both "qualify", and only one of them stops the collisions.
@@ -1194,7 +1433,7 @@ function followThrough(
         // and a train card are face up together 1.6 decisions a game — but ranking them is what the
         // ranking function is for, and a coin flip on the card that decides whether the district
         // ever becomes a Passenger Facility is not worth keeping for its own sake.
-        const useful = piles.sort((a, b) => takingRank(s, player, b.slot) - takingRank(s, player, a.slot))[0];
+        const useful = piles.sort((a, b) => takingRank(s, player, b.slot, tweaks) - takingRank(s, player, a.slot, tweaks))[0];
         if (useful) return because('a face-up card is worth more than a blind draw right now', useful);
         const blind = options.find((i) => i.type === 'draw.fromHomeOffice');
         if (blind) return because('no face-up card is worth taking — gamble on the deck', blind);
@@ -1255,7 +1494,7 @@ function followThrough(
       // STRAIGHTS that Enhancements require, and no Freight Facility has anywhere to go until a
       // district exists. Measured with track absent, the hand held a playable Enhancement on 4,778
       // turns and could legally place one on 33.
-      const track = bestTrackLay(s, player, options);
+      const track = !tweaks.noValueLays ? bestValuedLay(s, player, options, true) : bestTrackLay(s, player, options);
       if (track) return because('lay track — nothing else creates the straights Enhancements need or the spurs freight needs', track);
 
       // Then real development: a card actually laid into the grid. Freight facilities are scored —
@@ -1280,17 +1519,27 @@ function followThrough(
           s.cards.get(i.cardId)?.kind.kind !== 'track',
       );
       if (placed) return because('develop the district with a card that goes on the board', placed);
-      const play = options.find((i) => i.type === 'card.play');
+      const play = !tweaks.noValueLays
+        ? options.find((i) => i.type === 'card.play' && s.cards.get(i.cardId)?.kind.kind !== 'track') ??
+          bestValuedLay(s, player, options, false)
+        : options.find((i) => i.type === 'card.play');
       if (play) return because('play what is in hand', play);
       const end = options.find((i) => i.type === 'draw.end');
       if (end) return because('nothing in hand can be played anywhere legal', end);
       return because(
         'nothing playable — discard onto the Department whose face-up card is least worth keeping reachable',
-        bestDiscard(s, player, options) ?? pickFirst(options, 'card.discard') ?? options[0]!,
+        bestDiscard(s, player, options, tweaks) ?? pickFirst(options, 'card.discard') ?? options[0]!,
       );
     }
 
     case 'switch': {
+      // The planner decides the whole turn; the rules below are its fallback if the position is ever
+      // not the one it planned for, and the whole of switching under `noPlanSwitching`.
+      if (!tweaks.noPlanSwitching) {
+        const planned = plannedSwitch(s, player, options, tweaks);
+        if (planned) return planned;
+      }
+
       /**
        * A MOVE THAT DRAGS THE CREW'S OWN CUT BACK ON IS A WASTED MOVE, so take those off the table
        * before any heuristic gets to choose one.
@@ -1861,8 +2110,37 @@ export function playGame(
     tally(pumpFn(s));
     if (s.status === 'finished') break;
 
-    const actor =
-      s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
+    /**
+     * §3.3, EXTENDED PLAY (Gitea#11) — a simulated game plays the timetable it was dealt.
+     *
+     * DECIDED BY THE DRIVER, not by the policy, and that distinction is the whole point. A bot that
+     * is merely handed the two votes among its legal options will sometimes take another Day —
+     * `randomBot` does so half the time — and since the table can go on granting Days for ever, the
+     * game then runs until `maxTurns`. That is not a hypothetical: it turned `test/sim.test.ts` from
+     * under a second into an unbounded hang, because every seeded game in the harness suddenly played
+     * fifty thousand turns instead of two hundred.
+     *
+     * The harness exists to measure games of a configured length against a configured floor, so
+     * "would you like more Days?" has one answer here whatever the policy. `developerBot` declines on
+     * its own account too, which is what the server relies on when a table is all bots; this is the
+     * guarantee that holds for every OTHER policy, including ones not written yet.
+     */
+    if (s.status === 'awaitingExtension') {
+      const voter = s.extensionVotes.findIndex((v) => v === null);
+      if (voter < 0) break;
+      const decline: Intent = { type: 'game.extend', player: voter, agree: false };
+      intents.push(decline.type);
+      history.push(decline);
+      const declined = applyIntent(s, voter, decline);
+      // A broken invariant, not a game ending early: the status says a vote is pending and `voter` is
+      // a seat that has not cast one. Thrown rather than broken out of, matching the illegal-action
+      // check below — silently returning a short game is how a dead replay looks like a real one.
+      if (!declined.ok) throw new Error(`the extension vote was refused with ${declined.code}`);
+      tally(declined.events);
+      continue;
+    }
+
+    const actor = actingPlayer(s);
     if (actor === null) break;
 
     const options = legalActions(s, actor);

src/sim/compare.ts

@@ -23,6 +23,7 @@
  * Run with:
  *   node src/sim/compare.ts 1600 noTrainCap=1        — what the A/D cap is worth today
  *   node src/sim/compare.ts 1600 noOperateFirst=1    — what operating before drawing is worth
+ *   node src/sim/compare.ts 1600 noPlanSwitching=1   — what planning the switching turn is worth
  *
  * The flags are ABLATIONS: they turn off heuristics the bot already plays, so a negative delta is
  * the heuristic earning its place. That is what a measured bot needs going forward — the question
@@ -221,7 +222,7 @@ export function formatPaired(r: PairedResult): string {
  * against itself and report a confident zero, which is the most expensive way this tool could fail.
  */
 export const NUMERIC_TWEAKS = new Set<string>([]);
-export const BOOLEAN_TWEAKS = new Set(['noTrainCap', 'noOperateFirst']);
+export const BOOLEAN_TWEAKS = new Set(['noTrainCap', 'noOperateFirst', 'noPlanSwitching', 'noPlayableTakes', 'noValueLays', 'noDeliberateNewTrain']);
 
 export function parseTweaks(args: string[]): BotTweaks {
   const tweaks: Record<string, number | boolean> = {};

src/sim/display-step.ts

@@ -0,0 +1,134 @@
+/**
+ * THE DISPLAY-STEP COLLECTOR — v0.8.0, `docs/plans/jitsi-common-board.md` § v0.8.0 §§ 1-3.
+ *
+ * One ordered, watchable presentation step per accepted intent, so a player can see what everyone
+ * else did instead of finding the board already rearranged. TODO #13: *"It's not fun to do my turn
+ * and have magic happen in the background and then have to figure out what others did."*
+ *
+ * ONE HOOK, NOT TWO. The design anticipated wiring this into `GameSession.intent()` and
+ * `GameSession.driveBots()` separately, with `LocalSession` doing its own thing for solitaire. It
+ * does not need to: `src/server/session.ts` imports `submit` from `src/web/game.ts`, so solitaire,
+ * live multiplayer and every bot turn already funnel through ONE function. Collecting there is what
+ * makes solitaire a special case of multiplayer rather than a second implementation, which is the
+ * standing design direction for this codebase.
+ *
+ * AND REPLAY IS INERT FOR FREE. `fromSave` and `fromMultiplayerSave` rebuild a game by calling
+ * `applyIntent` + `record` + `drain` directly rather than `submit`, so a resumed server or a rebuilt
+ * undo does NOT re-emit the whole game as steps. That was expected to need an explicit guard — the
+ * plan calls it out as the same class of bug as #97, a mechanism firing on a path nobody pictured
+ * it running on. It needs none, but the property is load-bearing: **if a replay path is ever moved
+ * onto `submit()`, this becomes a real bug**, and `test/watchable.test.ts` pins it.
+ *
+ * WHAT A STEP IS. One accepted intent, or ONE AUTOMATIC PHASE — never one per `GameEvent`, because
+ * the event list is not a complete reducer and a receiver could not rebuild state from it. It gets a
+ * projected frame instead.
+ *
+ * PHASES EARN THEIR OWN STEPS, and that is TODO #18. `pump()` runs every automatic phase between one
+ * click and the next and `drain()` records the whole batch at once, so New Train, the Mainline and
+ * the shift change "look like they are being skipped entirely" — trains cross the Division in one
+ * jump. Folding them into the triggering intent's step reproduces exactly that. So `submit()` steps
+ * `advance()` one call at a time instead, and collects a step for each phase that actually DID
+ * something. A phase that did nothing adds no narration and therefore produces no step at all, which
+ * is Jesse's own rule (2026-09-09): "if nothing happens during a phase then we shouldn't lose time
+ * to it."
+ *
+ * `drain()` is deliberately NOT changed. Replay, undo and `fromSave` all use it, and the
+ * replay-inertness property below depends on their staying off this path. The stepped version lives
+ * in `submit()` and makes the same `advance()` calls in the same order, so the resulting state is
+ * identical — only the collection differs.
+ */
+
+import type { Intent } from '../engine/intents.ts';
+import type { GameState, PlayerIndex, SeatIndex } from '../engine/state.ts';
+import { seatOf } from '../engine/state.ts';
+import { publicSnapshot } from './view.ts';
+import type { PublicFrame } from './view.ts';
+import { deltaPublicFrame } from './public-delta.ts';
+import type { PublicFrameDelta } from './public-delta.ts';
+
+/**
+ * The wire format's version, on the ENVELOPE rather than on the projection.
+ *
+ * The plan's original sketch put `protocolVersion` inside `PublicFrame`. It does not belong there:
+ * `PublicFrame` is a projection of the game and its property list is an allow-list that
+ * `test/redaction.test.ts` enumerates, so a transport concern living in it would have to be
+ * allow-listed as public game state, which it is not. The step is the message; the message carries
+ * the version.
+ */
+export const DISPLAY_PROTOCOL_VERSION = 1;
+
+/** What produced a step: somebody's intent, or the Division advancing a phase by itself. */
+export type StepCause = Intent['type'] | 'phase';
+
+/** One watchable thing that happened, in order. */
+export type DisplayStep = {
+  protocolVersion: typeof DISPLAY_PROTOCOL_VERSION;
+  /** Monotonic per game. 0.8.1's reconnecting display stream needs it to detect a gap; a queue only needs the order. */
+  seq: number;
+  /**
+   * Who acted — NULL for an automatic phase, which nobody did.
+   *
+   * Both are carried because Employee Rotation makes "which seat" and "which player" different
+   * questions.
+   */
+  player: PlayerIndex | null;
+  seat: SeatIndex | null;
+  /** What caused it — the input to pacing's kind classification. */
+  cause: StepCause;
+  /** The public board after this intent and everything it drained, against the previous step. */
+  frame: PublicFrameDelta;
+  /** The narration this intent added, in order, including any phase lines drained behind it. */
+  lines: { text: string; tone: string }[];
+};
+
+/**
+ * Per-game collector state.
+ *
+ * Held on `Game` beside `log`, `cues` and `announced` and drained the same way, which is the
+ * established convention in this codebase for "the model accumulated something, the view takes it".
+ */
+export type DisplayCollector = {
+  /** Undrained steps, oldest first. */
+  steps: DisplayStep[];
+  /** The last public frame a step was built against, so the next delta has something to diff. */
+  last: PublicFrame | null;
+  /** Next sequence number to assign. */
+  seq: number;
+};
+
+export function newCollector(): DisplayCollector {
+  return { steps: [], last: null, seq: 0 };
+}
+
+/**
+ * Record one accepted intent as a step.
+ *
+ * Called from `submit()` AFTER `record()` and `drain()`, so `state` is the position the intent
+ * finally produced and `lines` is everything it caused to be said. The frame is projected
+ * immediately and never from a retained `GameState` reference — a retained reference would resolve
+ * to the FINAL state of a whole bot run, which is exactly the teleporting this exists to prevent.
+ */
+export function collectStep(
+  collector: DisplayCollector,
+  state: GameState,
+  player: PlayerIndex | null,
+  cause: StepCause,
+  lines: { text: string; tone: string }[],
+): void {
+  const next = publicSnapshot(state);
+  collector.steps.push({
+    protocolVersion: DISPLAY_PROTOCOL_VERSION,
+    seq: collector.seq++,
+    player,
+    seat: player === null ? null : seatOf(state, player),
+    cause,
+    frame: deltaPublicFrame(collector.last, next),
+    lines,
+  });
+  collector.last = next;
+}
+
+/** Take everything collected so far, leaving the collector empty — `takeMoment()`'s pattern. */
+export function takeSteps(collector: DisplayCollector): DisplayStep[] {
+  return collector.steps.splice(0, collector.steps.length);
+}

src/sim/narrate.ts

@@ -15,10 +15,10 @@
  * panel cannot drift from the rules.
  */
 
-import { MAX_CONSIST } from '../engine/content.ts';
+import { MAINLINE_PROFILES, MAX_CONSIST, crewTrayCount } from '../engine/content.ts';
 import { adTrackCount, coordKey, seatOf, turnOf } from '../engine/state.ts';
 import type { GameState, GridCoord, PlayerIndex, RollingStock, SeatIndex, TrayId } from '../engine/state.ts';
-import { areaOf, canAdvanceLoad, canBoard, canDetrain, canStartLoad, facilityCarType, facilityCarTypes, laborersLeft, movesFor, passengerRefusal, portersLeft } from '../engine/apply.ts';
+import { areaOf, canAdvanceLoad, canBoard, canDetrain, canStartLoad, facilityCarType, facilityCarTypes, freightRuleSpentHere, isFreight, laborersLeft, movesFor, passengerRefusal, portersLeft } from '../engine/apply.ts';
 import type { GameEvent } from '../engine/events.ts';
 
 // ---------------------------------------------------------------------------
@@ -127,6 +127,18 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
           .map((p) => ctx.playerName?.(p) ?? `Player ${p + 1}`)
           .join(' → ')}`,
       };
+    case 'superintendentChanged':
+      /**
+       * The Fedora is the only thing in the game that changes hands on a clock rather than because
+       * somebody did something, so it is the one handover nobody at the table watches happen.
+       */
+      return {
+        tone: 'clock',
+        text:
+          `SUPERINTENDENT — the Fedora passes to ${ctx.playerName?.(e.player) ?? 'the next player'} ` +
+          `at the end of Stage ${e.stage}. They rule on clearances, take the Yard Office and Red Flag ` +
+          `questions, and every round that goes round the table now starts with them.`,
+      };
     case 'phaseBegan':
       // Its own tone, not `quiet`. A phase marker sat in the same grey as the events inside it, so
       // the log read as one undifferentiated column and you could not see where a phase began.
@@ -134,7 +146,7 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
     case 'actorChanged':
       return {
         tone: 'quiet',
-        text: e.player === null ? 'No player acts — automatic phase' : `Player ${e.player} to act`,
+        text: e.player === null ? 'No player acts — automatic phase' : 'to act',
       };
 
     // -- local operations
@@ -155,7 +167,7 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
       return {
         tone: 'plain',
         where: e.to,
-        text: `CREW moved ${at(e.from)} → ${at(e.to)}${e.via ? ` via ${at(e.via)}` : ''} — ${e.movesRemaining} of 6 Moves left. The crew chip on the grid carries the whole train with it.`,
+        text: `Moved ${train(e.trayId)} ${at(e.from)} → ${at(e.to)}${e.via ? ` via ${at(e.via)}` : ''} — ${e.movesRemaining} of 6 Moves left. The crew chip on the grid carries the whole train with it.`,
       };
     case 'carsCoupled': {
       /**
@@ -181,7 +193,7 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
       return {
         tone: 'good',
         where: e.at,
-        text: `SMALL YARD — consist re-ordered from [${carsLabel(e.before)}] to [${carsLabel(e.after)}], so the right car is now on the end and can be spotted`,
+        text: `Used the SMALL YARD — consist re-ordered from [${carsLabel(e.before)}] to [${carsLabel(e.after)}], so the right car is now on the end and can be spotted`,
       };
     case 'carsDropped':
       // WHICH END. A cut comes off an outer end (§A.3) and the end decides everything that follows:
@@ -211,17 +223,32 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
           ? `Played ${card(e.cardId)} onto ${at(e.placement)}`
           : `Played ${card(e.cardId)}`,
       };
-    case 'mainlineModified':
+    case 'mainlineModified': {
+      // WHICH CARD, NOT JUST WHICH WAY IT WENT. "Mainline card 3 converted to plains" left the reader
+      // to remember what card 3 had been (playtest, 2026-09-15), and the card it WAS is the half that
+      // says what the play was worth.
+      const kindName = (k: string | undefined): string =>
+        MAINLINE_PROFILES.find((m) => m.kind === k)?.name ?? k ?? 'that card';
       return {
         tone: 'plain',
         text: e.became
-          ? `Realignment: Mainline card ${e.node} converted to ${e.became}`
-          : `Played ${e.key} on Mainline card ${e.node}`,
+          ? `Realignment: Mainline card ${e.node}, ${kindName(e.from)}, converted to ${kindName(e.became)}`
+          : `Played ${e.key} on Mainline card ${e.node}${e.from ? ` (${kindName(e.from)})` : ''}`,
       };
+    }
+    case 'redFlagSpent':
+      return {
+        tone: 'good',
+        text: `RED FLAG — Train ${e.trainNumber} stopped short of the ${e.side === 'east' ? 'Eastern' : 'Western'} Limits. The flag comes down with it.`,
+      };
+    case 'redFlagRuled':
+      return e.flag
+        ? { tone: 'plain', text: 'Flagged the approaching train' }
+        : { tone: 'plain', text: 'Waved the train through' };
     case 'redFlagsSet':
       return {
         tone: 'good',
-        text: `Red Flags set out to protect train ${e.trayId} on Mainline card ${e.node} — an approaching train must stop`,
+        text: `RED FLAGS set out on the ${e.side === 'east' ? 'Eastern' : 'Western'} Limits — the next train from that way is held short`,
       };
     case 'flyingSwitch':
       return {
@@ -328,12 +355,25 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
        * arrival; the only difference is what happens if it is left on Secondary Track when the next
        * Mainline Phase begins (`expediteFault`).
        */
-      return {
-        tone: 'plain',
-        text: e.expedited
-          ? `Train ${e.trainNumber} ARRIVED at the ${e.office} carrying ${carsLabel(e.consist)} — its card prints EXPEDITE, so keep it on the Office square: parked anywhere else in the district when the next Mainline Phase begins costs a Revenue point. It works and switches normally in the meantime.`
-          : `Train ${e.trainNumber} ARRIVED at the ${e.office} carrying ${carsLabel(e.consist)} — it stands here for the rest of this Stage. You can work it in Cargo now, switch it in the NEXT Stage's Local Operations, and it departs in that Stage's Mainline Phase.`,
-      };
+      /**
+       * WHOSE OFFICE, AND WHOSE TRAIN TO WORK — Jesse, playtest 2026-09-16.
+       *
+       * This said "ARRIVED at the Whistle Post" and then "You can work it in Cargo now". Both halves
+       * are wrong at a table of four: every seat has an Office, so the tier alone does not say which
+       * district the train is standing in, and the reader is usually NOT its Station Master — the
+       * line was telling three players they could work a train they cannot touch.
+       */
+      {
+        const name = ctx.playerName?.(e.owner) ?? null;
+        const whose = name === null ? `the ${e.office}` : `${name}'s ${e.office}`;
+        const worker = name === null ? 'Its Station Master' : name;
+        return {
+          tone: 'plain',
+          text: e.expedited
+            ? `Train ${e.trainNumber} ARRIVED at ${whose} carrying ${carsLabel(e.consist)} — its card prints EXPEDITE, so it must stay on the Office square: parked anywhere else in that district when the next Mainline Phase begins costs a Revenue point. It works and switches normally in the meantime.`
+            : `Train ${e.trainNumber} ARRIVED at ${whose} carrying ${carsLabel(e.consist)} — it stands there for the rest of this Stage. ${worker} can work it in Cargo now and switch it in the NEXT Stage's Local Operations, and it departs in that Stage's Mainline Phase.`,
+        };
+      }
     case 'expediteFault':
       return {
         tone: 'bad',
@@ -407,12 +447,31 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
       const wrecked = e.trains
         .map((t) => `${t.label} (${t.consist.length ? carsLabel(t.consist) : 'no cars'})`)
         .join(' and ');
+      /**
+       * WHOSE OFFICE, AND WHO PAYS (playtest, 2026-09-16: "it doesn't say who suffers the revenue
+       * loss… we need to know which player received the penalty and why").
+       *
+       * `player` is the seat at fault, and for everything that happens inside a district that is the
+       * district's owner — so it names the place as well as the payer. A Mainline collision is the
+       * Superintendent's by rule (§10), which is a different sentence: it happened on open road, not
+       * in anybody's Office. The 5 points ride in a separate `revenueChanged`, which is why the line
+       * never mentioned them; a player should not have to add two log entries together.
+       */
+      const who = ctx.playerName?.(e.player) ?? null;
+      const mainline = e.where === 'the Mainline';
+      const place = who === null || mainline ? e.where : `${who}'s ${e.where.replace(/^the /, '')}`;
+      const cost =
+        who === null
+          ? ' 5 Revenue is lost.'
+          : mainline
+            ? ` ${who} loses 5 Revenue: §10 makes a Mainline collision the Superintendent's fault.`
+            : ` ${who} loses 5 Revenue — it happened in their district.`;
       return {
         tone: 'bad',
         text:
-          `COLLISION — ${wrecked} destroyed: ${why}. Engines and cabooses go back to the Division ` +
-          `Yard, all other cars to the Classification Yard. A Timetabled train card returns ` +
-          `to its slot and runs again next Day; an Extra is gone for good.`,
+          `COLLISION at ${place} — ${wrecked} destroyed: ${why}.${cost} Engines and cabooses go back ` +
+          `to the Division Yard, all other cars to the Classification Yard. A Timetabled train card ` +
+          `returns to its slot and runs again next Day; an Extra is gone for good.`,
       };
     }
 
@@ -487,7 +546,23 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
         ? { tone: 'bad', text: `${e.reason.toUpperCase()} · ${e.delta} Revenue (now ${e.total})` }
         : { tone: 'good', text: `+${e.delta} Revenue (now ${e.total}) — ${e.reason}` };
     case 'phaseEnded':
-      return { tone: 'quiet', text: `Player ${e.player} finished ${phaseLabel(e.phase)}` };
+      return { tone: 'quiet', text: `Finished ${phaseLabel(e.phase)}` };
+
+    // -- §3.3, extended play (Gitea#11)
+    case 'extensionVoted':
+      return e.agree
+        ? { tone: 'plain', text: 'Would play one more Day' }
+        : { tone: 'plain', text: 'Called time — the game ends here' };
+    case 'dayExtended':
+      return { tone: 'clock', text: `── The table plays on: Day ${e.day} is added to the timetable ──` };
+    case 'playConcluded':
+      return { tone: 'clock', text: '── The railroad is put to bed. Final results stand. ──' };
+
+    // -- §11, the Yard Office (Gitea#5)
+    case 'yardOfficeRuled':
+      return e.take
+        ? { tone: 'plain', text: `Sent ${train(e.trainId)} into the Yard Office` }
+        : { tone: 'plain', text: `Kept ${train(e.trainId)} at the Train Order Office` };
   }
 }
 
@@ -616,6 +691,38 @@ export function impediments(s: GameState, player: PlayerIndex = 0): Impediment[]
      * that actually refused rather than a second guess at it.
      */
     if (f.kind === 'passenger') {
+      /**
+       * NOBODY TO PUT ON THE PLATFORM, AND NO WAY TO SEE WHY (playtest, 2026-09-16).
+       *
+       * "He would like to have two passengers waiting in his depot… but the only option he had was
+       * bringing a tank load into the refinery." His Depot had a Restaurant and a Hotel beside it and
+       * three outbound slots — capacity was never the problem. §6.3 stocking takes a LOADED car of
+       * the facility's type out of the Division Yard, and there was not a loaded coach in it: six
+       * were sitting in Classification, which §2.2 returns only when the Division Yard runs bare.
+       *
+       * Jesse's ruling (2026-09-16) is the same one Gitea#2 got: the shortage stays, because running
+       * out is part of the game. What must not stay is the silence — an action with no legal target
+       * is simply absent from the menu, so the player is left to guess whether they misunderstood the
+       * rules or the game is broken.
+       */
+      if (f.allows.outbound && f.outboundBox.length < f.capacity.outbound) {
+        const loadedCoaches = s.yards.divisionYard.filter((c) => c.type === 'coach' && c.loaded).length;
+        if (loadedCoaches === 0) {
+          const waiting = s.yards.classificationYard.filter((c) => c.type === 'coach' && c.loaded).length;
+          out.push({
+            where: `${name} ${key}`,
+            why:
+              `room for ${f.capacity.outbound - f.outboundBox.length} more passenger` +
+              `${f.capacity.outbound - f.outboundBox.length === 1 ? '' : 's'} to wait, but no loaded ` +
+              `coach in the Division Yard for the Freight Agent to bring over` +
+              (waiting > 0
+                ? ` — ${waiting} ${waiting === 1 ? 'is' : 'are'} in the Classification Yard, which comes ` +
+                  'back only when the Division Yard is bare'
+                : ''),
+            severity: 'waiting',
+          });
+        }
+      }
       if (portersLeft(f) > 0) {
         const coord = uncoordKey(key);
         // Passengers standing on the platform with nothing carrying them away.
@@ -721,6 +828,42 @@ export function impediments(s: GameState, player: PlayerIndex = 0): Impediment[]
    * Only while switching, and only the cards actually in the crew's way: `movesFor` reports the
    * squares the movement walk reached and refused, not every square on the board.
    */
+  /**
+   * WHY A CAR WILL NOT COME OFF (Gitea#21).
+   *
+   * "I dropped the first tank car, but that was all I was allowed to do" — and this panel, asked
+   * why, talked about the refinery's green box. The rule that actually refused is printed on the
+   * train: trains 3/4, the Express, "may drop or pick up one freight car at every location". The
+   * refusal was correct. Nothing said it.
+   *
+   * That is a worse failure than a missing button, because the panel did not stay silent — it
+   * offered a true statement about the FACILITY, which sent the player to spend a Freight Agent
+   * action that could not have helped. The rule was on the train card's tooltip, which is not
+   * where anyone looks when a button they expected is simply absent.
+   *
+   * Only when the crew has a freight car it could otherwise set out. A budget spent by a train
+   * with nothing left to drop is not blocking anything, and this panel earns its keep by being
+   * short enough to read.
+   */
+  const turnNow = turnOf(s, player);
+  if (s.clock.phase === 'localOps' && turnNow.option === 'switch') {
+    for (const [id, tray] of s.trays) {
+      if (tray.position.at !== 'grid' || tray.position.seat !== seatOf(s, player)) continue;
+      if (!tray.consist.some(isFreight)) continue;
+      if (!freightRuleSpentHere(s, player, id)) continue;
+      const { row, col } = tray.position.coord;
+      out.push({
+        where: `Train ${tray.trainNumber} at (${col},${row})`,
+        why:
+          'ONE FREIGHT CAR PER LOCATION — this train has already worked a freight car on this ' +
+          'square, so no more come off or on here until next turn. It may still work one at the ' +
+          'next square it reaches.',
+        // The printed rule doing its job, and it lifts by itself. Amber, not red.
+        severity: 'waiting',
+      });
+    }
+  }
+
   const turn = turnOf(s, player);
   if (s.clock.phase === 'localOps' && turn.option === 'switch' && turn.movesRemaining > 0) {
     for (const [id, tray] of s.trays) {
@@ -807,13 +950,69 @@ export function impediments(s: GameState, player: PlayerIndex = 0): Impediment[]
     }
   }
 
-  // Trains held for want of a Crew Tray (§7) — the scarcity mechanic, made visible.
-  const due = s.timetable[s.clock.stage - 1];
-  if (due !== null && due !== undefined && s.freeTrays.length === 0) {
+  /**
+   * TRAINS HELD FOR WANT OF A CREW TRAY (§7) — the scarcity mechanic, made visible (#98).
+   *
+   * This covered the TIMETABLED train due out this Stage and nothing else, which meant the two
+   * other things that queue for the same pool reported nothing at all. A player who spent a card on
+   * an Extra, or ordered a second section, got an EMPTY panel while their train sat behind an
+   * exhausted pool — and each had been announced once in the log in a line that promised a future
+   * event ("as soon as a Crew Tray frees up") which nothing then confirmed.
+   *
+   * All three are one condition, so they are written as one block: no free tray, and something
+   * waiting for one. The count rides along because "no free Crew Tray" reads like a permanent fact
+   * about the game rather than a state that will pass.
+   */
+  // `crewTrayCount` is the pool's size, asked rather than re-derived. `trays.size + freeTrays.length`
+  // gives the same number in play — `retireTrain` moves a tray back — but it is a second way to know
+  // one fact, which is the shape of every bug this release fixed.
+  const trays = `${s.freeTrays.length} of ${crewTrayCount(s.players.length)} Crew Trays free`;
+  if (s.freeTrays.length === 0) {
+    const due = s.timetable[s.clock.stage - 1];
+    if (due !== null && due !== undefined) {
+      out.push({
+        where: `Train ${due}`,
+        why: `due to depart but HELD — no free Crew Tray (${trays})`,
+        severity: 'stuck',
+      });
+    }
+
+    // An Extra belongs to the player who played the card (§7), so it is their errand and it is
+    // reported to them. A second section is the table's, like any Timetabled train.
+    for (const x of s.pendingExtras) {
+      if (x.player !== player) continue;
+      out.push({
+        where: `Extra X${x.trainNumber}`,
+        why: `played and waiting to be made up — no free Crew Tray (${trays})`,
+        severity: 'stuck',
+      });
+    }
+
+    for (const n of s.pendingSecondSections) {
+      out.push({
+        where: `Train ${n}`,
+        why: `second section ordered and waiting to be made up — no free Crew Tray (${trays})`,
+        severity: 'stuck',
+      });
+    }
+  }
+
+  /**
+   * A TRAIN HELD AT THE LIMITS BY AN INTERLOCKING (#99).
+   *
+   * It is inside the player's Limits, not on an A/D track, and it takes the first track that frees
+   * ahead of any newcomer. The map now draws it on the Limits square; this says what it is waiting
+   * for, which is the Office emptying rather than anything the held train itself can do.
+   */
+  for (const id of area.heldAtLimits) {
+    const t = s.trays.get(id);
+    if (!t) continue;
     out.push({
-      where: `Train ${due}`,
-      why: 'due to depart but HELD — no free Crew Tray',
-      severity: 'stuck',
+      where: `Train ${t.trainIsExtra ? 'X' : ''}${t.trainNumber ?? '—'}`,
+      why:
+        'held at your Limits by the Interlocking instead of colliding — it takes the first A/D ' +
+        'track that frees, ahead of any train arriving after it',
+      severity: 'waiting',
     });
   }
 

src/sim/pacing.ts

@@ -0,0 +1,256 @@
+/**
+ * HOW LONG EACH STEP IS SHOWN — v0.8.0, `docs/plans/jitsi-common-board.md` § v0.8.0 § 5.
+ *
+ * Shared rather than living in `src/web/`, so the 0.8.1 seatless board paces identically to a
+ * player's own screen. Two views of one game that disagreed about how fast it looks would be worse
+ * than either alone.
+ *
+ * WHY BY KIND RATHER THAN BY BUDGET. The obvious scheme is to give the whole backlog a time budget
+ * and divide it by the queue length. Measured against real games, that does exactly the wrong
+ * thing. From `public/replays/`: ~60 stages per game and ~5 intents per player per stage, so a
+ * four-player table produces ~15 other-player steps per stage — but 44 of a 307-intent game are
+ * `draw.end` and 60 are `loadUnload.end`, bookkeeping nobody wants to watch, while the thing that
+ * is worth watching is rare and clustered. Two of the three published replays contain no
+ * `switch.move` at all; the third has bursts of 14, 6, 6 and 6, and `trayMoved`'s own narration says
+ * "N of 6 Moves left" because six is the engine's cap per crew. So a uniform budget spends the
+ * player's attention on `draw.end` and rushes the switching.
+ *
+ * Assigning dwell by kind and letting the total fall out costs ~40s of animation across a whole
+ * 60-stage game, against ~3.6 minutes for a flat 700ms — better switching visibility for a fifth of
+ * the time. Jesse, 2026-09-09, on what matters: *"I definitely want to watch other players struggle
+ * with the switching exercises … I don't think reading the switching in the log will be anywhere
+ * nearly as interesting as watching the trains actually move on the board."*
+ *
+ * PACING IS CLIENT-SIDE ONLY. The server emits steps as fast as it likes and the client decides how
+ * to show them, which is what keeps Gitea#20's "do not slow the authoritative game" true.
+ */
+
+import type { StepCause } from './display-step.ts';
+
+export type StepKind = 'switching' | 'action' | 'phase' | 'bookkeeping';
+
+/**
+ * THE TUNING TABLE — dwell in milliseconds per kind.
+ *
+ * Start generous and tune down by playing; Jesse, 2026-09-09: *"start at 1s and tune down."* This is
+ * the committed default and changing it needs a web rebuild, which in the `.s9pk` is a release — so
+ * it is deliberately not the only way to change the pacing. A viewer's own `pace` multiplier
+ * (`Settings`, `localStorage`) and a `?pace=` URL parameter both scale these without one, and
+ * `pace = 0` turns the animation off entirely, which is also TODO #18's "a player who has seen it a
+ * hundred times will want it off". **Multipliers above 1 are supported and expected** — Jesse asked
+ * for 2 and 3 explicitly after the first play — up to `MAX_PACE`, and every tier scales together so
+ * their relative weighting survives.
+ *
+ * NOT IN GAME-CREATION SETTINGS, on Jesse's call 2026-09-09: dwell is presentation, not a rule, and
+ * `config` rides along in saves and replays. If it ever moves there, the config field supplies this
+ * table's multiplier — the table, the classification and the queue do not change.
+ */
+export const DWELL: Record<StepKind, number> = {
+  /** A train physically moving on the board. The thing worth watching, and protected accordingly. */
+  switching: 1000,
+  /**
+   * A card, a car or a load changing hands somewhere visible — and the announcement of what a
+   * player is about to do.
+   *
+   * 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 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.
+   */
+  action: 700,
+  /**
+   * An automatic phase that DID something — TODO #18.
+   *
+   * Only reached when the phase actually narrated: `submit()` collects no step for a phase that
+   * changed nothing, so this is never spent on the empty ones Jesse is content to guess at. Between
+   * an ordinary action and a switching move, because the Mainline phase moves trains the length of
+   * the Division and is the clearest case of "stuff just happened without being able to see how".
+   */
+  phase: 600,
+  /** Turn and phase bookkeeping. Nothing moved; do not spend the player's attention on it. */
+  bookkeeping: 0,
+};
+
+/**
+ * Which kind an intent is.
+ *
+ * Exhaustive over `Intent['type']` on purpose — a `default` would silently drop a newly added intent
+ * into whatever tier the fallback names, and the failure mode is invisible (a move that never gets
+ * a beat, or bookkeeping that stalls the queue for a second). `test/pacing.test.ts` walks every
+ * member of the union so a new intent cannot land here unclassified.
+ */
+export function kindOf(cause: StepCause): StepKind {
+  switch (cause) {
+    // The Division advancing itself — New Train, the Mainline, the shift change (TODO #18).
+    case 'phase':
+      return 'phase';
+
+    // The crew and its train moving, coupling, setting out and re-ordering — §6.1 and Appendix A.
+    case 'switch.move':
+    case 'switch.dropCars':
+    case 'switch.sortConsist':
+    case 'maneuver.flyingSwitch':
+    case 'maneuver.redFlags':
+      return 'switching';
+
+    // Something visible changed hands or position, but no train drove anywhere.
+    case 'card.play':
+    case 'card.discard':
+    case 'draw.fromHomeOffice':
+    case 'draw.fromDepartment':
+    case 'newTrain.placeCar':
+    case 'newTrain.passCar':
+    case 'newTrain.secondSection':
+    case 'newTrain.startExtra':
+    case 'porter.board':
+    case 'porter.detrain':
+    case 'laborer.startLoad':
+    case 'laborer.advanceLoad':
+    case 'laborer.beginUnload':
+    case 'freightAgent.stockOutbound':
+    case 'freightAgent.clearInbound':
+    case 'freightAgent.unjam':
+    case 'mainline.clearance':
+    case 'mainline.modify':
+    case 'mainline.redFlag':
+    case 'mainline.yardOffice':
+    case 'redFlag.play':
+      return 'action';
+
+    /**
+     * `localOps.choose` IS AN ANNOUNCEMENT, NOT BOOKKEEPING — moved out 2026-09-09 after the first
+     * real play. It is the line that reads "Player Bot 1 chose to SWITCH — six Moves to shunt cars
+     * around the yard": the heading for everything that follows, and at zero dwell nobody ever saw
+     * it, so a bot's turn began with no indication of what it was about to do.
+     */
+    case 'localOps.choose':
+      return 'action';
+
+    // Ending a phase or a turn, and voting. Nothing to see: the consequences were the thing, and
+    // there are more of these than of anything else.
+    case 'loadUnload.end':
+    case 'draw.end':
+    case 'switch.end':
+    case 'freightAgent.end':
+    case 'game.extend':
+      return 'bookkeeping';
+  }
+}
+
+/**
+ * The widest multiplier that is a speed rather than a mistake.
+ *
+ * `pace` has no lower surprise — 0 means off — but an unbounded upper one does: `?pace=300` from
+ * somebody typing 3.00, or a corrupt `localStorage` value, would give a switching move a five-minute
+ * dwell and look exactly like a frozen board. Twenty is far past any speed anyone would choose and
+ * well short of unusable.
+ *
+ * RAISED FROM TEN 2026-09-10, because the ceiling turned out not to be theoretical: Jesse played at
+ * 10× — the top of the ladder — and reported it *"still a bit fast, but followable"*. A control whose
+ * slowest setting is not slow enough for the person using it has the wrong ceiling, not the right one
+ * held firmly.
+ */
+export const MAX_PACE = 20;
+
+/**
+ * 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, 15, 20] as const;
+
+/**
+ * How long to show one step, in ms, at a given speed.
+ *
+ * `pace` scales every tier by the same factor, so **the tiers stay in proportion at any speed** — a
+ * switching move outlasts an ordinary action at 0.5× and at 3× alike. That is deliberate: the
+ * relative weighting is the design (a train moving is worth more attention than a card changing
+ * hands), and the multiplier is only how fast the whole thing runs. `0` means do not animate at all.
+ */
+export function dwellFor(cause: StepCause, pace = 1): number {
+  return Math.round(DWELL[kindOf(cause)] * Math.min(MAX_PACE, Math.max(0, pace)));
+}
+
+/**
+ * How much of the speed control a PHASE gets — damped, not the full multiplier.
+ *
+ * Phases were pinned at their tabled beat in v0.8.0.3, because scaling them with everything else put
+ * a wall of clock-ticking after a player's own move. That was right about the cost and wrong about
+ * the need: at 10× the caption row goes past faster than the sentence on it can be read. Jesse,
+ * 2026-09-10: *"phases displayed on the upper line go by too quickly still. Should be 4 times as
+ * long — at a guess. Maybe use the speed multiplier for that too?"*
+ *
+ * So they scale, at a third of the rate. That lands exactly on his guess — 10× gives a phase four
+ * times its tabled beat — while leaving 1× untouched, and it stays affordable because phase beats
+ * cluster rather than accumulate: measured over 60 pushes, a push carries **1.0 phase beat on
+ * average and 4 at worst**, so the wait after a move goes to ~2.4s typical and ~10s at its very
+ * worst rather than the minutes a full multiplier would have cost.
+ *
+ * Below 1× it simply follows the multiplier: somebody asking for everything faster means the phases
+ * too.
+ */
+function phaseSpeed(pace: number): number {
+  return pace <= 1 ? pace : 1 + (pace - 1) / 3;
+}
+
+/**
+ * How long to show one STEP — the form the queue actually uses.
+ *
+ * A step that said nothing gets no dwell, whatever caused it. That is one rule covering two cases
+ * arrived at separately: a phase where nothing happened (Jesse, 2026-09-09 — *"if nothing happens
+ * during a phase then we shouldn't lose time to it"*), and a phase that only handed the turn on,
+ * which changes the board but has nothing on it to look at. Structurally typed so this file does not
+ * have to import `DisplayStep` back from the module that imports `StepCause` from it.
+ */
+export function dwellForStep(
+  step: { cause: StepCause; player: number | null; lines: readonly unknown[]; frame: { table: object } },
+  pace = 1,
+): number {
+  // 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 ? phaseSpeed(pace) : 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.
+   *
+   * Measured, because the obvious rule was wrong twice. "No narration, no dwell" looked right and
+   * 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.
+   */
+  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, speed) : 0;
+}
+
+/**
+ * How many steps in a queue are actually going to be WATCHED.
+ *
+ * This is the number the "N behind" counter shows, and it is deliberately not `queue.length`. With
+ * bookkeeping dwelling at zero, a backlog of 17 where 12 are `*.end` would read "17", plummet to 5
+ * the instant it started, and then crawl — which is not the steady countdown the counter is for.
+ * Thirteen dwelling steps means thirteen things you are going to see.
+ */
+export function watchableCount(causes: readonly StepCause[], pace = 1): number {
+  return causes.filter((c) => dwellFor(c, pace) > 0).length;
+}

src/sim/public-delta.ts

@@ -0,0 +1,194 @@
+/**
+ * Delta for the SEATLESS public frame — v0.8.0, `docs/plans/jitsi-common-board.md` § v0.8.0 § 3.
+ *
+ * `frame-delta.ts` solves the same-shaped problem for a seated player's `Frame` and does NOT carry
+ * over, which is worth saying plainly because reusing it looks obvious and is wrong. It nulls three
+ * TOP-LEVEL keys — `cells`, `facilities`, `division` — and a `PublicFrame` has only the last of
+ * those. Its `cells` and `facilities` live one level down, inside `districts[]`, one entry per seat,
+ * and that is where nearly all of the bytes are.
+ *
+ * **So the districts are deltaed PER SEAT rather than as one array.** One accepted intent changes
+ * one district; comparing the whole array as a unit would resend every other player's board on
+ * every step, which is exactly the cost this exists to avoid. On a four-player table that is three
+ * boards of waste per step, and a step is emitted for every bot move as well as every human one.
+ *
+ * It is also a TRUE PARTIAL rather than a full frame with holes in it, which is the other place
+ * `frame-delta.ts` does not carry over. See `PublicFrameDelta` below for the measurement that forced
+ * that; in short, most steps change one field and shipping the other thirty-four cost 16.7 MB a game.
+ *
+ * The convention that does carry over, kept identical so a reader of one file can read the other:
+ * an absent or `null` field means "unchanged since the last thing sent to this receiver", and the
+ * receiving side merges against the last full frame it actually holds. A first connect or a
+ * reconnect after a gap sends a full frame instead — the display stream resets rather than replaying
+ * (§ v0.8.0).
+ *
+ * Node-free by design, like `frame-delta.ts`: the server and the browser both import this directly.
+ */
+
+import type { CellView, DivisionView, FacilityView, PublicDistrict, PublicFrame } from './view.ts';
+
+/**
+ * One district with its two heavy fields nulled when unchanged.
+ *
+ * `seat` is the identity and is always present — it is what the receiver matches on. `player` and
+ * `name` are always sent too, and deliberately: Employee Rotation moves players between districts,
+ * so the pairing of seat to player is itself news, and it costs two small fields to never have to
+ * reason about whether a relabelling was missed.
+ */
+export type PublicDistrictDelta = Omit<PublicDistrict, 'cells' | 'facilities'> & {
+  cells: CellView[] | null;
+  facilities: FacilityView[] | null;
+};
+
+/** The shared-table half of a `PublicFrame` — everything that is not the Division or a district. */
+type PublicTable = Omit<PublicFrame, 'division' | 'districts'>;
+
+/**
+ * A `PublicFrame` reduced to WHAT CHANGED.
+ *
+ * **Partial, not a full frame with holes**, and that distinction was measured rather than assumed.
+ * The first version of this spread `...next` and nulled only the board fields, so every step shipped
+ * all 35 top-level properties even when the sole change was whose turn it was. Once TODO #18 gave
+ * automatic phases their own steps, most steps became exactly that — a turn handed on, nothing to
+ * look at — and a full 6-day game cost **19.4 MB**, of which **16.7 MB was those silent steps at
+ * ~11 KB each**. As a partial they are a few dozen bytes.
+ */
+export type PublicFrameDelta = {
+  /** Only the shared-table fields whose value differs from the previous frame. */
+  table: Partial<PublicTable>;
+  /** The Division, only when it changed. */
+  division: DivisionView[] | null;
+  /** Only the districts that changed, each carrying only the board fields that changed. */
+  districts: PublicDistrictDelta[];
+};
+
+const same = (a: unknown, b: unknown): boolean => JSON.stringify(a) === JSON.stringify(b);
+
+const TABLE_KEYS = (frame: PublicFrame): (keyof PublicTable)[] =>
+  (Object.keys(frame) as (keyof PublicFrame)[]).filter(
+    (k): k is keyof PublicTable => k !== 'division' && k !== 'districts',
+  );
+
+/**
+ * `previous` is the last public frame actually sent to THIS receiver, or `null` for a first connect
+ * or a reset — in which case everything is sent in full.
+ */
+export function deltaPublicFrame(previous: PublicFrame | null, next: PublicFrame): PublicFrameDelta {
+  const before = new Map(previous?.districts.map((d) => [d.seat, d]) ?? []);
+  const table: Partial<PublicTable> = {};
+  for (const key of TABLE_KEYS(next)) {
+    if (previous === null || !same(previous[key], next[key])) {
+      (table as Record<string, unknown>)[key] = next[key];
+    }
+  }
+  const districts: PublicDistrictDelta[] = [];
+  for (const d of next.districts) {
+    const was = before.get(d.seat);
+    const cells = was && same(was.cells, d.cells) ? null : d.cells;
+    const facilities = was && same(was.facilities, d.facilities) ? null : d.facilities;
+    // A district with nothing new is left out entirely rather than sent as a row of nulls: on a
+    // four-player table three of them are unchanged on every single step.
+    if (was && cells === null && facilities === null && same(was, d)) continue;
+    districts.push({ ...d, cells, facilities });
+  }
+  return {
+    table,
+    division: previous !== null && same(previous.division, next.division) ? null : next.division,
+    districts,
+  };
+}
+
+/** The receiving side: merges a delta back onto the last full public frame this receiver holds. */
+export function applyPublicDelta(previous: PublicFrame | null, delta: PublicFrameDelta): PublicFrame {
+  const base = previous ?? (delta.table as PublicTable);
+  const merged = { ...base, ...delta.table } as PublicTable;
+  const bySeat = new Map((previous?.districts ?? []).map((d) => [d.seat, d]));
+  for (const d of delta.districts) {
+    const was = bySeat.get(d.seat);
+    bySeat.set(d.seat, {
+      ...d,
+      cells: d.cells ?? need(was?.cells, `districts[seat ${d.seat}].cells`),
+      facilities: d.facilities ?? need(was?.facilities, `districts[seat ${d.seat}].facilities`),
+    });
+  }
+  return {
+    ...merged,
+    division: delta.division ?? need(previous?.division, 'division'),
+    districts: [...bySeat.values()].sort((a, b) => a.seat - b.seat),
+  };
+}
+
+/**
+ * A delta that says "unchanged" against a receiver that has nothing to merge onto is a bug in the
+ * SENDER's bookkeeping, not a recoverable state — it means the two sides disagree about what has
+ * been delivered, and quietly producing a frame with a missing board would put a blank district in
+ * front of a player. `frame-delta.ts` throws in the same situation and for the same reason.
+ */
+function need<T>(value: T | undefined, what: string): T {
+  if (value === undefined) {
+    throw new Error(`deltaPublicFrame said "${what}" is unchanged, but there is no previous frame to merge onto`);
+  }
+  return value;
+}
+
+/** A face-up or face-down pile a card can move to or from, as the display addresses it. */
+export type PileKey = 'home' | 'salvage' | `dept${number}`;
+
+/**
+ * WHICH PILES A STEP MOVED — derived, never sent.
+ *
+ * The receiver already holds the frame before a step and the frame after it, so which pile changed
+ * is a diff rather than something the wire has to carry. That matters twice over: nothing is added
+ * to the protocol, and it cannot drift out of step with the projection the way a hand-maintained
+ * hint would.
+ *
+ * WHY IT IS NEEDED AT ALL. A player watching somebody else draw a card sees seven seconds of an
+ * unchanged board — the step holds the screen, and the only thing that moved is a number in a panel
+ * they were not looking at. Jesse, playing v0.8.0.4 at 10×: *"many operations still occurred too fast
+ * for me to see"*, which was never about duration. Lighting the pile is what tells the eye where.
+ *
+ * WHAT EACH ACTION MOVES, measured across four seeds rather than reasoned about:
+ *
+ * | intent                  | piles                                                    |
+ * | ----------------------- | -------------------------------------------------------- |
+ * | `draw.fromHomeOffice`   | `home` — the COUNT only; the card itself stays private    |
+ * | `draw.fromDepartment`   | that `dept`, and `home` too when the pile refills from it |
+ * | `card.discard`          | that `dept`                                               |
+ * | `card.play`             | `salvage`, or nothing here when it lands on the board      |
+ * | switching, new trains   | nothing here — those show on the board itself             |
+ */
+/**
+ * Mainline cards that became a different card between two public boards — a Realignment, which is the
+ * one play that changes the Division itself.
+ *
+ * Playtest, 2026-09-15: *"is it possible to flash the mainline card when it gets changed by realignment?
+ * This would be more obvious to see what's happening on the map."* Detected the same way `changedPiles`
+ * detects a pile moving — by comparing the two boards the queue already holds — rather than by reading
+ * the event, so the flash lands with the step that shows it and not when the intent arrived.
+ */
+export function changedDivisionCards(before: PublicFrame | null, after: PublicFrame): number[] {
+  if (before === null) return [];
+  const out: number[] = [];
+  after.division.forEach((node, i) => {
+    const was = before.division[i];
+    if (was && was.kind === 'ml' && node.kind === 'ml' && was.label !== node.label) out.push(i);
+  });
+  return out;
+}
+
+export function changedPiles(before: PublicFrame | null, after: PublicFrame): PileKey[] {
+  if (before === null) return [];
+  const out: PileKey[] = [];
+  if (before.deck !== after.deck) out.push('home');
+  after.departmentDepth.forEach((depth, i) => {
+    // The TOP as well as the depth: taking the face-up card and replacing it leaves the count alone
+    // and changes the card everybody can see, which is the half that matters to a watcher.
+    if (before.departmentDepth[i] !== depth || before.departments[i] !== after.departments[i]) {
+      out.push(`dept${i}`);
+    }
+  });
+  if (before.salvage.depth !== after.salvage.depth || before.salvage.top !== after.salvage.top) {
+    out.push('salvage');
+  }
+  return out;
+}

src/sim/replay.ts

@@ -34,6 +34,8 @@ import type { Intent } from '../engine/intents.ts';
 import { legalActions } from '../engine/legal.ts';
 import { createGame } from '../engine/setup.ts';
 import type { Facility, GameConfig, GameState } from '../engine/state.ts';
+import { actingPlayer } from '../engine/state.ts';
+import { reasonSentence } from '../web/panels.ts';
 import { developerBot, lastChoiceReason } from './bot.ts';
 import { carLabel, cuesFor, idleNote, isVisible, narrate } from './narrate.ts';
 // The view-model lives in its own module so the browser build can import it without dragging in
@@ -77,6 +79,8 @@ export function record(seed: number, length: GameLength, maxSteps = 100_000): Re
   const narrateCtx = {
     cardName: (id: string) => cardName(s, id),
     trainName: (id: string) => trainName(s, id),
+    // A player index is not a seat index, so the fallback names no number at all — see `web/game.ts`.
+    playerName: (p: number) => s.players[p]?.name ?? 'another player',
   };
 
   // Tracks whether a phase did anything, so an empty one can say so rather than ending silently.
@@ -135,7 +139,7 @@ export function record(seed: number, length: GameLength, maxSteps = 100_000): Re
     if (s.status === 'finished') break;
     if (!r.needsInput) continue;
 
-    const actor = s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
+    const actor = actingPlayer(s);
     if (actor === null) break;
     const options = legalActions(s, actor);
     if (options.length === 0) break;
@@ -147,12 +151,26 @@ export function record(seed: number, length: GameLength, maxSteps = 100_000): Re
     push(applied.events);
   }
 
+  /**
+   * IN WORDS, NOT AS AN ENUM (`TODO.md` #34). This heading read `loss — revenueFloor`, which is
+   * exactly the defect Gitea#16 was filed about on the playable page — it just outlived the fix
+   * here, because nothing player-facing pointed at it. `reasonSentence` is shared rather than
+   * reimplemented, so the replay and the results screen cannot end up explaining the same ending
+   * two different ways.
+   *
+   * Fed the LAST frame, which is the state the outcome was decided in and is already recorded.
+   * Tags are stripped: this lands in an `<h1>` and in a console line, neither of which wants markup.
+   */
   const o = s.outcome;
+  const last = frames[frames.length - 1];
+  const why = o && last ? reasonSentence(last, o, last.day).replace(/<[^>]+>/g, '') : '';
   return {
     seed,
     length,
     frames,
-    outcome: o ? `${o.result} — ${o.reason} · final Revenue ${s.players[0]?.revenue ?? 0}` : 'unfinished',
+    outcome: o
+      ? `${o.result === 'win' ? 'won' : 'lost'} — ${why} Final Revenue ${s.players[0]?.revenue ?? 0}.`
+      : 'unfinished',
   };
 }
 
@@ -214,7 +232,7 @@ export function compress(frames: Frame[]): Packed {
       const fi = c.facility ? f.facilities.indexOf(c.facility) : -1;
       // `trains` rides whole rather than being interned: it changes almost every frame, so a table
       // of them would be as long as the frames are and buy nothing.
-      return [ci, wi, c.enhancements, c.cars, fi, c.trains, c.adTracks, c.enhancementsWhat, c.standingWest];
+      return [ci, wi, c.enhancements, c.cars, fi, c.trains, c.adTracks, c.enhancementsWhat, c.standingWest, c.enhancementsSpent];
     });
     return { ...f, cells } as unknown as Frame;
   });
@@ -248,7 +266,7 @@ export function rehydrateCells(
   facs: unknown[],
 ): unknown[] {
   return packed.map((row) => {
-    const p = row as [number, number, string[], string[], number, unknown, unknown, string[], number];
+    const p = row as [number, number, string[], string[], number, unknown, unknown, string[], number, boolean[]];
     const c = cards[p[0]] as [number, number, string, string, boolean, string[]];
     // Tolerant the same way `standingWest` below is: an array rides through as-is, a lone object
     // (an older recording's singular `train`) is wrapped into a one-train roster, and null or
@@ -268,6 +286,10 @@ export function rehydrateCells(
       // cut ahead of or behind the engine exactly as the live board does. Absent in older recordings,
       // which read as 0 — the whole cut east of the engine, which is what they used to draw anyway.
       standingWest: p[8] ?? 0,
+      // Which dispatch devices were spent (#101), so a replay strikes a used Radio through exactly
+      // as the live board does. Absent in recordings made before it existed, which read as no
+      // device spent — the same thing they drew at the time, so an old replay is unchanged.
+      enhancementsSpent: p[9] ?? [],
     };
   });
 }

src/sim/save-replay.ts

@@ -52,6 +52,21 @@ export type PlayedGame = {
 export function playForReplay(seed: number, policy: BotPolicy, maxTurns = 50_000): PlayedGame {
   const game = newGame(seed);
   for (let t = 0; t < maxTurns; t++) {
+    /**
+     * §3.3, EXTENDED PLAY (Gitea#11) — a recorded replay is a game played to its end.
+     *
+     * The timetable running out leaves the game on "play one more Day?", where `currentActor` is
+     * null and this loop would otherwise stop — recording a file that replays to a question nobody
+     * answered rather than to a finished game. A recording bot plays the timetable it was dealt, the
+     * same rule `playGame` follows, so it declines and the file ends where a real game would.
+     */
+    if (game.state.status === 'awaitingExtension') {
+      const voter = game.state.extensionVotes.findIndex((v) => v === null);
+      if (voter < 0) break;
+      if (!submit(game, { type: 'game.extend', player: voter, agree: false }, voter)) break;
+      continue;
+    }
+
     const actor = currentActor(game);
     if (actor === null) break;
     const options = legalActions(game.state, actor);

src/sim/switch-planner.ts

@@ -0,0 +1,347 @@
+/**
+ * Component 17b — planning a whole switching turn before making the first Move.
+ *
+ * Dev-side, like the rest of the bot. The developer bot's switching branch chooses ONE move at a time
+ * from a ladder of rules, and its own comment names what that cannot do: "a strong player would use
+ * the six Moves to re-order the consist — that is the game's central switching puzzle, and this bot
+ * does not attempt it." This attempts it, for one turn at a time.
+ *
+ * WHY SEARCH IS FAIR HERE. A switching turn draws no card and rolls no die, so trying sequences on a
+ * copy of the game is exactly what a player does by looking at the board. The score below reads only
+ * what a player can see — the district, the cars on the trains, the facilities — and never the deck.
+ *
+ * WHY NOT EVERY SEQUENCE. Measured 2026-09-14 over 30 switching turns from bot games: a median turn
+ * reaches 229 distinct positions, but 11 of 30 passed 20,000, because setting cars out is free and a
+ * crew can leave them in a great many places. So the search keeps the best `beam` positions at each
+ * step and stops at `budget` positions tried. Small turns are searched completely inside that.
+ *
+ * THE SCORE IS OF WHERE THE TURN ENDS, not of what it did, and it starts from Jesse's ruling
+ * (2026-09-14): "players will attempt to deliver / pick up cars even if it delays trains." So a car
+ * put where it can be worked is worth a point, and a train left away from the Office costs a quarter
+ * of one. The weights are a starting point to measure, not a result.
+ */
+
+import { areaAtSeat, areaOf, commitEvents, facilityCarTypes, prepareIntent, withRouteCache } from '../engine/apply.ts';
+import { badlyMadeUp, isExpedited } from '../engine/advance.ts';
+import { MAX_CONSIST } from '../engine/content.ts';
+import type { Intent } from '../engine/intents.ts';
+import { legalSwitchingActions } from '../engine/legal.ts';
+import { cloneTally, coordKey, seatOf, turnOf } from '../engine/state.ts';
+import type { Facility, GameState, GridCoord, PlayerIndex, RollingStock, TrackCard } from '../engine/state.ts';
+
+export const SWITCH_WEIGHTS = {
+  /** A car standing where its industry can load or unload it — the point of switching. */
+  spot: 1.0,
+  /** The same, past what the industry's boxes can work at once. */
+  spotBeyondCapacity: 0.25,
+  /** A car the industry cannot work, taking room on its track. */
+  junkOnIndustry: -0.5,
+  /** A finished car — loaded at a shipper, emptied at a receiver — still waiting to be lifted. */
+  finishedLeft: -0.15,
+  /** A car on one of this district's trains that some industry here would work. */
+  carriedWanted: 0.35,
+  /** The same car left on ordinary track, where a later turn can fetch it. */
+  stagedWanted: 0.2,
+  /** A coach kept with its train, or parked at the Office where §A.4 allows it. */
+  coachWithTrain: 0.3,
+  /** A coach left anywhere else, where no Porter can work it. */
+  coachStranded: -0.3,
+  /** Anything but a coach standing on the Office square — the next arrival collides (§8.3). */
+  fouling: -3,
+  /** A train that ends the turn away from the Office and so cannot highball next Mainline Phase. */
+  trainAway: -0.25,
+  /** On top of that, an expedited train — Q3 charges a Revenue point every Phase it is away. */
+  expeditedAway: -1.0,
+  /** A train that could not leave even from the Office — engine buried, caboose mid-train (§8.2). */
+  notMadeUp: -0.6,
+  /** Tie-breaks, so equal outcomes prefer the plan that does less. */
+  perMove: -0.02,
+  perSetOut: -0.005,
+  /** A maneuver card spent — Flying Switch — so the planner plays one only when it buys something. */
+  cardSpent: -0.1,
+} as const;
+
+export type PlanOptions = {
+  budget: number;
+  beam: number;
+  /**
+   * Search Flying Switch alongside Moves, set-outs and sorts. On by default but UNMEASURED: the card
+   * is dealt 0 copies (Jesse, 2026-08-26), so over 400 paired seeds turning it on changed nothing —
+   * it is here so the planner can use the card the day it is dealt again.
+   */
+  flyingSwitch?: boolean;
+};
+/**
+ * Measured 2026-09-14, paired over 400 seeds against 3000/48: 2000/32 cost −0.02 ± 0.01 (t = −1.68,
+ * inside the noise) at half the time per turn; 1000/24 cost −0.06 ± 0.02 (t = −2.65) for little more.
+ */
+export const DEFAULT_PLAN: PlanOptions = { budget: 2000, beam: 32, flyingSwitch: true };
+
+export type SwitchPlan = {
+  /** The intents to submit, in order. Empty when nothing beats stopping where the crew stands. */
+  steps: Intent[];
+  /** `switchFingerprint` before each step, and after the last — so a caller can tell it is on plan. */
+  keys: string[];
+  rootScore: number;
+  score: number;
+  /** Positions tried. */
+  expanded: number;
+  /** False when the budget ran out before the search did. */
+  complete: boolean;
+};
+
+/**
+ * A copy of the game that a switching intent can be applied to without touching the original.
+ *
+ * NOT `structuredClone`, of the state or even of the district. A switching intent writes only the
+ * cars standing on cards, the industry tracks, the district's A/D and held lists, the consist and
+ * position of the trays standing in it, this player's turn and the tally — so exactly those arrays are
+ * copied and everything else is shared by reference. Measured 2026-09-14, deep-cloning the district
+ * was 44% of all planning time.
+ *
+ * `test/switch-planner.test.ts` proves across real games that planning leaves the original
+ * byte-identical — which is what fails first if a reducer ever starts writing somewhere new, or
+ * starts mutating a car or a card in place instead of replacing it.
+ */
+export function forkForSwitching(s: GameState, player: PlayerIndex): GameState {
+  const seat = seatOf(s, player);
+  const area = areaAtSeat(s, seat);
+  const grid = new Map<string, TrackCard>();
+  for (const [key, card] of area.grid) {
+    const f = card.facility;
+    grid.set(key, {
+      ...card,
+      standing: [...card.standing],
+      facility: f ? { ...f, industryTrack: { cars: [...f.industryTrack.cars] } } : f,
+    });
+  }
+  const officeAreas = new Map(s.officeAreas);
+  officeAreas.set(seat, {
+    ...area,
+    grid,
+    adOccupancy: [...area.adOccupancy],
+    heldAtLimits: [...area.heldAtLimits],
+    dispatchUsedToday: [...area.dispatchUsedToday],
+  });
+  const trays = new Map(s.trays);
+  for (const [id, t] of s.trays) {
+    if (t.position.at === 'grid' && t.position.seat === seat) trays.set(id, { ...t, consist: [...t.consist] });
+  }
+  const turns = new Map(s.turns);
+  const turn = s.turns.get(player)!;
+  turns.set(player, { ...turn, freightWorked: { ...turn.freightWorked } });
+  // Flying Switch spends its card (`spendCard`): the hand map is rewritten and the Salvage Yard grows.
+  const decks = { ...s.decks, hands: new Map(s.decks.hands), salvageYard: [...s.decks.salvageYard] };
+  return { ...s, officeAreas, trays, turns, decks, tally: cloneTally(s.tally) };
+}
+
+const carList = (xs: readonly RollingStock[]): string =>
+  xs.map((c) => `${c.type}${c.loaded ? '+' : '-'}${c.origin ?? ''}`).join(',');
+
+/**
+ * Everything a switching intent can change, as a string — two positions with the same fingerprint
+ * are the same position as far as the rest of the turn is concerned. Identical cars are not told
+ * apart, which is right: no intent names a car.
+ */
+export function switchFingerprint(s: GameState, player: PlayerIndex): string {
+  const seat = seatOf(s, player);
+  const parts: string[] = [];
+  for (const [id, t] of s.trays) {
+    if (t.position.at !== 'grid' || t.position.seat !== seat) continue;
+    const { row, col } = t.position.coord;
+    parts.push(`${id}@${row},${col}/${t.facing}/${t.railFacing ?? ''}/${t.engineAt}:${carList(t.consist)}`);
+  }
+  for (const [key, card] of areaOf(s, player).grid) {
+    const track = card.facility?.kind === 'freight' ? card.facility.industryTrack.cars : null;
+    if (card.standing.length === 0 && card.standingWest === 0 && (track?.length ?? 0) === 0) continue;
+    parts.push(`${key}=${carList(card.standing)}|${card.standingWest}|${track ? carList(track) : ''}`);
+  }
+  const turn = turnOf(s, player);
+  parts.push(`m${turn.movesRemaining}`, JSON.stringify(turn.freightWorked), `h${(s.decks.hands.get(player) ?? []).join(',')}`);
+  return parts.join(';');
+}
+
+/**
+ * §9.3 — an outbound industry loads EMPTY cars of its commodity, an inbound one unloads LOADED ones —
+ * but never a load that was made in this same district (v0.4.9e, `LOADED_IN_THIS_DISTRICT`).
+ */
+function works(f: Facility, c: RollingStock, seat: number): boolean {
+  if (f.kind !== 'freight' || !facilityCarTypes(f).includes(c.type)) return false;
+  return (!c.loaded && f.allows.outbound) || (c.loaded && f.allows.inbound && c.origin !== seat);
+}
+
+/**
+ * The car an industry has finished with. Only decidable at a one-way industry: at one that both
+ * ships and receives, a loaded car may be a delivery still waiting to be unloaded.
+ */
+function finished(f: Facility, c: RollingStock): boolean {
+  if (f.kind !== 'freight' || !facilityCarTypes(f).includes(c.type)) return false;
+  if (f.allows.outbound && !f.allows.inbound) return c.loaded;
+  if (f.allows.inbound && !f.allows.outbound) return !c.loaded;
+  return false;
+}
+
+const same = (a: GridCoord, b: GridCoord): boolean => a.row === b.row && a.col === b.col;
+
+/** How good this district's position is for the rest of the game, in rough Revenue points. */
+export function evaluateSwitching(s: GameState, player: PlayerIndex): number {
+  const W = SWITCH_WEIGHTS;
+  const area = areaOf(s, player);
+  const seat = seatOf(s, player);
+  const officeKey = coordKey(area.officeCoord);
+  const passengerOffice = area.grid.get(officeKey)?.facility?.kind === 'passenger';
+  let v = 0;
+
+  const withRoom: Facility[] = [];
+  for (const card of area.grid.values()) {
+    const f = card.facility;
+    if (!f || f.kind !== 'freight') continue;
+    if (f.industryTrack.cars.length < MAX_CONSIST) withRoom.push(f);
+    const cap = Math.max(1, f.capacity.outbound + f.capacity.inbound);
+    let working = 0;
+    for (const c of f.industryTrack.cars) {
+      if (works(f, c, seat)) v += ++working <= cap ? W.spot : W.spotBeyondCapacity;
+      else if (finished(f, c)) v += W.finishedLeft;
+      else v += W.junkOnIndustry;
+    }
+  }
+  const wanted = (c: RollingStock): boolean => withRoom.some((f) => works(f, c, seat));
+
+  for (const [key, card] of area.grid) {
+    if (card.facility?.kind === 'freight') continue;
+    const atOffice = key === officeKey;
+    for (const c of card.standing) {
+      if (c.type === 'coach') v += atOffice && passengerOffice ? W.coachWithTrain : W.coachStranded;
+      else if (atOffice) v += W.fouling;
+      else if (wanted(c)) v += W.stagedWanted;
+    }
+  }
+
+  for (const t of s.trays.values()) {
+    if (t.position.at !== 'grid' || t.position.seat !== seat) continue;
+    for (const c of t.consist) {
+      if (c.type === 'coach') v += passengerOffice ? W.coachWithTrain : 0;
+      else if (wanted(c)) v += W.carriedWanted;
+    }
+    if (t.trainNumber === null) continue;
+    if (!same(t.position.coord, area.officeCoord)) {
+      v += W.trainAway;
+      if (isExpedited(t)) v += W.expeditedAway;
+    }
+    if (badlyMadeUp(t)) v += W.notMadeUp;
+  }
+  return v;
+}
+
+/**
+ * For ORDERING the beam only, never for choosing the plan: a Move toward an industry changes nothing
+ * the score can see until the car is set out, so without this the beam would drop the approach in
+ * favour of positions that merely look tidy.
+ */
+function approach(s: GameState, player: PlayerIndex): number {
+  const area = areaOf(s, player);
+  const seat = seatOf(s, player);
+  const targets: { at: GridCoord; f: Facility }[] = [];
+  for (const [key, card] of area.grid) {
+    const f = card.facility;
+    if (!f || f.kind !== 'freight' || f.industryTrack.cars.length >= MAX_CONSIST) continue;
+    const [row, col] = key.split(',').map(Number);
+    targets.push({ at: { row: row!, col: col! }, f });
+  }
+  let bonus = 0;
+  for (const t of s.trays.values()) {
+    if (t.position.at !== 'grid' || t.position.seat !== seat) continue;
+    const here = t.position.coord;
+    for (const c of t.consist) {
+      let nearest = Infinity;
+      for (const { at, f } of targets) {
+        if (works(f, c, seat)) nearest = Math.min(nearest, Math.abs(at.row - here.row) + Math.abs(at.col - here.col));
+      }
+      if (nearest !== Infinity) bonus += 0.1 / (1 + nearest);
+    }
+  }
+  return bonus;
+}
+
+const SEARCHED = new Set<Intent['type']>(['switch.move', 'switch.dropCars', 'switch.sortConsist']);
+
+type Node = {
+  s: GameState;
+  steps: Intent[];
+  keys: string[];
+  moves: number;
+  setOuts: number;
+  cards: number;
+  score: number;
+  rank: number;
+};
+
+/** The best way found to spend what is left of this switching turn. Never mutates `s`. */
+export function planSwitchingTurn(
+  s: GameState,
+  player: PlayerIndex,
+  opts: PlanOptions = DEFAULT_PLAN,
+): SwitchPlan {
+  const W = SWITCH_WEIGHTS;
+  const scoreOf = (st: GameState, moves: number, setOuts: number, cards: number): number =>
+    evaluateSwitching(st, player) + moves * W.perMove + setOuts * W.perSetOut + cards * W.cardSpent;
+  const searched = (type: Intent['type']): boolean =>
+    SEARCHED.has(type) || (opts.flyingSwitch === true && type === 'maneuver.flyingSwitch');
+
+  const rootKey = switchFingerprint(s, player);
+  const rootScore = scoreOf(s, 0, 0, 0);
+  const root: Node = { s, steps: [], keys: [rootKey], moves: 0, setOuts: 0, cards: 0, score: rootScore, rank: rootScore };
+  let best = root;
+  const seen = new Set([rootKey]);
+  let frontier: Node[] = [root];
+  let expanded = 0;
+  let complete = true;
+
+  search: while (frontier.length > 0) {
+    const next: Node[] = [];
+    for (const node of frontier) {
+      const movesLeft = turnOf(node.s, player).movesRemaining;
+      // Every candidate is decided against THIS position, inside one route cache, and only then applied
+      // to its own copy: deciding on the copy would re-walk routes the listing had just walked.
+      const decided = withRouteCache(node.s, () =>
+        legalSwitchingActions(node.s, player)
+          .filter((i) => searched(i.type) && (i.type === 'switch.dropCars' || movesLeft >= 1))
+          .map((i) => ({ i, r: prepareIntent(node.s, player, i) })),
+      );
+      for (const { i, r } of decided) {
+        if (expanded >= opts.budget) {
+          complete = false;
+          break search;
+        }
+        expanded++;
+        if (!r.ok) continue;
+        const f = forkForSwitching(node.s, player);
+        commitEvents(f, r.events);
+        const key = switchFingerprint(f, player);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const setOut = i.type === 'switch.dropCars';
+        const moves = node.moves + (setOut ? 0 : 1);
+        const setOuts = node.setOuts + (setOut ? 1 : 0);
+        const cards = node.cards + (i.type === 'maneuver.flyingSwitch' ? 1 : 0);
+        const score = scoreOf(f, moves, setOuts, cards);
+        const child: Node = {
+          s: f,
+          steps: [...node.steps, i],
+          keys: [...node.keys, key],
+          moves,
+          setOuts,
+          cards,
+          score,
+          rank: score + approach(f, player),
+        };
+        if (score > best.score + 1e-9) best = child;
+        next.push(child);
+      }
+    }
+    // A stable sort, so equal ranks keep `legalActions` order and the bot stays deterministic.
+    frontier = next.length > opts.beam ? next.sort((a, b) => b.rank - a.rank).slice(0, opts.beam) : next;
+  }
+
+  return { steps: best.steps, keys: best.keys, rootScore, score: best.score, expanded, complete };
+}

src/sim/turnchart.ts

@@ -19,6 +19,8 @@ export type TurnChartFrame = {
   phase: string;
   phaseKey: string;
   actor: number | null;
+  /** What the game has stopped to ask, when it has. Null while a phase is simply running. */
+  awaiting?: { asks: string; train: string } | null;
 };
 
 /**
@@ -53,7 +55,7 @@ export function turnChartHtml(f: TurnChartFrame, actorName: string | null, super
       // Says WHO builds, which is the question this phase actually raises at a table: the round
       // starts with the Superintendent and works left, one car each, repeating (§7, Gap 9) — not
       // with whoever played the card. An Extra is the exception: its player loads it as they choose.
-      tip: 'Timetabled trains for this Stage are built: starting with the Superintendent and working left, each player adds ONE car, going round again until the consist is full or the Division Yard has nothing suitable. New timetabled trains are rolled onto the timetable. Held trains are built. An Extra is loaded by the player who played it.',
+      tip: 'Timetabled trains for this Stage are built: each player adds ONE car at a time, starting with the Superintendent and working eastward, repeating until the consist is full or the Division Yard has nothing suitable. New timetabled trains are rolled onto the timetable. Held trains are built. An Extra is loaded by the player who played it.',
       // a locomotive being made up
       icon: '<rect class="ic" x="2" y="6" width="9" height="7" rx="1"/><path class="ic" d="M11 9h4v4h-4"/><circle class="icf" cx="5" cy="15" r="1.5"/><circle class="icf" cx="13" cy="15" r="1.5"/>',
     },
@@ -93,8 +95,39 @@ export function turnChartHtml(f: TurnChartFrame, actorName: string | null, super
     );
   }).join('');
 
-  // An automatic phase is waiting on nobody, and saying so is more use than a blank.
-  const who = actorName ?? 'nobody — the Division is running itself';
+  /**
+   * WAITING ON WHOM, AND FOR WHAT.
+   *
+   * "nobody — the Division is running itself" is true of an automatic phase and was being printed
+   * over the top of three interruptions that are emphatically waiting on a person: §8.1's clearance
+   * ruling, the Yard Office offer and the Red Flag prompt. The Frame carried the phase's actor,
+   * which is null throughout the Mainline Phase, so a game stopped on a named player's decision
+   * reported that nobody was holding it up (Jesse, 2026-08-30). `Frame.actor` is `actingPlayer` now
+   * and answers who; `awaiting` says what, because "waiting on Bob" with no more than that is a
+   * game that looks stuck to everyone except Bob.
+   */
+  /**
+   * AN AUTOMATIC PHASE WAITS ON NOBODY, so it says what it is DOING instead of apologising.
+   *
+   * "nobody — the Division is running itself" reached the answer by negation, and left a player
+   * reading a line whose subject was an absence (Jesse, playtest 2026-09-16: it should say "waiting
+   * on <player>", or describe what the engine is doing — "the Division is moving trains during the
+   * mainline phase"). The phase's NAME is already printed on the line directly above this one, so
+   * these describe the work rather than repeating the label.
+   */
+  const DOING: Record<string, string> = {
+    mainline: 'the Division is moving trains',
+    newTrain: "the Division is building this Stage's trains",
+    loadUnload: 'the Division is working cargo',
+    shiftChange: 'the Division is changing shifts',
+  };
+  // Local Operations always has an actor, so its entry is the fallback rather than a case.
+  const who = actorName ?? DOING[f.phaseKey] ?? 'the Division is running itself';
+  // Only a person is WAITED ON. The Division is not waiting; it is working.
+  const waiting = actorName === null ? '' : 'waiting on ';
+  const asked = f.awaiting
+    ? ` <span class="tc-asks">${esc(f.awaiting.asks)} · ${esc(f.awaiting.train)}</span>`
+    : '';
   const fedora =
     superName === null
       ? ''
@@ -105,9 +138,12 @@ export function turnChartHtml(f: TurnChartFrame, actorName: string | null, super
     `<div class="tc-when"><b>Day ${f.day}</b><span>Stage ${f.stage} of 12</span>` +
     `<span class="dim">${esc(f.clock)}</span></div>` +
     `<div class="tc-now">phase <b>${esc(f.phase)}</b></div>` +
-    `<div class="tc-who">waiting on <b>${esc(who)}</b></div>` +
-    fedora +
-    `<ol class="tc-phases">${chips}</ol>`
+    `<div class="tc-who">${waiting}<b>${esc(who)}</b>${asked}</div>` +
+    // THE FEDORA RIDES AT THE END OF THE PHASE ROW (`TODO.md` #29, Jesse). It sat on its own line
+    // between the phases and everything above them, which put a thing that changes every third
+    // Stage in the middle of the things that change every Stage. The row it belongs beside is the
+    // one whose last chip is Supervisor Shift — the phase that passes it.
+    `<div class="tc-row"><ol class="tc-phases">${chips}</ol>${fedora}</div>`
   );
 }
 
@@ -130,12 +166,18 @@ export const TURNCHART_CSS = `
    says "Player Solitaire", so the chart should agree. In multiplayer this is the thing a table
    glances at most often, so it gets its own chip rather than hiding in the phase text. */
 .tc-who{display:flex;align-items:center;gap:6px;font-size:12px;color:#8b94a3}
+.tc-asks{color:#a99ac4;font-style:italic}
 .tc-who b{color:#b98cf0;background:rgba(150,110,230,.16);border:1px solid #8b6ad0;
   border-radius:11px;padding:1px 9px;font-size:12px}
 /* WHO HOLDS THE FEDORA. Violet like the rest of the chart — this is "where you are" news, not
    something to press — but unfilled, so the eye still lands on "waiting on" first: that is the one
    that changes every turn, while this changes four times a Day. */
-.tc-super{display:flex;align-items:center;gap:6px;font-size:12px;color:#8b94a3;cursor:help}
+/* The phase row and the Fedora on one line, the hat pushed to the far end (TODO.md #29): the row
+   is the Stage, and the Superintendent is who holds it. Wraps under the phases on a narrow screen
+   rather than squeezing the chips. */
+.tc-row{display:flex;align-items:center;gap:12px;flex-wrap:wrap}
+.tc-row ol.tc-phases{flex:1 1 auto}
+.tc-super{margin-left:auto;display:flex;align-items:center;gap:6px;font-size:12px;color:#8b94a3;cursor:help}
 .tc-super b{color:#cbb6f2;border:1px solid #6b5a94;border-radius:11px;padding:1px 9px;font-size:12px}
 ol.tc-phases{display:flex;gap:6px;list-style:none;margin:0;padding:0;flex-wrap:wrap}
 .tc-phase{display:flex;align-items:center;gap:6px;border:1px solid #2c333d;border-radius:14px;

src/sim/view.ts

@@ -10,11 +10,13 @@
  * drift into two different pictures of the same board.
  */
 
+import { isExpedited, regionOfTransit } from '../engine/advance.ts';
 import {
   areaAtSeat,
   areaOf,
   destinationsFor,
   facilityCarType,
+  isBeingMadeUp,
   laborersLeft,
   movesFor,
   ownCutFor,
@@ -26,15 +28,15 @@ import {
 import {
   ACTION_CARDS,
   ENHANCEMENT_CARDS,
-  HAND_LIMIT,
   MAINLINE_MODIFIER_CARDS,
   MAINLINE_PROFILES,
   MANEUVER_CARDS,
   MODIFIER_PROFILES,
   REALIGNMENTS,
-  REGIONS_PER_MAINLINE_CARD,
   OFFICE_ORDER,
   SPACE_USE_CARDS,
+  STAGES_PER_SHIFT,
+  crewTrayCount,
   enhancementRule,
   enhancementText,
   industryProfile,
@@ -46,9 +48,9 @@ import {
   mainlineDescription,
 } from '../engine/content.ts';
 import type { Intent } from '../engine/intents.ts';
-import type { Facility, GameConfig, GameState, PlayerIndex, SeatIndex, TrackCard, TurnoutOrientation } from '../engine/state.ts';
-import { carsOn, playerAtSeat, railFacingOf, seatOf, turnOf } from '../engine/state.ts';
-import type { Hand, HouseRules, TrackGeometry } from '../engine/content.ts';
+import type { Facility, GameConfig, GameState, OfficeArea, PlayerIndex, SeatIndex, TrackCard, TurnoutOrientation } from '../engine/state.ts';
+import { actingPlayer, carsOn, overHandLimit, playerAtSeat, railFacingOf, seatOf, turnOf } from '../engine/state.ts';
+import type { Direction, Hand, HouseRules, TrackGeometry } from '../engine/content.ts';
 import type { Port } from '../engine/track.ts';
 import { connectionsFor, slopeOfPair, variantsFor } from '../engine/track.ts';
 import type { Impediment } from './narrate.ts';
@@ -73,6 +75,14 @@ export type CellView = {
    * `toString()`), so it cannot reach the card catalogue itself.
    */
   enhancementsWhat: string[];
+  /**
+   * Which of those enhancements is SPENT for today, in the same order (#101).
+   *
+   * Only ever true of a dispatch device — Telegraph, Telephone, Radio — which is "once a day". The
+   * reason and the Fedora caveat are already written into `enhancementsWhat`; this is the flag the
+   * board styles from, because `board-svg.ts` imports nothing and cannot work it out for itself.
+   */
+  enhancementsSpent: boolean[];
   /**
    * EVERY TRAIN STANDING HERE, in order, each with the engine in it and which way it points.
    *
@@ -104,6 +114,15 @@ export type CellView = {
      * standing in front of them — the card is face down in a box somewhere by then.
      */
     what: string;
+    /**
+     * HELD AT THE LIMITS BY AN INTERLOCKING, rather than standing on this square (#99).
+     *
+     * The engine keeps these in `OfficeArea.heldAtLimits` and deliberately does NOT move
+     * `tray.position` onto the grid — a held train is not on a square anything may switch it from.
+     * So the map has to draw it from the held list, and mark it, or it reads as an ordinary arrival
+     * the player could work.
+     */
+    heldAtLimits?: true;
   }[];
   /**
    * Office card only: how many A/D tracks the tier has — null everywhere else.
@@ -258,6 +277,15 @@ export type TrainChip = {
    * it belongs in the tooltip, where there is room to say which it is.
    */
   stagesLeft?: number;
+  /**
+   * BEING MADE UP RIGHT NOW — §7's round, one car at a time, at a Division Point.
+   *
+   * The make-up panel names the train and the yard chips load it, and both are in the right-hand
+   * column; the train itself is drawn on the Division strip at the top left, looking exactly like
+   * every other chip on the map. So the two halves of the same activity never pointed at each other
+   * (Jesse, playtest 2026-09-16). Absent rather than false everywhere else, like `region` above.
+   */
+  beingMadeUp?: true;
 };
 /**
  * One card of a player's Running Track, as the Division sees it.
@@ -320,6 +348,16 @@ export type DivisionView = {
   what?: string;
   /** Mainline cards only: how many regions the card is divided into (§2.1 — two). */
   regions?: number;
+  /**
+   * Office nodes only: a Red Flag standing at this Office's Limits, and which approach it guards
+   * (#94). `null` when none is out.
+   *
+   * PUBLIC STATE, and the reason it has to be here: the flag is a token set out ON the board that
+   * holds the next train arriving from that side until it is spent. It was announced once in the
+   * log and then drawn nowhere, so a train would stop short with its only explanation scrolled out
+   * of the panel.
+   */
+  redFlag?: string | null;
   /** Office nodes only: the Running Track, Limits to Limits, west to east. */
   running?: RunningCardView[];
   /** Office nodes only: whose district this is. */
@@ -354,7 +392,21 @@ export type Frame = {
    * replay recorder, which sees the events; the live game keeps its own on the Game object.
    */
   cues?: string[];
+  /**
+   * WHO THE GAME IS WAITING ON — the phase's actor, or the owner of a pending interruption when
+   * there is one. It carried `clock.currentActor` alone until 2026-08-30, which is null during the
+   * Mainline Phase, so a game stopped dead on a Superintendent's clearance ruling reported "waiting
+   * on nobody — the Division is running itself" while it waited on a named person to click
+   * (reported by Jesse). The engine had the answer the whole time in `actingPlayer`.
+   */
   actor: number | null;
+  /**
+   * WHAT that player is being asked, when the game is stopped on a question rather than a turn.
+   * Null whenever the phase is simply running. Naming the person is not enough on its own: three
+   * different interruptions can be waiting, and "waiting on Bob" with no more than that is a game
+   * that looks stuck to everyone except Bob.
+   */
+  awaiting: { asks: string; train: string } | null;
   superintendent: number;
   revenue: number;
   /**
@@ -395,9 +447,29 @@ 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'];
+  /**
+   * §3.3, EXTENDED PLAY (Gitea#11). `days` above stays the ORIGINAL timetable — it is what the
+   * official result was decided at — so the Day the game now runs to is `days + extraDays`.
+   */
+  extraDays: number;
+  /** Per PLAYER, while `status` is `awaitingExtension`. `null` is a seat that has not voted. */
+  extensionVotes: (boolean | null)[];
+  /** The official result, frozen when the original timetable ran out. Null until then. */
+  official: GameState['official'];
+  /**
+   * Gitea#16 — everything interesting that has happened, folded from the event stream.
+   *
+   * Aggregate counts only, which is why it can ride the Frame at all: `test/redaction.test.ts`
+   * proves a Frame carries no other seat's secrets, and a count of trains is nobody's secret. Being
+   * here rather than on a side channel is what gets the results screen the same numbers in
+   * multiplayer as in solitaire, from one implementation.
+   */
+  tally: GameState['tally'];
   /**
    * Every PLAYER's public standing — names and Revenue. "The race is the game" (protocol.md §4).
    *
@@ -415,7 +487,17 @@ export type Frame = {
    * there is only one; the first thing you want to know at a four-player table.
    */
   viewer: number;
-  /** The viewer's position in the west-to-east chain, which is not their player index (§4.4). */
+  /**
+   * The viewer's position in the west-to-east chain, which is not their player index (§4.4).
+   *
+   * CARRIED AHEAD OF ITS CALLER, DELIBERATELY (#45). Nothing renders this today — the 2026-08-30
+   * dead-field audit found it read only by one test, and Jesse deferred the delete-or-document
+   * call. Documenting rather than deleting, because Gitea#20's common board keys every district by
+   * SEAT and resolves the player through `playerAtSeat` (§Employee Rotation moves players between
+   * districts), so a client that must pick its own district out of a seat-keyed board needs exactly
+   * this and cannot derive it from `viewer`. If step 2 ships without using it, delete it then —
+   * this note is the reason it survived one audit, not a permanent exemption from the next.
+   */
   viewerSeat: number;
   /**
    * §4.4's opening D12 per player, and the roll that chose the Superintendent — kept so a client
@@ -648,6 +730,26 @@ function suppressedGrants(modifiers: string[], f: Facility): string[] {
   for (const key of modifiers) {
     const m = MODIFIER_PROFILES.find((p) => p.kind === key);
     if (!m) continue;
+    /**
+     * A WHISTLE POST TAKES NOTHING AT ALL, AND SAYING "IT ONLY RECEIVES" WOULD BE A LIE.
+     *
+     * Jesse, playtest 2026-09-16: a Restaurant appeared to do nothing. It does nothing — a Whistle
+     * Post is not a Passenger Facility, so it allows neither direction and has 0 capacity each way;
+     * the engine's `usableGrant` discards the capacity while the porter is granted regardless, which
+     * leaves a porter with nothing to carry. Playing it there stays LEGAL on Jesse's call, so the
+     * card is not wasted — it starts working the moment the Office is upgraded — but the panel has
+     * to say so, or the player is left believing the card is broken.
+     *
+     * Only a Whistle Post can reach this: every freight flow allows at least one direction, and
+     * every Office above the first allows both.
+     */
+    if (f.kind === 'passenger' && !f.allows.outbound && !f.allows.inbound) {
+      out.push(
+        `${m.name}: DORMANT — a Whistle Post works no passengers at all, so nothing this card ` +
+          `grants is in use yet. It all starts working when the Office is upgraded to a Depot.`,
+      );
+      continue;
+    }
     if (m.addOut > 0 && !f.allows.outbound) {
       out.push(`${m.name}: +${m.addOut} outbound has no effect here — this facility only receives`);
     }
@@ -708,6 +810,39 @@ function baseOf(
  */
 function trainsOnCard(s: GameState, viewerSeat: SeatIndex, key: string): CellView['trains'] {
   const out: CellView['trains'] = [];
+
+  /**
+   * TRAINS HELD AT THE LIMITS — drawn here or drawn nowhere (#99).
+   *
+   * `arriveAtOffice` takes the tray out of the Mainline node's `transits` and, when an Interlocking
+   * saves it from Gap 2d's collision, pushes it onto `heldAtLimits` without giving it a grid
+   * position. The map draws mainline nodes from `transits` and squares from `position.at === 'grid'`
+   * — so between the two the train was drawn in NEITHER, and simply vanished off the board until an
+   * A/D track freed some Stages later.
+   *
+   * At WHICH Limits: the end it came in by. An eastbound train entered from the west, so it is held
+   * at `limitsWest`; a westbound one at `limitsEast`.
+   */
+  const area = areaAtSeat(s, viewerSeat);
+  for (const id of area.heldAtLimits) {
+    const t = s.trays.get(id);
+    if (!t) continue;
+    const at = t.direction === 'east' ? area.limitsWest : area.limitsEast;
+    if (`${at.row},${at.col}` !== key) continue;
+    out.push({
+      trayId: id,
+      label: t.trainNumber === null ? 'crew' : `T${t.trainIsExtra ? 'X' : ''}${t.trainNumber}`,
+      cars: t.consist.map((c) => carLabel(c, viewerSeat)),
+      engineAt: Math.max(0, Math.min(t.consist.length, t.engineAt)),
+      facing: railFacingOf(t),
+      what:
+        'HELD AT THE LIMITS — the Interlocking stopped it on the Limit Track instead of letting it ' +
+        'collide with a full Office. It takes the first A/D track that frees, ahead of any train ' +
+        `arriving after it. ${trainRules(t)}`,
+      heldAtLimits: true,
+    });
+  }
+
   for (const [id, t] of s.trays) {
     if (t.position.at !== 'grid' || t.position.seat !== viewerSeat) continue;
     if (`${t.position.coord.row},${t.position.coord.col}` !== key) continue;
@@ -1025,15 +1160,41 @@ export function describeIntent(s: GameState, i: Intent): string {
       return `${cardName(s, i.cardId)} on ${shortWhere} — ${where}${effect ? `; ${effect}` : ''}`;
     }
     case 'maneuver.redFlags':
-      return `set Red Flags to protect ${trainName(s, i.trayId)} — an approaching train must stop short`;
+      return (
+        `FLAG ${i.side === 'east' ? 'EAST' : 'WEST'} — hold the next ${i.side === 'east' ? 'westbound' : 'eastbound'} ` +
+        'train short of your Limits, so you can finish switching'
+      );
+    // §Q, the out-of-phase play (Gitea#19) — "COLLISION RISK! FLAG AGAINST T2?"
+    case 'mainline.redFlag':
+      return i.flag
+        ? 'FLAG IT — stop the train short of your Limits, spending a Red Flags card'
+        : 'wave it through — let it come in';
+    /**
+     * §11, the Yard Office (Gitea#5). The offer interrupts the Mainline Phase, so the label has to
+     * carry the whole question — there is no surrounding context on screen to lean on, and the
+     * player is being asked about a train they were not otherwise thinking about.
+     */
+    case 'mainline.yardOffice':
+      return i.take
+        ? 'take the YARD OFFICE — straight into the yard, leaving the Train Order Office free'
+        : 'keep it at the Train Order Office — the ordinary arrival, onto an A/D track';
+    // §3.3, extended play (Gitea#11). The results screen draws its own buttons, but a bot reads its
+    // options through this list like any other, and the label is what the history says it chose.
+    case 'game.extend':
+      return i.agree
+        ? 'play one more Day — the result already recorded still stands'
+        : 'end the game here';
     case 'maneuver.flyingSwitch':
       return `Flying Switch ${i.count} car(s) into ${at(i.to)}`;
     case 'mainline.clearance': {
       // The §8.1 ruling is the sharpest decision in the game and read "grant clearance" — no hint
       // that granting it risks a rear-ender, or that refusing merely costs time.
+      // Narrowed to the clearance question: `pendingDecision` is a union since Gitea#5, and only
+      // this member names a train ahead.
       const pending = s.clock.pendingDecision;
-      const who = pending ? trainName(s, pending.train) : 'the train';
-      const ahead = pending ? trainName(s, pending.occupiedBy) : 'the train ahead';
+      const clearance = pending?.kind === 'clearance' ? pending : null;
+      const who = clearance ? trainName(s, clearance.train) : 'the train';
+      const ahead = clearance ? trainName(s, clearance.occupiedBy) : 'the train ahead';
       // NOT "risks a collision, −5". A rear-end on a Mainline card is described by §10 and is what
       // ABS Signals exists to prevent, but no such collision is implemented — granting clearance is
       // currently free. Saying otherwise invents a consequence the engine will never deliver.
@@ -1073,7 +1234,30 @@ export function describeIntent(s: GameState, i: Intent): string {
     case 'redFlag.play':
       return 'play your red flag';
     case 'maneuver.redFlags':
-      return `set Red Flags to protect ${trainName(s, i.trayId)} — an approaching train must stop short`;
+      return (
+        `FLAG ${i.side === 'east' ? 'EAST' : 'WEST'} — hold the next ${i.side === 'east' ? 'westbound' : 'eastbound'} ` +
+        'train short of your Limits, so you can finish switching'
+      );
+    // §Q, the out-of-phase play (Gitea#19) — "COLLISION RISK! FLAG AGAINST T2?"
+    case 'mainline.redFlag':
+      return i.flag
+        ? 'FLAG IT — stop the train short of your Limits, spending a Red Flags card'
+        : 'wave it through — let it come in';
+    /**
+     * §11, the Yard Office (Gitea#5). The offer interrupts the Mainline Phase, so the label has to
+     * carry the whole question — there is no surrounding context on screen to lean on, and the
+     * player is being asked about a train they were not otherwise thinking about.
+     */
+    case 'mainline.yardOffice':
+      return i.take
+        ? 'take the YARD OFFICE — straight into the yard, leaving the Train Order Office free'
+        : 'keep it at the Train Order Office — the ordinary arrival, onto an A/D track';
+    // §3.3, extended play (Gitea#11). The results screen draws its own buttons, but a bot reads its
+    // options through this list like any other, and the label is what the history says it chose.
+    case 'game.extend':
+      return i.agree
+        ? 'play one more Day — the result already recorded still stands'
+        : 'end the game here';
     default: {
       // Every Intent now has a sentence, so `i` narrows to never here. Keeping the assignment makes
       // that a COMPILE error the day someone adds an intent without describing it — the playable UI
@@ -1090,28 +1274,76 @@ export function describeIntent(s: GameState, i: Intent): string {
  * replay cannot drift into two different pictures of the same board.
  */
 /**
- * The board as ONE SEAT sees it.
+ * ONE DISTRICT'S BOARD, BY SEAT — the cards on the table and the cars standing on them (Gitea#20
+ * step 1).
  *
- * `viewer` decides whose district, whose hand and whose facilities the Frame carries — everything
- * else (the Division, the timetable, the clock) is common to the table. It defaults to seat 0, which
- * is what solitaire and every replay want, so existing callers are unaffected.
+ * A district's BOARD is public. Everyone at the table can see the cards somebody has laid, the cars
+ * standing on them and the trains in the Office Area; what is private is a player's HAND, their
+ * objective and their Revenue detail, none of which is here. That split is why this can be handed to
+ * a seatless spectator unchanged.
  *
- * This was hardcoded to 0 throughout. That was correct while there was one player and would have
- * been a quiet disaster with more: every seat would have been shown player 0's railroad, including
- * player 0's hand, which is the one thing the state model calls secret.
+ * **KEYED BY SEAT, NOT BY PLAYER, and that is not a detail.** Employee Rotation moves players
+ * between districts, so district ownership cannot be assumed to match player index — the board
+ * belongs to the POSITION on the Division and the player is whoever is currently sitting there
+ * (`playerAtSeat`). Taking a player here would silently draw the wrong district the first time
+ * anybody rotated.
+ *
+ * `seat` is also the "home seat" for `carLabel`, which marks a load THIS district made — the printed
+ * game turns the chip upside down in the tray, and a load may not be broken in the Office Area that
+ * made it. For a player's own view that seat is theirs; for a spectator's view of district N it is
+ * N, which is the same fact asked from outside.
  */
-export function snapshot(
+/**
+ * WHAT AN ENHANCEMENT DOES — AND WHETHER IT CAN DO IT RIGHT NOW (#101).
+ *
+ * `enhancementText(key)` takes only the key, so it says the same thing for ever. That is right for
+ * every enhancement except the three dispatch devices, which are "once a day": a spent Radio read
+ * "Once a day, add +12…" all Day after it was gone, which is `trainRules` before #100 in a different
+ * corner of the same view.
+ *
+ * AND THE FEDORA, which is the half that actually surprises. `spendDispatchBonus` (advance.ts) reads
+ * the SUPERINTENDENT's own devices, not the train owner's, and the Fedora moves every
+ * `STAGES_PER_SHIFT` Stages — so a device does nothing at all while somebody else is dispatching,
+ * and is spent automatically, without its owner being asked, while they are.
+ *
+ * `dispatchBonus` decides what counts as a device, rather than a list of three keys written out
+ * here: the ladder lives in `ENHANCEMENT_RULES` and a fourth rung would otherwise be silently
+ * exempt.
+ */
+function enhancementState(
   s: GameState,
-  lines: { text: string; tone: string }[],
-  where: { row: number; col: number } | null,
-  whereFrom: { row: number; col: number } | null = null,
-  decision: Decision | null = null,
-  wasted = false,
-  viewer: PlayerIndex = 0,
-): Frame {
-  const area = areaOf(s, viewer);
-  const viewerSeat = seatOf(s, viewer);
+  area: OfficeArea,
+  seat: SeatIndex,
+  key: string,
+): { what: string; spent: boolean } {
+  const base = enhancementText(key) ?? prettyKey(key);
+  if (enhancementRule(key)?.dispatchBonus === undefined) return { what: base, spent: false };
 
+  const spent = area.dispatchUsedToday.includes(key);
+  if (spent) {
+    return {
+      what: `${base} SPENT for today — it comes back at the start of the next Day.`,
+      spent: true,
+    };
+  }
+  // Available, but only to whoever is dispatching. Naming the shift length is the difference
+  // between "not now" and knowing how long "not now" lasts.
+  if (seatOf(s, s.clock.superintendent) !== seat) {
+    return {
+      what:
+        `${base} Unspent, but IDLE: a device is only used by the district holding the Fedora, ` +
+        `which moves every ${STAGES_PER_SHIFT} Stages.`,
+      spent: false,
+    };
+  }
+  return { what: `${base} Available today, and this district is dispatching.`, spent: false };
+}
+
+export function projectDistrict(
+  s: GameState,
+  seat: SeatIndex,
+): { cells: CellView[]; facilities: FacilityView[]; runningRow: number; limits: { west: number; east: number } } {
+  const area = areaAtSeat(s, seat);
   const cells: CellView[] = [];
   const facilities: FacilityView[] = [];
   for (const [key, card] of area.grid) {
@@ -1129,7 +1361,7 @@ export function snapshot(
     else if (g.kind === 'spaceUse') label = prettyKey(g.key);
     else label = geometryLabel(g.geometry);
 
-    const fv = facilityView(card as never, officeProfile(area.tier).name, viewerSeat);
+    const fv = facilityView(card as never, officeProfile(area.tier).name, seat);
     if (fv) facilities.push(fv);
 
     cells.push({
@@ -1141,16 +1373,34 @@ export function snapshot(
       what: cellDescription(card, officeProfile(area.tier).name, row === area.runningRow),
       links: connectionsFor(card).map(([a, b]) => `${a}${b}`),
       enhancements: card.enhancements.map(prettyKey),
-      enhancementsWhat: card.enhancements.map((k) => enhancementText(k) ?? prettyKey(k)),
-      trains: trainsOnCard(s, viewerSeat, key),
+      enhancementsWhat: card.enhancements.map((k) => enhancementState(s, area, seat, k).what),
+      enhancementsSpent: card.enhancements.map((k) => enhancementState(s, area, seat, k).spent),
+      trains: trainsOnCard(s, seat, key),
       adTracks: card.geometry.kind === 'office' ? officeProfile(area.tier).adTracks : null,
-      cars: carsOn(card).map((c) => carLabel(c, viewerSeat)),
+      cars: carsOn(card).map((c) => carLabel(c, seat)),
       standingWest: card.standingWest,
       facility: fv,
     });
   }
 
-  const division: DivisionView[] = s.division.nodes.map((n) => {
+  return {
+    cells,
+    facilities,
+    runningRow: area.runningRow,
+    limits: { west: area.limitsWest.col, east: area.limitsEast.col },
+  };
+}
+
+/**
+ * THE DIVISION — every district's cell, the Mainline between them, and both Division Points.
+ *
+ * Wholly public and always was: it reads no hand, no objective and no per-viewer state, so a
+ * spectator's Division map and a player's are the same picture. It is extracted rather than
+ * rewritten for exactly that reason — the public view must not be a second implementation that can
+ * drift from the one players look at.
+ */
+export function projectDivision(s: GameState): DivisionView[] {
+  return s.division.nodes.map((n) => {
     if (n.kind === 'divisionPoint') {
       return {
         kind: 'dp',
@@ -1165,36 +1415,48 @@ export function snapshot(
       // Crossing time is in Stages now, so a Mainline card shows its terrain and the trains on it
       // with how long each still has to run.
       const name = MAINLINE_PROFILES.find((m) => m.kind === n.card)?.name ?? n.card;
-      const isGrade = MAINLINE_PROFILES.find((m) => m.kind === n.card)?.speed.kind === 'grade';
+      const isGrade = n.card === 'heavyGrade';
       /**
-       * WHERE ON THE CARD, from what the crossing already cost.
+       * WHERE ON THE CARD — now simply what the card says.
        *
-       * §2.1 divides a Mainline card into two regions and §8.2 moves a train one region per Stage.
-       * The engine crosses in `crossingStages` Stages instead, which varies by card speed, train
-       * speed, passengers and modifiers — so the printed model is recovered by treating the entry
-       * point as the thing that varies, exactly as the cards do:
+       * This used to recover a printed two-region model from a crossing time computed out of the
+       * card's mph, the train's Fast/Slow class, its consist and any modifiers, by treating the
+       * ENTRY point as the thing that varied: `entry = 2 - stagesTotal`. It even had to cope with a
+       * negative entry, for a slow train needing three Stages to cross a card with two regions.
        *
-       *     entry = REGIONS - stagesTotal        position = entry + elapsed
-       *
-       * A 60 card is one Stage, so the train enters at the second region and is gone — which is
-       * what "Start positions further along the card" means on the printed art. A 30 card is two
-       * Stages, giving one region per Stage, which is §8.2 exactly. A slow train needing three
-       * Stages cannot fit three steps into two regions, so it holds in the first for a Stage: the
-       * card's distance is fixed and the train is simply slow across it.
+       * Gitea#3 turned that the right way up. Regions are the primary thing — printed on the card,
+       * one per Stage — and the entry point is what the rules actually move. There is nothing left
+       * to reconstruct.
        */
-      const place = (t: { stagesRemaining: number; stagesTotal: number }): number => {
-        // `entry` may be NEGATIVE — a slow train needing three Stages cannot fit three steps into
-        // two regions, so it notionally starts before the card and spends the extra Stage getting
-        // to the first region. Clamping only the final position keeps that Stage at the START,
-        // where being slow shows; clamping `entry` first would have parked it at the exit instead.
-        const entry = REGIONS_PER_MAINLINE_CARD - t.stagesTotal;
-        const elapsed = t.stagesTotal - t.stagesRemaining;
-        return Math.min(REGIONS_PER_MAINLINE_CARD - 1, Math.max(0, entry + elapsed));
+      /**
+       * AND WHICH WAY IT CAME IN (Gitea#22). `regionOfTransit` counts from the end the train
+       * ENTERED — everything still to run is region 0 — and both directions share that one index
+       * space, which is what the collision rules want and why the engine asks it directly.
+       *
+       * The map is asking a different question: which printed box, LEFT TO RIGHT. East is right
+       * here and always has been, so for an eastbound train the two questions have the same answer
+       * by luck — it enters at the west end, so "just entered" and "leftmost box" coincide. A
+       * westbound train enters at the EAST end, so its region 0 is the right-hand box, and using
+       * the travel index directly drew the whole card mirrored.
+       *
+       * That cost a collision (seed 550943578, undo 187): a westbound TX17 that had just entered
+       * was drawn WEST of a westbound T5 that was nearly across, so the train physically behind
+       * appeared to be the one in front. Train 3 was cleared to follow T5 and ran into TX17 —
+       * where the rules had always had it.
+       *
+       * So the engine's index is turned into a place on the map here, once, at the boundary the
+       * map is drawn from. `regionOfTransit` keeps its meaning and the collision rules are
+       * untouched; only the picture changes.
+       */
+      const place = (t: { stagesRemaining: number; direction: Direction }): number => {
+        const travelled = regionOfTransit(n.card, t.stagesRemaining);
+        const regions = mainlineProfile(n.card).regions;
+        return t.direction === 'west' ? regions - 1 - travelled : travelled;
       };
       return {
         kind: 'ml',
         label: name,
-        regions: REGIONS_PER_MAINLINE_CARD,
+        regions: mainlineProfile(n.card).regions,
         trains: [n.transits.map((t) => {
           const chip = trainChip(s, t.tray);
           return {
@@ -1273,39 +1535,65 @@ export function snapshot(
       modifiers: [],
       gradeUp: null,
       seat: n.seat,
+      // Straight off the node the engine sets (#94). Public to every seat — a flag on the table is
+      // seen by everyone at it — so this is not redacted by viewer and must not become so.
+      redFlag: n.redFlag ?? null,
       running,
       switching: below,
     };
   });
+}
 
+/**
+ * WHO THE GAME IS WAITING ON — the one answer, asked one way (Gitea#20 step 1).
+ *
+ * TWO THINGS HAVE TO BE TRUE AT ONCE, and each was somewhere else before #96 put them together.
+ *
+ * `clock.currentActor` alone is not it: the engine sets that null while an interruption is standing
+ * — a §8.1 clearance goes to the Superintendent, a Yard Office offer to the district's owner — so a
+ * view reading the raw field reports "nobody" during exactly the moments a player is being waited
+ * on. `actingPlayer` knows that rule and is the engine's own answer to it.
+ *
+ * `actingPlayer` alone is not it either, and THIS is what #96 was: it has no status guard, so when
+ * the game is not running it hands back whatever `clock.currentActor` was left holding — the last
+ * seat to move before the timetable ran out. The §3.3 vote is the state that exposed it. That vote
+ * is PARALLEL, open to every un-voted seat at once, and `apply.ts` says in as many words that there
+ * is no actor to be; the screen named the last mover anyway, beside a tally correctly showing three
+ * seats outstanding.
+ *
+ * So: nobody is acting unless the game is `active`, and when it is, `actingPlayer` decides who.
+ *
+ * `currentActor(game)` in `web/game.ts` is this function taking a `Game`, and delegates to it —
+ * ONE answer, not two that agree until they don't. That matters more than it looks: `currentActor`
+ * is what refuses an intent, so a screen answering differently tells the table to wait on a player
+ * the server would turn away.
+ */
+export function currentActorOfState(s: GameState): PlayerIndex | null {
+  if (s.status !== 'active') return null;
+  return actingPlayer(s);
+}
+
+/**
+ * THE TABLE, AS EVERY SEAT SEES IT IDENTICALLY (Gitea#20 step 1).
+ *
+ * The clock, the phase, whose turn it is, the timetable, the yards, the deck COUNTS, the score and
+ * the house rules. Nothing here is redacted, and nothing here may become redacted: the whole point
+ * is that a spectator and a player read the same table state, so a field that has to differ by seat
+ * belongs in the player's own frame instead.
+ *
+ * Deck contents are counts and top-of-pile names only. A Department pile is FACE UP — a discard goes
+ * onto one precisely so a rival can take it — so naming its top card gives nothing away; the Home
+ * Office deck is face down and appears here as a length and nothing else.
+ */
+export function projectSharedTable(s: GameState) {
   return {
     day: s.clock.day,
     stage: s.clock.stage,
     clock: clockTime(s.clock.stage),
     phase: phaseLabel(s.clock.phase),
     phaseKey: s.clock.phase,
-    actor: s.clock.currentActor,
+    actor: currentActorOfState(s),
     superintendent: s.clock.superintendent,
-    revenue: s.players[viewer]?.revenue ?? 0,
-    lines,
-    where,
-    whereFrom,
-    division,
-    cells,
-    facilities,
-    /**
-     * NEWEST FIRST, matching the play page (`actionMenu`).
-     *
-     * The engine pushes a drawn card onto the END of the hand, which put the card just turned over
-     * at the far end of a wrapping row. Reversed here rather than in the engine so the bot's hand
-     * iteration — and every revenue measurement taken with it — is left alone.
-     *
-     * Both lines must reverse together or the descriptions come apart from the names.
-     */
-    hand: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => cardName(s, id)),
-    handWhat: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => cardDescription(s, id)),
-    handDiscardable: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => keepReason(s, id) === null),
-    handKeepWhy: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => keepReason(s, id)),
     deck: s.decks.homeOffice.length,
     departments: s.decks.departments.map((pile) => {
       const top = pile[pile.length - 1];
@@ -1330,9 +1618,6 @@ export function snapshot(
     },
     timetable: [...s.timetable],
     timetableWhat: s.timetable.map((n) => (n === null ? null : trainRules({ trainNumber: n, trainIsExtra: false }))),
-    decision,
-    wasted,
-    option: turnOf(s, viewer).option,
     houseRules: houseRules(s.config),
     mode: s.config.mode,
     optionalRules: s.config.optionalRules,
@@ -1341,31 +1626,27 @@ export function snapshot(
     maxCollisionsPerDay: s.config.maxCollisionsPerDay,
     maxCollisionsTotal: s.config.maxCollisionsTotal,
     collisionsToday: s.collisionsToday,
+    collisionsPrevDay: s.collisionsPrevDay,
     collisionsTotal: s.collisionsTotal,
     status: s.status,
     outcome: s.outcome,
+    extraDays: s.extraDays,
+    extensionVotes: [...s.extensionVotes],
+    official: s.official,
+    tally: s.tally,
     players: s.players.map((p) => ({
       index: p.index,
       seat: seatOf(s, p.index),
       name: p.name,
       revenue: p.revenue,
+      // A COUNT, never the cards. Hand SIZE is public — you can see how many cards somebody holds
+      // across a table — and this is the only thing about another player's hand that may be here.
       hand: (s.decks.hands.get(p.index) ?? []).length,
     })),
-    viewer,
-    viewerSeat,
     openingRolls: {
       division: [...s.openingRolls.division],
       superintendent: [...s.openingRolls.superintendent],
     },
-    handCount: (s.decks.hands.get(viewer) ?? []).length,
-    overHandLimit:
-      (s.decks.hands.get(viewer) ?? []).length > (s.decks.redFlags.get(viewer) ? HAND_LIMIT + 1 : HAND_LIMIT),
-    objective: objectiveOf(s, viewer),
-    runningRow: area.runningRow,
-    limits: { west: area.limitsWest.col, east: area.limitsEast.col },
-    movesLeft: s.clock.phase === 'localOps' && turnOf(s, viewer).option === 'switch' ? turnOf(s, viewer).movesRemaining : null,
-    moves: switchingMoves(s, viewer),
-    blocked: impediments(s, viewer),
     trains: [...s.trays.values()].map((t) => ({
       label: t.trainNumber === null ? 'local crew' : `Train ${t.trainIsExtra ? 'X' : ''}${t.trainNumber}`,
       where:
@@ -1375,6 +1656,166 @@ export function snapshot(
             ? `Mainline card ${t.position.index}`
             : `Office Area (${t.position.coord.col},${t.position.coord.row})`,
     })),
+    /**
+     * THE CREW TRAY POOL, WHICH IS §7's SCARCITY MECHANIC (#98).
+     *
+     * `state.ts` calls it explicit, and it was explicit only in the engine: there are fewer trays
+     * than there are trains wanting one, and nothing said how many were left. Public without
+     * question — the trays are physical objects in the middle of the table, and this is a count
+     * beside the deck and yard counts already here.
+     */
+    crewTrays: { free: s.freeTrays.length, total: crewTrayCount(s.players.length) },
+    /**
+     * THE TRAINS QUEUED FOR ONE — the other half, and the half that had been promised in words.
+     *
+     * Playing an Extra says "it runs once as soon as a Crew Tray frees up"; ordering a second
+     * section says "an identical train will run right behind it". Both were announced once in the
+     * log and then existed only in the engine, so neither promise was ever visibly kept. Who played
+     * an Extra is public: §7 gives the train to the player who played the card, in the open.
+     */
+    queued: {
+      extras: s.pendingExtras.map((x) => ({ trainNumber: x.trainNumber, player: x.player })),
+      secondSections: [...s.pendingSecondSections],
+    },
+  };
+}
+
+/** One district as a spectator sees it: whose seat it is, who is sitting there, and its board. */
+export type PublicDistrict = {
+  seat: SeatIndex;
+  player: PlayerIndex;
+  name: string;
+  cells: CellView[];
+  facilities: FacilityView[];
+  runningRow: number;
+  limits: { west: number; east: number };
+};
+
+/** What a seatless viewer may be shown: the table, the Division, and every district's board. */
+export type PublicFrame = ReturnType<typeof projectSharedTable> & {
+  division: DivisionView[];
+  districts: PublicDistrict[];
+};
+
+/**
+ * THE WHOLE GAME AS A SPECTATOR MAY SEE IT — no seat, no hand, no secrets (Gitea#20 step 1).
+ *
+ * **Built from the same lower-level projections a player's frame is, and deliberately NOT by calling
+ * `snapshot()` once per seat.** That shortcut is the trap: `snapshot` exists to assemble one
+ * player's view and carries their hand, their objective, their Revenue detail and their legal moves,
+ * so a public view made of player views starts by constructing everything it then has to remember to
+ * strip. It also defaults its viewer to player zero, which means a careless spectator call today
+ * serves seat 0's hand. Composing upward instead means a private field cannot arrive here by
+ * accident: it would have to be added to a projection that has no business holding one.
+ *
+ * **Districts are keyed by SEAT and the player is resolved through `playerAtSeat`.** Employee
+ * Rotation moves players between districts, so seat and player index are not interchangeable, and
+ * a public board that assumed they were would relabel every district the first time anybody rotated.
+ *
+ * What is NOT here, and why each: `hand`/`handWhat`/`handDiscardable`/`handKeepWhy` and `handCount`
+ * (the cards a seat holds), `objective` (a private goal), `option`/`movesLeft`/`moves` (one player's
+ * legal actions, which describe what they are ABOUT to do), `blocked` (computed per viewer and
+ * partly about their own crews), `decision`, `viewer`/`viewerSeat`, and the narration log — which
+ * `session.ts` sends incrementally and which is checked separately, because two of the leaks found
+ * in v0.7.9.2 lived there rather than in any frame.
+ */
+export function publicSnapshot(s: GameState): PublicFrame {
+  return {
+    ...projectSharedTable(s),
+    division: projectDivision(s),
+    districts: [...s.officeAreas.keys()].sort((a, b) => a - b).map((seat) => {
+      const player = playerAtSeat(s, seat);
+      return {
+        seat,
+        player,
+        // Through `seatLabel`, like every other seat a person reads: the internal index is
+        // zero-based and the spoken number is not (`session.test.ts` guards the conversion).
+        name: s.players[player]?.name ?? `Seat ${seatLabel(seat)}`,
+        ...projectDistrict(s, seat),
+      };
+    }),
+  };
+}
+
+/**
+ * The board as ONE SEAT sees it.
+ *
+ * `viewer` decides whose district, whose hand and whose facilities the Frame carries — everything
+ * else (the Division, the timetable, the clock) is common to the table. It defaults to seat 0, which
+ * is what solitaire and every replay want, so existing callers are unaffected.
+ *
+ * This was hardcoded to 0 throughout. That was correct while there was one player and would have
+ * been a quiet disaster with more: every seat would have been shown player 0's railroad, including
+ * player 0's hand, which is the one thing the state model calls secret.
+ */
+export function snapshot(
+  s: GameState,
+  lines: { text: string; tone: string }[],
+  where: { row: number; col: number } | null,
+  whereFrom: { row: number; col: number } | null = null,
+  decision: Decision | null = null,
+  wasted = false,
+  viewer: PlayerIndex = 0,
+): Frame {
+  const viewerSeat = seatOf(s, viewer);
+
+  const { cells, facilities, runningRow, limits } = projectDistrict(s, viewerSeat);
+  const division = projectDivision(s);
+  return {
+    /**
+     * THE SHARED TABLE COMES FROM THE SAME PROJECTION THE COMMON BOARD USES (Gitea#20 step 1).
+     *
+     * Spread rather than restated, so a player's frame and a spectator's cannot come to disagree
+     * about the clock, the phase, whose turn it is or the score. Everything after this point is
+     * either private to `viewer` or a viewer-specific slice; none of it shadows a shared field, and
+     * one that did would be exactly the bug this arrangement exists to make visible.
+     */
+    ...projectSharedTable(s),
+    /**
+     * The three interruptions §8.1 and Gitea#5/#19 can raise, said in the words the prompt itself
+     * uses. `decisionActor` above decides WHO; this is only what they are looking at.
+     */
+    awaiting: (() => {
+      const d = s.clock.pendingDecision;
+      if (!d) return null;
+      const train = trainName(s, d.train);
+      if (d.kind === 'clearance') return { asks: 'a clearance ruling', train };
+      if (d.kind === 'yardOffice') return { asks: 'the Yard Office offer', train };
+      return { asks: 'a Red Flag', train };
+    })(),
+    revenue: s.players[viewer]?.revenue ?? 0,
+    lines,
+    where,
+    whereFrom,
+    division,
+    cells,
+    facilities,
+    /**
+     * NEWEST FIRST, matching the play page (`actionMenu`).
+     *
+     * The engine pushes a drawn card onto the END of the hand, which put the card just turned over
+     * at the far end of a wrapping row. Reversed here rather than in the engine so the bot's hand
+     * iteration — and every revenue measurement taken with it — is left alone.
+     *
+     * Both lines must reverse together or the descriptions come apart from the names.
+     */
+    hand: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => cardName(s, id)),
+    handWhat: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => cardDescription(s, id)),
+    handDiscardable: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => keepReason(s, id) === null),
+    handKeepWhy: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => keepReason(s, id)),
+    decision,
+    wasted,
+    option: turnOf(s, viewer).option,
+    viewer,
+    viewerSeat,
+    handCount: (s.decks.hands.get(viewer) ?? []).length,
+    overHandLimit: overHandLimit(s, viewer),
+    objective: objectiveOf(s, viewer),
+    runningRow,
+    limits,
+    movesLeft: s.clock.phase === 'localOps' && turnOf(s, viewer).option === 'switch' ? turnOf(s, viewer).movesRemaining : null,
+    moves: switchingMoves(s, viewer),
+    blocked: impediments(s, viewer),
   };
 }
 
@@ -1545,6 +1986,12 @@ export function cardDescription(s: GameState, id: string): string {
 export function trainRules(t: {
   trainNumber: number | null;
   trainIsExtra: boolean;
+  /**
+   * X17 only — whether the speeches are made, which is what decides which HALF of its printed rule
+   * the train is currently living under (#100). Optional because the timetable renders a train
+   * number with no tray behind it; absent means "not yet", which is the state a train starts in.
+   */
+  speechMade?: boolean;
 }): string {
   const p = trainProfile(t.trainNumber ?? 0, t.trainIsExtra);
   if (!p) return '';
@@ -1589,11 +2036,25 @@ export function trainRules(t: {
   if (p.rules.pickUpEmptiesOnly) {
     parts.push('EMPTIES ONLY — it may not couple a loaded car. A caboose is not a load.');
   }
+  /**
+   * WHICH HALF OF ITS RULE THE CAMPAIGN TRAIN IS IN (#100).
+   *
+   * "One turn at station (speeches) then expedite" is two states, not one sentence. This used to
+   * print the sentence and stop, so the chip read identically before and after the speeches — while
+   * the fault the second half creates was warned about only under `expedite`, i.e. to every train
+   * EXCEPT the one that had just become subject to it.
+   */
   if (p.rules.stopThenExpedite) {
-    parts.push('STOPS ONCE FOR SPEECHES, then runs expedited from its next Office onward');
+    parts.push(
+      t.speechMade
+        ? 'SPEECHES MADE — it runs EXPEDITED from here on'
+        : 'STOPS ONCE FOR SPEECHES at its first Office, then runs expedited from the next one onward',
+    );
   }
 
-  if (p.rules.expedite) {
+  // `isExpedited` (advance.ts) is the engine's own test, borrowed rather than restated: a card that
+  // described a rule the engine did not apply — or the reverse — is the whole failure this is in.
+  if (isExpedited(t)) {
     // It is released and switched exactly like any other train — the restriction is on where it may
     // be LEFT, not on when it leaves.
     parts.push(
@@ -1788,7 +2249,16 @@ const SIMPLE_CARDS = [
  * view of its own. `0` means no floor is configured — nothing to pace against.
  */
 function objectiveOf(s: GameState, viewer: PlayerIndex): Frame['objective'] {
-  const { days, minCombinedRevenue: target } = s.config;
+  const { minCombinedRevenue: target } = s.config;
+  /**
+   * PACED AGAINST THE TIMETABLE ACTUALLY BEING PLAYED, extensions included (Gitea#11).
+   *
+   * `config.days` alone would say "the last Day is over" through every extended Day, and pace an
+   * eight-Day game against five — both of which the status line used to do the moment play carried
+   * on past the end. The official result is still decided at `config.days`; that is `checkVictory`'s
+   * business, and nothing here feeds it.
+   */
+  const days = s.config.days + s.extraDays;
   const revenue = s.players[viewer]?.revenue ?? 0;
   const daysLeft = Math.max(0, days - s.clock.day + 1);
   const elapsed = days - daysLeft + 1;
@@ -1927,6 +2397,9 @@ function trainChip(s: GameState, id: string): TrainChip {
     engineAt: at,
     facing: railFacingOf(t),
     what: t.trainNumber === null ? 'A local crew — no timetable, no card, no special rules.' : trainRules(t),
+    // Conditional spread, not `beingMadeUp: isBeingMadeUp(t)`: the field is optional-and-true, and
+    // `exactOptionalPropertyTypes` refuses an explicit `false` for it.
+    ...(isBeingMadeUp(t) ? { beingMadeUp: true as const } : {}),
   };
 }
 

src/web/game.ts

@@ -23,20 +23,24 @@
  * folding events does not rebuild a game — `protocol.md` §3.)
  */
 
-import { pump } from '../engine/advance.ts';
+import { advance, pump } from '../engine/advance.ts';
 import { applyIntent } from '../engine/apply.ts';
 import type { GameEvent } from '../engine/events.ts';
 import type { Intent } from '../engine/intents.ts';
 import { legalActions } from '../engine/legal.ts';
 import { createGame } from '../engine/setup.ts';
 import type { CardId, GameConfig, GameState, PlayerIndex } from '../engine/state.ts';
+import { overHandLimit as overHandLimitOf } from '../engine/state.ts';
 import { playerAtSeat } from '../engine/state.ts';
 import { cuesFor, narrate } from '../sim/narrate.ts';
+import { collectStep, newCollector } from '../sim/display-step.ts';
+import type { DisplayCollector } from '../sim/display-step.ts';
 // Import from the view module, NOT replay.ts — replay.ts writes files and reads process.argv,
 // which would pull node:fs into a browser bundle.
 import {
   cardDescription,
   cardName,
+  currentActorOfState,
   describeIntent,
   geometryLabel,
   snapshot,
@@ -48,7 +52,6 @@ import {
   DEFAULT_HOUSE_RULES,
   DEFAULT_MAX_COLLISIONS_PER_DAY,
   DEFAULT_MAX_COLLISIONS_TOTAL,
-  HAND_LIMIT,
   LEGACY_HOUSE_RULES,
   collectiveRevenueFloor,
   houseRules,
@@ -133,10 +136,25 @@ export type NewGameOptions = {
 
 /** The same config with the New Game dialog's answers in it. */
 export function configWith(opts: NewGameOptions): GameConfig {
+  const days = opts.days ?? SOLO_CONFIG.days;
   return {
     ...SOLO_CONFIG,
-    days: opts.days ?? SOLO_CONFIG.days,
-    minCombinedRevenue: opts.minCombinedRevenue ?? SOLO_CONFIG.minCombinedRevenue,
+    days,
+    /**
+     * DERIVED FROM THE DAYS ACTUALLY IN PLAY, not from `SOLO_CONFIG`'s five-Day constant.
+     *
+     * It fell back to the constant until 2026-08-30, so `configWith({ days: 1 })` asked a one-Day
+     * game to clear **15** — a floor a five-Day game averages barely half of — and
+     * `configWith({ days: 10 })` asked for the same 15 a five-Day game does. The two fields silently
+     * disagreed, which is the one thing a "build me a config" helper must not let happen.
+     *
+     * Not a live fault when it was found: `createLocalSession` is the only caller, and the page
+     * always writes `minCombinedRevenue` itself (`solitaireDefaults` re-derives it from the preset).
+     * Found by a throwaway probe that passed only `days` — which is exactly how the next caller
+     * would use this. At the default day count the answer is unchanged, since `SOLO_CONFIG`'s own
+     * floor is this same formula at `DEFAULT_DAYS`.
+     */
+    minCombinedRevenue: opts.minCombinedRevenue ?? collectiveRevenueFloor(1, days),
     maxCollisionsPerDay: opts.maxCollisionsPerDay ?? SOLO_CONFIG.maxCollisionsPerDay,
     maxCollisionsTotal: opts.maxCollisionsTotal ?? SOLO_CONFIG.maxCollisionsTotal,
     optionalRules: { ...SOLO_CONFIG.optionalRules, ...(opts.optionalRules ?? {}) },
@@ -229,7 +247,6 @@ export type Game = {
    * had already been played and the hand held three or fewer. Derived from the hand each render, so
    * it cannot drift out of step with what is actually held.
    */
-  mustPlayCard: boolean;
   /**
    * Sounds the last batch of events earned, for the page to play and clear.
    *
@@ -261,11 +278,22 @@ export type Game = {
    * having taken a turn to cause it.
    */
   announced: string | null;
+  /**
+   * ORDERED PRESENTATION STEPS — v0.8.0, TODO #13. One per accepted intent, so a player can WATCH
+   * what everyone else did rather than find the board already rearranged.
+   *
+   * Accumulated here beside `log`, `cues` and `announced` and drained the same way, because that is
+   * how this file already hands things to whatever is displaying the game. Filled by `submit()`
+   * alone, which is what makes it identical for solitaire and multiplayer and inert during replay —
+   * see `sim/display-step.ts`.
+   */
+  display: DisplayCollector;
 };
 
 /** How each intent kind is introduced in the action list, in the order they should appear. */
 const GROUP_ORDER: readonly { prefix: string; title: string }[] = [
   { prefix: 'mainline.clearance', title: 'Superintendent — rule on this train' },
+  { prefix: 'mainline.yardOffice', title: 'Where does this train arrive?' },
   { prefix: 'localOps.choose', title: 'Local Operations — choose ONE' },
   { prefix: 'switch.', title: 'Switching' },
   // Specific before general: `startsWith` means a bare `draw.` would swallow all three, and the
@@ -295,7 +323,7 @@ export const SOLO_PLAYER = 'Solitaire';
 
 export function newGame(seed: number, config: GameConfig = SOLO_CONFIG): Game {
   const state = createGame({ id: `web-${seed}`, seed, config, playerNames: [SOLO_PLAYER] });
-  const game: Game = { state, seed, history: [], log: [], mustPlayCard: false, cues: [], scheduled: null, justDrawn: null, announced: null };
+  const game: Game = { state, seed, history: [], log: [], cues: [], scheduled: null, justDrawn: null, announced: null, display: newCollector() };
   // A history that opens mid-Stage reads as though something was missed. Say what the game IS
   // first, then let the clock take over.
   game.log.push({ text: 'Game Begins', tone: 'start' });
@@ -314,9 +342,23 @@ export function newGame(seed: number, config: GameConfig = SOLO_CONFIG): Game {
  */
 export function newMultiplayerGame(seed: number, config: GameConfig, playerNames: string[]): Game {
   const state = createGame({ id: `mp-${seed}`, seed, config, playerNames });
-  const game: Game = { state, seed, history: [], log: [], mustPlayCard: false, cues: [], scheduled: null, justDrawn: null, announced: null };
+  const game: Game = { state, seed, history: [], log: [], cues: [], scheduled: null, justDrawn: null, announced: null, display: newCollector() };
   game.log.push({ text: 'Game Begins', tone: 'start' });
-  game.log.push({ text: `${config.mode} · ${playerNames.length} players · seed ${seed}`, tone: 'quiet' });
+  /**
+   * NO SEED AT A TABLE WITH MORE THAN ONE SEAT (Gitea#20 step 1).
+   *
+   * `game.log` is one shared list and `linesSince(seat)` (`server/session.ts`) slices it with no
+   * per-seat filter, so every line here reaches every player. Announcing the seed therefore handed
+   * each of them the whole future of the deal — every card order, every die — in the opening line
+   * of the game. Found while planning the public common board; it is a multiplayer leak with or
+   * without that display, which is why it is fixed here rather than waiting for it.
+   *
+   * `newGame` still records it, deliberately: a solitaire table has nobody to leak to, and the seed
+   * in the log is what a bug report quotes. The rule is "do not tell the OTHER seats", not "write
+   * less down". The seed remains in `game.seed`, in every save (`session.ts` persistence) and in the
+   * lobby record, so nothing administrative or replayable loses it.
+   */
+  game.log.push({ text: `${config.mode} · ${playerNames.length} players`, tone: 'quiet' });
   drain(game);
   return game;
 }
@@ -331,12 +373,18 @@ export function drain(game: Game): void {
   record(game, pump(game.state));
 }
 
-/** Whose turn it is, or null if the game is over or waiting on nothing. */
+/**
+ * Whose turn it is, or null if the game is over or waiting on nothing.
+ *
+ * `currentActorOfState` (sim/view.ts) IS this, taking the state rather than the `Game` — so this is
+ * the adapter and not a second copy. It used to be the second copy: it carried the status guard and
+ * the view's version did not, which is #96 — the turn chart named the last seat to move all the way
+ * through the §3.3 vote, while this function correctly refused every intent that seat could send.
+ * Two functions that agree until they don't are worse than one, because the disagreement surfaces
+ * as a screen nobody can square with the server.
+ */
 export function currentActor(game: Game): PlayerIndex | null {
-  if (game.state.status !== 'active') return null;
-  return game.state.clock.pendingDecision !== null
-    ? game.state.clock.superintendent
-    : game.state.clock.currentActor;
+  return currentActorOfState(game.state);
 }
 
 /** Every legal action right now, grouped for display. Empty when there is nothing to decide. */
@@ -465,13 +513,26 @@ export function actionGroups(game: Game): { options: Intent[]; groups: ActionGro
        */
       if (prefix === 'mainline.clearance') {
         const pending = game.state.clock.pendingDecision;
-        if (pending) {
+        if (pending?.kind === 'clearance') {
           headed =
             `Superintendent — may ${trainName(game.state, pending.train)} follow ` +
             `${trainName(game.state, pending.occupiedBy)} onto the same Mainline card?`;
         }
       }
 
+      /**
+       * §11 (Gitea#5) — the Yard Office offer interrupts the Mainline Phase, so it arrives with no
+       * context around it: the player was not thinking about this train a moment ago.
+       */
+      if (prefix === 'mainline.yardOffice') {
+        const pending = game.state.clock.pendingDecision;
+        if (pending?.kind === 'yardOffice') {
+          headed =
+            `${trainName(game.state, pending.train)} is arriving with no coaches — ` +
+            'take it into the Yard Office, or hold it at the Train Order Office?';
+        }
+      }
+
       /**
        * A PENDING EXTRA IS ITS OWN QUESTION, and its own heading.
        *
@@ -602,6 +663,14 @@ export type Menu = {
   makeUp: {
     trayId: string;
     title: string;
+    /**
+     * What the card still wants, after what is already coupled up — "1 boxcar/hopper + 1 caboose".
+     *
+     * The title says what the card CALLS FOR and never changes as cars go on, so a player had to
+     * diff it against the consist drawn on the Division map, in the other column. Null when the
+     * train is complete and only the send-it-out button is left.
+     */
+    needs: string | null;
     cars: MakeUpAction[];
     pass: number | null;
     /**
@@ -742,6 +811,7 @@ export function actionMenu(game: Game, seat: PlayerIndex = 0): Menu {
       ? {
           trayId: filling,
           title: consistTitle(game, filling) ?? 'Making up the train',
+          needs: consistNeeds(game, filling),
           cars: makeUpCars,
           pass,
           advice: makeUpAdvice(game, filling, makeUpCars),
@@ -894,6 +964,40 @@ function consistTitle(game: Game, trayId: string): string | null {
   return trainCardTitle(tray.trainNumber ?? 0, tray.trainIsExtra);
 }
 
+/**
+ * WHAT THE TRAIN STILL WANTS — the card's demand minus what is already on it.
+ *
+ * The heading says "its card calls for 3 boxcar/hopper + 1 caboose" and goes on saying it whether
+ * you have added none or three; the cars themselves are drawn on the Division map, in the other
+ * column. So the one question a player actually has while clicking — what is left? — was the one
+ * thing on screen that had to be worked out by eye, across two panels (Jesse, playtest 2026-09-16).
+ *
+ * BY CATEGORY, exactly as `acceptsCar` counts them, so this cannot promise a car the engine would
+ * then refuse. Null when nothing is outstanding.
+ */
+function consistNeeds(game: Game, trayId: string): string | null {
+  const tray = game.state.trays.get(trayId);
+  if (!tray) return null;
+  const p = trainProfile(tray.trainNumber ?? 0, tray.trainIsExtra);
+  if (!p) return null;
+
+  const cat = (t: string): 'coach' | 'caboose' | 'freight' =>
+    t === 'coach' ? 'coach' : t === 'caboose' ? 'caboose' : 'freight';
+  const have = (k: 'coach' | 'caboose' | 'freight'): number =>
+    tray.consist.filter((c) => cat(c.type) === k).length;
+
+  const parts: string[] = [];
+  const freight = p.consist.freight - have('freight');
+  const coach = p.consist.coach - have('coach');
+  const caboose = p.consist.caboose - have('caboose');
+  if (freight > 0) {
+    parts.push(`${freight} ${p.consist.freightTypes?.join('/') ?? 'freight'}${p.consist.emptiesOnly ? ' (empties only)' : ''}`);
+  }
+  if (coach > 0) parts.push(`${coach} coach${coach > 1 ? 'es' : ''}`);
+  if (caboose > 0) parts.push(`${caboose} caboose`);
+  return parts.length > 0 ? parts.join(' + ') : null;
+}
+
 /**
  * "Making up Extra X22 “Pee-Dee”: its card calls for 1 caboose — Per-diem train…"
  *
@@ -1009,14 +1113,45 @@ function makeUpAdvice(
  * button with a reason instead of hiding a move that has simply become illegal.
  */
 export function overHandLimit(game: Game, seat: PlayerIndex = 0): boolean {
-  const hand = game.state.decks.hands.get(seat) ?? [];
-  const limit = game.state.decks.redFlags.get(seat) ? HAND_LIMIT + 1 : HAND_LIMIT;
-  return hand.length > limit;
+  return overHandLimitOf(game.state, seat);
 }
 
-/** Submit an action. Returns false and changes nothing if the engine rejects it. */
-export function submit(game: Game, intent: Intent): boolean {
-  const actor = currentActor(game);
+/**
+ * Intents any seat may send regardless of whose turn it is — and, for `game.extend`, regardless of
+ * whether the game is still running at all (§3.3, Gitea#11).
+ *
+ * `currentActor` is null once the timetable has run out, which is correct for everything else and
+ * exactly wrong for the vote on playing another Day. Rather than teach `currentActor` about a state
+ * where EVERY seat may act at once — which it has no way to express — callers name the seat.
+ */
+export function isOutOfTurn(intent: Intent): intent is Extract<Intent, { type: 'game.extend' }> {
+  return intent.type === 'game.extend';
+}
+
+/**
+ * WHO ACTED, when replaying a saved history.
+ *
+ * A save is a flat `Intent[]` with no seat written beside each move, so a replay normally derives
+ * the actor from the turn order — the same order the live game went round in, reproduced exactly.
+ * That breaks for exactly one intent: the extension vote, which every seat may cast in any order,
+ * and which `currentActor` answers `null` for because the game has stopped. Replaying such a save
+ * used to fail outright with `NO_ACTOR`, which is to say an extended game could not be resumed at
+ * all — found by `test/server/session.test.ts`'s resume test, and the reason `game.extend` carries
+ * its voter (`intents.ts`).
+ */
+function replayActor(game: Game, intent: Intent): PlayerIndex | null {
+  return isOutOfTurn(intent) ? intent.player : currentActor(game);
+}
+
+/**
+ * Submit an action. Returns false and changes nothing if the engine rejects it.
+ *
+ * `as` names the seat for an out-of-turn intent (see `isOutOfTurn`). It cannot be used to smuggle an
+ * ordinary move past the turn order: `check` is still the authority and still asks `isActor`, so a
+ * named seat that is not the actor is refused exactly as it would have been.
+ */
+export function submit(game: Game, intent: Intent, as: PlayerIndex | null = null): boolean {
+  const actor = as ?? currentActor(game);
   if (actor === null) return false;
 
   const result = applyIntent(game.state, actor, intent);
@@ -1025,12 +1160,69 @@ export function submit(game: Game, intent: Intent): boolean {
     return false;
   }
   game.history.push(intent);
+  /**
+   * THE HIGH-WATER MARK FOR THIS STEP'S NARRATION (v0.8.0).
+   *
+   * Taken here rather than read from `session.ts`'s `sentLines`, which is per-seat and is MUTATED
+   * by `linesSince()` as a side effect of building a push — so it cannot answer "what did this one
+   * intent say?". `submit` brackets the whole thing, `record` and `drain` below are the only things
+   * that append, and the slice after them is exactly this intent's narration including whatever
+   * automatic phases it drained.
+   */
+  const saidFrom = game.log.length;
   record(game, result.events, actor);
-  game.mustPlayCard = overHandLimit(game);
-  drain(game);
+  collectStep(game.display, game.state, actor, intent.type, game.log.slice(saidFrom));
+  drainStepping(game);
   return true;
 }
 
+/**
+ * `drain()`'s STEPPED TWIN — TODO #18, and the reason this is not just `drain(game)`.
+ *
+ * `pump()` runs every automatic phase between one click and the next and `drain()` records the whole
+ * batch at once, so New Train, the Mainline and the shift change are never drawn at all: trains
+ * cross the Division in a single jump. Stepping `advance()` one call at a time and collecting after
+ * each is what gives those phases a visible beat, which is exactly what TODO Reference · #18 says is
+ * needed — *"a minimum dwell time on its own therefore fixes nothing"*.
+ *
+ * IDENTICAL BEHAVIOUR TO `drain()`, deliberately. The same `advance()` calls in the same order
+ * produce the same state; `record()` is called per phase rather than per batch, which is equivalent
+ * because `cuesFor` is a pure per-event map with no cross-event state and `record`'s other outputs
+ * (`scheduled`, `justDrawn`, `announced`) are last-wins in event order either way.
+ *
+ * A PHASE THAT DID NOTHING PRODUCES NO STEP. Jesse, 2026-09-09: *"if nothing happens during a phase
+ * then we shouldn't lose time to it."* Narrating nothing is the test for that — an empty phase adds
+ * no lines, so it is skipped rather than given a dwell to sit through.
+ *
+ * `drain()` itself is untouched, and must stay that way: `fromSave`, `fromMultiplayerSave` and
+ * `undo` all use it, and the collector staying off those paths is what keeps a replay from
+ * re-emitting a whole game as steps.
+ */
+function drainStepping(game: Game): void {
+  for (let i = 0; i < 10_000; i++) {
+    const from = game.log.length;
+    const r = advance(game.state);
+    record(game, r.events);
+    /**
+     * THE TEST IS THE EVENT LIST, NOT THE LOG — and getting that wrong drifted the board.
+     *
+     * `record()` deliberately drops `actorChanged` before narrating, so a phase whose only effect is
+     * handing the turn to the next player grows no lines at all. Collecting only when the log grew
+     * therefore skipped those, and the last step's frame was then a position behind the real one:
+     * the animated board ended a turn out of step with the game (`actor: 2` where the game said 1).
+     *
+     * A step whose narration is empty still carries the board. It simply costs no time to show —
+     * `dwellForStep` gives a silent step a dwell of zero — which is the same rule that collapses an
+     * empty phase, arrived at from the other direction.
+     */
+    if (r.events.length > 0) {
+      collectStep(game.display, game.state, null, 'phase', game.log.slice(from));
+    }
+    if (r.needsInput || game.state.status === 'finished') return;
+  }
+  throw new Error('phase driver failed to settle — probable infinite loop');
+}
+
 /**
  * Which cards in hand can be played RIGHT NOW, in hand order.
  *
@@ -1059,6 +1251,24 @@ export function view(game: Game, seat: PlayerIndex = 0): Frame {
   return snapshot(game.state, [], null, null, null, false, seat);
 }
 
+/**
+ * Fold a narration's opening word into the middle of a sentence — "Chose to draw" after a name has
+ * to read "Player Bob chose to draw".
+ *
+ * ONLY A SENTENCE-CASED WORD, which is the whole point. It used to be a flat
+ * `text.charAt(0).toLowerCase()`, so every line opening with an all-caps keyword came out mangled:
+ * `EXTRA X18 started…` rendered as `Player Solitaire eXTRA X18 started…`, and the same happened to
+ * `TRAIN 1 MADE UP` and `COLLISION`. Those words are shouted deliberately.
+ *
+ * `^[A-Z][a-z]` is the test — a capital followed by a lower-case letter is an ordinary word that was
+ * capitalised because it began a sentence, and nothing else is. It leaves all-caps keywords alone,
+ * and it also leaves alone a word whose second character is a digit or a hyphen (`X22 Pee-Dee`),
+ * which a naive "is it uppercase?" check would get wrong because `'2'.toUpperCase() === '2'`.
+ */
+function uncapitalise(text: string): string {
+  return /^[A-Z][a-z]/.test(text) ? text.charAt(0).toLowerCase() + text.slice(1) : text;
+}
+
 function record(game: Game, events: GameEvent[], actor: PlayerIndex | null = null): void {
   const who = actor === null ? null : (game.state.players[actor]?.name ?? null);
   for (const e of events) {
@@ -1067,12 +1277,50 @@ function record(game: Game, events: GameEvent[], actor: PlayerIndex | null = nul
     const n = narrate(e, {
       cardName: (id) => cardName(game.state, id),
       trainName: (id) => trainName(game.state, id),
+      // Whose district a train reached is not the actor — the Mainline Phase has none — so the
+      // narration resolves the name itself rather than being prefixed with one by the code below.
+      // NO NUMBER IN THE FALLBACK. This is a PLAYER index, and a player is not a seat — seats rotate
+      // under Employee Rotation, which is why `seatOf` exists — so "Seat 3" here would be a wrong
+      // number dressed as a right one, and `session.test.ts` rightly refuses any raw index shown to
+      // a person. Every caller passes real names; an unnamed player is anonymous rather than mislabelled.
+      playerName: (p) => game.state.players[p]?.name ?? 'another player',
     });
+    /**
+     * A BLIND DRAW IS PUBLIC; WHICH CARD CAME UP IS NOT (Gitea#20 step 1).
+     *
+     * Everybody at the table sees a hand go to the Home Office deck, so the draw itself belongs in
+     * the shared log. The card's NAME does not: the deck is face down, and this log goes to every
+     * seat unfiltered, so naming it told three opponents exactly what the fourth was holding.
+     *
+     * A DEPARTMENT SLOT IS NOT THE SAME and stays named. Those piles are face up — a discard goes
+     * onto one precisely so a rival can take it — so the card was public before it was drawn, and
+     * hiding it would lose real information for no gain.
+     *
+     * The drawing seat still learns what it got. `justDrawn` below is the owner-only channel and
+     * `session.ts` sends it to that seat alone, so this costs the drawer nothing. Solitaire keeps
+     * the name for the same reason it keeps the seed: a one-seat table has nobody to leak to, and
+     * a solo player's history naming their own draw is the record rather than a leak.
+     */
+    const blindDraw = e.type === 'cardDrawn' && e.source === 'homeOffice' && game.state.players.length > 1;
+    const said = blindDraw ? 'Drew a card from the Home Office deck' : n.text;
     // "Chose to DRAW a card" does not say WHO, which is unreadable the moment there is more than
     // one seat. Only events the player caused are attributed; the Division running itself is not.
+    /**
+     * A RULING IS MADE AS SUPERINTENDENT, NOT AS YOURSELF (playtest, 2026-09-15: "maybe it could say
+     * 'Superintendent Player Tom', so it's clear they got the move because they're Superintendent").
+     * These three are the only moves a player makes out of turn, by holding the office: §8.1's
+     * clearance, §11's Yard Office offer and §Q's Red Flag prompt. `clearanceGiven` carries no
+     * player at all — the office made it, whoever holds it — so the actor is what names it.
+     */
+    const RULINGS = ['clearanceGiven', 'yardOfficeRuled', 'redFlagRuled'];
+    const ruling = RULINGS.includes(e.type) && who !== null;
     const mine = who !== null && 'player' in e;
-    const text = mine ? `Player ${who} ${n.text.charAt(0).toLowerCase()}${n.text.slice(1)}` : n.text;
-    game.log.push({ text, tone: mine ? 'act' : n.tone });
+    const text = ruling
+      ? `Superintendent Player ${who} ${uncapitalise(said)}`
+      : mine
+        ? `Player ${who} ${uncapitalise(said)}`
+        : said;
+    game.log.push({ text, tone: mine || ruling ? 'act' : n.tone });
 
   }
   game.cues.push(...cuesFor(events));
@@ -1089,6 +1337,18 @@ function record(game: Game, events: GameEvent[], actor: PlayerIndex | null = nul
         `Train ${e.isExtra ? 'X' : ''}${e.trainNumber} has completed its run, leaving via the ` +
         `${e.side === 'east' ? 'Eastern' : 'Western'} Division Point. All players get 1 Revenue.`;
     }
+    /**
+     * THE FEDORA MOVING IS ANNOUNCED, NOT JUST LOGGED (playtest, 2026-09-16).
+     *
+     * It is the one thing in the game that changes hands on the clock rather than because somebody
+     * did something, so nobody is watching for it — and it decides who rules on clearances and who
+     * every round starts with. A line in the history is where you find it afterwards; this is what
+     * tells the table as it happens, the same treatment a completed run already gets.
+     */
+    if (e.type === 'superintendentChanged') {
+      const name = game.state.players[e.player]?.name ?? 'the next player';
+      game.announced = `${name} is now the Superintendent — the Fedora passed at the end of Stage ${e.stage}.`;
+    }
   }
   // Keep the log bounded; the full history lives in `history` and can be replayed.
   if (game.log.length > 400) game.log.splice(0, game.log.length - 400);
@@ -1167,12 +1427,23 @@ export function undo(game: Game, config: GameConfig = game.state.config): Game |
 export function fromSave(save: Save, config: GameConfig = SOLO_CONFIG): Game {
   const game = newGame(save.seed, configFor(save, config));
   for (const intent of save.history) {
-    const actor = currentActor(game);
+    const actor = replayActor(game, intent);
     if (actor === null) break;
     const result = applyIntent(game.state, actor, intent);
     if (!result.ok) break;
     game.history.push(intent);
-    record(game, result.events);
+    /**
+     * `actor` IS PASSED HERE, so a replayed game narrates exactly as the live one did.
+     *
+     * It was omitted, and the omission was invisible in solitaire for a reason worth keeping: the
+     * only test that compares logs ("leaves nothing in the log describing a move that was taken
+     * back") compares one `fromSave`-built log against ANOTHER, so the missing attribution cancelled
+     * out on both sides. Live play attributes (`submit` passes `actor`) and so does multiplayer's
+     * replay (`fromMultiplayerSave`) — this was the one path of the three that did not, which meant
+     * a restored save, an undone game (undo rebuilds through here) and the replay viewer all
+     * described the same moves in different words from the game that produced them.
+     */
+    record(game, result.events, actor);
     drain(game);
   }
   return game;
@@ -1186,16 +1457,18 @@ export function fromSave(save: Save, config: GameConfig = SOLO_CONFIG): Game {
  * this function only ever reconstructs from history that is already known to have been recorded
  * under the currently-running rules.
  *
- * UNLIKE `fromSave`'s loop, this passes `actor` to `record()` (matching `submit`'s own call,
+ * LIKE `fromSave`'s loop, this passes `actor` to `record()` (matching `submit`'s own call,
  * `game.ts` above) — found while testing Phase 3's resume path: without it, every replayed line loses
  * its "Player X" attribution and reads as anonymous "Chose to..." narration, which `record`'s own
  * comment calls "unreadable the moment there is more than one seat" — exactly the multiplayer case a
- * resumed game hits every time. `fromSave` has the same gap (it predates multiplayer and nothing ever
- * compares its output against a LIVE-played log, so it has gone unnoticed — `undo`'s rebuilt game is
- * itself `fromSave`-built, so `test/web.test.ts`'s replay-fidelity test only ever compares one
- * unattributed replay against another). Flagged in `TODO.md` rather than fixed there in this pass —
- * out of scope for Phase 3 and used far more widely, so worth its own careful look rather than a
- * touch-in-passing.
+ * resumed game hits every time.
+ *
+ * `fromSave` HAD THE SAME GAP AND NO LONGER DOES (fixed 2026-08-30). It predated multiplayer, and
+ * nothing ever compared its output against a LIVE-played log: `undo`'s rebuilt game is itself
+ * `fromSave`-built, so `test/web.test.ts`'s replay-fidelity test only ever compared one unattributed
+ * replay against another and the gap cancelled out on both sides. The test that now pins it plays a
+ * game live, restores it from its own save, and asserts the two logs are identical — which is the
+ * comparison that had been missing rather than a new requirement.
  */
 /**
  * Why the intent a replay stopped at is reported rather than swallowed.
@@ -1218,7 +1491,7 @@ export function fromMultiplayerSave(
 ): { game: Game; stopped: ReplayStop | null } {
   const game = newMultiplayerGame(seed, config, playerNames);
   for (const [index, intent] of history.entries()) {
-    const actor = currentActor(game);
+    const actor = replayActor(game, intent);
     if (actor === null) {
       return { game, stopped: { index, intent, code: 'NO_ACTOR' } };
     }

src/web/index.html

@@ -79,13 +79,13 @@ footer{margin-top:26px;color:var(--dim);font-size:11px;display:flex;gap:18px;fle
       <span class="go" id="door-multiplayer-go">Set up a game &rarr;</span>
     </a>
 
-    <a class="door" href="./play.html">
+    <a class="door" href="./play.html?solitaire">
       <h2>Play solitaire</h2>
-      <p>Play by yourself and run the entire division for five full days. Your goal is 20 Revenue.
-         Your game data is saved in your browser &mdash; if you close the tab and reopen this site
+      <p>Play by yourself and run the entire division for five full days. Clear the Revenue floor of
+         15 by the end or the game is a loss. Your game data is saved in your browser &mdash; if you close the tab and reopen this site
          without clearing your cache, your game is preserved and you can continue automatically.
          During the game you can also explicitly save your progress for later replay.</p>
-      <span class="go">Start a game &rarr;</span>
+      <span class="go">Set up a game &rarr;</span>
     </a>
 
     <a class="door" href="./replays.html">
@@ -100,7 +100,7 @@ footer{margin-top:26px;color:var(--dim);font-size:11px;display:flex;gap:18px;fle
 
   <footer>
     <span>build <span id="build">__BUILD__</span></span>
-    <span>solitaire runs entirely in your browser &mdash; no server code required</span>
+    <span>Multiplayer runs on StartOS server. Solitaire runs entirely in your browser.</span>
   </footer>
 </main>
 

src/web/lobby.ts

@@ -107,7 +107,8 @@ function explain(code: unknown, fallback: string): string {
   return messages[key] ?? (key !== '' ? key : fallback);
 }
 
-async function postJson(path: string, body: unknown): Promise<{ status: number; body: Record<string, unknown> }> {
+/** Exported for `main.ts`'s seat-recovery path (Gitea#33), so there is one JSON POST on this page. */
+export async function postJson(path: string, body: unknown): Promise<{ status: number; body: Record<string, unknown> }> {
   const res = await fetch(path, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -256,25 +257,21 @@ export function runLobby(handlers: LobbyHandlers, resume?: { token: string; game
     else if (type === 'custom') type = base;
     for (const r of typeRadios()) r.checked = r.value === type;
 
-    const scoring = preset(base).scoring;
-    const note = $('lb-type-note');
-    if (type === 'custom') {
-      note.textContent =
-        `${gameTypeLabel('custom', scoring)} · ${differing.length} ` +
-        `${differing.length === 1 ? 'setting differs' : 'settings differ'} from ${preset(base).label}.`;
-      note.className = 'ng-note changed-note';
-      // A Custom game is nobody's default: open the block that says how it differs.
-      $<HTMLDetailsElement>('lb-settings').open = true;
-    } else {
-      note.textContent = preset(type as PresetName).blurb;
-      note.className = 'ng-note';
-    }
+    /**
+     * NO SENTENCE UNDER THE RADIOS since 2026-08-30 — it restated the type just chosen to the person
+     * who had just chosen it, and the row is already labelled and already carries its own
+     * description (Jesse: "There's no need to repeat it below"). `form.mark` still puts a hint on
+     * each row that actually differs, which is where a Custom game's differences can be acted on.
+     */
+    // A Custom game is nobody's default: open the block that says how it differs.
+    if (type === 'custom') $<HTMLDetailsElement>('lb-settings').open = true;
   }
 
   for (const r of typeRadios()) {
     // Solitaire is on this screen so the two screens read as one list, but there is nothing here to
-    // deal it with — the New Game dialog is where a solitaire game comes from.
-    if (r.value === 'solitaire') markUnavailable(r, 'dealt with the New game button, not here');
+    // deal it with. Dimmed and left to speak for itself: the heading says "Game type
+    // (multi-player)", which is the explanation (Jesse, 2026-08-30).
+    if (r.value === 'solitaire') markUnavailable(r);
     r.onchange = () => {
       if (!r.checked) return;
       if (r.value === 'custom') {
@@ -615,18 +612,15 @@ export function prefillCode(code: string): void {
  *
  * Reported by Jesse 2026-08-23: "solitaire is disabled, but really hard to tell." A bare `disabled`
  * on a radio leaves the whole row at full strength — the dot simply refuses the click, which reads
- * as a broken control rather than an unavailable one. Dims the row and says why, once.
+ * as a broken control rather than an unavailable one.
+ *
+ * The dimming is the whole signal now. It used to append a reason to the row as well, and dropped
+ * that in 2026-08-30 along with the same text on the solitaire screen: one heading naming which
+ * game the screen deals says it once, where three dimmed rows each said it again.
  */
-function markUnavailable(radio: HTMLInputElement, why: string): void {
+function markUnavailable(radio: HTMLInputElement): void {
   radio.disabled = true;
-  const row = radio.closest('label');
-  if (!row) return;
-  row.classList.add('disabled');
-  if (row.querySelector('.lb-why')) return;
-  const note = document.createElement('span');
-  note.className = 'lb-why';
-  note.textContent = ` — ${why}`;
-  row.querySelector('span')?.appendChild(note);
+  radio.closest('label')?.classList.add('disabled');
 }
 
 function escapeHtml(s: string): string {

src/web/panels.ts

@@ -52,25 +52,61 @@ export function handHtml(f: Frame, canPlay: (boolean | null)[] = []): string {
  * Only the top card may ever be drawn, so the depth is a count and not a hint: everything below it
  * is out of reach, and choosing where to discard is choosing what to put there.
  */
-export function pilesHtml(f: Frame): string {
-  const pile = (label: string, top: string, depth: number, why: string, extra = '', slot = -1): string => {
+export function pilesHtml(f: Frame, lit: readonly string[] = []): string {
+  const pile = (
+    key: string,
+    label: string,
+    top: string,
+    depth: number,
+    why: string,
+    extra = '',
+    slot = -1,
+    faceDown = false,
+  ): string => {
     const tip = [why, extra].filter(Boolean).join(' · ');
     // A Department is a DROP TARGET for a discard. The attribute is always emitted; only the play
     // page binds a click to it, and only while a card is waiting to be discarded — so the replay
     // viewer draws exactly the same markup and nothing there is clickable.
     const target = slot >= 0 ? ` data-dept="${slot}"` : '';
+    // `lit` marks the pile the move being watched just touched — see `changedPiles`.
+    const cls = `handcard${faceDown ? ' facedown' : ''}${lit.includes(key) ? ' pilelit' : ''}`;
     return (
-      `<div class="handcard"${target}${tip ? ` data-tip="${esc(tip)}"` : ''} tabindex="0">` +
+      `<div class="${cls}"${target}${tip ? ` data-tip="${esc(tip)}"` : ''} tabindex="0">` +
       `<div class="pilehd"><span>${esc(label)}</span><span class="depth">${depth}</span></div>` +
       `<b>${esc(top)}</b></div>`
     );
   };
   return (
+    /**
+     * THE HOME OFFICE DECK, which the screen had never drawn.
+     *
+     * `f.deck` has carried the face-down count since the Frame existed and nothing read it — the
+     * exact shape of display gap `test/display-gaps.test.ts` was written to sweep for, surviving in
+     * the panel that draws every OTHER pile. Asked for by Jesse 2026-09-10 for a second reason: a
+     * player drawing from it is the commonest move nobody can see, so it needs somewhere to flash.
+     *
+     * FIRST, because that is the order a card travels: out of here, into a hand, then onto a
+     * Department or the Salvage Yard. Face down, so the card slot says so rather than naming a card
+     * — the whole point of this pile is that nobody knows what is on top.
+     */
+    pile(
+      'home',
+      'Home Office',
+      'face down',
+      f.deck,
+      'The draw deck. Face down — nobody sees what is on top, and a card drawn from here is private ' +
+        'to whoever drew it. When it runs out, the Salvage Yard and the Departments are swept back ' +
+        'into it.',
+      '',
+      -1,
+      true,
+    ) +
     f.departments
       .map((d, i) => {
         const depth = f.departmentDepth[i] ?? 0;
         const under = depth - 1;
         return pile(
+          `dept${i}`,
           `Dept ${i + 1}`,
           d,
           depth,
@@ -81,6 +117,7 @@ export function pilesHtml(f: Frame): string {
       })
       .join('') +
     pile(
+      'salvage',
       'Salvage',
       f.salvage.top,
       f.salvage.depth,
@@ -168,52 +205,353 @@ export function timetableHtml(f: Frame, justSet: number | null): string {
  */
 export function dayEndHtml(f: Frame): string {
   const ended = f.day - 1;
-  const left = f.days - ended;
-  const standings = [...f.players]
-    .sort((a, b) => b.revenue - a.revenue || a.seat - b.seat)
-    .map(
-      (p) =>
-        `<tr${p.index === f.viewer ? ' class="you"' : ''}><td>${esc(p.name)}` +
-        `${p.index === f.viewer ? ' <span class="dim">(you)</span>' : ''}</td>` +
-        `<td class="num">${p.revenue}</td></tr>`,
-    )
-    .join('');
-
-  // The target is a COMBINED floor in every mode that sets one, so it is reported against the whole
-  // table's Revenue rather than the viewer's — showing one player's score against a four-player
-  // target reads as a hopeless position when the table may be comfortably ahead.
-  const combined = f.players.reduce((n, p) => n + p.revenue, 0);
-  const target =
-    f.minCombinedRevenue > 0
-      ? `<p>Combined Revenue <b>${combined}</b> against a target of <b>${f.minCombinedRevenue}</b>.</p>`
-      : '';
-
-  /**
-   * Only when the game is actually scored on collisions.
-   *
-   * Two conditions, both of them `advance.ts`'s own: `0` on a dial turns that check off, and the
-   * checks run in COMPETITIVE AND CO-OP ONLY (§3.4). A solitaire game carries the default dials on
-   * its config and enforces neither, so reporting a collision budget there would put a rule on
-   * screen that this game does not have.
-   */
-  const scoredOnCollisions =
-    (f.mode === 'competitive' || f.mode === 'coop') &&
-    (f.maxCollisionsTotal > 0 || f.maxCollisionsPerDay > 0);
-  const collisions = scoredOnCollisions
-    ? `<p>Collisions: <b>${f.collisionsToday}</b> today, <b>${f.collisionsTotal}</b> in all.</p>`
-    : '';
+  const left = f.days + f.extraDays - ended;
 
   const ahead =
     left <= 0
       ? '<p>That was the last Day on the timetable.</p>'
-      : `<p><b>Day ${f.day} of ${f.days}</b> begins now — ${left} ${left === 1 ? 'Day' : 'Days'} left to run.</p>`;
+      : `<p><b>Day ${f.day} of ${f.days + f.extraDays}</b> begins now — ${left} ${left === 1 ? 'Day' : 'Days'} left to run.</p>`;
 
   return (
     `<h3 class="dayend-h">Day ${ended} has ended</h3>` +
     ahead +
-    `<table class="dayend-t"><tbody>${standings}</tbody></table>` +
-    target +
-    collisions
+    standingsHtml(f) +
+    targetHtml(f) +
+    collisionsHtml(f, ended)
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Shared between the Day-end dialog and the end-of-game results screen.
+//
+// Gitea#16 asked for the results screen and Gitea#10's dialog had already assembled most of it. The
+// three blocks below are the overlap, factored out rather than written twice: the two screens report
+// the same numbers about the same game, and the one thing they must never do is disagree.
+// ---------------------------------------------------------------------------
+
+/**
+ * Every player in Revenue order, the viewer marked.
+ *
+ * `winner` rings the player the OFFICIAL result named, which is not always the player at the top:
+ * in an extended game the standings keep moving after the result is settled, and showing the leader
+ * without saying who actually won would be the screen contradicting itself.
+ */
+function standingsHtml(f: Frame, winner: number | null = null): string {
+  const rows = [...f.players]
+    .sort((a, b) => b.revenue - a.revenue || a.seat - b.seat)
+    .map((p) => {
+      const marks =
+        (p.index === f.viewer ? ' <span class="dim">(you)</span>' : '') +
+        (p.index === winner ? ' <span class="wins">— winner</span>' : '');
+      return (
+        `<tr${p.index === f.viewer ? ' class="you"' : ''}><td>${esc(p.name)}${marks}</td>` +
+        `<td class="num">${p.revenue}</td></tr>`
+      );
+    })
+    .join('');
+  return `<table class="dayend-t"><tbody>${rows}</tbody></table>`;
+}
+
+/**
+ * The target is a COMBINED floor in every mode that sets one, so it is reported against the whole
+ * table's Revenue rather than the viewer's — showing one player's score against a four-player
+ * target reads as a hopeless position when the table may be comfortably ahead.
+ */
+function targetHtml(f: Frame): string {
+  if (f.minCombinedRevenue <= 0) return '';
+  const combined = f.players.reduce((n, p) => n + p.revenue, 0);
+  const met = combined >= f.minCombinedRevenue;
+  return (
+    `<p>Combined Revenue <b>${combined}</b> against a target of <b>${f.minCombinedRevenue}</b>` +
+    `${met ? ' — cleared.' : ' — short.'}</p>`
+  );
+}
+
+/**
+ * Only when the game is actually scored on collisions.
+ *
+ * Two conditions, both of them `advance.ts`'s own: `0` on a dial turns that check off, and the
+ * checks run in COMPETITIVE AND CO-OP ONLY (§3.4). A solitaire game carries the default dials on
+ * 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, endedDay?: number): string {
+  const scoredOnCollisions =
+    (f.mode === 'competitive' || f.mode === 'coop') &&
+    (f.maxCollisionsTotal > 0 || f.maxCollisionsPerDay > 0);
+  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>`;
+}
+
+/**
+ * WHY THE GAME ENDED, as a sentence (Gitea#16).
+ *
+ * The page used to interpolate `outcome.reason` straight into the DOM, so a player who finished a
+ * game read the words `GAME OVER — revenueFloor`: an internal enum value, printed at the one moment
+ * the game has the player's whole attention. Each reason gets a sentence that says what actually
+ * happened, with this game's own numbers in it.
+ *
+ * EXPORTED for the developer replay recorder (`sim/replay.ts`), which was still printing
+ * `loss — revenueFloor` into its own heading a release after this was written — the same defect the
+ * issue was filed about, surviving in the one place nobody had looked (`TODO.md` #34). One
+ * implementation, so the two cannot say the game ended for different reasons.
+ */
+export function reasonSentence(f: Frame, o: NonNullable<Frame['outcome']>, day: number): string {
+  const combined = f.players.reduce((n, p) => n + p.revenue, 0);
+  switch (o.reason) {
+    case 'daysElapsed':
+      return `Day ${day} was the last on the timetable, and it ran out.`;
+    case 'revenueFloor':
+      return (
+        `The Division closed short: <b>${combined}</b> Revenue between everyone, against a floor of ` +
+        `<b>${f.minCombinedRevenue}</b>. §3.3 — miss the floor and the whole table loses, whoever ` +
+        `earned the most.`
+      );
+    case 'collisionFloor':
+      return (
+        `Too many collisions — <b>${f.collisionsToday}</b> in one Day and <b>${f.collisionsTotal}</b> ` +
+        `in all, against limits of ${f.maxCollisionsPerDay || '—'} and ${f.maxCollisionsTotal || '—'}. ` +
+        `§3.4 — the railroad was declared unsafe and the game was stopped.`
+      );
+  }
+}
+
+/** The rules this game was actually dealt under — Gitea#16's "what the rules of the game were". */
+function rulesHtml(f: Frame): string {
+  const mode =
+    f.mode === 'coop' ? 'Co-op — the table scores together' :
+    f.mode === 'competitive' ? 'Competitive — highest Revenue wins' :
+    'Solitaire';
+  const optional = [
+    f.optionalRules.employeeRotation ? 'Employee Rotation' : null,
+    f.optionalRules.reducedVisibility ? 'Reduced Visibility' : null,
+    f.optionalRules.emergencyToolbox ? 'Emergency Toolbox' : null,
+  ].filter((x): x is string => x !== null);
+  const r = f.houseRules.revenue;
+
+  const rows: [string, string][] = [
+    ['Scoring', mode],
+    ['Timetable', f.extraDays > 0
+      ? `${f.days} Days, extended by ${f.extraDays} more`
+      : `${f.days} Day${f.days === 1 ? '' : 's'}`],
+    ['Revenue floor', f.minCombinedRevenue > 0 ? `${f.minCombinedRevenue} combined` : 'none'],
+    ['Collision limits', f.maxCollisionsPerDay > 0 || f.maxCollisionsTotal > 0
+      ? `${f.maxCollisionsPerDay || '—'} per Day, ${f.maxCollisionsTotal || '—'} in all`
+      : 'not scored'],
+    ['Pay rates', `${r.freightPerLoad} per load, ${r.passengerPerCoach} per coach, ${r.trainPerTransit} per transit`],
+    ['Extras start', f.houseRules.extraStart === 'divisionPointsOnly' ? 'Division Points and the Interchange'
+      : f.houseRules.extraStart === 'ownOffice' ? 'those, plus your own Control Point'
+      : 'those, plus any Control Point'],
+    ['Timetabled trains', f.houseRules.discardTimetabled ? 'may be discarded' : 'are never discarded'],
+    ['Optional rules', optional.length ? optional.join(', ') : 'none'],
+  ];
+
+  return `<h4 class="res-h">The rules in play</h4>${factTable(rows)}`;
+}
+
+/**
+ * A two-column table of plain-text facts.
+ *
+ * BOTH HALVES ESCAPED, exactly once, which is the only reason this is a shared helper rather than a
+ * template repeated twice. The rows it is given today are numbers and fixed phrases, but they are
+ * assembled from the Frame — and the day somebody adds a row carrying a player's name, or a facility
+ * label, the escaping has to already be here rather than be remembered.
+ */
+function factTable(rows: [string, string][]): string {
+  return (
+    '<table class="res-t"><tbody>' +
+    rows.map(([k, v]) => `<tr><td>${esc(k)}</td><td>${esc(v)}</td></tr>`).join('') +
+    '</tbody></table>'
+  );
+}
+
+/**
+ * THE RAILROAD — what actually happened out there, from `GameState.tally` (Gitea#16).
+ *
+ * Rows that would read zero for a reason (no passenger work in a game that had none, no collisions
+ * in a clean one) are dropped rather than printed as `0`: a screen of zeroes reads as a bug, and the
+ * absence of a line is the same information more quietly. A zero that is genuinely interesting —
+ * trains through the Division — stays.
+ */
+function tallyHtml(t: Frame['tally']): string {
+  const rows: [string, string][] = [['Trains through the Division', String(t.trainsCompleted)]];
+
+  if (t.trainsCompleted > 0) {
+    rows.push([
+      'Of those, worked en route',
+      `${t.trainsCompletedWithWork} of ${t.trainsCompleted}` +
+        (t.trainsCompletedWithWork === t.trainsCompleted ? ' — every one' : ''),
+    ]);
+  }
+  const push = (label: string, n: number, detail = ''): void => {
+    if (n > 0) rows.push([label, `${n}${detail}`]);
+  };
+  push('Loads made up', t.loadsCompleted);
+  push('Loads broken', t.unloadsCompleted);
+  /**
+   * BOTH HALVES OF THE MEN | AT | WORK PIPELINE, not just the loading one.
+   *
+   * §9.1 makes loading and unloading the same shape — begun, then carried through — and the Tally
+   * has counted both since it was written. The screen reported only the loading side, so a player
+   * with three unloads part-finished at the final whistle was told nothing about them while the
+   * equivalent loads were listed. Found 2026-08-30 auditing which Frame fields nothing reads:
+   * `unloadsBegun` was one of four, and the only one whose absence was visible on screen.
+   */
+  push('Loads still in the pipeline', t.loadsStarted - t.loadsCompleted);
+  push('Unloads still in the pipeline', t.unloadsBegun - t.unloadsCompleted);
+  push('Passengers boarded', t.passengersBoarded);
+  push('Passengers detrained', t.passengersDetrained);
+  push('Cars coupled', t.carsCoupled);
+  push('Cars set out', t.carsDropped);
+  push('Extras run', t.extrasStarted);
+  push('Second sections ordered', t.secondSections);
+  push('Flying switches', t.flyingSwitches);
+  push('Offices upgraded', t.officeUpgrades);
+  push('Facilities unjammed', t.facilitiesUnjammed);
+  push('Trains held', t.trainsHeld);
+  push('Trains diverted', t.trainsDiverted);
+  push('Expedite faults', t.expediteFaults);
+  push('Dispatch bonuses used', t.dispatchBonusesUsed);
+  if (t.clearancesRequested > 0) {
+    rows.push(['Clearances', `${t.clearancesAllowed} allowed of ${t.clearancesRequested} asked`]);
+  }
+  if (t.trainsDestroyed > 0) {
+    rows.push([
+      'Trains destroyed',
+      `${t.trainsDestroyed}, taking ${t.carsDestroyed} car${t.carsDestroyed === 1 ? '' : 's'} with them`,
+    ]);
+  }
+  // §X18 only — the one card in the deck that pays a train for standing still. Reported as what it
+  // is rather than as "the longest an engine sat on a siding", which the engine cannot answer (see
+  // `Tally.circusStops`).
+  if (t.circusStops.length > 0) {
+    rows.push([
+      'Circus set-ups',
+      t.circusStops.map((c) => `Train ${c.trainNumber} at ${c.where}`).join(', '),
+    ]);
+  }
+  push('Cards drawn', t.cardsDrawn);
+  push('Cards played', t.cardsPlayed);
+  // Gitea#9 made throwing a Timetabled train away a legal and deliberate move, so a discard is a
+  // CHOICE the player made rather than an accident of the hand limit — and the engine has counted
+  // it all along while the screen listed only draws and plays beside it.
+  push('Cards discarded', t.cardsDiscarded);
+
+  return `<h4 class="res-h">The railroad</h4>${factTable(rows)}`;
+}
+
+/** Per-player work, for a table that wants to know who did what rather than only who won. */
+function perPlayerHtml(f: Frame): string {
+  const t = f.tally;
+  if (f.players.length < 2) return '';
+  const head =
+    '<tr><th></th><th class="num">Rev</th><th class="num">Loads</th><th class="num">Unloads</th>' +
+    '<th class="num">Pass.</th><th class="num">Cards</th><th class="num">Crashes</th></tr>';
+  const rows = [...f.players]
+    .sort((a, b) => b.revenue - a.revenue || a.seat - b.seat)
+    .map((p) => {
+      const q = t.byPlayer[p.index];
+      if (!q) return '';
+      return (
+        `<tr${p.index === f.viewer ? ' class="you"' : ''}><td>${esc(p.name)}</td>` +
+        `<td class="num">${p.revenue}</td><td class="num">${q.loads}</td>` +
+        `<td class="num">${q.unloads}</td>` +
+        `<td class="num">${q.passengersBoarded + q.passengersDetrained}</td>` +
+        `<td class="num">${q.cardsPlayed}</td><td class="num">${q.collisions}</td></tr>`
+      );
+    })
+    .join('');
+  return `<h4 class="res-h">Who did what</h4><table class="res-t res-wide"><tbody>${head}${rows}</tbody></table>`;
+}
+
+/**
+ * THE END-OF-GAME RESULTS SCREEN — Gitea#16, first pass.
+ *
+ * Everything the Frame already knew plus everything the event tally counted, in the order a player
+ * asks for it: what happened, who won, by how much, under what rules, and then what the railroad
+ * actually did all game. Badges and the "what would make this exciting" brainstorm are the second
+ * pass the issue asks for and are deliberately not here.
+ *
+ * THE OFFICIAL RESULT IS THE ONE AT THE TOP, always. In an extended game (Gitea#11) the standings go
+ * on moving after the winner is settled, so this screen reports the frozen result first and puts
+ * everything that happened afterwards in its own section, marked as informational. "In a five-day
+ * game, even if it's extended to eight or nine days, the winner and the official answer is the
+ * winner at the end of five days" (Jesse, 2026-08-28).
+ */
+export function resultsHtml(f: Frame): string {
+  // `official` is written by the engine the moment any game ends, so it is present on every finished
+  // game. The fallback keeps this rendering something sane for a Frame that predates it — a replay
+  // of a save recorded before this release, which the replay viewer will happily hand us.
+  const report = f.official;
+  const o = report?.outcome ?? f.outcome;
+  if (!o) return '<p class="dim">This game has not ended.</p>';
+
+  const officialDay = report?.day ?? f.days;
+  const winnerName =
+    o.winner === null ? null : (f.players.find((p) => p.index === o.winner)?.name ?? null);
+
+  const headline =
+    o.result === 'loss'
+      ? 'The Division failed'
+      : winnerName === null
+        ? 'The Division ran'
+        : `${esc(winnerName)} takes the Division`;
+
+  /**
+   * The result is reported against the standings AS THEY WERE at the official ending, not as they
+   * are now — in an extended game those are different numbers, and the winner has to be shown
+   * winning. `revenues` is frozen alongside the outcome for exactly this.
+   */
+  const frozen = report
+    ? { ...f, players: f.players.map((p) => ({ ...p, revenue: report.revenues[p.index] ?? p.revenue })) }
+    : f;
+
+  const result =
+    o.result === 'loss'
+      ? '<p>Nobody wins this one.</p>'
+      : o.winner === null
+        ? '<p>The table clears it together — a Co-op game has no individual winner.</p>'
+        : `<p><b>${esc(winnerName ?? '')}</b> finishes ahead on Revenue.</p>`;
+
+  const extended =
+    f.extraDays > 0
+      ? '<h4 class="res-h">After the timetable</h4>' +
+        `<p>The table played on for ${f.extraDays} more Day${f.extraDays === 1 ? '' : 's'}, ` +
+        `through Day ${f.days + f.extraDays}. None of it changed the result above — it is recorded ` +
+        'here because it happened.</p>' +
+        standingsHtml(f) +
+        targetHtml(f) +
+        collisionsHtml(f) +
+        tallyHtml(f.tally)
+      : '';
+
+  return (
+    `<h3 class="dayend-h res-${o.result}">${headline}</h3>` +
+    `<p>${reasonSentence(frozen, o, officialDay)}</p>` +
+    result +
+    standingsHtml(frozen, o.winner) +
+    targetHtml(frozen) +
+    collisionsHtml(frozen) +
+    perPlayerHtml(frozen) +
+    rulesHtml(f) +
+    tallyHtml(report?.tally ?? f.tally) +
+    extended
   );
 }
 
@@ -375,6 +713,30 @@ h3{font-size:11px;text-transform:uppercase;letter-spacing:.07em;color:#8b94a3;ma
 .handcard:focus{outline:2px solid #4d6fa8;outline-offset:1px}
 .cardrow.ref .handcard{background:#1c2129;border-style:dashed;border-color:#39424e;color:#b6bec9}
 .handcard.unplayable{color:#7d8794;border-color:#39424e}
+/* THE HOME OFFICE DECK. Face down, so its card slot names no card — it says so instead, in the
+   dimmed voice the rest of the panel uses for "nothing to read here". */
+.handcard.facedown > b{color:#6f7885;font-style:italic;font-weight:400}
+/* THE PILE A WATCHED MOVE JUST TOUCHED (v0.8.1).
+   A STATE, NOT A FLASH, and that is the whole point. The .tt-slot.fresh rule above animates for a fixed
+   1.5s, which is right for a die roll nobody is waiting on — but a step can hold the screen for
+   seven seconds at 10x, so a fixed animation would be over long before the pause it belongs to and
+   the player would be back to staring at an unchanged board. The flash-in marks the moment; the lit
+   border and background stay for exactly as long as the step is up, because the class is on the
+   element only while that step is the one being shown. */
+.handcard.pilelit{border-color:#8fd6a0;background:#1d3327;box-shadow:0 0 0 2px #2f6b47,0 0 14px rgba(143,214,160,.55);
+  animation:pilepulse 1.15s ease-in-out infinite}
+/* A PULSE FOR THE WHOLE DWELL, not one flash at the start. Measured: at 10x a pile stays lit for
+   just under seven seconds, so the highlight was never brief — but a single 0.45s flash-in and a
+   dark green fill were easy to miss entirely while watching the district. Jesse: "caught one flash
+   deck light up for just a very brief moment, but couldn't see that with what bot was doing in
+   office area and history and catch up area all at same time." Something still moving keeps drawing
+   the eye for as long as the move is up; a state that settles stops asking to be looked at. */
+@keyframes pilepulse{0%,100%{background:#1d3327;box-shadow:0 0 0 2px #2f6b47,0 0 14px rgba(143,214,160,.45)}
+  50%{background:#2f6b47;box-shadow:0 0 0 3px #8fd6a0,0 0 22px rgba(143,214,160,.85)}}
+/* Motion is the point here, so the reduced-motion fallback has to be loud in a different way rather
+   than simply not moving: a solid ring and a brighter fill, held. */
+@media(prefers-reduced-motion:reduce){
+  .handcard.pilelit{animation:none;background:#2f6b47;box-shadow:0 0 0 3px #8fd6a0}}
 .handcard.unplayable::after{content:"";position:absolute;inset:0;border-radius:5px;pointer-events:none;
   background:repeating-linear-gradient(45deg,transparent 0 5px,rgba(150,160,175,.20) 5px 6px)}
 /* THE CARD JUST DRAWN. It sits first in the row, and this says which one that is — three cards that
@@ -415,9 +777,18 @@ h3{font-size:11px;text-transform:uppercase;letter-spacing:.07em;color:#8b94a3;ma
 /* And the piles that are NOT targets step back while a discard is being aimed, so the three that
    are stand out from the Salvage Yard beside them. */
 .cardrow.aiming .handcard:not(.target){opacity:.4}
-.stock .ld.addable,.stock .mt.addable{cursor:pointer;border-radius:3px;padding:0 4px;
-  outline:1px solid #5aa9e6;background:rgba(90,169,230,.16)}
-.stock .ld.addable:hover,.stock .mt.addable:hover{background:rgba(90,169,230,.34)}
+/* A CAR YOU MAY ADD IS AN ACTION, SO IT WEARS THE ACTION COLOUR — Jesse, playtest 2026-09-16: the
+   highlight was "just a small bold and basically the same color as everything else", which is the
+   whole difficulty with making the yard chip the button. #c8912f is the border colour that the
+   action buttons themselves use, so a clickable car looks like every other thing inviting a click,
+   rather than like a number that happens to be outlined.
+
+   THE LOADED/EMPTY TEXT COLOURS ARE LEFT ALONE. Green and blue-grey are what say which of the two
+   numbers is which; the amber answers "may I click this", which is a different question, and
+   painting over the first to answer the second would cost real information. */
+.stock .ld.addable,.stock .mt.addable{cursor:pointer;border-radius:3px;padding:0 4px;font-weight:700;
+  outline:2px solid #c8912f;background:rgba(200,145,47,.20);box-shadow:0 0 0 2px rgba(200,145,47,.16)}
+.stock .ld.addable:hover,.stock .mt.addable:hover{background:rgba(200,145,47,.38)}
 /* Twelve Stages across, so a Day is one glance. The current Stage is lit, Stages already gone are
    dimmed, and a slot the die has just filled flashes once. */
 .tt{display:flex;gap:3px;flex-wrap:wrap}
@@ -479,4 +850,20 @@ ul.blocked{margin:0;padding-left:18px}
 .dayend-t tr:first-child td{border-top:0}
 .dayend-t .num{text-align:right;font-variant-numeric:tabular-nums;font-weight:700;padding-right:0}
 .dayend-t .you td{color:#8fd6a0}
+.dayend-t .wins{color:#e8c56a;font-weight:700}
+
+/* END-OF-GAME RESULTS (Gitea#16). Same family as the Day-end dialog above, which is the point —
+   the two screens share their standings/target/collision blocks and should look like each other. */
+.res-h{font-size:12px;text-transform:uppercase;letter-spacing:.08em;color:#8b95a3;
+  margin:16px 0 6px;border-top:1px solid #2c333d;padding-top:10px}
+.res-win{color:#8fd6a0}
+.res-loss{color:#d98f8f}
+.res-t{border-collapse:collapse;margin:4px 0;width:100%}
+.res-t td,.res-t th{padding:3px 12px 3px 0;border-top:1px solid #232a33;vertical-align:top}
+.res-t tr:first-child td{border-top:0}
+.res-t td:first-child{color:#8b95a3;white-space:nowrap}
+.res-t th{color:#6d7783;font-weight:600;font-size:11px;text-transform:uppercase;letter-spacing:.05em}
+.res-t .num{text-align:right;font-variant-numeric:tabular-nums}
+.res-wide td:first-child{color:#e6e9ee}
+.res-t .you td{color:#8fd6a0}
 `;

src/web/play.html

@@ -76,11 +76,24 @@ dialog input:focus{outline:none;border-color:#4d6fa8}
   padding:5px 14px;cursor:pointer;font:inherit;font-size:13px}
 .ng-buttons button:hover{border-color:#4d6fa8}
 #ng-deal{background:#31527f;border-color:#4d6fa8}
+/* The save warning is the one thing on this screen that describes something IRREVERSIBLE, and it
+   sat in `.ng-note` — the same dim 11px grey as the twenty explanatory notes above it, which is
+   where the eye has already learned there is nothing to act on. Sized and coloured to be read
+   (Jesse, 2026-08-30). Amber rather than red: losing a saved game is a real cost, not a danger, and
+   red here would outrank the actual rules of the game sitting above it. */
+#ss-saved-note{font-size:15px;font-weight:500;line-height:1.55;color:#ffcf70;background:#332a15;
+  border:1px solid #b8912c;border-left:5px solid #e0a83c;border-radius:5px;padding:12px 14px;
+  margin:18px 0 0}
+#ss-saved-note b{color:#ffe3a6}
+/* Two live choices, so neither is the quiet one: `Create new game` keeps the primary blue it has when
+   it is the only button, and `Continue` is given the same weight rather than reading as a cancel. */
+#ss-deal{background:#31527f;border-color:#4d6fa8}
+#ss-resume{background:#2f5340;border-color:#4f8a68}
 main{display:grid;grid-template-columns:minmax(0,1fr) 400px;gap:14px;padding:14px;align-items:start}
 @media(max-width:1100px){main{grid-template-columns:1fr}}
 section{background:var(--panel);border:1px solid var(--line);border-radius:7px;
   padding:10px 12px;margin-bottom:12px}
-#lobby{max-width:1040px;margin:0 auto;padding:14px}
+#lobby,#solitairesetup{max-width:1040px;margin:0 auto;padding:14px}
 /* The create form is two short lists, not one long one: what game this is on the left, what its
    rules are on the right. Collapses to one column where there is no room for two. */
 .lb-two{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1.1fr);gap:22px;align-items:start}
@@ -95,13 +108,24 @@ section{background:var(--panel);border:1px solid var(--line);border-radius:7px;
    lobby and nothing on it said so — a radio that silently refuses reads as a broken radio. */
 .ng-radio.disabled{opacity:.45;cursor:not-allowed}
 .ng-radio.disabled:hover{background:none}
-.lb-why{color:#e0b060;font-size:11px}
-#lobby h2{margin-top:0}
-#lobby h3{margin-bottom:2px}
+#lobby h2,#solitairesetup h2{margin-top:0}
+#lobby h3,#solitairesetup h3{margin-bottom:2px}
 .lb-seat{display:flex;align-items:center;gap:8px;padding:5px 0;border-bottom:1px solid var(--line)}
 .lb-seat:last-child{border-bottom:none}
 .lb-seat .who{flex:1}
 #presence{color:#e0b060;font-size:12px;padding:0 14px;empty-cells:hide}
+/* WHAT YOU ARE WATCHING — v0.8.0, TODO #13/#15. An IN-FLOW row rather than a floating banner like
+   #phasenote and #announce: those announce a moment and fade, this one stands for as long as the
+   board is behind and has a button you have to be able to hit. Amber on the button because amber
+   already means clickable everywhere else on this page; the row itself stays quiet so it does not
+   compete with the three banners it sits under. */
+#watching{display:flex;align-items:center;gap:10px;padding:4px 14px;font-size:12px;color:#9aa0b4}
+#watching[hidden]{display:none}
+#watching-what{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.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,#watching-pause{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}
@@ -160,6 +184,14 @@ button.cardact.discard{color:#d6b48a}
 .scheduled{display:block;font-size:11.5px;margin:0 0 7px;padding:3px 9px;border-radius:5px;
   background:rgba(40,140,60,.22);border:1px solid #2f6b47;color:#bfe8cd;font-weight:600}
 .makeup-note{font-size:11px;margin:0 0 5px}
+/* WHAT THE TRAIN STILL WANTS. Deliberately NOT amber: amber means "you can click this" everywhere
+   else on this page, and this line is the REASON for clicking rather than a thing to click — the
+   cars in the Division Yard are. Brighter than the note beneath it, because it answers the question
+   the player actually has while looking at it. `done` goes green like `.scheduled`: a complete
+   consist is good news, not an instruction. */
+.makeup-needs{font-size:12px;margin:0 0 5px;color:#e6e9ee}
+.makeup-needs b{color:#f2e6cf}
+.makeup-needs.done{color:#bfe8cd}
 /* WHICH TRAIN AM I SWITCHING. A row of crews rather than a stacked list — they are alternatives,
    and the chosen one is the crew whose squares the board is drawing, so it wears the same violet
    "you are here" the rest of the page uses. */
@@ -203,6 +235,17 @@ button.act{display:inline-block}
 button.ghost{background:#222831;border:1px solid #4a5361;color:#c6ccd6;font-size:11px;
   padding:2px 9px;margin-left:10px;text-transform:none;letter-spacing:0;vertical-align:middle}
 button.ghost:hover{border-color:#4d6fa8;color:var(--fg)}
+/* A SEGMENTED CONTROL, BECAUSE A CYCLE COULD NOT REACH EVERY STATE (TODO #16).
+   One button that steps auto -> pinned -> auto can only ever offer the pin OPPOSITE to whatever
+   auto is doing at that moment, which depends on the phase — so "always hidden" was unreachable
+   from "always showing" without waiting for the right phase in between. Three controls, one per
+   mode, and the current one is lit. The buttons still say what they DO rather than what the panel
+   is doing, which was the earlier fix and is worth keeping. */
+.seg{display:inline-flex;margin-left:10px;vertical-align:middle;border-radius:4px;overflow:hidden;
+  border:1px solid #4a5361}
+.seg button.ghost{margin:0;border:0;border-radius:0;border-left:1px solid #4a5361}
+.seg button.ghost:first-child{border-left:0}
+.seg button.ghost[aria-pressed="true"]{background:#2f3a4a;color:var(--fg);font-weight:600}
 #district.folded #grid{display:none}
 #district.folded .districtrule{display:none}
 /* Said once, quietly, beside the thing it governs — a rule a player needs on their first district
@@ -212,6 +255,16 @@ button.ghost:hover{border-color:#4d6fa8;color:var(--fg)}
 .districtrule b{color:#cfd6e0}
 #district.folded #districtsummary{display:block;padding:2px 0 1px;font-size:12px}
 #districtsummary{display:none}
+/* The This Game card folds the same way the district does, and for the same reason: a panel that
+   vanishes entirely reads as broken, so the summary line is what a folded card still says. */
+#gamecard.folded #gamecardbody{display:none}
+#gamecard #gamecardsummary{display:none}
+#gamecard.folded #gamecardsummary{display:block;padding:2px 0 1px;font-size:12px}
+#gamecardbody dl{display:grid;grid-template-columns:auto 1fr;gap:2px 10px;margin:4px 0 10px}
+#gamecardbody dt{color:#8b94a3;font-size:11px}
+#gamecardbody dd{margin:0;font-size:12px;color:#cfd6e0}
+#gamecardbody dd.changed{color:#f0b64a}
+#gamecardbody h4{margin:8px 0 0;font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:#8b94a3}
 /* An action you cannot take yet keeps its place but drops its light — the amber means "press me",
    so a disabled button must not wear it. */
 #actions button.blocked,#actions button:disabled{background:#232830;border:1px dashed #4a5361;
@@ -222,6 +275,14 @@ h3.actions-hd{font-size:13px;text-transform:none;letter-spacing:.01em;color:#cfe
 .over{padding:9px;border-radius:5px;font-weight:700;margin-bottom:8px}
 .over.win{background:rgba(40,140,60,.35)}
 .over.loss{background:rgba(160,60,60,.3)}
+/* THE EXTENSION VOTE (Gitea#11) — unanimous, so who has not answered yet is the useful half. */
+.vote-tally{display:flex;flex-wrap:wrap;gap:4px 12px;margin:0 0 9px;font-size:12px}
+.vote.yes{color:#8fd6a0}
+.vote.no{color:#d98f8f}
+.vote.wait{color:var(--dim)}
+/* Wider than the New Game dialog: the results carry a seven-column per-player table (Gitea#16). */
+#resultsdlg{max-width:640px}
+#resultsdlg table{max-width:100%}
 /* cards, log, blocked */
 .card.gone{opacity:.35;text-decoration:line-through}
 .subj{display:block;width:100%;margin:2px 0}
@@ -299,9 +360,10 @@ ul.blocked li{padding:2px 0}
 
 <!-- THE LOBBY (Phase 4) — shown instead of the game UI whenever there is no game yet to play: no
      stored session token, or a token whose game hasn't started. `lobby.ts` owns everything in here;
-     `main.ts` only decides whether THIS div or `#gameui` below is the one currently visible.
-     `#newgamedlg` at the very end of the body is solitaire-only, and asks the same questions through
-     the same shared module (`settings-form.ts`) — the two blocks are generated from one template. -->
+     `main.ts` only decides whether THIS div, `#solitairesetup` or `#gameui` is the one visible.
+     `#solitairesetup` asks the same questions of a solitaire player, through the same shared module
+     (`settings-form.ts`) — the two blocks are generated from one template, and since 2026-08-30
+     they are the ONLY two: the in-game dialog that was a third copy is gone. -->
 <div id="lobby" hidden>
   <header><b><a href="./index.html" class="home">Station Master</a></b> — <span class="dim">Multiplayer</span></header>
 
@@ -394,12 +456,13 @@ ul.blocked li{padding:2px 0}
          can be shared, compared or replayed. Leave it blank for a random one.</p>
       <!-- WITH THE TABLE SIZE IT IS ABOUT, not below the rules block — reported by Jesse, who found
            it separated from the control it explains by fifteen settings. -->
-      <p class="ng-note">Every chair has to be taken before the game can start — by a person or by a
-         bot. Pick the size of the table now; it cannot change once the game is created.</p>
+      <p class="ng-note">Every chair must be filled before the game can start. For solitaire,
+         there&rsquo;s only one player. For multiplayer, that must be filled by a person or a
+         bot. The number of players cannot be changed once the game is created.</p>
       </div>
 
       <div class="lb-col">
-      <h3>Game type</h3>
+      <h3>Game type (multi-player)</h3>
     <div class="set-row" id="lb-type-row">
       <label class="ng-radio"><input type="radio" name="lb-type" value="solitaire">
         <span><b>Solitaire</b><br><span class="dim">One railroad, one player. The whole Division is yours to run.</span></span></label>
@@ -413,7 +476,7 @@ ul.blocked li{padding:2px 0}
         <span><b>Custom</b><br><span class="dim">Whatever you set below. Selected for you the moment you change a rule; it is scored as the type you started from.</span></span></label>
     </div>
 
-      <p class="ng-note" id="lb-type-note"></p>
+      
       </div>
 
       <!-- FULL WIDTH WHEN IT OPENS. Reported by Jesse: opened inside the right-hand column it made a
@@ -423,7 +486,7 @@ ul.blocked li{padding:2px 0}
         <summary>Game settings</summary>
         <p class="ng-note">Every rule the game type sets, and every one of them yours to change.
            Changing any of them selects <b>Custom</b>, which keeps the scoring of the type you
-           started from; clicking a type again resets all of them back to it. They are fixed when the
+           started from; changing the game type resets all of them back to it. They are fixed when the
            game is created and cannot be changed once it starts.</p>
       <div class="set-groups">
 
@@ -497,13 +560,13 @@ ul.blocked li{padding:2px 0}
       </div>
       <div class="set-row" id="lb-colday-row">
         <label class="ng-gate"><input type="checkbox" id="lb-colday-on" checked>
-          <span>The game ends and everyone loses if collisions in one Day reach</span>
+          <span>The game ends immediately and results in a loss if collisions in one Day reach</span>
           <input id="lb-colday" type="number" min="0" step="1" class="gate-num"></label>
         <span class="set-hint" id="lb-colday-hint"></span>
       </div>
       <div class="set-row" id="lb-coltotal-row">
         <label class="ng-gate"><input type="checkbox" id="lb-coltotal-on" checked>
-          <span>The game ends and everyone loses after this many collisions in the whole game</span>
+          <span>The game ends immediately and results in a loss after this many collisions in the whole game</span>
           <input id="lb-coltotal" type="number" min="0" step="1" class="gate-num"></label>
         <span class="set-hint" id="lb-coltotal-hint"></span>
       </div>
@@ -514,7 +577,7 @@ ul.blocked li{padding:2px 0}
 
       <div class="set-group">
       <h3>Optional rules</h3>
-      <p class="ng-note">Off in every game type; each one changes how the game plays.</p>
+      <p class="ng-note">Each one changes how the game plays.</p>
       <div class="set-row" id="lb-visibility-row">
         <label class="ng-num"><span>Reduced Visibility — five switching Moves instead of six in the
           night Stages (1&ndash;3 and 11&ndash;12)</span>
@@ -547,7 +610,7 @@ ul.blocked li{padding:2px 0}
       </details>
 
       <div class="lb-span">
-        <button id="lb-create" type="button">Create game</button>
+        <button id="lb-create" type="button">Create new game</button>
         <p class="lb-error" id="lb-create-err" role="alert"></p>
       </div>
       </div>
@@ -584,6 +647,208 @@ ul.blocked li{padding:2px 0}
   </section>
 </div>
 
+<!-- ===================================================================
+     SOLITAIRE SETUP — the same question multiplayer already asks first,
+     now asked here too (Jesse, 2026-08-29): a genuinely fresh visit deals
+     nothing until this screen's own Deal button is pressed. A saved game,
+     an explicit `?seed=`, or a URL already carrying a Deal's answers (any
+     of the shared block's fields — `hand` names the one always written)
+     all skip straight past this screen, exactly as `?lobby` already skips
+     past it into the lobby: those are not "no plan yet", they are a
+     choice already made, elsewhere.
+
+     THE SAME BLOCK THE DIALOG AND THE LOBBY USE, same shared module
+     (`settings-form.ts`), same order — three screens are one design now
+     instead of two. Only Solitaire can be dealt from here, so the other
+     four types are shown exactly as the in-game dialog shows them: present,
+     disabled, with a note pointing at the Multiplayer door instead.
+     ==================================================================== -->
+<div id="solitairesetup" hidden>
+  <header><b><a href="./index.html" class="home">Station Master</a></b> — <span class="dim">Solitaire</span></header>
+
+  <section>
+    <h2>New solitaire game</h2>
+    <p class="ng-note">One railroad, one player, five full days by default — everything below is
+       yours to change before you deal. Clearing the Revenue floor wins; falling short loses.</p>
+
+    <!-- THE SAME THREE PARAMETERS THE LOBBY ASKS, in the same order, with the same note under them
+         (Jesse, 2026-08-30: "everything beneath that should be the same"). The table size is here
+         rather than hidden because it is one of the three things that describe a game, and leaving
+         it out made this screen a different form that happened to share a rules block. It is LOCKED
+         at one: a `LocalSession` runs the engine in this browser and a table needs a server, which
+         is the same reason the four multiplayer game types are shown disabled below. -->
+    <div class="lb-params">
+      <label class="ng-num"><span>Seed</span>
+        <input id="ss-seed" type="text" inputmode="numeric" autocomplete="off" placeholder="blank for a random seed"></label>
+      <label class="ng-num"><span>Players at the table</span>
+        <select id="ss-players" disabled>
+          <option value="1" selected>1</option>
+        </select></label>
+      <label class="ng-num"><span>Days</span>
+        <input id="ss-days" type="number" min="1" max="20" step="1" value="5"></label>
+    </div>
+    <p class="ng-note">The same seed and the same settings always deal the same railroad, so a game
+       can be shared, compared or replayed. Leave it blank for a random one.</p>
+    <p class="ng-note">Every chair must be filled before the game can start. For solitaire,
+       there&rsquo;s only one player. For multiplayer, that must be filled by a person or a
+       bot. The number of players cannot be changed once the game is created.</p>
+
+    <h3>Game type (solitaire)</h3>
+    <div class="set-row" id="ss-type-row">
+      <label class="ng-radio"><input type="radio" name="ss-type" value="solitaire" checked>
+        <span><b>Solitaire</b><br><span class="dim">One railroad, one player. The whole Division is yours to run.</span></span></label>
+      <label class="ng-radio"><input type="radio" name="ss-type" value="coop">
+        <span><b>Co-op</b><br><span class="dim">Everyone&#8217;s Revenue is one table score. You win together or lose together.</span></span></label>
+      <label class="ng-radio"><input type="radio" name="ss-type" value="competitive">
+        <span><b>Competitive</b><br><span class="dim">Highest Revenue wins — unless the table misses its combined minimum, and then everyone loses.</span></span></label>
+      <label class="ng-radio"><input type="radio" name="ss-type" value="cutthroat">
+        <span><b>Cutthroat</b><br><span class="dim">Highest Revenue wins, and nothing is shared — the only way everyone loses is three collisions in one Day.</span></span></label>
+      <label class="ng-radio"><input type="radio" name="ss-type" value="custom">
+        <span><b>Custom</b><br><span class="dim">Whatever you set below. Selected for you the moment you change a rule; it is scored as the type you started from.</span></span></label>
+    </div>
+
+    
+
+    <details id="ss-settings" open>
+      <summary>Game settings</summary>
+      <p class="ng-note">Every rule the game type sets, and every one of them yours to change.
+         Changing any of them selects <b>Custom</b>, which keeps the scoring of the type you
+         started from; changing the game type resets all of them back to it. They are fixed when the
+         game is created and cannot be changed once it starts.</p>
+      <div class="set-groups">
+
+      <div class="set-group">
+      <h3>Starting hand</h3>
+      <p class="ng-note">What each player is dealt before the first turn. The hand limit is three
+         either way — deal six and the first turn is spent choosing which of them to keep.</p>
+      <div class="set-row" id="ss-hand-row">
+        <label class="ng-radio"><input type="radio" name="ss-hand" value="threeRandom">
+          <span><b>Three random cards</b><br><span class="dim">The original rule. At the hand limit already, and no guarantee of track.</span></span></label>
+        <label class="ng-radio"><input type="radio" name="ss-hand" value="sixRandom" checked>
+          <span><b>Six random cards</b><br><span class="dim">Twice the choice, still no guaranteed track — the first turn is a discard.</span></span></label>
+        <label class="ng-radio"><input type="radio" name="ss-hand" value="threeTrackThreeOther">
+          <span><b>Three random track and three random non-track cards</b><br><span class="dim">Dealt from two piles, so the district you can build is dealt rather than waited for.</span></span></label>
+        <span class="set-hint" id="ss-hand-hint"></span>
+      </div>
+      </div>
+
+      <div class="set-group">
+      <h3>Where an Extra may start</h3>
+      <p class="ng-note">The player who plays an Extra Train card chooses where its Crew Tray goes,
+         and the place decides which way it runs — a Division Point sends it away from itself; in the
+         middle of the railroad the player picks east or west. The Division Points and the Interchange
+         belong to nobody and are always available. Starting one inside a district is the part that
+         favours a seat, so it is set here. An Office must be a Control Point whatever this says: a
+         Whistle Post never qualifies.</p>
+      <div class="set-row" id="ss-extra-row">
+        <label class="ng-radio"><input type="radio" name="ss-extra" value="divisionPointsOnly">
+          <span><b>Division Points and the Interchange only</b><br><span class="dim">The strictest reading. Every Extra begins on shared ground.</span></span></label>
+        <label class="ng-radio"><input type="radio" name="ss-extra" value="ownOffice">
+          <span><b>Also the playing player&#8217;s own Control Point</b><br><span class="dim">You may start one at home, but not in somebody else&#8217;s district.</span></span></label>
+        <label class="ng-radio"><input type="radio" name="ss-extra" value="anyOffice">
+          <span><b>Also any player&#8217;s Control Point</b><br><span class="dim">The most permissive — an Extra may be planted in another player&#8217;s district.</span></span></label>
+        <span class="set-hint" id="ss-extra-hint"></span>
+      </div>
+      </div>
+
+      <div class="set-group">
+      <h3>Revenue</h3>
+      <p class="ng-note">What each piece of work pays, 0 to 5. A coach pays when it is boarded and
+         again when it is detrained; a load pays when it is made up and again when it is broken. Zero
+         switches an economy off so the others can be read.</p>
+      <div class="set-row" id="ss-passenger-row">
+        <label class="ng-num"><span>Passenger revenue per coach</span>
+          <input id="ss-passenger" type="number" min="0" max="5" step="1" value="1"></label>
+        <span class="set-hint" id="ss-passenger-hint"></span>
+      </div>
+      <div class="set-row" id="ss-freight-row">
+        <label class="ng-num"><span>Freight revenue per load</span>
+          <input id="ss-freight" type="number" min="0" max="5" step="1" value="1"></label>
+        <span class="set-hint" id="ss-freight-hint"></span>
+      </div>
+      <div class="set-row" id="ss-transit-row">
+        <label class="ng-num"><span>Train revenue per transit</span>
+          <input id="ss-transit" type="number" min="0" max="5" step="1" value="0"></label>
+        <span class="set-hint" id="ss-transit-hint"></span>
+      </div>
+      <p class="ng-note">A transit pays every player, once, when a train runs off the end of the
+         Division — the one thing nobody has to work for.</p>
+      </div>
+
+      <div class="set-group">
+      <h3>Victory conditions</h3>
+      <p class="ng-note">The ways this game can end badly. Each one is switched on or off in its own
+         right; how long the game runs is set above, with the table size.</p>
+      <div class="set-row" id="ss-minrev-row">
+        <label class="ng-gate"><input type="checkbox" id="ss-minrev-on" checked>
+          <span>You lose if Revenue at the end is under</span>
+          <input id="ss-minrev" type="number" min="0" step="1" class="gate-num"></label>
+        <span class="set-hint" id="ss-minrev-hint"></span>
+      </div>
+      <div class="set-row" id="ss-colday-row">
+        <label class="ng-gate"><input type="checkbox" id="ss-colday-on" checked>
+          <span>The game ends immediately and results in a loss if collisions in one Day reach</span>
+          <input id="ss-colday" type="number" min="0" step="1" class="gate-num"></label>
+        <span class="set-hint" id="ss-colday-hint"></span>
+      </div>
+      <div class="set-row" id="ss-coltotal-row">
+        <label class="ng-gate"><input type="checkbox" id="ss-coltotal-on" checked>
+          <span>The game ends immediately and results in a loss after this many collisions in the whole game</span>
+          <input id="ss-coltotal" type="number" min="0" step="1" class="gate-num"></label>
+        <span class="set-hint" id="ss-coltotal-hint"></span>
+      </div>
+      <p class="ng-note">The opponent-directed cards — Derail, Watertower, Hobo Jungle and the
+         nineteen others, along with the seven that answer them — are not implemented yet, so no game
+         type deals them whatever else is set here.</p>
+      </div>
+
+      <div class="set-group">
+      <h3>Optional rules</h3>
+      <p class="ng-note">Each one changes how the game plays.</p>
+      <div class="set-row" id="ss-visibility-row">
+        <label class="ng-num"><span>Reduced Visibility — five switching Moves instead of six in the
+          night Stages (1&ndash;3 and 11&ndash;12)</span>
+          <input id="ss-visibility" type="checkbox"></label>
+        <span class="set-hint" id="ss-visibility-hint"></span>
+      </div>
+      <div class="set-row" id="ss-rotation-row">
+        <label class="ng-num"><span>Employee Rotation — not applicable for solitaire</span>
+          <input id="ss-rotation" type="checkbox" disabled></label>
+        <span class="set-hint" id="ss-rotation-hint"></span>
+      </div>
+      <div class="set-row" id="ss-toolbox-row">
+        <label class="ng-num"><span>Emergency Toolbox — start holding a Red Flag, so a hand of four;
+          play or discard down to three on the first turn</span>
+          <input id="ss-toolbox" type="checkbox"></label>
+        <span class="set-hint" id="ss-toolbox-hint"></span>
+      </div>
+      <div class="set-row" id="ss-tossloco-row">
+        <label class="ng-num"><span>A Timetabled train may be discarded — toss it face-up to a
+          Department slot. Turn this off and a train card can only ever be played onto the timetable.
+          An Extra is never discardable either way</span>
+          <input id="ss-tossloco" type="checkbox"></label>
+        <span class="set-hint" id="ss-tossloco-hint"></span>
+      </div>
+      </div>
+
+      </div>
+    </details>
+
+    <!-- Shown only when `station-master.save.v1` holds a game. Dealing from this screen CLEARS that
+         save (`commitNewGame` calls `clearSave`), so without a way back the door would be a way to
+         lose a game in progress — and the door is reached by clicking "Play solitaire", which nobody
+         reads as "discard what I was playing". -->
+    <p id="ss-saved-note" hidden><b>You have a solitaire game in progress.</b> Creating a new game
+       replaces it permanently &mdash; there is no undo. Choose <b>Continue saved game</b> to pick it
+       up where you left off.</p>
+
+    <menu class="ng-buttons">
+      <button id="ss-resume" type="button" hidden>Continue saved game</button>
+      <button id="ss-deal" type="button">Create new game</button>
+    </menu>
+  </section>
+</div>
+
 <div id="gameui" hidden>
 <div class="topbar">
 <header>
@@ -592,20 +857,23 @@ ul.blocked li{padding:2px 0}
   <!-- The objective, and nothing else: score, target, Days left. The "behind the pace" chip and the
        engine's guess at what your score ought to be were noise on the one line that must not wrap. -->
   <span id="objective" class="pace">—</span>
-  <span class="dim">seed <span id="seed">—</span></span>
+  <!-- THE COLLISION COUNTS, WHICH ARE A LIVE SCORE AND NOT A SETTING (TODO #28). The Frame has
+       carried `collisionsToday` and `collisionsTotal` since v0.7.0 and nothing on the board drew
+       them, so the one victory condition that can end a game early was invisible while it ran.
+       Empty and collapsed when both limits are 0 — a game that cannot end this way should not be
+       counting towards it. The limits themselves live in the This Game card; this is progress. -->
+  <span class="dim" id="collisions" title=""></span>
   <!-- THE GAME CODE SURVIVES THE LOBBY. It used to end at `Lobby.Start` — the code was never carried
        into `LobbyReady` — so a seated player could not say which game they were in, could not match
        it against the administrator's Games in Progress list, and could not pass it to a latecomer.
        Empty (and collapsed) in solitaire, where there is no code. -->
   <span class="dim" id="gamecode" title="The code this game was created under. The administrator's Games in Progress list uses it, and it is how you say which game you mean."></span>
-  <!-- Co-op, Competitive, Cutthroat or Custom, derived from the config the Frame carries
-       (`presets.ts`). A Cutthroat game used to look exactly like a Co-op one from the board. -->
-  <span class="dim" id="gametype" title=""></span>
-  <!-- WHICH RULES THIS GAME IS BEING PLAYED UNDER. The settings are chosen when the game is dealt
-       and then never mentioned again, which makes a playtest note ("scored 4") unreadable a week
-       later: at 0 revenue per transit that is a different game from the same seed at 5. Short enough
-       to keep the header on one line; the tooltip spells it out. -->
-  <span class="dim" id="houserules" title="">—</span>
+  <!-- The seed, the seat, the game type and every house rule MOVED TO THE THIS GAME CARD, 2026-08-30
+       (TODO #28). Jesse: "we can give complete information about all the game options and not take
+       up valuable real estate at the top of the screen… it is not something that they're likely to
+       need all the time." What stays here is what is glanced at every turn — Revenue, the objective,
+       the collision counts — plus the game code, which is identity rather than settings: it is how
+       you say WHICH game you are in, out loud, without opening anything. -->
   <button id="sound" title="Whistle at the end of each Stage, the crossing bell at the end of each Day, and the conductor when a train is built. Currently synthesised, not recorded.">🔇 muted</button>
   <!-- BOARD ZOOM. Applies to the Division map and the Office Area grid alike — both already scroll
        horizontally (`#division`, `#grid`) when they run wide, so this only ever needs to resize the
@@ -613,9 +881,17 @@ 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. Your own moves are never delayed — only theirs. Starts at 1×, which holds a switching move for one second; the slowest setting, 20×, holds it for twenty. Off draws every move at once.">
+    <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="Deal a fresh game. You choose the seed, the opening hand and what the three economies pay. Undo steps back one action at a time; this throws the whole game away, so download the replay first if you want to keep it.">New game</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>
   <button id="multiplayer" title="Create or join a Competitive or Co-op game on this server, with other players.">Multiplayer</button>
   <!-- LEAVING A RUNNING GAME. Reported by Jesse 2026-08-23: "if I'm a player in the middle of the
        game and I need to leave, how do I leave the game, clear the token from my browser so I can
@@ -642,14 +918,35 @@ ul.blocked li{padding:2px 0}
      collapsed whenever everyone connected is still connected — a `LocalSession` never fills it. -->
 <div id="presence"></div>
 
+<!-- WHAT YOU ARE WATCHING, and how far behind the board is — v0.8.0, TODO #13/#15.
+     One row rather than three additions: the countdown, the caption naming the action being shown,
+     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>
+  <!-- PAUSE BESIDE SKIP, not instead of it: they are opposite answers to "that went past too fast".
+       Skip gives up the animation to reach the game; Pause holds the board on the step being shown
+       for as long as you want to look at it, and gives the step back the dwell it still had. -->
+  <button id="watching-pause" class="ghost" type="button" title="Hold the board on the move being shown. Nothing is lost and nothing is hurried — press again to carry on from the same step.">Pause</button>
+  <span id="watching-behind" class="wbehind"></span>
+  <span id="watching-what"></span>
+</div>
+
 <main>
   <div>
     <section><h2>The Division — west to east</h2><div id="division"></div>
       <p class="ng-note" id="seating-chain"></p></section>
     <section id="district">
-      <h2>Your Office Area
+      <h2><span id="districtwho">Your Office Area</span>
         <span class="dim" style="text-transform:none;letter-spacing:0">— hover any card for the full explanation</span>
-        <button id="districttoggle" class="ghost" title="Auto-hide keeps the district open during Local Operations and Cargo — the phases that change it — and folds it otherwise. Click to pin it open or hidden instead.">auto-hide: on</button>
+        <span id="districttoggle" class="seg" role="group" aria-label="When to show your Office Area"><button id="dm-auto" class="ghost" type="button" title="Open during Local Operations and Cargo — the phases that change the district — and folded otherwise.">Auto-hide</button><button id="dm-open" class="ghost" type="button" title="Keep the Office Area open in every phase.">Always show</button><button id="dm-closed" class="ghost" type="button" title="Keep the Office Area folded in every phase. The summary line stays, so it reads as folded rather than missing.">Always hide</button></span>
+        <!-- LOOK AT ANOTHER PLAYER'S OFFICE AREA. Filled by `renderDistrict` with one button per
+             opponent, and collapsed at a table of one. The look is read-only and lasts a single
+             render on purpose — see `peekPlayer` in `main.ts`. -->
+        <span id="districtpeek" class="seg" role="group" aria-label="Look at another player's Office Area"></span>
       </h2>
       <div id="districtsummary" class="dim"></div>
       <!-- THE RULE THAT SHAPES EVERY DISTRICT, said once where the district is.
@@ -693,190 +990,34 @@ ul.blocked li{padding:2px 0}
     </section>
     <section><h2>Blocked — why nothing is moving</h2><ul class="blocked" id="blocked"></ul></section>
     <section><h2>Facilities</h2><div id="facs"></div></section>
+    <!-- THIS GAME — the settings it was dealt under, off the top line and out of the way (TODO #28).
+         Last in the column and folded by default because it is looked up, not watched: "Oh wait,
+         what did we set that to?" The body is `rulesListHtml`, the same renderer the join preview
+         and the seating screen draw, so what you agreed to in the lobby and what you can read
+         mid-game cannot drift apart. -->
+    <section id="gamecard" class="folded"><h2>This Game
+        <button id="gamecardtoggle" class="ghost" type="button" title="The seed, the seat, the game type and every rule this game was dealt under.">show</button>
+      </h2>
+      <div id="gamecardsummary" class="dim"></div>
+      <div id="gamecardbody"></div>
+    </section>
   </div>
 </main>
 
-<!-- ===================================================================
-     NEW GAME — the seed, the opening hand, and what the three economies pay.
+<!-- THE IN-GAME "NEW GAME" BUTTON GOES TO THE SOLITAIRE SETUP SCREEN — there is no second
+     dialog any more (Jesse, 2026-08-30: "it should not go to a separate screen. We should reuse the
+     Solitaire New Game Screen… in general we should reuse what we already have").
 
-     It was a `prompt()` asking for a seed. Two of the three things that decide what kind of game
-     you are about to play had no way in at all: the opening hand had been changed twice with no
-     way back to the earlier rule, and the revenue rates were constants in the source. Balance is
-     the open question in this game (`TODO.md`), and the way to settle it is to deal several games
-     at different settings — which needs a dialog, not a rebuild.
+     `#newgamedlg` was a third copy of the same questions, and the one that drifted: it kept the
+     multiplayer wording ("Everyone loses if COMBINED Revenue…") on a screen only ever shown to a
+     solitaire player, and explained Employee Rotation in full beside a control it had disabled.
+     Deleting it removes the drift rather than re-wording it.
 
-     Every control has a default that is the recommended answer, so DEAL with nothing touched is a
-     complete, sensible game. The settings ride in the URL alongside the seed, because a seed alone
-     no longer names a game: `?seed=430` with a different opening hand is a different railroad.
-     ==================================================================== -->
+     Nothing is lost by navigating away mid-game: `render()` calls `save()` on every frame, so the
+     game in progress is always on disk, and the setup screen offers "Continue saved game"
+     to come straight back to it. -->
 </div><!-- /gameui -->
 
-<dialog id="newgamedlg" aria-labelledby="ng-title">
-  <form method="dialog" id="newgameform">
-    <h2 class="big" id="ng-title">New game</h2>
-
-    <!-- THE SAME BLOCK THE LOBBY USES, same shared module, same order — the two screens are one
-         design. Only Solitaire can be dealt here; the multiplayer types are shown disabled rather
-         than hidden, so what this screen offers and what the lobby offers read as one list. -->
-    <div class="lb-params">
-      <label class="ng-num"><span>Seed</span>
-        <input id="ng-seed" type="text" inputmode="numeric" autocomplete="off" placeholder="blank for a random seed"></label>
-      <label class="ng-num"><span>Days</span>
-        <input id="ng-days" type="number" min="1" max="20" step="1" value="5"></label>
-    </div>
-    <p class="ng-note">The same seed and the same settings always deal the same railroad, so a game
-       can be shared, compared or replayed. Leave it blank for a random one.</p>
-
-    <h3>Game type</h3>
-    <div class="set-row" id="ng-type-row">
-      <label class="ng-radio"><input type="radio" name="ng-type" value="solitaire">
-        <span><b>Solitaire</b><br><span class="dim">One railroad, one player. The whole Division is yours to run.</span></span></label>
-      <label class="ng-radio"><input type="radio" name="ng-type" value="coop" checked>
-        <span><b>Co-op</b><br><span class="dim">Everyone&#8217;s Revenue is one table score. You win together or lose together.</span></span></label>
-      <label class="ng-radio"><input type="radio" name="ng-type" value="competitive">
-        <span><b>Competitive</b><br><span class="dim">Highest Revenue wins — unless the table misses its combined minimum, and then everyone loses.</span></span></label>
-      <label class="ng-radio"><input type="radio" name="ng-type" value="cutthroat">
-        <span><b>Cutthroat</b><br><span class="dim">Highest Revenue wins, and nothing is shared — the only way everyone loses is three collisions in one Day.</span></span></label>
-      <label class="ng-radio"><input type="radio" name="ng-type" value="custom">
-        <span><b>Custom</b><br><span class="dim">Whatever you set below. Selected for you the moment you change a rule; it is scored as the type you started from.</span></span></label>
-    </div>
-
-    <p class="ng-note" id="ng-type-note"></p>
-
-    <details id="ng-settings" open>
-      <summary>Game settings</summary>
-      <p class="ng-note">Every rule the game type sets, and every one of them yours to change.
-         Changing any of them selects <b>Custom</b>; clicking a type again resets all of them back
-         to it.</p>
-      <div class="set-groups">
-
-      <div class="set-group">
-      <h3>Starting hand</h3>
-      <p class="ng-note">What each player is dealt before the first turn. The hand limit is three
-         either way — deal six and the first turn is spent choosing which of them to keep.</p>
-      <div class="set-row" id="ng-hand-row">
-        <label class="ng-radio"><input type="radio" name="ng-hand" value="threeRandom">
-          <span><b>Three random cards</b><br><span class="dim">The original rule. At the hand limit already, and no guarantee of track.</span></span></label>
-        <label class="ng-radio"><input type="radio" name="ng-hand" value="sixRandom" checked>
-          <span><b>Six random cards</b><br><span class="dim">Twice the choice, still no guaranteed track — the first turn is a discard.</span></span></label>
-        <label class="ng-radio"><input type="radio" name="ng-hand" value="threeTrackThreeOther">
-          <span><b>Three random track and three random non-track cards</b><br><span class="dim">Dealt from two piles, so the district you can build is dealt rather than waited for.</span></span></label>
-        <span class="set-hint" id="ng-hand-hint"></span>
-      </div>
-      </div>
-
-      <div class="set-group">
-      <h3>Where an Extra may start</h3>
-      <p class="ng-note">The player who plays an Extra Train card chooses where its Crew Tray goes,
-         and the place decides which way it runs — a Division Point sends it away from itself; in the
-         middle of the railroad the player picks east or west. The Division Points and the Interchange
-         belong to nobody and are always available. Starting one inside a district is the part that
-         favours a seat, so it is set here. An Office must be a Control Point whatever this says: a
-         Whistle Post never qualifies.</p>
-      <div class="set-row" id="ng-extra-row">
-        <label class="ng-radio"><input type="radio" name="ng-extra" value="divisionPointsOnly">
-          <span><b>Division Points and the Interchange only</b><br><span class="dim">The strictest reading. Every Extra begins on shared ground.</span></span></label>
-        <label class="ng-radio"><input type="radio" name="ng-extra" value="ownOffice">
-          <span><b>Also the playing player&#8217;s own Control Point</b><br><span class="dim">You may start one at home, but not in somebody else&#8217;s district.</span></span></label>
-        <label class="ng-radio"><input type="radio" name="ng-extra" value="anyOffice">
-          <span><b>Also any player&#8217;s Control Point</b><br><span class="dim">The most permissive — an Extra may be planted in another player&#8217;s district.</span></span></label>
-        <span class="set-hint" id="ng-extra-hint"></span>
-      </div>
-      </div>
-
-      <div class="set-group">
-      <h3>Revenue</h3>
-      <p class="ng-note">What each piece of work pays, 0 to 5. A coach pays when it is boarded and
-         again when it is detrained; a load pays when it is made up and again when it is broken. Zero
-         switches an economy off so the others can be read.</p>
-      <div class="set-row" id="ng-passenger-row">
-        <label class="ng-num"><span>Passenger revenue per coach</span>
-          <input id="ng-passenger" type="number" min="0" max="5" step="1" value="1"></label>
-        <span class="set-hint" id="ng-passenger-hint"></span>
-      </div>
-      <div class="set-row" id="ng-freight-row">
-        <label class="ng-num"><span>Freight revenue per load</span>
-          <input id="ng-freight" type="number" min="0" max="5" step="1" value="1"></label>
-        <span class="set-hint" id="ng-freight-hint"></span>
-      </div>
-      <div class="set-row" id="ng-transit-row">
-        <label class="ng-num"><span>Train revenue per transit</span>
-          <input id="ng-transit" type="number" min="0" max="5" step="1" value="0"></label>
-        <span class="set-hint" id="ng-transit-hint"></span>
-      </div>
-      <p class="ng-note">A transit pays every player, once, when a train runs off the end of the
-         Division — the one thing nobody has to work for.</p>
-      </div>
-
-      <div class="set-group">
-      <h3>Victory conditions</h3>
-      <p class="ng-note">The ways this game can end badly. Each one is switched on or off in its own
-         right; how long the game runs is set above, with the table size.</p>
-      <div class="set-row" id="ng-minrev-row">
-        <label class="ng-gate"><input type="checkbox" id="ng-minrev-on" checked>
-          <span>Everyone loses if combined Revenue at the end is under</span>
-          <input id="ng-minrev" type="number" min="0" step="1" class="gate-num"></label>
-        <span class="set-hint" id="ng-minrev-hint"></span>
-      </div>
-      <div class="set-row" id="ng-colday-row">
-        <label class="ng-gate"><input type="checkbox" id="ng-colday-on" checked>
-          <span>The game ends and everyone loses if collisions in one Day reach</span>
-          <input id="ng-colday" type="number" min="0" step="1" class="gate-num"></label>
-        <span class="set-hint" id="ng-colday-hint"></span>
-      </div>
-      <div class="set-row" id="ng-coltotal-row">
-        <label class="ng-gate"><input type="checkbox" id="ng-coltotal-on" checked>
-          <span>The game ends and everyone loses after this many collisions in the whole game</span>
-          <input id="ng-coltotal" type="number" min="0" step="1" class="gate-num"></label>
-        <span class="set-hint" id="ng-coltotal-hint"></span>
-      </div>
-      <p class="ng-note">The opponent-directed cards — Derail, Watertower, Hobo Jungle and the
-         nineteen others, along with the seven that answer them — are not implemented yet, so no game
-         type deals them whatever else is set here.</p>
-      </div>
-
-      <div class="set-group">
-      <h3>Optional rules</h3>
-      <p class="ng-note">Off in every game type; each one changes how the game plays.</p>
-      <div class="set-row" id="ng-visibility-row">
-        <label class="ng-num"><span>Reduced Visibility — five switching Moves instead of six in the
-          night Stages (1&ndash;3 and 11&ndash;12)</span>
-          <input id="ng-visibility" type="checkbox"></label>
-        <span class="set-hint" id="ng-visibility-hint"></span>
-      </div>
-      <div class="set-row" id="ng-rotation-row">
-        <label class="ng-num"><span>Employee Rotation — at the end of each Day everyone moves one
-          chair left and takes over the next station up the line. Your Revenue and the Fedora go with
-          you; the district stays where it is</span>
-          <input id="ng-rotation" type="checkbox"></label>
-        <span class="set-hint" id="ng-rotation-hint"></span>
-      </div>
-      <div class="set-row" id="ng-toolbox-row">
-        <label class="ng-num"><span>Emergency Toolbox — everyone starts holding a Red Flag, so a hand
-          of four; play or discard down to three on the first turn</span>
-          <input id="ng-toolbox" type="checkbox"></label>
-        <span class="set-hint" id="ng-toolbox-hint"></span>
-      </div>
-      <div class="set-row" id="ng-tossloco-row">
-        <label class="ng-num"><span>A Timetabled train may be discarded — toss it face-up to a
-          Department slot, where a rival may pick it up. Turn this off and a train card can only ever
-          be played onto the timetable. An Extra is never discardable either way</span>
-          <input id="ng-tossloco" type="checkbox"></label>
-        <span class="set-hint" id="ng-tossloco-hint"></span>
-      </div>
-      </div>
-
-      </div>
-    </details>
-
-    <menu class="ng-buttons">
-      <span class="ng-note" id="ng-multiplayer-note" style="margin:0 auto 0 0">Use the <b>Multiplayer</b> button instead — it creates or joins a game on this server.</span>
-      <button value="cancel" id="ng-cancel" type="submit" formnovalidate>Cancel</button>
-      <button value="deal" id="ng-deal" type="submit">Deal</button>
-    </menu>
-  </form>
-</dialog>
-
 <!-- THE DAY ROLLING OVER (Gitea#10). A Day turns inside the automatic phases, so it happens
      between one click and the next; the phase banner and the announcement flash both fade before
      someone reading the board notices them. A modal stops and waits, which is the whole request:
@@ -890,6 +1031,27 @@ ul.blocked li{padding:2px 0}
   </form>
 </dialog>
 
+<!-- THE END-OF-GAME RESULTS (Gitea#16). Filled by `resultsHtml` and opened from `renderEnding`,
+     which puts it up once per ending unasked and leaves a button to reopen it. Reopenable matters:
+     Gitea#11 lets a table play past the end, and continuing must not cost you the results screen. -->
+<!-- THE EXTENSION QUESTION IS ASKED HERE, not only behind this dialog (Gitea#11 + #16).
+     This opens ITSELF at every ending, and it is modal — so `renderEnding`'s "play one more Day"
+     buttons, which it writes into `#actions`, sit underneath it. A player saw a results screen whose
+     only control was Close and reasonably concluded the game was over: reported by Jesse
+     2026-08-30, "Solitaire game ended. I did not have an option to extend the game by a day."
+     Gitea#11 was verified over the HTTP API, which renders no dialog, so the browser never was.
+     The two extension buttons are hidden unless the game is actually awaiting a vote. -->
+<dialog id="resultsdlg" aria-labelledby="rs-title">
+  <form method="dialog">
+    <div id="resultsbody"></div>
+    <menu class="ng-buttons">
+      <button value="extend-yes" id="rs-extend-yes" type="submit" hidden>Play One More Day</button>
+      <button value="extend-no" id="rs-extend-no" type="submit" hidden>End the Game Here</button>
+      <button value="ok" id="rs-ok" type="submit">Close</button>
+    </menu>
+  </form>
+</dialog>
+
 <!-- THE HANDOFF, between `Lobby.Start` and the first Frame.
      `beginRemote` used to write "… connecting to the game" into `#presence` — the DISCONNECT banner,
      whose job is `⚠ waiting on Alice`. It worked only because the first render overwrote it, and it

src/web/presets.ts

@@ -119,8 +119,14 @@ export const PRESETS: readonly Preset[] = [
     revenueFloor: (players, days) => collectiveRevenueFloor(players, days),
     rules: {
       startingHand: SIX,
-      // Nobody else's district exists, so "any Control Point" and "your own" are the same rule.
-      extraStart: 'anyOffice',
+      /**
+       * Nobody else's district exists, so "any Control Point" and "your own" are the same rule —
+       * `apply.ts` only ever rejects `ownOffice` when `start.seat !== seatOf(s, player)`, which
+       * cannot happen at one seat. It said `anyOffice` until 2026-08-30, which was true and read
+       * wrong: a solitaire player has no "any player" to contrast themselves with, so the permissive
+       * label described a permission nobody was being granted. Jesse's call; no gameplay effect.
+       */
+      extraStart: 'ownOffice',
       passengerPerCoach: 1,
       freightPerLoad: 1,
       trainPerTransit: 0,

src/web/replays.ts

@@ -26,6 +26,7 @@ import { createGame } from '../engine/setup.ts';
 import { snapshot } from '../sim/view.ts';
 import type { Intent } from '../engine/intents.ts';
 import { SOLO_CONFIG } from './game.ts';
+import { actingPlayer } from '../engine/state.ts';
 
 type Save = { seed: number; history: Intent[] };
 type Entry = { file: string; title: string; note?: string; seed?: number };
@@ -55,7 +56,12 @@ type Step = {
 function rebuild(save: Save): { steps: Step[]; stoppedEarly: boolean } {
   const s = createGame({ id: `replay-${save.seed}`, seed: save.seed, config: SOLO_CONFIG, playerNames: ['player'] });
   const steps: Step[] = [];
-  const ctx = { cardName: (id: string) => cardName(s, id), trainName: (id: string) => trainName(s, id) };
+  const ctx = {
+    cardName: (id: string) => cardName(s, id),
+    trainName: (id: string) => trainName(s, id),
+    // A player index is not a seat index, so the fallback names no number at all — see `game.ts`.
+    playerName: (p: number) => s.players[p]?.name ?? 'another player',
+  };
   const push = (events: ReturnType<typeof pump>): void => {
     const lines = events
       .filter((e) => e.type !== 'actorChanged')
@@ -69,7 +75,7 @@ function rebuild(save: Save): { steps: Step[]; stoppedEarly: boolean } {
   push(pump(s));
   let stoppedEarly = false;
   for (const intent of save.history) {
-    const actor = s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
+    const actor = actingPlayer(s);
     if (actor === null || s.status !== 'active') break;
     const r = applyIntent(s, actor, intent);
     if (!r.ok) {

src/web/session.ts

@@ -16,7 +16,10 @@
  */
 
 import type { Intent } from '../engine/intents.ts';
-import type { Frame } from '../sim/view.ts';
+import type { Frame, PublicFrame } from '../sim/view.ts';
+import { publicSnapshot } from '../sim/view.ts';
+import { takeSteps } from '../sim/display-step.ts';
+import type { DisplayStep } from '../sim/display-step.ts';
 import type { PlayerIndex } from '../engine/state.ts';
 import { applyDelta } from '../sim/frame-delta.ts';
 import type { FrameDelta } from '../sim/frame-delta.ts';
@@ -27,8 +30,8 @@ import {
   currentActor,
   fromSave,
   handPlayable,
+  isOutOfTurn,
   newGame,
-  overHandLimit,
   submit,
   toSave,
   undo,
@@ -57,8 +60,6 @@ export type Session = {
   seat(): PlayerIndex;
   /** Whose turn it is, or null when the game is over or waiting on nothing. */
   actor(): PlayerIndex | null;
-  /** True when the hand is over §6.2's limit and the turn cannot be ended. */
-  overHandLimit(): boolean;
   /** Which cards in hand are playable right now, in hand order. */
   handPlayable(): boolean[];
   /**
@@ -107,6 +108,28 @@ export type Session = {
    * starts — which is exactly when "is everyone here?" is the question.
    */
   presence(): { seat: PlayerIndex; connected: boolean; seen: boolean }[];
+  /**
+   * ORDERED PRESENTATION STEPS — v0.8.0, TODO #13. What everyone else did, in order, so it can be
+   * WATCHED rather than discovered.
+   *
+   * On the interface rather than on `LocalSession`, which is the whole point: solitaire drains its
+   * own collector and a remote session reads the same steps off `Push.steps`, so the page animates
+   * one queue and cannot tell which it has. That is what makes TODO #18 (solitaire's phases flying
+   * past) and TODO #13 (multiplayer's invisible turns) the same code path.
+   *
+   * NOT `steps()` — `LocalSession.steps()` already exists and counts submitted intents for the Undo
+   * button. Different thing entirely, hence the longer name.
+   */
+  takeDisplaySteps(): DisplayStep[];
+  /**
+   * A public frame to start the queue from, once — draining, and non-null only when the queue must
+   * be RESET rather than advanced.
+   *
+   * Steps carry deltas against a chain, so a client with no baseline cannot merge the next one. That
+   * happens on a first connect, on a reconnect, and locally after an undo or a restore — all of
+   * which rebuild from scratch. A reset means "throw away what is queued and draw this".
+   */
+  takeDisplayReset(): PublicFrame | null;
   /**
    * Stop listening, for good.
    *
@@ -147,6 +170,12 @@ export type LocalSession = Session & {
  */
 export function createLocalSession(seed: number, options?: NewGameOptions): LocalSession {
   let game: Game = options ? newGame(seed, configWith(options)) : newGame(seed);
+  /**
+   * The baseline the step queue starts from. Set here, and again whenever the game is REPLACED —
+   * `undo` and `restore` rebuild by replaying history, which (by design) collects no steps, so the
+   * queue has to be told to start over rather than left holding a chain that no longer continues.
+   */
+  let pendingReset: PublicFrame | null = publicSnapshot(game.state);
   const listeners = new Set<() => void>();
   const changed = (): void => {
     for (const fn of [...listeners]) fn();
@@ -160,10 +189,11 @@ export function createLocalSession(seed: number, options?: NewGameOptions): Loca
     menu: () => actionMenu(game),
     seat: () => 0,
     actor: () => currentActor(game),
-    overHandLimit: () => overHandLimit(game),
     handPlayable: () => handPlayable(game),
     submit: async (intent: Intent) => {
-      const ok = submit(game, intent);
+      // Seat 0 is the solitaire player, and the extension vote (Gitea#11) is the one intent that
+      // arrives when `currentActor` is null — so it has to name its seat. See `isOutOfTurn`.
+      const ok = submit(game, intent, isOutOfTurn(intent) ? 0 : null);
       if (ok) changed();
       return ok;
     },
@@ -187,6 +217,14 @@ export function createLocalSession(seed: number, options?: NewGameOptions): Loca
     },
     justDrawn: () => game.justDrawn,
     presence: () => [],
+    // Solitaire's own steps, from the same collector `submit()` fills for every seat of a
+    // multiplayer game. No separate code path — see `sim/display-step.ts`.
+    takeDisplaySteps: () => takeSteps(game.display),
+    takeDisplayReset: () => {
+      const reset = pendingReset;
+      pendingReset = null;
+      return reset;
+    },
 
     seed: () => game.seed,
     save: () => toSave(game),
@@ -200,6 +238,8 @@ export function createLocalSession(seed: number, options?: NewGameOptions): Loca
       back.scheduled = null;
       back.justDrawn = null;
       back.announced = null;
+      // The rebuilt game has an empty collector and a chain that starts over, so the queue must too.
+      pendingReset = publicSnapshot(back.state);
       changed();
       return true;
     },
@@ -208,6 +248,7 @@ export function createLocalSession(seed: number, options?: NewGameOptions): Loca
       // Restoring replays the whole history and re-records every draw; none of it is news.
       game.justDrawn = null;
       game.announced = null;
+      pendingReset = publicSnapshot(game.state);
       changed();
     },
   };
@@ -221,6 +262,10 @@ type Push = {
   lines: { text: string; tone: string }[];
   /** One entry for a change; every other seat at once on the connect push. */
   presence?: { seat: PlayerIndex; connected: boolean; seen: boolean }[];
+  /** Ordered presentation steps — v0.8.0, identical in every seat's push because they are public. */
+  steps?: DisplayStep[];
+  /** The baseline for the step queue, sent on a connect only. */
+  publicReset?: PublicFrame;
   /**
    * THE FOUR TRANSIENT SIGNALS, added 2026-08-23.
    *
@@ -271,6 +316,8 @@ export function createRemoteSession(
   let menu: Menu | null = null;
   let lines: { text: string; tone: string }[] = [];
   const presence = new Map<PlayerIndex, { connected: boolean; seen: boolean }>();
+  let displaySteps: DisplayStep[] = [];
+  let displayReset: PublicFrame | null = null;
   let cues: string[] = [];
   let scheduled: number | null = null;
   let announcement: string | null = null;
@@ -325,6 +372,21 @@ export function createRemoteSession(
     if (push.announcement !== undefined && push.announcement !== null) announcement = push.announcement;
     // Persists until another draw replaces it, matching the local session's own `justDrawn`.
     if (push.justDrawn !== undefined) justDrawnCard = push.justDrawn;
+    /**
+     * A RESET DISCARDS WHAT WAS QUEUED, rather than arriving alongside it.
+     *
+     * `publicReset` comes on a connect, which is also a RECONNECT — and a reconnecting client's
+     * queue holds steps whose deltas chain off a baseline the server has since moved past. Merging
+     * them onto the new baseline would draw a board that never existed. The history panel is what
+     * carries what was missed; the animation does not replay it (§ v0.8.0).
+     */
+    if (push.publicReset) {
+      displayReset = push.publicReset;
+      displaySteps = [];
+    }
+    // Accumulated, like cues: two pushes can land between two renders and every step is one thing
+    // that happened.
+    if (push.steps) displaySteps = [...displaySteps, ...push.steps];
     changed();
   };
 
@@ -338,7 +400,6 @@ export function createRemoteSession(
     menu: () => menu ?? { options: [], direct: [], placeable: [], hand: [], makeUp: null },
     seat: () => seat,
     actor: () => need().actor,
-    overHandLimit: () => need().overHandLimit,
     handPlayable: () => (menu?.hand ?? []).map((h) => h.playNow !== null),
     async submit(intent: Intent): Promise<boolean> {
       const seq = nextSeq++;
@@ -378,6 +439,12 @@ export function createRemoteSession(
     },
     justDrawn: () => justDrawnCard,
     presence: () => [...presence].map(([seat, p]) => ({ seat, connected: p.connected, seen: p.seen })),
+    takeDisplaySteps: () => displaySteps.splice(0, displaySteps.length),
+    takeDisplayReset: () => {
+      const reset = displayReset;
+      displayReset = null;
+      return reset;
+    },
     close() {
       // `reportedGone` first: closing the stream fires `onerror`, and this is a deliberate exit, not
       // a game that vanished — `onGone` must not be called and land the page in "that game is no

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 => {

src/web/step-queue.ts

@@ -0,0 +1,260 @@
+/**
+ * THE ANIMATION QUEUE — v0.8.0, `docs/plans/jitsi-common-board.md` § v0.8.0 §§ 4-6.
+ *
+ * Holds the public board the screen is currently showing, which is not always the board the game is
+ * actually on. Steps arrive faster than a person can follow — a bot's whole switching turn lands in
+ * ONE push, because `driveBots()` plays it out before the push goes back — so this is what turns a
+ * burst into something watchable. TODO #13.
+ *
+ * TRANSPORT-AGNOSTIC ON PURPOSE. It takes `DisplayStep`s and does not care whether they came from
+ * the engine in this tab or off an SSE stream, which is what lets solitaire (#18: phases that are
+ * never drawn) and multiplayer (#13: turns you never see) run one implementation. Nothing here
+ * imports the DOM either, so it is testable without one.
+ *
+ * NO TIMERS OF ITS OWN. The caller drives it with `advance(now)` from whatever loop it already has
+ * — a `requestAnimationFrame`, a test's fake clock. A queue that owned a `setInterval` would need
+ * starting, stopping and cleaning up on every game replacement, and would be untestable without
+ * faking timers.
+ */
+
+import type { PublicFrame } from '../sim/view.ts';
+import type { DisplayStep } from '../sim/display-step.ts';
+import { applyPublicDelta, changedDivisionCards, changedPiles } from '../sim/public-delta.ts';
+import type { PileKey } from '../sim/public-delta.ts';
+import { dwellForStep } from '../sim/pacing.ts';
+
+export type StepQueue = {
+  /** Throw away what is queued and show this board — a first connect, a reconnect, an undo. */
+  reset(frame: PublicFrame): void;
+  /** Queue steps to be shown in order. */
+  push(steps: readonly DisplayStep[]): void;
+  /**
+   * Show as much as `now` allows. Returns true if the displayed board changed, so a caller can skip
+   * a redraw when nothing did.
+   */
+  advance(now: number): boolean;
+  /** Show everything immediately. Returns true if anything was skipped. */
+  skip(): boolean;
+  /** The board to draw, or null before any reset has arrived. */
+  current(): PublicFrame | null;
+  /**
+   * How many queued steps the player is still going to WATCH — the number the "N behind" counter
+   * shows. Not the queue length: see `watchableCount` in `sim/pacing.ts`.
+   */
+  behind(): number;
+  /** The last step actually shown, for the caption line (#15). Null before anything has been shown. */
+  showing(): DisplayStep | null;
+  /**
+   * The piles the step now on screen moved, for the display to light.
+   *
+   * Here because this is the only place that holds both the frame before a step and the frame after
+   * it — deriving it anywhere else would mean keeping a second copy of the board in step.
+   */
+  lit(): readonly PileKey[];
+  /** True while there is anything left to show. */
+  busy(): boolean;
+  /**
+   * How many narrated lines belong to steps NOT yet shown.
+   *
+   * The log and the board are two different moments while the queue is behind: a push carries its
+   * narration and its steps together, so every line of a bot's turn is in the history panel before the
+   * board has drawn a single move of it (playtest, 2026-09-15: *"is it possible to stall history so it
+   * stays in sync with the number behind?"*). Those lines are the TAIL of the log — they arrived last —
+   * so the caller holds back exactly this many and reveals each as its step goes up.
+   */
+  pendingLines(): number;
+  /** Division nodes whose card changed in the step now on screen, for the map to flash. */
+  flashing(): readonly number[];
+  /**
+   * HOLD THE PLAYBACK ON THE STEP NOW SHOWING — Jesse, playtest 2026-09-16, asking for a pause
+   * beside Skip.
+   *
+   * Skip is the only control the row has had, and it is one-way and total: the way to look harder at
+   * a move that just went past was to not be too slow about it. Pause is the opposite lever — the
+   * board stops where it is and nothing is consumed, so a player can read the caption, look at the
+   * district and then carry on from exactly that step.
+   *
+   * TAKES `now` BECAUSE THE QUEUE OWNS NO CLOCK (see the note at the top of this file). The dwell
+   * still owing is preserved across the hold rather than being spent while nobody was watching:
+   * `resume` pushes the deadline out by however long the pause lasted, so a step paused with 200ms
+   * left resumes with 200ms left instead of vanishing on the next frame.
+   *
+   * Returns false when there is nothing to hold, or nothing being held.
+   */
+  pause(now: number): boolean;
+  resume(now: number): boolean;
+  paused(): boolean;
+};
+
+/**
+ * WHOSE MOVE THE SCREEN IS SHOWING (Gitea#25).
+ *
+ * The game and the board on screen are two different moments. The server plays every bot move the
+ * instant a human's turn ends (`driveBots`), so the LIVE game is nearly always waiting on the human —
+ * while this queue is still replaying the bots, step by step. The turn chart and the Division map's
+ * move marker read the live actor, so a table of one person and three bots said "waiting on" that
+ * person throughout, against a playback row naming the bot actually moving.
+ *
+ * While the queue is behind or still showing a step, the answer is that step's player — `null` for an
+ * automatic phase, which is "the Division is running itself". Otherwise it is the live actor, and
+ * `replaying` is false so a caller can keep live-only detail, such as a ruling the game is waiting on,
+ * off a screen that has not caught up with it yet.
+ */
+export function actorOnScreen(
+  queue: Pick<StepQueue, 'behind' | 'busy' | 'showing'>,
+  live: number | null,
+): { actor: number | null; replaying: boolean } {
+  if (queue.behind() === 0 && !queue.busy()) return { actor: live, replaying: false };
+  const shown = queue.showing();
+  return shown === null ? { actor: live, replaying: false } : { actor: shown.player, replaying: true };
+}
+
+/**
+ * `pace` is read on every step rather than captured, so changing the setting takes effect at once.
+ *
+ * `viewer` says which seat is watching, so THIS PLAYER'S OWN MOVES COST NO TIME. They are already on
+ * screen: a seated player's own board is drawn from their authoritative `Frame`, not from the queue,
+ * so holding their click for a dwell shows them nothing and delays the thing they actually want to
+ * watch — the 700ms before a bot's turn starts animating is 700ms of their own move being replayed
+ * at them. The step is still APPLIED, because the delta chain runs through it.
+ *
+ * Automatic phases have no player and are unaffected, which is what keeps TODO #18 working in
+ * solitaire where every intent is the viewer's own.
+ */
+export function createStepQueue(
+  pace: () => number = () => 1,
+  viewer: () => number | null = () => null,
+): StepQueue {
+  let shown: PublicFrame | null = null;
+  let last: DisplayStep | null = null;
+  let litPiles: readonly PileKey[] = [];
+  let flashedCards: readonly number[] = [];
+  let pending: DisplayStep[] = [];
+  /** When the step now on screen is due to give way. Null when nothing is waiting. */
+  let dueAt: number | null = null;
+  /** When the player pressed Pause, so `resume` can give the current step back the time it had. */
+  let pausedAt: number | null = null;
+
+  /** How long this step holds the screen — zero for the viewer's own moves; see above. */
+  const dwell = (step: DisplayStep): number =>
+    step.player !== null && step.player === viewer() ? 0 : dwellForStep(step, pace());
+
+  /** Applies one step to the displayed board. A step's delta chains off the previous step's frame. */
+  const show = (step: DisplayStep): void => {
+    const before = shown;
+    shown = applyPublicDelta(shown, step.frame);
+    last = step;
+    /**
+     * NOT FOR YOUR OWN MOVES. You drew that card; you do not need the deck flashed at you. Same rule
+     * that gives your own steps no dwell — the display is for watching everybody else.
+     */
+    litPiles = step.player !== null && step.player === viewer() ? [] : changedPiles(before, shown);
+    // A Realignment changes the Division under everyone, so it is flashed for the player who did it
+    // too — unlike a pile, which only tells the drawer what they already know.
+    flashedCards = changedDivisionCards(before, shown);
+  };
+
+  return {
+    reset(frame) {
+      shown = frame;
+      pending = [];
+      dueAt = null;
+      // A reconnect, an undo or a fresh deal replaces the board outright; a hold on the playback that
+      // no longer exists would leave the row stuck reading "paused" with nothing behind it.
+      pausedAt = null;
+      // Nothing was watched arriving at this board, so nothing on it is lit.
+      litPiles = [];
+      flashedCards = [];
+      // `last` deliberately survives: a reconnect should not blank the caption line, and the
+      // sentence describing the most recent action is still true.
+    },
+
+    push(steps) {
+      pending.push(...steps);
+    },
+
+    advance(now) {
+      // Held. Nothing is shown and, crucially, nothing is CONSUMED — `dueAt` is left where it was
+      // and `resume` moves it, so the hold costs the current step none of its dwell.
+      if (pausedAt !== null) return false;
+      if (pending.length === 0) {
+        // The LAST step of a burst still owes its dwell. Clearing `dueAt` here reported the queue
+        // idle the instant that step was shown, which snapped the district panel home before anyone
+        // could look at it — see `busy()`.
+        if (dueAt !== null && now >= dueAt) dueAt = null;
+        return false;
+      }
+      // First step of a burst: show it immediately rather than waiting out a dwell for a board the
+      // player has not been shown yet.
+      if (dueAt === null) {
+        const first = pending.shift()!;
+        show(first);
+        dueAt = now + dwell(first);
+        return true;
+      }
+      let drew = false;
+      /**
+       * A LOOP, not a single step. A dwell of zero means "do not spend the player's attention on
+       * this" — bookkeeping, and phases where nothing happened (TODO #18) — so a run of them must
+       * collapse within one call instead of costing a frame each. The board still passes through
+       * every state in order; nobody is shown a state that never existed.
+       */
+      while (pending.length > 0 && now >= dueAt) {
+        const next = pending.shift()!;
+        show(next);
+        dueAt = dueAt + dwell(next);
+        drew = true;
+      }
+      if (pending.length === 0 && now >= dueAt) dueAt = null;
+      return drew;
+    },
+
+    skip() {
+      // Skipping while held is a decision to stop watching, so it also lifts the hold — otherwise the
+      // board would jump to the game and then sit there paused, with a Resume button that does nothing.
+      pausedAt = null;
+      if (pending.length === 0) return false;
+      for (const step of pending) show(step);
+      pending = [];
+      dueAt = null;
+      return true;
+    },
+
+    pause(now) {
+      if (pausedAt !== null) return false;
+      // Nothing on screen owes any time and nothing is queued: there is no playback to hold.
+      if (pending.length === 0 && dueAt === null) return false;
+      pausedAt = now;
+      return true;
+    },
+
+    resume(now) {
+      if (pausedAt === null) return false;
+      // Give the step on screen back exactly the dwell it was holding when the player pressed Pause.
+      if (dueAt !== null) dueAt += now - pausedAt;
+      pausedAt = null;
+      return true;
+    },
+
+    paused: () => pausedAt !== null,
+
+    current: () => shown,
+    behind: () => pending.filter((s) => dwell(s) > 0).length,
+    showing: () => last,
+    lit: () => litPiles,
+    /**
+     * STILL SHOWING SOMETHING, not just still holding something back.
+     *
+     * This was `pending.length > 0`, which went false the moment the last step of a burst was
+     * shown — so the animation loop stopped and the district panel snapped back to the viewer's own
+     * board without that step ever being visible. Reported from real play: "I briefly saw that it was
+     * the bot's office area, then their turn was done and it pointed back to my office area."
+     *
+     * `dueAt` is non-null exactly while the step on screen has time left, so the two together mean
+     * "there is more to come, or what is up has not had its moment yet".
+     */
+    pendingLines: () => pending.reduce((n, s) => n + s.lines.length, 0),
+    flashing: () => flashedCards,
+    busy: () => pending.length > 0 || dueAt !== null,
+  };
+}

test/advance.test.ts

@@ -66,6 +66,21 @@ function playToCompletion(s: GameState, seed = 1, maxTurns = 20_000): PlayStats
     tally(pump(s));
     if (s.status === 'finished') break;
 
+    /**
+     * §3.3, EXTENDED PLAY (Gitea#11) — this harness plays the timetable it was dealt.
+     *
+     * It picks at random among legal options, and one of the two options here is "play another
+     * Day" — so left alone it would extend the game forever and terminate only on `maxTurns`. That
+     * is not a bug in the feature: a game genuinely does not end now until somebody says stop, and
+     * `developerBot` says stop for exactly this reason. Said explicitly here rather than folded
+     * into the random pick, because "how does this loop terminate" deserves an answer in the loop.
+     */
+    if (s.status === 'awaitingExtension') {
+      const r = applyIntent(s, 0, { type: 'game.extend', player: 0, agree: false });
+      assert.ok(r.ok, 'a solitaire player could not decline an extension');
+      break;
+    }
+
     const actor = s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
     if (actor === null) break;
 
@@ -480,7 +495,7 @@ describe('the Superintendent clearance interrupt (§8.1)', () => {
     assert.equal(r.needsInput, true, 'the phase must stop and ask');
     assert.notEqual(s.clock.pendingDecision, null);
     assert.equal(s.clock.pendingDecision!.train, 'behind');
-    assert.equal(s.clock.pendingDecision!.occupiedBy, 'ahead');
+    assert.equal((s.clock.pendingDecision as { occupiedBy: string }).occupiedBy, 'ahead');
   });
 
   it('does not ask when the train ahead is coming the other way — that is an absolute bar', () => {
@@ -526,7 +541,7 @@ describe('the Superintendent clearance interrupt (§8.1)', () => {
   it('clears the decision once the Superintendent rules', () => {
     const s = game();
     s.clock.phase = 'mainline';
-    s.clock.pendingDecision = { train: 'a', occupiedBy: 'b' };
+    s.clock.pendingDecision = { kind: 'clearance', train: 'a', occupiedBy: 'b' };
     const r = applyIntent(s, 0, { type: 'mainline.clearance', allow: false });
     assert.ok(r.ok);
     assert.equal(s.clock.pendingDecision, null);
@@ -544,9 +559,13 @@ describe('victory conditions (§3, Gap 10e) — unified 2026-08-20', () => {
     s.clock.phase = 'shiftChange';
     s.players[0]!.revenue = 0;
     advance(s);
-    assert.equal(s.status, 'finished');
+    // PAUSES rather than finishes since Gitea#11: a days-based ending offers another Day, and the
+    // result is recorded either way. `official` is the frozen answer; `status` is only where play
+    // has got to. The two collision tests at the foot of this block are the contrast.
+    assert.equal(s.status, 'awaitingExtension');
     assert.equal(s.outcome!.result, 'loss');
     assert.equal(s.outcome!.reason, 'revenueFloor');
+    assert.equal(s.official!.outcome.reason, 'revenueFloor');
   });
 
   it('wins a timed Solitaire game that clears minCombinedRevenue', () => {
@@ -556,7 +575,7 @@ describe('victory conditions (§3, Gap 10e) — unified 2026-08-20', () => {
     s.clock.phase = 'shiftChange';
     s.players[0]!.revenue = 10;
     advance(s);
-    assert.equal(s.status, 'finished');
+    assert.equal(s.status, 'awaitingExtension');
     assert.equal(s.outcome!.result, 'win');
   });
 
@@ -567,7 +586,7 @@ describe('victory conditions (§3, Gap 10e) — unified 2026-08-20', () => {
     s.clock.phase = 'shiftChange';
     s.players[0]!.revenue = 0;
     advance(s);
-    assert.equal(s.status, 'finished');
+    assert.equal(s.status, 'awaitingExtension');
     assert.equal(s.outcome!.result, 'win');
   });
 
@@ -582,7 +601,7 @@ describe('victory conditions (§3, Gap 10e) — unified 2026-08-20', () => {
     s.players[0]!.revenue = 5; // best individual score...
     s.players[1]!.revenue = 3; // ...but combined (8) still misses the floor (20).
     advance(s);
-    assert.equal(s.status, 'finished');
+    assert.equal(s.status, 'awaitingExtension');
     assert.equal(s.outcome!.result, 'loss');
     assert.equal(s.outcome!.reason, 'revenueFloor');
   });
@@ -598,7 +617,7 @@ describe('victory conditions (§3, Gap 10e) — unified 2026-08-20', () => {
     s.players[0]!.revenue = 4;
     s.players[1]!.revenue = 6; // combined 10 clears the floor, neither alone would.
     advance(s);
-    assert.equal(s.status, 'finished');
+    assert.equal(s.status, 'awaitingExtension');
     assert.equal(s.outcome!.result, 'win');
     assert.equal(s.outcome!.winner, null, 'Co-op names an individual winner instead of a shared one');
   });
@@ -636,13 +655,36 @@ describe('victory conditions (§3, Gap 10e) — unified 2026-08-20', () => {
     assert.notEqual(s.status, 'finished');
   });
 
-  it('solitaire never checks the collision floor, whatever the counts', () => {
+  it('solitaire checks the collision floor too, like every other mode', () => {
+    /**
+     * REVERSED 2026-08-30, and this test previously asserted the opposite ("solitaire never checks
+     * the collision floor, whatever the counts").
+     *
+     * The exclusion was never a stated rule — §3.4 does not carve solitaire out — and nothing on
+     * screen reflected it: `SOLO_CONFIG` carried both limits, the New Game dialog offered them as
+     * live settings, and the text beside them said the game would end in a loss. A solitaire player
+     * could set a limit of 1 and crash all game. Found reviewing that screen's wording; Jesse's
+     * ruling is that the settings do what they say.
+     */
     const s = game(1, { mode: 'solitaire', maxCollisionsPerDay: 1, maxCollisionsTotal: 1 });
     s.collisionsToday = 99;
     s.collisionsTotal = 99;
     s.clock.stage = 1;
     s.clock.phase = 'shiftChange';
     advance(s);
+    assert.equal(s.status, 'finished');
+    assert.equal(s.outcome!.reason, 'collisionFloor');
+  });
+
+  it('still lets a solitaire game switch the collision floor off with 0', () => {
+    // The disable path is what a player who does not want the new ending reaches for, so it has to
+    // work at one seat exactly as it does at four.
+    const s = game(1, { mode: 'solitaire', maxCollisionsPerDay: 0, maxCollisionsTotal: 0 });
+    s.collisionsToday = 99;
+    s.collisionsTotal = 99;
+    s.clock.stage = 1;
+    s.clock.phase = 'shiftChange';
+    advance(s);
     assert.notEqual(s.status, 'finished');
   });
 });
@@ -730,43 +772,156 @@ describe('MILESTONE: a full solitaire game runs headless', () => {
   });
 });
 
-describe('X18 Circus Train — a point for standing still', () => {
-  it('pays once for a Stage spent stopped, and never again', () => {
-    /**
-     * REPORTED: "Circus train TX18 was stopped on a siding for a full Stage and I did not get my
-     * Revenue point." It never could: `stopEarnsPoint` was declared on the profile and read
-     * NOWHERE, along with eight other special-train rules. The one card in the deck that pays for
-     * standing still paid nothing.
-     */
-    const s = game();
+describe('X18 Circus / X17 Campaign — a point for setting up (Gitea#13)', () => {
+  /**
+   * REPORTED originally: "Circus train TX18 was stopped on a siding for a full Stage and I did not
+   * get my Revenue point." It never could: `stopEarnsPoint` was declared on the profile and read
+   * NOWHERE, along with eight other special-train rules.
+   *
+   * REDEFINED by Gitea#13 (Jesse, 2026-08-29), and these tests carry the three parts of that
+   * ruling: the point is paid ONCE PER OFFICE AREA rather than once per game, only when the train
+   * is FULLY LOADED, and only in an Office Area at all.
+   */
+  const circusAt = (s: GameState, seat: number, coord: { row: number; col: number }, consist: unknown[]) => {
     s.clock.phase = 'mainline';
     s.trays.set('circus', {
       id: 'circus', trainNumber: 18, trainIsExtra: true, engineAt: 0,
-      consist: [], direction: 'east',
-      position: { at: 'grid', seat: 0, coord: { row: -1, col: 0 } },
+      consist, direction: 'east',
+      position: { at: 'grid', seat, coord },
       movesUsed: 0,
     } as never);
     // A card under it, so the crew is somewhere real rather than off the grid.
-    areaOf(s, 0).grid.set('-1,0', {
+    areaOf(s, seat as never).grid.set(`${coord.row},${coord.col}`, {
       geometry: { kind: 'track', geometry: 'straight' },
       baseOperationalRail: true, standing: [], facility: null, modifiers: [], enhancements: [],
     } as never);
+  };
 
+  const loaded = [
+    { type: 'boxcar', loaded: true },
+    { type: 'boxcar', loaded: true },
+    { type: 'coach', loaded: true },
+    { type: 'caboose', loaded: true },
+  ];
+
+  const runPhase = (s: GameState) => {
+    s.clock.phase = 'mainline';
+    s.movedThisPhase = new Set();
+    return pump(s);
+  };
+
+  it('pays a fully loaded Circus for a Stage spent set up', () => {
+    const s = game();
+    circusAt(s, 0, { row: -1, col: 0 }, loaded);
     const before = s.players[0]!.revenue;
-    const first = pump(s);
     assert.ok(
-      first.some((e) => e.type === 'trainStoodStill' && e.trainNumber === 18),
+      pump(s).some((e) => e.type === 'trainStoodStill' && e.trainNumber === 18),
       'the Circus Train stood still for a Stage and earned nothing',
     );
     assert.equal(s.players[0]!.revenue, before + 1, 'the point was not paid');
+  });
 
-    // "One turn stopped" — once. A train that goes on standing there does not keep earning.
-    const paidAgain = () => {
-      s.clock.phase = 'mainline';
-      s.movedThisPhase = new Set();
-      return pump(s).some((e) => e.type === 'trainStoodStill');
-    };
-    assert.ok(!paidAgain(), 'the Circus Train collected a second time for the same set-up');
+  it('pays once per Office Area, however long it parks there', () => {
+    // "Once per stop in an office area" — a train that goes on standing in the same district does
+    // not keep earning. This is the half that was already true, for a different reason.
+    const s = game();
+    circusAt(s, 0, { row: -1, col: 0 }, loaded);
+    pump(s);
+    assert.ok(!runPhase(s).some((e) => e.type === 'trainStoodStill'),
+      'the Circus collected twice for the same set-up');
+    assert.ok(!runPhase(s).some((e) => e.type === 'trainStoodStill'),
+      'the Circus collected a third time for the same set-up');
+  });
+
+  it('pays AGAIN in a different district — each player can be visited', () => {
+    /**
+     * The half that is new. "In a multiplayer game, each player could score if the circus stops in
+     * their area" — so the claim is per seat, and a touring Circus is paid by each district it sets
+     * up in. Before Gitea#13 this paid once per GAME and the second district got nothing.
+     */
+    const s = createGame({
+      id: 'g', seed: 5, config: baseConfig({ mode: 'competitive' }), playerNames: ['A', 'B'],
+    });
+    circusAt(s, 0, { row: -1, col: 0 }, loaded);
+    pump(s);
+    const paidFirst = s.players.map((p) => p.revenue);
+
+    // The same train, moved into the other player's district.
+    const tray = s.trays.get('circus')!;
+    areaOf(s, 1 as never).grid.set('-1,0', {
+      geometry: { kind: 'track', geometry: 'straight' },
+      baseOperationalRail: true, standing: [], facility: null, modifiers: [], enhancements: [],
+    } as never);
+    tray.position = { at: 'grid', seat: 1, coord: { row: -1, col: 0 } } as never;
+
+    assert.ok(runPhase(s).some((e) => e.type === 'trainStoodStill'),
+      'the Circus set up in a second district and earned nothing');
+    const owner = s.seating[1]!;
+    assert.equal(
+      s.players[owner]!.revenue,
+      paidFirst[owner]! + 1,
+      'the point did not go to whoever sits in the district it stopped in',
+    );
+  });
+
+  it('pays nothing when the cars are empty — "not much of a circus"', () => {
+    const s = game();
+    circusAt(s, 0, { row: -1, col: 0 }, [
+      { type: 'boxcar', loaded: false },
+      { type: 'coach', loaded: true },
+      { type: 'caboose', loaded: true },
+    ]);
+    const before = s.players[0]!.revenue;
+    assert.ok(!pump(s).some((e) => e.type === 'trainStoodStill'),
+      'an empty car aboard still collected the set-up point');
+    assert.equal(s.players[0]!.revenue, before, 'Revenue moved for a train that was not full');
+  });
+
+  it('pays nothing to a train carrying nothing at all', () => {
+    // `every` on an empty list is vacuously true, so the emptiest train of the lot is exactly the
+    // one a careless test would pay.
+    const s = game();
+    circusAt(s, 0, { row: -1, col: 0 }, []);
+    assert.ok(!pump(s).some((e) => e.type === 'trainStoodStill'),
+      'a Circus carrying nothing was paid for setting up');
+  });
+
+  it('pays nothing for standing out on the Mainline', () => {
+    /**
+     * It used to, and it misattributed the point: `playerAtSeat` needs a seat, there is none off
+     * the grid, and the fallback handed it to PLAYER 0 wherever the train was standing. Jesse's
+     * ruling scopes the rule to Office Areas, which removes the bug rather than patching it.
+     */
+    const s = game();
+    s.clock.phase = 'mainline';
+    const index = s.division.nodes.findIndex((n) => n.kind === 'mainline');
+    s.trays.set('circus', {
+      id: 'circus', trainNumber: 18, trainIsExtra: true, engineAt: 0,
+      consist: loaded, direction: 'east',
+      position: { at: 'mainline', index },
+      movesUsed: 0,
+    } as never);
+    const before = s.players[0]!.revenue;
+    pump(s);
+    assert.equal(s.players[0]!.revenue, before, 'a Mainline set-up paid a point');
+  });
+
+  it('pays the Campaign Train only when its candidate is aboard', () => {
+    // X17 carries one coach and no freight, so "fully loaded" is exactly "the coach is occupied".
+    // It earned nothing at all before Gitea#13 — it had `stopThenExpedite` and no scoring rule.
+    const occupied = game();
+    circusAt(occupied, 0, { row: -1, col: 0 }, [{ type: 'coach', loaded: true }]);
+    occupied.trays.get('circus')!.trainNumber = 17;
+    const beforeOccupied = occupied.players[0]!.revenue;
+    pump(occupied);
+    assert.equal(occupied.players[0]!.revenue, beforeOccupied + 1, 'a full Campaign Train earned nothing');
+
+    const empty = game();
+    circusAt(empty, 0, { row: -1, col: 0 }, [{ type: 'coach', loaded: false }]);
+    empty.trays.get('circus')!.trainNumber = 17;
+    const beforeEmpty = empty.players[0]!.revenue;
+    pump(empty);
+    assert.equal(empty.players[0]!.revenue, beforeEmpty, 'an empty Campaign Train was paid for its speech');
   });
 });
 
@@ -986,7 +1141,12 @@ describe('the history says WHY a train moved, and says it truthfully', () => {
 
     // A train ahead of it in the same Subdivision, running the SAME way — §8.1's fourth condition,
     // which is the Superintendent's call rather than an absolute bar.
-    const ahead = s.division.nodes.findIndex((n) => n.kind === 'mainline');
+    //
+    // AHEAD MEANS EAST OF THE OFFICE for this eastbound train. This used to take the FIRST Mainline card
+    // in the Division, which is west of the Office — behind the train — and still expected a ruling,
+    // which is exactly the fault Gitea#26 reported. The card is now one the train would actually follow.
+    const office = s.division.nodes.findIndex((n) => n.kind === 'office' && n.seat === 0);
+    const ahead = s.division.nodes.findIndex((n, i) => i > office && n.kind === 'mainline');
     const node = s.division.nodes[ahead];
     assert.equal(node?.kind, 'mainline');
     s.trays.set('ahead', {
@@ -1272,7 +1432,7 @@ describe('an Extra starts where the player puts it (Gitea#4)', () => {
       const r = advance(s);
       assert.equal(r.needsInput, true, 'the phase must stop and ask');
       assert.equal(s.clock.pendingDecision?.train, tray.id);
-      assert.equal(s.clock.pendingDecision?.occupiedBy, 'ahead');
+      assert.equal((s.clock.pendingDecision as { occupiedBy: string } | null)?.occupiedBy, 'ahead');
 
       // HOLD keeps it in the yard.
       assert.ok(applyIntent(s, s.clock.superintendent, { type: 'mainline.clearance', allow: false }).ok);
@@ -1356,3 +1516,69 @@ describe('an Extra starts where the player puts it (Gitea#4)', () => {
     assert.equal(check(s, 0, at), 'NO_EXTRA_PENDING');
   });
 });
+
+// ---------------------------------------------------------------------------
+
+describe('§8.1 counts only trains AHEAD of the one departing (Gitea#26)', () => {
+  /**
+   * REPORTED from playtesting v0.8.0.9: two westbound Extras, X15 at an Office and X18 still crossing
+   * the card to its EAST. The Superintendent was asked to rule on X15 against X18 — a train behind it —
+   * and holding X15 kept the Whistle Post's only A/D track full, so X18 arrived into it and was
+   * destroyed. Reproduced by replaying the exported save; the positions below are that situation in a
+   * one-seat Division, where every Office is a Whistle Post and the Subdivision spans them all.
+   */
+  const setup = (occupant: { direction: 'east' | 'west'; side: 'east' | 'west'; number: number }) => {
+    const s = game(7, { days: 5 });
+    const area = areaOf(s, 0);
+    const office = s.division.nodes.findIndex((n) => n.kind === 'office' && n.seat === 0);
+    s.trays.set('departing', {
+      id: 'departing', trainNumber: 15, trainIsExtra: true, engineAt: 0, consist: [],
+      direction: 'west', facing: 'w',
+      position: { at: 'grid', seat: 0, coord: area.officeCoord }, movesUsed: 0,
+    });
+    area.adOccupancy.push('departing');
+    const card = s.division.nodes.findIndex((n, i) =>
+      n.kind === 'mainline' && (occupant.side === 'east' ? i > office : i < office));
+    const node = s.division.nodes[card];
+    assert.equal(node?.kind, 'mainline');
+    s.trays.set('other', {
+      id: 'other', trainNumber: occupant.number, trainIsExtra: true, engineAt: 0, consist: [],
+      direction: occupant.direction, facing: occupant.direction === 'east' ? 'e' : 'w',
+      position: { at: 'mainline', index: card }, movesUsed: 0,
+    });
+    if (node?.kind === 'mainline') {
+      node.transits.push({ tray: 'other', stagesRemaining: 2, stagesTotal: 2, direction: occupant.direction });
+    }
+    s.clock.phase = 'mainline';
+    return s;
+  };
+
+  it('does not put a same-direction train BEHIND the departing one to the Superintendent', () => {
+    const s = setup({ direction: 'west', side: 'east', number: 18 });
+    const r = advance(s);
+    assert.ok(!r.events.some((e) => e.type === 'clearanceRequested'), 'a train behind was put to the Superintendent');
+    assert.ok(
+      r.events.some((e) => e.type === 'trainHighballed' && e.trainNumber === 15),
+      'the departing train did not highball with nothing ahead of it',
+    );
+    assert.ok(!r.events.some((e) => e.type === 'trainsDestroyed'), 'a train was destroyed');
+  });
+
+  it('does not bar a departure over an opposite-direction train BEHIND it, which is moving away', () => {
+    const s = setup({ direction: 'east', side: 'east', number: 18 });
+    const r = advance(s);
+    assert.ok(
+      r.events.some((e) => e.type === 'trainHighballed' && e.trainNumber === 15),
+      'a train moving away behind it held the departure',
+    );
+  });
+
+  it('still puts a same-direction train AHEAD to the Superintendent', () => {
+    const s = setup({ direction: 'west', side: 'west', number: 18 });
+    const r = advance(s);
+    assert.ok(
+      r.events.some((e) => e.type === 'clearanceRequested' && e.trainId === 'departing'),
+      'a train the departing one would follow was not put to the Superintendent',
+    );
+  });
+});

test/apply.test.ts

@@ -159,6 +159,60 @@ describe('Local Operations: drawing (§6.2)', () => {
     assert.notEqual(s.decks.departments[1]![0], target, 'refilled with the same card');
   });
 
+  it('a PLAYED timetabled train never comes back, but a discarded one does — Gitea#23', () => {
+    /**
+     * Jesse's ruling, 2026-09-10: *"Once you've played a regularly scheduled train and it's in the
+     * salvage deck, that train is already on the timetable. It does not make sense to put that back
+     * into a reshuffled home deck to get played again. By contrast, a regularly scheduled train
+     * that's in a discard pile could potentially get reused later, and so should have that
+     * capability. Extras run one time and then they're done — if they are in the Salvage deck, they
+     * should get shuffled back in so that they could get run again."*
+     *
+     * So the test is WHERE the card is, not only what it is: the same card is spent in the Salvage
+     * Yard and still runnable in a Department. That is what this pins, because it is the kind of rule
+     * a later tidy-up would happily "simplify" into filtering by card kind everywhere.
+     */
+    const s = game();
+    const kindOfCard = (id: string): string => s.cards.get(id)?.kind.kind ?? '?';
+    const pool = [...s.decks.homeOffice];
+    const trains = pool.filter((id) => kindOfCard(id) === 'timetabledTrain');
+    const extras = pool.filter((id) => kindOfCard(id) === 'extraTrain');
+    const others = pool.filter((id) => !['timetabledTrain', 'extraTrain'].includes(kindOfCard(id)));
+    assert.ok(trains.length >= 2 && extras.length >= 1 && others.length >= 5, 'the deal lacks the cards this needs');
+
+    const spentTrain = trains[0]!;      // played: in the Salvage Yard, its slot taken
+    const discardedTrain = trains[1]!;  // never played: sitting in a Department
+    const playedExtra = extras[0]!;     // a single run, free to run again
+
+    s.decks.salvageYard = [spentTrain, playedExtra, ...others.slice(0, 3)];
+    s.decks.departments = [[discardedTrain], [others[3]!], [others[4]!]];
+    s.decks.homeOffice = [others[5]!];
+
+    applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
+    const r = applyIntent(s, 0, { type: 'draw.fromHomeOffice' });
+    assert.ok(r.ok);
+    assert.ok(r.events.some((e) => e.type === 'deckReshuffled'), 'no reshuffle was emitted');
+
+    const recovered = new Set([...s.decks.homeOffice, ...s.decks.departments.flat()]);
+    const hands = new Set([...s.decks.hands.values()].flat());
+
+    // THE RULING, both halves.
+    assert.ok(!recovered.has(spentTrain), 'a played timetabled train was shuffled back in');
+    assert.ok(!hands.has(spentTrain), 'a played timetabled train was dealt back into a hand');
+    assert.ok(
+      s.decks.salvageYard.includes(spentTrain),
+      'a played timetabled train should stay in the Salvage Yard, not vanish',
+    );
+    assert.ok(
+      recovered.has(discardedTrain) || hands.has(discardedTrain),
+      'a DISCARDED timetabled train must come back — it was never played, so its slot is open',
+    );
+    assert.ok(
+      recovered.has(playedExtra) || hands.has(playedExtra),
+      'a played Extra must come back — an Extra is one run, not a standing slot',
+    );
+  });
+
   it('reshuffles the Salvage Yard and Departments back in when the deck runs out', () => {
     // §6.2 — "If drawing a card has depleted the Home Office deck, immediately collect all cards
     // from the Salvage Yard and three Department decks, reshuffle, and reestablish the Home Office
@@ -182,7 +236,11 @@ describe('Local Operations: drawing (§6.2)', () => {
     assert.ok(r.ok);
     assert.ok(r.events.some((e) => e.type === 'deckReshuffled'), 'no reshuffle was emitted');
 
-    assert.equal(s.decks.salvageYard.length, 0, 'the Salvage Yard must be swept');
+    // Swept EXCEPT the trains whose slots are already on the timetable — see the ruling test below.
+    assert.ok(
+      s.decks.salvageYard.every((id) => s.cards.get(id)?.kind.kind === 'timetabledTrain'),
+      'the Salvage Yard must be swept apart from spent timetabled trains',
+    );
     assert.ok(s.decks.homeOffice.length > 0, 'the deck must be re-established');
     assert.ok(
       s.decks.departments.every((p) => p.length === 1),
@@ -956,7 +1014,7 @@ describe('the Superintendent clearance ruling (§8.1)', () => {
     const s = game();
     s.clock.phase = 'mainline';
     s.clock.currentActor = null; // nobody's turn — yet the Superintendent must still rule
-    s.clock.pendingDecision = { train: 'tray0', occupiedBy: 'tray1' };
+    s.clock.pendingDecision = { kind: 'clearance', train: 'tray0', occupiedBy: 'tray1' };
     const r = applyIntent(s, 0, { type: 'mainline.clearance', allow: false });
     assert.ok(r.ok);
     assert.equal(s.clock.pendingDecision, null);
@@ -964,7 +1022,7 @@ describe('the Superintendent clearance ruling (§8.1)', () => {
 
   it('is refused to a player who is not the Superintendent', () => {
     const s = game();
-    s.clock.pendingDecision = { train: 'tray0', occupiedBy: 'tray1' };
+    s.clock.pendingDecision = { kind: 'clearance', train: 'tray0', occupiedBy: 'tray1' };
     s.clock.superintendent = 1;
     assert.equal(check(s, 0, { type: 'mainline.clearance', allow: true }), 'NOT_SUPERINTENDENT');
   });
@@ -1679,7 +1737,7 @@ describe('the Crew Tray is a train, and must be made up to leave (§8.2, Appendi
     const build = (toNose: boolean): string[] => {
       const s = game();
       const id = placeTray(s, at(0, 0), [car('boxcar')] as never);
-      reduce(s, { type: 'carsCoupled', trayId: id, at: at(0, 0), stock: [car('hopper')] as never, from: [], toNose });
+      reduce(s, { type: 'carsCoupled', player: 0, trayId: id, at: at(0, 0), stock: [car('hopper')] as never, from: [], toNose });
       return s.trays.get(id)!.consist.map((c) => c.type);
     };
     assert.deepEqual(build(true), ['hopper', 'boxcar'], 'running forward takes cars on the nose');
@@ -1694,11 +1752,11 @@ describe('the Crew Tray is a train, and must be made up to leave (§8.2, Appendi
     const tray = s.trays.get(id)!;
     tray.engineAt = 0;
 
-    reduce(s, { type: 'carsCoupled', trayId: id, at: at(0, 0), stock: [car('hopper')] as never, from: [], toNose: true });
+    reduce(s, { type: 'carsCoupled', player: 0, trayId: id, at: at(0, 0), stock: [car('hopper')] as never, from: [], toNose: true });
     assert.equal(tray.engineAt, 1, 'the engine should now have a car ahead of it');
     assert.deepEqual(tray.consist.map((c) => c.type), ['hopper', 'boxcar']);
 
-    reduce(s, { type: 'carsDropped', trayId: id, at: at(0, 0), stock: [car('hopper')] as never, fromNose: true });
+    reduce(s, { type: 'carsDropped', player: 0, trayId: id, at: at(0, 0), stock: [car('hopper')] as never, fromNose: true });
     assert.equal(tray.engineAt, 0, 'setting out the nose cars puts the engine back in front');
     assert.deepEqual(tray.consist.map((c) => c.type), ['boxcar']);
   });
@@ -1823,7 +1881,7 @@ describe('the engine is drawn pointing east or west, whatever track it is standi
    * So `facing` stays a PORT (movement needs one) and `railFacingOf` is what the board draws.
    */
   const moved = (id: string, facing: 'n' | 's' | 'e' | 'w') =>
-    ({ type: 'trayMoved', trayId: id, from: at(0, 0), to: at(0, 0), movesRemaining: 3, facing }) as const;
+    ({ type: 'trayMoved', player: 0, trayId: id, from: at(0, 0), to: at(0, 0), movesRemaining: 3, facing }) as const;
 
   it('carries the east-west sense across north-south track', () => {
     const s = game();

test/card-reference.test.ts

@@ -0,0 +1,54 @@
+/**
+ * The card reference must not drift from the cards.
+ *
+ * `docs/rules/card-reference.md` spent several releases describing the v0.4.5 deck — twelve numbered
+ * trains, "3 / 4 Mail-Express, 3 coaches" — while `content.ts` had train 3 as the Express with two
+ * freight cars and a per-location freight rule. Worse, `content.ts` named that file as "the place
+ * that now carries what the cards say", so the code sent readers to a table its own banner told them
+ * not to trust. Nothing failed, because nothing checked.
+ *
+ * `docs/rules/as-built.md` is emitted from the same exported catalogues the engine instantiates
+ * from, and this re-runs the generator and compares. Change a card face without regenerating and
+ * this goes red — which is the whole point: a document nothing verifies is a document that will be
+ * wrong, and this project's own history is the evidence.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..');
+const doc = join(root, 'docs/rules/as-built.md');
+
+describe('docs/rules/as-built.md is generated, and current', () => {
+  it('matches what the generator emits from content.ts today', () => {
+    const before = readFileSync(doc, 'utf8');
+    execFileSync(process.execPath, [join(root, 'scripts/build-card-reference.ts')], { cwd: root });
+    const after = readFileSync(doc, 'utf8');
+    assert.equal(
+      after,
+      before,
+      'the checked-in card reference is stale — run `npm run build:cards` and commit the result',
+    );
+  });
+
+  it('carries the current train catalogue, not the v0.4.5 deck', () => {
+    // The specific drift that went unnoticed for several releases, asserted by name so a future
+    // regeneration against an old content.ts cannot quietly reintroduce it.
+    const md = readFileSync(doc, 'utf8');
+    assert.match(md, /Crack Limited/);
+    assert.match(md, /\| 3 \| Express \|/);
+    assert.ok(!/Mail-Express/.test(md), 'the superseded v0.4.5 train names are back');
+    assert.ok(!/Manifest Freight/.test(md), 'the superseded v0.4.5 train names are back');
+  });
+
+  it('says it is generated, so nobody edits it by hand', () => {
+    const md = readFileSync(doc, 'utf8');
+    assert.match(md, /Generated from `src\/engine\/content\.ts`/);
+    assert.match(md, /Do not edit by/);
+  });
+});

test/cut-ordering.test.ts

@@ -13,7 +13,7 @@ import assert from 'node:assert/strict';
 
 import { applyIntent, areaOf, check } from '../src/engine/apply.ts';
 import { createGame } from '../src/engine/setup.ts';
-import type { CrewTray, GameConfig, GameState, GridCoord, RollingStock, TrackCard } from '../src/engine/state.ts';
+import type { CrewTray, GameConfig, GameState, GridCoord, RollingStock, TrackArc, TrackCard } from '../src/engine/state.ts';
 import { carsOn, coordKey, turnOf } from '../src/engine/state.ts';
 
 const config: GameConfig = {
@@ -53,12 +53,18 @@ function row(s: GameState, n: number): void {
   for (let c = 0; c < n; c++) addCard(s, at(1, c), straight());
 }
 
+/**
+ * `facing` is the PORT the engine points out through, which is not always an east-west one: a train
+ * standing on a curve points along its 45° leg. `railFacing` carries the east-west sense the train
+ * arrived with, so it keeps a straight answer whatever port the nose is on (`railFacingOf`).
+ */
 function placeTray(
   s: GameState,
   coord: GridCoord,
   consist: RollingStock[],
-  facing: 'e' | 'w',
+  facing: 'n' | 's' | 'e' | 'w',
   engineAt = 0,
+  railFacing: 'e' | 'w' = facing === 'w' ? 'w' : 'e',
 ): string {
   const id = s.freeTrays.pop()!;
   s.trays.set(id, {
@@ -67,9 +73,9 @@ function placeTray(
     trainIsExtra: false,
     engineAt,
     consist,
-    direction: facing === 'w' ? 'west' : 'east',
+    direction: railFacing === 'w' ? 'west' : 'east',
     facing,
-    railFacing: facing,
+    railFacing,
     position: { at: 'grid', seat: 0, coord },
     movesUsed: 0,
   } as CrewTray);
@@ -373,3 +379,85 @@ describe('taking your own cut back is undoing the drop, not a fresh pick-up', ()
     );
   });
 });
+
+// ---------------------------------------------------------------------------
+
+describe('a 45° leg is part of the west-to-east row, not outside it (Gitea#17)', () => {
+  /**
+   * Reported: "Cars were West to East Caboose, Loaded boxcar, Loaded boxcar, Loaded boxcar. After
+   * backing into that square cars were attached to the train Loaded boxcar, Loaded boxcar, Loaded
+   * boxcar, Caboose, Engine." The caboose came back next to the engine instead of at the far end,
+   * which also leaves the train badly made up under §8.2.
+   *
+   * The square was a `sw` CURVE and the train backed in through its SOUTH leg. `standing` runs west
+   * to east, and the two places that walk it both asked the PORT which end of the row they were at:
+   * `exploreMoves` reversed the row for an 'e' entry and for nothing else, and `cutTowards` answered
+   * "you meet nothing" for a north or south exit. Neither is a property of the port.
+   *
+   * A 45° leg leaves through the MIDDLE of its edge, so its end of the run is whichever end the arc
+   * does not reach: the south leg of a `sw` curve is the row's EAST end, and the south leg of an
+   * `se` curve is its WEST end. Same port, opposite answers — which is why `rowEndAt` has to ask the
+   * card.
+   */
+  const curve = (arc: TrackArc, standing: RollingStock[] = [], standingWest = 0): TrackCard => ({
+    geometry: { kind: 'track', geometry: 'curved', arc, hand: 'right' },
+    baseOperationalRail: true,
+    standing,
+    standingWest,
+    facility: null,
+    modifiers: [],
+    enhancements: [],
+  });
+
+  /**
+   * The reported board, minimally: a `sw` curve holding the cut, and an `ne` curve below it for the
+   * train to run from. Both legs lie on the `ne_sw` diagonal, so the two cards actually join.
+   */
+  function board(standing: RollingStock[], standingWest = standing.length): GameState {
+    const s = game();
+    addCard(s, at(1, 0), curve('sw', standing, standingWest));
+    addCard(s, at(0, 0), curve('ne'));
+    switching(s);
+    return s;
+  }
+
+  it('backs into a cut through the south leg and meets the EAST end of the row first', () => {
+    const s = board([car('caboose', true), car('boxcar', true), car('boxcar', true), car('boxcar', true)]);
+    // Facing east on the `ne` curve, so reversing pulls out through its north leg and into the
+    // curve above through that card's south leg — the move in the reported save.
+    const id = placeTray(s, at(0, 0), [], 'e');
+    const r = applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(1, 0), reverse: true });
+    assert.ok(r.ok, `the reverse move was refused: ${r.ok ? '' : r.code}`);
+    // Coupled behind the engine nearest-car-first, and the nearest car is the one at the south end
+    // — the LAST of a west-to-east row on a `sw` curve. The caboose was westmost, so it ends up
+    // furthest from the engine, which is where §8.2 needs it.
+    assert.deepEqual(types(s.trays.get(id)!.consist), ['boxcar', 'boxcar', 'boxcar', 'caboose']);
+  });
+
+  it('meets the WEST end of the row first where the same leg belongs to an `se` curve', () => {
+    // The mirror, and the reason the port alone cannot answer: an `se` curve's south leg is the
+    // west end of its row, so the same reverse move meets the caboose first.
+    const s = game();
+    addCard(s, at(1, 0), curve('se', [car('caboose', true), car('boxcar', true)], 2));
+    addCard(s, at(0, 0), curve('nw'));
+    switching(s);
+    const id = placeTray(s, at(0, 0), [], 'w');
+    const r = applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(1, 0), reverse: true });
+    assert.ok(r.ok, `the reverse move was refused: ${r.ok ? '' : r.code}`);
+    assert.deepEqual(types(s.trays.get(id)!.consist), ['caboose', 'boxcar']);
+  });
+
+  it('takes its own cut back with it when it pulls out through the south leg (§A.4)', () => {
+    // The other half of the same assumption: `cutTowards` said a train leaving north or south meets
+    // nothing, so a crew standing on a curve drove away and left the cars beside it standing —
+    // exactly what mandatory coupling forbids.
+    const s = board([car('boxcar', true)], 0);
+    // `standingWest` 0 puts the boxcar EAST of the train, which on a `sw` curve is between it and
+    // the south leg it is about to leave by.
+    const id = placeTray(s, at(1, 0), [], 's');
+    const r = applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(0, 0), reverse: false });
+    assert.ok(r.ok, `the move off the curve was refused: ${r.ok ? '' : r.code}`);
+    assert.deepEqual(types(s.trays.get(id)!.consist), ['boxcar'], 'the cut beside the train was left standing');
+    assert.deepEqual(standingAt(s, at(1, 0)), [], 'the cars should have come off the card');
+  });
+});

test/display-gaps.test.ts

@@ -0,0 +1,437 @@
+/**
+ * WHAT THE ENGINE KNOWS AND THE SCREEN DOES NOT — the 2026-09-07 sweep.
+ *
+ * Gitea#21, Gitea#22, #94 and #96 were four instances of one fault in a row: the engine gained a
+ * thing that changes what a train may do, and nothing drew it. Each was found by a player hitting
+ * it. So rather than wait for the fifth, every field of `GameState` and its nested types was
+ * enumerated and checked for a reader in `sim/view.ts`, `src/web/` and `sim/narrate.ts`, and the
+ * survivors were then verified by running the engine rather than by trusting the grep.
+ *
+ * Four fields had no reader anywhere. `movedThisPhase` is set and cleared inside one `advance` call
+ * and is genuinely nobody's business. The other three are these tests. The bookkeeping fields whose
+ * EFFECT is already visible as legality — `freightWorked`, `drawnThisTurn`, `freightAgentUsed`,
+ * `movesUsed` (its complement `movesRemaining` is on the Frame), `switchedSince` — are deliberately
+ * not here: a field is not a display gap merely because no one renders it.
+ *
+ * The method is worth more than the three fixes, and is written down in TODO Reference · #98.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createGame } from '../src/engine/setup.ts';
+import { crewTrayCount, enhancementText } from '../src/engine/content.ts';
+import { areaOf } from '../src/engine/apply.ts';
+import { impediments } from '../src/sim/narrate.ts';
+import { projectDistrict, projectSharedTable, publicSnapshot, trainRules } from '../src/sim/view.ts';
+import type { CrewTray, GameConfig, GameState, PlayerIndex, SeatIndex } from '../src/engine/state.ts';
+import { seatOf } from '../src/engine/state.ts';
+
+const config: GameConfig = {
+  mode: 'competitive',
+  days: 3,
+  minCombinedRevenue: 0,
+  maxCollisionsPerDay: 0,
+  maxCollisionsTotal: 0,
+  pvpCardsAllowed: false,
+  optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
+};
+
+const game = (): GameState => {
+  const s = createGame({ id: 'g', seed: 4242, config, playerNames: ['Ann', 'Bob'] });
+  s.status = 'active';
+  return s;
+};
+
+/**
+ * THE CREW TRAY POOL IS A MECHANIC, AND IT WAS INVISIBLE (#98).
+ *
+ * `state.ts` calls tray scarcity "an explicit mechanic": there are fewer trays than there are trains
+ * wanting one, and which trains get held is the whole of §7. The engine knows three things about it
+ * — how many trays are free, which Extras are queued for one, and which second sections are — and
+ * the view read none of them.
+ *
+ * The panel that answers "why is nothing moving?" had exactly one tray rule, keyed off the train due
+ * out THIS Stage (`s.timetable[stage - 1]`). So a player who spent a card on an Extra, or ordered a
+ * second section, got a blocked panel that was completely EMPTY while their train sat behind an
+ * exhausted pool — and both had been announced once in the log, in a line that promised a future
+ * event ("as soon as a Crew Tray frees up") which nothing then confirmed.
+ */
+describe('the Crew Tray pool is a mechanic the player can see (#98)', () => {
+  /** A table whose trays are all out, with one Extra and one second section queued behind them. */
+  const jammed = (): GameState => {
+    const s = game();
+    s.freeTrays = [];
+    s.pendingExtras.push({ trainNumber: 17, player: 0 as PlayerIndex });
+    s.pendingSecondSections.push(8);
+    return s;
+  };
+
+  it('reports how many Crew Trays are free, and how many there are', () => {
+    const s = game();
+    const total = crewTrayCount(2);
+    assert.equal(s.freeTrays.length, total, 'the premise is gone: trays were already out at setup');
+    assert.deepEqual(projectSharedTable(s).crewTrays, { free: total, total });
+
+    s.freeTrays = s.freeTrays.slice(0, 1);
+    assert.deepEqual(
+      projectSharedTable(s).crewTrays,
+      { free: 1, total },
+      'the pool emptied and the shared table did not notice',
+    );
+  });
+
+  it('names the trains queued for a tray, so a promise made in the log is kept on the board', () => {
+    const q = projectSharedTable(jammed()).queued;
+    assert.deepEqual(q.extras, [{ trainNumber: 17, player: 0 }], 'a played Extra is waiting nowhere visible');
+    assert.deepEqual(q.secondSections, [8], 'an ordered second section is waiting nowhere visible');
+  });
+
+  it('tells the player who played the Extra that it is held for want of a crew', () => {
+    const blocked = impediments(jammed(), 0 as PlayerIndex);
+    const extra = blocked.find((b) => /X17/.test(b.where));
+    assert.ok(extra, 'the blocked panel said nothing about an Extra held for want of a Crew Tray');
+    assert.match(extra.why, /Crew Tray/, 'it was listed without naming the thing it is waiting for');
+    assert.equal(extra.severity, 'stuck');
+    // The POOL SIZE, not a second derivation of it. Written as `trays.size + freeTrays.length`
+    // first, which reads 0 of 0 for any state where a tray is neither free nor carrying a train.
+    assert.match(
+      extra.why,
+      new RegExp(`0 of ${crewTrayCount(2)} Crew Trays free`),
+      'the panel reported the wrong pool size',
+    );
+  });
+
+  it('says the same for a second section, which waits on the identical pool', () => {
+    const blocked = impediments(jammed(), 0 as PlayerIndex);
+    const second = blocked.find((b) => /Train 8\b/.test(b.where) && /second section/i.test(b.why));
+    assert.ok(second, 'an ordered second section was queued invisibly');
+    assert.match(second.why, /Crew Tray/);
+  });
+
+  it('says none of it once a tray is free, because then nothing is being waited on', () => {
+    const s = jammed();
+    s.freeTrays = ['tray0'];
+    const blocked = impediments(s, 0 as PlayerIndex);
+    assert.equal(
+      blocked.filter((b) => /Crew Tray/.test(b.why)).length,
+      0,
+      'a free tray still reported trains held for want of one',
+    );
+  });
+
+  it('is on the common board too — the pool is on the table, not in a hand', () => {
+    const pub = publicSnapshot(jammed()) as unknown as Record<string, unknown>;
+    assert.ok('crewTrays' in pub, 'a spectator cannot see the scarcity everyone at the table can');
+    assert.ok('queued' in pub);
+  });
+});
+
+/**
+ * A TRAIN HELD AT THE LIMITS IS STILL ON THE BOARD (#99).
+ *
+ * The Interlocking enhancement is the designed answer to a full Office: instead of the automatic
+ * collision of Gap 2d, "may stop an inbound train on the Limit Track" — the train is held inside the
+ * player's Limits, and takes the first A/D track that frees, ahead of any newcomer.
+ *
+ * It was drawn NOWHERE. `arriveAtOffice` removes the tray from the Mainline node's `transits`
+ * (advance.ts) and the Interlocking branch pushes it onto `area.heldAtLimits` without assigning
+ * `tray.position` — so the map, which draws mainline nodes from `transits` and district squares from
+ * `position.at === 'grid'`, has nothing to draw it from in either place. The train vanished off the
+ * board on arrival and reappeared in the Office some Stages later.
+ *
+ * Measured before fixing: with the tray in `transits` the Interchange node carries its chip; with
+ * the tray moved to `heldAtLimits` exactly as the engine moves it, the node's `trains` is empty and
+ * no grid square has gained it.
+ *
+ * The fix is in the VIEW, not the engine. The engine's state is right — a held train is inside the
+ * Limits and not on an A/D track, which is what `heldAtLimits` says — and `position` is left alone
+ * deliberately, so nothing may treat the train as standing on a square it could be switched from.
+ */
+describe('a train held at the Limits is drawn at the Limits (#99)', () => {
+  const held = (direction: 'east' | 'west') => {
+    const s = game();
+    const seat = seatOf(s, 0 as PlayerIndex);
+    const area = areaOf(s, 0 as PlayerIndex);
+    const trayId = s.freeTrays.pop()!;
+    const tray: CrewTray = {
+      id: trayId,
+      trainNumber: 5,
+      trainIsExtra: false,
+      engineAt: 0,
+      consist: [],
+      direction,
+      movesUsed: 0,
+      position: { at: 'mainline', index: 1 },
+    } as CrewTray;
+    s.trays.set(trayId, tray);
+    area.heldAtLimits.push(trayId);
+    return { s, seat, trayId, area };
+  };
+
+  it('draws it on the Limits square it is standing at, not nowhere', () => {
+    const { s, seat, trayId, area } = held('east');
+    const { cells } = projectDistrict(s, seat as SeatIndex);
+    const on = cells.filter((c) => c.trains.some((t) => t.trayId === trayId));
+    assert.equal(on.length, 1, 'a train held at the Limits is drawn on no square at all');
+    assert.equal(on[0]!.row, area.limitsWest.row, 'drawn at the wrong Limits');
+    assert.equal(on[0]!.col, area.limitsWest.col);
+  });
+
+  it('holds an EASTBOUND train at the western Limits, because that is the end it came in by', () => {
+    const { s, seat, area } = held('east');
+    const { cells } = projectDistrict(s, seat as SeatIndex);
+    const on = cells.find((c) => c.trains.length > 0)!;
+    assert.deepEqual({ row: on.row, col: on.col }, { row: area.limitsWest.row, col: area.limitsWest.col });
+  });
+
+  it('and a WESTBOUND train at the eastern Limits', () => {
+    const { s, seat, area } = held('west');
+    const { cells } = projectDistrict(s, seat as SeatIndex);
+    const on = cells.find((c) => c.trains.length > 0)!;
+    assert.deepEqual({ row: on.row, col: on.col }, { row: area.limitsEast.row, col: area.limitsEast.col });
+  });
+
+  it('says on the chip that it is HELD, so it is not read as a train free to switch', () => {
+    const { s, seat, trayId } = held('east');
+    const { cells } = projectDistrict(s, seat as SeatIndex);
+    const chip = cells.flatMap((c) => c.trains).find((t) => t.trayId === trayId)!;
+    assert.equal(chip.heldAtLimits, true, 'a held train looked exactly like one standing on the square');
+    assert.match(chip.what, /Interlocking|held/i, 'the chip does not say why it is standing there');
+  });
+
+  it('tells the district owner it is waiting, and what for', () => {
+    const { s } = held('east');
+    const blocked = impediments(s, 0 as PlayerIndex);
+    const b = blocked.find((x) => /Train 5/.test(x.where) && /Limits/i.test(x.why));
+    assert.ok(b, 'the blocked panel said nothing about a train held at the Limits');
+  });
+
+  it('does not invent a train on a square when nothing is held', () => {
+    const s = game();
+    const { cells } = projectDistrict(s, seatOf(s, 0 as PlayerIndex) as SeatIndex);
+    assert.equal(cells.flatMap((c) => c.trains).length, 0, 'a district with no trains drew one');
+  });
+});
+
+/**
+ * THE CAMPAIGN TRAIN'S SPEECHES CHANGE ITS RULES, AND THE CARD HAS TO SAY WHICH HALF IT IS IN (#100).
+ *
+ * X17 is "one turn at station (speeches) then expedite". Its first Office arrival is an ordinary
+ * stop; every arrival after that runs EXPEDITED, which means that if it is not back on the Office
+ * square when the next Mainline Phase begins it is a Station Master fault costing 1 Revenue.
+ *
+ * `trainRules()` took `{ trainNumber, trainIsExtra }` — it could not see `speechMade` even though
+ * both of its tray-side callers pass a whole `CrewTray` that has it. So the chip read identically
+ * before and after, and worse: the "EXPEDITED — must be kept ready to highball… costs 1 Revenue"
+ * warning is printed only under `rules.expedite`, so X17 became subject to a fault whose warning the
+ * game shows to other trains and never to it.
+ */
+describe('the Campaign Train says whether its speeches are made (#100)', () => {
+  const X17 = { trainNumber: 17, trainIsExtra: true } as const;
+
+  it('before the speeches, says they are still to come and does not claim it is expedited yet', () => {
+    const t = trainRules({ ...X17 });
+    assert.match(t, /SPEECHES/i);
+    assert.doesNotMatch(t, /costs 1 Revenue/, 'it warned of a fault the train is not yet subject to');
+  });
+
+  it('after the speeches, says it is expedited NOW and carries the fault it is now subject to', () => {
+    const t = trainRules({ ...X17, speechMade: true });
+    assert.match(t, /EXPEDITED/, 'a train that is now expedited did not say so');
+    assert.match(t, /costs 1 Revenue/, 'the fault warning is shown to other trains and not to this one');
+  });
+
+  it('reads differently before and after — the whole of the bug was that it did not', () => {
+    assert.notEqual(trainRules({ ...X17 }), trainRules({ ...X17, speechMade: true }));
+  });
+
+  it('still warns a permanently expedited train, which must not regress', () => {
+    const fast = trainRules({ trainNumber: 5, trainIsExtra: false });
+    assert.match(fast, /EXPEDITED/);
+    assert.match(fast, /costs 1 Revenue/);
+  });
+
+  it('says nothing about speeches for a train that has no such rule', () => {
+    assert.doesNotMatch(trainRules({ trainNumber: 5, trainIsExtra: false }), /SPEECHES/i);
+  });
+});
+
+/**
+ * A DISPATCH DEVICE SAYS WHETHER IT IS STILL AVAILABLE TODAY (#101).
+ *
+ * Telegraph (+4), Telephone (+8) and Radio (+12) are "once a day, when dispatching facing trains,
+ * add +N to the other train's number". The device is drawn on its card and its effect text is in the
+ * tooltip — but `enhancementText(key)` takes only the KEY, so it could not vary with anything, and
+ * the Radio read "once a day, add +12…" all Day after it had been spent. That is `trainRules` before
+ * #100, in a different corner of the same view.
+ *
+ * THE SECOND HALF IS THE ONE THAT SURPRISES. `spendDispatchBonus` reads
+ * `areaOf(s, s.clock.superintendent)` — the SUPERINTENDENT's own devices, not the train owner's —
+ * and the Fedora moves every `STAGES_PER_SHIFT` Stages, four times a Day. So a player's Radio does
+ * nothing at all for three-quarters of the Day, and is spent automatically, without being asked,
+ * during the quarter it is theirs to use. The board said neither half.
+ *
+ * Shown on EVERY district (Jesse, 2026-09-07), not only the viewer's: it is public, and a rival's
+ * spent Radio is exactly what you want to know before forcing a meet. `projectDistrict` serves both
+ * the player's own cells and the common board's `districts`, so one change covers both.
+ */
+describe('a dispatch device says whether it is still available today (#101)', () => {
+  /** Puts `key` on the first card of seat 0's district and returns the pieces to assert on. */
+  const withDevice = (key: string, opts: { spent?: boolean; fedora?: boolean } = {}) => {
+    const s = game();
+    const area = areaOf(s, 0 as PlayerIndex);
+    const card = [...area.grid.values()][0]!;
+    card.enhancements.push(key);
+    if (opts.spent) area.dispatchUsedToday.push(key);
+    // The Fedora is a PLAYER; give it to somebody whose seat is not this district's.
+    s.clock.superintendent = (opts.fedora ? 0 : 1) as PlayerIndex;
+    const seat = seatOf(s, 0 as PlayerIndex);
+    const cells = projectDistrict(s, seat as SeatIndex).cells;
+    const cell = cells.find((c) => c.enhancements.length > 0)!;
+    const i = cell.enhancementsWhat.findIndex((w) => new RegExp(key, 'i').test(w));
+    return { s, area, cell, what: cell.enhancementsWhat[i] ?? '', spent: cell.enhancementsSpent[i] };
+  };
+
+  it('reads as available before it is used, and says what it is worth', () => {
+    const { what, spent } = withDevice('radio', { fedora: true });
+    assert.equal(spent, false, 'an unused device reported itself spent');
+    assert.match(what, /\+12/, 'the device no longer says what it is worth');
+    assert.doesNotMatch(what, /spent/i, 'an unused device claimed it had been spent');
+  });
+
+  it('says so once it has been spent, and says when it comes back', () => {
+    const { what, spent } = withDevice('radio', { spent: true, fedora: true });
+    assert.equal(spent, true, 'a spent device still reported itself available');
+    assert.match(what, /spent/i, 'a spent device read exactly as it did before it was spent');
+    assert.match(what, /next Day|tomorrow/i, 'it does not say the device comes back');
+  });
+
+  it('reads differently spent and unspent — the whole of the bug was that it did not', () => {
+    assert.notEqual(
+      withDevice('telegraph', { fedora: true }).what,
+      withDevice('telegraph', { spent: true, fedora: true }).what,
+    );
+  });
+
+  it('says a device is idle while somebody else holds the Fedora', () => {
+    const { what } = withDevice('telephone');
+    assert.match(what, /Fedora|Superintendent/i, 'nothing said the device is only used while dispatching');
+  });
+
+  it('does not say that when this district IS the Superintendent', () => {
+    const { what } = withDevice('telephone', { fedora: true });
+    assert.doesNotMatch(what, /while .*holds? the Fedora/i);
+  });
+
+  /**
+   * EXACT equality, not "does not mention the Fedora". The first draft asserted the absence of
+   * /spent|Fedora/i with the Fedora held, and a mutation that removed the `dispatchBonus` guard
+   * altogether PASSED it — because the leaked text in that case reads "Available today, and this
+   * district is dispatching", which contains neither word. A test for a field being left alone has
+   * to compare it to what it should be.
+   */
+  it('leaves an enhancement that is not a dispatch device exactly as it was', () => {
+    for (const fedora of [true, false]) {
+      const { what, spent } = withDevice('interlocking', { fedora });
+      assert.equal(spent, false, 'a non-dispatch enhancement was marked spendable');
+      assert.equal(what, enhancementText('interlocking'), 'an Interlocking was given a dispatch caveat');
+    }
+  });
+
+  it('comes back when the Day turns, which is what clears the record', () => {
+    const { s, area } = withDevice('radio', { spent: true, fedora: true });
+    area.dispatchUsedToday = [];
+    const cell = projectDistrict(s, seatOf(s, 0 as PlayerIndex) as SeatIndex).cells.find(
+      (c) => c.enhancements.length > 0,
+    )!;
+    assert.equal(cell.enhancementsSpent.some((x) => x), false, 'a new Day did not restore the device');
+  });
+
+  /**
+   * SEAT IS NOT PLAYER INDEX, and this is the one place the two are joined: the Fedora is held by a
+   * PLAYER and the devices sit in an Office Area keyed by SEAT. `advance.ts` carried a comment
+   * warning that indexing one with the other was safe only while seating was the identity map — it
+   * read as a live bug and was not one, because `areaOf` resolves through `seatOf`. The comment is
+   * corrected; this is the guard, because the next reader deserves better than a claim.
+   *
+   * §4.4's D12 makes seating a real permutation, so a two-player game where player 1 sits in seat 0
+   * is ordinary rather than contrived.
+   */
+  it("marks the SUPERINTENDENT's own district as dispatching under non-identity seating", () => {
+    const s = game();
+    s.seating = [1, 0] as PlayerIndex[];
+    assert.notEqual(seatOf(s, 0 as PlayerIndex), 0, 'the premise is gone: seating is still identity');
+    s.clock.superintendent = 0 as PlayerIndex;
+
+    const mine = areaOf(s, 0 as PlayerIndex);
+    [...mine.grid.values()][0]!.enhancements.push('radio');
+    const other = areaOf(s, 1 as PlayerIndex);
+    [...other.grid.values()][0]!.enhancements.push('radio');
+
+    const whatAt = (player: PlayerIndex): string => {
+      const cells = projectDistrict(s, seatOf(s, player) as SeatIndex).cells;
+      return cells.find((c) => c.enhancements.length > 0)!.enhancementsWhat.join(' ');
+    };
+    // The Fedora is player 0's, whatever seat that is.
+    assert.doesNotMatch(whatAt(0 as PlayerIndex), /IDLE/, "the Superintendent's own device read as idle");
+    assert.match(whatAt(1 as PlayerIndex), /IDLE/, "somebody else's device read as dispatching");
+  });
+
+  it('is on every district of the common board, not only the viewer own', () => {
+    const { s } = withDevice('radio', { spent: true, fedora: true });
+    const pub = publicSnapshot(s);
+    const all = pub.districts.flatMap((d) => d.cells);
+    assert.ok(
+      all.some((c) => c.enhancementsSpent.some((x) => x)),
+      "a spectator cannot see which devices are spent in a player's district",
+    );
+  });
+});
+
+/**
+ * THE RED FLAG HOLDER IS NOT A PER-PLAYER FACT, so it does not belong on the public player view.
+ *
+ * `docs/plans/jitsi-common-board.md` step 1 asks for one: "Add the Red Flag holder to the public
+ * player projection. It is public game state but is currently absent from `Frame`", and its
+ * `PublicPlayerView` carries `redFlagHeld: boolean`. Every other step-1 item shipped across v0.7.9.2
+ * to v0.7.9.5; this one is STRUCK OFF instead, because the premise does not hold in this codebase.
+ *
+ * `decks.redFlags` is written in exactly one place — `setup.ts`, from
+ * `config.optionalRules.emergencyToolbox` — and never again. There is no `.set` anywhere else, and
+ * `redFlag.play` (the intent gated on holding one) emits a `phaseEnded` event and does not spend it.
+ * So every player holds one or none of them does, decided before the first card is dealt.
+ *
+ * A `redFlagHeld` on each player would therefore be `optionalRules.emergencyToolbox` copied N times
+ * — already on the public projection — while implying to every reader of the common board that it
+ * varies by player and might change during a game. That is worse than the absence.
+ *
+ * This test exists so the plan item is not re-raised from the plan text: if the rule ever DOES
+ * become per-player, this fails and the projection is the right place to look.
+ */
+describe('the Red Flag holding is the Emergency Toolbox option, not a per-player fact', () => {
+  const dealt = (emergencyToolbox: boolean): GameState =>
+    createGame({
+      id: 'g',
+      seed: 99,
+      config: { ...config, optionalRules: { ...config.optionalRules, emergencyToolbox } },
+      playerNames: ['Ann', 'Bob', 'Cy'],
+    });
+
+  for (const toolbox of [true, false]) {
+    it(`gives every player the same answer with the toolbox ${toolbox ? 'on' : 'off'}`, () => {
+      const s = dealt(toolbox);
+      const held = s.players.map((p) => s.decks.redFlags.get(p.index) === true);
+      assert.deepEqual(held, [toolbox, toolbox, toolbox], 'the Red Flag has become a per-player fact');
+    });
+  }
+
+  it('is already public, through the option it comes from', () => {
+    const pub = publicSnapshot(dealt(true));
+    assert.equal(
+      pub.optionalRules.emergencyToolbox,
+      true,
+      'a spectator cannot tell whether the hand limit is three or four',
+    );
+  });
+});

test/enhancements.test.ts

@@ -14,7 +14,7 @@ import { applyIntent, areaOf, check, hasDistrictEnhancement, isProtectedFromDera
 import { ENHANCEMENT_RULES, enhancementRule, trainProfile } from '../src/engine/content.ts';
 import { createGame } from '../src/engine/setup.ts';
 import type { GameConfig, GameState, GridCoord, TrackCard } from '../src/engine/state.ts';
-import { coordKey, subdivisions, turnOf } from '../src/engine/state.ts';
+import { coordKey, decisionActor, subdivisions, turnOf } from '../src/engine/state.ts';
 
 const config: GameConfig = {
   mode: 'solitaire',
@@ -287,17 +287,124 @@ describe('Interlocking and Yard Office relieve the Office', () => {
     assert.equal(s.players[0]!.revenue, -5);
   });
 
-  it('diverts a coachless train to the Yard Office', () => {
+  /**
+   * §11, THE YARD OFFICE (Gitea#5) — offered, not imposed, and only down a route that exists.
+   *
+   * Jesse: "you have to ask if non-coach trains wish to go in there, rather than to the office",
+   * "if the Yard Office is not accessible in one move, you should not get the option", and cars on
+   * the way in "result in a crash". All three were missing: the train was teleported onto the card.
+   */
+  const answer = (s: GameState, take: boolean) => {
+    const who = decisionActor(s);
+    assert.notEqual(who, null, 'nothing was pending, so there was nothing to answer');
+    const r = applyIntent(s, who!, { type: 'mainline.yardOffice', take });
+    assert.ok(r.ok, 'the district owner could not answer the Yard Office offer');
+    advance(s);
+  };
+
+  it('OFFERS the Yard Office to the district owner rather than diverting automatically', () => {
     const s = game();
     const card = straight();
     card.enhancements.push('yardOffice');
-    addCard(s, at(-1, 0), card);
+    addCard(s, at(0, 2), card);
     const id = inbound(s, [{ type: 'hopper', loaded: true }]);
 
     advance(s);
+    assert.equal(s.clock.pendingDecision?.kind, 'yardOffice', 'the phase did not stop to ask');
+    assert.equal(decisionActor(s), 0, 'the question went to the wrong player');
     const pos = s.trays.get(id)!.position;
-    assert.ok(pos.at === 'grid' && pos.coord.row === -1, 'arrived at the Yard Office');
-    assert.ok(!areaOf(s, 0).adOccupancy.includes(id), 'did not take an A/D track');
+    assert.ok(pos.at !== 'grid' || pos.coord.col !== 2, 'the train moved before anyone answered');
+  });
+
+  it('takes the Yard Office when the owner says yes', () => {
+    const s = game();
+    const card = straight();
+    card.enhancements.push('yardOffice');
+    addCard(s, at(0, 2), card);
+    const id = inbound(s, [{ type: 'hopper', loaded: true }]);
+
+    advance(s);
+    answer(s, true);
+    const pos = s.trays.get(id)!.position;
+    assert.ok(pos.at === 'grid' && pos.coord.col === 2, 'did not arrive at the Yard Office');
+    assert.ok(!areaOf(s, 0).adOccupancy.includes(id), 'took an A/D track anyway');
+    assert.equal(s.players[0]!.revenue, 0, 'a clear lead should not have collided');
+  });
+
+  it('goes to the Train Order Office when the owner says no', () => {
+    // "They can of course still choose to have the train go to the standard office."
+    const s = game();
+    const card = straight();
+    card.enhancements.push('yardOffice');
+    addCard(s, at(0, 2), card);
+    const id = inbound(s, [{ type: 'hopper', loaded: true }]);
+
+    advance(s);
+    answer(s, false);
+    assert.ok(areaOf(s, 0).adOccupancy.includes(id), 'declining did not put it on an A/D track');
+  });
+
+  it('does not offer what cannot be reached, and says why in the history', () => {
+    /**
+     * Jesse, 2026-08-29: "make sure this is logged in history — why can't move so user knows why
+     * they can't get to yard." A silent absence is indistinguishable from a broken feature, which
+     * is how the missing reachability check survived this long.
+     */
+    const s = game();
+    const card = straight();
+    card.enhancements.push('yardOffice');
+    // Far off the Running Track, with nothing laid between: no route in one move.
+    addCard(s, at(3, 4), card);
+    inbound(s, [{ type: 'hopper', loaded: true }]);
+
+    const events = advance(s).events;
+    assert.equal(s.clock.pendingDecision, null, 'offered a Yard Office it cannot reach');
+    const said = events.find(
+      (e) => e.type === 'trainDiverted' && e.reason.includes('could not be offered'),
+    );
+    assert.ok(said, `nothing in the history explains why:\n${JSON.stringify(events, null, 1)}`);
+    assert.match(
+      (said as { reason: string }).reason,
+      /one move/,
+      'the reason does not say it is out of reach in one move',
+    );
+  });
+
+  it('offers a fouled lead, and taking it collides', () => {
+    /**
+     * The third missing condition. "Just like other trains finding cars on the tracks you use to
+     * get into either result in a crash" — and Jesse's ruling keeps the OFFER: a route that exists
+     * is offered, and the consequence of taking it is the player's. §8.3 already reads cars in the
+     * path of an arriving train as a collision rather than a coupling.
+     */
+    const s = game();
+    const card = straight();
+    card.enhancements.push('yardOffice');
+    addCard(s, at(0, 2), card);
+    // A car standing on the lead between the Office and the yard.
+    areaOf(s, 0).grid.get(coordKey(at(0, 1)))!.standing = [{ type: 'boxcar', loaded: false }];
+    const id = inbound(s, [{ type: 'hopper', loaded: true }]);
+
+    advance(s);
+    assert.equal(s.clock.pendingDecision?.kind, 'yardOffice', 'a fouled lead was not offered at all');
+
+    answer(s, true);
+    assert.equal(s.players[0]!.revenue, -5, 'running through standing cars did not collide');
+    assert.ok(!s.trays.has(id), 'the train survived the collision');
+  });
+
+  it('declining a fouled lead is safe — the standard Office is unaffected', () => {
+    const s = game();
+    const card = straight();
+    card.enhancements.push('yardOffice');
+    addCard(s, at(0, 2), card);
+    areaOf(s, 0).grid.get(coordKey(at(0, 1)))!.standing = [{ type: 'boxcar', loaded: false }];
+    const id = inbound(s, [{ type: 'hopper', loaded: true }]);
+
+    advance(s);
+    answer(s, false);
+    assert.equal(s.players[0]!.revenue, 0, 'declining the Yard Office still cost a collision');
+    assert.ok(areaOf(s, 0).adOccupancy.includes(id), 'the train did not reach the Office');
   });
 
   it('does not divert a train carrying coaches', () => {

test/events.test.ts

@@ -48,10 +48,25 @@ const KNOWN_UNREDUCED = [
   'dispatchBonusUsed',
   'expediteFault',
   'phaseBegan',
+  /**
+   * §Q, Red Flags (Gitea#19). The flag comes down inside the phase driver as it stops a train, so
+   * this is described rather than reduced like everything else here.
+   *
+   * ADDED DELIBERATELY, and it cost a bug first: the flag was originally taken down in a `reduce`
+   * case, which never fires for an event `advance.ts` emits — so it stayed up and held every train
+   * that came. That is precisely the failure this list exists to make visible.
+   */
+  'redFlagSpent',
   // Employee Rotation moves `seating` in the phase driver and then describes what it did, which is
   // the pattern every entry on this list follows.
   'seatsRotated',
   'stageBegan',
+  /**
+   * §5's Fedora handover, emitted by `shiftChange` on the same mutate-then-describe path as its
+   * neighbours here: the clock moves the Superintendent and then says so. Added 2026-09-16 because
+   * riding on `actorChanged` meant the log dropped it as turn bookkeeping.
+   */
+  'superintendentChanged',
   'trainArrived',
   'trainCompleted',
   'trainDiverted',

test/extended-play.test.ts

@@ -0,0 +1,324 @@
+/**
+ * §3.3, EXTENDED PLAY — Gitea#11, "when game ends allow players to continue playing if they wish".
+ *
+ * The rule as Jesse specified it (2026-08-28), which is what these tests are written against:
+ *
+ *   - the OFFICIAL result is decided at the original game length and never changes. "In a five-day
+ *     game, even if it's extended to eight or nine days, the winner and the official answer is the
+ *     winner at the end of five days";
+ *   - extending grants exactly ONE Day, and the question is put again at the end of it;
+ *   - solitaire: the player decides alone. Multiplayer: unanimous, and one refusal ends it there;
+ *   - only days-based endings offer it. A §3.4 collision breach is final, during an extended Day
+ *     just as during the regular game.
+ *
+ * The persistence half matters as much as the rules half: a save is `{ seed, config, history }`
+ * replayed through the engine, so an extension that is not an INTENT does not survive a reload, an
+ * Undo, or a server restart. `replays the extension` below is the test that pins that.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { advance, pump } from '../src/engine/advance.ts';
+import { applyIntent, check } from '../src/engine/apply.ts';
+import { STAGES_PER_DAY } from '../src/engine/content.ts';
+import { legalActions } from '../src/engine/legal.ts';
+import { createGame } from '../src/engine/setup.ts';
+import { currentActorOfState, publicSnapshot, snapshot } from '../src/sim/view.ts';
+import { currentActor } from '../src/web/game.ts';
+import { developerBot, playGame, randomBot } from '../src/sim/bot.ts';
+import type { GameConfig, GameState } from '../src/engine/state.ts';
+
+const baseConfig = (over: Partial<GameConfig> = {}): GameConfig => ({
+  mode: 'solitaire',
+  days: 3,
+  minCombinedRevenue: 0,
+  maxCollisionsPerDay: 0,
+  maxCollisionsTotal: 0,
+  pvpCardsAllowed: false,
+  optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
+  ...over,
+});
+
+const game = (over: Partial<GameConfig> = {}, names = ['Jesse']): GameState =>
+  createGame({ id: 'g', seed: 1, config: baseConfig(over), playerNames: names });
+
+/** Parks a game on the last Stage of its final Day, so one `advance` runs the clock off the end. */
+function atTheEnd(s: GameState): GameState {
+  s.clock.day = s.config.days + s.extraDays + 1;
+  s.clock.stage = STAGES_PER_DAY;
+  s.clock.phase = 'shiftChange';
+  return s;
+}
+
+describe('§3.3 extended play — the ending pauses rather than stopping (Gitea#11)', () => {
+  it('offers another Day on a days-based ending, and records the result anyway', () => {
+    const s = atTheEnd(game());
+    advance(s);
+    assert.equal(s.status, 'awaitingExtension', 'a days-based ending did not offer another Day');
+    assert.ok(s.outcome, 'the result was not decided');
+    assert.ok(s.official, 'the official result was not frozen');
+    assert.equal(s.official!.day, s.config.days, 'the official Day is not the original game length');
+  });
+
+  it('does NOT offer another Day after a collision breach — §3.4 is final', () => {
+    const s = game({ mode: 'competitive', maxCollisionsPerDay: 2 });
+    s.collisionsToday = 2;
+    s.clock.stage = 1;
+    s.clock.phase = 'shiftChange';
+    advance(s);
+    assert.equal(s.status, 'finished', 'a railroad declared unsafe offered to carry on');
+    assert.equal(s.outcome!.reason, 'collisionFloor');
+  });
+
+  it('refuses every ordinary intent while the extension question is open', () => {
+    const s = atTheEnd(game());
+    advance(s);
+    assert.equal(check(s, 0, { type: 'draw.fromHomeOffice' }), 'WRONG_PHASE');
+    assert.equal(check(s, 0, { type: 'game.extend', player: 0, agree: true }), null, 'the vote itself was refused');
+  });
+
+  it('offers only the two votes, and only to a seat that has not voted', () => {
+    const s = atTheEnd(game({ mode: 'competitive' }, ['A', 'B']));
+    advance(s);
+    assert.deepEqual(
+      legalActions(s, 0).map((i) => i.type),
+      ['game.extend', 'game.extend'],
+      'something other than the vote is legal while the game is stopped',
+    );
+    applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
+    assert.equal(legalActions(s, 0).length, 0, 'a seat was offered a second vote');
+    assert.equal(check(s, 0, { type: 'game.extend', player: 0, agree: true }), 'ALREADY_VOTED');
+    assert.equal(legalActions(s, 1).length, 2, 'the seat still to vote was not offered the vote');
+  });
+
+  it('refuses the vote when no extension is pending', () => {
+    const s = game();
+    assert.equal(check(s, 0, { type: 'game.extend', player: 0, agree: true }), 'NOT_AWAITING_EXTENSION');
+  });
+});
+
+describe('§3.3 extended play — one Day at a time (Gitea#11)', () => {
+  it('grants exactly one Day in solitaire, then asks again at the end of it', () => {
+    const s = atTheEnd(game());
+    advance(s);
+    const official = { ...s.official!.outcome };
+
+    applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
+    assert.equal(s.status, 'active', 'agreeing did not resume play');
+    assert.equal(s.extraDays, 1, 'more or less than one Day was granted');
+    assert.deepEqual(s.extensionVotes, [null], 'the votes were not cleared for the next question');
+
+    // Run the extra Day off the end: the question comes round again.
+    atTheEnd(s);
+    advance(s);
+    assert.equal(s.status, 'awaitingExtension', 'the second ending did not ask again');
+    assert.equal(s.extraDays, 1, 'a second Day was granted without being asked for');
+    assert.deepEqual(s.official!.outcome, official, 'the official result was rewritten');
+    assert.equal(s.official!.day, s.config.days, 'the official Day moved with the extension');
+  });
+
+  it('ends the moment one seat declines, without waiting for the rest', () => {
+    const s = atTheEnd(game({ mode: 'competitive' }, ['A', 'B', 'C']));
+    advance(s);
+    applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
+    assert.equal(s.status, 'awaitingExtension', 'one yes ended the vote');
+
+    applyIntent(s, 1, { type: 'game.extend', player: 1, agree: false });
+    assert.equal(s.status, 'finished', 'a refusal did not end the game immediately');
+    assert.equal(s.extraDays, 0, 'a Day was granted despite a refusal');
+    assert.equal(check(s, 2, { type: 'game.extend', player: 2, agree: true }), 'NOT_AWAITING_EXTENSION',
+      'the seat that never voted is still being waited on');
+  });
+
+  it('needs every seat before it grants the Day', () => {
+    const s = atTheEnd(game({ mode: 'competitive' }, ['A', 'B', 'C']));
+    advance(s);
+    applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
+    applyIntent(s, 1, { type: 'game.extend', player: 1, agree: true });
+    assert.equal(s.status, 'awaitingExtension', 'two of three votes granted the Day');
+    applyIntent(s, 2, { type: 'game.extend', player: 2, agree: true });
+    assert.equal(s.status, 'active', 'a unanimous table was not given its Day');
+    assert.equal(s.extraDays, 1);
+  });
+
+  it('keeps the official result when a collision ends an EXTENDED Day', () => {
+    // The case the freeze exists for: a railroad declared unsafe on the extra Day does not retract
+    // who won on the last scheduled one.
+    const s = atTheEnd(game({ mode: 'competitive', maxCollisionsPerDay: 2 }, ['A', 'B']));
+    s.players[0]!.revenue = 9;
+    s.players[1]!.revenue = 2;
+    advance(s);
+    const official = { ...s.official!.outcome };
+    assert.equal(official.result, 'win');
+    assert.equal(official.winner, 0);
+
+    applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
+    applyIntent(s, 1, { type: 'game.extend', player: 1, agree: true });
+    assert.equal(s.status, 'active');
+
+    s.collisionsToday = 2;
+    s.clock.stage = 1;
+    s.clock.phase = 'shiftChange';
+    advance(s);
+    assert.equal(s.status, 'finished');
+    assert.equal(s.outcome!.reason, 'collisionFloor', 'the current evaluation was not updated');
+    assert.deepEqual(s.official!.outcome, official, 'a late collision rewrote a recorded win');
+  });
+
+  it('decides the winner at the ORIGINAL game length, whoever leads afterwards', () => {
+    const s = atTheEnd(game({ mode: 'competitive' }, ['A', 'B']));
+    s.players[0]!.revenue = 9;
+    s.players[1]!.revenue = 2;
+    advance(s);
+    assert.equal(s.official!.outcome.winner, 0);
+    assert.deepEqual(s.official!.revenues, [9, 2], 'the official standings were not frozen');
+
+    applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
+    applyIntent(s, 1, { type: 'game.extend', player: 1, agree: true });
+
+    // B overtakes A during the extra Day, and it changes nothing official.
+    s.players[1]!.revenue = 40;
+    atTheEnd(s);
+    advance(s);
+    assert.equal(s.official!.outcome.winner, 0, 'overtaking after the timetable took the win');
+    assert.deepEqual(s.official!.revenues, [9, 2], 'the frozen standings moved');
+    assert.equal(s.outcome!.winner, 1, 'the informational evaluation did not follow the new leader');
+  });
+});
+
+describe('§3.3 extended play — it survives being replayed (Gitea#11)', () => {
+  it('reproduces an extended game from seed and intents alone', () => {
+    // The reason the vote is an intent at all. A save is a replay, so a decision that is not in the
+    // history did not happen — an extended game would evaporate on the next reload.
+    const play = (): GameState => {
+      const s = atTheEnd(game());
+      advance(s);
+      applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
+      return s;
+    };
+    const a = play();
+    const b = play();
+    assert.equal(a.extraDays, b.extraDays);
+    assert.equal(a.status, b.status);
+    assert.deepEqual(a.official!.outcome, b.official!.outcome);
+  });
+
+  it('narrates the vote, so a table can see who called time', () => {
+    const s = atTheEnd(game({ mode: 'competitive' }, ['A', 'B']));
+    advance(s);
+    const yes = applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
+    assert.ok(yes.ok);
+    assert.deepEqual(yes.events.map((e) => e.type), ['extensionVoted']);
+    const no = applyIntent(s, 1, { type: 'game.extend', player: 1, agree: false });
+    assert.ok(no.ok);
+    assert.deepEqual(no.events.map((e) => e.type), ['extensionVoted', 'playConcluded']);
+  });
+
+  it('announces the granted Day', () => {
+    const s = atTheEnd(game());
+    advance(s);
+    const r = applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
+    assert.ok(r.ok);
+    assert.deepEqual(r.events.map((e) => e.type), ['extensionVoted', 'dayExtended']);
+    const extended = r.events.find((e) => e.type === 'dayExtended');
+    assert.equal(extended && 'day' in extended ? extended.day : null, s.config.days + 1);
+  });
+});
+
+describe('§3.3 extended play — bots play the timetable they were dealt (Gitea#11)', () => {
+  it('REGRESSION: a simulated game terminates whatever the policy would vote', () => {
+    /**
+     * `playGame` declines on the driver's own account rather than leaving it to the policy, and this
+     * is why. `randomBot` picks uniformly among its legal options, so it takes another Day about
+     * half the time — and since a table may go on granting Days for ever, the game then runs to
+     * `maxTurns`. It did: `test/sim.test.ts` went from under a second to an unbounded hang, every
+     * seeded game in the harness playing fifty thousand turns instead of a couple of hundred.
+     *
+     * `randomBot` is the policy that exposes it, but the guarantee has to hold for any policy,
+     * including ones not written yet — hence the fix living in the driver and the test living here.
+     */
+    const s = createGame({ id: 'g', seed: 9, config: baseConfig({ days: 1 }), playerNames: ['Jesse'] });
+    const out = playGame(s, randomBot(7), pump, 4_000);
+    assert.equal(s.status, 'finished', 'a simulated game did not finish');
+    assert.equal(s.extraDays, 0, 'the harness played Days the game was not dealt');
+    assert.ok(out.turns < 4_000, `ran to the turn cap (${out.turns}) instead of ending`);
+  });
+
+  it('developerBot declines, so a bot-only game ends on schedule', () => {
+    // "If only bots are playing, they never vote to extend" (Jesse, 2026-08-28). The server votes
+    // yes on a bot's behalf once every human has already agreed; this policy is what is left when
+    // there are no humans to follow.
+    const s = atTheEnd(game());
+    advance(s);
+    const choice = developerBot.choose(s, 0, legalActions(s, 0));
+    assert.equal(choice.type, 'game.extend');
+    assert.equal('agree' in choice ? choice.agree : null, false, 'a bot asked for another Day');
+  });
+});
+
+/**
+ * §3.3 — WHO THE SCREEN SAYS THE TABLE IS WAITING ON, while the vote is open.
+ *
+ * The vote is PARALLEL, and `apply.ts` says so where it accepts one: "open to every seat at once:
+ * it is a table decision rather than a ruling, so THERE IS NO ACTOR TO BE". Any seat that has not
+ * voted may vote at any moment, in any order, and one refusal ends it. So the honest answer to "who
+ * are we waiting on" is every un-voted seat — which is exactly what the vote tally beside the chart
+ * already draws — and the honest answer to "whose turn is it" is nobody.
+ *
+ * The engine gave that answer and the screen did not. `currentActor(game)` guards on
+ * `status !== 'active'` and returned null; `actingPlayer(state)` has no such guard and returned
+ * `clock.currentActor`, which still holds whoever moved last before the timetable ran out. The
+ * frame took the second, so the turn chart named one arbitrary seat — the last to act, who has no
+ * more claim on the vote than anybody else — while the tally underneath correctly showed three
+ * seats outstanding.
+ *
+ * The fourth of these in a row after Gitea#21, #22 and #94, and the first found by asking the
+ * question of a state the game is not ACTIVE in. See TODO #96.
+ */
+describe('§3.3 extended play — the vote has no actor (#96)', () => {
+  const table = (): GameState => {
+    const s = atTheEnd(game({ mode: 'competitive' }, ['Ann', 'Bob', 'Cy']));
+    advance(s);
+    assert.equal(s.status, 'awaitingExtension', 'the table is not being asked');
+    return s;
+  };
+
+  it('reports nobody acting while the vote is open, to a player and to a spectator alike', () => {
+    const s = table();
+    assert.notEqual(s.clock.currentActor, null, 'the premise is gone: nothing was left on the clock');
+
+    assert.equal(currentActorOfState(s), null, 'the engine named an actor during a parallel vote');
+    assert.equal(
+      snapshot(s, [], null, null, null, false, 0).actor,
+      null,
+      'the turn chart named a seat while the whole table was voting',
+    );
+    assert.equal(publicSnapshot(s).actor, null, 'the common board named a seat during the vote');
+  });
+
+  it('agrees with the session, which is the half that decides what is legal', () => {
+    // The disagreement is the bug, not either answer on its own: `currentActor` is what refuses an
+    // intent, so a screen that names somebody it would refuse is telling the table to wait on a
+    // player who cannot act.
+    const s = table();
+    const g = { state: s, log: [] } as unknown as Parameters<typeof currentActor>[0];
+    assert.equal(currentActorOfState(s), currentActor(g), 'the screen and the session disagree');
+  });
+
+  it('still names the actor during ordinary play, which is the case that must not regress', () => {
+    const s = game({ mode: 'competitive' }, ['Ann', 'Bob', 'Cy']);
+    pump(s);
+    assert.equal(s.status, 'active', 'the premise is gone: the game is not running');
+    assert.equal(currentActorOfState(s), s.clock.currentActor, 'an active game lost its actor');
+    assert.equal(snapshot(s, [], null, null, null, false, 0).actor, s.clock.currentActor);
+  });
+
+  it('reports nobody once the table has declined and the game is finished', () => {
+    const s = table();
+    applyIntent(s, 1, { type: 'game.extend', player: 1, agree: false });
+    assert.equal(s.status, 'finished', 'a refusal did not end it');
+    assert.equal(currentActorOfState(s), null, 'a finished game still had somebody to move');
+    assert.equal(publicSnapshot(s).actor, null, 'the common board named a seat after the game ended');
+  });
+});

test/harness.test.ts

@@ -228,14 +228,28 @@ describe('the game conserves Rolling Stock', () => {
       for (let t = 0; t < 50_000; t++) {
         const before = census(s);
         const pumped = pump(s);
-        // §10 — a collision destroys both trains and everything they were carrying. That is the one
-        // legitimate way the count falls, so the expectation follows it down.
-        for (const e of pumped) {
-          if (e.type === 'trainsDestroyed') for (const tr of e.trains) expected -= tr.consist.length;
-        }
-        assert.ok(
-          census(s) === before || pumped.some((e) => e.type === 'trainsDestroyed'),
-          `seed ${seed}: the engine changed the census by ${census(s) - before} outside a collision`,
+        /**
+         * A COLLISION DESTROYS NO CAR, and this used to assume it destroyed all of them.
+         *
+         * The subtraction that stood here — `expected -= tr.consist.length` for every train in a
+         * `trainsDestroyed` event — describes a rule the engine does not have. Gap 2c (`advance.ts`,
+         * "TAKE THE WRECK OFF THE CARD") sends the wreck's cabooses back to the Division Yard and
+         * everything else to Classification, so the stock is conserved through a collision like any
+         * other move. The train is destroyed; its cars are not.
+         *
+         * It passed for as long as it did because none of the six seeds below ever collided, so the
+         * branch never ran. Changing the deck to the sheet's counts (Gitea#14) moved the deals, seed
+         * 24757 collided, and the test failed claiming the engine had CONJURED three cars — the
+         * exact opposite of what had happened.
+         *
+         * So the census is now held flat, unconditionally, which is both the real invariant and a
+         * stronger test than the one it replaces: there is no longer any event that excuses a
+         * change, and `expected` cannot drift away from the supply it was dealt.
+         */
+        assert.equal(
+          census(s),
+          before,
+          `seed ${seed}: the engine changed the census by ${census(s) - before} while pumping`,
         );
         if (s.status === 'finished') break;
         const actor = s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
@@ -290,7 +304,18 @@ describe('every published replay actually replays', () => {
         `${f} is dead — it replays ${back.history.length} of ${save.history.length} intents. ` +
           'Re-record it with save-replay.ts rather than editing the file.',
       );
-      assert.equal(back.state.status, 'finished', `${f} does not reach the end of its game`);
+      /**
+       * `awaitingExtension` counts as the end since Gitea#11 — and for a published file it is the
+       * EXPECTED end. These saves were recorded before extended play existed, so their histories
+       * carry no `game.extend` vote: replaying one runs the timetable out and stops on the question
+       * nobody was there to answer. That is a game that reached the end of its own history, which is
+       * what this test is about. `active` would still be a dead replay.
+       */
+      assert.ok(
+        back.state.status === 'finished' || back.state.status === 'awaitingExtension',
+        `${f} does not reach the end of its game — status ${back.state.status}`,
+      );
+      assert.ok(back.state.official !== null, `${f} ends without recording a result`);
     }
   });
 });

test/mainline-cards.test.ts

@@ -12,6 +12,7 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 
+import type { MainlineKind } from '../src/engine/content.ts';
 import { advance } from '../src/engine/advance.ts';
 import { applyIntent, areaOf, check } from '../src/engine/apply.ts';
 import { legalActions } from '../src/engine/legal.ts';
@@ -27,7 +28,7 @@ import {
 import { createGame } from '../src/engine/setup.ts';
 import type { GameEvent } from '../src/engine/events.ts';
 import type { GameConfig, GameState, GridCoord, TrackCard } from '../src/engine/state.ts';
-import { coordKey, turnOf } from '../src/engine/state.ts';
+import { coordKey, decisionActor, turnOf } from '../src/engine/state.ts';
 import { snapshot } from '../src/sim/view.ts';
 
 const config: GameConfig = {
@@ -43,6 +44,20 @@ const game = (seed = 5): GameState => createGame({ id: 'g', seed, config, player
 const at = (row: number, col: number): GridCoord => ({ row, col });
 
 /** Puts a card of `kind`/`key` in hand and returns its id. */
+/**
+ * Puts a specific rules card in hand and returns its id, MINTING ONE IF THE DECK NO LONGER DEALS IT.
+ *
+ * A card at `copies: 0` is still a card: the catalogue keeps its row and the engine keeps its rule,
+ * so the design stays visible and the mechanic works the moment it is dealt again. Poling and the
+ * sharp curves have been treated that way for a while, and Gitea#14 put the dispatching ladder,
+ * Facing Point Locks, Flying Switch, Section House and Vandalism there too — none of them are in
+ * `docs/Deck cards5.xlsx`.
+ *
+ * This used to throw when it could not find one, which made "dealt zero copies" and "deleted"
+ * indistinguishable from a test's point of view: zeroing Flying Switch took five passing tests of a
+ * rule that had not changed at all down with it. Minting keeps the rule under test independently of
+ * whether the deck currently deals the card, which is the whole reason for keeping the row.
+ */
 function hand(s: GameState, kind: string, key: string): string {
   for (const [id, card] of s.cards) {
     const k = card.kind as { kind: string; key?: string };
@@ -51,7 +66,10 @@ function hand(s: GameState, kind: string, key: string): string {
       return id;
     }
   }
-  throw new Error(`no ${kind} card: ${key}`);
+  const id = `zero-copy-${kind}-${key}`;
+  s.cards.set(id, { id, kind: { kind, key } } as never);
+  s.decks.hands.set(0, [id]);
+  return id;
 }
 
 /**
@@ -90,53 +108,124 @@ function drawTurn(s: GameState): void {
 
 // ---------------------------------------------------------------------------
 
-describe('grade modifiers change crossing time', () => {
-  it('a Heavy Grade takes two Stages bare', () => {
-    assert.equal(crossingStages('heavyGrade', 'fast', false), 2);
+/**
+ * Crossing time on the region model (Gitea#3). `cross` fills in the parts each test does not care
+ * about, so the numbers below read as the table RAR gave rather than as argument lists.
+ */
+const cross = (
+  kind: Parameters<typeof crossingStages>[0],
+  over: Partial<Parameters<typeof crossingStages>[1]> = {},
+): number =>
+  crossingStages(kind, {
+    trainSpeed: 'fast',
+    direction: 'east',
+    gradeUp: 'east',
+    modifiers: [],
+    ...over,
+  });
+
+describe('a card costs one Stage per printed region (Gitea#3)', () => {
+  /**
+   * RAR, 2026-08-26, and this REPLACES the two rules that were here before — Q1, "the printed 60/30
+   * are mph expressed as crossing time", and Q2, "a Slow train adds one Stage to every card".
+   *
+   * "Ignore speed signs, they are just graphics. Regions shown on cards indicate how many stages it
+   * takes to cross. Plains is 1. Double track is 1, tunnel is 2, curves is 2, heavy grade is 3
+   * unless you have help."
+   *
+   * The report that opened the issue was a Slow train taking two Stages to clear Double Track. Q2 is
+   * what did that, and it is gone.
+   */
+  it('crosses in the number of regions the card prints, whatever the train', () => {
+    for (const speed of ['fast', 'slow'] as const) {
+      assert.equal(cross('plains', { trainSpeed: speed }), 1, `plains, ${speed}`);
+      assert.equal(cross('doubleTrack', { trainSpeed: speed }), 1, `double track, ${speed}`);
+      assert.equal(cross('trestle', { trainSpeed: speed }), 1, `trestle, ${speed}`);
+      assert.equal(cross('curves', { trainSpeed: speed }), 2, `curves, ${speed}`);
+      assert.equal(cross('tunnel', { trainSpeed: speed }), 2, `tunnel, ${speed}`);
+      assert.equal(cross('heavyGrade', { trainSpeed: speed }), 3, `heavy grade, ${speed}`);
+    }
+  });
+
+  it('reads Fast/Slow on Hilly and on nothing else', () => {
+    // "Some cards say fast / slow… Fast / Slow does not apply to every card — just those that say
+    // fast / slow on them. Currently this is only hilly." A fast train starts in the second region.
+    assert.equal(cross('hilly', { trainSpeed: 'fast' }), 1);
+    assert.equal(cross('hilly', { trainSpeed: 'slow' }), 2);
+  });
+
+  it('does not read the consist any more', () => {
+    // Hilly used to take its split off the printed P60/F30 and decide by whether the train carried a
+    // coach, so a fast freight crossed slower than a slow passenger train. RAR: "I notice that you
+    // are basing stages in mainline cards off coach/non-coach. Actually, all trains are rated as
+    // FAST and SLOW." `crossingStages` no longer takes a consist at all — this test is here so the
+    // deletion is deliberate rather than incidental.
+    assert.equal(cross('hilly', { trainSpeed: 'fast' }), cross('hilly', { trainSpeed: 'fast' }));
+  });
+
+  it('runs a train through a siding or an Interchange in one Stage', () => {
+    // Both print a back region that is not part of the road, so a train passing through starts past
+    // it. What that region is FOR is tested below and in the collision tests.
+    assert.equal(cross('uncontrolledSiding'), 1);
+    assert.equal(cross('interchange'), 1);
+  });
+
+  it('costs the extra Stage to anything starting in that back region', () => {
+    // The Uncontrolled Siding with a train already on it, and an Extra beginning its run at an
+    // Interchange. Both start at the back and have the whole card to run.
+    assert.equal(cross('uncontrolledSiding', { startsAtBack: true }), 2);
+    assert.equal(cross('interchange', { startsAtBack: true }), 2);
+  });
+});
+
+describe('grade modifiers move the start, not the clock', () => {
+  it('a Heavy Grade takes three Stages bare', () => {
+    // Three regions, up from the two the old 30mph reading gave it.
+    assert.equal(cross('heavyGrade'), 3);
   });
 
   it('Brakeman speeds the descent but not the climb', () => {
-    // Q11 — the card prints "(Up)" and "Player sets orientation", so the last argument is which
-    // way is UPHILL. With up = east, a westbound train is descending.
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['brakeman'], 'west', 'east'), 1);
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['brakeman'], 'east', 'east'), 2);
+    // Q11 — the card prints "(Up)" and "Player sets orientation", so `gradeUp` is which way is
+    // UPHILL. With up = east, a westbound train is descending.
+    assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'west' }), 2);
+    assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'east' }), 3);
   });
 
-  it('follows the orientation the player chose, not a fixed compass direction', () => {
-    // The same train on the same card, with the card turned around: Brakeman helps a westbound
-    // train on an east-climbing grade, and an eastbound one when the grade climbs west.
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['brakeman'], 'east', 'west'), 1);
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['brakeman'], 'west', 'west'), 2);
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'west', 'west'), 1);
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'east', 'west'), 2);
+  it('follows the orientation the card was dealt, not a fixed compass direction', () => {
+    // The same train on the same card, with the card turned around.
+    assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'east', gradeUp: 'west' }), 2);
+    assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'west', gradeUp: 'west' }), 3);
+    assert.equal(cross('heavyGrade', { modifiers: ['helpers'], direction: 'west', gradeUp: 'west' }), 2);
+    assert.equal(cross('heavyGrade', { modifiers: ['helpers'], direction: 'east', gradeUp: 'west' }), 3);
   });
 
   it('Helpers speed the climb but not the descent', () => {
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'east', 'east'), 1);
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'west', 'east'), 2);
+    // RAR: "helpers… helps all trains going up hill by starting 1 region easier — so 2 to traverse,
+    // not 3."
+    assert.equal(cross('heavyGrade', { modifiers: ['helpers'], direction: 'east' }), 2);
+    assert.equal(cross('heavyGrade', { modifiers: ['helpers'], direction: 'west' }), 3);
   });
 
-  it('Airbrakes stack with Brakeman on a slow train', () => {
-    // A slow train pays 3 on a grade; Brakeman and Airbrakes take one Stage each.
-    assert.equal(crossingStages('heavyGrade', 'slow', false, [], 'west', 'east'), 3);
-    assert.equal(crossingStages('heavyGrade', 'slow', false, ['brakeman'], 'west', 'east'), 2);
-    assert.equal(
-      crossingStages('heavyGrade', 'slow', false, ['brakeman', 'airbrakes'], 'west', 'east'),
-      1,
-    );
+  it('Airbrakes stack on top of Brakeman', () => {
+    // "Airbrakes is an upgrade from brakemen (which must be played first)", so a fully-equipped
+    // grade is one Stage downhill — and `check` refuses Airbrakes without Brakeman already there.
+    assert.equal(cross('heavyGrade', { direction: 'west' }), 3);
+    assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'west' }), 2);
+    assert.equal(cross('heavyGrade', { modifiers: ['brakeman', 'airbrakes'], direction: 'west' }), 1);
   });
 
   it('never lets a train cross in no time', () => {
+    // Three modifiers on a three-region card would otherwise put the start past the far edge.
     assert.equal(
-      crossingStages('heavyGrade', 'fast', false, ['brakeman', 'airbrakes'], 'west', 'east'),
+      cross('heavyGrade', { modifiers: ['brakeman', 'airbrakes', 'helpers'], direction: 'west' }),
       1,
     );
   });
 
   it('leaves non-grade cards alone', () => {
     // Brakeman on Plains would be an illegal placement anyway; the maths must not move regardless.
-    assert.equal(crossingStages('plains', 'fast', false, ['brakeman'], 'west', 'east'), 1);
-    assert.equal(crossingStages('curves', 'fast', false, ['helpers'], 'east', 'east'), 2);
+    assert.equal(cross('plains', { modifiers: ['brakeman'], direction: 'west' }), 1);
+    assert.equal(cross('curves', { modifiers: ['helpers'] }), 2);
   });
 });
 
@@ -209,8 +298,8 @@ describe('Realignment converts one Mainline type to another', () => {
 
     assert.ok(r.ok);
     assert.equal(node.card, 'plains', 'Curves realigns to Plains');
-    // The point of the card: Curves is a 30 (two Stages), Plains a 60 (one).
-    assert.equal(crossingStages(node.card, 'fast', false), 1);
+    // The point of the card: Curves prints two regions, Plains one, so realigning halves the time.
+    assert.equal(cross(node.card), 1);
   });
 
   it('refuses a card with no conversion listed', () => {
@@ -228,77 +317,177 @@ describe('Realignment converts one Mainline type to another', () => {
   });
 });
 
-describe('Red Flags protect a stopped train', () => {
-  /** A slow train `behind` closing on a stopped train `ahead`, both eastbound on node 1. */
-  function rearEnder(s: GameState) {
-    const node = pinned(s, 1, 'plains');
-    node.transits.push({ tray: 'ahead', stagesRemaining: 2, stagesTotal: 2, direction: 'east' });
-    s.trays.set('ahead', {
-      id: 'ahead', trainNumber: 4, trainIsExtra: false, engineAt: 0,
-      consist: [], direction: 'east', position: { at: 'mainline', index: 1 }, movesUsed: 0,
+describe('Red Flags hold a train out of your Limits (Gitea#19)', () => {
+  /**
+   * REPLACES the old rule outright (Jesse, 2026-08-29). Red Flags used to be played on a stopped
+   * train out on the Mainline and protected it from a rear-ender — measured at 4,212 offers and 4
+   * plays across 600 games, a mechanic nobody used. ABS Signals already does that job better.
+   *
+   * Now: "If played, asked FLAG EAST or FLAG WEST. That stops all trains from entering your limits
+   * from that direction (i.e. Flag East holds westbound trains)." Spent on the train it stops —
+   * one card, one train.
+   */
+
+  /** A westbound train one Stage from entering seat 0's district from the east. */
+  function approaching(s: GameState) {
+    const officeIndex = s.division.nodes.findIndex((n) => n.kind === 'office' && n.seat === 0);
+    const node = pinned(s, officeIndex + 1, 'plains');
+    node.transits.push({ tray: 'inbound', stagesRemaining: 1, stagesTotal: 1, direction: 'west' });
+    s.trays.set('inbound', {
+      id: 'inbound', trainNumber: 9, trainIsExtra: false, engineAt: 0,
+      consist: [{ type: 'hopper', loaded: true }], direction: 'west',
+      position: { at: 'mainline', index: officeIndex + 1 }, movesUsed: 0,
     });
-    s.trays.set('behind', {
-      id: 'behind', trainNumber: 2, trainIsExtra: false, engineAt: 0,
-      consist: [], direction: 'east', position: { at: 'divisionPoint', side: 'west' }, movesUsed: 0,
-    });
-    const dp = s.division.nodes[0];
-    if (dp?.kind === 'divisionPoint') dp.holding.push('behind');
     s.clock.phase = 'mainline';
     s.movedThisPhase = new Set();
-    return node;
+    return s.division.nodes[officeIndex] as Extract<typeof s.division.nodes[0], { kind: 'office' }>;
   }
 
-  it('holds the approaching train instead of letting it close', () => {
+  it('FLAG EAST holds a westbound train short of the Limits', () => {
     const s = game();
-    const node = rearEnder(s);
-    node.redFlagged = ['ahead'];
+    const office = approaching(s);
+    office.redFlag = 'east';
 
     advance(s);
-    assert.deepEqual(
-      s.trays.get('behind')!.position,
-      { at: 'divisionPoint', side: 'west' },
-      'the flagged train must not be approached',
-    );
+    const pos = s.trays.get('inbound')!.position;
+    assert.equal(pos.at, 'mainline', 'the flagged train came in anyway');
+    assert.ok(!areaOf(s, 0).adOccupancy.includes('inbound'), 'it reached an A/D track');
   });
 
-  it('comes in when the protected train rolls', () => {
+  it('is spent on the train it stops — one card, one train', () => {
     const s = game();
-    const node = rearEnder(s);
-    node.redFlagged = ['ahead'];
-    // Bring the protected train to the end of its crossing so it leaves the card.
-    node.transits[0]!.stagesRemaining = 1;
+    const office = approaching(s);
+    office.redFlag = 'east';
 
-    for (let i = 0; i < 12 && (node.redFlagged?.length ?? 0) > 0; i++) advance(s);
-    assert.deepEqual(node.redFlagged, [], 'flags come in once the train moves off');
+    advance(s);
+    assert.equal(office.redFlag, undefined, 'the flag stayed up after stopping a train');
   });
 
-  it('only protects a train out on the Mainline', () => {
+  it('lets the train in on the next Mainline Phase', () => {
+    // "Loses one Mainline Phase" — it buys a Stage to clear the lead, not permanent protection.
+    const s = game();
+    const office = approaching(s);
+    office.redFlag = 'east';
+    advance(s);
+
+    s.clock.phase = 'mainline';
+    s.movedThisPhase = new Set();
+    advance(s);
+    assert.ok(areaOf(s, 0).adOccupancy.includes('inbound'), 'the train never came in');
+  });
+
+  it('does not hold a train coming from the OTHER side', () => {
+    // "Flag East holds westbound trains" — an eastbound train arrives from the west.
+    const s = game();
+    const office = approaching(s);
+    office.redFlag = 'west';
+
+    advance(s);
+    assert.ok(areaOf(s, 0).adOccupancy.includes('inbound'), 'a west flag held a train from the east');
+    assert.equal(office.redFlag, 'west', 'the wrong-side flag was spent');
+  });
+
+  it('is played on a side, not on a train', () => {
     const s = game();
-    rearEnder(s);
     s.clock.phase = 'localOps';
     s.clock.currentActor = 0;
     const cardId = hand(s, 'maneuver', 'redFlags');
 
-    assert.equal(
-      check(s, 0, { type: 'maneuver.redFlags', cardId, trayId: 'behind' }),
-      'NO_PLACEMENT',
-      'a train sitting at a Division Point cannot be rear-ended',
-    );
-    assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, trayId: 'ahead' }), null);
+    assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, side: 'east' }), null);
+    assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, side: 'west' }), null);
   });
 
-  it('will not double-flag the same train', () => {
+  it('will not double-flag the same side', () => {
     const s = game();
-    const node = rearEnder(s);
     s.clock.phase = 'localOps';
     s.clock.currentActor = 0;
     const cardId = hand(s, 'maneuver', 'redFlags');
-    node.redFlagged = ['ahead'];
+    const officeIndex = s.division.nodes.findIndex((n) => n.kind === 'office' && n.seat === 0);
+    const office = s.division.nodes[officeIndex] as { redFlag?: string };
+    office.redFlag = 'east';
 
-    assert.equal(
-      check(s, 0, { type: 'maneuver.redFlags', cardId, trayId: 'ahead' }),
-      'OPTION_ALREADY_CHOSEN',
-    );
+    assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, side: 'east' }), 'ALREADY_FLAGGED');
+    assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, side: 'west' }), null,
+      'the other side should still be free');
+  });
+});
+
+describe('Red Flags offered at the moment of danger (Gitea#19)', () => {
+  /**
+   * "In actual cases of danger… if there is a train or cars on the track and there will be a
+   * collision, then you break in with a dialog that says COLLISION RISK! FLAG AGAINST T2? This way,
+   * you can play the card normally or out of phase, but only if you need it."
+   *
+   * The engine establishes the danger, so the player is never asked to judge it — which is also why
+   * the bot can now use this card at all. It is offered ONLY to somebody holding one.
+   */
+  function dangerous(s: GameState, giveCard: boolean) {
+    const officeIndex = s.division.nodes.findIndex((n) => n.kind === 'office' && n.seat === 0);
+    const node = pinned(s, officeIndex + 1, 'plains');
+    node.transits.push({ tray: 'inbound', stagesRemaining: 1, stagesTotal: 1, direction: 'west' });
+    s.trays.set('inbound', {
+      id: 'inbound', trainNumber: 9, trainIsExtra: false, engineAt: 0,
+      consist: [{ type: 'hopper', loaded: true }], direction: 'west',
+      position: { at: 'mainline', index: officeIndex + 1 }, movesUsed: 0,
+    });
+    // A hopper fouling the Running Track: §8.3 makes this arrival a collision.
+    const area = areaOf(s, 0);
+    area.grid.get(coordKey(area.officeCoord))!.standing = [{ type: 'hopper', loaded: false }];
+    if (giveCard) hand(s, 'maneuver', 'redFlags');
+    s.clock.phase = 'mainline';
+    s.movedThisPhase = new Set();
+  }
+
+  it('breaks in to offer the flag when an arrival would collide', () => {
+    const s = game();
+    dangerous(s, true);
+    advance(s);
+    assert.equal(s.clock.pendingDecision?.kind, 'redFlag', 'no prompt before a certain collision');
+    assert.equal(decisionActor(s), 0, 'the prompt went to the wrong player');
+  });
+
+  it('flagging holds the train and costs the card', () => {
+    const s = game();
+    dangerous(s, true);
+    advance(s);
+    const before = (s.decks.hands.get(0) ?? []).length;
+
+    const r = applyIntent(s, 0, { type: 'mainline.redFlag', flag: true });
+    assert.ok(r.ok, 'the flag was refused');
+    advance(s);
+
+    assert.equal(s.players[0]!.revenue, 0, 'the collision happened anyway');
+    assert.equal(s.trays.get('inbound')!.position.at, 'mainline', 'the train came in regardless');
+    assert.equal((s.decks.hands.get(0) ?? []).length, before - 1, 'the card was not spent');
+  });
+
+  it('declining lets the collision happen', () => {
+    const s = game();
+    dangerous(s, true);
+    advance(s);
+
+    assert.ok(applyIntent(s, 0, { type: 'mainline.redFlag', flag: false }).ok);
+    advance(s);
+    assert.equal(s.players[0]!.revenue, -5, 'waving it through did not collide');
+  });
+
+  it('does not offer a flag to a player holding none', () => {
+    // A prompt with one button is not a choice, and it leaks that a collision is coming.
+    const s = game();
+    dangerous(s, false);
+    advance(s);
+    assert.equal(s.clock.pendingDecision, null, 'offered a flag to a player with no card');
+    assert.equal(s.players[0]!.revenue, -5, 'the collision should have happened');
+  });
+
+  it('stays quiet when the arrival is safe', () => {
+    const s = game();
+    dangerous(s, true);
+    // Clear the hazard: nothing fouling the Running Track, and room at the Office.
+    const area = areaOf(s, 0);
+    area.grid.get(coordKey(area.officeCoord))!.standing = [];
+    advance(s);
+    assert.equal(s.clock.pendingDecision, null, 'interrupted the phase for a safe arrival');
   });
 });
 
@@ -681,6 +870,100 @@ describe('a turnout may be laid on top of a card already down', () => {
   });
 });
 
+describe('extras that must run loaded, and one that must not (Gitea#13)', () => {
+  /**
+   * "I've redefined some of the extra trains that they have to run full boxcars — military trains,
+   * circus trains, etc. If not loaded, then empty, and if none available, run without."
+   *
+   * A PREFERENCE ORDER, so every test here is about what the DIVISION YARD still holds. The rule
+   * has nothing to say about a train once it is running; it decides which car may be taken next.
+   */
+  const madeUp = (trainNumber: number) => {
+    const s = game();
+    s.clock.phase = 'newTrain';
+    s.trays.set('t', {
+      id: 't', trainNumber, trainIsExtra: true, engineAt: 0,
+      consist: [], direction: 'east', position: { at: 'divisionPoint', side: 'west' }, movesUsed: 0,
+    });
+    return s;
+  };
+  const place = (carType: string, loaded: boolean) =>
+    ({ type: 'newTrain.placeCar', trayId: 't', carType, loaded }) as never;
+  /** Leaves the Division Yard holding exactly the cars described. */
+  const stockYard = (s: ReturnType<typeof madeUp>, cars: { type: string; loaded: boolean }[]) => {
+    s.yards.divisionYard.length = 0;
+    s.yards.divisionYard.push(...(cars as never[]));
+  };
+
+  it('refuses an empty while the yard can still supply a loaded one (X18 Circus)', () => {
+    const s = madeUp(18);
+    stockYard(s, [{ type: 'boxcar', loaded: true }, { type: 'boxcar', loaded: false }]);
+    assert.equal(check(s, 0, place('boxcar', false)), 'NO_SUITABLE_CAR',
+      'an empty was accepted while a loaded boxcar was still in the yard');
+    assert.equal(check(s, 0, place('boxcar', true)), null, 'the loaded boxcar was refused');
+  });
+
+  it('accepts an empty once the yard has no loaded car of that kind left', () => {
+    // "If not loaded, then empty." The rule releases as soon as the yard cannot supply.
+    const s = madeUp(18);
+    stockYard(s, [{ type: 'boxcar', loaded: false }]);
+    assert.equal(check(s, 0, place('boxcar', false)), null,
+      'an empty was refused when the yard held no loaded car at all');
+  });
+
+  it('does not let a loaded car of the WRONG category unlock the rule', () => {
+    // A loaded coach is no reason to refuse an empty boxcar: the preference is per category, since
+    // that is the slot the car is competing for.
+    const s = madeUp(18);
+    stockYard(s, [{ type: 'coach', loaded: true }, { type: 'boxcar', loaded: false }]);
+    assert.equal(check(s, 0, place('boxcar', false)), null,
+      'a loaded coach blocked an empty boxcar');
+  });
+
+  it('exempts the caboose, which is never empty in the supply', () => {
+    const s = madeUp(18);
+    stockYard(s, [{ type: 'caboose', loaded: true }, { type: 'boxcar', loaded: true }]);
+    assert.equal(check(s, 0, place('caboose', true)), null, 'the caboose its card calls for was refused');
+  });
+
+  it('applies to the Military train too', () => {
+    const s = madeUp(19);
+    stockYard(s, [{ type: 'coach', loaded: true }, { type: 'coach', loaded: false }]);
+    assert.equal(check(s, 0, place('coach', false)), 'NO_SUITABLE_CAR',
+      'the Military train took an empty coach over a loaded one');
+  });
+
+  it('leaves trains without the rule alone', () => {
+    // X21 Freight Extra has no loading rule: an empty is as good as a loaded one.
+    const s = madeUp(21);
+    stockYard(s, [{ type: 'boxcar', loaded: true }, { type: 'boxcar', loaded: false }]);
+    assert.equal(check(s, 0, place('boxcar', false)), null,
+      'a train with no loading rule was made to prefer loaded cars');
+  });
+
+  it('REGRESSION: X13 Appleseed is empties-only, and now the rules say so too', () => {
+    /**
+     * `ConsistSpec.emptiesOnly` was declared on the card, RENDERED to the player as "(empties only)"
+     * by `web/game.ts` and `sim/view.ts`, and enforced by NOTHING — `acceptsCar` never read it. So
+     * the Appleseed could be made up with loaded cars while its own card said it could not. Found
+     * while building Gitea#13, which is the same rule pointing the other way.
+     */
+    const s = madeUp(13);
+    stockYard(s, [{ type: 'boxcar', loaded: true }, { type: 'boxcar', loaded: false }]);
+    assert.equal(check(s, 0, place('boxcar', true)), 'NO_SUITABLE_CAR',
+      'the Appleseed took a loaded car despite printing "empties only"');
+    assert.equal(check(s, 0, place('boxcar', false)), null, 'the Appleseed refused an empty');
+  });
+
+  it('still lets the Appleseed take the caboose its consist calls for', () => {
+    // Every caboose in ROLLING_STOCK_SUPPLY is minted loaded, so an unexempted empties-only rule
+    // would bar the one car the card explicitly lists.
+    const s = madeUp(13);
+    stockYard(s, [{ type: 'caboose', loaded: true }]);
+    assert.equal(check(s, 0, place('caboose', true)), null, 'the empties-only rule ate the caboose');
+  });
+});
+
 describe("a train is made up to its card's consist (§8.2)", () => {
   it('takes a caboose when the card calls for one, and refuses a fourth freight car', () => {
     // Train 9 "Heavy Freight" is freight 3 + caboose 1. It was being made up with FOUR hoppers and
@@ -731,7 +1014,11 @@ describe("a train is made up to its card's consist (§8.2)", () => {
 
 describe('regions on a Mainline card (§2.1, §8.2)', () => {
   /** Put one train mid-crossing and ask the view where the map should draw it. */
-  const regionFor = (stagesTotal: number, stagesRemaining: number): { region: number; regions: number } => {
+  const regionFor = (
+    stagesTotal: number,
+    stagesRemaining: number,
+    direction: 'east' | 'west' = 'east',
+  ): { region: number; regions: number } => {
     const s = createGame({
       id: 'reg',
       seed: 4,
@@ -744,7 +1031,7 @@ describe('regions on a Mainline card (§2.1, §8.2)', () => {
     const node = s.division.nodes.find((n) => n.kind === 'mainline');
     assert.ok(node && node.kind === 'mainline');
     const tray = [...s.trays.keys()][0]!;
-    node.transits.push({ tray, stagesRemaining, stagesTotal, direction: 'east' });
+    node.transits.push({ tray, stagesRemaining, stagesTotal, direction });
     const ml = snapshot(s, [], null).division.find((n) => n.kind === 'ml');
     assert.ok(ml, 'no Mainline node in the view');
     const t = ml!.trains.flat()[0]!;
@@ -787,6 +1074,74 @@ describe('regions on a Mainline card (§2.1, §8.2)', () => {
       }
     }
   });
+
+  it('never leaves the card it is on, whichever way it runs', () => {
+    for (const direction of ['east', 'west'] as const) {
+      for (let total = 1; total <= 4; total++) {
+        for (let left = total; left >= 1; left--) {
+          const r = regionFor(total, left, direction).region;
+          assert.ok(r >= 0 && r <= 1, `${direction}, total ${total}, ${left} left put the train in region ${r}`);
+        }
+      }
+    }
+  });
+
+  /**
+   * GITEA#22 — A WESTBOUND TRAIN WAS DRAWN IN THE WRONG HALF OF THE CARD.
+   *
+   * `regionOfTransit` answers "how far along its crossing is this train", counted from the end it
+   * ENTERED: a train with everything still to run is in region 0. That is the right question for the
+   * collision rules, which is what the engine asks it, and both directions share the one index space.
+   *
+   * The map asks a different question — WHICH PRINTED BOX, left to right — and used the same number
+   * for it. East is right on this map and always has been, so for an eastbound train the two agree by
+   * luck: it enters at the west end, so "just entered" and "leftmost box" are the same box. A
+   * westbound train enters at the EAST end, so its region 0 is the card's RIGHT-hand box, and drawing
+   * it at index 0 put it at the left — the whole card mirrored.
+   *
+   * Reported from seed 550943578, undo 187, and it cost a collision. Three westbound trains: TX17 had
+   * just entered (2 Stages still to run, so travel index 0) and T5 was nearly across (1 Stage left,
+   * index 1). Physically TX17 was BEHIND T5 — further east, the direction they had both come from.
+   * The map drew TX17 at the left and so put it further WEST, which reads as further ahead. Asked
+   * whether Train 3 could follow Train 5 onto the card, the Superintendent said yes, and Train 3
+   * entered behind — into TX17, exactly where the rules had it and nowhere near where the map did.
+   *
+   * The engine was right throughout. Only the picture lied, so the fix is one mirror in the view and
+   * the collision rules are untouched. This is the same class of bug as the consist row at the
+   * Whistle Post (`board-svg.ts`, seed 270861860), which came out mirrored for the same reason.
+   */
+  describe('Gitea#22 — the map draws a westbound train where it actually is', () => {
+    it('mirrors a westbound train, because it entered from the east end', () => {
+      // Two-region card. Just entered, 2 Stages still to run: an eastbound train is in the WEST box
+      // and a westbound one is in the EAST box, because they came in at opposite ends.
+      assert.equal(regionFor(2, 2, 'east').region, 0);
+      assert.equal(regionFor(2, 2, 'west').region, 1);
+
+      // One Stage left, nearly across: the two swap.
+      assert.equal(regionFor(2, 1, 'east').region, 1);
+      assert.equal(regionFor(2, 1, 'west').region, 0);
+    });
+
+    it('puts the follower behind the leader, not in front of it — the seed 550943578 collision', () => {
+      // TX17 had just entered; T5 was a Stage from the far end. Both westbound, so BEHIND means to
+      // the east, which is to the right, which is the higher index.
+      const tx17 = regionFor(2, 2, 'west').region;
+      const t5 = regionFor(2, 1, 'west').region;
+      assert.ok(
+        tx17 > t5,
+        `a westbound train that has just entered must be drawn east of one that is nearly across, ` +
+          `but TX17 was drawn at ${tx17} and T5 at ${t5}`,
+      );
+    });
+
+    it('leaves an eastbound train where it has always been drawn', () => {
+      // The mirror must not disturb the direction that was right, which is every existing region test
+      // above — those all run east — and the case the printed rule was written for.
+      assert.equal(regionFor(2, 2, 'east').region, 0);
+      assert.equal(regionFor(2, 1, 'east').region, 1);
+      assert.equal(regionFor(1, 1, 'east').region, 1);
+    });
+  });
 });
 
 describe('Q13 — a train that catches the one ahead runs into it', () => {
@@ -796,18 +1151,35 @@ describe('Q13 — a train that catches the one ahead runs into it', () => {
    * then region 1 — so it catches up whichever order the phase happens to process them in.
    */
   const twoTrains = (opts: { absSignals?: boolean } = {}): { s: GameState; events: GameEvent[] } => {
-    const s = createGame({
-      id: 'rear', seed: 3,
-      config: {
-        mode: 'solitaire', days: 5, minCombinedRevenue: 0, maxCollisionsPerDay: 0, maxCollisionsTotal: 0, pvpCardsAllowed: false,
-        optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
-      },
-      playerNames: ['bot'],
-    });
-    const index = s.division.nodes.findIndex(
-      (n) => n.kind === 'mainline' && !mainlineProfile(n.card).trainsMayPass,
-    );
-    assert.ok(index >= 0, 'no single-track Mainline card in this Division');
+    /**
+     * THE SEED IS SEARCHED FOR, NOT WRITTEN DOWN.
+     *
+     * This asked for seed 3 and asserted that its Division held a single-track Mainline card. It
+     * does not any more: the Division is laid out from the same RNG stream the card deck is
+     * shuffled from, so changing the SIZE of that deck re-deals the Division too. Gitea#14's deck
+     * counts moved it, and the test failed on its own precondition — "no single-track Mainline card
+     * in this Division" — which says nothing about the rule under test.
+     *
+     * The fixture needs A Division with a card trains may not pass on, not one particular one, so
+     * it now takes the first seed that provides one. That is stable across any future retune, and
+     * it fails loudly if such a Division stops being reachable at all.
+     */
+    let s!: GameState;
+    let index = -1;
+    for (let seed = 3; seed < 200 && index < 0; seed++) {
+      s = createGame({
+        id: 'rear', seed,
+        config: {
+          mode: 'solitaire', days: 5, minCombinedRevenue: 0, maxCollisionsPerDay: 0, maxCollisionsTotal: 0, pvpCardsAllowed: false,
+          optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
+        },
+        playerNames: ['bot'],
+      });
+      index = s.division.nodes.findIndex(
+        (n) => n.kind === 'mainline' && !mainlineProfile(n.card).trainsMayPass,
+      );
+    }
+    assert.ok(index >= 0, 'no seed under 200 deals a Division holding a single-track Mainline card');
     const node = s.division.nodes[index]!;
     assert.ok(node.kind === 'mainline');
     if (node.kind !== 'mainline') throw new Error('unreachable');
@@ -863,12 +1235,116 @@ describe('Q13 — a train that catches the one ahead runs into it', () => {
     );
   });
 
-  it('leaves trains alone on a card that prints "trains may pass"', () => {
-    // Double Track and Uncontrolled Siding hold two trains because they HAVE two roads. Catching up
-    // there means going past, which is what the card is for. Without this the mechanic fired 0.41
-    // times a game while the bot never once granted clearance — the tell that they were all
-    // passing cards.
+  /**
+   * ENTERING an occupied region, as opposed to catching up inside the card (Gitea#3).
+   *
+   * A card can be ONE region wide — Plains, Double Track and Trestle all are — so a following train
+   * granted clearance is in the same place as the train ahead the moment it arrives. Nothing tested
+   * that: the catch-up check lives inside `stagesRemaining > 1`, which a one-Stage crossing never
+   * reaches, so entering behind another train on a Plains was silently free.
+   */
+  const enteringBehind = (card: MainlineKind, opts: { absSignals?: boolean } = {}) => {
+    const s = game();
+    const index = s.division.nodes.findIndex((n) => n.kind === 'mainline');
+    const node = s.division.nodes[index]!;
+    assert.ok(node.kind === 'mainline');
+    if (node.kind !== 'mainline') throw new Error('unreachable');
+    node.card = card;
+    node.transits = [];
+    if (opts.absSignals) node.absSignals = true;
+
+    /**
+     * THE TRAIN ALREADY THERE IS THE JUNIOR ONE, and that is what makes the situation reachable.
+     *
+     * Trains move lowest number first, so a card's occupant normally clears before anything behind
+     * it is even considered — put train 9 on the card and train 11 at the Division Point and 9 has
+     * gone by the time 11 enters. The conflict is a SUPERIOR train catching an inferior one that has
+     * not got out of the way yet, so the numbers run the other way round here.
+     */
+    const leader = s.freeTrays.pop()!;
+    s.trays.set(leader, {
+      id: leader, trainNumber: 11, trainIsExtra: false, engineAt: 0,
+      consist: [{ type: 'boxcar', loaded: false }], direction: 'east',
+      position: { at: 'mainline', index },
+    } as never);
+    const total = crossingStages(card, { trainSpeed: 'fast', direction: 'east', gradeUp: 'east', modifiers: [] });
+    node.transits.push({ tray: leader, stagesRemaining: total, stagesTotal: total, direction: 'east' });
+
+    // And the one arriving, held at the Division Point west of it.
+    const dp = s.division.nodes[index - 1];
+    assert.ok(dp && dp.kind === 'divisionPoint', 'expected a Division Point west of the first card');
+    if (!dp || dp.kind !== 'divisionPoint') throw new Error('unreachable');
+    const follower = s.freeTrays.pop()!;
+    s.trays.set(follower, {
+      id: follower, trainNumber: 9, trainIsExtra: false, engineAt: 0,
+      consist: [{ type: 'boxcar', loaded: false }], direction: 'east',
+      position: { at: 'divisionPoint', side: dp.side },
+    } as never);
+    dp.holding.push(follower);
+
+    /**
+     * THE SUPERINTENDENT LETS IT IN, which is the whole point.
+     *
+     * A same-direction train in the Subdivision is not an absolute bar — §8.1 makes it a judgment
+     * call, and `advance` stops and asks. Granting it is what puts one train in behind another, and
+     * §10 is then explicit that the wreck is the Superintendent's fault. So the fixture answers
+     * `allow: true` whenever it is asked, and the collision below is the consequence of that
+     * ruling rather than of a rule firing on its own.
+     */
+    s.clock.phase = 'mainline';
+    const events: GameEvent[] = [];
+    for (let i = 0; i < 6; i++) {
+      events.push(...advance(s).events);
+      if (s.clock.pendingDecision !== null) {
+        const who = s.clock.superintendent;
+        const r = applyIntent(s, who, { type: 'mainline.clearance', allow: true });
+        assert.ok(r.ok, `clearance refused: ${r.ok ? '' : r.code}`);
+        events.push(...r.events);
+      }
+    }
+    return { s, node, events, follower };
+  };
+
+  it('runs a train into the one ahead when it ENTERS an occupied region', () => {
+    const { events } = enteringBehind('plains');
+    const smash = events.find((e) => e.type === 'trainsDestroyed');
+    assert.ok(smash, 'a train entered a one-region card behind another and nothing happened');
+  });
+
+  it('holds it short instead when the card carries ABS Signals', () => {
+    // RAR: "ABS. This is played on a mainline card to prevent collisions. If a collision would
+    // normally occur, the train moving onto the card is instead held back."
+    const { events } = enteringBehind('plains', { absSignals: true });
+    assert.ok(!events.some((e) => e.type === 'trainsDestroyed'), 'ABS Signals did not prevent it');
+    assert.ok(
+      events.some((e) => e.type === 'trainHeld' && /ABS Signals/.test(e.reason)),
+      'nothing was held short of the train ahead',
+    );
+  });
+
+  it('takes the siding instead of colliding on an Uncontrolled Siding', () => {
+    // "If a train already exists when you arrive, you go in the second stage back — you are in the
+    // siding and are one behind the other train. This prevents a collision, since you are not in
+    // same exact location." So: no wreck, both trains on the card, and the newcomer paying the
+    // extra Stage for the detour.
+    const { node, events, follower } = enteringBehind('uncontrolledSiding');
+    assert.ok(!events.some((e) => e.type === 'trainsDestroyed'), 'the siding did not prevent a collision');
+    const mine = node.transits.find((t) => t.tray === follower);
+    assert.ok(mine, 'the arriving train never made it onto the card');
+    assert.equal(mine.stagesTotal, 2, 'it should have entered at the back of the card, not the front');
+  });
+
+  it('leaves trains alone on the one card that prints "trains may pass"', () => {
+    // Double Track holds two trains because it HAS two roads. Catching up there means going past,
+    // which is what the card is for.
+    //
+    // THE UNCONTROLLED SIDING USED TO BE IN THIS LIST AND IS NOT ANY MORE (Gitea#3). It holds two
+    // trains as well, but not by letting them share a place: the second one takes the siding and
+    // sits a region behind, which is what keeps them apart — "you are in the siding and are one
+    // behind the other train. This prevents a collision, since you are not in same exact location."
+    // Marked "may pass" it skipped the collision test entirely, so the siding did nothing at all and
+    // two trains could occupy the same region of it unchallenged.
     const passing = MAINLINE_PROFILES.filter((m) => m.trainsMayPass).map((m) => m.kind);
-    assert.deepEqual(passing, ['doubleTrack', 'uncontrolledSiding']);
+    assert.deepEqual(passing, ['doubleTrack']);
   });
 });

test/multiplayer.test.ts

@@ -24,12 +24,13 @@ import { impediments, narrate } from '../src/sim/narrate.ts';
 import { readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { actionMenu } from '../src/web/game.ts';
+import { newCollector } from '../src/sim/display-step.ts';
 import type { Game } from '../src/web/game.ts';
 
 /** The thin wrapper `actionMenu` expects, built directly around an already-created multi-player state
  * — `newGame` (game.ts) hardcodes one player, so it cannot construct this for a multi-seat game. */
 const wrap = (s: GameState): Game =>
-  ({ state: s, seed: s.seed, history: [], log: [], mustPlayCard: false, cues: [], scheduled: null, justDrawn: null, announced: null });
+  ({ state: s, seed: s.seed, history: [], log: [], cues: [], scheduled: null, justDrawn: null, announced: null, display: newCollector() });
 
 const competitive: GameConfig = {
   mode: 'competitive',

test/pacing.test.ts

@@ -0,0 +1,244 @@
+/**
+ * DWELL BY KIND — v0.8.0, `docs/plans/jitsi-common-board.md` § v0.8.0 § 5.
+ *
+ * The classification is exhaustive over `Intent['type']` at COMPILE time: `kindOf` declares a
+ * `StepKind` return and has no `default`, so a new intent breaks the build rather than landing
+ * silently in a fallback tier. These tests add the part the compiler cannot do — they read the
+ * intent union out of the source, so the guard survives someone later adding a `default:` that
+ * would swallow the very thing the exhaustiveness was protecting.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+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';
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..');
+
+/** Every `type: '…'` literal in the Intent union, read from the source rather than hand-listed. */
+function declaredIntents(): string[] {
+  const src = readFileSync(join(root, 'src/engine/intents.ts'), 'utf8');
+  return [...new Set([...src.matchAll(/type: '([a-zA-Z.]+)'/g)].map((m) => m[1]!))].sort();
+}
+
+const KINDS: StepKind[] = ['switching', 'action', 'phase', 'bookkeeping'];
+
+describe('pacing — dwell by kind', () => {
+  it('classifies every intent the engine declares', () => {
+    const declared = declaredIntents();
+    assert.ok(declared.length > 25, `only found ${declared.length} intents — the parse is wrong`);
+    for (const intent of declared) {
+      const kind = kindOf(intent as Intent['type']);
+      assert.ok(
+        KINDS.includes(kind),
+        `${intent} classified as "${kind}", which is not a StepKind — a default case has crept in`,
+      );
+    }
+  });
+
+  it('protects switching and collapses bookkeeping', () => {
+    // The two ends of the measured argument: a switching move is the thing worth watching, and
+    // `*.end` bookkeeping is over half of a real game's intents.
+    assert.equal(kindOf('switch.move'), 'switching');
+    assert.equal(kindOf('switch.dropCars'), 'switching');
+    assert.equal(kindOf('switch.sortConsist'), 'switching');
+    assert.equal(kindOf('draw.end'), 'bookkeeping');
+    assert.equal(kindOf('loadUnload.end'), 'bookkeeping');
+    assert.equal(kindOf('switch.end'), 'bookkeeping');
+    /**
+     * `localOps.choose` IS AN ANNOUNCEMENT, not bookkeeping — moved 2026-09-09 after the first real
+     * 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.
+     */
+    assert.equal(kindOf('localOps.choose'), 'action');
+
+    assert.ok(DWELL.switching > DWELL.action, 'switching must outrank an ordinary action');
+    assert.equal(DWELL.bookkeeping, 0, 'bookkeeping must cost the player no time at all');
+  });
+
+  it('starts switching at a full second, per the 2026-09-09 decision', () => {
+    // Jesse: "start at 1s and tune down". Pinned so a later tune is a deliberate edit rather than
+    // a drift, and so the number in the plan and the number in the code cannot disagree.
+    assert.equal(DWELL.switching, 1000);
+    assert.equal(dwellFor('switch.move'), 1000);
+  });
+
+  it('supports multipliers above 1, and keeps the tiers in proportion at every speed', () => {
+    /**
+     * Jesse, 2026-09-09, after the first play: keep switching and ordinary actions at DIFFERENT
+     * delays, and support 2.0 and 3.0 as well as 1.5. So this pins both halves — that the larger
+     * multipliers work at all, and that scaling never flattens the tiers into each other, since the
+     * relative weighting is the design and the multiplier is only how fast it runs.
+     */
+    for (const pace of [0.5, 1, 1.5, 2, 3]) {
+      assert.equal(dwellFor('switch.move', pace), Math.round(DWELL.switching * pace));
+      assert.equal(dwellFor('card.play', pace), Math.round(DWELL.action * pace));
+      assert.ok(
+        dwellFor('switch.move', pace) > dwellFor('card.play', pace),
+        `at ${pace}x a switching move no longer outlasts an ordinary action`,
+      );
+      assert.equal(dwellFor('draw.end', pace), 0, 'bookkeeping stays free at every speed');
+    }
+    // A whole switching exercise at 3x is slow on purpose, and still not absurd.
+    assert.equal(dwellFor('switch.move', 3) * 6, 18_000);
+
+    // And a typo cannot freeze the board: ?pace=300 from somebody meaning 3.00.
+    assert.equal(dwellFor('switch.move', 300), DWELL.switching * MAX_PACE);
+    assert.equal(dwellFor('switch.move', MAX_PACE + 5), dwellFor('switch.move', MAX_PACE));
+  });
+
+  it('scales with the viewer\'s pace, and 0 turns it off', () => {
+    assert.equal(dwellFor('switch.move', 1), 1000);
+    assert.equal(dwellFor('switch.move', 0.5), 500);
+    assert.equal(dwellFor('switch.move', 2), 2000);
+    // TODO #18's "a player who has seen it a hundred times will want it off" — no second mechanism.
+    for (const intent of declaredIntents()) {
+      assert.equal(dwellFor(intent as Intent['type'], 0), 0, `${intent} still dwells at pace 0`);
+    }
+    // A negative pace is a corrupt preference, not a request to run time backwards.
+    assert.equal(dwellFor('switch.move', -3), 0);
+  });
+
+  it('counts only the steps a player will actually watch', () => {
+    /**
+     * The counter's whole point. A backlog of 17 where 12 are bookkeeping must read "5", not "17"
+     * followed by an instant plummet to 5 — the countdown is meant to be steady enough to decide
+     * whether to press Skip.
+     */
+    const queue: Intent['type'][] = [
+      ...Array<Intent['type']>(12).fill('draw.end'),
+      ...Array<Intent['type']>(5).fill('switch.move'),
+    ];
+    assert.equal(queue.length, 17);
+    assert.equal(watchableCount(queue), 5);
+    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');
+    /**
+     * The ceiling is not theoretical. Jesse played at 10× — the top of the ladder as it then was —
+     * and called it "still a bit fast, but followable", so the ladder has to go past the speed
+     * somebody actually reached for and found insufficient.
+     */
+    assert.ok(PACE_LEVELS.some((p) => p > 10), 'the ladder must go beyond the speed that was too fast');
+    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
+     * phases that moved trains without saying so, killing the very thing #18 asks for. "Anything
+     * 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, 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', player: 1, lines: ['moved'], frame: { table: {} } }),
+      DWELL.switching,
+    );
+  });
+
+  it('the speed control stretches the clock at a THIRD of the rate it stretches people', () => {
+    /**
+     * Two complaints, one from each direction, and the answer is between them.
+     *
+     * v0.8.0.3, from a 5× game: *"after my turn … I'm still subject to that same delay before it
+     * moves on. That makes no sense."* — phases were scaling with everything else and walling off a
+     * player's own turn. So they were pinned at their tabled beat.
+     *
+     * v0.8.0.7, from a 10× game: *"phases displayed on the upper line go by too quickly still.
+     * Should be 4 times as long — at a guess."* — pinned was too short to read the caption.
+     *
+     * Damped scaling satisfies both: 1× unchanged, 10× lands exactly on the four-times guess, and
+     * the cost stays bounded because phase beats cluster rather than accumulate.
+     */
+    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: {} } };
+
+    assert.equal(dwellForStep(phase, 1), DWELL.phase, '1x must be exactly the tabled beat');
+    assert.equal(dwellForStep(phase, 10), DWELL.phase * 4, '10x must be four times it, as asked for');
+
+    for (const pace of [2, 3, 5, 7, 10, 15, 20]) {
+      const p = dwellForStep(phase, pace);
+      const t = dwellForStep(theirs, pace);
+      assert.ok(p > DWELL.phase, `a phase must grow at ${pace}x`);
+      assert.ok(
+        p < DWELL.phase * pace,
+        `a phase must grow SLOWER than the multiplier at ${pace}x, or the clock walls off the turn`,
+      );
+      assert.ok(t > p, `somebody's move must still outlast a phase beat at ${pace}x`);
+    }
+    // Off still means off, for the clock as much as for anybody's move; and below 1x the clock
+    // follows the multiplier straight, because "faster" should mean everything.
+    assert.equal(dwellForStep(phase, 0), 0);
+    assert.equal(dwellForStep(theirs, 0), 0);
+    assert.equal(dwellForStep(phase, 0.5), DWELL.phase * 0.5);
+  });
+
+  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.
+    const turn: Intent['type'][] = [
+      'localOps.choose',
+      ...Array<Intent['type']>(6).fill('switch.move'),
+      'switch.end',
+    ];
+    const total = turn.reduce((ms, i) => ms + dwellFor(i), 0);
+    assert.equal(total, DWELL.action + 6 * DWELL.switching);
+    assert.ok(total > 5_000 && total < 10_000, `a switching turn takes ${total}ms to watch`);
+    assert.equal(watchableCount(turn), 7, 'the six moves and the announcement; not the end');
+  });
+
+  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 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
+     * 750ms for the whole thing.
+     */
+    const turn: Intent['type'][] = [
+      'localOps.choose',
+      'draw.fromHomeOffice',
+      'card.play',
+      'draw.end',
+      'localOps.choose',
+      'freightAgent.stockOutbound',
+    ];
+    const total = turn.reduce((ms, i) => ms + dwellFor(i), 0);
+    assert.ok(total >= 3_000, `an ordinary bot turn is only ${total}ms — too fast to follow`);
+    assert.equal(watchableCount(turn), 5, 'only the turn-ending bookkeeping is free');
+  });
+});

test/presets.test.ts

@@ -59,8 +59,11 @@ describe('what each game type is', () => {
     assert.equal(presetSettings('cutthroat', 4, 5).extraStart, 'anyOffice');
     assert.equal(presetSettings('coop', 4, 5).extraStart, 'ownOffice');
     assert.equal(presetSettings('competitive', 4, 5).extraStart, 'ownOffice');
-    // At one player the two rules are the same rule.
-    assert.equal(presetSettings('solitaire', 1, 5).extraStart, 'anyOffice');
+    // At one player the two rules ARE the same rule — `apply.ts` only rejects `ownOffice` when the
+    // start is another seat's, which cannot happen. Solitaire said `anyOffice` until 2026-08-30:
+    // true, and it read wrong, since a lone player has no "any player" to be contrasted with. The
+    // label changed and the behaviour did not.
+    assert.equal(presetSettings('solitaire', 1, 5).extraStart, 'ownOffice');
   });
 
   it('leaves every optional rule off, in every type', () => {

test/public-delta.test.ts

@@ -0,0 +1,294 @@
+/**
+ * THE SEATLESS PUBLIC DELTA — v0.8.0, `docs/plans/jitsi-common-board.md` § v0.8.0 § 3.
+ *
+ * The property that matters is RECONSTRUCTION: a receiver that started from one full frame and
+ * merged every delta since must hold exactly what a fresh `publicSnapshot()` would give it. A delta
+ * scheme that is merely smaller is worthless if the two sides drift, and the drift would show up as
+ * a board that is subtly wrong rather than as an error.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { pump } from '../src/engine/advance.ts';
+import { createGame } from '../src/engine/setup.ts';
+import { legalActions } from '../src/engine/legal.ts';
+import type { GameConfig, GameState, PlayerIndex } from '../src/engine/state.ts';
+import { applyIntent } from '../src/engine/apply.ts';
+import { currentActorOfState, publicSnapshot } from '../src/sim/view.ts';
+import type { PublicFrame } from '../src/sim/view.ts';
+import { applyPublicDelta, changedPiles, deltaPublicFrame } from '../src/sim/public-delta.ts';
+
+const config: GameConfig = {
+  mode: 'competitive',
+  days: 5,
+  minCombinedRevenue: 0,
+  maxCollisionsPerDay: 0,
+  maxCollisionsTotal: 0,
+  pvpCardsAllowed: false,
+  optionalRules: {
+    reducedVisibility: false,
+    employeeRotation: false,
+    emergencyToolbox: false,
+  },
+};
+
+function newState(seed: number, players = 3, rotation = false): GameState {
+  const s = createGame({
+    id: `delta-${seed}`,
+    seed,
+    config: rotation
+      ? { ...config, optionalRules: { ...config.optionalRules, employeeRotation: true } }
+      : config,
+    playerNames: Array.from({ length: players }, (_, i) => `p${i}`),
+  });
+  pump(s);
+  return s;
+}
+
+/** Plays one legal action, preferring a switch move so districts actually change between frames. */
+function step(s: GameState, actor: PlayerIndex): boolean {
+  const options = legalActions(s, actor);
+  if (options.length === 0) return false;
+  const move = options.find((o) => o.type.startsWith('switch.') && o.type !== 'switch.end');
+  const chosen = move ?? options.find((o) => o.type === 'localOps.choose') ?? options[0]!;
+  const r = applyIntent(s, actor, chosen);
+  if (!r.ok) return false;
+  pump(s);
+  return true;
+}
+
+describe('public frame delta', () => {
+  it('reconstructs exactly what a fresh projection produces, over a long chain', () => {
+    for (const seed of [1917398, 4242]) {
+      const s = newState(seed);
+      let sent: PublicFrame | null = null;
+      let held: PublicFrame | null = null;
+      let steps = 0;
+
+      for (let i = 0; i < 300; i++) {
+        const actor = currentActorOfState(s);
+        if (actor === null) break;
+        if (!step(s, actor)) break;
+
+        const next = publicSnapshot(s);
+        const delta = deltaPublicFrame(sent, next);
+        held = applyPublicDelta(held, delta);
+        sent = next;
+        steps++;
+
+        assert.deepEqual(
+          held,
+          next,
+          `merged frame drifted from a fresh projection at step ${steps} (seed ${seed})`,
+        );
+      }
+      assert.ok(steps > 20, `only ${steps} steps for seed ${seed} — the chain proved little`);
+    }
+  });
+
+  it('sends a district board only when that district changed', () => {
+    const s = newState(1917398);
+    const first = publicSnapshot(s);
+    // Nothing has moved, so a delta against an identical frame must null every board.
+    const idle = deltaPublicFrame(first, publicSnapshot(s));
+    assert.equal(idle.division, null, 'the Division was unchanged and must not be resent');
+    assert.equal(idle.districts.length, 0, 'an unchanged district must be omitted, not sent as nulls');
+    assert.deepEqual(idle.table, {}, 'an unchanged table must send no fields at all');
+
+    // Now move one player. Only that seat's board may be sent — this is the whole point of keying
+    // the delta by seat rather than comparing `districts` as one array.
+    let moved: PublicIndexed | null = null;
+    for (let i = 0; i < 200 && moved === null; i++) {
+      const actor = currentActorOfState(s);
+      if (actor === null) break;
+      const before = publicSnapshot(s);
+      if (!step(s, actor)) break;
+      const after = publicSnapshot(s);
+      const changed = after.districts.filter(
+        (d) => JSON.stringify(d.cells) !== JSON.stringify(before.districts.find((b) => b.seat === d.seat)?.cells),
+      );
+      if (changed.length === 1) moved = { seat: changed[0]!.seat, before, after };
+    }
+    assert.ok(moved !== null, 'no single-district change occurred, so this test proved nothing');
+
+    const delta = deltaPublicFrame(moved.before, moved.after);
+    assert.equal(delta.districts.length, 1, 'only the district that changed may be sent');
+    assert.equal(delta.districts[0]!.seat, moved.seat);
+    assert.notEqual(delta.districts[0]!.cells, null, 'the district that changed must carry its board');
+  });
+
+  it('a step that changes one field sends one field — the reason this is a partial', () => {
+    /**
+     * MEASURED, not assumed. The first version spread the whole frame and nulled only the boards, so
+     * a step whose sole change was whose turn it is still shipped all 35 top-level properties. Once
+     * TODO #18 gave automatic phases their own steps, most steps became exactly that, and a full game
+     * cost 19.4 MB of which 16.7 MB was those. This is the guard against that returning.
+     */
+    const s = newState(1917398);
+    const before = publicSnapshot(s);
+    const full = JSON.stringify(deltaPublicFrame(null, before)).length;
+
+    // Hand the turn on without touching a board, which is what an automatic phase mostly does.
+    const after = { ...before, actor: ((before.actor ?? 0) + 1) as PlayerIndex };
+    const delta = deltaPublicFrame(before, after);
+    assert.deepEqual(Object.keys(delta.table), ['actor'], 'only the field that changed may be sent');
+    assert.equal(delta.districts.length, 0);
+    assert.equal(delta.division, null);
+
+    const size = JSON.stringify(delta).length;
+    assert.ok(size < 120, `a one-field delta serialised to ${size} bytes`);
+    assert.ok(size * 100 < full, `a one-field delta (${size}B) is not much smaller than a full frame (${full}B)`);
+  });
+
+  it('always carries seat, player and name, so Employee Rotation cannot be missed', () => {
+    // Rotation moves players between districts, so the seat→player pairing is itself news. Those
+    // fields are small and are never nulled; the boards they label are what the delta saves.
+    const s = newState(777, 3, true);
+    const a = publicSnapshot(s);
+    // A full frame carries every district, each labelled — that is what a receiver matches on later.
+    const full = deltaPublicFrame(null, a);
+    assert.equal(full.districts.length, a.districts.length);
+    for (const d of full.districts) {
+      assert.equal(typeof d.seat, 'number');
+      assert.equal(typeof d.player, 'number');
+      assert.ok(typeof d.name === 'string' && d.name.length > 0, 'every district must stay labelled');
+    }
+    // And a district sent at all always carries its labels, even when only its board moved: rotation
+    // makes the seat→player pairing news in its own right.
+    const rotated = { ...a, districts: a.districts.map((d, i) => (i === 0 ? { ...d, player: ((d.player + 1) % 3) as PlayerIndex } : d)) };
+    const delta = deltaPublicFrame(a, rotated);
+    assert.equal(delta.districts.length, 1, 'a relabelled district must be sent even with no board change');
+    assert.equal(typeof delta.districts[0]!.player, 'number');
+  });
+
+  it('a first frame is sent whole', () => {
+    const s = newState(4242);
+    const full = deltaPublicFrame(null, publicSnapshot(s));
+    assert.notEqual(full.division, null);
+    for (const d of full.districts) {
+      assert.notEqual(d.cells, null, `seat ${d.seat} must be sent in full on a first frame`);
+      assert.notEqual(d.facilities, null);
+    }
+    // And it merges with no previous frame at all.
+    assert.deepEqual(applyPublicDelta(null, full), publicSnapshot(s));
+  });
+
+  it('refuses to merge an "unchanged" board it has nothing to merge onto', () => {
+    // A sender whose bookkeeping has drifted would otherwise hand a player a blank district.
+    const s = newState(4242);
+    const a = publicSnapshot(s);
+    const unchanged = deltaPublicFrame(a, publicSnapshot(s));
+    assert.throws(() => applyPublicDelta(null, unchanged), /no previous frame to merge onto/);
+  });
+});
+
+type PublicIndexed = { seat: number; before: PublicFrame; after: PublicFrame };
+
+describe('which piles a step moved', () => {
+  /**
+   * MEASURED FROM REAL PLAY, then pinned. The table in `changedPiles` claims what each action moves,
+   * and a claim in a comment is worth nothing unless something checks it — so this drives real games
+   * and asserts the mapping holds, action by action.
+   */
+  it('maps each action to the piles it actually touches', () => {
+    const seen = new Map<string, Set<string>>();
+    /**
+     * TWO PASSES, because a single driver cannot reach every case. Left to itself the bot almost
+     * never takes a Department card, and a driver that prefers one then never draws from the deck —
+     * so each preference is played out separately and the assertions below require BOTH to have
+     * been observed rather than passing on whichever happened to occur.
+     */
+    for (const prefer of ['draw.fromDepartment', 'draw.fromHomeOffice'] as const) {
+      for (const seed of [1917398, 191056, 4242]) {
+        const s = newState(seed);
+        for (let i = 0; i < 400; i++) {
+          const actor = currentActorOfState(s);
+          if (actor === null) break;
+          const options = legalActions(s, actor);
+          if (options.length === 0) break;
+          const chosen =
+            options.find((o) => o.type === prefer) ??
+            options.find((o) => o.type === 'card.discard') ??
+            options[i % options.length]!;
+          const before = publicSnapshot(s);
+          const r = applyIntent(s, actor, chosen);
+          if (!r.ok) break;
+          pump(s);
+          const piles = changedPiles(before, publicSnapshot(s)).map((p) => p.replace(/dept\d/, 'dept'));
+          if (!seen.has(chosen.type)) seen.set(chosen.type, new Set());
+          for (const p of piles) seen.get(chosen.type)!.add(p);
+          if (piles.length === 0) seen.get(chosen.type)!.add('(none)');
+        }
+      }
+    }
+
+    const of = (t: string): Set<string> => seen.get(t) ?? new Set();
+    // NOT VACUOUS: the four cases the mapping is actually about must all have happened.
+    for (const needed of ['draw.fromHomeOffice', 'draw.fromDepartment', 'card.discard', 'card.play']) {
+      assert.ok(of(needed).size > 0, `${needed} never occurred, so its rule proved nothing`);
+    }
+
+    // A HOME OFFICE DRAW MOVES THE COUNT AND NOTHING ELSE ON A PILE. The card is private; the deck
+    // getting shorter is not, and it is the only thing a watcher can be shown.
+    assert.deepEqual([...of('draw.fromHomeOffice')].sort(), ['home']);
+    // A DEPARTMENT DRAW touches that Department, and sometimes the deck too — the pile refills from
+    // it. Both are public, so both may light.
+    for (const p of of('draw.fromDepartment')) {
+      assert.ok(p === 'dept' || p === 'home', `a Department draw moved "${p}"`);
+    }
+    assert.ok(of('draw.fromDepartment').has('dept'), 'a Department draw must light its Department');
+    // A DISCARD lands face up on a Department, and which one is public.
+    assert.deepEqual([...of('card.discard')].sort(), ['dept']);
+    // A PLAYED CARD that does not stay on the board lands face up in the Salvage Yard.
+    assert.ok(of('card.play').has('salvage'), 'a played card must be able to light the Salvage Yard');
+    // ENDING A PHASE moves no card anywhere, so nothing should light for it.
+    for (const quiet of ['draw.end', 'loadUnload.end', 'switch.end', 'localOps.choose']) {
+      if (of(quiet).size > 0) assert.deepEqual([...of(quiet)], ['(none)'], `${quiet} lit a pile`);
+    }
+  });
+
+  it('lights nothing without a previous frame to compare against', () => {
+    // A reset has nothing to have watched arriving, so nothing on it is lit.
+    const s = newState(4242);
+    assert.deepEqual(changedPiles(null, publicSnapshot(s)), []);
+  });
+});
+
+describe('a Mainline card that changed under the players (Gitea#28)', () => {
+  it('names the node a Realignment converted, and nothing else', async () => {
+    const { changedDivisionCards } = await import('../src/sim/public-delta.ts');
+    const { REALIGNMENTS } = await import('../src/engine/content.ts');
+
+    const s = newState(4242);
+    const before = publicSnapshot(s);
+
+    // Realignment converts a card to another kind (`content.ts`'s table). Applied to the state directly:
+    // what is being tested is the DETECTOR, not the play that reaches it — which needs the card in hand,
+    // the draw option taken and no train on the card.
+    const at = s.division.nodes.findIndex((n) => n.kind === 'mainline' && REALIGNMENTS.some((r) => r.from === n.card));
+    assert.ok(at >= 0, 'no Mainline card in this Division can be realigned at all');
+    const node = s.division.nodes[at];
+    assert.equal(node?.kind, 'mainline');
+    if (node?.kind === 'mainline') {
+      node.card = REALIGNMENTS.find((r) => r.from === node.card)!.to;
+    }
+    const after = publicSnapshot(s);
+
+    assert.deepEqual(changedDivisionCards(before, after), [at], 'the realigned card was not the one reported');
+    assert.deepEqual(changedDivisionCards(after, after), [], 'an unchanged Division reported a change');
+    assert.deepEqual(changedDivisionCards(null, after), [], 'a first board has nothing to compare against');
+  });
+
+  it('says nothing when only the trains on a card moved', async () => {
+    const { changedDivisionCards } = await import('../src/sim/public-delta.ts');
+    const s = newState(1917398);
+    const before = publicSnapshot(s);
+    const at = s.division.nodes.findIndex((n) => n.kind === 'mainline');
+    const node = s.division.nodes[at];
+    if (node?.kind === 'mainline') {
+      node.transits.push({ tray: 'tray1', stagesRemaining: 1, stagesTotal: 1, direction: 'east' });
+    }
+    assert.deepEqual(changedDivisionCards(before, publicSnapshot(s)), [], 'a train arriving flashed the card');
+  });
+});

test/redaction.test.ts

@@ -17,7 +17,10 @@ import { pump } from '../src/engine/advance.ts';
 import { createGame } from '../src/engine/setup.ts';
 import type { GameConfig, GameState, PlayerIndex } from '../src/engine/state.ts';
 import { developerBot, playGame } from '../src/sim/bot.ts';
-import { snapshot } from '../src/sim/view.ts';
+import { cardName, publicSnapshot, snapshot } from '../src/sim/view.ts';
+import { newGame, newMultiplayerGame, submit } from '../src/web/game.ts';
+import { createSession } from '../src/server/session.ts';
+import { legalActions } from '../src/engine/legal.ts';
 
 const config: GameConfig = {
   mode: 'competitive',
@@ -99,6 +102,30 @@ describe('redaction — a seat\'s Frame never carries another seat\'s secrets',
     assert.ok(!serialized.includes(String(s.seed)), 'the seed value leaked into the Frame some other way');
   });
 
+  it('the tally that rides the Frame is aggregate counts, never a card id (Gitea#16)', () => {
+    // Gitea#16's statistics live on `GameState` and reach a remote client on the Frame, which is
+    // only safe because nothing in a Tally identifies a card. That is a property of what
+    // `tally.ts` chooses to count, and nothing in the type system enforces it — so it is asserted
+    // here, where a future counter that stashed a `cardId` "just for badges" would be caught.
+    for (const players of [3, 4]) {
+      const s = midGame(players, 5000 + players);
+      const secrets = new Set<string>([...s.decks.homeOffice]);
+      for (const hand of s.decks.hands.values()) for (const id of hand) secrets.add(id);
+      for (let viewer = 0 as PlayerIndex; viewer < players; viewer++) {
+        const serialized = JSON.stringify(snapshot(s, [], null, null, null, false, viewer).tally);
+        for (const cardId of secrets) {
+          assert.ok(!serialized.includes(`"${cardId}"`), `the tally carries card id "${cardId}"`);
+        }
+      }
+    }
+  });
+
+  it('every seat sees the SAME tally — it is the table\'s account, not a private one', () => {
+    const s = midGame(3, 5555);
+    const tallies = [0, 1, 2].map((p) => snapshot(s, [], null, null, null, false, p as PlayerIndex).tally);
+    for (const t of tallies) assert.deepEqual(t, tallies[0], 'the tally differs by seat');
+  });
+
   it('only the viewer\'s own hand and handCount are non-public — everything else matches across seats', () => {
     // The redaction surface is four fields (§7), not sixty event types. Cross-check that seats agree
     // on everything else a Frame carries about shared state.
@@ -115,3 +142,412 @@ describe('redaction — a seat\'s Frame never carries another seat\'s secrets',
     }
   });
 });
+
+
+/**
+ * THE OTHER HALF OF §7, AND THE HALF THAT WAS NEVER LOOKED AT.
+ *
+ * Every test above serializes a `Frame`, and every one of them passes `[]` for the narration log —
+ * so the entire shared log has sat outside the redaction net since the net was built. It is not a
+ * hypothetical hole: `game.log` is ONE list, and `linesSince(seat)` (`server/session.ts`) slices it
+ * with no per-seat filter at all, so every line written into it reaches every player.
+ *
+ * Two things were being written into it that should never have left the seat that caused them, both
+ * found while planning the public common board (Gitea#20 step 1) and both live in multiplayer today,
+ * with or without that display:
+ *
+ *   1. the SEED, announced in the opening line of every multiplayer game — which hands every player
+ *      the whole future of the deal;
+ *   2. the NAME OF A CARD DRAWN BLIND from the Home Office deck.
+ *
+ * SOLITAIRE IS DELIBERATELY LEFT ALONE in both cases. There is nobody to leak to at a one-seat
+ * table, the seed in the log is what a bug report quotes, and a solo player's own history naming
+ * the card they drew is the record, not a leak. The rule is "do not tell the OTHER seats", not
+ * "write less down" — so both checks below assert the solitaire text is still there.
+ */
+describe('redaction — the shared narration log never carries a seat\'s secrets', () => {
+  const names = ['Ann', 'Bob', 'Cy'];
+
+  it('never announces the seed to the table (Gitea#20 step 1)', () => {
+    const g = newMultiplayerGame(550943578, config, names);
+    const log = g.log.map((l) => l.text).join('\n');
+    assert.ok(
+      !/550943578/.test(log),
+      `the seed was announced to every seat:\n${log}`,
+    );
+    // The opening line must still say what the game IS — the leak is the number, not the line.
+    assert.match(log, /Game Begins/);
+    assert.match(log, /3 players/);
+  });
+
+  it('still tells a solitaire player their own seed — there is nobody to leak it to', () => {
+    const g = newGame(550943578);
+    const log = g.log.map((l) => l.text).join('\n');
+    assert.match(log, /550943578/, 'a solo game stopped recording the seed its bug reports quote');
+  });
+
+  it('never names a card drawn blind from the Home Office deck (Gitea#20 step 1)', () => {
+    const g = newMultiplayerGame(4242, config, names);
+
+    // Drive to the first Home Office draw any seat makes, and note what it actually drew.
+    let drawn: string | null = null;
+    for (let i = 0; i < 400 && drawn === null; i++) {
+      const actor = g.state.clock.currentActor;
+      if (actor === null) break;
+      const before = g.log.length;
+      if (!submit(g, { type: 'localOps.choose', option: 'draw' }, actor as PlayerIndex)) continue;
+      if (!submit(g, { type: 'draw.fromHomeOffice' }, actor as PlayerIndex)) continue;
+      drawn = g.justDrawn;
+      void before;
+    }
+    assert.ok(drawn, 'no seat ever drew from the Home Office deck');
+
+    const name = cardName(g.state, drawn!);
+    const log = g.log.map((l) => l.text).join('\n');
+    assert.ok(
+      !log.includes(name),
+      `a blind draw named "${name}" to the whole table:\n${log.split('\n').slice(-6).join('\n')}`,
+    );
+    // The draw itself is public — everyone saw a hand go to the deck. Only WHICH card is not.
+    assert.match(log, /Home Office/i);
+
+    // And the drawing seat still learns what it got: `justDrawn` is the owner-only channel, and
+    // `session.ts` sends it to that seat alone.
+    assert.equal(g.justDrawn, drawn);
+  });
+});
+
+
+/**
+ * #91 — THE SYSTEMATIC NET, not two strings.
+ *
+ * v0.7.9.2 closed the seed and the blind draw. Both were found by reading a plan, not by a test, and
+ * that is the point: a redaction suite made of the leaks somebody happened to notice proves nothing
+ * about the next one. This is the pass the common-board plan asks for (Gitea#20 step 1 § Tests) —
+ * serialise EVERYTHING a seat or a spectator receives and search it for everything that must not be
+ * in it, across every game state where the shape of the answer changes.
+ *
+ * **What is searched for**, per the plan: every opponent hand card id AND its display name, the
+ * objective, `justDrawn` for the wrong seat, seed values and seed narration, and private decision
+ * and menu data. Display names matter as much as ids — "Red Flags" in a log leaks exactly what
+ * `c118` would, and only the id would have been caught before.
+ *
+ * **Where it is searched**: a player's `Frame`, the `PublicFrame` a spectator gets, the incremental
+ * narration `Push.lines` carries, and a reconnect push — which is a full Frame rather than a delta
+ * and is therefore its own opportunity to leak.
+ *
+ * **And the acceptance bar is not this file.** The plan is explicit that passing redaction tests
+ * alone is insufficient and that every public property needs an allow-list review; the last test
+ * here is that allow-list, so adding a field to the public projection fails until somebody has said
+ * out loud that it is public.
+ */
+describe('#91 — nothing private survives serialisation, in any state', () => {
+  const names = ['Ann', 'Bob', 'Cy'];
+
+  /**
+   * Everything one seat can see, split into the two halves the checks below treat differently.
+   *
+   * `structural` is the machine-readable state: their Frame, the public board, and the frame of every
+   * presentation step they are sent (v0.8.0, TODO #13). `narration` is what the table was TOLD.
+   *
+   * Steps are folded in here rather than given a test of their own so every case below covers them:
+   * the blind draw, the pending decision, Employee Rotation before and after the seating moves, and
+   * the played-out game. Their `lines` are a slice of `g.log` by construction, so the log covers the
+   * narration half of a step and does not need to be searched twice.
+   */
+  const everythingSeatSees = (g: ReturnType<typeof newMultiplayerGame>, seat: PlayerIndex): {
+    structural: string;
+    history: string;
+    narration: string[];
+  } => ({
+    /**
+     * `[]` for the Frame's own lines, MATCHING PRODUCTION. `frameFor()` (`server/session.ts`) has
+     * passed no log since #97 — narration goes out incrementally through `Push.lines` instead — so
+     * embedding it here audits a path that no longer exists, and worse, it puts the whole log inside
+     * `structural` where the face-up-pile rule below cannot reach it. The log is audited in full as
+     * `narration`; this is a de-duplication, not a relaxation.
+     */
+    structural:
+      JSON.stringify(snapshot(g.state, [], null, null, null, false, seat)) +
+      '\n' + JSON.stringify(publicSnapshot(g.state)),
+    /**
+     * THE STEP FRAMES ARE A RECORD OF WHAT WAS PUBLIC OVER TIME, not a view of the position now —
+     * so they get the PRECISE check and not the fuzzy one, for the same reason the face-up-pile
+     * lines do.
+     *
+     * Every one is built by `deltaPublicFrame` over `publicSnapshot`, which the allow-list test at
+     * the bottom of this file pins property by property; that is what guarantees a step frame is
+     * clean. Searching their accumulation for a card NAME asks "was this ever public?" and answers
+     * a question nobody was posing: Train 6 sat face-up in a Department at step 40 and is in Ann's
+     * hand at step 120, and both facts are correct. A card ID is different — narration never renders
+     * one and no public field carries an opponent's, so finding one anywhere is still proof.
+     */
+    history: JSON.stringify(g.display.steps.map((step) => step.frame)),
+    narration: g.log.map((l) => l.text),
+  });
+
+  /**
+   * A FACE-UP PILE IS ALLOWED TO NAME THE CARD ON IT, and the log is history rather than a view.
+   *
+   * §2.6: the three Department piles and the Salvage Yard are face up, "so players can audit
+   * discards" — a discard goes onto one precisely so a rival can take it. So "Player Ann discarded
+   * Train 6 face-up on top of Department 3" is the record working, and it stays in the log after Ann
+   * takes the card back into her hand. The name-based check below would otherwise read that historical
+   * line as proof of what Ann is holding NOW, which is how it reported a leak against correct code on
+   * seed 1917398.
+   *
+   * These lines are excluded from the NAME check only. The card-id check and the seed check still run
+   * over them, because those are precise: an id is unique, so finding one is proof, and narration
+   * never renders a raw id.
+   *
+   * **This does not weaken the blind-draw detection**, which is the leak this whole net was built
+   * for (v0.7.9.2, "Red Flags"): a blind draw names the HOME OFFICE DECK, which is face down and
+   * matches nothing here.
+   */
+  const namesAFaceUpPile = (line: string): boolean => /Department|Salvage/i.test(line);
+
+  /**
+   * Every secret belonging to somebody OTHER than `seat`: their card ids, and the names those ids
+   * render as. Ids alone were what the original tests looked for, and an id is the precise
+   * instrument — it is unique, so finding one is proof.
+   *
+   * **A NAME IS ONLY EVIDENCE WHEN IT IS DISTINCTIVE, and most are not.** Card names are types, not
+   * identities: "right-hand curve" names a dozen cards, and one of them is legitimately drawn on the
+   * board as a cell label the moment anybody lays track. Searching for a name that also exists in
+   * public is a test that fails on correct code, which is worse than no test — so a name counts only
+   * when EVERY card bearing it is in that one opponent's hand. Then, and only then, seeing it says
+   * something about what they are holding.
+   *
+   * This is what caught the blind-draw leak in v0.7.9.2: "Red Flags" was in exactly one hand, and it
+   * was in the log.
+   */
+  const secretsOfOthers = (
+    g: ReturnType<typeof newMultiplayerGame>,
+    seat: PlayerIndex,
+  ): { what: string; value: string; precise: boolean }[] => {
+    // `precise` marks evidence that is proof on its own — a card id is unique, so finding one
+    // anywhere is a leak. A NAME is circumstantial and is searched over a narrower string; see
+    // `namesAFaceUpPile`.
+    const out: { what: string; value: string; precise: boolean }[] = [];
+    // How many cards in the whole game carry each name, and how many of those are in a given hand.
+    const totalByName = new Map<string, number>();
+    for (const id of g.state.cards.keys()) {
+      const n = cardName(g.state, id);
+      totalByName.set(n, (totalByName.get(n) ?? 0) + 1);
+    }
+    for (const p of g.state.players) {
+      if (p.index === seat) continue;
+      const hand = g.state.decks.hands.get(p.index) ?? [];
+      const heldByName = new Map<string, number>();
+      for (const id of hand) {
+        const n = cardName(g.state, id);
+        heldByName.set(n, (heldByName.get(n) ?? 0) + 1);
+      }
+      for (const id of hand) {
+        out.push({ what: `${p.name}'s card id`, value: id, precise: true });
+        const name = cardName(g.state, id);
+        if (totalByName.get(name) === heldByName.get(name)) {
+          out.push({ what: `${p.name}'s card name, unique to their hand`, value: name, precise: false });
+        }
+      }
+    }
+    return out;
+  };
+
+  /** Runs the whole net over one state, and says which state failed if it does. */
+  const audit = (g: ReturnType<typeof newMultiplayerGame>, where: string): void => {
+    for (const seat of g.state.players.map((p) => p.index)) {
+      const { structural, history, narration } = everythingSeatSees(g, seat);
+      const everything = structural + '\n' + history + '\n' + narration.join('\n');
+      // Names are fuzzy evidence, so they are searched everywhere EXCEPT the lines a face-up pile
+      // is entitled to name a card on. Ids are precise and are searched everywhere.
+      const forNames = structural + '\n' + narration.filter((l) => !namesAFaceUpPile(l)).join('\n');
+      for (const { what, value, precise } of secretsOfOthers(g, seat)) {
+        assert.ok(
+          !(precise ? everything : forNames).includes(value),
+          `${where}: seat ${seat} can see ${what} ("${value}")`,
+        );
+      }
+      // The seed is the whole future of the deal and must not reach a seat by any route.
+      assert.ok(!everything.includes(String(g.seed)), `${where}: seat ${seat} can see the seed ${g.seed}`);
+    }
+    // And the spectator board, which has no seat and is therefore entitled to nothing private.
+    const pub = JSON.stringify(publicSnapshot(g.state));
+    for (const p of g.state.players) {
+      for (const id of g.state.decks.hands.get(p.index) ?? []) {
+        assert.ok(!pub.includes(id), `${where}: the public board carries ${p.name}'s card ${id}`);
+      }
+    }
+    assert.ok(!pub.includes(String(g.seed)), `${where}: the public board carries the seed`);
+    for (const k of ['hand', 'objective', 'justDrawn', 'decision', 'moves', 'blocked', 'viewer']) {
+      assert.ok(!(k in (JSON.parse(pub) as Record<string, unknown>)), `${where}: the public board has a "${k}" field`);
+    }
+  };
+
+  /** Plays `n` legal moves, so a state is a real position rather than a constructed one. */
+  const play = (g: ReturnType<typeof newMultiplayerGame>, n: number): void => {
+    for (let i = 0; i < n; i++) {
+      const a = g.state.clock.currentActor;
+      if (a === null) break;
+      const opts = legalActions(g.state, a);
+      if (!opts.length) break;
+      if (!submit(g, opts[i % opts.length]!, a)) break;
+    }
+  };
+
+  it('a newly created multiplayer game', () => {
+    audit(newMultiplayerGame(4242, config, names), 'fresh game');
+  });
+
+  it('after a blind Home Office draw', () => {
+    const g = newMultiplayerGame(4242, config, names);
+    let drew = false;
+    for (let i = 0; i < 200 && !drew; i++) {
+      const a = g.state.clock.currentActor;
+      if (a === null) break;
+      if (!submit(g, { type: 'localOps.choose', option: 'draw' }, a)) continue;
+      drew = submit(g, { type: 'draw.fromHomeOffice' }, a);
+    }
+    assert.ok(drew, 'no seat drew from the Home Office deck');
+    audit(g, 'after a blind draw');
+  });
+
+  it('the net actually sees the presentation steps it claims to cover (v0.8.0)', () => {
+    /**
+     * Guards the COVERAGE, not the code. `everythingSeatSees` folds `display.steps` into the string
+     * every case above is audited against — which is worth nothing if that array is empty in
+     * practice. So: play a real game, and assert both that steps accumulated and that the audited
+     * string contains them.
+     */
+    const g = newMultiplayerGame(1917398, config, names);
+    play(g, 120);
+    assert.ok(g.display.steps.length > 20, `only ${g.display.steps.length} steps — the net covers little`);
+    const { history, narration } = everythingSeatSees(g, 0 as PlayerIndex);
+    assert.ok(
+      history.includes(JSON.stringify(g.display.steps.map((step) => step.frame))),
+      'the audited string does not actually contain the step frames',
+    );
+    // And a step's own narration is a slice of the log, so the log half covers it.
+    const fromSteps = g.display.steps.flatMap((step) => step.lines.map((l) => l.text));
+    assert.ok(fromSteps.length > 0, 'the steps carried no narration to cover');
+    assert.ok(fromSteps.every((t) => narration.includes(t)), 'a step said something the log did not');
+    audit(g, 'a played game with presentation steps');
+  });
+
+  it('mid-game, with real hands and a built board', () => {
+    // A DISTINCTIVE seed, deliberately. Seed 7 makes the seed check meaningless — "7" is in "Train
+    // 7", in every coordinate and in half the numbers on the board — so it reported a leak that was
+    // not one. Nine digits collide with nothing, which is what makes a substring match evidence.
+    const g = newMultiplayerGame(613884219, config, names);
+    play(g, 300);
+    audit(g, 'mid-game');
+  });
+
+  it('with a decision pending, and with the Superintendent acting', () => {
+    const g = newMultiplayerGame(550943578, config, names);
+    let sawDecision = false;
+    for (let i = 0; i < 800; i++) {
+      if (g.state.clock.pendingDecision !== null) {
+        sawDecision = true;
+        audit(g, `pending decision (${g.state.clock.pendingDecision.kind})`);
+        break;
+      }
+      const a = g.state.clock.currentActor;
+      if (a === null) break;
+      const opts = legalActions(g.state, a);
+      if (!opts.length || !submit(g, opts[0]!, a)) break;
+    }
+    // A seed that never raises one is not a failure of redaction; say so rather than passing mutely.
+    if (!sawDecision) assert.ok(true, 'no decision arose on this seed — nothing to audit');
+  });
+
+  it('with Employee Rotation on, before and after ownership moves', () => {
+    // The case where seat and player index come apart. A projection that confused them would hand
+    // one player another's district, which is a leak the other tests cannot see.
+    const rotating = { ...config, optionalRules: { ...config.optionalRules, employeeRotation: true } };
+    const g = newMultiplayerGame(729315046, rotating, names);
+    audit(g, 'employee rotation, before');
+    const seatingBefore = [...g.state.seating];
+    play(g, 400);
+    audit(g, 'employee rotation, after');
+    // If the seating never moved this test proved less than it looks — say which happened.
+    const moved = seatingBefore.some((p, i) => g.state.seating[i] !== p);
+    assert.ok(moved || g.state.status !== 'active', 'rotation never moved anybody and the game did not end');
+  });
+
+  it('a game played out to the end, or as far as it goes', () => {
+    const g = newMultiplayerGame(613884219, config, names);
+    play(g, 6000);
+    // Says which it actually got, rather than claiming a finished game it may not have reached.
+    audit(g, `played out (status ${g.state.status})`);
+  });
+
+  it('a reconnect push, which is a full Frame rather than a delta', () => {
+    const session = createSession(550943578, config, names);
+    for (const seat of [0, 1, 2] as PlayerIndex[]) {
+      const push = session.connect(seat);
+      const seen = JSON.stringify(push);
+      const state = session.exportSave();
+      assert.ok(!seen.includes(String(state.seed)), `the reconnect push for seat ${seat} carries the seed`);
+      for (const p of [0, 1, 2] as PlayerIndex[]) {
+        if (p === seat) continue;
+        // `connect` returns that seat's own Frame; another seat's hand must not be in it.
+        assert.ok(
+          !/"hand":\[[^\]]/.test(JSON.stringify((push.frame as unknown as Record<string, unknown>)['players'] ?? '')),
+          `the reconnect push for seat ${seat} carries a hand inside players[]`,
+        );
+      }
+    }
+  });
+
+  /**
+   * THE ALLOW-LIST, and the plan's actual acceptance bar.
+   *
+   * Every property of the public projection, written down and reviewed as public. This does not
+   * check the CONTENT of anything — the tests above do that — it checks that nobody has added a
+   * field without saying out loud that a spectator may see it. That is the check that would have
+   * caught both v0.7.9.2 leaks, because both were fields nobody had ever asked the question about.
+   *
+   * When this fails, the fix is not to add the key here. It is to decide whether the field is
+   * public, and only then to add it.
+   */
+  it('every public property is on the allow-list, and nothing else is', () => {
+    const PUBLIC: readonly string[] = [
+      // The clock and the phase — what a spectator's board is FOR.
+      'day', 'stage', 'clock', 'phase', 'phaseKey', 'actor', 'superintendent',
+      // Deck sizes and face-up piles. A Department pile is face up; the Home Office deck is a count.
+      'deck', 'departments', 'departmentsWhat', 'departmentDepth', 'salvage',
+      // Rolling stock in the yards, by type — visible on the table.
+      'yards',
+      // The timetable is public: it is what everyone is playing against.
+      'timetable', 'timetableWhat',
+      // 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',
+      // The opening rolls decided seating and the Superintendent in the open.
+      'openingRolls',
+      // Where every train is standing.
+      'trains',
+      // The Crew Tray pool and the trains queued for one (#98). §7 scarcity is played out in the
+      // open: the trays are objects in the middle of the table, and an Extra is played face up, so
+      // who is waiting for a crew is not a secret. Counts and train numbers only — never a hand.
+      'crewTrays', 'queued',
+      // The board itself.
+      'division', 'districts',
+    ];
+    const g = newMultiplayerGame(4242, config, names);
+    const actual = Object.keys(publicSnapshot(g.state)).sort();
+    const allowed = [...PUBLIC].sort();
+    assert.deepEqual(
+      actual,
+      allowed,
+      'the public projection gained or lost a property — decide whether it is public before listing it',
+    );
+  });
+});

test/replay.test.ts

@@ -6,6 +6,9 @@
  */
 
 import { describe, it } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import assert from 'node:assert/strict';
 
 import { pump } from '../src/engine/advance.ts';
@@ -13,8 +16,8 @@ import { DEFAULT_MAX_COLLISIONS_PER_DAY, DEFAULT_MAX_COLLISIONS_TOTAL, collectiv
 import type { GameEvent } from '../src/engine/events.ts';
 import { areaOf } from '../src/engine/apply.ts';
 import { createGame } from '../src/engine/setup.ts';
-import { coordKey } from '../src/engine/state.ts';
-import type { GameConfig, GameState } from '../src/engine/state.ts';
+import { coordKey, turnOf } from '../src/engine/state.ts';
+import type { GameConfig, GameState, GridCoord } from '../src/engine/state.ts';
 import { developerBot, playGame } from '../src/sim/bot.ts';
 import { impediments, isVisible, narrate, phaseLabel } from '../src/sim/narrate.ts';
 import { compress, rehydrateCells, record, renderHtml } from '../src/sim/replay.ts';
@@ -41,10 +44,13 @@ const SAMPLES: GameEvent[] = [
   { type: 'stageBegan', day: 1, stage: 7 },
   { type: 'phaseBegan', phase: 'mainline' },
   { type: 'actorChanged', player: 0 },
+  // Sampled rather than left to swell the unsampled count: this sentence is one a player reads at
+  // the table every third Stage, so its text is worth exercising.
+  { type: 'superintendentChanged', player: 1, stage: 6 },
   { type: 'localOpsOptionChosen', player: 0, option: 'switch' },
-  { type: 'trayMoved', trayId: 't0', from: { row: 0, col: 0 }, to: { row: 0, col: 1 }, movesRemaining: 5 },
-  { type: 'carsCoupled', trayId: 't0', at: { row: 0, col: 1 }, stock: [{ type: 'hopper', loaded: false }], from: [{ row: 0, col: 1 }], toNose: true },
-  { type: 'carsDropped', trayId: 't0', at: { row: 1, col: 0 }, stock: [{ type: 'hopper', loaded: false }] },
+  { type: 'trayMoved', player: 0, trayId: 't0', from: { row: 0, col: 0 }, to: { row: 0, col: 1 }, movesRemaining: 5 },
+  { type: 'carsCoupled', player: 0, trayId: 't0', at: { row: 0, col: 1 }, stock: [{ type: 'hopper', loaded: false }], from: [{ row: 0, col: 1 }], toNose: true },
+  { type: 'carsDropped', player: 0, trayId: 't0', at: { row: 1, col: 0 }, stock: [{ type: 'hopper', loaded: false }] },
   { type: 'cardDrawn', player: 0, source: 'homeOffice', cardId: 'c1' },
   { type: 'cardPlayed', player: 0, cardId: 'c1', placement: { row: 1, col: 0 }, variant: 0 },
   { type: 'officeUpgraded', player: 0, from: 'whistlePost', to: 'depot' },
@@ -72,12 +78,56 @@ const SAMPLES: GameEvent[] = [
 
 describe('narration', () => {
   it('covers every event type the engine can emit', () => {
-    // Guards against a new event type slipping in unnarrated.
-    const covered = new Set(SAMPLES.map((e) => e.type));
-    const declared = new Set<string>();
-    for (const e of SAMPLES) declared.add(e.type);
-    assert.equal(covered.size, 30, 'sample list is out of step with GameEvent');
-    assert.equal(declared.size, 30);
+    /**
+     * THIS TEST USED TO BUILD BOTH SETS FROM `SAMPLES` and compare them to each other, so it could
+     * only ever assert that the sample list had 30 distinct entries — the one thing it could not
+     * detect was the thing its comment promised, a new `GameEvent` slipping in unnarrated. Fixed
+     * 2026-09-09 while adding the v0.8.0 step collector, which made the event union load-bearing for
+     * a second reader.
+     *
+     * The union is read out of `src/engine/events.ts` rather than hand-listed, the same way
+     * `test/pacing.test.ts` reads the intent union: a list maintained by hand is a list that goes
+     * stale, which is how this got here.
+     */
+    const here = dirname(fileURLToPath(import.meta.url));
+    const declared = new Set(
+      [...readFileSync(join(here, '../src/engine/events.ts'), 'utf8').matchAll(/type: '([a-zA-Z]+)'/g)]
+        .map((m) => m[1]!),
+    );
+    const narrated = new Set(
+      [...readFileSync(join(here, '../src/sim/narrate.ts'), 'utf8').matchAll(/case '([a-zA-Z]+)':/g)]
+        .map((m) => m[1]!),
+    );
+    assert.ok(declared.size > 40, `only ${declared.size} event types parsed — the parse is wrong`);
+
+    // THE INVARIANT THAT MATTERS: an event the engine can emit and `narrate` has no case for falls
+    // through to a placeholder, in front of a player. This is the check the old version promised.
+    const unnarrated = [...declared].filter((t) => !narrated.has(t));
+    assert.deepEqual(unnarrated, [], 'these event types can be emitted and have no narration case');
+
+    const covered = new Set<string>(SAMPLES.map((e) => e.type));
+    const unknown = [...covered].filter((t) => !declared.has(t));
+    assert.deepEqual(unknown, [], 'these samples name an event the engine no longer declares');
+
+    /**
+     * THE KNOWN GAP, PINNED SO IT CANNOT GROW.
+     *
+     * `SAMPLES` exercises the TEXT of 30 of the 55 declared events; the other 25 have a narration
+     * case (checked above) but no sample, so nothing proves their sentence is any good. Found
+     * 2026-09-09 — the old test built both of its sets from `SAMPLES` and compared them to each
+     * other, so it could only ever assert that the sample list had 30 distinct entries, and the one
+     * thing it could not detect was the thing its comment promised.
+     *
+     * Pinned rather than fixed: writing 25 fixtures is a job of its own, and a bad sentence is worth
+     * finding deliberately rather than in a rush. What this does guarantee is that a NEW event type
+     * cannot join the unsampled set silently.
+     */
+    const unsampled = [...declared].filter((t) => !covered.has(t)).sort();
+    assert.equal(
+      unsampled.length,
+      25,
+      `the unsampled set changed (${unsampled.length}): add a sample for a new event, or update this count`,
+    );
   });
 
   it('gives every event a specific, non-empty sentence', () => {
@@ -99,6 +149,33 @@ describe('narration', () => {
     assert.match(loss.text, /COLLISION/i);
   });
 
+  /**
+   * WHOSE OFFICE, AND WHOSE TRAIN — Jesse, playtest 2026-09-16.
+   *
+   * The line went to every seat reading "ARRIVED at the Whistle Post … You can work it in Cargo now".
+   * At a table of four that is one true sentence and one false one: every seat has an Office, so the
+   * tier alone does not say which district the train is standing in, and three of the four readers
+   * cannot touch it. Constructed here rather than fished out of a game so both halves are pinned
+   * exactly, and the resolver-less path is checked too — the replay viewers pass no names for a
+   * table they do not have.
+   */
+  it('names WHOSE Office a train reached, and never tells the table they can work it', () => {
+    const named = narrate(
+      { type: 'trainArrived', trainNumber: 3, consist: [], office: 'Whistle Post', owner: 1, expedited: false },
+      { playerName: () => 'Tom' },
+    );
+    assert.match(named.text, /Tom's Whistle Post/, `the arrival did not name the Office's owner: ${named.text}`);
+    assert.match(named.text, /Tom can work it/, `the arrival did not say whose train it is to work: ${named.text}`);
+    assert.doesNotMatch(named.text, /\bYou can work it\b/i, `the arrival still addresses every reader: ${named.text}`);
+
+    // No resolver — still English, and still no raw index leaking into a sentence.
+    const anon = narrate({
+      type: 'trainArrived', trainNumber: 3, consist: [], office: 'Whistle Post', owner: 1, expedited: false,
+    });
+    assert.match(anon.text, /at the Whistle Post/, anon.text);
+    assert.doesNotMatch(anon.text, /undefined|\bplayer \d+\b/i, anon.text);
+  });
+
   it('points at the board cell where something happened', () => {
     const n = narrate({ type: 'loadCompleted', player: 0, at: { row: 1, col: 2 }, carType: 'hopper' });
     assert.deepEqual(n.where, { row: 1, col: 2 });
@@ -138,6 +215,89 @@ describe('impediments', () => {
     s.freeTrays = [];
     assert.ok(impediments(s, 0).some((b) => /HELD/.test(b.why)));
   });
+
+  /** A crew standing on `at`, working the given train, with one empty tank car on the drawbar. */
+  const express = (s: GameState, trainNumber: number, at: GridCoord): string => {
+    const id = s.freeTrays.pop()!;
+    s.trays.set(id, {
+      id, trainNumber, trainIsExtra: false, engineAt: 0,
+      consist: [{ type: 'tank', loaded: false, origin: 0 }],
+      direction: 'east', position: { at: 'grid', seat: 0, coord: at }, movesUsed: 0,
+    });
+    return id;
+  };
+
+  /**
+   * GITEA#21 — THE GAME REFUSED, AND THE PANEL EXPLAINED SOMETHING ELSE.
+   *
+   * "I wanted to drop two empty tank cars so that the freight agents and men at work could load
+   * them later. I dropped the first tank car, but that was all I was allowed to do. Checked
+   * 'Blocked — why nothing is moving' and saw: refinery 1,0 — green box empty — nothing to load
+   * (needs a Freight Agent action)."
+   *
+   * Replayed from the attached save (seed 550943578, 181 intents): the crew was Train 3, and the
+   * engine's answer was `FREIGHT_WORKED_HERE`. Train 3 is the Express, and the Express prints "May
+   * drop or pick up one freight car at every location" — so THE REFUSAL WAS CORRECT and the rule
+   * is not what is wrong here. It resets next turn, and the Express may work a car at the next
+   * square this turn; that is what makes it an Express rather than a one-car-a-Stage train.
+   *
+   * What was wrong is that nothing said so. The panel whose entire job is "why is nothing moving?"
+   * listed the refinery's green box — a true statement about the FACILITY, and nothing to do with
+   * why the drop was refused — so the player was sent to fix a Freight Agent action that would not
+   * have helped. The rule was on the train card's own tooltip, which is not where somebody looks
+   * when a button they expected is missing.
+   *
+   * The panel is where a refusal gets explained, so the budget belongs in it.
+   */
+  it('says when the Express has spent its one freight car on this square (Gitea#21)', () => {
+    const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
+    const area = areaOf(s, 0);
+    const at = area.officeCoord;
+
+    // A crew standing at the Office working Train 3 — the Express — with a tank car still on it.
+    const trayId = express(s, 3, at);
+
+    s.clock.phase = 'localOps';
+    const turn = turnOf(s, 0);
+    turn.option = 'switch';
+
+    // Nothing to say before it has worked anything here.
+    assert.ok(
+      !impediments(s, 0).some((b) => /FREIGHT CAR PER LOCATION/i.test(b.why)),
+      'the budget was reported spent before the train had worked a car at all',
+    );
+
+    // Now it has set one car out here — exactly the state the save is in at intent 181.
+    turn.freightWorked[`${trayId}@${coordKey(at)}`] = 1;
+
+    const row = impediments(s, 0).find((b) => /FREIGHT CAR PER LOCATION/i.test(b.why));
+    assert.ok(
+      row,
+      `nothing explained the refusal:\n${JSON.stringify(impediments(s, 0), null, 2)}`,
+    );
+    // It must name the train, or a player with three crews out cannot tell which one it means.
+    assert.match(row!.where, /Train 3/);
+    // And it must say the limit lifts, or it reads as "this train can never work here again".
+    assert.match(row!.why, /turn/i);
+    // Amber: this is the printed rule doing its job, not a fault.
+    assert.equal(row!.severity, 'waiting');
+  });
+
+  it('leaves every other train alone — the rule is printed on 3 and 4 only (Gitea#21)', () => {
+    const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
+    const area = areaOf(s, 0);
+    const at = area.officeCoord;
+    // Train 5 is The Sparrow, which prints no per-location freight limit.
+    const trayId = express(s, 5, at);
+    s.clock.phase = 'localOps';
+    turnOf(s, 0).option = 'switch';
+    turnOf(s, 0).freightWorked[`${trayId}@${coordKey(at)}`] = 1;
+
+    assert.ok(
+      !impediments(s, 0).some((b) => /FREIGHT CAR PER LOCATION/i.test(b.why)),
+      'a train with no such rule was told it had spent a budget it does not have',
+    );
+  });
 });
 
 /**
@@ -214,6 +374,24 @@ describe('a blocked platform says why (Gitea#2)', () => {
     assert.ok(f.inboundBox.length === 0, 'the red slots were free — the shortage is the only cause');
   });
 
+  it('says why the game ended in words, not as a raw enum (TODO #34)', () => {
+    /**
+     * The heading read `loss — revenueFloor` — the exact defect Gitea#16 was filed about on the
+     * playable page, still alive here a release after that was fixed, because nothing
+     * player-facing pointed at the developer replay. It shares `reasonSentence` with the results
+     * screen now, so the two cannot explain one ending in two ways.
+     */
+    const rec = record(1234, 'standard');
+    for (const raw of ['revenueFloor', 'daysElapsed', 'collisionFloor']) {
+      assert.ok(!rec.outcome.includes(raw), `the summary still prints the raw reason "${raw}"`);
+    }
+    assert.doesNotMatch(rec.outcome, /<[^>]+>/, 'markup leaked into a heading and a console line');
+    assert.match(rec.outcome, /Revenue/, 'the summary says nothing about how the game went');
+    // And the sentence is the shared one, with this game's own numbers in it.
+    assert.match(rec.outcome, /closed short|last on the timetable|declared unsafe/,
+      'the ending is not explained in the words the results screen uses');
+  });
+
   it('says nothing about a platform that is working fine', () => {
     // Passengers waiting AND a train with an empty coach to take them: no impediment.
     const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
@@ -257,7 +435,10 @@ describe('replay recording', () => {
     const last = rec.frames[rec.frames.length - 1]!;
     assert.equal(last.revenue, stats.revenue.net, 'final revenue disagrees with the engine');
     assert.equal(last.day, s.clock.day, 'final Day disagrees with the engine');
-    assert.match(rec.outcome, new RegExp(stats.result));
+    // The summary says "won"/"lost" rather than the engine's `win`/`loss` (TODO #34 — it is a
+    // sentence for a reader now, not an enum). Mapped here so this still checks the two AGREE,
+    // which is what the test is for, rather than checking they are spelled the same.
+    assert.match(rec.outcome, new RegExp(stats.result === 'win' ? 'won' : 'lost'));
   });
 
   it('narrates every frame', () => {

test/route-cache.test.ts

@@ -0,0 +1,88 @@
+/**
+ * The engine's speed-ups must not change a single game (2026-09-15).
+ *
+ * `applyIntent` became `prepareIntent` (check and execute, sharing one walk of the position's routes)
+ * followed by `commitEvents` (reduce and tally), so the switching planner can decide every candidate
+ * against one position and apply each to a copy. Two properties hold that together:
+ *
+ * 1. `prepareIntent` never writes the state it reads — including through the route cache it opens.
+ * 2. Preparing on one state and committing to an EQUAL copy lands on exactly what `applyIntent` does.
+ *
+ * Checked at every decision of seeded bot games rather than on hand-built positions, so the intents
+ * exercised are the ones real play submits.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { pump } from '../src/engine/advance.ts';
+import { applyIntent, commitEvents, prepareIntent } from '../src/engine/apply.ts';
+import {
+  DEFAULT_MAX_COLLISIONS_PER_DAY,
+  DEFAULT_MAX_COLLISIONS_TOTAL,
+  collectiveRevenueFloor,
+  lengthProfile,
+} from '../src/engine/content.ts';
+import { legalActions } from '../src/engine/legal.ts';
+import { createGame } from '../src/engine/setup.ts';
+import type { GameConfig, GameState } from '../src/engine/state.ts';
+import { developerBot, playGame } from '../src/sim/bot.ts';
+
+const config = (): GameConfig => {
+  const days = lengthProfile('short').days;
+  return {
+    mode: 'solitaire',
+    days,
+    minCombinedRevenue: collectiveRevenueFloor(1, days),
+    maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
+    maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
+    pvpCardsAllowed: false,
+    optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
+  };
+};
+
+const serialise = (s: GameState): string =>
+  JSON.stringify(s, (_k, v) => (v instanceof Map ? [...v] : v instanceof Set ? [...v] : v));
+
+describe('applyIntent split into prepareIntent and commitEvents', () => {
+  it('prepares without writing, and committing to a copy matches applying in place', () => {
+    let decisions = 0;
+    let rejectedSeen = 0;
+    const s = createGame({ id: 'split-8919', seed: 8919, config: config(), playerNames: ['bot'] });
+    const policy = {
+      name: 'split-probe',
+      choose(st: GameState, player: number, options: ReturnType<typeof legalActions>) {
+        const chosen = developerBot.choose(st, player, options);
+        if (decisions < 400) {
+          decisions++;
+          const before = serialise(st);
+          const prepared = prepareIntent(st, player, chosen);
+          assert.equal(serialise(st), before, `decision ${decisions}: prepareIntent wrote into the state it read`);
+          assert.ok(prepared.ok, `decision ${decisions}: a legal choice was refused by prepareIntent`);
+
+          const viaCommit = structuredClone(st);
+          const viaApply = structuredClone(st);
+          commitEvents(viaCommit, prepared.events);
+          const applied = applyIntent(viaApply, player, chosen);
+          assert.ok(applied.ok);
+          assert.deepEqual(applied.events, prepared.events, `decision ${decisions}: the two paths produced different events`);
+          assert.equal(serialise(viaCommit), serialise(viaApply), `decision ${decisions}: committing to a copy diverged from applying`);
+
+          // A refused intent must come back refused from both paths, with nothing written.
+          const refused = { type: 'switch.end' } as const;
+          const r = prepareIntent(st, player, refused);
+          if (!r.ok) {
+            rejectedSeen++;
+            assert.equal(serialise(st), before);
+            assert.equal(applyIntent(structuredClone(st), player, refused).ok, false);
+          }
+        }
+        return chosen;
+      },
+    };
+    const r = playGame(s, policy, pump);
+    assert.ok(r.finished, 'the probed game did not finish');
+    assert.ok(decisions > 0, 'no decision was probed');
+    assert.ok(rejectedSeen > 0, 'no refused intent was exercised');
+  });
+});

test/server/claims.test.ts

@@ -0,0 +1,68 @@
+/**
+ * Seat recovery codes — Gitea#33.
+ *
+ * The properties worth pinning are the ones that make a code safe to put in a link: it is spendable
+ * exactly once, it stops working on its own, and a bad code is indistinguishable from a spent one.
+ * `now` is a parameter rather than a clock, so expiry is tested without faking timers.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { CLAIM_TTL_MS, createClaimStore } from '../../src/server/claims.ts';
+
+describe('seat recovery codes', () => {
+  it('mints a code that names the seat it was minted for', () => {
+    const claims = createClaimStore();
+    const { code, expiresAt } = claims.mint('tok-abc', 'game-1', 1000);
+    assert.equal(expiresAt, 1000 + CLAIM_TTL_MS);
+    assert.deepEqual(claims.redeem(code, 1000), { token: 'tok-abc', gameId: 'game-1' });
+  });
+
+  it('spends a code exactly once — a link in a chat log is worth nothing afterwards', () => {
+    const claims = createClaimStore();
+    const { code } = claims.mint('tok-abc', 'game-1', 0);
+    assert.ok(claims.redeem(code, 1));
+    assert.equal(claims.redeem(code, 2), null, 'the same code was accepted twice');
+  });
+
+  it('stops working once its time is up, without anything having to sweep it', () => {
+    const claims = createClaimStore();
+    const { code } = claims.mint('tok-abc', 'game-1', 0);
+    assert.equal(claims.redeem(code, CLAIM_TTL_MS - 1)?.token, 'tok-abc', 'expired early');
+    const again = claims.mint('tok-abc', 'game-1', 0).code;
+    assert.equal(claims.redeem(again, CLAIM_TTL_MS), null, 'a code outlived its expiry');
+  });
+
+  it('answers the same way for unknown, spent and expired codes', () => {
+    const claims = createClaimStore();
+    const { code } = claims.mint('tok-abc', 'game-1', 0);
+    claims.redeem(code, 1);
+    const expired = claims.mint('tok-abc', 'game-1', 0).code;
+
+    assert.equal(claims.redeem('never-existed', 1), null);
+    assert.equal(claims.redeem(code, 1), null);
+    assert.equal(claims.redeem(expired, CLAIM_TTL_MS + 1), null);
+  });
+
+  it('gives every mint its own code', () => {
+    const claims = createClaimStore();
+    const codes = new Set([0, 1, 2, 3, 4].map(() => claims.mint('tok-abc', 'game-1', 0).code));
+    assert.equal(codes.size, 5, 'two mints produced the same code');
+  });
+
+  it('forgets expired codes rather than accumulating them', () => {
+    const claims = createClaimStore();
+    claims.mint('tok-a', 'game-1', 0);
+    claims.mint('tok-b', 'game-1', 0);
+    assert.equal(claims.outstanding(0), 2);
+    assert.equal(claims.outstanding(CLAIM_TTL_MS), 0, 'expired codes were still being held');
+  });
+
+  it('keeps a short-lived code short-lived when asked for one', () => {
+    const claims = createClaimStore();
+    const { code, expiresAt } = claims.mint('tok-abc', 'game-1', 500, 60_000);
+    assert.equal(expiresAt, 60_500);
+    assert.equal(claims.redeem(code, 60_500), null);
+  });
+});

test/server/session.test.ts

@@ -412,3 +412,198 @@ describe('the four transient signals (2026-08-23)', () => {
     assert.equal(later.scheduled, undefined, 'a reconnecting client was re-sent an old timetable flash');
   });
 });
+
+// ---------------------------------------------------------------------------
+
+describe('§3.3 extended play across the server (Gitea#11)', () => {
+  /**
+   * A one-Day game, so these tests reach the end of the timetable by actually PLAYING to it.
+   *
+   * There is no back door into a session's engine state and there should not be — `connect`,
+   * `intent`, `exportSave` and `summary` are the whole surface. So the clock is run down through the
+   * same calls a client makes, which has the side benefit of exercising the real path: what is under
+   * test here is the session's handling of the vote (the turn guard, the bots, the saved status),
+   * and reaching it any other way would prove less.
+   */
+  const oneDay: GameConfig = { ...config, days: 1 };
+
+  /** What seat `seat` can currently see. `connect` always yields a full Frame, never a delta. */
+  const frameOf = (session: GameSession, seat: PlayerIndex) => session.connect(seat).frame!;
+
+  /** Plays until the game stops asking for ordinary moves. Returns the Frame it stopped on. */
+  function playToTheEnd(session: GameSession, seats: PlayerIndex[]) {
+    let seq = 0;
+    for (let i = 0; i < 5_000; i++) {
+      const acting = seats.find((s) => session.connect(s).menu !== null);
+      if (acting === undefined) break;
+      const menu = session.connect(acting).menu!;
+      if (menu.options.length === 0) break;
+      if (!session.intent(acting, seq++, menu.options[0]!).accepted) break;
+    }
+    return { frame: frameOf(session, seats[0]!), seq };
+  }
+
+  it('stops to ask rather than ending, and every seat can see the question', () => {
+    const session = createSession(42, oneDay, ['Alice', 'Bob']);
+    const { frame } = playToTheEnd(session, [0, 1] as PlayerIndex[]);
+    assert.equal(frame.status, 'awaitingExtension', 'the game did not stop to ask');
+    assert.ok(frame.official, 'the official result did not reach the client');
+    assert.deepEqual(frame.extensionVotes, [null, null], 'the votes did not reach the client');
+  });
+
+  it('accepts the vote from a seat that is not the current actor', () => {
+    // `currentActor` is null once the game has stopped, so the ordinary turn guard would refuse
+    // every vote with NOT_YOUR_TURN. Both seats vote here and neither of them is the actor.
+    const session = createSession(42, oneDay, ['Alice', 'Bob']);
+    const { seq } = playToTheEnd(session, [0, 1] as PlayerIndex[]);
+    const a = session.intent(0 as PlayerIndex, seq + 1, { type: 'game.extend', player: 0, agree: true });
+    assert.equal(a.accepted, true, 'seat 0 could not vote');
+    const b = session.intent(1 as PlayerIndex, seq + 2, { type: 'game.extend', player: 1, agree: true });
+    assert.equal(b.accepted, true, 'seat 1 could not vote');
+
+    const after = frameOf(session, 0 as PlayerIndex);
+    assert.equal(after.extraDays, 1, 'a unanimous table was not given its Day');
+    assert.equal(after.status, 'active', 'play did not resume');
+  });
+
+  it('bots agree only once every human has, and never lead', () => {
+    // "Bots will not disagree with the human. Humans get to vote first" (Jesse, 2026-08-28).
+    const session = createSession(42, oneDay, ['Alice', 'Botty'], [1 as PlayerIndex]);
+    const { seq } = playToTheEnd(session, [0, 1] as PlayerIndex[]);
+    assert.equal(frameOf(session, 0 as PlayerIndex).status, 'awaitingExtension');
+    assert.equal(
+      frameOf(session, 0 as PlayerIndex).extensionVotes[1],
+      null,
+      'the bot voted before the human did',
+    );
+
+    session.intent(0 as PlayerIndex, seq + 1, { type: 'game.extend', player: 0, agree: true });
+    const after = frameOf(session, 0 as PlayerIndex);
+    assert.equal(after.extraDays, 1, 'the bot did not follow the human into another Day');
+    assert.equal(after.status, 'active');
+  });
+
+  it('a human refusal ends it, and no bot overrides that', () => {
+    const session = createSession(42, oneDay, ['Alice', 'Botty'], [1 as PlayerIndex]);
+    const { seq } = playToTheEnd(session, [0, 1] as PlayerIndex[]);
+    session.intent(0 as PlayerIndex, seq + 1, { type: 'game.extend', player: 0, agree: false });
+    const after = frameOf(session, 0 as PlayerIndex);
+    assert.equal(after.status, 'finished');
+    assert.equal(after.extraDays, 0);
+  });
+
+  it('REGRESSION: an all-bot game ends rather than hanging on the question', () => {
+    /**
+     * `driveBots` loops on `currentActor`, which is null the moment the game stops to ask — so it
+     * cannot cast the vote itself, and the bots' vote is driven separately. The first cut of that
+     * driver returned early when there were no humans to follow, on the reasoning that a bot-only
+     * table would decline through the ordinary path. It has no ordinary path: nothing ever asked
+     * the bots, and an all-bot session sat on the question for ever without reaching `finished`.
+     * Caught by `summary()`'s own "a finished game waits on nobody" test.
+     */
+    const session = createSession(4242, oneDay, ['A', 'B'], [0, 1] as PlayerIndex[]);
+    assert.equal(frameOf(session, 0 as PlayerIndex).status, 'finished', 'the bots never answered');
+    assert.equal(session.summary().waitingOn, null);
+    assert.equal(frameOf(session, 0 as PlayerIndex).extraDays, 0, 'bots voted themselves another Day');
+  });
+
+  it('saves a game awaiting its vote as ACTIVE, so a restart resumes it', () => {
+    // `server/index.ts` never loads a `finished` game back into memory. A game paused on the
+    // extension question is waiting on its table, not over — persisting it as finished would strand
+    // it on disk mid-decision.
+    const session = createSession(42, oneDay, ['Alice', 'Bob']);
+    playToTheEnd(session, [0, 1] as PlayerIndex[]);
+    assert.equal(frameOf(session, 0 as PlayerIndex).status, 'awaitingExtension');
+    assert.equal(session.exportSave().status, 'active', 'a paused game was saved as finished');
+    assert.equal(session.summary().status, 'active');
+  });
+
+  it('resumes a paused game from its history, vote and all', () => {
+    const session = createSession(42, oneDay, ['Alice', 'Bob']);
+    const { seq } = playToTheEnd(session, [0, 1] as PlayerIndex[]);
+    session.intent(0 as PlayerIndex, seq + 1, { type: 'game.extend', player: 0, agree: true });
+
+    const resumed = resumeSession(session.exportSave());
+    const a = frameOf(session, 0 as PlayerIndex);
+    const b = frameOf(resumed, 0 as PlayerIndex);
+    assert.deepEqual(b.extensionVotes, a.extensionVotes, 'the votes did not survive the replay');
+    assert.equal(b.extraDays, a.extraDays, 'the extra Day did not survive the replay');
+    assert.deepEqual(b.official, a.official, 'the official result did not survive the replay');
+  });
+});
+
+/**
+ * NARRATION HAS ONE PATH, AND A RECONNECT HAS TO GET ALL OF IT (#97, Gitea#20 step 1).
+ *
+ * The common-board plan asks for one thing here: "stop passing the full game log into `frameFor()`;
+ * continue sending sanitized incremental narration through `Push.lines`." Doing only the first half
+ * would have deleted a real behaviour, so this pins the pair.
+ *
+ * WHAT WAS ACTUALLY WRONG. `Frame.lines` carried the WHOLE log on every push, and nothing read it:
+ * `RemoteSession` (`web/session.ts`) accumulates `lines` from `push.lines` alone and its `lines()`
+ * returns that accumulator. So the log was serialised into every frame for every seat, grew all
+ * game, and was thrown away on arrival — while `linesSince` sent the same text again, correctly,
+ * beside it.
+ *
+ * And the duplicate was masking a bug rather than merely wasting bandwidth. `connect()` clears
+ * `lastFrame` but did NOT clear `sentLines`, so a reconnecting seat was told "nothing new since your
+ * last push" — while the browser it was answering had just reloaded and started from an EMPTY
+ * accumulator. The history panel came back blank after a refresh, mid-game, with the server holding
+ * the whole log and shipping it in the one field nobody reads.
+ *
+ * So the two halves are one change: a (re)connect resets the seat's watermark and `Push.lines` on a
+ * connect IS the history, which is what lets the frame stop carrying a second copy.
+ */
+describe('narration reaches a seat exactly once, by one path (#97)', () => {
+  /**
+   * A session with narration already in the log and NO connect yet, so a first connect is a real
+   * "catch me up" rather than a no-op. Connecting inside this helper is what made the first draft of
+   * the reconnect test pass vacuously: both sides of the comparison were the empty array.
+   */
+  const played = (): GameSession => createSession(550943578, config, ['Alice', 'Bob']);
+
+  it('a FIRST connect carries the narration so far in Push.lines', () => {
+    const session = createSession(550943578, config, ['Alice', 'Bob']);
+    const push = session.connect(0 as PlayerIndex);
+    assert.ok(push.lines.length > 0, 'a first connect was given no narration at all');
+    assert.ok(
+      push.lines.some((l) => /players|competitive/i.test(l.text)),
+      'the opening lines are not in what a first connect received',
+    );
+  });
+
+  it('a RECONNECT is given the whole log again, because the browser it answers has none', () => {
+    const session = played();
+    const first = session.connect(0 as PlayerIndex);
+    const again = session.connect(0 as PlayerIndex);
+    // NON-EMPTY first: two empty arrays are deepEqual, and asserting only that is how this test
+    // passed against the broken code on its first draft.
+    assert.ok(first.lines.length > 0, 'the premise is gone: there was no narration to be given');
+    assert.deepEqual(
+      again.lines,
+      first.lines,
+      'a reconnecting seat was told nothing was new, and its history panel would come back empty',
+    );
+  });
+
+  it('the Frame does NOT carry a second copy of the log', () => {
+    const session = played();
+    const push = session.connect(0 as PlayerIndex);
+    assert.deepEqual(
+      (push.frame as unknown as { lines: unknown[] }).lines,
+      [],
+      'the whole narration log is still being serialised into every Frame, where nothing reads it',
+    );
+  });
+
+  it('an ordinary push after a connect carries only what is NEW', () => {
+    const session = played();
+    const opening = session.connect(0 as PlayerIndex);
+    assert.ok(opening.lines.length > 0);
+    // A second connect for the OTHER seat must not re-send seat 0 anything.
+    const other = session.connect(1 as PlayerIndex);
+    assert.ok(other.lines.length > 0, 'the other seat got no history of its own');
+    const third = session.connect(0 as PlayerIndex);
+    assert.deepEqual(third.lines, opening.lines, 'a reconnect is the full log, every time');
+  });
+});

test/session.test.ts

@@ -17,7 +17,7 @@ import assert from 'node:assert/strict';
 import { readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 
-import { actionGroups, currentActor, handPlayable, newGame, overHandLimit, submit, toSave, view } from '../src/web/game.ts';
+import { actionGroups, currentActor, handPlayable, newGame, submit, toSave, view } from '../src/web/game.ts';
 import { createLocalSession } from '../src/web/session.ts';
 import { seatLabel } from '../src/sim/view.ts';
 
@@ -63,7 +63,13 @@ describe('a local session plays the same game as the calls it replaced', () => {
     assert.ok(turns > 50, `only ${turns} decisions — the game stalled`);
 
     const f = session.view();
-    assert.equal(f.status, 'finished');
+    /**
+     * `awaitingExtension` since Gitea#11, not `finished`: both loops stop when there is no actor,
+     * and a days-based ending now parks the game on the "play one more Day?" question rather than
+     * ending it outright. What this test is actually about is unchanged — the two sides reach the
+     * SAME position — and the assertion below is still the one carrying that.
+     */
+    assert.equal(f.status, 'awaitingExtension');
     assert.equal(f.status, view(game).status);
     assert.equal(f.day, view(game).day);
     assert.deepEqual(f.cells, view(game).cells, 'the board differs across the boundary');
@@ -75,7 +81,6 @@ describe('a local session plays the same game as the calls it replaced', () => {
     assert.equal(session.seat(), 0);
     assert.equal(session.actor(), currentActor(session.game));
     assert.deepEqual(session.handPlayable(), handPlayable(session.game));
-    assert.equal(session.overHandLimit(), overHandLimit(session.game));
   });
 });
 

test/setup.test.ts

@@ -63,56 +63,73 @@ const gameDealtWith = (startingHand: StartingHand, seed = 1234) =>
 
 describe('card catalogue (component 1)', () => {
   it('composes the deck from the design', () => {
-    // Transcribed from docs/Deck cards2.xlsx. The sheet's own totals are "Sum other 115" and
-    // "Total track 104", i.e. 219, plus 12 start cards for its grand total of 231.
+    // THE WHOLE CATALOGUE IS docs/Deck cards5.xlsx NOW (Gitea#14). Sheet 5's own totals are
+    // "Total track 48" and "Total other (in play) 107", i.e. 155 shuffled, plus 12 start cards for
+    // its grand total of 167. Card for card, 84 rows agree with it exactly and the only ones that
+    // do not are listed below — every one of them a deliberate hold, in one direction or the other.
     //
-    // We are at 235 rather than 219 because of three deliberate departures, all flagged in
-    // content.ts: 18 extra industry cards (Gap 12, industries 9 → 27), 7 extra office cards (Q12,
-    // offices 7 → 14), and the 8 sharp curves taken back OUT. The first two were tuned against a deck
-    // that had NO track in it, so both are due a re-measurement now that 96 track cards share the
-    // draw.
+    // EVERY COUNT IN THE CATALOGUE IS NOW THE SHEET'S. The two deliberate departures that used to
+    // sit here are gone with Gitea#14 — the Q12 office doubling (offices 14 → 7) and the Gap 12
+    // industry tripling (27 → 9) — because both were measured against a deck holding 96 track
+    // cards, and sheet 5 halves that. content.ts carries the measurements that decided it.
     //
-    // Two entries are dealt ZERO copies and kept in the catalogue so the design stays visible:
-    // Poling, whose effect is "TBD in the source", and the sharp curves, whose only difference from
-    // an ordinary curve was a Move cost nothing ever charged.
-    // DECK_SIZE is the CATALOGUE, 235. The deck actually dealt is smaller: the 22 opponent-directed
-    // cards are held back in every mode until they are implemented, so `buildDeck` returns 213.
-    assert.equal(DECK_SIZE, 235);
+    // We are at 143 rather than the sheet's 155 for ONE reason: the ten Safety, Event, Inspection
+    // and Space-use cards sheet 5 adds are not built, and stay out until they are (Jesse,
+    // 2026-08-26) — Cargo Theft, Civic Improvement, Civilian angel, Delayed Clearance, Flares 2,
+    // Robbery, Service Delays, Shipper complaints, Strike, Union Hall 2. Twelve copies in all.
+    //
+    // NOTHING RUNS THE OTHER WAY ANY MORE. Every card sheet 5 does not list is dealt ZERO copies
+    // rather than deleted, so the design stays visible and the rules stay implemented: the
+    // Telegraph/Telephone/Radio ladder, Facing Point Locks (both), Flying Switch, Section House and
+    // Vandalism, all removed from the design on purpose; Poling, whose effect the source records as
+    // "TBD"; and the sharp curves, whose only difference from an ordinary curve was a Move cost
+    // nothing ever charged — sheet 5 deals those zero too, so the catalogue and the design agree.
+    //
+    // DECK_SIZE is the CATALOGUE, 143. The deck actually dealt is smaller: the 20 opponent-directed
+    // cards are held back in every mode until they are implemented, so `buildDeck` returns 123.
+    assert.equal(DECK_SIZE, 143);
     assert.equal(buildDeck().length, SOLITAIRE_DECK_SIZE);
   });
 
   it('matches the design deck composition exactly', () => {
     const byCategory = Object.fromEntries(deckComposition().map((c) => [c.category, c.count]));
     assert.deepEqual(byCategory, {
-      // 96, not the sheet's 104: the 8 SHARP CURVES are dealt zero copies. The only thing that made
-      // one different from an ordinary curve was a Move cost that nothing ever charged, so they were
-      // geometric duplicates taking 8 draws. Kept in the catalogue at zero, as Poling is.
-      track: 96,
-      // 14, not the sheet's 7 — Q12 office density; see OFFICE_PROFILES.
-      office: 14,
-      // 27, not the sheet's 9 — Gap 12 industry density; see INDUSTRY_PROFILES.
-      industry: 27,
+      // Sheet 5's track counts exactly (Gitea#14): 16 straights, 8+8 curves, 8+8 turnouts, and the
+      // sharp curves dealt none — which is where the catalogue already had them, and where sheet 5
+      // now puts them too.
+      track: 48,
+      // The sheet's 7 — the Q12 doubling came out in Gitea#14; see OFFICE_PROFILES.
+      office: 7,
+      // The sheet's 9 — the Gap 12 tripling came out in Gitea#14; see INDUSTRY_PROFILES.
+      industry: 9,
       modifier: 23,
       train: 22,
-      spaceUse: 12,
-      enhancement: 18,
-      mainlineModifier: 7,
-      // 6, not 7 — Poling is dealt no copies until its rule is known.
-      maneuver: 6,
-      action: 10,
+      spaceUse: 11,
+      // 6 — the dispatching ladder and Facing Point Locks are dealt 0 copies (see
+      // ENHANCEMENT_CARDS), and Interlocking, Water column and ABS Signals came down to the sheet's
+      // single copies. What is left is the sheet's Enhancements exactly, bar Railroad crossing,
+      // which sheet 5 moved here from the Action cards and which is still counted there below.
+      enhancement: 6,
+      // 5 — Facing Point Locks came out of the Mainline modifiers too.
+      mainlineModifier: 5,
+      // 3 — Red Flags is the sheet's 3; Flying Switch and Poling are both dealt none.
+      maneuver: 3,
+      // 9 — Vandalism is dealt none. The rest are opponent-directed and held out of every deck.
+      action: 9,
     });
   });
 
   it('removes opponent-directed cards from a solitaire deck', () => {
     // Q6 took Space-use and Action cards out of solitaire, where they have no legal target. They are
     // now out of the COMPETITIVE deck too, until they are implemented: `checkPlay` answers both
-    // categories NOT_IMPLEMENTED, so dealing them would make 22 of 235 draws (9%) reject outright.
-    // 206, not 213: the 22 opponent-directed cards come out, and so do the SEVEN that exist only to
-    // answer them — Facing Point Locks (both the Enhancement and the Mainline modifier, 2 each), two
-    // Water Columns and one Overpass. A defence with nothing to defend against is the same dead draw
-    // as the attack would be. `SimpleCard.answers` names the pairing, so they return together.
-    assert.equal(SOLITAIRE_DECK_SIZE, 206);
-    assert.equal(DEFENCE_ONLY_COPIES, 7);
+    // categories NOT_IMPLEMENTED, so dealing them would be a dead draw.
+    // 121, not 123: the 20 opponent-directed cards come out, and so do the TWO that exist only to
+    // answer them — one Water Column and one Overpass. A defence with nothing to defend against is
+    // the same dead draw as the attack would be. `SimpleCard.answers` names the pairing, so they
+    // return together. It was seven until Gitea#14 dealt Facing Point Locks zero copies: a card at
+    // zero is already out, so it no longer needs holding back.
+    assert.equal(SOLITAIRE_DECK_SIZE, 121);
+    assert.equal(DEFENCE_ONLY_COPIES, 2);
     for (const c of DEFENCE_ONLY_CARDS) {
       assert.ok(c.answers, `${c.name} is held back without saying what it answers`);
       assert.ok(
@@ -131,11 +148,12 @@ describe('card catalogue (component 1)', () => {
   });
 
   it('deals track FROM the deck, at the sheet\'s counts', () => {
-    // Column B of Deck cards2.xlsx, "Number in Deck": 32 straights, 16+16 curves, 16+16 turnouts —
-    // and 4+4 sharp curves, which are dealt none. An earlier reading took the sheet's LAST column,
-    // "Track Per Player" (26), as a separate stack outside the deck; it is the sheet's 104 shared out
-    // among four players, not a second pile.
-    assert.equal(TRACK_IN_DECK, 96);
+    // Column B of Deck cards5.xlsx, "Number in Deck": 16 straights, 8+8 curves, 8+8 turnouts, and
+    // 0+0 sharp curves. Sheet 2 had each of those at double, which is what the deck dealt until
+    // Gitea#14. An earlier reading took the sheet's LAST column, "Track Per Player" (26), as a
+    // separate stack outside the deck; it is the sheet's total shared out among four players, not a
+    // second pile.
+    assert.equal(TRACK_IN_DECK, 48);
     const deck = buildDeck();
     for (const t of TRACK_CARDS) {
       const n = deck.filter(
@@ -146,11 +164,26 @@ describe('card catalogue (component 1)', () => {
   });
 
   it('makes track the largest category in the deck', () => {
-    // 96 of 235. Building a district is paid for in the industry or train you did not draw, which
+    // 48 of 121. Building a district is paid for in the industry or train you did not draw, which
     // is the whole reason it matters that track is a card rather than a private supply.
+    //
+    // This asked for a THIRD of the deck until Gitea#14, which was only ever a rule of thumb. It
+    // asks its own question now — is track still the biggest single thing you can draw — plus a
+    // loose band, because the exact share is not settled yet and should not be pinned as though it
+    // were. Sheet 5 puts track at 48 of the 155 cards it would have you shuffle, i.e. 31%; we read
+    // 40% because the Space-use, Safety, Event and Inspection cards are held out, which concentrates
+    // everything that is left. The share falls TOWARDS the sheet as those land, so the band is set
+    // to hold across that whole journey rather than to be re-edited at each step.
     const deck = buildDeck();
-    const track = deck.filter((c) => c.kind.kind === 'track').length;
-    assert.ok(track > deck.length / 3, `track is only ${track} of ${deck.length} cards`);
+    const counts = new Map<string, number>();
+    for (const c of deck) counts.set(c.kind.kind, (counts.get(c.kind.kind) ?? 0) + 1);
+    const track = counts.get('track') ?? 0;
+    for (const [kind, n] of counts) {
+      if (kind === 'track') continue;
+      assert.ok(track > n, `${kind} has ${n} cards against track's ${track}`);
+    }
+    const share = track / deck.length;
+    assert.ok(share > 0.28 && share < 0.45, `track is ${(share * 100).toFixed(1)}% of the deck`);
   });
 
   it('has 12 timetabled trains, odd westbound and even eastbound', () => {

test/sim.test.ts

@@ -191,15 +191,26 @@ describe('the revenue chain works end to end (regression)', () => {
     // only because unloads were mis-scored as completed loads after one Laborer action instead of
     // four. Correcting that dropped mean revenue from 24.8 to ~4.6 and the win rate to zero, so
     // "did anyone win" is no longer a safe proxy for "does freight work".
+    /**
+     * TWO HUNDRED GAMES, up from forty (Gitea#3). Completed freight loads got scarcer when the
+     * Mainline went onto the region model, and measurably so — on these seeds: 40 games yield 0
+     * loads, 80 yield 3 (1 game), 120 yield 10 (4 games), 200 yield 21 (9 games). Forty could no
+     * longer reach the precondition it exists to establish.
+     *
+     * WHY it got scarcer is not settled and is worth someone's attention rather than a guess — the
+     * change speeds crossings up, which ought to put MORE trains through a district, not fewer.
+     * Freight share of gross fell from 8% to 5% over 100 games across the same change. Recorded in
+     * TODO.md under Play Balance; the assertion itself is untouched.
+     */
     const report = simulate({
-      games: 40,
+      games: 200,
       length: 'standard',
       mode: 'solitaire',
       players: ['bot'],
       policy: developerBot,
     });
     const freight = report.perGame.reduce((n, g) => n + g.revenue.freightLoad, 0);
-    assert.ok(freight > 0, 'no freight load completed across 40 games');
+    assert.ok(freight > 0, 'no freight load completed across 200 games');
   });
 
   it('grows the Office Area off the Running Track, on either side', () => {
@@ -351,7 +362,32 @@ describe('end-of-game statistics', () => {
      * rule that has become unreachable. Exempted by name so the other forty-odd event checks stay live,
      * and so removing this line is what proves the bot has been fixed.
      */
-    const KNOWN_UNREACHABLE_BY_THE_BOT = ['event flyingSwitch'];
+    /**
+     * RED FLAGS JOINS IT, and the reason CHANGED with Gitea#19 — the exemption stays, but it no
+     * longer means what it used to.
+     *
+     * IT USED TO MEAN "the bot will not take it": measured over 600 games under the old rule,
+     * `maneuver.redFlags` was OFFERED 4,212 times and PLAYED 4. The card protected a stopped train
+     * out on the Mainline, it was always available, and the bot simply declined it.
+     *
+     * SINCE Gitea#19 the bot would take it every time — `worthFlagging` accepts the out-of-phase
+     * prompt unconditionally, because the engine only raises that prompt when an arrival is
+     * certainly about to collide, so there is nothing left for the bot to judge. It still never
+     * plays one. MEASURED after the redesign, 200 solitaire games: `redFlagsSet` fires ZERO times.
+     *
+     * The reason is now arithmetic rather than judgement, and it is worth writing down because it
+     * says what would actually change it. The prompt needs two things to coincide — an arrival that
+     * would collide (0.14 collisions per game, so roughly one game in seven) AND the district's
+     * owner holding a Red Flags card at that moment, out of a three-card hand drawn from 121. The
+     * bot also never plants a flag speculatively, which is the other half of the card and the half
+     * a human would use to buy time for switching.
+     *
+     * So this canary is measuring deck luck, not reachability. `test/mainline-cards.test.ts`
+     * exercises both halves of the rule end to end on a hand-built board, which is where the
+     * behaviour is actually pinned. Removing this line still proves something worth proving — that
+     * the bot has learned to plant a flag on purpose rather than only when handed one.
+     */
+    const KNOWN_UNREACHABLE_BY_THE_BOT = ['event flyingSwitch', 'event redFlagsSet'];
     const found = anomalies(report.perGame);
     const never = found
       .filter((a) => a.severity === 'never')
@@ -643,12 +679,17 @@ describe('the bot builds sidings that are actually sidings (regression)', () =>
     // Measured across 100 games: tank cars boarded a train 0.07 times a game and were dropped by a
     // crew ZERO times, while boxcars were 67% of every drop — and 23 of 79 waiting loads were
     // sitting at an industry that wanted a tank.
-    // A HUNDRED GAMES, not thirty — the comment above says the original measurement used 100, and
-    // the sample has to be that big to mean anything: measured now, a tank is set out in 3% of games
-    // and a reefer in 5%. Thirty games passed on luck and stopped the moment the opening deal moved
-    // which cards a seed puts in reach. Deterministic seeds, so this either holds or it does not.
+    // THREE HUNDRED GAMES, up from a hundred, because the sheet's industry density (Gitea#14) makes
+    // the rare commodities much rarer. Measured on these exact seeds, the game at which each type is
+    // first set out by a crew: caboose 5, boxcar 12, hopper 37, reefer 44, coach 64, **tank 216**.
+    //
+    // A Refinery is one card in a hundred and fifty now, so a tank moving at all needs that card
+    // drawn, placed, reached and worked. The old sample of 100 stopped covering it — not because the
+    // rule broke, but because the deck did what the sheet asks. The sample follows the measurement
+    // rather than the assertion being softened: tank is still the strict test, for the reason below.
+    // Deterministic seeds, so this either holds or it does not.
     const dropped = new Set<string>();
-    for (let i = 0; i < 100; i++) {
+    for (let i = 0; i < 300; i++) {
       const s = createGame({
         id: `cs-${i}`,
         seed: 1000 + i * 7919,
@@ -998,6 +1039,12 @@ describe('the bot does not lay track that cannot work (regression)', () => {
     // A TIE-BREAKER rather than a veto, so this is a rate and not a zero: forbidding it outright
     // measured WORSE (-0.62 revenue a game), while preferring the cleaner of two equally good
     // placements measured better and cut these from 28% of pieces to 7%.
+    //
+    // AND IT STAYS A TIE-BREAKER. Gitea#15 was filed as "track placements must connect" and briefly
+    // became a rule here; RAR reversed it on review (2026-08-26) — a rail may stop dead against its
+    // neighbour, and such a stub is useful as a siding to park cars on. What the engine must refuse
+    // is a TRAIN crossing the gap, which is `exploreMoves`' job and is tested in `track.test.ts`.
+    // So laying one of these is a preference, exactly as it was, and the rate below is the bar.
     let laid = 0;
     let dead = 0;
     /**
@@ -1094,8 +1141,14 @@ describe('the freight figures count both halves (regression)', () => {
      * The subject here is the INSTRUMENT — does `freightUnload` count Revenue earned rather than
      * unloads started — and `unloads > 0` is only the precondition that makes the comparison mean
      * anything. Widening the sample restores the precondition without weakening the assertion.
+     *
+     * A HUNDRED AND FIFTY DEALS, up from forty, for the same reason as the commodity test above:
+     * Gitea#14 put the deck on the sheet's industry density and completed unloads went with it.
+     * Measured on these seeds, the first deal to EARN unload Revenue is number **46**, and 19 deals
+     * in 400 earn any — so forty could not reach the precondition it exists to establish. 150 clears
+     * it with room, and the assertion itself is untouched.
      */
-    for (let i = 0; i < 40; i++) {
+    for (let i = 0; i < 150; i++) {
       const seed = 1000 + i * 7919;
       const s = createGame({
         id: `fu-${seed}`, seed,

test/step-queue.test.ts

@@ -0,0 +1,409 @@
+/**
+ * THE ANIMATION QUEUE — v0.8.0, `docs/plans/jitsi-common-board.md` § v0.8.0 §§ 5-6.
+ *
+ * Driven against REAL steps from a real game rather than hand-built fixtures, because the properties
+ * that matter are about what actual play produces: a bot's whole switching turn arriving in one
+ * burst, and a backlog that is mostly bookkeeping.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { legalActions } from '../src/engine/legal.ts';
+import type { GameConfig } from '../src/engine/state.ts';
+import { currentActor, newMultiplayerGame, submit } from '../src/web/game.ts';
+import { publicSnapshot } from '../src/sim/view.ts';
+import { takeSteps } from '../src/sim/display-step.ts';
+import type { DisplayStep } from '../src/sim/display-step.ts';
+import { actorOnScreen, createStepQueue } from '../src/web/step-queue.ts';
+import { DWELL } from '../src/sim/pacing.ts';
+
+const config: GameConfig = {
+  mode: 'competitive',
+  days: 5,
+  minCombinedRevenue: 0,
+  maxCollisionsPerDay: 0,
+  maxCollisionsTotal: 0,
+  pvpCardsAllowed: false,
+  optionalRules: {
+    reducedVisibility: false,
+    employeeRotation: false,
+    emergencyToolbox: false,
+  },
+};
+
+/**
+ * Plays a real game and returns its steps, preferring switch moves so a burst actually occurs.
+ *
+ * 400 moves, not 120: switching is not legal until there is track laid and a train in the district,
+ * and on this seed the first `switch.move` is at move 144. A shorter run produces a queue with no
+ * switching in it at all, which would make the pacing assertions here vacuous.
+ */
+function realSteps(seed: number, moves: number): { steps: DisplayStep[]; final: ReturnType<typeof publicSnapshot> } {
+  const game = newMultiplayerGame(seed, config, ['Alice', 'Bob', 'Carol']);
+  takeSteps(game.display);
+  const steps: DisplayStep[] = [];
+  for (let i = 0; i < moves; i++) {
+    const actor = currentActor(game);
+    if (actor === null) break;
+    const options = legalActions(game.state, actor);
+    if (options.length === 0) break;
+    const move = options.find((o) => o.type.startsWith('switch.') && o.type !== 'switch.end');
+    if (!submit(game, move ?? options.find((o) => o.type === 'localOps.choose') ?? options[0]!)) break;
+    steps.push(...takeSteps(game.display));
+  }
+  return { steps, final: publicSnapshot(game.state) };
+}
+
+/** The baseline a queue starts from, matching what a connect push carries. */
+function baseline(seed: number): ReturnType<typeof publicSnapshot> {
+  const game = newMultiplayerGame(seed, config, ['Alice', 'Bob', 'Carol']);
+  return publicSnapshot(game.state);
+}
+
+describe('the step queue', () => {
+  it('shows the whole burst in order and lands on the real board', () => {
+    const { steps, final } = realSteps(1917398, 400);
+    assert.ok(steps.length > 30, `only ${steps.length} steps — this proved little`);
+
+    const q = createStepQueue();
+    q.reset(baseline(1917398));
+    q.push(steps);
+
+    // Run a clock forward until it settles, in 50ms ticks like a render loop would.
+    let now = 0;
+    for (let i = 0; i < 20_000 && q.busy(); i++) {
+      q.advance(now);
+      now += 50;
+    }
+    assert.equal(q.busy(), false, 'the queue never drained');
+    assert.deepEqual(q.current(), final, 'the animated board did not land on the real one');
+    assert.equal(q.showing()?.seq, steps[steps.length - 1]!.seq, 'the caption is not on the last step');
+  });
+
+  it('a burst of switching takes real time, and bookkeeping takes none', () => {
+    const { steps } = realSteps(1917398, 400);
+    const q = createStepQueue();
+    q.reset(baseline(1917398));
+
+    // Only the bookkeeping: it must all collapse into a single advance.
+    // `.end` only: `localOps.choose` became an announcement worth watching after the first real play.
+    const bookkeeping = steps.filter((s) => s.cause.endsWith('.end'));
+    assert.ok(bookkeeping.length > 10, 'not enough bookkeeping steps to prove the collapse');
+    q.push(bookkeeping);
+    q.advance(0);
+    q.advance(0);
+    assert.equal(q.busy(), false, `${bookkeeping.length} bookkeeping steps should cost no time at all`);
+
+    // And switching: each one must hold the screen.
+    const switching = steps.filter((s) => s.cause.startsWith('switch.') && s.cause !== 'switch.end');
+    assert.ok(switching.length >= 6, `only ${switching.length} switching steps found`);
+    const q2 = createStepQueue();
+    q2.reset(baseline(1917398));
+    q2.push(switching.slice(0, 6));
+    q2.advance(0);
+    assert.equal(q2.behind(), 5, 'the first is shown at once; five are still to watch');
+    q2.advance(DWELL.switching - 1);
+    assert.equal(q2.behind(), 5, 'a switching move must not be replaced early');
+    q2.advance(DWELL.switching);
+    assert.equal(q2.behind(), 4, 'and must be replaced once its dwell is up');
+  });
+
+  /**
+   * PAUSE — Jesse, playtest 2026-09-16, asking for one beside Skip.
+   *
+   * The property that matters is not "it stops", which any flag gives you. It is that a hold COSTS
+   * THE STEP NOTHING: a move paused half-way through its dwell has to resume with half a dwell left,
+   * or pausing to look at something would punish you by throwing the rest of it away the moment you
+   * let go. That is the whole assertion below, measured against `DWELL.switching` rather than a
+   * hand-picked number so it follows the tuning table.
+   */
+  it('pause holds the board where it is, and resume gives the step back the dwell it had left', () => {
+    const { steps } = realSteps(1917398, 400);
+    const switching = steps.filter((s) => s.cause.startsWith('switch.') && s.cause !== 'switch.end');
+    assert.ok(switching.length >= 6, `only ${switching.length} switching steps found`);
+
+    const q = createStepQueue();
+    q.reset(baseline(1917398));
+    q.push(switching.slice(0, 6));
+    q.advance(0);
+    assert.equal(q.behind(), 5, 'the first is shown at once; five are still to watch');
+
+    // Held half-way through the first move's dwell, and left held for ten times that long.
+    const half = DWELL.switching / 2;
+    assert.equal(q.pause(half), true);
+    assert.equal(q.paused(), true);
+    const held = q.showing()?.seq;
+    q.advance(half + 10_000);
+    assert.equal(q.behind(), 5, 'a held queue consumed a step');
+    assert.equal(q.showing()?.seq, held, 'the board moved while it was supposed to be held');
+    assert.equal(q.busy(), true, 'a held queue must still read busy, or the render loop stops');
+
+    // Resumed, the move still owes exactly the half-dwell it had left — no more, and no less.
+    const at = half + 10_000;
+    assert.equal(q.resume(at), true);
+    assert.equal(q.paused(), false);
+    q.advance(at + half - 1);
+    assert.equal(q.behind(), 5, 'the step was robbed of time it was owed while held');
+    q.advance(at + half);
+    assert.equal(q.behind(), 4, 'and it never gave way once the rest of its dwell was up');
+  });
+
+  it('refuses to hold an idle queue, and Skip lifts a hold rather than leaving it stuck', () => {
+    const q = createStepQueue();
+    q.reset(baseline(1917398));
+    assert.equal(q.pause(0), false, 'an idle queue has no playback to hold');
+    assert.equal(q.paused(), false);
+
+    const { steps } = realSteps(1917398, 400);
+    q.push(steps);
+    q.advance(0);
+    assert.equal(q.pause(10), true);
+    assert.equal(q.skip(), true, 'Skip must still work while held');
+    assert.equal(q.paused(), false, 'Skip left the queue held, with a Resume that does nothing');
+    assert.equal(q.busy(), false);
+  });
+
+  it('counts only what will be watched, so the countdown is steady', () => {
+    // The counter's whole purpose: a backlog of mostly-bookkeeping must not read as a huge number
+    // that collapses the instant it starts.
+    const { steps } = realSteps(1917398, 400);
+    const q = createStepQueue();
+    q.reset(baseline(1917398));
+    q.push(steps);
+    const behind = q.behind();
+    assert.ok(behind > 0 && behind < steps.length, `behind ${behind} of ${steps.length} queued`);
+
+    q.advance(0);
+    let ticks = 0;
+    let previous = q.behind();
+    let now = 0;
+    while (q.busy() && ticks++ < 20_000) {
+      now += 50;
+      q.advance(now);
+      const nowBehind = q.behind();
+      assert.ok(nowBehind <= previous, 'the counter must never go up while draining');
+      previous = nowBehind;
+    }
+    assert.equal(q.behind(), 0);
+  });
+
+  it('skip jumps to the real board without losing a single state on the way', () => {
+    const { steps, final } = realSteps(1917398, 400);
+    const q = createStepQueue();
+    q.reset(baseline(1917398));
+    q.push(steps);
+    q.advance(0);
+
+    assert.equal(q.skip(), true, 'there was a backlog to skip');
+    assert.equal(q.busy(), false);
+    assert.equal(q.behind(), 0);
+    // Skip applies every delta rather than jumping the chain, so the board is exact.
+    assert.deepEqual(q.current(), final, 'skipping produced a board the game was never in');
+    assert.equal(q.skip(), false, 'skipping an empty queue changes nothing');
+  });
+
+  it('pace 0 turns animation off entirely — TODO #18', () => {
+    const { steps, final } = realSteps(1917398, 400);
+    const q = createStepQueue(() => 0);
+    q.reset(baseline(1917398));
+    q.push(steps);
+    // One advance at a single instant must consume everything: nothing dwells at all.
+    q.advance(0);
+    q.advance(0);
+    assert.equal(q.busy(), false, 'with animation off, nothing may be left waiting');
+    assert.equal(q.behind(), 0, 'nothing is "behind" when nothing is being animated');
+    assert.deepEqual(q.current(), final);
+  });
+
+  it('pace scales the wait without changing the order', () => {
+    const { steps } = realSteps(1917398, 400);
+    const switching = steps.filter((s) => s.cause.startsWith('switch.') && s.cause !== 'switch.end').slice(0, 3);
+    assert.equal(switching.length, 3);
+
+    const half = createStepQueue(() => 0.5);
+    half.reset(baseline(1917398));
+    half.push(switching);
+    half.advance(0);
+    half.advance(DWELL.switching / 2);
+    assert.equal(half.behind(), 1, 'at half pace, half the dwell should have advanced one step');
+  });
+
+  it('holds the LAST step of a burst for its dwell — the v0.8.0 snap-back bug', () => {
+    /**
+     * 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 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
+     * for as long as their move is being shown.
+     */
+    const { steps } = realSteps(1917398, 400);
+    const one = steps.filter((s) => s.cause === 'switch.move').slice(0, 1);
+    assert.equal(one.length, 1);
+
+    const q = createStepQueue();
+    q.reset(baseline(1917398));
+    q.push(one);
+
+    q.advance(0);
+    assert.equal(q.behind(), 0, 'nothing is queued behind it');
+    assert.equal(q.busy(), true, 'but it is still being shown, so the queue is not idle');
+
+    q.advance(DWELL.switching - 1);
+    assert.equal(q.busy(), true, 'still inside its dwell');
+
+    q.advance(DWELL.switching);
+    assert.equal(q.busy(), false, 'and idle only once its moment has passed');
+  });
+
+  it("does not spend time replaying the viewer's own moves", () => {
+    // A seated player's own board is drawn from their authoritative Frame, so they have already seen
+    // their own click. Holding it delays the thing they wanted to watch — a bot's turn.
+    const { steps } = realSteps(1917398, 400);
+    const mine = steps.filter((s) => s.player === 0 && s.cause === 'switch.move').slice(0, 3);
+    assert.equal(mine.length, 3, 'need three of seat 0\'s own moves');
+
+    const asSeat0 = createStepQueue(() => 1, () => 0);
+    asSeat0.reset(baseline(1917398));
+    asSeat0.push(mine);
+    // Twice at the same instant: the first call shows the head of the burst, the second collapses the
+    // zero-dwell run behind it. In the page that is two animation frames, ~16ms apart.
+    asSeat0.advance(0);
+    asSeat0.advance(0);
+    assert.equal(asSeat0.busy(), false, "the viewer's own moves must cost no time at all");
+    assert.equal(asSeat0.behind(), 0, 'and must never be counted as something to wait for');
+
+    // The same steps seen by somebody else are worth watching.
+    const asSpectator = createStepQueue(() => 1, () => 1);
+    asSpectator.reset(baseline(1917398));
+    asSpectator.push(mine);
+    asSpectator.advance(0);
+    assert.equal(asSpectator.busy(), true, "another seat's moves are worth showing");
+    assert.equal(asSpectator.behind(), 2);
+  });
+
+  it('a reset discards the backlog rather than merging it onto a new baseline', () => {
+    /**
+     * A reconnecting client holds steps whose deltas chain off a baseline the server has moved past.
+     * Merging them onto the new one would draw a board that never existed — and `applyPublicDelta`
+     * would throw the moment a "null means unchanged" field had nothing to merge onto.
+     */
+    const { steps, final } = realSteps(1917398, 400);
+    const q = createStepQueue();
+    q.reset(baseline(1917398));
+    q.push(steps.slice(0, 10));
+    q.advance(0);
+    assert.ok(q.busy());
+
+    q.reset(final);
+    assert.equal(q.busy(), false, 'a reset must empty the queue');
+    assert.equal(q.behind(), 0);
+    assert.deepEqual(q.current(), final);
+    // And the caption survives: a reconnect should not blank the "what just happened" line.
+    assert.ok(q.showing() !== null, 'the caption should survive a reset');
+  });
+
+  it('can always be emptied, so a player is never stranded behind it', () => {
+    /**
+     * "Your Move" is put away while the board is catching up (v0.8.0.6), which makes `busy()` the
+     * thing standing between a player and their own turn. So the ways it can be cleared matter more
+     * than they did: `skip()` must always work, from any state, including one where the clock has
+     * never advanced — which is exactly the situation a page with no `requestAnimationFrame` is in,
+     * and how this was found.
+     */
+    const { steps, final } = realSteps(1917398, 400);
+    const q = createStepQueue();
+    q.reset(baseline(1917398));
+    q.push(steps);
+    // Never advanced at all: no frame has been shown, and the queue is full.
+    assert.equal(q.busy(), true);
+    assert.equal(q.skip(), true, 'a never-advanced queue must still be skippable');
+    assert.equal(q.busy(), false, 'and must be idle afterwards, or the player stays locked out');
+    assert.deepEqual(q.current(), final);
+  });
+
+  it('draws nothing before a reset has arrived', () => {
+    const q = createStepQueue();
+    assert.equal(q.current(), null);
+    assert.equal(q.advance(0), false);
+    assert.equal(q.behind(), 0);
+    assert.equal(q.showing(), null);
+  });
+});
+
+describe('whose move the screen is showing (Gitea#25)', () => {
+  const step = (player: number | null) => ({ player }) as DisplayStep;
+  const queue = (behind: number, busy: boolean, showing: DisplayStep | null) => ({
+    behind: () => behind,
+    busy: () => busy,
+    showing: () => showing,
+  });
+
+  it('names the live actor once the board has caught up', () => {
+    assert.deepEqual(actorOnScreen(queue(0, false, step(2)), 0), { actor: 0, replaying: false });
+  });
+
+  it('names the player of the step on screen while the board is behind — not the live actor', () => {
+    // One human (seat 0) against bots: the live game already waits on seat 0 while bot 2's moves replay.
+    assert.deepEqual(actorOnScreen(queue(3, true, step(2)), 0), { actor: 2, replaying: true });
+  });
+
+  it('keeps naming the last step while it is still on screen, after the counter reaches zero', () => {
+    assert.deepEqual(actorOnScreen(queue(0, true, step(1)), 0), { actor: 1, replaying: true });
+  });
+
+  it('names nobody for an automatic phase being shown', () => {
+    assert.deepEqual(actorOnScreen(queue(2, true, step(null)), 0), { actor: null, replaying: true });
+  });
+
+  it('falls back to the live actor before any step has been shown', () => {
+    assert.deepEqual(actorOnScreen(queue(1, true, null), 3), { actor: 3, replaying: false });
+  });
+});
+
+describe('the log is held back with the board, and a changed card flashes (playtest, 2026-09-15)', () => {
+  it('owes exactly the lines of the steps not yet shown', () => {
+    const { steps } = realSteps(1917398, 400);
+    const q = createStepQueue();
+    q.reset(baseline(1917398));
+    assert.equal(q.pendingLines(), 0, 'an empty queue holds nothing back');
+
+    q.push(steps);
+    const owed = steps.reduce((n, s) => n + s.lines.length, 0);
+    assert.equal(q.pendingLines(), owed, 'every queued step still owes its lines');
+
+    // Drive the clock as a render loop would; the debt falls monotonically and ends at nothing.
+    let now = 0;
+    let last = owed;
+    for (let i = 0; i < 20_000 && q.busy(); i++) {
+      q.advance(now);
+      const left = q.pendingLines();
+      assert.ok(left <= last, 'the held-back count grew while the board caught up');
+      last = left;
+      now += 50;
+    }
+    assert.equal(q.pendingLines(), 0, 'the board caught up but lines were still withheld');
+  });
+
+  it('skipping reveals the whole log at once', () => {
+    const { steps } = realSteps(1917398, 400);
+    const q = createStepQueue();
+    q.reset(baseline(1917398));
+    q.push(steps);
+    q.skip();
+    assert.equal(q.pendingLines(), 0, 'Skip left lines withheld — the history would stay short');
+  });
+
+  it('flashes nothing on an ordinary step', () => {
+    // Realignment is rare in bot play, so this pins the quiet case: the map must not pulse at random.
+    const { steps } = realSteps(1917398, 400);
+    const q = createStepQueue();
+    q.reset(baseline(1917398));
+    q.push(steps.slice(0, 5));
+    q.advance(0);
+    assert.deepEqual(q.flashing(), [], 'a step that changed no Mainline card flashed one');
+  });
+});

test/switch-planner.test.ts

@@ -0,0 +1,100 @@
+/**
+ * The switching planner (`sim/switch-planner.ts`) — the two properties it cannot be allowed to lose.
+ *
+ * 1. PLANNING TOUCHES NOTHING. The planner applies intents to a partial copy of the game
+ *    (`forkForSwitching`) that shares everything a switching intent is not supposed to write. If a
+ *    reducer ever starts writing somewhere new, the copy leaks into the real game, and this is where
+ *    that shows: the game is serialised before and after planning and must not have changed.
+ * 2. A PLAN IS WHAT THE ENGINE WILL DO. Every step replays through `applyIntent` on a FULL copy, and
+ *    lands on the fingerprint the planner promised for it. That is what makes the partial copy
+ *    trustworthy, and it is what the bot relies on to know it is still on plan.
+ *
+ * Taken from real seeded bot games rather than hand-built positions, because a district that
+ * satisfies the track geometry by hand tests the builder as much as the planner.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { pump } from '../src/engine/advance.ts';
+import { applyIntent } from '../src/engine/apply.ts';
+import { legalActions, legalSwitchingActions } from '../src/engine/legal.ts';
+import {
+  DEFAULT_MAX_COLLISIONS_PER_DAY,
+  DEFAULT_MAX_COLLISIONS_TOTAL,
+  MOVES_PER_LOCAL_OPS,
+  collectiveRevenueFloor,
+  lengthProfile,
+} from '../src/engine/content.ts';
+import { createGame } from '../src/engine/setup.ts';
+import type { GameConfig, GameState } from '../src/engine/state.ts';
+import { actingPlayer, turnOf } from '../src/engine/state.ts';
+import { developerBot, playGame } from '../src/sim/bot.ts';
+import { planSwitchingTurn, switchFingerprint } from '../src/sim/switch-planner.ts';
+
+const config = (): GameConfig => {
+  const days = lengthProfile('short').days;
+  return {
+    mode: 'solitaire',
+    days,
+    minCombinedRevenue: collectiveRevenueFloor(1, days),
+    maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
+    maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
+    pvpCardsAllowed: false,
+    optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
+  };
+};
+
+const serialise = (s: GameState): string =>
+  JSON.stringify(s, (_k, v) => (v instanceof Map ? [...v] : v instanceof Set ? [...v] : v));
+
+describe('switching planner', () => {
+  it('asks for switching intents that are exactly the switching subset of legalActions, in order', () => {
+    const SWITCHING = new Set(['switch.move', 'switch.dropCars', 'switch.sortConsist', 'maneuver.flyingSwitch', 'switch.end']);
+    let compared = 0;
+    for (const seed of [1000, 8919]) {
+      const s = createGame({ id: `legal-${seed}`, seed, config: config(), playerNames: ['bot'] });
+      playGame(s, developerBot, pump, 50_000, undefined, (st) => {
+        const p = actingPlayer(st);
+        if (p === null || st.clock.phase !== 'localOps') return;
+        const all = legalActions(st, p).filter((i) => SWITCHING.has(i.type));
+        assert.deepEqual(legalSwitchingActions(st, p), all);
+        compared++;
+      });
+    }
+    assert.ok(compared > 0, 'no Local Operations decision was reached');
+  });
+
+  it('never changes the game it plans for, and every plan replays to the position it promised', () => {
+    let checked = 0;
+    let withSteps = 0;
+    for (const seed of [1000, 8919, 16838]) {
+      const s = createGame({ id: `plan-${seed}`, seed, config: config(), playerNames: ['bot'] });
+      const r = playGame(s, developerBot, pump, 50_000, undefined, (st) => {
+        const p = actingPlayer(st);
+        if (p === null || st.clock.phase !== 'localOps') return;
+        const turn = turnOf(st, p);
+        if (turn.option !== 'switch' || turn.movesRemaining !== MOVES_PER_LOCAL_OPS) return;
+
+        const before = serialise(st);
+        const plan = planSwitchingTurn(st, p, { budget: 400, beam: 16 });
+        assert.equal(serialise(st), before, `seed ${seed}: planning wrote into the real game`);
+        assert.ok(plan.score >= plan.rootScore, 'a plan is never worse than stopping where the crew stands');
+
+        const copy = structuredClone(st);
+        plan.steps.forEach((step, n) => {
+          assert.equal(switchFingerprint(copy, p), plan.keys[n], `seed ${seed}: step ${n} started off plan`);
+          const applied = applyIntent(copy, p, step);
+          assert.ok(applied.ok, `seed ${seed}: step ${n} (${step.type}) was refused by the engine`);
+        });
+        assert.equal(switchFingerprint(copy, p), plan.keys.at(-1), `seed ${seed}: the plan did not end where it said`);
+
+        checked++;
+        if (plan.steps.length > 0) withSteps++;
+      });
+      assert.ok(r.finished, `seed ${seed}: a game with the planner switched on did not finish`);
+    }
+    assert.ok(checked > 0, 'no switching turn was reached, so nothing was tested');
+    assert.ok(withSteps > 0, 'every plan was empty, so replay was never exercised');
+  });
+});

test/tally.test.ts

@@ -0,0 +1,218 @@
+/**
+ * THE EVENT TALLY — Gitea#16's statistics, and the one property they depend on.
+ *
+ * "I don't know if we keep statistics on…" is the question the issue opens with. Nothing was being
+ * kept; `GameState.tally` now is, folded from the event stream at the two places every event passes
+ * through (`engine/tally.ts` explains which and why).
+ *
+ * The property that matters is EXACTLY ONCE. A statistic folded twice reads high and a statistic
+ * folded nowhere reads zero, and both are indistinguishable from a quiet game when you are looking
+ * at a results screen. So the central test here does not assert particular numbers: it plays real
+ * games, collects every event the engine emitted along the way, counts them independently, and
+ * checks the tally against that count. A fold hooked in the wrong place fails it whatever the seed.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { advance } from '../src/engine/advance.ts';
+import { tallyEvent } from '../src/engine/tally.ts';
+import { applyIntent } from '../src/engine/apply.ts';
+import { STAGES_PER_DAY } from '../src/engine/content.ts';
+import { legalActions } from '../src/engine/legal.ts';
+import { createGame } from '../src/engine/setup.ts';
+import { developerBot } from '../src/sim/bot.ts';
+import type { GameEvent } from '../src/engine/events.ts';
+import type { GameConfig, GameState } from '../src/engine/state.ts';
+
+const baseConfig = (over: Partial<GameConfig> = {}): GameConfig => ({
+  mode: 'solitaire',
+  days: 3,
+  minCombinedRevenue: 0,
+  maxCollisionsPerDay: 0,
+  maxCollisionsTotal: 0,
+  pvpCardsAllowed: false,
+  optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
+  ...over,
+});
+
+/** Plays a whole game with the developer bot, keeping every event the engine produced. */
+function playKeepingEvents(
+  seed: number,
+  over: Partial<GameConfig> = {},
+  names = ['Jesse'],
+): { state: GameState; events: GameEvent[] } {
+  const state = createGame({ id: 'g', seed, config: baseConfig(over), playerNames: names });
+  const events: GameEvent[] = [];
+  for (let i = 0; i < 20_000; i++) {
+    const r = advance(state);
+    events.push(...r.events);
+    if (state.status === 'finished') break;
+    if (!r.needsInput) continue;
+
+    // The bot declines an extension, so this terminates on the timetable it was dealt (Gitea#11).
+    const actor =
+      state.status === 'awaitingExtension'
+        ? state.extensionVotes.findIndex((v) => v === null)
+        : state.clock.pendingDecision !== null
+          ? state.clock.superintendent
+          : state.clock.currentActor;
+    if (actor === null || actor < 0) break;
+    const options = legalActions(state, actor);
+    if (options.length === 0) break;
+    const applied = applyIntent(state, actor, developerBot.choose(state, actor, options));
+    if (!applied.ok) break;
+    events.push(...applied.events);
+  }
+  return { state, events };
+}
+
+/** Counts events the way `tally.ts` should have, without sharing any of its code. */
+function countIndependently(events: GameEvent[]) {
+  let sum = 0;
+  const n = (type: GameEvent['type']): number => events.filter((e) => e.type === type).length;
+  for (const e of events) {
+    if (e.type === 'carsCoupled' || e.type === 'carsDropped') sum += e.stock.length;
+  }
+  return {
+    trainsCompleted: n('trainCompleted'),
+    loadsCompleted: n('loadCompleted'),
+    unloadsCompleted: n('unloadCompleted'),
+    loadsStarted: n('loadStarted'),
+    unloadsBegun: n('unloadBegan'),
+    passengersBoarded: n('passengersBoarded'),
+    passengersDetrained: n('passengersDetrained'),
+    cardsDrawn: n('cardDrawn'),
+    cardsPlayed: n('cardPlayed'),
+    cardsDiscarded: n('cardDiscarded'),
+    officeUpgrades: n('officeUpgraded'),
+    flyingSwitches: n('flyingSwitch'),
+    extrasStarted: n('extraStarted'),
+    secondSections: n('secondSectionOrdered'),
+    trainsHeld: n('trainHeld'),
+    trainsDiverted: n('trainDiverted'),
+    expediteFaults: n('expediteFault'),
+    facilitiesUnjammed: n('facilityUnjammed'),
+    dispatchBonusesUsed: n('dispatchBonusUsed'),
+    clearancesRequested: n('clearanceRequested'),
+    switchedCars: sum,
+  };
+}
+
+describe('the tally counts every event exactly once (Gitea#16)', () => {
+  for (const seed of [1, 7, 42, 116956197]) {
+    it(`agrees with an independent count of the event stream — seed ${seed}`, () => {
+      const { state, events } = playKeepingEvents(seed);
+      const want = countIndependently(events);
+      const t = state.tally;
+
+      assert.equal(t.trainsCompleted, want.trainsCompleted, 'trains through the Division');
+      assert.equal(t.loadsCompleted, want.loadsCompleted, 'loads made up');
+      assert.equal(t.unloadsCompleted, want.unloadsCompleted, 'loads broken');
+      assert.equal(t.loadsStarted, want.loadsStarted, 'loads started');
+      assert.equal(t.unloadsBegun, want.unloadsBegun, 'unloads begun');
+      assert.equal(t.passengersBoarded, want.passengersBoarded, 'passengers boarded');
+      assert.equal(t.passengersDetrained, want.passengersDetrained, 'passengers detrained');
+      assert.equal(t.cardsDrawn, want.cardsDrawn, 'cards drawn');
+      assert.equal(t.cardsPlayed, want.cardsPlayed, 'cards played');
+      assert.equal(t.cardsDiscarded, want.cardsDiscarded, 'cards discarded');
+      assert.equal(t.officeUpgrades, want.officeUpgrades, 'offices upgraded');
+      assert.equal(t.flyingSwitches, want.flyingSwitches, 'flying switches');
+      assert.equal(t.extrasStarted, want.extrasStarted, 'extras started');
+      assert.equal(t.secondSections, want.secondSections, 'second sections');
+      assert.equal(t.trainsHeld, want.trainsHeld, 'trains held');
+      assert.equal(t.trainsDiverted, want.trainsDiverted, 'trains diverted');
+      assert.equal(t.expediteFaults, want.expediteFaults, 'expedite faults');
+      assert.equal(t.facilitiesUnjammed, want.facilitiesUnjammed, 'facilities unjammed');
+      assert.equal(t.dispatchBonusesUsed, want.dispatchBonusesUsed, 'dispatch bonuses');
+      assert.equal(t.clearancesRequested, want.clearancesRequested, 'clearances requested');
+      assert.equal(t.carsCoupled + t.carsDropped, want.switchedCars, 'cars switched');
+    });
+  }
+
+  it('actually counted something — a tally of zeroes would pass the check above vacuously', () => {
+    // The trap `stats.ts` warns about in its own doc comment: "this never happened" is a finding,
+    // not something to scroll past. A fold hooked nowhere at all agrees perfectly with an
+    // independent count of an event stream nobody looked at, so the exactly-once tests above cannot
+    // catch it on their own.
+    //
+    // ASSERTED ON WHAT THE DEVELOPER BOT ACTUALLY DOES, which is not much: `node src/sim/harness.ts
+    // 12 standard` means 1.1 Revenue per game at an 8% freight share and loses every game on the
+    // revenue floor, and it goes whole games without coupling a single car. That is a known
+    // property of the bot (TODO.md, Bot Performance) and not this fold's business — so this test
+    // asserts on traffic and cards, which happen in every game, rather than on switching, which
+    // would make it a bot-strength test wearing a statistics test's clothes.
+    const { state, events } = playKeepingEvents(1);
+    assert.ok(events.length > 500, `only ${events.length} events — the game barely ran`);
+    assert.ok(state.tally.cardsDrawn > 0, 'no cards were drawn all game');
+    assert.ok(state.tally.trainsCompleted > 0, 'no train ever left the Division');
+    assert.ok(state.tally.cardsPlayed > 0, 'no card was ever played');
+  });
+
+  it('splits Revenue into what was earned and what was given back', () => {
+    // Reconciliation is the real assertion and it holds for any game, earned or not: gained minus
+    // lost IS the score the engine kept. Seed 44 is named because it is one where Revenue actually
+    // moves in both directions — it earns 1 and gives back 5 to a collision — so the two halves are
+    // being told apart rather than both sitting at zero.
+    //
+    // It was seed 42 until v0.8.0.10. That game's collision was the Superintendent holding a train over
+    // one BEHIND it (Gitea#26); with the ruling gone the collision is too, and seed 42 now earns 5 and
+    // loses nothing — a better game and a vacuous test. The seed moved, not the assertion.
+    for (const seed of [1, 7, 44]) {
+      const { state } = playKeepingEvents(seed);
+      const me = state.tally.byPlayer[0]!;
+      assert.equal(
+        me.revenueGained - me.revenueLost,
+        state.players[0]!.revenue,
+        `seed ${seed}: gained minus lost does not reconcile with the score the engine kept`,
+      );
+    }
+    const { state } = playKeepingEvents(44);
+    const me = state.tally.byPlayer[0]!;
+    assert.ok(me.revenueGained > 0, 'seed 44 earned nothing — the gained half is not being counted');
+    assert.ok(me.revenueLost > 0, 'seed 44 lost nothing — the lost half is not being counted');
+  });
+
+  it('records a Circus set-up as the one-off it is, not as a streak', () => {
+    /**
+     * `trainStoodStill` is NOT "this train did not move this Stage". It fires only for a train whose
+     * profile sets `stopEarnsPoint` — the X18 Circus — and `advance.ts` claims it once per train
+     * with `stopPointClaimed`, so it can never fire twice for the same one.
+     *
+     * Gitea#16 asks for "longest engine sat on a siding" and its comment assumed this event would
+     * answer it. It cannot, and a streak folded from it would have read "1 Stage" for ever. Pinned
+     * here so that the day a real per-Stage signal is added, whoever adds it finds this test rather
+     * than the old wrong assumption.
+     */
+    const s = createGame({ id: 'g', seed: 1, config: baseConfig(), playerNames: ['Jesse'] });
+    const feed = (e: GameEvent): void => tallyEvent(s, e);
+    feed({ type: 'trainStoodStill', trainNumber: 18, where: '(0,0)' });
+    assert.deepEqual(s.tally.circusStops, [{ trainNumber: 18, where: '(0,0)' }]);
+    assert.ok(!('longestStand' in s.tally), 'a streak that cannot be computed is being reported');
+  });
+});
+
+describe('the official result freezes the tally with it (Gitea#11 + #16)', () => {
+  it('records the statistics as they stood when the timetable ran out', () => {
+    const { state } = playKeepingEvents(1);
+    assert.ok(state.official, 'no official result was recorded');
+    // Nothing was played after the ending in this game, so the two agree — which is the check that
+    // the freeze happens AFTER the last batch of events is folded rather than before it.
+    assert.equal(state.official!.tally.trainsCompleted, state.tally.trainsCompleted);
+    assert.ok(state.official!.tally.cardsDrawn > 0, 'the frozen tally is empty');
+  });
+
+  it('keeps the frozen copy still while the live tally moves on', () => {
+    const s = createGame({ id: 'g', seed: 1, config: baseConfig(), playerNames: ['Jesse'] });
+    s.clock.day = s.config.days + 1;
+    s.clock.stage = STAGES_PER_DAY;
+    s.clock.phase = 'shiftChange';
+    advance(s);
+    const frozen = s.official!.tally.cardsDrawn;
+
+    applyIntent(s, 0, { type: 'game.extend', player: 0, agree: true });
+    tallyEvent(s, { type: 'cardDrawn', player: 0, source: 'homeOffice', cardId: 'x' });
+    assert.equal(s.tally.cardsDrawn, frozen + 1, 'the live tally did not move');
+    assert.equal(s.official!.tally.cardsDrawn, frozen, 'the frozen tally moved with it');
+  });
+});

test/track.test.ts

@@ -540,6 +540,100 @@ describe('placement and drop-off', () => {
     assert.ok(!canPlaceAt(area, at(-1, 1), straight()), 'an east-west straight cannot meet a 45° leg');
   });
 
+  describe('a rail that stops dead against its neighbour (Gitea#15)', () => {
+    /**
+     * REPORTED, THEN REVERSED. The issue first read "if a card is placed in that space, it MUST
+     * connect", against a right-hand curve laid at (1,-1) with an Ice House above it and a turnout
+     * with a north-facing leg below. **RAR reviewed it and ruled the other way (2026-08-26): the
+     * placement is fine, and a stub like that has a use — a siding to park cars on.**
+     *
+     * "We need to confirm, however, that trains are not allowed to traverse from the turnout below
+     * to that right-hand curve since the tracks do not connect." That is what these tests are: the
+     * rule lives in MOVEMENT, not in placement.
+     *
+     * The save cannot carry this any more — Gitea#14 took the deck from 206 cards to 121, so its
+     * card ids no longer exist and the history stops at the first `card.play`. The geometry is what
+     * mattered, and it is rebuilt here directly.
+     */
+    /** A Modifier card — an Ice House. Not track: no ports on any edge. */
+    const modifierCard = (): TrackCard => ({
+      geometry: { kind: 'modifier', modifier: 'iceHouse' },
+      baseOperationalRail: false,
+      standing: [],
+      standingWest: 0,
+      facility: null,
+      modifiers: [],
+      enhancements: [],
+    });
+
+    /** A Grocer's Warehouse — a Facility, so a plain east-west through track. */
+    const warehouse = (): TrackCard => ({
+      geometry: { kind: 'facility', facility: 'grocersWarehouse' },
+      baseOperationalRail: true,
+      standing: [],
+      standingWest: 0,
+      facility: null,
+      modifiers: [],
+      enhancements: [],
+    });
+
+    /**
+     * The reported district. `withCurve` puts the disputed right-hand curve on the square; without
+     * it, the square is empty and the placement itself is under test.
+     *
+     * The turnout's leg goes NORTH on the `nw_se` diagonal; the curve is `ne`, which is `ne_sw` and
+     * has no south port at all. Two reasons the two do not join, either of which is enough.
+     */
+    const board = (withCurve: boolean): OfficeArea =>
+      areaFrom(
+        {
+          [coordKey(at(0, -1))]: turnout({ stem: 'w', through: 'e', diverge: 'n' }),
+          [coordKey(at(0, 0))]: officeCard(),
+          [coordKey(at(1, 0))]: warehouse(),
+          [coordKey(at(2, -1))]: modifierCard(),
+          ...(withCurve ? { [coordKey(at(1, -1))]: curve('ne') } : {}),
+        },
+        at(0, 0),
+      );
+
+    it('allows the reported placement, which connects on one side and nothing else', () => {
+      // RAR's ruling. The curve joins the warehouse to its east; its north leg faces an Ice House
+      // that carries no rail, and the turnout below faces its portless south edge. All legal.
+      assert.ok(canPlaceAt(board(false), at(1, -1), curve('ne')), 'the reported play was refused');
+    });
+
+    it('will not let a train cross from the turnout below onto that curve', () => {
+      // The confirmation the issue actually asks for. Running west out of the Office and into the
+      // turnout, the 45° leg goes north — and stops at the curve's blank south edge.
+      const dests = reachableDestinations(ctxFor(board(true)), at(0, 0), 'w');
+      assert.ok(!has(dests, 1, -1), 'a train drove across rails that do not meet');
+    });
+
+    it('still reaches the curve from the side that DOES join', () => {
+      // Otherwise the test above would pass on a card that is simply unreachable, which proves
+      // nothing. East of the curve is the warehouse, and east-west edges always meet.
+      const dests = reachableDestinations(ctxFor(board(true)), at(1, 0), 'w');
+      assert.ok(has(dests, 1, -1), 'the curve was unreachable from the side that joins');
+    });
+
+    it('will not let a train cross a north edge onto a card with no rail at all', () => {
+      // The Ice House above. A Modifier is scenery beside the rails — Jesse confirmed a rail may
+      // point at a building — so what stops a train is the same `joins` test, not a placement rule.
+      const dests = reachableDestinations(ctxFor(board(true)), at(1, 0), 'w');
+      assert.ok(!has(dests, 2, -1), 'a train drove into an Ice House');
+    });
+
+    it('still allows an exit that faces a BLANK square', () => {
+      // Unchanged by the reversal, and the reason a district can grow at all: a turnout laid on the
+      // Running Track with nothing yet beside its diverging leg is a perfectly good play.
+      const area = areaFrom({ [coordKey(at(0, 0))]: officeCard() }, at(0, 0));
+      assert.ok(
+        canPlaceAt(area, at(0, 1), turnout({ stem: 'w', through: 'e', diverge: 'n' })),
+        'a turnout whose leg faces open space was refused',
+      );
+    });
+  });
+
   it('refuses a card that connects to nothing', () => {
     const area = areaFrom({ [coordKey(at(0, 0))]: officeCard() }, at(0, 0));
     assert.ok(!canPlaceAt(area, at(3, 3), straight()), 'orphaned track is never legal');

test/watchable.test.ts

@@ -0,0 +1,406 @@
+/**
+ * THE WATCHABLE TABLE — v0.8.0, Gitea#20 / TODO #13, #15, #18.
+ *
+ * One shared, ordered presentation of everyone else's turns, on a seated player's own screen. The
+ * design is `docs/plans/jitsi-common-board.md` § v0.8.0; this file is its tests.
+ *
+ * Starting with ATTRIBUTION, because the caption row and the history panel both read these lines
+ * and a line that does not say who acted is useless on a screen built to answer "what did they
+ * just do?".
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { applyIntent } from '../src/engine/apply.ts';
+import { legalActions } from '../src/engine/legal.ts';
+import type { GameConfig, PlayerIndex } from '../src/engine/state.ts';
+import { fromMultiplayerSave, newGame, newMultiplayerGame, submit } from '../src/web/game.ts';
+import { currentActor } from '../src/web/game.ts';
+import { applyPublicDelta } from '../src/sim/public-delta.ts';
+import { publicSnapshot } from '../src/sim/view.ts';
+import type { PublicFrame } from '../src/sim/view.ts';
+import { takeSteps } from '../src/sim/display-step.ts';
+import { createSession } from '../src/server/session.ts';
+import { kindOf } from '../src/sim/pacing.ts';
+
+const config: GameConfig = {
+  mode: 'competitive',
+  days: 5,
+  minCombinedRevenue: 0,
+  maxCollisionsPerDay: 0,
+  maxCollisionsTotal: 0,
+  pvpCardsAllowed: false,
+  optionalRules: {
+    reducedVisibility: false,
+    employeeRotation: false,
+    emergencyToolbox: false,
+  },
+};
+
+/**
+ * The four events a switching turn is made of. Every one of them used to arrive in the shared log
+ * unattributed: `record()` (`web/game.ts`) prefixes a line with the player's name only when the
+ * event itself carries `player`, and these four were the only events in their class that did not
+ * — `cardDrawn`, `cardPlayed`, `cardDiscarded`, `carPlacedOnTrain`, `loadStarted`, `loadCompleted`,
+ * `flyingSwitch` and `localOpsOptionChosen` all did. So a switching turn read as an attributed
+ * bracket around anonymous contents:
+ *
+ *     Player Alice chose to switch            ← attributed
+ *     CREW moved (1,2) → (1,3) — 4 of 6       ← whose train?
+ *     Player Alice finished Local Operations  ← attributed
+ *
+ * Measured 2026-09-09 and fixed with the feature that reads them, not filed.
+ */
+const SWITCHING_EVENTS = ['trayMoved', 'carsCoupled', 'carsDropped', 'consistSorted'] as const;
+
+/** How each of those four reads in the log, so the assertions can find them by text. */
+const SWITCHING_LINE = /^Player .+ (moved (Train |the local crew)|coupled \d+ car|set out |used the SMALL YARD)/;
+
+describe('switching is attributed — TODO #13', () => {
+  it('every switching event carries the player who acted', () => {
+    /**
+     * Driven by PREFERRING switch moves rather than taking the first legal action, because bot
+     * switching is clustered rather than spread: two of the three published replays contain no
+     * `switch.move` at all, so a game driven by `options[0]` can finish without ever exercising
+     * this. The counter below then guards against the test passing vacuously.
+     */
+    let seen = 0;
+    for (const seed of [1917398, 191056, 4242]) {
+      const game = newMultiplayerGame(seed, config, ['Alice', 'Bob', 'Carol']);
+      for (let i = 0; i < 800; i++) {
+        const actor = currentActor(game);
+        if (actor === null) break;
+        const options = legalActions(game.state, actor);
+        if (options.length === 0) break;
+        const move = options.find((o) => o.type.startsWith('switch.') && o.type !== 'switch.end');
+        const chosen = move ?? options.find((o) => o.type === 'localOps.choose') ?? options[0]!;
+
+        // Read the events this intent produces before applying it for real, so the assertion sees
+        // exactly what `record()` will be handed.
+        const preview = applyIntent(structuredClone(game.state), actor, chosen);
+        if (preview.ok) {
+          for (const e of preview.events) {
+            if ((SWITCHING_EVENTS as readonly string[]).includes(e.type)) {
+              assert.ok(
+                'player' in e,
+                `${e.type} carries no player, so the log cannot say whose crew it was`,
+              );
+              assert.equal(
+                (e as { player: PlayerIndex }).player,
+                actor,
+                `${e.type} names the wrong player`,
+              );
+              seen++;
+            }
+          }
+        }
+        if (!submit(game, chosen)) break;
+      }
+    }
+    assert.ok(seen > 0, 'no switching event was produced, so this test proved nothing');
+  });
+
+  it('reads as a player action in the log, not as anonymous plain text', () => {
+    let lines = 0;
+    for (const seed of [1917398, 4242]) {
+      const game = newMultiplayerGame(seed, config, ['Alice', 'Bob', 'Carol']);
+      for (let i = 0; i < 800; i++) {
+        const actor = currentActor(game);
+        if (actor === null) break;
+        const options = legalActions(game.state, actor);
+        if (options.length === 0) break;
+        const move = options.find((o) => o.type.startsWith('switch.') && o.type !== 'switch.end');
+        if (!submit(game, move ?? options.find((o) => o.type === 'localOps.choose') ?? options[0]!)) break;
+      }
+
+      for (const line of game.log) {
+        // The old wording. `uncapitalise` deliberately leaves an acronym alone (`^[A-Z][a-z]` only),
+        // so "CREW moved" and "SMALL YARD —" would have survived the prefix and read as
+        // "Player Alice CREW moved …". Both were reworded to compose.
+        assert.doesNotMatch(
+          line.text,
+          /^CREW moved|^SMALL YARD —/,
+          `an unattributed switching line survived: ${line.text}`,
+        );
+        if (SWITCHING_LINE.test(line.text)) {
+          assert.equal(line.tone, 'act', `a switching line must read as somebody's move: ${line.text}`);
+          lines++;
+        }
+      }
+    }
+    assert.ok(lines > 0, 'no switching line reached the log, so this test proved nothing');
+  });
+});
+
+describe('the display-step collector — TODO #13', () => {
+  it('emits one step per accepted intent plus one per automatic phase, in order', () => {
+    const game = newMultiplayerGame(1917398, config, ['Alice', 'Bob', 'Carol']);
+    let accepted = 0;
+    for (let i = 0; i < 120; i++) {
+      const actor = currentActor(game);
+      if (actor === null) break;
+      const options = legalActions(game.state, actor);
+      if (options.length === 0) break;
+      const move = options.find((o) => o.type.startsWith('switch.') && o.type !== 'switch.end');
+      if (!submit(game, move ?? options.find((o) => o.type === 'localOps.choose') ?? options[0]!)) break;
+      accepted++;
+    }
+    assert.ok(accepted > 30, `only ${accepted} intents accepted — this proved little`);
+
+    const steps = takeSteps(game.display);
+    /**
+     * TWO KINDS OF STEP SINCE TODO #18: one per accepted intent, and one per automatic phase that
+     * did anything. So the count is no longer `accepted` — but every intent must still have exactly
+     * one step, which is the invariant that matters.
+     */
+    const byIntent = steps.filter((s) => s.cause !== 'phase');
+    const byPhase = steps.filter((s) => s.cause === 'phase');
+    assert.equal(byIntent.length, accepted, 'one step per accepted intent, no more and no fewer');
+    assert.ok(byPhase.length > 0, 'no phase produced a step — TODO #18 is not being served');
+    steps.forEach((s, i) => {
+      assert.equal(s.seq, i, 'sequence numbers must be dense and in order');
+      assert.equal(s.protocolVersion, 1);
+      assert.ok(kindOf(s.cause), `step ${i} carries a cause pacing cannot classify`);
+      // A phase is nobody's move; an intent is always somebody's.
+      assert.equal(s.player === null, s.cause === 'phase', `step ${i} disagrees about who acted`);
+      assert.equal(s.seat === null, s.cause === 'phase');
+    });
+    assert.equal(takeSteps(game.display).length, 0, 'draining must empty the collector');
+  });
+
+  it('a rejected intent produces no step', () => {
+    const game = newMultiplayerGame(4242, config, ['Alice', 'Bob', 'Carol']);
+    takeSteps(game.display);
+    // Somebody else's turn: refused before the engine is touched, so nothing to present.
+    const notMyTurn = ((currentActor(game) ?? 0) + 1) % 3;
+    assert.equal(submit(game, { type: 'draw.end' }, notMyTurn as PlayerIndex), false);
+    assert.equal(takeSteps(game.display).length, 0, 'a refused intent must not be presented');
+  });
+
+  it('the step deltas reconstruct the public board exactly', () => {
+    const game = newMultiplayerGame(1917398, config, ['Alice', 'Bob', 'Carol']);
+    let held: PublicFrame | null = null;
+    for (let i = 0; i < 150; i++) {
+      const actor = currentActor(game);
+      if (actor === null) break;
+      const options = legalActions(game.state, actor);
+      if (options.length === 0) break;
+      const move = options.find((o) => o.type.startsWith('switch.') && o.type !== 'switch.end');
+      if (!submit(game, move ?? options.find((o) => o.type === 'localOps.choose') ?? options[0]!)) break;
+      for (const s of takeSteps(game.display)) held = applyPublicDelta(held, s.frame);
+    }
+    assert.deepEqual(held, publicSnapshot(game.state), 'the animated board drifted from the real one');
+  });
+
+  /**
+   * THE PROPERTY THAT IS CURRENTLY FREE AND MUST STAY THAT WAY.
+   *
+   * `fromSave`/`fromMultiplayerSave` rebuild a game with `applyIntent` + `record` + `drain` rather
+   * than `submit`, so a resumed server does not re-emit the whole game as steps and burn the
+   * sequence. The plan expected this to need an explicit guard. It does not — but move a replay
+   * path onto `submit()` and it silently becomes a real bug, which is why this is pinned.
+   */
+  it('replaying a save emits no steps at all', () => {
+    const game = newMultiplayerGame(1917398, config, ['Alice', 'Bob', 'Carol']);
+    for (let i = 0; i < 80; i++) {
+      const actor = currentActor(game);
+      if (actor === null) break;
+      const options = legalActions(game.state, actor);
+      if (options.length === 0) break;
+      if (!submit(game, options[0]!)) break;
+    }
+    assert.ok(game.history.length > 20, 'need a real history to replay');
+
+    const rebuilt = fromMultiplayerSave(game.seed, config, ['Alice', 'Bob', 'Carol'], game.history);
+    assert.equal(
+      rebuilt.game.display.steps.length,
+      0,
+      'a replay re-emitted the whole game as display steps',
+    );
+    assert.equal(rebuilt.game.display.seq, 0, 'a replay burned display sequence numbers');
+  });
+
+  it('solitaire collects the same way multiplayer does', () => {
+    // The standing design direction: solitaire is a special case of multiplayer, not a second
+    // implementation. Both go through one `submit()`, so this needs no separate code path — and
+    // that is exactly what makes TODO #18 fall out of TODO #13's mechanism.
+    const game = newGame(4242);
+    let accepted = 0;
+    for (let i = 0; i < 60; i++) {
+      const actor = currentActor(game);
+      if (actor === null) break;
+      const options = legalActions(game.state, actor);
+      if (options.length === 0) break;
+      if (!submit(game, options[0]!)) break;
+      accepted++;
+    }
+    assert.ok(accepted > 10, 'the solitaire game did not get going');
+    const collected = takeSteps(game.display);
+    assert.equal(
+      collected.filter((s) => s.cause !== 'phase').length,
+      accepted,
+      'solitaire must collect a step per intent too',
+    );
+    // And solitaire is where TODO #18 lives — its phases must earn beats on the same path.
+    assert.ok(collected.some((s) => s.cause === 'phase'), 'solitaire got no phase steps');
+  });
+});
+
+describe('steps reach a seated player — TODO #13', () => {
+  it('never replays the opening bot turns at the first client to connect', () => {
+    /**
+     * `buildSession` runs `driveBotTurns()` at construction, so with bots ahead of you in the order
+     * the game has already moved before anybody can connect. Those steps must be DROPPED, not
+     * queued: a connecting client's `publicReset` is the board as it stands after those very moves,
+     * so replaying them onto it would draw positions the game had already left.
+     *
+     * Found by review 2026-09-09 rather than by a failing test, which is why this one exists.
+     */
+    const session = createSession(1917398, config, ['Alice', 'Bob', 'Carol'], [1, 2]);
+    const push = session.connect(0 as PlayerIndex);
+    assert.ok(push.publicReset, 'a connecting client needs a baseline');
+    assert.equal(push.steps, undefined, 'the connect push must carry no steps at all');
+
+    // And the first real broadcast must carry only what THIS move produced — nothing older.
+    const option = push.menu?.options[0];
+    assert.ok(option, 'seat 0 should have something to do');
+    const r = session.intent(0 as PlayerIndex, 1, option);
+    assert.ok(r.accepted);
+    const steps = [...r.pushes.values()][0]?.steps ?? [];
+    assert.ok(steps.length > 0, 'the move produced no steps');
+    /**
+     * The first step delivered must be THIS seat's move — not a bot's, which is what a replayed
+     * opening turn would look like. The sequence does NOT restart at 0: `takeSteps` empties the
+     * collector without rewinding the counter, so the first thing a client sees may be seq 14. That
+     * is fine and deliberate — what 0.8.1's gap detection needs is monotonic and dense, not
+     * zero-based.
+     */
+    assert.equal(steps[0]!.player, 0, 'the first delivered step was not the move just made');
+    assert.equal(steps[0]!.cause, option.type);
+    steps.forEach((st, i) => {
+      if (i > 0) assert.equal(st.seq, steps[i - 1]!.seq + 1, 'sequence must stay dense');
+    });
+  });
+
+
+  it('every seat gets the same public steps, and a connect gets a baseline to merge onto', () => {
+    const session = createSession(1917398, config, ['Alice', 'Bob', 'Carol'], [1, 2]);
+
+    const connected = session.connect(0 as PlayerIndex);
+    assert.ok(connected.publicReset, 'a connecting client needs a baseline for its step queue');
+
+    let seen = 0;
+    for (let i = 0; i < 60; i++) {
+      const menu = session.connect(0 as PlayerIndex).menu;
+      const option = menu?.options[0];
+      if (!option) break;
+      const r = session.intent(0 as PlayerIndex, i, option);
+      if (!r.accepted) break;
+      const pushes = [...r.pushes.values()];
+      if (pushes.length === 0) continue;
+      const first = pushes[0]!.steps ?? [];
+      if (first.length === 0) continue;
+      seen += first.length;
+      for (const p of pushes) {
+        assert.deepEqual(p.steps, first, 'every seat must receive the identical public steps');
+      }
+    }
+    assert.ok(seen > 0, 'no steps reached a push, so this proved nothing');
+  });
+});
+
+describe('the Fedora passing is visible (playtest 2026-09-16)', () => {
+  it('names the new Superintendent in the history at the Stage it happens', async () => {
+    const { newMultiplayerGame, currentActor, submit } = await import('../src/web/game.ts');
+    const { legalActions } = await import('../src/engine/legal.ts');
+
+    /**
+     * It used to ride on `actorChanged`, which `record()` drops as turn bookkeeping — so the one
+     * moment that event meant something never reached a player. Driven far enough to cross a shift
+     * boundary (Stages 3, 6, 9, 12) rather than asserted on a hand-built event, because the point is
+     * that a real game produces the line.
+     */
+    const game = newMultiplayerGame(1917398, config, ['Alice', 'Bob', 'Carol']);
+    for (let i = 0; i < 900; i++) {
+      const actor = currentActor(game);
+      if (actor === null) break;
+      const options = legalActions(game.state, actor);
+      if (options.length === 0) break;
+      if (!submit(game, options.find((o) => o.type === 'localOps.choose') ?? options[0]!)) break;
+      if (game.state.clock.stage > 3 || game.state.clock.day > 1) break;
+    }
+
+    const handover = game.log.filter((l) => /SUPERINTENDENT — the Fedora passes to/.test(l.text));
+    assert.ok(handover.length > 0, 'the game crossed a shift change and the log never said so');
+    assert.match(handover[0]!.text, /Alice|Bob|Carol/, 'the handover did not name the new Superintendent');
+  });
+});
+
+describe('the log says who acted, once, and in what capacity (Gitea#30, #31)', () => {
+  it('never names a player twice — no "Player Jesse player 0 finished …"', async () => {
+    const { newMultiplayerGame, currentActor, submit } = await import('../src/web/game.ts');
+    const { legalActions } = await import('../src/engine/legal.ts');
+
+    const game = newMultiplayerGame(1917398, config, ['Alice', 'Bob', 'Carol']);
+    for (let i = 0; i < 400; i++) {
+      const actor = currentActor(game);
+      if (actor === null) break;
+      const options = legalActions(game.state, actor);
+      if (options.length === 0) break;
+      if (!submit(game, options.find((o) => o.type === 'localOps.choose') ?? options[0]!)) break;
+    }
+
+    assert.ok(game.log.length > 50, 'the game barely ran, so this proved little');
+    for (const line of game.log) {
+      // `record()` prefixes the acting player's NAME; a narration that also named them read
+      // "Player Alice player 0 finished Local Operations" (playtest, 2026-09-15).
+      assert.doesNotMatch(
+        line.text,
+        /\bplayer \d+\b/i,
+        `a line still carries a bare player index: ${line.text}`,
+      );
+    }
+  });
+
+  it('attributes a clearance ruling to the office, not to the seat\'s own turn', async () => {
+    const { newMultiplayerGame, drain, submit } = await import('../src/web/game.ts');
+    const { areaOf } = await import('../src/engine/apply.ts');
+
+    const game = newMultiplayerGame(7, config, ['Alice', 'Bob', 'Carol']);
+    const s = game.state;
+    const area = areaOf(s, 0);
+
+    // A westbound train at seat 0's Office, and another westbound AHEAD of it — west of the Office —
+    // which is §8.1's fourth condition and the Superintendent's to rule on (see Gitea#26).
+    s.trays.set('departing', {
+      id: 'departing', trainNumber: 15, trainIsExtra: true, engineAt: 0, consist: [],
+      direction: 'west', facing: 'w',
+      position: { at: 'grid', seat: 0, coord: area.officeCoord }, movesUsed: 0,
+    } as never);
+    area.adOccupancy.push('departing');
+    const office = s.division.nodes.findIndex((n) => n.kind === 'office' && n.seat === 0);
+    const card = s.division.nodes.findIndex((n, i) => i < office && n.kind === 'mainline');
+    const node = s.division.nodes[card];
+    assert.equal(node?.kind, 'mainline');
+    s.trays.set('ahead', {
+      id: 'ahead', trainNumber: 9, trainIsExtra: false, engineAt: 0, consist: [],
+      direction: 'west', facing: 'w', position: { at: 'mainline', index: card }, movesUsed: 0,
+    } as never);
+    if (node?.kind === 'mainline') {
+      node.transits.push({ tray: 'ahead', stagesRemaining: 2, stagesTotal: 2, direction: 'west' });
+    }
+
+    s.clock.phase = 'mainline';
+    drain(game);
+    assert.equal(s.clock.pendingDecision?.kind, 'clearance', 'no ruling was called for, so nothing was tested');
+
+    const before = game.log.length;
+    assert.ok(submit(game, { type: 'mainline.clearance', allow: false }, s.clock.superintendent));
+    const said = game.log.slice(before).map((l) => l.text);
+    assert.ok(
+      said.some((text) => text.startsWith('Superintendent Player ')),
+      `a ruling did not read as the office's: ${said.join(' | ')}`,
+    );
+  });
+});