v0.7.0 — four game types, a lobby you can read and leave, and a multiplayer game that makes a sound

The multiplayer set-up, the lobby, the start of a game, and four signals a remote client had never
been sent. Reasoning, the preset table and what was verified how: CHANGELOG.md.

- Co-op, Competitive, Cutthroat, Solitaire and Custom, on both screens, from one shared block —
  they had drifted, and each was missing a question the other asked.
- A player reads the whole rule set before taking a seat, may leave a lobby or a running game, and
  keeps a seat across a reload. The host may clear a chair. The browser remembers every game it is
  in, not just the last one.
- The start of a game is drawn: a handoff beat, an announcement, the code and type in the header.
- Sound, the timetable flash, announcements and the just-drawn badge now reach a remote client;
  justDrawn goes to the seat that drew it and nobody else.
- Played on StartOS, which found the rest: an Extra belongs to the player who played it, the board
  never named the Superintendent, bot seats were reported as absent players, and rule section
  numbers are out of every string a player reads.

Also carries the previous session's Heavy Grade documentation work — asked again, answer unchanged.

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

.gitignore

@@ -41,3 +41,12 @@ __pycache__/
 # website's replay viewer. It was therefore never committed, and a fresh clone was missing a page
 # the build copies unconditionally. Only the throwaway files this directory collects are ignored.
 /replay*.html
+
+# Playtest saves — somebody's game, attached to a bug report.
+#
+# ANCHORED, and with the README exempted: the directory has to exist and say what it is for, while
+# nothing that lands in it is ever committed. A save is a seed plus the moves made, it belongs to
+# whoever sent it, and it goes stale the moment the rules move. `public/replays/` is the place for
+# one that is worth publishing.
+/playtests/*
+!/playtests/README.md

CHANGELOG.md

@@ -19,6 +19,250 @@ page as `v0.1.0 · <sha> · <date>`, so what is deployed can always be identifie
 
 ---
 
+## 0.7.0 — 2026-08-23
+
+The multiplayer set-up, the lobby, the start of a game, and four things a remote client had never
+been shown. Jesse's cleanup pass, worked area by area with the design settled before any code was
+written.
+
+### Four game types, and Custom
+
+The lobby used to offer two modes and a folded block of numbers; the New Game dialog offered three
+modes that only *previewed* defaults. Both now offer the same five: **Solitaire, Co-op, Competitive,
+Cutthroat** and **Custom**.
+
+A type is a **set of defaults, not a ruleset**. Picking one fills the whole form; every rule stays
+editable; editing any of them selects **Custom**, which keeps the scoring of the type it was edited
+away from and says so on screen ("Custom — scored as Co-op · 3 settings differ from Co-op"). Clicking
+a named type again resets every rule below the radios.
+
+| | Solitaire | Co-op | Competitive | Cutthroat |
+| --- | --- | --- | --- | --- |
+| Scored as | solitaire | coop | competitive | competitive |
+| Opening hand | six | six | six | six |
+| An Extra may start at | any Control Point | your own | your own | **any player's** |
+| Passenger / freight / transit | 1 / 1 / 0 | 1 / 1 / **1** | 1 / 1 / 0 | 1 / 1 / 0 |
+| Combined Revenue floor | 3 × players × Days | 3 × players × Days | 2 × players × Days | **off** |
+| Collisions in one Day | 3 | 3 | 3 | 3 |
+| Collisions in the game | 5 | 5 | 5 | **off** |
+
+**The floor is a formula, not a number**, which is why the seed, the table size and the Day count sit
+ABOVE the type radios as *parameters*: changing one re-derives the floor rather than making the game
+Custom, so "Co-op, 3 players, 8 days" is still Co-op. Once a host types a floor themselves it is
+theirs and nothing overwrites it.
+
+**The type is derived, never stored** (`presetOf`, `src/web/presets.ts`). A saved game is its numbers;
+a name written beside them is one more thing that can disagree with them. A join preview measures a
+Custom game against the nearest type it is scored as, so "Custom" alone is never all a player is told.
+
+**Every field says what its type would have set**, and goes amber when it differs — a non-standard
+game should be possible and never accidental.
+
+### The two screens stopped drifting apart
+
+They each carried a hand-written copy of the same form, and had already diverged in both directions:
+
+- **The lobby had no "where an Extra may start" at all**, so every multiplayer game ever played used
+  the most permissive setting — an Extra could be planted in another player's district — and no host
+  was ever asked. It is a Cutthroat-only default now.
+- **The solitaire dialog had none of the three optional rules**, so Employee Rotation and the
+  Emergency Toolbox could not be played solo at all. They ride in the URL with everything else now
+  (`vis`, `rot`, `tool`), and Employee Rotation is disabled at a table of one, where it has no
+  meaning.
+
+Both blocks are generated from one template and driven by one module (`src/web/settings-form.ts`);
+`test/web.test.ts` asserts the built page carries every field on both screens, which is the guard the
+shared markup was for.
+
+### The dead PvP checkbox is gone
+
+`buildDeck` ANDs `pvpCardsAllowed` with a hard-coded `cardsImplemented = false`, so the checkbox
+could not change anything whatever it was set to — on either screen. The 22 opponent-directed cards
+(and the 7 defensive cards held out with them) are a property of the game type now, and where the
+control was there is a sentence saying they are not implemented yet.
+
+### Victory conditions lost the magic zero
+
+`0` means "off" to the engine, which is exact and unreadable: a Cutthroat game showed two zeroes and
+left the player to know the convention. Each condition is a checkbox with its number now, and the
+wording says what actually happens — *"The game ends and everyone loses if collisions in one Day
+reach 3"*. Unchecked still writes `0`, so nothing underneath changed.
+
+### The lobby
+
+- **Joining is its own door**, not a heading below fifteen fields a joiner has no use for.
+- **A player reads the whole rule set before taking a seat** — `GET /api/lobby/preview`, gated by the
+  same join secret, taking no seat, and **never carrying the seed**, which decides every shuffle.
+- **A seat survives a reload.** The token used to live in a closure and reach `localStorage` only at
+  `Lobby.Start`, so refreshing while seated orphaned the chair: the player could not return and
+  nobody could free it, on a table that cannot start until every chair is taken. The record is
+  written at create/join with a `stage`, and a reload walks `/api/session` then the lobby stream to
+  land wherever the seat actually is.
+- **There is a way out.** `POST /api/lobby/leave` frees a seat; naming somebody else's is host-only,
+  which is the host's *remove*; the last human leaving deletes the lobby, its code and its index row
+  rather than leaving a table of bots waiting for a host who no longer exists.
+- **The lobby stream can fail out loud.** `onmessage` was the only handler, so a dropped connection
+  left the seating screen frozen and silent. It now says so, and its probe tells a blip from a dead
+  lobby — and finds a game that *started* while the connection was down.
+- **A stored join secret collapses to one line** and re-opens itself on a 403, beside the field it is
+  about.
+- **Two players may not share a display name** (`NAME_TAKEN`, trimmed and case-insensitive). The name
+  labels the district on the map, is what the turn chart means by "waiting on Jesse", and prefixes
+  every line that player causes; the names lock at `Lobby.Start`, so the refusal has to be at the
+  door. Refused rather than suffixed: a player should play under the name they chose.
+- **Bots are numbered in the seating list** the way `startLobby` will number them.
+- **The code copies as a code and as an invite link** (`?lobby&code=…`) — the link never carries the
+  join secret, which travels out of band by design.
+- **Server codes became sentences** in a red block instead of `.dim` grey: `LOBBY_FULL` was being
+  printed at players verbatim.
+- **Everyone at the table can see what they are about to play**, not just the host who typed it.
+
+### The start of a game, which nobody had ever drawn
+
+`beginRemote` wrote "… connecting to the game" into `#presence` — the DISCONNECT banner — and it
+worked only because the first render overwrote it. The handoff is its own state now: a curtain with a
+deliberate beat, a stall message if the board never arrives, then an announcement naming the game and
+its type, and a marker at the top of the log so the bots' opening turns are visibly *after* the start
+rather than merged into it. The **game code and the game type are in the header** for the rest of the
+game — the code used to end at the lobby door, and the type was never on the `Frame` at all, so a
+Cutthroat game looked exactly like a Co-op one from the board. Start cannot be pressed twice.
+
+### A client is told who else is at the table
+
+`/api/stream`'s connect push carried the board, the menu and the log — and nothing about anybody
+else. `broadcastPresence` only ever reports a CHANGE, so a player learnt of a seat only if it dropped
+*after* they connected: at a table where two people had not opened the game yet, the screen said
+nothing at all. Every other seat now rides on the connect push, with `seen` separating **was here and
+dropped** from **has never opened the game** — the first will probably be back, the second needs
+somebody sent a link.
+
+### The four transient signals reach multiplayer
+
+`createRemoteSession` answered all four with empty values, so a game on a server had **no sound at
+all**, no flash on the timetable slot a D12 had just filled, no announcement when a completed run
+paid the table, and no badge on the card you had just drawn. All four ride on the push now.
+
+The shared three (cues, the flash, the announcement) are drained once per broadcast and are identical
+in every seat's push — a collision anywhere on the Division, the Stage bell and a train leaving the
+Division are the table's, not one player's. `justDrawn` is **not** shared: `game.justDrawn` is one
+field for the whole game and does not say whose card it is, so the server remembers who drew and
+sends it to that seat alone. A reconnect gets the badge back but none of the shared three: a fresh
+connection is drawing a state, and replaying the sounds of everything it missed is a burst of noise
+about the past.
+
+Draining them also fixed a slow leak nothing had noticed: `game.cues` grew without bound on a server,
+because the only thing that ever emptied it was a local session's render.
+
+### Two smaller fixes found on the way
+
+- **Undo re-dealt a game under the wrong victory conditions.** `undo(game)` defaulted its config to
+  `SOLO_CONFIG`, and `Save` carries only the house rules — so undoing a move in an eight-Day game
+  replayed it as a five-Day one, with the Revenue floor and both collision caps reverting too. It
+  defaults to the game's own config now.
+- **The page deals the Solitaire game type, not the engine's fallback.** Every type opens with six
+  cards (Jesse's call), but `SOLO_CONFIG` deliberately did not move: every engine test and every sim
+  measurement is taken against it. What a player is dealt when they open the page is the type.
+
+### Verified by running it, not by reading it
+
+A real server, a real lobby and a real game — which is where two of these came from:
+
+- **A bot seat was being reported as a disconnected player.** Every screen would have carried
+  "waiting on Bot 1 — not here yet" for the whole game. Bots hold no connection and never will, so
+  they are not reported at all.
+- **The six-card opening survives a table with bots in it.** A three-seat game (two humans, one bot)
+  played through Day 1 without stalling on the discard round the six-card deal creates — the risk
+  worth checking before making six the default everywhere.
+
+Also exercised end to end: preview before joining (and its 403/404s), the duplicate-name refusal,
+leave freeing a seat, a non-host being refused somebody else's chair, the last human closing the
+lobby down to its index row, and every one of the four signals arriving at two seats at once.
+
+`test/presets.test.ts` pins the numbers in the table above, `test/server/session.test.ts` pins the
+`justDrawn` boundary, `test/server/lobby.test.ts` covers leaving and the name rule, and
+`test/web.test.ts` gained a suite for the lobby screen, which had none at all.
+
+### Found by playing it on StartOS, and fixed in the same release
+
+Everything above was written before the build went on a box. These came out of Jesse playing it:
+
+- **An Extra belongs to the player who played it.** §7 gives an Extra to whoever played the card —
+  they place the Crew Tray and load the consist as they choose — while a TIMETABLED train's consist
+  is built by the table, starting at the Superintendent and working left. `pendingExtras` was a bare
+  `number[]`, so nothing recorded whose Extra it was and the phase asked whoever the acting order
+  happened to be on: right in solitaire, wrong at every table. It carries the player now, the tray
+  remembers who is building it (`builtBy`), and another seat is refused with `NOT_YOUR_EXTRA` and is
+  not even offered a start point. **No migration**: a save is a seed plus intents, so a `GameState`
+  shape change costs nothing.
+- **The board never named the Superintendent.** Reported as "seat 1 played a train card BUT seat 2
+  was prompted to build the train — what's the rule?" The engine was right; the screen simply never
+  said who held the Fedora, so the question had no answer on it. `Frame` has carried `superintendent`
+  since v0.4.0 and only the standalone replay ever drew it. It is a chip on the turn chart now,
+  shared by all three screens and hidden in solitaire, and the New Train pill's tooltip says who
+  builds a consist rather than only what the phase does.
+- **A player can leave a running game**, keeping their seat and their token, and the lobby lists
+  every game the browser is in with Rejoin and Forget. This fixes something worse than what was
+  asked for: `localStorage` held exactly ONE session, so joining a second game overwrote the first
+  token and locked that seat out permanently — `TODO.md` had it as the nearer half of the lost-token
+  problem. Leaving closes the SSE stream too, so the table sees the seat go quiet instead of being
+  told somebody is present who is not.
+- **`?lobby` now beats resuming.** The splash's multiplayer door and an invite link both mean "I want
+  to pick a game", but a remembered session was checked first — so anyone already in a game was
+  dropped straight back into it and could never reach the lobby from the door. A bare load still
+  resumes.
+- **The create form is two columns**, the lobby is 1040px rather than 640px wide, and Game settings
+  spans both columns when it opens with its five groups flowing into as many columns as fit — it
+  used to open inside one column and leave the other standing empty down a very long scroll.
+- **"Every chair has to be taken" moved** next to the table size it explains, from below the rules
+  block.
+- **A disabled game type now looks disabled** — the row dims and says why. A bare `disabled` on a
+  radio leaves the label at full strength and reads as a broken control.
+- **Rule section numbers are out of every string a player reads** — 22 of them, across the page copy,
+  the turn chart, the narration, the panels and the bot's own explanation line. "§6.2 — you may not
+  end a turn holding more than three cards" is now "You may not end a turn holding more than three
+  cards". The sentences still state the rule; they no longer cite a number that a rewrite will
+  invalidate. Code comments keep their references, which is where they are useful.
+
+Two more findings went into `TODO.md` rather than into code, at Jesse's direction: the Division map
+draws no track geometry at all (a turnout is pixel-identical to the straight it replaced — the whole
+visible change is a caption), and the map's buffer stops and direction go wrong once the route wraps
+through the lanes. All three are one drawing pass with the items already queued there.
+
+### Also in this commit: Heavy Grade orientation, asked again and unchanged
+
+Uncommitted documentation work from the previous session, carried in here rather than left in the
+tree. "Did we ever fix Heavy Grade to allow user placement of direction?" was raised a second time,
+with the option of giving the choice to the **Superintendent** considered and rejected: the advantage
+is permanent and the office rotates every three Stages, so a rotating chooser moves the fairness
+problem rather than solving it. v0.5.0 stands — the orientation is rolled from the seed.
+
+**The docs were the real defect.** `README.md` listed it among three open rules questions, all three
+of which v0.5.0 had closed, and the Mainline deck reference said the implementation "needs a player
+-selection step". Both corrected, the reasoning recorded in `docs/rules/implications.md` §10 Q11 so
+it is not asked a third time, and `content.ts`/`setup.ts` gained comments saying which half of the
+printed card is deliberately overridden and why. No code change, and none wanted.
+
+### Housekeeping
+
+`playtests/` is a gitignored home for save files that arrive with a bug report, with a committed
+README saying what goes there and how to open one (the replay viewer takes a file straight off
+disk). `package-lock.json`'s version had been stuck at 0.5.0 since that release — only
+`package.json` was ever bumped — and now matches.
+
+**`undo()` defaulted its config to `SOLO_CONFIG`** (noted above), and while confirming that, one more
+came out of the same corner: nothing was draining `game.cues` on a server, so it grew without bound
+for the life of a game. Draining it per broadcast is what makes multiplayer sound work and fixes that
+at the same time.
+
+### Not done here
+
+The visual rendering of the new screens was not looked at in a browser while it was being written —
+headless Firefox could not start on this box, so everything was verified by test and by driving the
+real server. It has since been played on StartOS, which is where the fixes in the section above came
+from; the Division map items it also turned up are in `TODO.md` rather than in this release.
+
+---
+
 ## 0.6.3 — 2026-08-23
 
 The deploy script only. No rules change, no game change, and the built site is byte-for-byte what

README.md

@@ -10,29 +10,48 @@ train into an occupied Subdivision. Get that wrong and two trains meet at speed.
 
 ## Status
 
-**v0.4.8 — solitaire is playable in a browser.** The whole game runs client-side: the engine is pure,
-imports nothing outside itself, and never touches `Math.random`, so a static host is all it needs.
+**Solitaire is playable in a browser and multiplayer runs against a server.** The solitaire game runs
+entirely client-side — the engine is pure, imports nothing outside itself, and never touches
+`Math.random`, so a static host is all it needs. Multiplayer adds an authoritative server for the
+seats a shared game requires.
 
-- **Rules** — specified, with **three open questions** left. Thirteen gaps in the original prototype
-  rules were found and closed; three more came after, and are in `TODO.md`: where the Local's coach
-  stands while its engine works (a §A.4 question), Poling — the one card in the deck with no defined
-  behaviour — and whether a Heavy Grade's orientation is rolled or chosen at setup.
+The current version is in [`package.json`](package.json), and every page stamps it with the commit
+and build date, so what is deployed can always be identified from the page itself. This section
+deliberately no longer names one: it went stale for six releases.
+
+- **Rules** — specified. Thirteen gaps in the original prototype rules were found and closed, and the
+  three that came after were all settled in v0.5.0: a coach may be set out at the Office (§A.4),
+  Poling stays out of the deck at zero copies since the source records its effect only as "TBD", and
+  **a Heavy Grade's orientation is rolled from the seed, never chosen by a player** — see
+  [`docs/rules/implications.md`](docs/rules/implications.md) §10 for each ruling and its reasoning.
 - **Card faces** — every card's printed values specified.
 - **Architecture** — seven documents, including a 20-component build plan and the multiplayer plan.
-- **Code** — the engine, the bot, the balance harness, the replay viewer and the playable page. A
-  game can be saved, shared, replayed and stepped back through.
-- **Not built** — the multiplayer server (Phases 0 and 1 of the plan are done: seat and player are
-  separate, turn state is per player, and the page talks to a `Session` rather than to the engine, so
-  a remote one drops in without the page changing — but there is no server, no turn submission and no
-  per-player push), the 22 opponent-directed cards, and real audio.
+- **Code** — the engine, the bot, the balance harness, the replay viewer, the playable page, and the
+  server. A game can be saved, shared, replayed and stepped back through.
+- **Multiplayer — built and running.** `src/server/` serves a lobby (create, join, preview, leave,
+  add a bot, start, and a stream), turn submission, per-session state and persistence, with its own
+  tests under `test/server/`. Games survive a release rather than being destroyed by one. A player
+  weighing a join reads the **whole rule set before taking a seat**; a seat survives a browser
+  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
+  session token still locks someone out of a running game from a genuinely fresh browser.
+- **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
+  toggle could not do anything, so both screens state the fact in words instead.
 
-Balance is *not* where it should be: the developer bot averaged 7.0 Revenue against a target of 20 —
-of which ~5.4 was the "one Revenue per train that completes its run" rule, so the working freight and
-passenger economy is still only ~2. That rule is now a **setting that defaults to off**, along with
-the passenger and freight rates and the opening hand, so the economy can be read on its own and the
-alternatives can be played rather than argued about. Nothing in this file or in `TODO.md` has been
-re-measured at the new defaults; `TODO.md` says why, and says which of it is the bot and which is the
-deck.
+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**.
+
+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
+read on its own and the alternatives played rather than argued about. Run
+`node src/sim/harness.ts 400 standard` for today's number rather than trusting one written here;
+`TODO.md` says which of the gap is the bot and which is the deck.
 
 Versions follow the convention at the top of [`CHANGELOG.md`](CHANGELOG.md): third digit for fixes,
 second for a set of features, 1.0 for the first release that deserves the name.
@@ -46,14 +65,18 @@ station-master/
 ├── docs/
 │   ├── rules/          ← the ruleset, card reference, glossary, decision record
 │   ├── architecture/   ← how it is built, and what the pieces are
+│   ├── plans/          ← worked plans for a single change, kept for the reasoning
 │   └── design/         ← board layout studies and rendering samples
-├── public/replays/     ← saved games published to the site's replay directory
+├── public/
+│   ├── replays/        ← saved games published to the site's replay directory
+│   └── images/         ← art the build copies into the site
 ├── scripts/            ← build and deploy the static site
 ├── src/
 │   ├── engine/         ← pure rules engine: no I/O, no clock, deterministic from a seed
+│   ├── server/         ← the authoritative multiplayer server: lobby, sessions, persistence
 │   ├── sim/            ← bot, harness, replay, board rendering
-│   └── web/            ← the playable site: splash, game, replay viewer
-└── test/
+│   └── web/            ← the playable site: splash, game, lobby, replay viewer
+└── test/               ← including test/server/ for the server's own suite
 ```
 
 Start with [`docs/design.md`](docs/design.md) — it indexes everything. Commit messages stay high
@@ -62,7 +85,9 @@ level; [`CHANGELOG.md`](CHANGELOG.md) carries the reasoning and the measurements
 
 ## Development
 
-Requires **Node 22.18+**, which runs TypeScript directly by type stripping. There is no build step.
+Requires **Node 22.18+**, which runs TypeScript directly by type stripping — so there is no compile
+step, and the engine, the bot and the tests all run straight from source. (`npm run build:web` is a
+separate thing: it assembles the static SITE into `dist/`.)
 
 ```sh
 npm install
@@ -104,16 +129,30 @@ is the thing this machinery exists to prevent.
   `fromSave` replays it exactly — that one property gives save, share, undo, restart recovery and
   post-game replay. Events are a DERIVED stream: they narrate what happened and drive the display,
   and they do not reconstruct the position. The phase driver mutates state and then describes it, so
-  fourteen of the forty-six event types are never reduced. Anything that needs to rebuild a game
+  roughly a third of the event types are never reduced at all. Anything that needs to rebuild a game
   replays the intents.
 - **Never call `Math.random()`.** One ambient random call silently breaks replay.
-- **Track is a deck card, but the opening district is dealt.** 96 of the 235 cards are track — the
-  largest category — so a district is built from what you draw, and building it costs you the
-  industry or train you drew instead. The opening hand is the exception, and it is now **chosen when
-  the game is dealt**: three random cards (the default, and the prototype rule), six random cards, or
-  three track and three other from two separately shuffled piles. The last of those is the only one
-  that guarantees you a district to build; deal six and you open over the limit of three, so the
-  first turn is spent choosing. See `TODO.md`.
+- **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
+  of them selects **Custom**, which keeps the scoring of the type it came from. The type is *derived*
+  from the numbers rather than stored, so a saved game carries no name that can disagree with what it
+  actually is. Both screens that deal a game — the lobby and the New Game dialog — ask the same
+  eleven questions through one shared block (`src/web/settings-form.ts`), because for two releases
+  they each had a question the other lacked. What separates the types: Co-op alone pays for a
+  transit, Cutthroat alone lets an Extra be planted in another player's district and has no shared
+  failure condition at all beyond three collisions in a Day, and the Revenue floor is a formula in
+  the table size and the length (3 per player per Day in Co-op, 2 in Competitive) rather than a
+  number.
+- **Track is a deck card, but the opening district is dealt.** Track is the largest category in the
+  deck by a distance — so a district is built from what you draw, and building it costs you the
+  industry or train you drew instead. The opening hand is the exception, and it is **chosen when the
+  game is dealt**: three random cards (the prototype rule), six random cards, or three track and
+  three other from two separately shuffled piles. The last of those is the only one that guarantees
+  you a district to build; deal six and you open over the limit of three, so the first turn is spent
+  choosing. **Every game type now deals six** (Jesse’s call, v0.7.0) — the engine's own fallback,
+  `SOLO_CONFIG`, deliberately did not move with it, because every sim measurement is taken against
+  that. See `TODO.md`.
 - **What the work pays is a setting too.** Passenger revenue per coach, freight revenue per load and
   train revenue per transit each run 0–5 and are fixed when the game is dealt. The first two default
   to 1 and pay at both ends of a movement — boarding *and* detraining, loading *and* unloading. The

TODO.md

@@ -37,9 +37,11 @@ Queued 2026-08-22, from playing on StartOS:
 7. **Make "Games in Progress" readable** — nested groups rather than one run-on line per game, plus
    sorting by name, start time or last move. Reasoning in Multiplayer below. Small, and it is the
    action most used for actual administration.
-8. **Give a player a way back into a game after losing their browser** — today a fresh browser is
-   locked out permanently, even though the server still knows who they are. Reasoning in
-   Multiplayer below; needs Jesse's call on whether a token in a URL is acceptable.
+8. **Give a player a way back into a game after losing their browser** — a fresh browser is still
+   locked out of a RUNNING game, even though the server knows who they are. Reasoning in Multiplayer
+   below; needs Jesse's call on whether a token in a URL is acceptable. **The lobby half of this was
+   fixed 2026-08-23** — a reload while seated no longer orphans the chair, and a seat can now be
+   given up rather than wedging the table.
 
 Queued 2026-08-22, from a v0.4.9d gameplay-testing report (six bugs, forwarded by Jesse):
 
@@ -110,6 +112,24 @@ Queued 2026-08-22, from a session looking at the screen rather than the rules. A
     them, so the screen sits you at the table. Needs no new data; the cost is that "west to east"
     stops starting where you start reading.
 
+Queued 2026-08-23, from Jesse playing the v0.7.0 build on StartOS. **All three are the same drawing
+pass as 19-21 and 24 above, and he asked for them to be discussed together rather than picked off:**
+
+25. **The Division map does not draw track geometry at all** — a turnout laid on the Running Track
+    looks exactly like the straight it replaced, because the only thing that changes is a caption.
+    Reasoning and the measurement in Display below.
+26. **CONFIRMED IN PLAY: the buffer stop points the wrong way** at two players — see item 21, now
+    reported from a real game rather than read off the code.
+27. **CONFIRMED IN PLAY: east is not always to the right.** As a train crosses the Division the route
+    wraps through the lanes, so a player's east can be drawn south, west or north. See item 20; it is
+    the same wrap that puts the buffer stop in the wrong place.
+
+28. **INVESTIGATE: move the game's settings off the top line and into a card of their own** — and
+    show ALL of them, not the four that fit. Reasoning in Display below.
+
+29. **Put the Fedora at the right-hand end of the phase row**, with (or in) the Supervisor Shift
+    pill. Reasoning in Display below.
+
 ---
 
 ## Replay / Save Games
@@ -565,6 +585,19 @@ Deferred while planning the server; decisions and reasoning are in `docs/archite
       2026-08-22: "if I opened a fresh browser window and wanted to resume HOPPER-4607, how would
       the server know which player I am and which game I'm trying to get to?"
 
+      **PARTLY FIXED 2026-08-23, and the fixed half was the more common one.** A browser that
+      reloaded while SEATED IN A LOBBY used to orphan its chair outright — the token lived in a
+      closure and was only written to `localStorage` at `Lobby.Start`, so the player could not
+      return and nobody could free the seat, on a table that cannot start until every chair is
+      taken. The record is written at create/join now, carries `stage`, and `start()` walks the two
+      probes (`/api/session`, then the lobby stream) to land the browser wherever its seat actually
+      is. **A player may also LEAVE now** (`/api/lobby/leave`), and the host may clear a chair, so a
+      stranded seat is no longer permanent for the rest of the table either.
+
+      **What is left is exactly the case Jesse asked about**: a genuinely fresh browser, on a
+      RUNNING game. Everything below still stands, and still needs his call on whether a token in a
+      URL is acceptable.
+
       **A new tab or window of the SAME browser is fine** — `localStorage` is per-origin and shared
       across a profile, so `start()` finds the token and rejoins automatically. **A genuinely fresh
       browser is not**: another browser, a private window, another device, or cleared site data.
@@ -634,6 +667,58 @@ Deferred while planning the server; decisions and reasoning are in `docs/archite
       almost nothing — and sorting by last move ascending is how you find the game nobody has
       touched, which is the main reason to open this action at all.
 
+- [x] **~~The lobby, the setup form and the start of a game~~ — done 2026-08-23 (Jesse's cleanup
+      pass).** Kept for the reasoning, since several of these were decisions rather than fixes.
+
+      **The game types.** Co-op, Competitive, Cutthroat, Solitaire and Custom (`src/web/presets.ts`),
+      replacing the old two-mode radio. A type is a set of DEFAULTS, not a ruleset: every rule stays
+      editable, and editing one selects Custom, which keeps the scoring of the type it came from.
+      Jesse's numbers — Co-op pays 1 per transit and asks 3 combined Revenue per player per Day;
+      Competitive asks 2 and pays nothing for transits; Cutthroat asks nothing at all and lifts the
+      whole-game collision cap, leaving three-in-one-Day as the only shared way to lose; every type
+      deals six cards. **The Revenue floor is a formula**, so table size and Day count re-derive it
+      rather than making a game Custom — which is why those two, and the seed, sit above the type
+      radios as parameters. The type is DERIVED from the numbers, never stored, so no saved game
+      carries a label that can disagree with itself (`test/presets.test.ts`).
+
+      **Where an Extra may start was missing from the lobby entirely**, so every multiplayer game
+      ever played used the most permissive setting (`anyOffice` — an Extra may be planted in another
+      player's district) and no host was ever asked. It is a Cutthroat-only default now. The reverse
+      hole existed too: the solitaire dialog had none of the three optional rules. Both screens ask
+      the same eleven questions through one shared module (`settings-form.ts`), and a test asserts
+      the markup carries every field on both — the drift is what motivated the shared block.
+
+      **The dead PvP checkbox is gone from both screens.** `buildDeck` ANDs `pvpCardsAllowed` with a
+      hard-coded `cardsImplemented = false`, so the control could not do anything whatever it was
+      set to. The 22 opponent-directed cards (and the 7 defences held out with them) are now a
+      property of the game type, and the fact is stated in words where the checkbox was.
+
+      **The lobby itself:** joining is a door of its own rather than a heading below fifteen fields
+      the joiner has no use for; a stored join secret collapses to one line and re-opens on a 403; a
+      display name is remembered and may not duplicate another at the same table (`NAME_TAKEN`); the
+      seating list numbers bots as the game will; the code copies as a code AND as an invite link;
+      server codes are translated into sentences in a red block instead of `.dim` grey; the lobby
+      stream has an `onerror` that tells a blip from a dead lobby (and finds a game that started
+      while the connection was down); and **a player may read the whole rule set before taking a
+      seat** (`/api/lobby/preview`, which never carries the seed).
+
+      **The start of a game**, which nobody had ever drawn: a handoff curtain with a deliberate beat
+      instead of a "connecting" line written into the DISCONNECT banner, an announcement naming the
+      game and its type, a marker at the top of the log so the bots' opening turns are visibly after
+      the start, the game code and the type in the header for the rest of the game, and a Start
+      button that cannot be pressed twice.
+
+      **The four transient signals reach a remote client at last.** `createRemoteSession` answered
+      all four with empty values, so multiplayer had no sound, no timetable flash, no announcement
+      when a completed run paid the table, and no badge on the card you had just drawn. `justDrawn`
+      is the redaction-sensitive one — `game.justDrawn` is one field for the whole game and does not
+      say whose card it is — so the server remembers who drew and sends it to that seat alone.
+
+      **Two things found by RUNNING it rather than reading it.** A bot seat was being reported as a
+      disconnected player, which would have put "waiting on Bot 1 — not here yet" on every screen
+      for a whole game. And the six-card opening survives a table with bots in it: a three-seat game
+      (two humans, one bot) played through Day 1 without stalling on the discard round.
+
 - [ ] **Let the game join a call and talk to the table.** Long-term. If the game could join a Zoom,
       Teams or Jitsi call and post into its chat, it could carry the whole table's shared state
       without anyone alt-tabbing: the history of actions as they happen, and a prompt when someone
@@ -1036,6 +1121,13 @@ Deferred while planning the server; decisions and reasoning are in `docs/archite
 
 What is on the screen and where. Split out of Other 2026-08-22; the rules are elsewhere.
 
+- [ ] **The log's start marker only works while the whole log fits.** Added 2026-08-23: a multiplayer
+      game marks the top of the history with "— the game began —", which is honest only while the
+      panel is showing every line there is. The panel caps at `slice(-60)`, so past sixty lines the
+      marker is suppressed rather than lying about where the top is — and "what happened while I was
+      waiting" (item 13) still has no marker at all. Both want the same mechanism, and item 23's
+      newest-at-the-top question decides what that mechanism draws.
+
 - [ ] **INVESTIGATE: a "most recent action" line under the status block.** Raised by Jesse
       2026-08-22: a line below the status block ("Day, Stage, phase, waiting on") and above the
       Division map, carrying the same kind of text the history does — *"Jesse drew from the Home
@@ -1127,6 +1219,102 @@ What is on the screen and where. Split out of Other 2026-08-22; the rules are el
       will want it off. Whatever this becomes probably needs a speed control, or to scale with whether
       anything actually happened in the phase.
 
+- [ ] **INVESTIGATE: the game's settings belong in a card, not along the top line.** Raised by Jesse
+      2026-08-23, playing the v0.7.0 build: "the game-specific information in the very top line should
+      probably be a card like Facilities, timetable or blocked. Off on the side, we can give complete
+      information about all the game options and not take up valuable real estate at the top of the
+      screen."
+
+      **What the top line carries today**, in order: Revenue, the objective (`#objective`), the seed
+      or seat (`#seed` — the seed in solitaire, `Seat 2` in a multiplayer game), the game code
+      (`#gamecode`, added 2026-08-23), the game type (`#gametype`, e.g. "Custom — scored as
+      Competitive"), and an abbreviation of the house rules (`#houserules`, "3 cards · 1/1/0"). The
+      last four were each added because the information was missing entirely, and the header is now
+      carrying them because it was the only place they had ever been put.
+
+      **What a card could say that the header cannot.** Jesse's list, plus what the Frame already
+      carries: seed and seat, the game code, the game type and what it is scored as, the opening hand,
+      all three revenue rates, the Day count, the combined-Revenue floor, BOTH collision limits (with
+      the running counts, which the Frame has as `collisionsToday`/`collisionsTotal`), where an Extra
+      may start, and every optional rule that is on. **Nothing new has to be sent** — `Frame` gained
+      `mode` and `optionalRules` in v0.7.0, and everything else on that list was already on it. The
+      read-only renderer already exists too: `rulesListHtml` (`settings-form.ts`) draws exactly this
+      list for the join preview and the seating screen, so the card is largely a matter of calling it.
+
+      **His own framing of the value**, worth keeping because it names when it is read: "To go, 'Oh
+      wait, what did we set that to?' They should be able to look that up, but it does not need to be
+      at the top every moment because it is not something that they're likely to need all the time."
+
+      **The open questions.** Which of the six stay on the top line — Revenue and the objective are
+      glanced at constantly and clearly belong there, the seed and the code almost never are. Whether
+      the card folds like `#district` does or is always open. Whether the collision counts belong in
+      it or beside the objective, since they are a live score rather than a setting. And it interacts
+      with the Display items about the right column and the middle of the Division map (item 22): if
+      the shared board moves to the centre, the right column is "yours", and a settings card is not
+      yours — it is the table's.
+
+- [ ] **INVESTIGATE: the Fedora belongs at the right-hand end of the phase row.** Raised by Jesse
+      2026-08-23, the day after it was added: "on the next row down, we recently added Superintendent
+      and saying who's got the Fedora. That information should be all the way on the right, where
+      currently it says 'Supervisor Shift'. Would it be possible to say 'Supervisor Shift — and then
+      the player name, who's the current supervisor'? If not, just moving the Superintendent and the
+      Fedora graphic to the right-hand side of Supervisor Shift is probably a better place for that."
+
+      **Where it is now.** `turnChartHtml` (`sim/turnchart.ts`, shared by the play screen and both
+      replay viewers) lays out four blocks in a row: the Day/Stage/clock, the phase, "waiting on
+      <name>", then the Fedora chip (`.tc-super`), and last the `<ol class="tc-phases">` of five phase
+      pills. So the Fedora sits in the middle of the row, immediately before the pills.
+
+      **Putting the name IN the Supervisor Shift pill is the appealing version and needs thought.**
+      The pills are a WHERE-ARE-WE indicator — each lights violet while its phase is running and dims
+      once it is done — so a name inside one may read as "this phase belongs to that player", which is
+      not what the Fedora means (the office holds the clearance ruling and starts every round, in
+      every phase). The pill is also the one whose tooltip already explains the hat passing every
+      third Stage, which is why it is the natural home. Worth trying both and looking at them.
+
+      **The fallback Jesse names** — move `.tc-super` to the end of the row, after the pills — is a
+      two-line change and safe. Neither should be done without looking at the row as a whole: it is
+      the most-glanced-at strip on the page, and item 15's "most recent action" line wants space in
+      the same place.
+
+- [ ] **THE DIVISION MAP DRAWS NO TRACK GEOMETRY — a turnout is indistinguishable from a straight.**
+      Reported by Jesse 2026-08-23, playing the v0.7.0 build on StartOS: he upgraded a straight on his
+      Running Track to a turnout and "did not see the division map on my side updated. And in the
+      opponent's screen, they did not see any update in their division map either."
+
+      **It did update. The whole visible change is one word.** Measured rather than reasoned about —
+      a real two-player game played out ~260 turns, then a running-track straight upgraded to a
+      turnout, diffing the drawn SVG on both seats:
+
+      ```
+      own division view : CHANGED
+      other's view      : CHANGED
+      drawn SVG         : CHANGED
+        removed: <text class="bs-name" ...>straight</text>
+        added  : <text class="bs-name" ...>turnout</text>
+      ```
+
+      **Why.** `divisionSvg` draws the SAME generic rail on every Running Track cell —
+      `rail(c.x + 6, c.y + 32, c.x + c.w - 6)`, unconditionally — and prints the card's name under it.
+      So a straight, a curve and a turnout are pixel-identical on the map and only the caption
+      differs. `officeSvg` does it properly for the district grid: it reads `cell.links` and draws the
+      real geometry, 45° legs included.
+
+      **The data is already there and unused.** `RunningCardView` carries
+      `links: connectionsFor(card)` — the same field `officeSvg` draws from — and `divisionSvg` never
+      reads it. So this is a rendering change with no plumbing behind it.
+
+      **What is NOT wrong, checked at the same time:** a card laid anywhere BELOW the Running Track
+      correctly changes nothing on the map — the map is the through route between the Limits, and
+      district interiors live in the Office Area grid. Of 4,000 bot steps in a two-player game, all
+      15 running-row plays changed both players' maps and none of the 19 below-the-row plays did. The
+      delta is not dropping anything: `deltaFrame` JSON-compares `division` and sends it whenever it
+      differs.
+
+      **Do it with items 19, 20, 21 and 24** — Jesse's instruction, 2026-08-23. Drawing real geometry
+      is the same pass as turning that geometry through 90° down a side lane, and both are wasted
+      work if the map is later rotated to seat the viewer at the bottom.
+
 - [ ] **INVESTIGATE: turn the track art vertical on a Division card laid vertically.** Raised by Jesse
       2026-08-22: a side lane "looks like a bunch of disconnected left-right tracks stacked one on top
       of another instead of looking like a continuous track."
@@ -1143,7 +1331,11 @@ What is on the screen and where. Split out of Other 2026-08-22; the rules are el
       a rotated card or a differently-arranged one. Worth a sketch before any code.
 
 - [ ] **INVESTIGATE: run the inter-row connector round the outside, as rail, with angled corners.**
-      Raised by Jesse 2026-08-22.
+      Raised by Jesse 2026-08-22. **CONFIRMED IN PLAY 2026-08-23**, and it is worse than a drawing
+      complaint: "as a train traverses the board in a multiplayer game, east is not always to the
+      right. Sometimes, for train direction, east might be south, west, or north as it traverses the
+      different players." The route wrapping through the lanes is exactly this, and a player reading
+      direction off the screen is being told the wrong thing — not merely an ugly corner.
 
       **Where it comes out is wrong.** The turn between two sides of the table is drawn from
       `a.y + CH` — the BOTTOM edge of the last cell in the top row — across to `b.y`, the TOP edge of
@@ -1167,7 +1359,11 @@ What is on the screen and where. Split out of Other 2026-08-22; the rules are el
       fill, so these two interact.
 
 - [ ] **INVESTIGATE: the Division Point captions overflow, and the buffer stops point the wrong way
-      once the route wraps.** Raised by Jesse 2026-08-22.
+      once the route wraps.** Raised by Jesse 2026-08-22. **CONFIRMED IN PLAY 2026-08-23** at two
+      players: "the eastern division point has the end marker to the right, so it overlays where the
+      track is into the person's area, instead of off the left at the actual end of the track." The
+      stop is drawn past the cell's right-hand edge whatever lane the cell ended up in, so at a
+      wrapped route it points back into the board — over a district, not away from the line.
 
       **The captions.** "west end · in and out" and "east end · in and out" are centred under their own
       cell at `x = c.x + c.w / 2`. That was a deliberate fix — they used to hang off the outside of
@@ -1698,6 +1894,18 @@ Doesn't fit the above.
       Shed and Power Plant may be similarly stale — flagged as a new item above rather than assumed.
 - [x] **Poling — closed, v0.5.0.** Confirmed already at 0 copies, the same treatment as Sharp Curves,
       pinned by `mainline-cards.test.ts`. No code change; removed from Rules Questions.
+- [x] **Heavy Grade orientation — asked again 2026-08-23, and the answer did not change.** Raised as
+      "did we ever fix Heavy Grade to allow user placement of direction?", with the option of giving
+      the choice to the **Superintendent** considered and rejected. Jesse's call: v0.5.0 stands.
+      Three things came out of the re-examination and are recorded in `implications.md` §10 Q11 so it
+      is not asked a third time — the advantage is permanent while the office rotates, so a rotating
+      chooser moves the fairness problem rather than solving it; there is no setup phase to ask in
+      (`createGame` is pure, and `pendingDecision` is typed for clearance alone across 19 readers);
+      and since v0.6.2 deals the Mainline deck without replacement, only **20%** of solitaire games
+      contain a Heavy Grade at all. **The docs were the real defect** — `README.md` listed it among
+      three open rules questions, all three of which v0.5.0 had closed, and the Mainline deck
+      reference said the implementation "needs a player-selection step". Both corrected; no code
+      change, and none wanted.
 - [x] **Heavy Grade orientation stays rolled, permanently — v0.5.0, Jesse's call.** The card prints
       "Player sets orientation", but a Heavy Grade sits on the shared Division chain between two
       players (or beyond an end Division Point, next to one) — never inside one player's own district

docs/StationMaster-Mainline-Deck-v0.4.5.md

@@ -38,7 +38,7 @@ The PDF art labels this card “Yard”; this reference uses the implementation
 | Plains | 60 mph; one Stage for Fast, two for Slow. The implementation has one Plains *type* rather than the PDF’s two physical copies. |
 | Curves | 30 mph; two Stages for Fast, three for Slow. |
 | Hilly | Passenger train: 60 mph. Freight-only train: 30 mph. Add one Stage if Slow. |
-| Heavy Grade | Starts at 30 mph; two Stages for Fast, three for Slow. The card requires the player to select its uphill direction; v0.4.5 instead selects that direction from the game seed during setup. Grade modifiers can reduce the time, to a minimum of one Stage. |
+| Heavy Grade | Starts at 30 mph; two Stages for Fast, three for Slow. The card prints “Player sets orientation”; **the game deliberately overrides that and rolls the uphill direction from the seed** — settled in v0.5.0 and re-confirmed 2026-08-23, see the note below. Grade modifiers can reduce the time, to a minimum of one Stage. |
 | Double Track | 60 mph. Printed capability: trains may pass. The traffic-resolution rule is in Rules §4.5. |
 | Uncontrolled Siding | 60 mph. Printed capability: trains may pass. The traffic-resolution rule is in Rules §4.5. |
 | Tunnel | 30 mph. |
@@ -70,6 +70,16 @@ For the grade cards, “uphill” should be the direction selected by the player
 
 ## What is not implemented
 
-- There is no finite draw pile, player choice, or physical placement interaction for Mainline cards; setup selects their types automatically from the seeded random stream.
+- There is no player choice or physical placement interaction for Mainline cards; setup deals them automatically from the seeded random stream. There **is** a finite draw pile as of v0.6.2 — the deck above, dealt without replacement, so no Division can hold two of a card printed once.
 - Interchange is catalogued as a “sort cars” card, but v0.4.5 has no operation that reorders a train on the Interchange. The Small Yard in an Office Area is the implemented sorting mechanism.
-- Heavy Grade orientation is seeded automatically rather than chosen by a player. The implementation needs a player-selection step to match the card.
+- Interchange now has one player-facing use: an Extra Train may be **started** there, made up in its yard and highballing onto the Mainline when the Subdivision is clear (§7, v0.6.2). Car sorting remains unimplemented.
+
+## Heavy Grade orientation is settled, not missing
+
+Heavy Grade orientation is rolled from the seed rather than chosen by a player. **This is a decision, not a gap, and it is not awaiting a player-selection step.**
+
+The card prints “(Up)” and “Player sets orientation”, which assumes the card has an owner. This one does not: `buildDivision` lays the Division as `DP · Mainline · Office · Mainline · … · DP`, so a Heavy Grade always sits **between two districts**, or beyond an end Division Point next to one — never inside a single player’s own district.
+
+Orientation is not cosmetic: Brakeman and Airbrakes each take a Stage off a train running **downhill**, Helpers takes one off a train running **uphill**, and odd-numbered trains run west while even run east. Turning the card around therefore decides which of those modifier cards are worth anything and which direction of traffic is favoured — permanently, for the whole game. Handing that to one of the two neighbours advantages them over the other, and no player has a fair claim to it.
+
+**Re-opened and closed again on 2026-08-23**, when the option of giving the choice to the Superintendent was considered and rejected. Jesse’s call: v0.5.0’s ruling stands. Rolling from the seed is deterministic, roughly even (51/49 east/west over 400 games), identical for solitaire and multiplayer, and keeps setup non-interactive — the game has no setup phase, so the question would have to interrupt play before the first Local Operations, in the minority of games that deal the card at all (20% at one player, rising to 50% at four).

docs/architecture/lobby-and-sessions.md

@@ -44,8 +44,10 @@ Real accounts can be layered on later without touching the rules engine, which i
 ## 2. Creating and joining
 
 ```
-Lobby.Create { secret, config }            →  { gameId, gameCode, token }
-Lobby.Join   { secret, gameCode, displayName }  →  { token, player }
+Lobby.Create  { secret, config, displayName, players, seed }  →  { gameId, gameCode, token, player }
+Lobby.Preview { secret, gameCode }                            →  { gameCode, hostName, config, players, seated }
+Lobby.Join    { secret, gameCode, displayName }               →  { gameId, gameCode, token, player }
+Lobby.Leave   { token, seat? }                                →  { ok, closed? }
 ```
 
 **These four messages are the one family with no types behind them**, because the engine has no
@@ -60,7 +62,28 @@ per-origin, alongside the token.
 
 A **game code** — short, human-speakable, e.g. `RAIL-4471` — is the discovery mechanism *inside* the
 door. No matchmaking, no browsing, no public game list. Players are already talking to each other; the
-code just needs to survive being read aloud.
+code just needs to survive being read aloud. The seating screen also offers it as an invite **link**
+(`…/play.html?lobby&code=RAIL-4471`), which is what a chat message wants — the link carries the code
+and never the join secret, because the secret is the door key and travels out of band by design.
+
+**A player reads the rules before taking a chair.** `Lobby.Preview` answers the same join secret with
+the whole config, the host's name and who is seated, and takes no seat — added 2026-08-23, when the
+alternative was sitting down blind and (until the same pass) having no way back out. **It never
+carries the seed**: the seed decides every shuffle and every roll in the game, so it belongs to the
+host alone.
+
+**Two players may not share a display name.** The name labels the district on the Division map, it is
+what the turn chart means by "waiting on Jesse", and `record()` puts it in front of every line that
+player causes — so two of them make all three ambiguous, and the names lock at `Lobby.Start`. A
+clashing join is refused (`NAME_TAKEN`, compared trimmed and case-insensitively) rather than silently
+suffixed: a player should play under the name they chose, or be asked for another.
+
+**Anybody may leave, and the host may clear a chair.** `Lobby.Leave` frees the seat, drops the token
+from `joinOrder`, and passes host rights on exactly as a dropped connection does. Naming somebody
+else's `seat` is host-only. When the last human leaves, the lobby is deleted outright — code, file and
+index row — rather than left as a table of bots waiting for a host who no longer exists. Before this
+existed a mis-join or a player who wandered off wedged the whole table, since Start needs every chair
+filled and a bot may not be dropped onto an occupied seat.
 
 **One game at a time per person is expected usage and is deliberately not enforced** (`multiplayer.md`
 §10). Enforcing it needs cross-game state whose only job is deciding when to release someone, and
@@ -88,15 +111,27 @@ The cap is about what has been played, not about what the game can do.
 
 ## 3. Configuration, and when it locks
 
-Set before start, immutable after:
+Set before start, immutable after — the whole of `GameConfig` (`state.ts`), which the host fills in
+by choosing a **game type** and then editing whatever they like:
 
 ```
-mode          : solitaire | competitive | coop
-victory       : firstToTarget | highestAfterDays
-length        : short | standard | campaign
-optionalRules : { reducedVisibility, sisterTrains, employeeRotation, emergencyToolbox }
+mode              : solitaire | competitive | coop
+days              : how long the game runs
+minCombinedRevenue, maxCollisionsPerDay, maxCollisionsTotal   (0 = that condition is off)
+pvpCardsAllowed   : a property of the type, not a control — the cards are unbuilt (setup.ts)
+optionalRules     : { reducedVisibility, employeeRotation, emergencyToolbox }
+houseRules        : { startingHand, extraStart, revenue }
 ```
 
+**The four game types** (`src/web/presets.ts`, Jesse's design 2026-08-23) are Co-op, Competitive,
+Cutthroat and Solitaire, plus **Custom** — which is not a fifth type but the state of having edited
+one, and is scored as whichever type it was edited away from. The type is *derived* by comparing a
+config against the four, never stored, so a saved game carries no label that can disagree with its own
+numbers. Seed, player count and Day count sit ABOVE the type on both screens as **parameters**: the
+types are formulas in the table size and the length (the Revenue floor is 3 per player per Day in
+Co-op, 2 in Competitive, nothing in Cutthroat), so changing one re-derives rather than making the game
+Custom.
+
 These must lock at `Lobby.Start`. Changing `length` mid-game would move the finish line; changing
 `mode` would switch which failure floors apply (§3.4, §3.5). Neither has a coherent meaning
 mid-game, so the server should refuse rather than try.
@@ -141,6 +176,12 @@ to hide it. Show the chain forming.
 **Solitaire is unchanged and must stay so:** one player is one seat, seating is trivially `[0]`, and
 every published replay depends on that.
 
+**What a seat is told as the game begins** (2026-08-23). The board used to simply appear, mid-Local
+Operations, with a log already several bot turns deep and nothing marking where the game began. The
+page now holds a deliberate beat on a handoff curtain, announces the game and its type, marks the top
+of the log, and shows the code and the type in the header for the rest of the game — none of which is
+new *data*, only the first time any of it was drawn.
+
 **Employee Rotation** (Appendix B), if enabled, moves every player one seat left at the end of each
 Day, carrying their Revenue and the Fedora with them. **The model supports this as of v0.4.0**:
 offices and districts are keyed by seat, hands and Revenue and the Fedora by player, and `seating[]`
@@ -163,6 +204,16 @@ if it was their turn. Broadcast a disconnect notice so everyone else can see why
 server-layer news about a *connection*, not about the game, so it belongs with the transport rather
 than in `GameEvent`, which must stay replayable from a seed.
 
+**On connect, a client is told about every other seat at once** (2026-08-23). A change notice alone
+answered "who just left", never "who is here" — so a player arriving at a table where two people had
+not opened the game yet was told nothing about them at all, which is precisely the question at the
+moment a game starts. Each entry carries `seen`, separating **was here and dropped** from **has never
+opened the game**: the first will probably be back, the second needs somebody to send them the link.
+`seen` is remembered only for as long as the process runs, so after a restart every absent seat reads
+as "not here yet" — the more cautious of the two. **Bot seats are never reported**: a bot holds no
+connection and never will, and listing one puts "waiting on Bot 1" on every screen for the whole game
+(found by playing a three-seat game, not by reading the code).
+
 **On reconnect:** the client presents its token and the server replies with a **full current view**.
 Not an event tail — a returning client needs the position, not the history of how it got there, and
 the server can always produce the position because it holds the game

docs/architecture/protocol.md

@@ -103,6 +103,17 @@ Two consequences worth knowing before adding an event:
 - **Events are not what goes over the wire.** The server applies the intent and pushes the resulting
   `Frame` (`multiplayer.md` D2/D3). Events are narration and cues, not the protocol — and a reconnect
   gets a fresh `Frame` rather than the tail it missed.
+- **What events EARN does go over the wire, as four transient signals** (2026-08-23): the sound cues,
+  the timetable slot a D12 just filled, a one-line announcement, and the id of the card that just came
+  into this seat's hand. They ride beside the `Frame` rather than on it because they mark a *moment*
+  and are consumed — putting them on the Frame would re-fire them on every redraw. Before this a
+  remote client got none of them, so multiplayer had no sound at all, no flash and no announcements
+  while solitaire had all three. The first three are shared and identical in every seat's push; the
+  fourth is **not** — `game.justDrawn` is one field for the whole game and does not say whose card it
+  is, so the server remembers who drew and sends it to that seat alone
+  (`test/server/session.test.ts`, "the four transient signals"). A reconnect gets none of the shared
+  three: a fresh connection is drawing a state, and replaying the sounds of everything it missed is a
+  burst of noise about the past.
 
 ---
 

docs/rules/implications.md

@@ -89,6 +89,28 @@ district — so whichever direction climbs advantages one neighbour over the oth
 has a fair claim to the decision. Orientation is **rolled** from the seed instead — deterministic,
 and roughly even (51/49 east/west across 400 games) — identically for solitaire and multiplayer.
 
+**Re-opened and closed again, 2026-08-23.** The question came back as "did we ever fix Heavy Grade
+to allow user placement of direction?", and the option of handing the choice to the **Superintendent**
+— the neutral office, which rotates with the Fedora every three Stages — was considered and rejected.
+Jesse's call: v0.5.0's ruling stands. What the re-examination surfaced, worth recording so this is not
+asked a third time:
+
+- **The advantage is permanent; the office is not.** Orientation decides which modifier cards pay for
+  the whole game (Brakeman and Airbrakes on the descent, Helpers on the climb) and therefore which
+  direction of traffic is favoured — and odd trains run west while even run east. A rotating office
+  making a one-way, once-and-for-all call does not dissolve the fairness problem, it just moves it.
+- **There is no setup phase to ask in.** `createGame` is pure and synchronous and the game opens at
+  Day 1, Stage 1, Local Operations. The question would have to interrupt play before the first turn,
+  and `clock.pendingDecision` is typed for clearance alone (`SuperintendentClearance | null`, read in
+  19 places), so a second decision kind would be most of the work.
+- **Most games never meet the card.** Since v0.6.2 deals the Mainline deck without replacement there
+  is at most one Heavy Grade in ten cards, drawn `players + 1` times: **20%** of solitaire games,
+  rising to 50% at four players. A pre-game interrupt for a rule four games in five never see.
+
+The docs were the actual defect. `README.md` still listed it among three open rules questions (all
+three closed in v0.5.0) and `StationMaster-Mainline-Deck-v0.4.5.md` still said "the implementation
+needs a player-selection step to match the card". Both now say settled, and why.
+
 **Still not implemented**: the Action (10) and Space-use (12) cards, which are genuinely
 multiplayer-only. Playing them is rejected with `NOT_IMPLEMENTED`.
 
@@ -542,7 +564,7 @@ We modelled a Mainline card as **2 regions, uniform**. The design has **ten dist
 | Plains | 60 | |
 | Curves | 30 | |
 | Hilly | **P60 / F30** | different speeds for passenger and freight |
-| Heavy Grade (Up) | **G** | player sets orientation; Brakeman/Airbrakes/Helpers unlock better start positions |
+| Heavy Grade (Up) | **G** | player sets orientation †; Brakeman/Airbrakes/Helpers unlock better start positions |
 | Double Track | 60 | **trains may pass** |
 | Uncontrolled Siding | 60 | trains may pass; separate "no pass" and "passing" starts |
 | Tunnel | 30 | |
@@ -550,6 +572,10 @@ We modelled a Mainline card as **2 regions, uniform**. The design has **ten dist
 | Interchange | 60 | **sort cars into any new order**; has a Yard Limit. Printed "Yard" on the prototype card and renamed after play — it shared a word with the Division Yard, the Classification Yard, the Salvage Yard, the Yard Office and the Small Yard, and is none of them |
 | East / West Division Point | — | the ends |
 
+† **"Player sets orientation" is deliberately NOT implemented** — the table records what the card
+prints, which is what this section is for. The game rolls the uphill direction from the seed instead;
+settled v0.5.0, re-confirmed 2026-08-23, reasoning in §10 Q11 above.
+
 Each card shows **Start positions** — where a train enters depending on direction, train type, and
 which modifier cards are in play. The Heavy Grade card has five distinct starts (plain, brakemen,
 airbrakes, plain, helpers), so playing Brakeman literally moves your entry point further along.

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "station-master",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "station-master",
-      "version": "0.5.0",
+      "version": "0.7.0",
       "devDependencies": {
         "@types/node": "^26.1.2",
         "typescript": "^7.0.2"

package.json

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

playtests/README.md

@@ -0,0 +1,28 @@
+# Playtest saves
+
+Save files that came in with a bug report, or that were kept from a session worth re-reading.
+
+**Nothing in here is committed** — `.gitignore` keeps the directory empty as far as git is
+concerned, except for this file. They are somebody's game, not part of the project, and they go
+stale the moment the rules move.
+
+## What a save is
+
+A seed and the list of moves made — a few hundred bytes of JSON. That is enough to rebuild the
+whole game, which is why a replay can be emailed like a text file. Written by **Save replay** on the
+play screen; a multiplayer game's copy lives on the server, under its data directory.
+
+## How to open one
+
+Open `replays.html` on the site (or a local `npm run serve:web`) and use **Open a save file** at the
+bottom of the page — it takes a file straight off disk, no upload anywhere. Step through it frame by
+frame to find the position being reported.
+
+A save replays only under the rules it was dealt with; every save records them, and one written
+before a rules change may stop part-way. That is expected, and it is why these are kept beside a
+report rather than in the repository.
+
+## Publishing one
+
+A replay worth keeping for everyone goes in `public/replays/` instead, where the build publishes it
+into the site's replay directory with an index entry.

src/engine/advance.ts

@@ -266,8 +266,14 @@ function newTrainPhase(s: GameState, events: GameEvent[]): AdvanceResult {
    * chooser is the acting player; §7 says the player who PLAYED the card, which is the same person
    * in solitaire and needs `pendingExtras` to carry a player before it is not.
    */
-  if (s.pendingExtras.length > 0 && s.freeTrays.length > 0) {
-    s.clock.currentActor = actorAt(s, s.clock.actorOffset % s.players.length);
+  const extra = s.pendingExtras[0];
+  if (extra !== undefined && s.freeTrays.length > 0) {
+    // §7 — the player who PLAYED the card places it. `pendingExtras` carries them (2026-08-23);
+    // before that it was a bare train number and this asked whoever the acting order was on, which
+    // is the same person in solitaire and the wrong one at every table. Reported by Jesse from a
+    // two-player game.
+    if (s.clock.currentActor !== extra.player) events.push({ type: 'actorChanged', player: extra.player });
+    s.clock.currentActor = extra.player;
     return { events, needsInput: true };
   }
 
@@ -285,7 +291,16 @@ function newTrainPhase(s: GameState, events: GameEvent[]): AdvanceResult {
   const filling = trainNeedingCars(s);
   if (filling) {
     const tray = s.trays.get(filling)!;
-    const nextActor = actorAt(s, tray.consist.length % s.players.length);
+    /**
+     * TWO DIFFERENT RULES, and §7 states them a paragraph apart. A TIMETABLED train's consist is
+     * built by the table — "starting with the Superintendent and working left, each player may place
+     * ONE car" — while an EXTRA is loaded by the player who played it, "as he chooses". So an Extra
+     * does not enter the round at all; it belongs to `builtBy` until it is full.
+     */
+    const nextActor =
+      tray.trainIsExtra && tray.builtBy !== undefined
+        ? tray.builtBy
+        : actorAt(s, tray.consist.length % s.players.length);
     if (s.clock.currentActor !== nextActor) events.push({ type: 'actorChanged', player: nextActor });
     s.clock.currentActor = nextActor;
     return { events, needsInput: true };

src/engine/apply.ts

@@ -1050,7 +1050,11 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
     // -- New Train ------------------------------------------------------------
     case 'newTrain.startExtra': {
       if (!inPhase(s, 'newTrain')) return 'WRONG_PHASE';
-      if (!s.pendingExtras.includes(i.trainNumber)) return 'NO_EXTRA_PENDING';
+      const pending = s.pendingExtras.find((x) => x.trainNumber === i.trainNumber);
+      if (!pending) return 'NO_EXTRA_PENDING';
+      // §7 — "the player who played the card MAY place the Crew Tray": it is theirs to place, and
+      // nobody else's to place for them.
+      if (pending.player !== player) return 'NOT_YOUR_EXTRA';
       if (s.freeTrays.length === 0) return 'NO_FREE_TRAY';
       const where = resolveExtraStart(s, player, i);
       if (typeof where === 'string') return where;
@@ -2254,7 +2258,8 @@ export function reduce(s: GameState, e: GameEvent): void {
     }
 
     case 'extraQueued':
-      s.pendingExtras.push(e.trainNumber);
+      // §7 hands this train to the player who played the card, so the queue records them.
+      s.pendingExtras.push({ trainNumber: e.trainNumber, player: e.player });
       break;
 
     case 'secondSectionOrdered':
@@ -2284,11 +2289,14 @@ export function reduce(s: GameState, e: GameEvent): void {
      */
     case 'extraStarted': {
       const trayId = s.freeTrays.pop()!;
-      s.pendingExtras = s.pendingExtras.filter((n) => n !== e.trainNumber);
+      s.pendingExtras = s.pendingExtras.filter((x) => x.trainNumber !== e.trainNumber);
       const { direction } = e;
       const base = {
         id: trayId, trainNumber: e.trainNumber, trainIsExtra: true, engineAt: 0,
         consist: [] as RollingStock[], direction, movesUsed: 0,
+        // The queue is emptied here, before a single car goes on, so the tray carries the owner
+        // from now on — §7 lets the player who played it load the consist as they choose.
+        builtBy: e.player,
       };
       // Which way the tray physically points, for the cards it will pick up. A Division Point start
       // does not set it: those trays have never carried a facing and `enterMainline` does not read

src/engine/content.ts

@@ -504,8 +504,9 @@ 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" with the player setting orientation.
+ * 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).
  *
  * 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.
@@ -531,6 +532,14 @@ 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'] },
+  /**
+   * `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.
+   */
   { 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'] },
@@ -664,12 +673,24 @@ export function mainlineDescription(kind: MainlineKind, gradeUp: Direction = 'ea
 }
 
 /**
- * Q11, answered: the Heavy Grade card prints "(Up)" and "Player sets orientation", so which way it
- * climbs is a property of the placed card, not a constant. `gradeUp` is the direction a train is
- * travelling when it goes UPHILL; a train heading the other way is descending.
+ * 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.
+ * Airbrakes only counts when Brakeman is already there, which the placement rule enforces
+ * (`MAINLINE_MODIFIER_RULES`, `requiresOnCard`).
  */
 function gradeReduction(
   profile: MainlineProfile,

src/engine/intents.ts

@@ -258,6 +258,8 @@ export type RejectionCode =
   | 'NO_EMPTY_COACH_IN_YARD'
   | 'NOT_A_CONTROL_POINT'
   | 'NO_EXTRA_PENDING'
+  /** §7 gives an Extra to the player who played the card; another seat may not place it for them. */
+  | 'NOT_YOUR_EXTRA'
   | 'NO_FREE_TRAY'
   | 'NO_FREE_AD_TRACK'
   // -- §7, where an Extra may be started (`resolveExtraStart`)

src/engine/legal.ts

@@ -79,7 +79,7 @@ function candidates(s: GameState, player: PlayerIndex): Intent[] {
       out.push(...localOpsCandidates(s, player));
       break;
     case 'newTrain':
-      out.push(...newTrainCandidates(s));
+      out.push(...newTrainCandidates(s, player));
       break;
     case 'loadUnload':
       out.push(...loadUnloadCandidates(s, player));
@@ -257,7 +257,7 @@ function localOpsCandidates(s: GameState, player: PlayerIndex): Intent[] {
   return out;
 }
 
-function newTrainCandidates(s: GameState): Intent[] {
+function newTrainCandidates(s: GameState, player: PlayerIndex): Intent[] {
   const out: Intent[] = [];
   for (const [trayId] of s.trays) {
     for (const carType of CAR_TYPES) {
@@ -279,7 +279,9 @@ function newTrainCandidates(s: GameState): Intent[] {
    * is placed. In the middle of the railroad — an Interchange, a Control Point — both ways are real
    * runs, so those are offered twice, once per direction.
    */
-  for (const trainNumber of s.pendingExtras) {
+  // Only the player who played it is offered anywhere to put it (§7) — `check` refuses anyone else
+  // with NOT_YOUR_EXTRA, and offering options that are certain to be refused is how a menu lies.
+  for (const { trainNumber } of s.pendingExtras.filter((x) => x.player === player)) {
     for (const side of ['west', 'east'] as const) {
       out.push({ type: 'newTrain.startExtra', trainNumber, start: { kind: 'divisionPoint', side } });
     }

src/engine/setup.ts

@@ -254,7 +254,11 @@ function buildDivision(players: number, rng: Rng): DivisionNode[] {
        * district — so whichever direction climbs advantages one neighbour over the other, and there
        * is no single player who owns that call fairly. Orientation is rolled from the seed instead,
        * identically for solitaire and multiplayer, and this is not expected to change when setup
-       * eventually gains an interactive phase for other decisions. See implications.md §10 Q11.
+       * eventually gains an interactive phase for other decisions.
+       *
+       * RE-CONFIRMED 2026-08-23, when the question was raised again and giving the choice to the
+       * Superintendent was considered and rejected — the office rotates every three Stages, the
+       * advantage it would hand out does not. See implications.md §10 Q11.
        */
       node.gradeUp = rng.nextInt(2) === 0 ? 'east' : 'west';
     }

src/engine/state.ts

@@ -371,6 +371,15 @@ export type CrewTray = {
    * bug `isBeingMadeUp` was tightened to kill, and an arriving train never carries this.
    */
   beingMadeUp?: boolean;
+  /**
+   * WHOSE TRAIN THIS IS TO BUILD, for an Extra only.
+   *
+   * §7's Extra is loaded by the player who played the card, not by the Superintendent-first round
+   * that fills a Timetabled train — so the tray has to remember them: `pendingExtras` is emptied the
+   * moment the Extra starts, which is before a single car goes on. Undefined on every Timetabled
+   * train, where the round decides instead.
+   */
+  builtBy?: PlayerIndex;
   /**
    * WHERE THE ENGINE SITS IN THE TRAY, as an index into `consist`.
    *
@@ -831,8 +840,15 @@ export type GameState = {
   /**
    * §7 — Extra Trains played from hand, waiting for a free Crew Tray. An Extra is not scheduled:
    * it runs once, immediately, then its card goes to the Salvage Yard (§2.3).
+   *
+   * CARRIES WHO PLAYED IT (2026-08-23, Jesse's call). §7 gives an Extra to the player who played the
+   * card — "may place the Crew Tray at either Division Point ... and may load the consist as he
+   * chooses" — which is a different rule from the Timetabled make-up round, where the table goes
+   * round starting at the Superintendent. This was a bare `number[]`, so the engine could not tell
+   * whose Extra it was and asked whoever the acting order happened to be on: correct in solitaire,
+   * where there is only one player, and wrong at every table.
    */
-  pendingExtras: number[];
+  pendingExtras: { trainNumber: number; player: PlayerIndex }[];
   /**
    * Q9 — train numbers ordered to run a second section. The next New Train Phase makes up an
    * identical train behind the first, if a Crew Tray is free.

src/server/http.ts

@@ -41,6 +41,7 @@ import { createSession } from './session.ts';
 import type { GameSession, Push } from './session.ts';
 import {
   createLobby,
+  leaveLobby,
   freshGameCode,
   playerCountAllowed,
   joinLobby,
@@ -129,6 +130,15 @@ async function serveStatic(distDir: string, urlPath: string, res: ServerResponse
  * simply ending, indistinguishable from a network hiccup that `EventSource` would otherwise retry.
  */
 type LobbyPush = { lobby: Lobby; you: PlayerIndex; started: boolean };
+/** What `/api/lobby/preview` answers with — everything a player weighing a join needs, and nothing
+ * that would spoil the game. THE SEED IS NOT IN IT: it decides every shuffle and every roll. */
+type LobbyPreview = {
+  gameCode: string;
+  hostName: string;
+  config: GameConfig;
+  players: number;
+  seated: { seat: number; who: string | null; bot: boolean }[];
+};
 
 export function startServer(opts: ServerOptions): void {
   const games = opts.initialGames;
@@ -143,6 +153,8 @@ export function startServer(opts: ServerOptions): void {
   const gameConnections = new Map<string, Map<PlayerIndex, ServerResponse>>();
   const gameEventIds = new Map<string, Map<PlayerIndex, number>>();
   const lobbyConnections = new Map<string, Map<string, ServerResponse>>();
+  /** Which seats of a game have ever held a connection in THIS process — see `presenceOfOthers`. */
+  const everConnected = new Map<string, Set<PlayerIndex>>();
 
   function writeSse(res: ServerResponse, id: number, data: unknown): void {
     res.write(`id: ${id}\ndata: ${JSON.stringify(data)}\n\n`);
@@ -176,11 +188,37 @@ export function startServer(opts: ServerOptions): void {
     if (!conns) return;
     for (const [other, res] of conns) {
       if (other === seat) continue;
-      const push: Push = { menu: null, lines: [], presence: { seat, connected } };
+      const push: Push = { menu: null, lines: [], presence: [{ seat, connected, seen: true }] };
       writeSse(res, nextEventId(gameId, other), push);
     }
   }
 
+  /**
+   * EVERY OTHER SEAT'S STATE, for a client that has just connected.
+   *
+   * `broadcastPresence` only ever reports a CHANGE, so a player arriving at a table where two people
+   * had not opened the game yet was told nothing about them at all — and "is everyone here?" is the
+   * question at the moment a game starts. `seen` separates a seat that was here and dropped from one
+   * that has never connected; it is remembered only for as long as this process runs, so after a
+   * restart every absent seat reads as "not here yet", which is the more cautious of the two.
+   */
+  function presenceOfOthers(
+    gameId: string,
+    seat: PlayerIndex,
+    session: GameSession,
+  ): NonNullable<Push['presence']> {
+    const conns = gameConnections.get(gameId);
+    const ever = everConnected.get(gameId) ?? new Set<PlayerIndex>();
+    const out: NonNullable<Push['presence']> = [];
+    for (let other = 0 as PlayerIndex; other < session.playerCount; other++) {
+      // A bot holds no connection and never will, so reporting it would put "waiting on Bot 1 — not
+      // here yet" on every screen for the whole game. Found by playing a real 3-seat game.
+      if (other === seat || session.isBot(other)) continue;
+      out.push({ seat: other, connected: conns?.has(other) === true, seen: ever.has(other) });
+    }
+    return out;
+  }
+
   function broadcastLobby(gameId: string): void {
     const lobby = lobbies.get(gameId);
     const conns = lobbyConnections.get(gameId);
@@ -389,7 +427,12 @@ export function startServer(opts: ServerOptions): void {
         await persistLobby(result.lobby);
         await persistSession(result.session);
         broadcastLobby(lobby.gameId);
-        sendJson(res, 200, { gameId: lobby.gameId, token: result.session.token, player: result.session.player });
+        sendJson(res, 200, {
+          gameId: lobby.gameId,
+          gameCode: lobby.gameCode,
+          token: result.session.token,
+          player: result.session.player,
+        });
         return;
       }
 
@@ -418,6 +461,83 @@ export function startServer(opts: ServerOptions): void {
         return;
       }
 
+      /**
+       * GIVING UP A SEAT — the player's own, or (host only) somebody else's.
+       *
+       * There was no door out of a lobby before this: a mis-join or a player who wandered off left a
+       * chair that could not be freed, and a table that cannot start until every chair is taken.
+       * The host's "remove" and a player's "Leave" are the same act from opposite ends, so they are
+       * one route — `seat` names somebody else's chair and is refused to anyone but the host.
+       */
+      if (url.pathname === '/api/lobby/leave' && req.method === 'POST') {
+        const body = (await readJson(req)) as { token?: string; seat?: number };
+        const ps = typeof body.token === 'string' ? sessions.get(body.token) : undefined;
+        const lobby = ps ? lobbies.get(ps.gameId) : undefined;
+        if (!ps || !lobby) {
+          sendJson(res, 404, { error: 'no such lobby' });
+          return;
+        }
+        const seat = typeof body.seat === 'number' ? (body.seat as PlayerIndex) : undefined;
+        if (seat !== undefined && seat !== ps.player && lobby.hostToken !== ps.token) {
+          sendJson(res, 403, { error: 'NOT_HOST' });
+          return;
+        }
+        const result = leaveLobby(lobby, ps.token, seat);
+        if (result.empty) {
+          // Nobody human is left to start it. Everything about this lobby goes, including the code,
+          // so it cannot be joined into a game that will never begin.
+          lobbies.delete(lobby.gameId);
+          gameCodes.delete(lobby.gameCode);
+          for (const [, watcher] of lobbyConnections.get(lobby.gameId) ?? []) watcher.end();
+          lobbyConnections.delete(lobby.gameId);
+          await deleteLobby(opts.dataDir, lobby.gameId);
+          // The row goes with the lobby rather than being marked: a game that never started is not a
+          // game an administrator has any use for a record of.
+          await removeIndexEntry(opts.dataDir, lobby.gameId);
+          sendJson(res, 200, { ok: true, closed: true });
+          return;
+        }
+        await persistLobby(result.lobby);
+        broadcastLobby(lobby.gameId);
+        sendJson(res, 200, { ok: true });
+        return;
+      }
+
+      /**
+       * WHAT AM I ABOUT TO JOIN? Read-only, takes no seat, and gated by the same join secret the
+       * door itself is.
+       *
+       * A player used to have to take a chair before they could see a single rule of the game they
+       * were sitting down to — and until 2026-08-23 there was then no way back out of it.
+       */
+      if (url.pathname === '/api/lobby/preview' && req.method === 'GET') {
+        if (url.searchParams.get('secret') !== opts.joinSecret) {
+          sendJson(res, 403, { error: 'bad or missing secret' });
+          return;
+        }
+        const code = (url.searchParams.get('gameCode') ?? '').trim().toUpperCase();
+        const gameId = gameCodes.get(code);
+        const lobby = gameId ? lobbies.get(gameId) : undefined;
+        if (!lobby) {
+          sendJson(res, 404, { error: 'no open lobby with that code' });
+          return;
+        }
+        const hostSeat = lobby.seats.find((seat) => seat?.kind === 'human' && seat.token === lobby.hostToken);
+        const preview: LobbyPreview = {
+          gameCode: lobby.gameCode,
+          hostName: hostSeat?.kind === 'human' ? hostSeat.displayName : 'unknown',
+          config: lobby.config,
+          players: lobby.seats.length,
+          seated: lobby.seats.map((seat, i) => ({
+            seat: i,
+            who: seat?.kind === 'human' ? seat.displayName : null,
+            bot: seat?.kind === 'bot',
+          })),
+        };
+        sendJson(res, 200, preview);
+        return;
+      }
+
       if (url.pathname === '/api/lobby/start' && req.method === 'POST') {
         const body = (await readJson(req)) as { token?: string };
         const ps = typeof body.token === 'string' ? sessions.get(body.token) : undefined;
@@ -523,7 +643,13 @@ export function startServer(opts: ServerOptions): void {
         const conns = gameConnections.get(gameId) ?? new Map<PlayerIndex, ServerResponse>();
         conns.set(seat, res);
         gameConnections.set(gameId, conns);
-        writeSse(res, nextEventId(gameId, seat), session.connect(seat));
+        const ever = everConnected.get(gameId) ?? new Set<PlayerIndex>();
+        ever.add(seat);
+        everConnected.set(gameId, ever);
+        // The board, and who else is at the table — the second half used to be missing entirely.
+        const first = session.connect(seat);
+        first.presence = presenceOfOthers(gameId, seat, session);
+        writeSse(res, nextEventId(gameId, seat), first);
         broadcastPresence(gameId, seat, true);
         // Idle for minutes at a time is the expected shape of this game (multiplayer.md §9) — a
         // silent SSE connection is exactly what a proxy in the path may reap. A comment line is not a

src/server/lobby.ts

@@ -50,7 +50,12 @@ export type Lobby = {
 };
 
 export type CreateResult = { lobby: Lobby; session: PlayerSession };
-export type JoinResult = { ok: true; lobby: Lobby; session: PlayerSession } | { ok: false; code: 'LOBBY_FULL' | 'ALREADY_STARTED' };
+export type JoinResult =
+  | { ok: true; lobby: Lobby; session: PlayerSession }
+  | { ok: false; code: 'LOBBY_FULL' | 'ALREADY_STARTED' | 'NAME_TAKEN' };
+/** `empty` when the last human has gone — the caller drops the lobby rather than leaving a table of
+ * bots waiting for a host who no longer exists. */
+export type LeaveResult = { lobby: Lobby; empty: boolean };
 export type StartResult = { ok: true; playerNames: string[]; botSeats: PlayerIndex[] } | { ok: false; code: 'NOT_HOST' | 'BAD_PLAYER_COUNT' };
 
 /**
@@ -140,6 +145,19 @@ export function joinLobby(lobby: Lobby, displayName: string): JoinResult {
   const seatIndex = lobby.seats.findIndex((s) => s === null);
   if (seatIndex < 0) return { ok: false, code: 'LOBBY_FULL' };
 
+  /**
+   * TWO PLAYERS CANNOT SHARE A NAME (2026-08-23).
+   *
+   * The name is not decoration: it labels the district on the Division map, it is what the turn
+   * chart means by "waiting on Jesse", and `record()` puts it in front of every line that player
+   * causes. Two identical names make all three ambiguous, and there is no way to fix it once the
+   * game starts — the names are locked into the session at `Lobby.Start`. Refused rather than
+   * silently suffixed: a player should play under the name they chose, or be told to choose again.
+   */
+  const wanted = displayName.trim().toLowerCase();
+  const clash = lobby.seats.some((s) => s?.kind === 'human' && s.displayName.trim().toLowerCase() === wanted);
+  if (clash) return { ok: false, code: 'NAME_TAKEN' };
+
   const token = randomUUID();
   const session: PlayerSession = { token, gameId: lobby.gameId, player: seatIndex, displayName };
   const seats = [...lobby.seats];
@@ -151,6 +169,35 @@ export function joinLobby(lobby: Lobby, displayName: string): JoinResult {
   };
 }
 
+/**
+ * GIVING UP A SEAT — a player leaving, or the host clearing somebody out of a chair.
+ *
+ * There was no way out of a lobby at all before 2026-08-23: a mis-join or a player who wandered off
+ * wedged the table, because Start needs every chair filled and `setBotSeat` refuses to touch an
+ * occupied human seat. One function serves both, since they differ only in whose seat is named, and
+ * `http.ts` is what checks that a caller naming somebody else's seat is the host.
+ *
+ * Host rights move exactly as they do on a dropped connection (`reassignHost`), and the caller is
+ * told when the last human has gone so the lobby can be dropped rather than left orphaned.
+ */
+export function leaveLobby(lobby: Lobby, token: string, seat?: PlayerIndex): LeaveResult {
+  const index =
+    seat === undefined ? lobby.seats.findIndex((s) => s?.kind === 'human' && s.token === token) : seat;
+  const occupant = index >= 0 ? (lobby.seats[index] ?? null) : null;
+  if (index < 0 || occupant?.kind !== 'human') return { lobby, empty: false };
+
+  const seats = [...lobby.seats];
+  seats[index] = null;
+  const departing = occupant.token;
+  const withoutThem: Lobby = {
+    ...lobby,
+    seats,
+    joinOrder: lobby.joinOrder.filter((t) => t !== departing),
+  };
+  const empty = !seats.some((s) => s?.kind === 'human');
+  return { lobby: reassignHost(withoutThem, departing), empty };
+}
+
 /** Host-only in effect (`http.ts` checks the caller's token against `hostToken` before calling
  * this) — marks an empty seat as bot-filled, or clears one back to empty. Never touches an occupied
  * human seat; the host removes a person by them leaving, not by overwriting their seat. */

src/server/session.ts

@@ -42,14 +42,33 @@ export type Push = {
   /** Narration since the LAST push to this specific seat, not the whole game's log. */
   lines: { text: string; tone: string }[];
   /**
-   * Connection news about ANOTHER seat — never this push's own recipient. `lobby-and-sessions.md`
+   * Connection news about OTHER seats — never this push's own recipient. `lobby-and-sessions.md`
    * §5: a disconnect is server-layer news about a connection, not a `GameEvent`, so it must not go
    * through the engine or the shared narration log (which must stay replayable from a seed). Built
    * and broadcast entirely by `http.ts`, which already owns the connection table; `session.ts` never
    * sets this field itself — every `Push` `session.ts` builds carries a real `frame` and no
    * `presence`, and `http.ts`'s presence notices carry no `frame` and no `menu`.
+   *
+   * A LIST, since 2026-08-23: a connecting client is told about every other seat at once. It used to
+   * learn of a seat only when that seat disconnected AFTER it connected, so a player arriving at a
+   * table where two people had not shown up yet was told nothing at all. `seen` distinguishes "was
+   * here and dropped" from "has never opened the game".
    */
-  presence?: { seat: PlayerIndex; connected: boolean };
+  presence?: { seat: PlayerIndex; connected: boolean; seen: boolean }[];
+  /**
+   * THE FOUR TRANSIENT SIGNALS (2026-08-23) — what solitaire has always drawn and multiplayer never
+   * did: sound cues, the timetable slot a D12 just filled, a one-line announcement, and the card
+   * that just came into this seat's hand.
+   *
+   * The first three are SHARED — a collision anywhere on the Division, the Stage bell, a train
+   * running off the end pays everyone — so they are identical in every seat's push and drained once
+   * per broadcast. `justDrawn` is not: it goes ONLY to the seat that drew it (`game.justDrawn` is
+   * one field for the whole game and does not say whose). `test/redaction.test.ts` is the guard.
+   */
+  cues?: string[];
+  scheduled?: number | null;
+  announcement?: string | null;
+  justDrawn?: string | null;
 };
 
 /**
@@ -141,6 +160,9 @@ function buildSession(
   lastMoveAtInit: number,
 ): GameSession {
   let lastMoveAt = lastMoveAtInit;
+  /** Who drew the card `game.justDrawn` names. The engine records WHICH card came into hand but not
+   * whose hand it went into, and that is the whole difference between a badge and a leak. */
+  let lastDraw: { seat: PlayerIndex; cardId: string } | null = null;
   const lastSeq = new Map<PlayerIndex, number>();
   const lastFrame = new Map<PlayerIndex, Frame>();
   const sentLines = new Map<PlayerIndex, number>();
@@ -166,16 +188,41 @@ function buildSession(
     return seat === currentActor(game) ? actionMenu(game, seat) : null;
   }
 
-  function pushFor(seat: PlayerIndex): Push {
+  /** What the last batch of events earned, drained from the game exactly once and then handed to
+   * every seat. `null` on a (re)connect: a fresh connection is drawing a STATE, and replaying the
+   * sounds of everything it missed would be a burst of noise about the past. */
+  type Moment = { cues: string[]; scheduled: number | null; announcement: string | null };
+
+  function takeMoment(): Moment {
+    const cues = game.cues.splice(0, game.cues.length);
+    const scheduled = game.scheduled;
+    game.scheduled = null;
+    const announcement = game.announced;
+    game.announced = null;
+    return { cues, scheduled, announcement };
+  }
+
+  function pushFor(seat: PlayerIndex, moment: Moment | null): Push {
     const frame = frameFor(seat);
     const delta = deltaFrame(lastFrame.get(seat) ?? null, frame);
     lastFrame.set(seat, frame);
-    return { frame: delta, menu: menuFor(seat), lines: linesSince(seat) };
+    const push: Push = { frame: delta, menu: menuFor(seat), lines: linesSince(seat) };
+    if (moment) {
+      if (moment.cues.length > 0) push.cues = moment.cues;
+      if (moment.scheduled !== null) push.scheduled = moment.scheduled;
+      if (moment.announcement !== null) push.announcement = moment.announcement;
+    }
+    // The drawer's own card, and nobody else's — on a reconnect too, so the badge survives a refresh.
+    if (lastDraw !== null && lastDraw.seat === seat) push.justDrawn = lastDraw.cardId;
+    return push;
   }
 
   function pushesForAll(): Map<PlayerIndex, Push> {
+    const moment = takeMoment();
     const out = new Map<PlayerIndex, Push>();
-    for (let seat = 0; seat < playerNames.length; seat++) out.set(seat as PlayerIndex, pushFor(seat as PlayerIndex));
+    for (let seat = 0; seat < playerNames.length; seat++) {
+      out.set(seat as PlayerIndex, pushFor(seat as PlayerIndex, moment));
+    }
     return out;
   }
 
@@ -224,13 +271,21 @@ function buildSession(
       const options = legalActions(game.state, actor);
       if (options.length === 0) return;
       const choice = developerBot.choose(game.state, actor, options);
+      const drawnBefore = game.justDrawn;
       const ok = submit(game, choice);
+      if (game.justDrawn !== drawnBefore && game.justDrawn !== null) {
+        lastDraw = { seat: actor, cardId: game.justDrawn };
+      }
       /* c8 ignore next -- `options` came from `legalActions`, so `choice` is always legal. */
       if (!ok) throw new Error(`driveBots: developerBot chose an illegal action for seat ${actor}`);
       settleTiming();
     }
   }
   driveBots();
+  // 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();
 
   return {
     playerCount: playerNames.length,
@@ -240,7 +295,7 @@ 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);
+      return pushFor(seat, null);
     },
 
     intent(seat, seq, i) {
@@ -259,7 +314,11 @@ function buildSession(
       const code = check(game.state, seat, i);
       if (code) return { accepted: false, code };
 
+      const drawnBefore = game.justDrawn;
       const applied = submit(game, i);
+      if (game.justDrawn !== drawnBefore && game.justDrawn !== null) {
+        lastDraw = { seat, cardId: game.justDrawn };
+      }
       /* c8 ignore next -- `check` above already proved this intent is legal; `submit` cannot then refuse it. */
       if (!applied) return { accepted: false, code: 'REJECTED' };
 

src/sim/bot.ts

@@ -139,7 +139,7 @@ export function makeDeveloperBot(tweaks: BotTweaks): BotPolicy {
   choose(s, player, options) {
     lastReason = 'no specific reason — first legal option';
     const clearance = ruleOnClearance(options);
-    if (clearance) return because('the Superintendent must rule on a following train (§8.1)', clearance);
+    if (clearance) return because('the Superintendent must rule on a following train', clearance);
 
     // Red Flags come before anything else — protection is only worth playing at the moment the
     // collision is actually pending, and that moment passes.

src/sim/narrate.ts

@@ -267,7 +267,7 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
     case 'secondSectionOrdered':
       return {
         tone: 'bad',
-        text: `SECOND SECTION ordered on Train ${e.trainNumber} — an identical train will run right behind it, which forces the Superintendent to rule on a following train (§8.1)`,
+        text: `SECOND SECTION ordered on Train ${e.trainNumber} — an identical train will run right behind it, which forces the Superintendent to rule on a following train`,
       };
     /**
      * WHERE THE PLAYER PUT IT, not where its number would have sent it.
@@ -382,7 +382,7 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
       return {
         tone: 'good',
         text: bumped
-          ? `Train ${e.trainNumber} SCHEDULED at Stage ${e.slot + 1} — rolled ${e.roll}, but Stage ${e.roll} was already taken, so it moved down the column to the next free Stage (§7)`
+          ? `Train ${e.trainNumber} SCHEDULED at Stage ${e.slot + 1} — rolled ${e.roll}, but Stage ${e.roll} was already taken, so it moved down the column to the next free Stage`
           : `Train ${e.trainNumber} SCHEDULED to depart at Stage ${e.slot + 1} (rolled ${e.roll}) — it will run at this time EVERY Day from now on`,
       };
     }
@@ -400,9 +400,9 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
       // player the score had changed and nothing else.
       const why =
         e.reason === 'no free A/D track'
-          ? `it arrived at ${e.where} with every A/D track already occupied — there was nowhere to put it (§8.3)`
+          ? `it arrived at ${e.where} with every A/D track already occupied — there was nowhere to put it`
           : e.reason === 'cars fouling the Running Track'
-            ? `it ran into cars left standing on ${e.where} between the Limits and the Office (§8.3)`
+            ? `it ran into cars left standing on ${e.where} between the Limits and the Office`
             : e.reason;
       const wrecked = e.trains
         .map((t) => `${t.label} (${t.consist.length ? carsLabel(t.consist) : 'no cars'})`)
@@ -411,7 +411,7 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
         tone: 'bad',
         text:
           `COLLISION — ${wrecked} destroyed: ${why}. Engines and cabooses go back to the Division ` +
-          `Yard, all other cars to the Classification Yard (§10). A Timetabled train card returns ` +
+          `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.`,
       };
     }
@@ -420,7 +420,7 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
       return {
         tone: 'bad',
         text:
-          `SUPERINTENDENT MUST RULE (§8.1): ${train(e.trainId)} wants to enter the Mainline card ` +
+          `SUPERINTENDENT MUST RULE: ${train(e.trainId)} wants to enter the Mainline card ` +
           `that ${train(e.occupiedBy)} is still crossing. Allow it and ${train(e.trainId)} may run ` +
           `into the back of ${train(e.occupiedBy)} — a collision costs 5 Revenue. Hold it and it ` +
           `waits where it is, losing time but safe.`,
@@ -440,13 +440,13 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
       return {
         tone: 'good',
         where: e.at,
-        text: `Porter boarded passengers at ${at(e.at)} — one coach per Porter per Stage (§9.2)`,
+        text: `Porter boarded passengers at ${at(e.at)} — one coach per Porter per Stage`,
       };
     case 'passengersDetrained':
       return {
         tone: 'good',
         where: e.at,
-        text: `Porter de-trained passengers at ${at(e.at)} — one coach per Porter per Stage (§9.2)`,
+        text: `Porter de-trained passengers at ${at(e.at)} — one coach per Porter per Stage`,
       };
 
     // -- freight pipeline
@@ -562,7 +562,7 @@ export function impediments(s: GameState, player: PlayerIndex = 0): Impediment[]
         why: blockedByBox
           ? 'green box has a load but MEN is occupied'
           : `a load is staged but no empty ${want} is spotted on this industry's track — it stays ` +
-            'in the green box until a crew sets one out here (§9.3)',
+            'in the green box until a crew sets one out here',
         severity: blockedByBox ? 'waiting' : 'stuck',
       });
     }
@@ -583,7 +583,7 @@ export function impediments(s: GameState, player: PlayerIndex = 0): Impediment[]
         why: spotted
           ? 'green box empty — nothing to load (needs a Freight Agent action)'
           : `green box empty — the Freight Agent can stage a load now, but no empty ${want} is ` +
-            'spotted here, so a crew must set one out before Laborers can work it (§9.3)',
+            'spotted here, so a crew must set one out before Laborers can work it',
         severity: 'waiting',
       });
     }
@@ -668,7 +668,7 @@ export function impediments(s: GameState, player: PlayerIndex = 0): Impediment[]
 
       if (pf.porters < 1) {
         say(
-          'this Office has NO Porters — a Whistle Post is not a Passenger Facility (§9) and cannot ' +
+          'this Office has NO Porters — a Whistle Post is not a Passenger Facility and cannot ' +
             'work passengers at all. Upgrade it to a Depot or better.',
           'stuck',
         );
@@ -691,7 +691,7 @@ export function impediments(s: GameState, player: PlayerIndex = 0): Impediment[]
           );
         }
         if (loadedOnTrain && !s.yards.divisionYard.some((c) => c.type === 'coach' && !c.loaded)) {
-          say('no EMPTY coach in the Division Yard to swap into the train (§9.2 requires one)');
+          say('no EMPTY coach in the Division Yard to swap into the train — one is required');
         }
       }
     }

src/sim/replay.ts

@@ -492,7 +492,11 @@ function boxes(items, cap, cls) {
 
 function render() {
   const f = FRAMES[i];
-  $('turnchart').innerHTML = turnChartHtml(f, f.actor === null ? null : 'Player ' + (f.actor + 1));
+  $('turnchart').innerHTML = turnChartHtml(
+    f,
+    f.actor === null ? null : 'Player ' + (f.actor + 1),
+    f.players.length > 1 ? 'Player ' + (f.superintendent + 1) : null,
+  );
   $('super').textContent = 'P' + f.superintendent;
   $('rev').textContent = f.revenue;
   $('rev').className = 'big ' + (f.revenue < 0 ? 't-bad' : f.revenue > 0 ? 't-good' : '');

src/sim/turnchart.ts

@@ -27,7 +27,18 @@ export type TurnChartFrame = {
  * The first three are the rules text; Cargo and Supervisor Shift are written from what the engine
  * does, since the recovered sheet does not spell them out.
  */
-export function turnChartHtml(f: TurnChartFrame, actorName: string | null): string {
+/**
+ * `superName` is the player holding the Fedora, or null for a table where saying so is noise — one
+ * seat, where it is always you.
+ *
+ * REPORTED BY JESSE 2026-08-23, from a two-player game on StartOS: seat 1 played a train card and
+ * seat 2 was asked to build the train, "what's the rule for WHICH player builds a train?" The engine
+ * was right — §7 makes up a consist "starting with the Superintendent and working left" — but the
+ * board did not name the Superintendent ANYWHERE, so the question could not be answered from the
+ * screen. `Frame` has carried `superintendent` all along and the standalone replay printed it; the
+ * live game never did.
+ */
+export function turnChartHtml(f: TurnChartFrame, actorName: string | null, superName: string | null = null): string {
   const PHASES: { key: string; label: string; tip: string; icon: string }[] = [
     {
       key: 'localOps',
@@ -39,7 +50,10 @@ export function turnChartHtml(f: TurnChartFrame, actorName: string | null): stri
     {
       key: 'newTrain',
       label: 'New Train',
-      tip: 'Timetabled trains for this Stage are built. New timetabled trains are randomly placed on the timetable. Held trains are built. Extra trains are built.',
+      // 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.',
       // 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"/>',
     },
@@ -81,12 +95,18 @@ export function turnChartHtml(f: TurnChartFrame, actorName: string | null): stri
 
   // 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';
+  const fedora =
+    superName === null
+      ? ''
+      : `<div class="tc-super" data-tip="The Superintendent holds the Fedora. Every third Stage — 3, 6, 9 and 12 — it passes one seat to the left. The office rules on whether a following train may depart, and every round that goes round the table starts here: the New Train make-up round, and the acting order within a phase." tabindex="0">` +
+        `<span aria-hidden="true">🎩</span> Superintendent <b>${esc(superName)}</b></div>`;
 
   return (
     `<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>`
   );
 }
@@ -112,6 +132,11 @@ export const TURNCHART_CSS = `
 .tc-who{display:flex;align-items:center;gap:6px;font-size:12px;color:#8b94a3}
 .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}
+.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;
   padding:3px 10px 3px 7px;font-size:11px;color:#8b94a3;background:#1a1f26;cursor:help}

src/sim/view.ts

@@ -46,7 +46,7 @@ import {
   mainlineDescription,
 } from '../engine/content.ts';
 import type { Intent } from '../engine/intents.ts';
-import type { Facility, GameState, PlayerIndex, SeatIndex, TrackCard, TurnoutOrientation } from '../engine/state.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 { Port } from '../engine/track.ts';
@@ -374,6 +374,16 @@ export type Frame = {
    * must be able to answer. Resolved, never partial, so nobody downstream re-applies defaults.
    */
   houseRules: HouseRules;
+  /**
+   * WHICH GAME THIS IS — the mode it is scored under and Appendix B's three switches.
+   *
+   * Added 2026-08-23 with the game types (`web/presets.ts`). Everything else needed to name a game
+   * "Co-op" or "Cutthroat" was already here; `mode` and `optionalRules` were the two missing pieces,
+   * so a remote client could see the dials but not what they added up to — and a Cutthroat game
+   * looked exactly like a Co-op one from the board.
+   */
+  mode: GameConfig['mode'];
+  optionalRules: GameConfig['optionalRules'];
   /**
    * The victory-condition dials this game was configured with (`GameConfig`, `state.ts`), plus the
    * running collision counts — same reasoning as `houseRules`: a remote client holds no `GameState`
@@ -1313,6 +1323,8 @@ export function snapshot(
     wasted,
     option: turnOf(s, viewer).option,
     houseRules: houseRules(s.config),
+    mode: s.config.mode,
+    optionalRules: s.config.optionalRules,
     days: s.config.days,
     minCombinedRevenue: s.config.minCombinedRevenue,
     maxCollisionsPerDay: s.config.maxCollisionsPerDay,

src/web/game.ts

@@ -121,6 +121,14 @@ export type NewGameOptions = {
   minCombinedRevenue?: number;
   maxCollisionsPerDay?: number;
   maxCollisionsTotal?: number;
+  /**
+   * Appendix B's three, added 2026-08-23 when the New Game dialog gained them.
+   *
+   * The lobby has offered these since v0.6.0 and the solitaire dialog could not, which meant a
+   * solitaire game could never be played under Employee Rotation or the Emergency Toolbox at all.
+   * Partial like `houseRules`: a caller names only what it is setting.
+   */
+  optionalRules?: Partial<GameConfig['optionalRules']>;
 };
 
 /** The same config with the New Game dialog's answers in it. */
@@ -131,6 +139,7 @@ export function configWith(opts: NewGameOptions): GameConfig {
     minCombinedRevenue: opts.minCombinedRevenue ?? SOLO_CONFIG.minCombinedRevenue,
     maxCollisionsPerDay: opts.maxCollisionsPerDay ?? SOLO_CONFIG.maxCollisionsPerDay,
     maxCollisionsTotal: opts.maxCollisionsTotal ?? SOLO_CONFIG.maxCollisionsTotal,
+    optionalRules: { ...SOLO_CONFIG.optionalRules, ...(opts.optionalRules ?? {}) },
     houseRules: houseRules(opts.houseRules ? { houseRules: opts.houseRules } : {}),
   };
 }
@@ -1136,10 +1145,15 @@ function configFor(save: Save, config: GameConfig): GameConfig {
  *
  * Returns null when there is nothing to undo, so the caller can leave the button disabled.
  */
-export function undo(game: Game, config: GameConfig = SOLO_CONFIG): Game | null {
+export function undo(game: Game, config: GameConfig = game.state.config): Game | null {
   if (game.history.length === 0) return null;
   // `toSave` first, so the rules this game was dealt under come with it. Rebuilding the save by hand
   // here dropped them, and undo re-dealt the game under the defaults instead of its own settings.
+  //
+  // THE VICTORY DIALS COME FROM THE GAME ITSELF for the same reason (2026-08-23). `Save` carries only
+  // the house rules, so defaulting this parameter to `SOLO_CONFIG` meant undoing a game dealt over
+  // eight Days replayed it as a five-Day game — the length, the Revenue floor and both collision
+  // caps all quietly reverting to the defaults.
   return fromSave({ ...toSave(game), history: game.history.slice(0, -1) }, config);
 }
 

src/web/lobby.ts

@@ -1,10 +1,22 @@
 /**
- * The lobby screen — Phase 4 of `docs/architecture/multiplayer.md` (§12 steps 17-20).
+ * The lobby screen — Phase 4 of `docs/architecture/multiplayer.md` (§12 steps 17-20), rebuilt
+ * 2026-08-23 (Jesse's cleanup pass).
  *
- * Everything in `#lobby` (`play.html`) is owned here: the join-secret gate, creating or joining a
- * game by code, and the seating screen up to `Lobby.Start`. `main.ts` calls `runLobby` once, at
- * `start()`, only when there is no stored session to reconnect with — see `main.ts`'s own comment
- * on why a stored `{token, gameId, seat}` skips this module entirely.
+ * Everything in `#lobby` (`play.html`) is owned here: the join-secret gate, the two doors (join a
+ * game, create one), the read-only preview a player reads BEFORE taking a seat, and the seating
+ * screen up to `Lobby.Start`.
+ *
+ * WHAT CHANGED, and why each one was worth changing:
+ *   - JOINING CAME FIRST. It used to be a heading below the whole create form — fifteen fields a
+ *     player who was handed a code has no use for.
+ *   - A SEAT SURVIVES A RELOAD. The token was held in a closure and only written to `localStorage`
+ *     at `Lobby.Start`, so a refresh before the host started orphaned the chair: the player could
+ *     not get back and the seat could not be freed. `onSeated` hands it to `main.ts` immediately.
+ *   - THERE IS A WAY OUT. `/api/lobby/leave` frees a seat, so a mis-join or a player who wanders off
+ *     no longer wedges a table that cannot start until every chair is taken.
+ *   - THE STREAM CAN FAIL OUT LOUD. `onmessage` was the only handler; a dropped connection left the
+ *     seating screen frozen and silent.
+ *   - THE RULES ARE VISIBLE TO EVERYONE, not just the host who typed them.
  *
  * MIRRORS SERVER TYPES RATHER THAN IMPORTING THEM, same choice `web/session.ts` already made for
  * `Push`: this file must never depend on anything under `src/server/`, even at the type level, since
@@ -12,12 +24,36 @@
  */
 
 import type { GameConfig, PlayerIndex } from '../engine/state.ts';
-import { defaultMultiplayerConfig } from './game.ts';
-import { STARTING_HAND_LABELS, houseRules } from '../engine/content.ts';
-import type { StartingHand } from '../engine/content.ts';
+import {
+  closestPreset,
+  configFromSettings,
+  gameTypeLabel,
+  preset,
+  presetSettings,
+} from './presets.ts';
+import type { GameType, PresetName } from './presets.ts';
+import { rulesListHtml, settingsForm } from './settings-form.ts';
 import { seatLabel } from '../sim/view.ts';
 
-export type LobbyReady = { token: string; gameId: string; seat: PlayerIndex };
+export type LobbyReady = { token: string; gameId: string; seat: PlayerIndex; gameCode: string };
+
+/** What the page must do with a seat this screen takes or gives up. `main.ts` owns the storage; this
+ * module owns the moments. */
+export type LobbyHandlers = {
+  /** The game has begun — tear this screen down and build a `RemoteSession`. Called at most once. */
+  onReady: (r: LobbyReady) => void;
+  /** A seat is now held. Called before the game starts, so a reload can come back to it. */
+  onSeated: (s: { token: string; gameId: string; gameCode: string }) => void;
+  /** The seat is gone — left, removed, or the lobby closed under us. Forget the stored record. */
+  onLeft: (gameId?: string) => void;
+  /** Every game this browser still holds a seat in — the page owns the storage, this screen only
+   * draws it. */
+  known?: () => { gameId: string; gameCode: string; stage: 'lobby' | 'game' }[];
+  /** Re-enter one of them. */
+  rejoin?: (gameId: string) => void;
+  /** Give one up for good: the token is the only proof of identity, so this cannot be undone. */
+  forget?: (gameId: string) => void;
+};
 
 type LobbySeat = { kind: 'human'; token: string; displayName: string } | { kind: 'bot' } | null;
 type Lobby = {
@@ -30,12 +66,46 @@ type Lobby = {
   createdAt: number;
 };
 type LobbyPush = { lobby: Lobby; you: PlayerIndex; started: boolean };
+type Preview = {
+  gameCode: string;
+  hostName: string;
+  config: GameConfig;
+  players: number;
+  seated: { seat: number; who: string | null; bot: boolean }[];
+};
 
 /** Per-origin, same reasoning `lobby-and-sessions.md` §1 gives for the session token itself — a
  * secret typed at one address means nothing at another. */
 const SECRET_KEY = 'stationmaster-joinsecret';
+/** The name is not a credential; it is remembered for the same reason the secret is — nobody should
+ * retype what they typed last time. */
+const NAME_KEY = 'stationmaster-displayname';
 
 const $ = <T extends HTMLElement = HTMLElement>(id: string): T => document.getElementById(id) as T;
+const has = (id: string): boolean => document.getElementById(id) !== null;
+
+/**
+ * A server code turned into a sentence.
+ *
+ * `LOBBY_FULL` and `BAD_PLAYER_COUNT` used to be printed at the player exactly as the server said
+ * them. The codes are the server's vocabulary, not the table's.
+ */
+function explain(code: unknown, fallback: string): string {
+  const messages: Record<string, string> = {
+    LOBBY_FULL: 'That table is already full — every chair is taken.',
+    ALREADY_STARTED: 'That game has already started.',
+    BAD_PLAYER_COUNT: 'That table size cannot start a game — 2 to 4 players.',
+    NOT_HOST: 'Only the host can do that.',
+    NAME_TAKEN: 'Somebody at that table is already using that name — pick another.',
+    'bad or missing secret': 'That join secret was not accepted by this server.',
+    // What a lobby answers once it has become a GAME — most often seen by a host pressing Start
+    // twice, and by a tab left open on a lobby that started somewhere else.
+    'no such lobby': 'That game is no longer waiting to start — it has either begun or been closed.',
+    'no open lobby with that code': 'No game is waiting under that code. Check it, or ask for a new one — a game that has already started cannot be joined.',
+  };
+  const key = typeof code === 'string' ? code : '';
+  return messages[key] ?? (key !== '' ? key : fallback);
+}
 
 async function postJson(path: string, body: unknown): Promise<{ status: number; body: Record<string, unknown> }> {
   const res = await fetch(path, {
@@ -46,21 +116,73 @@ async function postJson(path: string, body: unknown): Promise<{ status: number;
   return { status: res.status, body: (await res.json()) as Record<string, unknown> };
 }
 
+async function getJson(path: string): Promise<{ status: number; body: Record<string, unknown> }> {
+  const res = await fetch(path);
+  return { status: res.status, body: (await res.json().catch(() => ({}))) as Record<string, unknown> };
+}
+
 /**
- * Shows `#lobby`, drives it through creating or joining a game and then seating, and calls
- * `onReady` exactly once — the instant `Lobby.Start` fires, from WHICHEVER browser tab started it.
- * Never calls back more than once; the caller is expected to tear this screen down (`main.ts` hides
- * `#lobby` and shows `#gameui`) as its very first action inside `onReady`.
+ * Shows `#lobby` and drives it. `resume` re-enters the seating screen for a browser that already
+ * holds a seat (a reload before the host started) rather than starting at the doors.
  */
-export function runLobby(onReady: (r: LobbyReady) => void): void {
+export function runLobby(handlers: LobbyHandlers, resume?: { token: string; gameId: string; gameCode: string }): void {
+  // Nothing below exists on a page that is not `play.html` — and `main.ts` is imported by tests that
+  // stub only part of the DOM. Bail rather than throwing through the module's caller.
+  if (!has('lobby') || !has('lb-choice-section')) return;
   $('lobby').hidden = false;
-  $<HTMLInputElement>('lb-secret').value = localStorage.getItem(SECRET_KEY) ?? '';
 
+  const form = settingsForm('lb-');
   let source: EventSource | null = null;
+  let done = false;
 
-  function setError(id: string, message: string): void {
-    $(id).textContent = message;
+  /**
+   * THE GAMES THIS BROWSER IS ALREADY IN.
+   *
+   * Rejoining is what the stored token is FOR, and until now the only thing that ever used one was a
+   * bare page load — so a player who left a game, or who joined a second, had no way to get back to
+   * the first. Drawn from the page's own storage (`main.ts`), never from this module.
+   */
+  function renderKnown(): void {
+    if (!has('lb-known')) return;
+    const games = handlers.known?.() ?? [];
+    $('lb-known').hidden = games.length === 0;
+    if (games.length === 0) return;
+    $('lb-known-list').innerHTML = games
+      .map(
+        (g) =>
+          `<div class="lb-known-row"><span class="code">${escapeHtml(g.gameCode || g.gameId.slice(0, 8))}</span>` +
+          `<span class="dim">${g.stage === 'lobby' ? 'waiting to start' : 'in play'}</span>` +
+          `<button class="lb-rejoin" data-game="${escapeHtml(g.gameId)}">Rejoin</button>` +
+          `<button class="lb-forget ghost" data-game="${escapeHtml(g.gameId)}">Forget</button></div>`,
+      )
+      .join('');
+    for (const btn of Array.from($('lb-known-list').querySelectorAll<HTMLButtonElement>('.lb-rejoin'))) {
+      btn.onclick = () => handlers.rejoin?.(btn.dataset['game'] ?? '');
+    }
+    for (const btn of Array.from($('lb-known-list').querySelectorAll<HTMLButtonElement>('.lb-forget'))) {
+      btn.onclick = () => {
+        // Confirmed, because it is not recoverable from this browser: the token IS the identity
+        // (`lobby-and-sessions.md` §1), and nothing else on this server will accept a claim to that
+        // seat.
+        const code = btn.previousElementSibling?.previousElementSibling?.textContent ?? 'that game';
+        if (!confirm(`Forget ${code}? This browser will not be able to rejoin it — your seat stays in the game, and only whoever runs the server could let you back in.`)) return;
+        handlers.forget?.(btn.dataset['game'] ?? '');
+        renderKnown();
+      };
+    }
   }
+  renderKnown();
+
+  // -- the join secret ------------------------------------------------------------------------
+
+  function showSecret(saved: boolean): void {
+    $('lb-secret-saved').hidden = !saved;
+    $('lb-secret-ask').hidden = saved;
+  }
+  const storedSecret = localStorage.getItem(SECRET_KEY) ?? '';
+  $<HTMLInputElement>('lb-secret').value = storedSecret;
+  showSecret(storedSecret !== '');
+  $<HTMLButtonElement>('lb-secret-change').onclick = () => showSecret(false);
 
   function secret(): string {
     const value = $<HTMLInputElement>('lb-secret').value;
@@ -68,25 +190,248 @@ export function runLobby(onReady: (r: LobbyReady) => void): void {
     return value;
   }
 
+  /** A rejected secret re-opens the field it is about — the error used to appear a screen away from
+   * the box that caused it. */
+  function secretRejected(status: number): boolean {
+    if (status !== 403) return false;
+    showSecret(false);
+    $<HTMLInputElement>('lb-secret').focus();
+    return true;
+  }
+
+  // -- display name ---------------------------------------------------------------------------
+
+  const nameField = $<HTMLInputElement>('lb-name');
+  nameField.value = localStorage.getItem(NAME_KEY) ?? '';
+  function displayName(): string {
+    const value = nameField.value.trim();
+    if (value !== '') localStorage.setItem(NAME_KEY, value);
+    return value;
+  }
+
+  // -- the two doors --------------------------------------------------------------------------
+
+  function door(which: 'join' | 'create'): void {
+    $('lb-join-panel').hidden = which !== 'join';
+    $('lb-create-panel').hidden = which !== 'create';
+    $('lb-door-join').classList.toggle('active', which === 'join');
+    $('lb-door-create').classList.toggle('active', which === 'create');
+  }
+  $<HTMLButtonElement>('lb-door-join').onclick = () => door('join');
+  $<HTMLButtonElement>('lb-door-create').onclick = () => door('create');
+
+  // -- the create form ------------------------------------------------------------------------
+
+  /** The named type the form is currently measured against — and, for a Custom game, the type it is
+   * scored as. Custom is only ever reached FROM one of these, so there is always an answer. */
+  let base: PresetName = 'coop';
+  let type: GameType = 'coop';
+  /** Once the host types a Revenue floor it is theirs; players and days stop re-deriving it. */
+  let floorTyped = false;
+
+  const players = (): number => Number($<HTMLSelectElement>('lb-players').value) || 4;
+  const days = (): number => {
+    const raw = Number($<HTMLInputElement>('lb-days').value);
+    return Number.isFinite(raw) && raw >= 1 ? Math.round(raw) : 5;
+  };
+
+  function typeRadios(): HTMLInputElement[] {
+    return Array.from(document.querySelectorAll<HTMLInputElement>('input[name="lb-type"]'));
+  }
+
+  /** Reset every rule to a named type. Seed, players and days are parameters, and are left alone. */
+  function selectPreset(name: PresetName): void {
+    base = name;
+    type = name;
+    floorTyped = false;
+    const values = presetSettings(name, players(), days());
+    form.write(values, values);
+    form.setEmployeeRotationAvailable(true);
+    refresh();
+  }
+
+  function refresh(): void {
+    const differing = form.mark(base, players(), days());
+    if (differing.length > 0) type = 'custom';
+    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';
+    }
+  }
+
+  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');
+    r.onchange = () => {
+      if (!r.checked) return;
+      if (r.value === 'custom') {
+        // Clicking Custom keeps everything as it stands, and keeps the scoring of the type it came
+        // from (Jesse, 2026-08-23) — it is only ever reached from one of the named types.
+        type = 'custom';
+        refresh();
+        return;
+      }
+      selectPreset(r.value as PresetName);
+    };
+  }
+
+  form.onEdit((key) => {
+    // The floor is derived until somebody sets it; ticking the condition off counts as setting it.
+    if (key === 'minCombinedRevenue') floorTyped = true;
+    type = 'custom';
+    refresh();
+  });
+
+  /** Players and days are parameters, not settings: they re-derive the floor and never make a game
+   * Custom by themselves. */
+  function paramsChanged(): void {
+    if (!floorTyped) {
+      const values = form.read();
+      const want = presetSettings(base, players(), days());
+      form.write({ ...values, minCombinedRevenue: want.minCombinedRevenue }, want);
+    }
+    refresh();
+  }
+  $<HTMLSelectElement>('lb-players').onchange = paramsChanged;
+  $<HTMLInputElement>('lb-days').oninput = paramsChanged;
+
+  selectPreset('coop');
+  door('join');
+
+  // -- creating -------------------------------------------------------------------------------
+
+  $<HTMLButtonElement>('lb-create').onclick = () => {
+    const name = displayName();
+    if (name === '') {
+      $('lb-create-err').textContent = 'Enter a display name first.';
+      return;
+    }
+    const asked = $<HTMLInputElement>('lb-seed').value.trim();
+    // Blank or unparseable both mean "surprise me", which is what leaving the box alone asks for.
+    const seed = asked === '' || !Number.isFinite(Number(asked)) ? null : Math.trunc(Number(asked));
+    const config = configFromSettings(form.read(), preset(base).scoring, days(), preset(base).pvpCards);
+
+    $('lb-create-err').textContent = '';
+    void postJson('/api/lobby/create', {
+      secret: secret(),
+      config,
+      displayName: name,
+      players: players(),
+      seed,
+    }).then(({ status, body }) => {
+      if (status !== 200) {
+        secretRejected(status);
+        $('lb-create-err').textContent = explain(body['error'], 'Could not create the game.');
+        return;
+      }
+      enterSeating(body['gameId'] as string, body['token'] as string, body['gameCode'] as string);
+    });
+  };
+
+  // -- joining --------------------------------------------------------------------------------
+
+  let previewed: Preview | null = null;
+
+  function showPreview(p: Preview): void {
+    previewed = p;
+    $('lb-preview').hidden = false;
+    $('lb-preview-code').textContent = p.gameCode;
+    const near = closestPreset(p.config, p.players, p.config.days);
+    const label = gameTypeLabel(
+      near.differing.length === 0 ? near.name : 'custom',
+      p.config.mode,
+    );
+    $('lb-preview-type').textContent =
+      near.differing.length === 0
+        ? label
+        : `${label} · ${near.differing.length} ${near.differing.length === 1 ? 'setting differs' : 'settings differ'} from ${preset(near.name).label}`;
+    const taken = p.seated.filter((s) => s.who !== null || s.bot).length;
+    const names = p.seated
+      .map((s) => (s.bot ? 'a bot' : (s.who ?? 'empty')))
+      .join(', ');
+    $('lb-preview-who').textContent = `Host: ${p.hostName} · ${taken} of ${p.players} seats taken — ${names}`;
+    $('lb-preview-rules').innerHTML = rulesListHtml(p.config, p.players, p.config.days);
+  }
+
+  $<HTMLButtonElement>('lb-look').onclick = () => {
+    const code = $<HTMLInputElement>('lb-code').value.trim().toUpperCase();
+    $('lb-preview').hidden = true;
+    if (code === '') {
+      $('lb-join-err').textContent = 'Enter the game code you were given.';
+      return;
+    }
+    $('lb-join-err').textContent = '';
+    void getJson(
+      `/api/lobby/preview?gameCode=${encodeURIComponent(code)}&secret=${encodeURIComponent(secret())}`,
+    ).then(({ status, body }) => {
+      if (status !== 200) {
+        secretRejected(status);
+        $('lb-join-err').textContent = explain(body['error'], 'Could not look up that game.');
+        return;
+      }
+      showPreview(body as unknown as Preview);
+    });
+  };
+
+  $<HTMLButtonElement>('lb-join').onclick = () => {
+    const name = displayName();
+    const code = previewed?.gameCode ?? $<HTMLInputElement>('lb-code').value.trim().toUpperCase();
+    if (name === '') {
+      $('lb-join-err').textContent = 'Enter a display name first.';
+      return;
+    }
+    $('lb-join-err').textContent = '';
+    void postJson('/api/lobby/join', { secret: secret(), gameCode: code, displayName: name }).then(
+      ({ status, body }) => {
+        if (status !== 200) {
+          secretRejected(status);
+          $('lb-join-err').textContent = explain(body['error'], 'Could not join that game.');
+          return;
+        }
+        enterSeating(body['gameId'] as string, body['token'] as string, code);
+      },
+    );
+  };
+
+  // -- seating --------------------------------------------------------------------------------
+
   function renderSeating(lobby: Lobby, you: PlayerIndex, token: string): void {
     $('lb-gamecode').textContent = lobby.gameCode;
     const isHost = lobby.hostToken === token;
 
     let html = '';
+    // Bots are numbered here exactly as `startLobby` numbers them at the moment the game starts, so
+    // the table you set up is the table that appears on the board.
+    let botNumber = 0;
     for (let seat = 0; seat < lobby.seats.length; seat++) {
       const occupant = lobby.seats[seat] ?? null;
       const isYou = occupant?.kind === 'human' && occupant.token === token;
       const isSeatHost = occupant?.kind === 'human' && occupant.token === lobby.hostToken;
+      if (occupant?.kind === 'bot') botNumber++;
       const who =
         occupant === null
           ? '<span class="dim">— waiting —</span>'
           : occupant.kind === 'bot'
-            ? 'Bot'
-            : `${occupant.displayName}${isYou ? ' (you)' : ''}${isSeatHost ? ' — host' : ''}`;
+            ? `Bot ${botNumber}`
+            : `${escapeHtml(occupant.displayName)}${isYou ? ' (you)' : ''}${isSeatHost ? ' — host' : ''}`;
       let action = '';
       if (isHost) {
         if (occupant === null) action = `<button class="lb-bot-add" data-seat="${seat}">+ bot</button>`;
         else if (occupant.kind === 'bot') action = `<button class="lb-bot-remove" data-seat="${seat}">remove bot</button>`;
+        else if (!isYou) action = `<button class="lb-kick" data-seat="${seat}">remove</button>`;
       }
       html += `<div class="lb-seat"><span class="dim">Seat ${seatLabel(seat)}</span><span class="who">${who}</span>${action}</div>`;
     }
@@ -94,21 +439,30 @@ export function runLobby(onReady: (r: LobbyReady) => void): void {
 
     /**
      * The code is the whole invitation, so it has to leave this screen by some route other than
-     * being read off it and retyped. `navigator.clipboard` is unavailable on an insecure origin
-     * and can be refused outright, so a failure says the code is there to be selected rather than
-     * silently doing nothing.
+     * being read off it and retyped. Two buttons because they are two different acts: the CODE is
+     * what you read aloud on a call and works at whatever address each player reaches the box by;
+     * the LINK is what you paste into a chat, and only works for someone who can reach this address.
+     * Neither carries the join secret — that is the door key, and it travels out of band.
+     *
+     * `navigator.clipboard` is unavailable on an insecure origin and can be refused outright, so a
+     * failure says the code is there to be selected rather than silently doing nothing.
      */
-    const copyBtn = $<HTMLButtonElement>('lb-copy');
-    copyBtn.onclick = () => {
-      const say = (m: string): void => {
-        $('lb-copied').textContent = m;
-        setTimeout(() => ($('lb-copied').textContent = ''), 4000);
-      };
+    const say = (m: string): void => {
+      $('lb-copied').textContent = m;
+      setTimeout(() => ($('lb-copied').textContent = ''), 4000);
+    };
+    const copy = (text: string, ok: string): void => {
       void navigator.clipboard
-        ?.writeText(lobby.gameCode)
-        .then(() => say('Copied.'))
+        ?.writeText(text)
+        .then(() => say(ok))
         .catch(() => say('Could not copy — select the code above instead.'));
     };
+    $<HTMLButtonElement>('lb-copy').onclick = () => copy(lobby.gameCode, 'Code copied.');
+    $<HTMLButtonElement>('lb-copylink').onclick = () =>
+      copy(
+        `${location.origin}${location.pathname}?lobby&code=${encodeURIComponent(lobby.gameCode)}`,
+        'Invite link copied — the join secret is not in it.',
+      );
 
     for (const btn of Array.from($('lb-seats').querySelectorAll<HTMLButtonElement>('.lb-bot-add'))) {
       btn.onclick = () => void postJson('/api/lobby/bot', { token, seat: Number(btn.dataset['seat']), filled: true });
@@ -116,135 +470,165 @@ export function runLobby(onReady: (r: LobbyReady) => void): void {
     for (const btn of Array.from($('lb-seats').querySelectorAll<HTMLButtonElement>('.lb-bot-remove'))) {
       btn.onclick = () => void postJson('/api/lobby/bot', { token, seat: Number(btn.dataset['seat']), filled: false });
     }
+    for (const btn of Array.from($('lb-seats').querySelectorAll<HTMLButtonElement>('.lb-kick'))) {
+      btn.onclick = () => {
+        void postJson('/api/lobby/leave', { token, seat: Number(btn.dataset['seat']) }).then(({ status, body }) => {
+          if (status !== 200) $('lb-start-note').textContent = explain(body['error'], 'Could not clear that seat.');
+        });
+      };
+    }
+
+    // What everyone at the table is about to play — the host chose it, and until now nobody else
+    // could see any of it.
+    const near = closestPreset(lobby.config, lobby.seats.length, lobby.config.days);
+    const label = gameTypeLabel(near.differing.length === 0 ? near.name : 'custom', lobby.config.mode);
+    $('lb-seating-type').textContent =
+      near.differing.length === 0
+        ? label
+        : `${label} · ${near.differing.length} ${near.differing.length === 1 ? 'setting differs' : 'settings differ'} from ${preset(near.name).label}`;
+    $('lb-seating-rules').innerHTML = rulesListHtml(lobby.config, lobby.seats.length, lobby.config.days);
 
     const waiting = lobby.seats.filter((s) => s === null).length;
     const startBtn = $<HTMLButtonElement>('lb-start');
     startBtn.hidden = !isHost;
     startBtn.disabled = waiting > 0;
-    $('lb-start-note').textContent = isHost
-      ? waiting === 0
-        ? ''
-        : `Waiting on ${waiting} more ${waiting === 1 ? 'player' : 'players'} — add a bot to any empty chair to start now.`
-      : 'Waiting for the host to start the game.';
+    startBtn.textContent = 'Start game';
+    $('lb-start-note').textContent = '';
+    const waitNote = $('lb-stream-note');
+    if (waitNote.dataset['reason'] !== 'stream') {
+      waitNote.hidden = waiting === 0 && isHost;
+      waitNote.textContent = isHost
+        ? waiting === 0
+          ? ''
+          : `Waiting on ${waiting} more ${waiting === 1 ? 'player' : 'players'} — add a bot to any empty chair to start now.`
+        : 'Waiting for the host to start the game.';
+      waitNote.hidden = waitNote.textContent === '';
+    }
     startBtn.onclick = () => {
+      // No busy state used to mean a second press posted a second start, whose 409 landed on screen
+      // as a raw code.
+      startBtn.disabled = true;
+      startBtn.textContent = 'Starting…';
       void postJson('/api/lobby/start', { token }).then(({ status, body }) => {
-        if (status !== 200) setError('lb-start-note', String(body['error'] ?? 'could not start'));
+        if (status !== 200) {
+          startBtn.disabled = false;
+          startBtn.textContent = 'Start game';
+          $('lb-start-note').textContent = explain(body['error'], 'Could not start the game.');
+        }
       });
     };
   }
 
-  function enterSeating(gameId: string, token: string): void {
+  function streamNote(message: string): void {
+    const el = $('lb-stream-note');
+    el.dataset['reason'] = message === '' ? '' : 'stream';
+    el.textContent = message;
+    el.hidden = message === '';
+  }
+
+  function enterSeating(gameId: string, token: string, gameCode: string): void {
+    handlers.onSeated({ token, gameId, gameCode });
     $('lb-choice-section').hidden = true;
     $('lb-seating-section').hidden = false;
+
+    $<HTMLButtonElement>('lb-leave').onclick = () => {
+      void postJson('/api/lobby/leave', { token }).then(() => {
+        source?.close();
+        handlers.onLeft(gameId);
+        $('lb-seating-section').hidden = true;
+        $('lb-choice-section').hidden = false;
+        renderKnown();
+        notice('');
+      });
+    };
+
     source = new EventSource(`/api/lobby/stream?token=${encodeURIComponent(token)}`);
     source.onmessage = (ev: MessageEvent<string>) => {
+      streamNote('');
       const push = JSON.parse(ev.data) as LobbyPush;
       if (push.started) {
         source?.close();
-        onReady({ token, gameId, seat: push.you });
+        if (done) return;
+        done = true;
+        handlers.onReady({ token, gameId, seat: push.you, gameCode: push.lobby.gameCode });
         return;
       }
       renderSeating(push.lobby, push.you, token);
     };
-  }
 
-  const chosenMode = (): 'competitive' | 'coop' =>
-    ($('lb-choice-section').querySelector<HTMLInputElement>('input[name="lb-mode"]:checked')?.value ??
-      'competitive') as 'competitive' | 'coop';
-  const chosenPlayers = (): number => Number($<HTMLSelectElement>('lb-players').value) || 4;
-  const num = (id: string): number => Number($<HTMLInputElement>(id).value);
-
-  /**
-   * Mode and table size only move the DEFAULTS, exactly as the solitaire dialog's own presets do —
-   * every field stays editable afterwards, so "Co-op, 3 players" is a starting point rather than a
-   * fixed ruleset. Re-running this on a change is also what keeps the combined-Revenue floor
-   * honest: it is derived from the player count, and the count is a control on this form.
-   */
-  function applyDefaults(): void {
-    const c = defaultMultiplayerConfig(chosenMode(), chosenPlayers());
-    const rules = houseRules(c);
-    $<HTMLInputElement>('lb-days').value = String(c.days);
-    $<HTMLInputElement>('lb-minrev').value = String(c.minCombinedRevenue);
-    $<HTMLInputElement>('lb-colday').value = String(c.maxCollisionsPerDay);
-    $<HTMLInputElement>('lb-coltotal').value = String(c.maxCollisionsTotal);
-    $<HTMLInputElement>('lb-passenger').value = String(rules.revenue.passengerPerCoach);
-    $<HTMLInputElement>('lb-freight').value = String(rules.revenue.freightPerLoad);
-    $<HTMLInputElement>('lb-transit').value = String(rules.revenue.trainPerTransit);
-    // Co-op has no valid target for the opponent-directed cards, so the toggle is forced off rather
-    // than merely defaulted off — the same rule `buildDeck` applies.
-    const pvp = $<HTMLInputElement>('lb-pvp');
-    pvp.checked = c.pvpCardsAllowed;
-    pvp.disabled = chosenMode() !== 'competitive';
-  }
-  for (const input of Array.from(
-    $('lb-choice-section').querySelectorAll<HTMLInputElement>('input[name="lb-mode"]'),
-  )) {
-    input.onchange = applyDefaults;
-  }
-  $<HTMLSelectElement>('lb-players').onchange = applyDefaults;
-  applyDefaults();
-
-  $<HTMLButtonElement>('lb-create').onclick = () => {
-    const displayName = $<HTMLInputElement>('lb-name').value.trim();
-    const mode = chosenMode();
-    if (displayName === '') {
-      setError('lb-create-err', 'enter a display name first');
-      return;
-    }
-    const players = chosenPlayers();
-    const hand = $('lb-settings').querySelector<HTMLInputElement>('input[name="lb-hand"]:checked')?.value;
-    // Blank or unparseable both mean "surprise me", which is what leaving the box alone asks for.
-    const asked = $<HTMLInputElement>('lb-seed').value.trim();
-    const seed = asked === '' || !Number.isFinite(Number(asked)) ? null : Math.trunc(Number(asked));
-
-    const config: GameConfig = {
-      ...defaultMultiplayerConfig(mode, players),
-      days: Math.max(1, Math.round(num('lb-days')) || 5),
-      minCombinedRevenue: Math.max(0, Math.round(num('lb-minrev')) || 0),
-      maxCollisionsPerDay: Math.max(0, Math.round(num('lb-colday')) || 0),
-      maxCollisionsTotal: Math.max(0, Math.round(num('lb-coltotal')) || 0),
-      pvpCardsAllowed: $<HTMLInputElement>('lb-pvp').checked && mode === 'competitive',
-      optionalRules: {
-        reducedVisibility: $<HTMLInputElement>('lb-visibility').checked,
-        employeeRotation: $<HTMLInputElement>('lb-rotation').checked,
-        emergencyToolbox: $<HTMLInputElement>('lb-toolbox').checked,
-      },
-      houseRules: {
-        ...(STARTING_HAND_LABELS.some((o) => o.value === hand) ? { startingHand: hand as StartingHand } : {}),
-        revenue: {
-          passengerPerCoach: num('lb-passenger'),
-          freightPerLoad: num('lb-freight'),
-          trainPerTransit: num('lb-transit'),
-        },
-      },
-    };
-
-    void postJson('/api/lobby/create', { secret: secret(), config, displayName, players, seed }).then(
-      ({ status, body }) => {
-        if (status !== 200) {
-          setError('lb-create-err', String(body['error'] ?? 'could not create the game'));
+    /**
+     * A DEAD LOBBY AND A BLIP LOOK IDENTICAL HERE, so ask — the same shape `session.ts` already uses
+     * for the game stream, which the lobby never got.
+     *
+     * Three answers matter. The game may have STARTED while we were disconnected (the `started` push
+     * is sent once and then the connection closes, so a drop at the wrong moment loses it) —
+     * `/api/session` knows, and we go straight in. The lobby may still be there, in which case
+     * `EventSource` is already retrying and the note is all that is needed. Or it is gone, and
+     * sitting on a frozen seating screen is the one thing that must not happen.
+     */
+    source.onerror = () => {
+      if (done) return;
+      streamNote('Connection lost — retrying. You can leave and rejoin if this does not clear.');
+      void getJson(`/api/session?token=${encodeURIComponent(token)}`).then(({ status, body }) => {
+        if (done) return;
+        if (status === 200) {
+          done = true;
+          source?.close();
+          handlers.onReady({ token, gameId, seat: body['player'] as PlayerIndex, gameCode });
           return;
         }
-        setError('lb-create-err', '');
-        enterSeating(body['gameId'] as string, body['token'] as string);
-      },
-    );
-  };
+        void getJson(
+          `/api/lobby/preview?gameCode=${encodeURIComponent(gameCode)}&secret=${encodeURIComponent(secret())}`,
+        ).then(({ status: lobbyStatus }) => {
+          if (done || lobbyStatus === 200) return;
+          source?.close();
+          handlers.onLeft(gameId);
+          $('lb-seating-section').hidden = true;
+          $('lb-choice-section').hidden = false;
+          renderKnown();
+          streamNote('');
+          notice('That game is no longer waiting on this server — it was ended, or the last player left.');
+        });
+      });
+    };
+  }
 
-  $<HTMLButtonElement>('lb-join').onclick = () => {
-    const displayName = $<HTMLInputElement>('lb-name').value.trim();
-    const gameCode = $<HTMLInputElement>('lb-code').value.trim();
-    if (displayName === '' || gameCode === '') {
-      setError('lb-join-err', 'enter a display name and a game code');
-      return;
-    }
-    void postJson('/api/lobby/join', { secret: secret(), gameCode, displayName }).then(({ status, body }) => {
-      if (status !== 200) {
-        setError('lb-join-err', String(body['error'] ?? 'could not join that game'));
-        return;
-      }
-      setError('lb-join-err', '');
-      enterSeating(body['gameId'] as string, body['token'] as string);
-    });
-  };
+  if (resume) enterSeating(resume.gameId, resume.token, resume.gameCode);
+}
+
+/** The lobby-wide message slot: why you are looking at this screen, when it was not your own click. */
+export function notice(message: string): void {
+  const el = document.getElementById('lb-notice');
+  if (!el) return;
+  el.textContent = message;
+  el.hidden = message === '';
+}
+
+/** Prefills the code from an invite link and opens the join door on it. */
+export function prefillCode(code: string): void {
+  const field = document.getElementById('lb-code') as HTMLInputElement | null;
+  if (field) field.value = code.toUpperCase();
+}
+
+/**
+ * A CHOICE THAT CANNOT BE TAKEN HAS TO SAY SO.
+ *
+ * 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.
+ */
+function markUnavailable(radio: HTMLInputElement, why: string): 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);
+}
+
+function escapeHtml(s: string): string {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 }

src/web/main.ts

@@ -14,12 +14,9 @@ import { PANEL_CSS, blockedHtml, facilitiesHtml, pilesHtml, timetableHtml, yardH
 import { TOOLTIP_CSS, installTooltips } from './tooltip.ts';
 import { playCue } from './sound.ts';
 import {
-  DEFAULT_MAX_COLLISIONS_PER_DAY,
-  DEFAULT_MAX_COLLISIONS_TOTAL,
   MOVES_PER_LOCAL_OPS,
   EXTRA_START_LABELS,
   STARTING_HAND_LABELS,
-  collectiveRevenueFloor,
   houseRules,
 } from '../engine/content.ts';
 import type { ExtraStartRule, HouseRuleOverrides, HouseRules, RevenueRules, StartingHand } from '../engine/content.ts';
@@ -27,8 +24,19 @@ import type { NewGameOptions } from './game.ts';
 import type { LocalSession, Session } from './session.ts';
 import { createLocalSession, createRemoteSession } from './session.ts';
 import type { PlayerIndex } from '../engine/state.ts';
-import { runLobby } from './lobby.ts';
+import { notice, prefillCode, runLobby } from './lobby.ts';
 import type { LobbyReady } from './lobby.ts';
+import {
+  closestPreset,
+  configFromFrame,
+  gameTypeLabel,
+  preset,
+  presetOf,
+  presetSettings,
+  settingsOf,
+} from './presets.ts';
+import type { GameType, PresetName } from './presets.ts';
+import { settingsForm } from './settings-form.ts';
 
 const SAVE_KEY = 'station-master.save.v1';
 const SETTINGS_KEY = 'station-master.settings.v1';
@@ -227,7 +235,11 @@ function piecePreview(links: string[], label: string): string {
  */
 function renderTurnChart(f: Frame): void {
   const actorName = f.actor === null ? null : (f.players[f.actor]?.name ?? null);
-  $('turnchart').innerHTML = turnChartHtml(f, actorName);
+  // Named only at a table with more than one seat: in solitaire the Fedora is always yours, and a
+  // chip that can never change is a chip to read past.
+  const superName =
+    f.players.length > 1 ? (f.players.find((p) => p.index === f.superintendent)?.name ?? null) : null;
+  $('turnchart').innerHTML = turnChartHtml(f, actorName, superName);
 }
 
 /**
@@ -271,6 +283,19 @@ const VICTORY_PARAMS = {
   coltotal: 'maxCollisionsTotal',
 } as const;
 
+/**
+ * Appendix B's three, in the URL like everything else the dialog asks (2026-08-23).
+ *
+ * The dialog navigates to a URL and `start()` reads the game back out of it, so a setting missing
+ * from here is a setting the dialog silently discards — which is exactly what happened to these
+ * three for as long as only the lobby offered them.
+ */
+const OPTIONAL_PARAMS = {
+  vis: 'reducedVisibility',
+  rot: 'employeeRotation',
+  tool: 'emergencyToolbox',
+} as const;
+
 function gameOptionsFromUrl(params: URLSearchParams): NewGameOptions {
   const rules: HouseRuleOverrides = {};
   const hand = params.get('hand');
@@ -296,9 +321,52 @@ function gameOptionsFromUrl(params: URLSearchParams): NewGameOptions {
       options[key] = Math.max(0, Math.round(Number(raw)));
     }
   }
+  const optional: Partial<NonNullable<NewGameOptions['optionalRules']>> = {};
+  for (const [param, key] of Object.entries(OPTIONAL_PARAMS)) {
+    const raw = params.get(param);
+    // Present and not "0" means on: `?rot=1` and `?rot` alike, since a bare flag reads as ''.
+    if (raw !== null) optional[key] = raw !== '0';
+  }
+  if (Object.keys(optional).length > 0) options.optionalRules = optional;
   return options;
 }
 
+/**
+ * THE SOLITAIRE GAME TYPE'S RULES, under whatever the URL actually named.
+ *
+ * `SOLO_CONFIG` is the ENGINE's fallback and stays where it is — every engine test and every sim run
+ * is measured against it, and moving it would silently re-deal all of them. What a PLAYER is dealt
+ * when they open the page is a different question, and its answer is the Solitaire game type
+ * (`presets.ts`) — which since 2026-08-23 opens with six cards, like every other type, so that the
+ * New Game dialog and the lobby agree about what "Solitaire" means.
+ */
+function solitaireDefaults(options: NewGameOptions): NewGameOptions {
+  const days = options.days ?? 5;
+  const p = presetSettings('solitaire', 1, days);
+  const revenue = options.houseRules?.revenue ?? {};
+  return {
+    days,
+    minCombinedRevenue: options.minCombinedRevenue ?? p.minCombinedRevenue,
+    maxCollisionsPerDay: options.maxCollisionsPerDay ?? p.maxCollisionsPerDay,
+    maxCollisionsTotal: options.maxCollisionsTotal ?? p.maxCollisionsTotal,
+    optionalRules: {
+      reducedVisibility: options.optionalRules?.reducedVisibility ?? p.reducedVisibility,
+      // One player, so there is nobody to rotate with whatever a hand-edited URL says.
+      employeeRotation: false,
+      emergencyToolbox: options.optionalRules?.emergencyToolbox ?? p.emergencyToolbox,
+    },
+    houseRules: {
+      startingHand: options.houseRules?.startingHand ?? p.startingHand,
+      extraStart: options.houseRules?.extraStart ?? p.extraStart,
+      revenue: {
+        passengerPerCoach: revenue.passengerPerCoach ?? p.passengerPerCoach,
+        freightPerLoad: revenue.freightPerLoad ?? p.freightPerLoad,
+        trainPerTransit: revenue.trainPerTransit ?? p.trainPerTransit,
+      },
+    },
+  };
+}
+
 function rulesToUrl(rules: HouseRules, options: NewGameOptions, seed: string): string {
   const params = new URLSearchParams();
   if (seed !== '') params.set('seed', seed);
@@ -311,18 +379,212 @@ function rulesToUrl(rules: HouseRules, options: NewGameOptions, seed: string): s
     const value = options[key];
     if (value !== undefined) params.set(param, String(value));
   }
+  for (const [param, key] of Object.entries(OPTIONAL_PARAMS)) {
+    // Only the ones that are ON: a URL that spells out three `=0`s says nothing extra and is three
+    // parameters longer.
+    if (options.optionalRules?.[key] === true) params.set(param, '1');
+  }
   return `?${params}`;
 }
 
-function loadRemote(): LobbyReady | null {
+/**
+ * WHAT THIS BROWSER REMEMBERS ABOUT A MULTIPLAYER GAME, and when.
+ *
+ * It used to be written only at `Lobby.Start`, which meant a refresh while SEATED — before the host
+ * started — orphaned the chair: the token existed nowhere else, so the player could not return and
+ * the seat could not be freed, and a table that needs every chair filled could no longer start.
+ * The record is written the moment a seat is taken, and `stage` says how far it got.
+ */
+type RemoteRecord = {
+  token: string;
+  gameId: string;
+  gameCode: string;
+  /** Only known once the game exists; a lobby-stage record has no seat yet. */
+  seat?: PlayerIndex;
+  stage: 'lobby' | 'game';
+};
+
+/**
+ * EVERY multiplayer game this browser holds a seat in, and which was last played.
+ *
+ * It used to be ONE record under one key, so joining a second game overwrote the first — and since
+ * the token IS the identity (`lobby-and-sessions.md` §1), that seat was then locked out for good.
+ * `TODO.md` had it as "a second, nearer limit" under the lost-token item; Jesse hit it from the
+ * other side, asking how to leave a game and play a different one later.
+ */
+type RemoteStore = { games: Record<string, RemoteRecord>; last: string | null };
+
+function readStore(): RemoteStore {
   try {
     const raw = localStorage.getItem(REMOTE_KEY);
-    return raw ? (JSON.parse(raw) as LobbyReady) : null;
+    if (!raw) return { games: {}, last: null };
+    const parsed = JSON.parse(raw) as Partial<RemoteStore> & Partial<RemoteRecord>;
+    // The single-record shape written before 2026-08-23 — carried across rather than dropped, so an
+    // update does not throw away the game somebody is in the middle of.
+    if (typeof parsed.token === 'string' && typeof parsed.gameId === 'string') {
+      const one: RemoteRecord = {
+        token: parsed.token,
+        gameId: parsed.gameId,
+        gameCode: parsed.gameCode ?? '',
+        ...(parsed.seat === undefined ? {} : { seat: parsed.seat }),
+        stage: parsed.stage ?? 'game',
+      };
+      return { games: { [one.gameId]: one }, last: one.gameId };
+    }
+    const games = parsed.games ?? {};
+    return { games, last: parsed.last ?? null };
   } catch {
-    return null;
+    return { games: {}, last: null };
   }
 }
 
+function writeStore(store: RemoteStore): void {
+  try {
+    localStorage.setItem(REMOTE_KEY, JSON.stringify(store));
+  } catch {
+    // A full or disabled localStorage must not take the game down with it — the session in memory
+    // keeps working, it simply will not survive a reload.
+  }
+}
+
+/** The game to re-enter on a bare page load: the one most recently played. */
+function loadRemote(): RemoteRecord | null {
+  const store = readStore();
+  return store.last === null ? null : (store.games[store.last] ?? null);
+}
+
+function saveRemote(record: RemoteRecord): void {
+  const store = readStore();
+  store.games[record.gameId] = record;
+  store.last = record.gameId;
+  writeStore(store);
+}
+
+/** Deliberate, and the one irreversible thing on the lobby screen: the token is the only proof of
+ * who you are, so forgetting it gives up the seat with no way back from this browser. */
+function forgetRemote(gameId: string): void {
+  const store = readStore();
+  delete store.games[gameId];
+  if (store.last === gameId) store.last = null;
+  writeStore(store);
+}
+
+function knownRemote(): RemoteRecord[] {
+  return Object.values(readStore().games);
+}
+
+/** The handlers the lobby drives this page through — one place, since four callers open a lobby.
+ * Storage lives here rather than in `lobby.ts`, which owns the screen and not the browser. */
+const lobbyHandlers = {
+  onReady: (ready: LobbyReady): void => beginRemote(ready),
+  onSeated: (s: { token: string; gameId: string; gameCode: string }): void =>
+    saveRemote({ ...s, stage: 'lobby' }),
+  onLeft: (gameId?: string): void => {
+    const target = gameId ?? readStore().last;
+    if (target !== null && target !== undefined) forgetRemote(target);
+  },
+  known: (): { gameId: string; gameCode: string; stage: 'lobby' | 'game' }[] =>
+    knownRemote().map((r) => ({ gameId: r.gameId, gameCode: r.gameCode, stage: r.stage })),
+  forget: (gameId: string): void => forgetRemote(gameId),
+  rejoin: (gameId: string): void => {
+    const record = readStore().games[gameId];
+    if (!record) return;
+    if (record.stage === 'game' && record.seat !== undefined) {
+      beginRemote({ ...record, seat: record.seat });
+      return;
+    }
+    // Still seated in a lobby that had not started: the stream puts us back on the seating screen,
+    // and its own probe handles a game that began while we were away.
+    showScreen('lobby');
+    runLobby(lobbyHandlers, { token: record.token, gameId: record.gameId, gameCode: record.gameCode });
+  },
+};
+
+/**
+ * THE GAME CODE THIS PAGE IS IN, once it is in one.
+ *
+ * It ended at the lobby door before 2026-08-23 — `LobbyReady` carried the token, the game id and the
+ * seat, and the code (the only one of the four a person can read out) was dropped. A seated player
+ * could not say which game they were in, match it against the administrator's Games in Progress
+ * list, or pass it to a latecomer. Empty in solitaire, where there is no code.
+ */
+let gameCode = '';
+
+/** How long the handoff curtain holds, so the start of a game is a moment rather than a snap. */
+const HANDOFF_BEAT_MS = 1500;
+/** How long to wait before saying the board has not arrived. */
+const HANDOFF_STALL_MS = 8000;
+let handoffOpenedAt = 0;
+let handoffStall: number | null = null;
+let firstFrameSeen = false;
+
+function setText(id: string, text: string): void {
+  const el = document.getElementById(id);
+  if (el) el.textContent = text;
+}
+
+/** The curtain between `Lobby.Start` and the first Frame — see `#handoff` in `play.html`. */
+function openHandoff(): void {
+  const el = document.getElementById('handoff');
+  if (!el) return;
+  firstFrameSeen = false;
+  handoffOpenedAt = Date.now();
+  el.classList.add('shown');
+  setText('handoff-title', 'Dealing the railroad…');
+  setText('handoff-note', 'Laying out the Division and rolling for seats.');
+  if (handoffStall !== null) clearTimeout(handoffStall);
+  handoffStall = window.setTimeout(() => {
+    if (firstFrameSeen) return;
+    setText('handoff-title', 'Still waiting for the server');
+    setText(
+      'handoff-note',
+      'The game exists, but its board has not arrived yet. It will appear as soon as the server sends it.',
+    );
+  }, HANDOFF_STALL_MS);
+}
+
+function closeHandoff(): void {
+  document.getElementById('handoff')?.classList.remove('shown');
+  if (handoffStall !== null) clearTimeout(handoffStall);
+  handoffStall = null;
+}
+
+/** Flash a one-line announcement over the board. Shared by the session's own announcements and by
+ * the "the game has begun" line, which comes from the page rather than from an event. */
+function flashAnnounce(text: string): void {
+  const el = document.getElementById('announce');
+  if (!el) return;
+  el.textContent = text;
+  el.className = 'shown';
+  window.setTimeout(() => {
+    if (el.textContent === text) el.className = '';
+  }, 4200);
+}
+
+/**
+ * THE FIRST FRAME OF A MULTIPLAYER GAME — the one moment nobody had ever seen drawn.
+ *
+ * The board simply appeared, mid-Local-Operations, with a log already several bot turns deep and
+ * nothing saying this was the game just set up. `#phasenote` cannot help: it announces a CHANGE of
+ * phase, and there is no previous phase to have changed from.
+ */
+function noteFirstFrame(f: Frame): void {
+  if (firstFrameSeen || isLocal(session)) return;
+  firstFrameSeen = true;
+  const held = Date.now() - handoffOpenedAt;
+  const config = configFromFrame(f);
+  const type = gameTypeLabel(presetOf(config, f.players.length, f.days), f.mode);
+  window.setTimeout(
+    () => {
+      closeHandoff();
+      flashAnnounce(
+        `The game has begun — ${type} · ${f.players.length} players · Day ${f.day}, Stage ${f.stage}`,
+      );
+    },
+    Math.max(0, HANDOFF_BEAT_MS - held),
+  );
+}
+
 /** Toggles the two mutually-exclusive top-level screens `play.html` defines — `#lobby` (Phase 4)
  * and `#gameui` (the board, whether local or remote). Both start `hidden` in the markup so neither
  * ever flashes before `start()` decides which one this load actually needs. */
@@ -338,12 +600,14 @@ function showScreen(which: 'lobby' | 'gameui'): void {
  * so it is always written back here before anything else happens.
  */
 function beginRemote(ready: LobbyReady): void {
-  localStorage.setItem(REMOTE_KEY, JSON.stringify(ready));
+  saveRemote({ token: ready.token, gameId: ready.gameId, gameCode: ready.gameCode, seat: ready.seat, stage: 'game' });
+  gameCode = ready.gameCode;
   showScreen('gameui');
   // Nothing can be drawn until the first push arrives, and a page showing nothing at all is
   // indistinguishable from a page that is broken — which is exactly what a dead session used to
-  // look like, forever.
-  $('presence').textContent = '… connecting to the game';
+  // look like, forever. This is its own state now rather than a borrowed line in the DISCONNECT
+  // banner (`#presence`), and it holds a beat so the game visibly begins.
+  openHandoff();
   session = createRemoteSession(ready.token, ready.seat, abandonRemote);
   applyCapabilities();
   // A LocalSession has data the instant it is constructed; a RemoteSession does not — its first
@@ -366,16 +630,19 @@ function beginRemote(ready: LobbyReady): void {
  * Forgetting the token is what makes the next load land in the lobby instead of repeating it.
  */
 function abandonRemote(): void {
-  localStorage.removeItem(REMOTE_KEY);
+  // That one game is gone; any OTHER game this browser is in is untouched.
+  const store = readStore();
+  if (store.last !== null) forgetRemote(store.last);
+  closeHandoff();
   showScreen('lobby');
   $('presence').textContent = '';
-  runLobby(beginRemote);
-  const note = document.getElementById('lb-create-err');
-  if (note) {
-    note.textContent =
-      'That game is no longer on this server — it was either ended by whoever runs it, or the ' +
-      'service was updated, which does not carry games in progress across. Create or join a new one.';
-  }
+  runLobby(lobbyHandlers);
+  // The lobby's own notice slot, not the create form's error line: the player may well have been a
+  // joiner, and with the two doors that line is behind a panel they are not looking at.
+  notice(
+    'That game is no longer on this server — it was either ended by whoever runs it, or the ' +
+      'service was updated, which does not carry games in progress across. Create or join a new one.',
+  );
 }
 
 /**
@@ -388,21 +655,44 @@ function abandonRemote(): void {
 function start(): void {
   const params = new URLSearchParams(location.search);
 
+  /**
+   * ASKING FOR THE LOBBY BEATS RESUMING A GAME.
+   *
+   * The splash's "Play multiplayer" door and an invite link both land here with `?lobby`, and both
+   * mean "I want to pick a game" — but a remembered session used to be checked first, so anyone
+   * already in a game was dropped straight back into it and could never reach the lobby from the
+   * door at all. A BARE load still resumes, which is the common case and the one D11 is about.
+   */
+  const invited = params.get('code');
+  if (params.get('lobby') !== null || invited !== null) {
+    showScreen('lobby');
+    if (invited !== null && invited !== '') prefillCode(invited);
+    runLobby(lobbyHandlers);
+    return;
+  }
+
   // Entered without checking it still exists — deliberately. Verifying up front would mean an
   // await before anything renders on the common path, where the game IS still there; instead the
   // session reports a dead game through `abandonRemote`, which lands in the lobby.
   const remembered = loadRemote();
-  if (remembered) {
-    beginRemote(remembered);
+  if (remembered && remembered.stage === 'game' && remembered.seat !== undefined) {
+    beginRemote({ ...remembered, seat: remembered.seat });
     return;
   }
-
-  // The splash's "Play multiplayer" door (index.html) lands here — straight into the lobby,
-  // rather than dealing a solitaire game first and leaving the player to find the in-game
-  // Multiplayer button themselves.
-  if (params.get('lobby') !== null) {
+  /**
+   * A SEAT TAKEN BUT NOT YET PLAYING — this browser reloaded while the lobby was still seating.
+   *
+   * The lobby stream answers all three cases from here without another route: it pushes the seating
+   * screen if the lobby is still open, and its `onerror` probe finds either a game that started
+   * while we were away (straight in) or a lobby that is gone (back to the doors, with a reason).
+   */
+  if (remembered) {
     showScreen('lobby');
-    runLobby(beginRemote);
+    runLobby(lobbyHandlers, {
+      token: remembered.token,
+      gameId: remembered.gameId,
+      gameCode: remembered.gameCode,
+    });
     return;
   }
 
@@ -410,7 +700,7 @@ function start(): void {
   const requested = params.get('seed');
   // A seed in the URL makes a game shareable and reproducible: same link, same deal.
   const seed = requested !== null ? Number(requested) || 1 : Math.floor(Math.random() * 1e9);
-  const local = createLocalSession(seed, gameOptionsFromUrl(params));
+  const local = createLocalSession(seed, solitaireDefaults(gameOptionsFromUrl(params)));
   session = local;
 
   // A saved game carries its OWN rules and re-deals itself under them, whatever the URL says — see
@@ -445,6 +735,8 @@ function applyCapabilities(): void {
   // Creating or joining ANOTHER multiplayer game from inside a running one is not a thing this
   // page offers — same reasoning as `newgame`, and the same capability answers both.
   hide('multiplayer', c.newGame);
+  // The mirror of the three above: leaving a game is the one control that only a REMOTE session has.
+  hide('leavegame', !c.newGame);
 }
 
 /**
@@ -489,16 +781,67 @@ function renderSeatingChain(f: Frame): void {
  * collapses the banner rather than leaving a reassuring "all connected" line nobody needs to read.
  */
 function renderPresence(f: Frame): void {
-  const away = session
-    .presence()
-    .filter((p) => !p.connected)
-    .map((p) => f.players.find((pl) => pl.index === p.seat)?.name ?? `Seat ${seatLabel(p.seat)}`);
-  $('presence').textContent = away.length === 0 ? '' : `⚠ waiting on ${away.join(', ')} — disconnected`;
+  const name = (seat: PlayerIndex): string =>
+    f.players.find((pl) => pl.index === seat)?.name ?? `Seat ${seatLabel(seat)}`;
+  const presence = session.presence();
+  /**
+   * TWO DIFFERENT ABSENCES, and they call for two different things from the table.
+   *
+   * A seat the server has never heard from has not opened the game yet — somebody needs to send them
+   * the link. A seat that WAS here and dropped will probably be back. The server reports both from
+   * `/api/stream`'s connect push (2026-08-23); before that a client learnt of a seat only when it
+   * disconnected AFTER you connected, so a table where two people had not shown up yet said nothing
+   * at all.
+   */
+  const dropped = presence.filter((p) => p.seen && !p.connected).map((p) => name(p.seat));
+  const never = presence.filter((p) => !p.seen).map((p) => name(p.seat));
+  const parts: string[] = [];
+  if (dropped.length > 0) parts.push(`${dropped.join(', ')} — disconnected`);
+  if (never.length > 0) parts.push(`${never.join(', ')} — not here yet`);
+  $('presence').textContent = parts.length === 0 ? '' : `⚠ waiting on ${parts.join(' · ')}`;
+}
+
+/**
+ * WHICH GAME THIS IS, in the header: its code and its type.
+ *
+ * Neither used to be anywhere on the board. The code ended at the lobby door, and the type was never
+ * on the Frame at all — so a player could read what a load paid but not whether they were in a Co-op
+ * game or a Cutthroat one, which is the difference between helping the table and racing it.
+ */
+function renderGameIdentity(f: Frame): void {
+  const codeEl = document.getElementById('gamecode');
+  if (codeEl) codeEl.textContent = gameCode === '' ? '' : `game ${gameCode}`;
+
+  const el = document.getElementById('gametype');
+  if (!el) return;
+  const config = configFromFrame(f);
+  const players = f.players.length;
+  const type = presetOf(config, players, f.days);
+  const near = closestPreset(config, players, f.days);
+  el.textContent = gameTypeLabel(type, f.mode);
+  el.title =
+    type === 'custom'
+      ? `A custom game, scored as ${preset(near.name).scoring === 'coop' ? 'Co-op' : 'Competitive'}. ` +
+        `${near.differing.length} ${near.differing.length === 1 ? 'setting differs' : 'settings differ'} ` +
+        `from ${preset(near.name).label}.\n\n${rulesSummary(f)}`
+      : `${preset(type).blurb}\n\n${rulesSummary(f)}`;
+}
+
+/** The victory conditions in force, spelled out for the header's tooltip. */
+function rulesSummary(f: Frame): string {
+  const off = (n: number): string => (n === 0 ? 'off' : String(n));
+  return (
+    `Days: ${f.days}\n` +
+    `Combined Revenue floor: ${off(f.minCombinedRevenue)}\n` +
+    `Collisions in one Day that end the game: ${off(f.maxCollisionsPerDay)}\n` +
+    `Collisions in the whole game that end it: ${off(f.maxCollisionsTotal)}`
+  );
 }
 
 function render(): void {
   const f = session.view();
   const menu = session.menu();
+  noteFirstFrame(f);
 
   // Which squares the selected card or track piece may go on. Highlighting them is what turns the
   // coordinate list into a board: you pick the thing, then click where it goes.
@@ -535,6 +878,7 @@ function render(): void {
   // The seed is never sent to a remote client at all (it would leak every future shuffle and roll,
   // `multiplayer.md` §7) — `RemoteSession` has no `.seed()` because there is nothing to return.
   $('seed').textContent = isLocal(session) ? String(session.seed()) : `Seat ${seatLabel(session.seat())}`;
+  renderGameIdentity(f);
   renderHouseRules(f.houseRules);
 
   // -- division
@@ -809,10 +1153,20 @@ function render(): void {
 
   // -- log
   const log = $('log');
-  log.innerHTML = session.lines()
-    .slice(-60)
-    .map((l) => `<div class="line t-${l.tone}">${esc(l.text)}</div>`)
-    .join('');
+  const allLines = session.lines();
+  const shownLines = allLines.slice(-60);
+  /**
+   * WHERE THE GAME BEGAN. In a multiplayer game the bots move the instant the host presses Start, so
+   * by the time the board paints the log already has several turns in it and nothing says which of
+   * them are yours to have missed. Only drawn while the whole log is on screen: past sixty lines the
+   * top of the panel is no longer the start of the game, and a marker claiming otherwise would lie.
+   */
+  const startMarker =
+    !isLocal(session) && allLines.length === shownLines.length
+      ? '<div class="line t-phase">— the game began —</div>'
+      : '';
+  log.innerHTML =
+    startMarker + shownLines.map((l) => `<div class="line t-${l.tone}">${esc(l.text)}</div>`).join('');
   log.scrollTop = log.scrollHeight;
 
   /**
@@ -837,14 +1191,7 @@ function render(): void {
    * out loud rather than left in the log. Drained, so it shows once and does not re-fire on a redraw.
    */
   const announcement = session.takeAnnouncement();
-  if (announcement) {
-    const el = $('announce');
-    el.textContent = announcement;
-    el.className = 'shown';
-    window.setTimeout(() => {
-      if (el.textContent === announcement) el.className = '';
-    }, 4200);
-  }
+  if (announcement) flashAnnounce(announcement);
 
   renderDistrict(f);
   renderActions(menu, f, justSet);
@@ -1074,13 +1421,13 @@ function renderActions(
    */
   const scheduledNote =
     justSet !== null && f.timetable[justSet] != null
-      ? `<div class="scheduled" data-tip="§7 — the Stage is rolled on 1D12 when the card is played; if that Stage is taken the train works down the column to the next free one. From now on it runs at this time every Day.">` +
+      ? `<div class="scheduled" data-tip="The Stage is rolled on 1D12 when the card is played; if that Stage is taken the train works down the column to the next free one. From now on it runs at this time every Day.">` +
         `Train ${f.timetable[justSet]} is scheduled to depart at Stage ${justSet + 1} — see the Timetable</div>`
       : '';
 
   const movesNote =
     f.movesLeft !== null
-      ? `<div class="moves${f.movesLeft === 0 ? ' spent' : ''}" data-tip="§6.1 — six Moves a turn. A Move runs any distance in one direction; changing direction costs another, which is why a run-around has to be planned inside the count.">` +
+      ? `<div class="moves${f.movesLeft === 0 ? ' spent' : ''}" data-tip="Six Moves a turn. A Move runs any distance in one direction; changing direction costs another, which is why a run-around has to be planned inside the count.">` +
         `${f.movesLeft} of ${MOVES_PER_LOCAL_OPS} Moves left</div>`
       : '';
 
@@ -1163,7 +1510,7 @@ function renderActions(
         ? `Click a car in the Division Yard below to add it — ${addable} kind${addable === 1 ? '' : 's'} it may take are highlighted there.`
         : menu.makeUp.pass !== null
           ? 'The Division Yard is bare, so there is nothing to add. Send the train out as it stands.'
-          : 'Nothing in the Division Yard may join this train, and §7 does not allow passing while the yard holds cars.') +
+          : 'Nothing in the Division Yard may join this train, and passing is not allowed while the yard holds cars.') +
       `</div>` +
       /**
        * WHICH ORDER TO ADD THEM IN, when the order is what decides whether the train can work.
@@ -1177,7 +1524,7 @@ function renderActions(
         ? `<div class="makeup-advice ${menu.makeUp.advice.tone}">${esc(menu.makeUp.advice.text)}</div>`
         : '') +
       (menu.makeUp.pass !== null
-        ? `<button class="act" data-i="${menu.makeUp.pass}" data-tip="§8.2 — a train may depart with FEWER cars than its card lists, but never with the wrong ones. This sends it out as it stands.">no more cars — send it out</button>`
+        ? `<button class="act" data-i="${menu.makeUp.pass}" data-tip="A train may depart with FEWER cars than its card lists, but never with the wrong ones. This sends it out as it stands.">no more cars — send it out</button>`
         : '') +
       `</div>`;
   }
@@ -1237,11 +1584,11 @@ function renderActions(
      */
     const stuck = f.handDiscardable.length > 0 && f.handDiscardable.every((d) => !d);
     const tip = stuck
-      ? '§6.2 — you may not end a turn holding more than three cards, and a TRAIN CARD IS NEVER ' +
+      ? 'You may not end a turn holding more than three cards, and a TRAIN CARD IS NEVER ' +
         'DISCARDED. Every card you hold is a train, so the only way on is to play one onto the ' +
         'timetable. A train may be held for as many Stages and Days as you like; it just cannot be ' +
         'thrown away.'
-      : '§6.2 — you may not end a turn holding more than three cards (four with a Red Flag). Play ' +
+      : 'You may not end a turn holding more than three cards (four with a Red Flag). Play ' +
         'one onto the board, or discard one face-up to a Department slot. A train card is never ' +
         'discardable and can only be played.';
     html +=
@@ -1356,7 +1703,35 @@ if (multiplayerBtn) {
     const started = f.status === 'active' && (f.day > 1 || f.stage > 1);
     if (started && !confirm(`Leave this game (seed ${session.seed()}, Day ${f.day}) for multiplayer?`)) return;
     showScreen('lobby');
-    runLobby(beginRemote);
+    runLobby(lobbyHandlers);
+  };
+}
+
+/**
+ * LEAVE A RUNNING GAME — back to the lobby, seat and token kept.
+ *
+ * Reported by Jesse 2026-08-23: a player who has to go had no way out at all. The page re-entered
+ * the same game on every load, and the only thing that ever let go of a session was the game itself
+ * being destroyed. Leaving does NOT give up the seat: `lobby-and-sessions.md` §5 keeps it and the
+ * table waits, which is the design — nothing moves on an absent player's behalf. The token is kept
+ * too, so the game can be re-entered from "Games you are in"; forgetting it is a separate, deliberate
+ * act on that list, because the token is the only proof of who you are.
+ */
+const leaveBtn = document.getElementById('leavegame');
+if (leaveBtn) {
+  leaveBtn.onclick = () => {
+    if (isLocal(session)) return;
+    const f = session.view();
+    const code = gameCode === '' ? 'this game' : gameCode;
+    if (!confirm(`Leave ${code} (Day ${f.day}, Stage ${f.stage})? Your seat is kept and the game waits for you.`)) return;
+    // Stop listening before leaving the screen, so the table sees the seat go quiet rather than
+    // being told somebody is present who is not.
+    session.close?.();
+    closeHandoff();
+    showScreen('lobby');
+    $('presence').textContent = '';
+    runLobby(lobbyHandlers);
+    notice(`You left ${code}. It is still yours — rejoin it under "Games you are in" whenever you like.`);
   };
 }
 
@@ -1364,38 +1739,99 @@ const newBtn = document.getElementById('newgame');
 const dlg = document.getElementById('newgamedlg') as HTMLDialogElement | null;
 if (newBtn && dlg) {
   const field = <T extends HTMLElement>(id: string): T => document.getElementById(id) as T;
-  type Mode = 'solitaire' | 'competitive' | 'coop';
+  const ngForm = settingsForm('ng-');
 
   /**
-   * PICKING A TYPE JUST SETS THE FIELDS BELOW TO THAT TYPE'S DEFAULTS (Jesse's design, 2026-08-20) —
-   * every number stays editable afterward, so "Competitive" isn't a fixed ruleset, it's a starting
-   * point. `players = 4` for Competitive/Co-op is a nominal stand-in: there's no lobby yet to ask who
-   * is actually seated (Phase 4), so this is a suggestion a real seat count will replace.
+   * THE SAME FIVE GAME TYPES THE LOBBY OFFERS, and the same shared rules block under them.
    *
-   * Only Solitaire can be dealt today — Deal disables itself for the other two, with a note, rather
-   * than pretending a click would do something (`RemoteSession` is Phase 2).
+   * The dialog used to carry its own copy of the questions and its own idea of the defaults, which
+   * is how it ended up with "where an Extra may start" that the lobby did not have and none of the
+   * three optional rules that it did. Both screens now read `presets.ts` and drive their block
+   * through `settings-form.ts`; only Solitaire can actually be DEALT here, so the three multiplayer
+   * types are shown disabled rather than hidden — what this screen offers and what the lobby offers
+   * should read as one list, not two.
    */
-  function applyModePreset(mode: Mode): void {
-    const days = 5;
-    const players = mode === 'solitaire' ? 1 : 4;
-    field<HTMLInputElement>('ng-days').value = String(days);
-    field<HTMLInputElement>('ng-minrev').value = String(collectiveRevenueFloor(players, days));
-    field<HTMLInputElement>('ng-colday').value = String(DEFAULT_MAX_COLLISIONS_PER_DAY);
-    field<HTMLInputElement>('ng-coltotal').value = String(DEFAULT_MAX_COLLISIONS_TOTAL);
+  let ngBase: PresetName = 'solitaire';
+  let ngType: GameType = 'solitaire';
+  /** As in the lobby: the floor is derived from the length until the player sets one themselves. */
+  let ngFloorTyped = false;
 
-    // No valid target for these cards in Solitaire or Co-op — forced off, not merely defaulted off.
-    const pvp = field<HTMLInputElement>('ng-pvp');
-    pvp.checked = mode === 'competitive';
-    pvp.disabled = mode !== 'competitive';
+  const ngDays = (): number => {
+    const raw = Number(field<HTMLInputElement>('ng-days').value);
+    return Number.isFinite(raw) && raw >= 1 ? Math.round(raw) : 5;
+  };
 
-    field<HTMLButtonElement>('ng-deal').disabled = mode !== 'solitaire';
-    field<HTMLElement>('ng-multiplayer-note').style.visibility = mode === 'solitaire' ? 'hidden' : 'visible';
+  const ngTypeRadios = (): HTMLInputElement[] =>
+    Array.from(dlg.querySelectorAll<HTMLInputElement>('input[name="ng-type"]'));
+
+  function ngRefresh(): void {
+    const differing = ngForm.mark(ngBase, 1, ngDays());
+    if (differing.length > 0) ngType = 'custom';
+    else if (ngType === 'custom') ngType = ngBase;
+    for (const r of ngTypeRadios()) r.checked = r.value === ngType;
+    const note = field<HTMLElement>('ng-type-note');
+    note.textContent =
+      ngType === 'custom'
+        ? `${gameTypeLabel('custom', preset(ngBase).scoring)} · ${differing.length} ` +
+          `${differing.length === 1 ? 'setting differs' : 'settings differ'} from ${preset(ngBase).label}.`
+        : preset(ngType as PresetName).blurb;
   }
 
-  for (const input of dlg.querySelectorAll<HTMLInputElement>('input[name="ng-mode"]')) {
-    input.onchange = () => applyModePreset(input.value as Mode);
+  function ngSelectPreset(name: PresetName): void {
+    ngBase = name;
+    ngType = name;
+    ngFloorTyped = false;
+    const values = presetSettings(name, 1, ngDays());
+    ngForm.write(values, values);
+    ngRefresh();
   }
 
+  for (const r of ngTypeRadios()) {
+    // Nothing here can deal a multiplayer game: a `LocalSession` runs the engine in this browser and
+    // a table needs a server. The lobby is the door, and the row says so rather than just refusing
+    // the click (Jesse, 2026-08-23 — a disabled radio that looks enabled reads as a broken one).
+    if (r.value !== 'solitaire' && r.value !== 'custom') {
+      r.disabled = true;
+      const row = r.closest('label');
+      if (row && !row.querySelector('.lb-why')) {
+        row.classList.add('disabled');
+        const note = document.createElement('span');
+        note.className = 'lb-why';
+        note.textContent = ' — use the Multiplayer button; a table needs a server';
+        row.querySelector('span')?.appendChild(note);
+      }
+    }
+    r.onchange = () => {
+      if (!r.checked) return;
+      if (r.value === 'custom') {
+        ngType = 'custom';
+        ngRefresh();
+        return;
+      }
+      ngSelectPreset(r.value as PresetName);
+    };
+  }
+
+  ngForm.onEdit((key) => {
+    if (key === 'minCombinedRevenue') ngFloorTyped = true;
+    ngType = 'custom';
+    ngRefresh();
+  });
+
+  // Days is a parameter, not a rule: it re-derives the floor and never makes a game Custom by itself.
+  field<HTMLInputElement>('ng-days').oninput = () => {
+    if (!ngFloorTyped) {
+      const values = ngForm.read();
+      const want = presetSettings(ngBase, 1, ngDays());
+      ngForm.write({ ...values, minCombinedRevenue: want.minCombinedRevenue }, want);
+    }
+    ngRefresh();
+  };
+
+  // "Everyone moves one chair left" has no meaning at a table of one — disabled with the rest of the
+  // block still visible, so the two screens read the same.
+  ngForm.setEmployeeRotationAvailable(false);
+
   /**
    * ASK FOR ALL OF IT, rather than documenting URL parameters in the title bar.
    *
@@ -1405,8 +1841,9 @@ if (newBtn && dlg) {
    *
    * The dialog OPENS ON THE RULES IN PLAY rather than on the defaults: dealing a second game to
    * compare against the first is the common case, and re-entering settings each time is how a
-   * comparison silently stops comparing. Mode always reopens on Solitaire — it's the only one a
-   * previous session could actually have been, since Deal is disabled for the other two.
+   * comparison silently stops comparing. Which TYPE that is comes out of the comparison — a game
+   * dealt at the Solitaire defaults reopens on Solitaire, and one that was tuned reopens on Custom
+   * with every changed field marked.
    */
   newBtn.onclick = () => {
     // The button itself is hidden for a session that cannot deal (`applyCapabilities`), but the
@@ -1420,26 +1857,15 @@ if (newBtn && dlg) {
     const started = f.status === 'active' && (day > 1 || f.stage > 1);
     if (started && !confirm(`Forget this game (seed ${local.seed()}, Day ${day}) and deal a new one?`)) return;
 
-    const current = f.houseRules;
     field<HTMLInputElement>('ng-seed').value = '';
-    for (const input of dlg.querySelectorAll<HTMLInputElement>('input[name="ng-mode"]')) {
-      input.checked = input.value === 'solitaire';
-    }
-    applyModePreset('solitaire');
-    for (const input of dlg.querySelectorAll<HTMLInputElement>('input[name="ng-hand"]')) {
-      input.checked = input.value === current.startingHand;
-    }
-    for (const input of dlg.querySelectorAll<HTMLInputElement>('input[name="ng-extra"]')) {
-      input.checked = input.value === current.extraStart;
-    }
-    field<HTMLInputElement>('ng-passenger').value = String(current.revenue.passengerPerCoach);
-    field<HTMLInputElement>('ng-freight').value = String(current.revenue.freightPerLoad);
-    field<HTMLInputElement>('ng-transit').value = String(current.revenue.trainPerTransit);
-    // Overwrite the preset with the actual rules in play — solitaire is the only real session today.
     field<HTMLInputElement>('ng-days').value = String(f.days);
-    field<HTMLInputElement>('ng-minrev').value = String(f.minCombinedRevenue);
-    field<HTMLInputElement>('ng-colday').value = String(f.maxCollisionsPerDay);
-    field<HTMLInputElement>('ng-coltotal').value = String(f.maxCollisionsTotal);
+    ngBase = 'solitaire';
+    ngType = 'solitaire';
+    ngFloorTyped = false;
+    // The rules actually in play, then the comparison decides what to call them.
+    ngForm.write(settingsOf(configFromFrame(f)), presetSettings('solitaire', 1, f.days));
+    ngForm.setEmployeeRotationAvailable(false);
+    ngRefresh();
     dlg.showModal();
   };
 
@@ -1449,8 +1875,6 @@ if (newBtn && dlg) {
    *
    * The answers go into the URL and the page navigates, which is the same path `?seed=` already
    * took: `start()` reads them back, so there is exactly one place that turns a URL into a game.
-   * Deal is disabled whenever the mode radio isn't Solitaire, so this never actually runs for the
-   * other two — nothing here needs to branch on mode.
    */
   dlg.addEventListener('close', () => {
     if (dlg.returnValue !== 'deal') return;
@@ -1459,24 +1883,30 @@ if (newBtn && dlg) {
     // A seed the browser cannot parse is not a reason to refuse to deal — blank and unparseable
     // both mean "surprise me", which is what leaving the box alone plainly asks for.
     const seed = asked === '' || !Number.isFinite(Number(asked)) ? '' : String(Math.trunc(Number(asked)));
-    const picked = dlg.querySelector<HTMLInputElement>('input[name="ng-hand"]:checked')?.value;
-    const extra = dlg.querySelector<HTMLInputElement>('input[name="ng-extra"]:checked')?.value;
+    const settings = ngForm.read();
     const rules = houseRules({
       houseRules: {
-        ...(STARTING_HAND_LABELS.some((o) => o.value === picked) ? { startingHand: picked as StartingHand } : {}),
-        ...(EXTRA_START_LABELS.some((o) => o.value === extra) ? { extraStart: extra as ExtraStartRule } : {}),
+        startingHand: settings.startingHand,
+        extraStart: settings.extraStart,
         revenue: {
-          passengerPerCoach: Number(field<HTMLInputElement>('ng-passenger').value),
-          freightPerLoad: Number(field<HTMLInputElement>('ng-freight').value),
-          trainPerTransit: Number(field<HTMLInputElement>('ng-transit').value),
+          passengerPerCoach: settings.passengerPerCoach,
+          freightPerLoad: settings.freightPerLoad,
+          trainPerTransit: settings.trainPerTransit,
         },
       },
     });
     const victory: NewGameOptions = {
-      days: Math.max(1, Math.round(Number(field<HTMLInputElement>('ng-days').value)) || 5),
-      minCombinedRevenue: Math.max(0, Math.round(Number(field<HTMLInputElement>('ng-minrev').value)) || 0),
-      maxCollisionsPerDay: Math.max(0, Math.round(Number(field<HTMLInputElement>('ng-colday').value)) || 0),
-      maxCollisionsTotal: Math.max(0, Math.round(Number(field<HTMLInputElement>('ng-coltotal').value)) || 0),
+      days: Math.max(1, ngDays()),
+      minCombinedRevenue: settings.minCombinedRevenue,
+      maxCollisionsPerDay: settings.maxCollisionsPerDay,
+      maxCollisionsTotal: settings.maxCollisionsTotal,
+      optionalRules: {
+        reducedVisibility: settings.reducedVisibility,
+        // Never on at a table of one, whatever the box says — the control is disabled for the same
+        // reason, and this is the half that reaches the engine.
+        employeeRotation: false,
+        emergencyToolbox: settings.emergencyToolbox,
+      },
     };
 
     clearSave();

src/web/panels.ts

@@ -34,7 +34,7 @@ export function handHtml(f: Frame, canPlay: (boolean | null)[] = []): string {
   // §6.2 (Gitea#6) — say so on the card itself. A player who cannot discard a train needs to read
   // that on the train, not deduce it from a button that is not there.
   const held = 'You may hold this for as many Stages and Days as you like — but a train card is ' +
-    'never discarded (§6.2). The only way it leaves your hand is onto the timetable.';
+    'never discarded. The only way it leaves your hand is onto the timetable.';
   return f.hand.length
     ? f.hand
         .map((h, i) => {
@@ -291,7 +291,7 @@ export function facilitiesHtml(f: Frame): string {
               : '') +
             `<div class="fstat ${x.jammed ? 'bad' : x.canFinish ? 'good' : 'idle'}" data-tip="${
               x.jammed
-                ? 'A load is sitting on MEN|AT|WORK with no spotted car to receive it. That locks the industry track, which blocks the very car that would clear it (§9.3).'
+                ? 'A load is sitting on MEN|AT|WORK with no spotted car to receive it. That locks the industry track, which blocks the very car that would clear it.'
                 : x.canFinish
                   ? 'A matching empty car is spotted on this industry\'s track, so a load worked here can come off onto it.'
                   : 'No matching car is spotted. Starting a load here would park it on WORK and jam the facility.'

src/web/play.html

@@ -80,7 +80,22 @@ main{display:grid;grid-template-columns:minmax(0,1fr) 400px;gap:14px;padding:14p
 @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:640px;margin:0 auto;padding:14px}
+#lobby{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}
+@media(max-width:860px){.lb-two{grid-template-columns:1fr;gap:0}}
+.lb-col{min-width:0}
+.lb-span{grid-column:1/-1;min-width:0}
+/* The rules in as many columns as the width allows — one in the New Game dialog, which is narrow. */
+.set-groups{display:grid;grid-template-columns:repeat(auto-fit,minmax(290px,1fr));gap:0 26px;align-items:start}
+.set-group{min-width:0;break-inside:avoid}
+.set-group h3:first-child{margin-top:4px}
+/* A DISABLED CHOICE HAS TO LOOK DISABLED. Reported by Jesse: Solitaire is not selectable in the
+   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}
 .lb-seat{display:flex;align-items:center;gap:8px;padding:5px 0;border-bottom:1px solid var(--line)}
@@ -227,6 +242,57 @@ h3.actions-hd{font-size:13px;text-transform:none;letter-spacing:.01em;color:#cfe
 ul.blocked{list-style:none;margin:0;padding:0;font-size:12px}
 ul.blocked li{padding:2px 0}
 .sev-warn{color:#e0b060}.sev-stop{color:#e58080}
+/* THE RULES BLOCK, shared by the lobby and the New Game dialog (`settings-form.ts`).
+   `.changed` is the one signal that says "this game is not the type it claims" — amber, the palette's
+   attention colour, never red: a changed rule is a choice, not an error. */
+.set-row{padding:3px 0}
+.set-row.changed{border-left:3px solid #e0b060;padding-left:9px;margin-left:-12px;
+  background:rgba(224,176,96,.08);border-radius:0 4px 4px 0}
+.set-hint{display:block;font-size:11px;color:var(--dim);margin:2px 0 0}
+/* The line under the type radios when a game is no longer the type it started as. */
+.changed-note{color:#e0b060}
+.set-row.changed .set-hint{color:#e0b060}
+.set-row.unavailable{opacity:.5}
+.ng-gate{display:flex;align-items:center;gap:8px;flex-wrap:wrap;padding:3px 0}
+.ng-gate input[type=checkbox]{flex:none}
+.gate-num{width:82px}
+.ng-gate input:disabled{opacity:.45}
+.lb-params{display:flex;gap:14px;flex-wrap:wrap;align-items:end;margin:8px 0}
+.lb-params .ng-num{flex:1 1 150px}
+/* An error a player must not scroll past. The grey `.dim` line this replaced was routinely missed —
+   it looked like the note above it. Red is the palette's `.sev-stop`. */
+.lb-error{color:#e58080;font-size:14px;font-weight:600;margin:8px 0;padding:8px 11px;
+  border-left:3px solid #e58080;background:rgba(229,128,128,.12);border-radius:0 5px 5px 0;
+  empty-cells:hide}
+.lb-error:empty{display:none}
+.lb-warn{color:#e0b060;font-size:13px;margin:8px 0}
+.lb-doors{display:flex;gap:9px;margin:14px 0 12px}
+.lb-door{flex:1;background:#222831;color:var(--fg);border:1px solid var(--line);border-radius:7px;
+  padding:9px 12px;cursor:pointer;font:inherit;font-size:14px}
+.lb-door:hover{border-color:#4d6fa8}
+.lb-door.active{background:#2f3a4b;border-color:#6f8fc8;color:#cfe0f5;font-weight:600}
+.lb-saved{display:flex;align-items:center;gap:10px}
+.lb-known-row{display:flex;align-items:center;gap:10px;padding:6px 0;border-bottom:1px solid var(--line)}
+.lb-known-row:last-child{border-bottom:none}
+.lb-known-row .code{font-weight:700;letter-spacing:.06em;color:#f2e6cf;flex:1}
+.lb-type{font-size:15px;font-weight:600;color:#cfe0f5;margin:2px 0 8px}
+.lb-preview-head{background:#1e242c;border:1px solid var(--line);border-radius:7px;padding:10px 12px;margin:0 0 10px}
+/* The read-only rule set — what a joining player reads before sitting down, and what the seating
+   screen keeps showing afterwards. Generated, never a form: nobody but the host may change these. */
+.rules-list{border:1px solid var(--line);border-radius:7px;background:#171c23;padding:4px 12px;margin:0 0 12px}
+.rules-list dl{display:grid;grid-template-columns:minmax(140px,auto) 1fr;gap:2px 14px;margin:8px 0}
+.rules-list dt{color:var(--dim);font-size:12px}
+.rules-list dd{margin:0;font-size:13px}
+.rules-list dd.changed{color:#e0b060}
+.rules-list h4{font-size:11px;text-transform:uppercase;letter-spacing:.07em;color:var(--dim);margin:10px 0 0}
+/* THE HANDOFF. Between the host pressing Start and the first Frame arriving there is nothing to
+   draw — and a blank board is what a broken game looks like too. */
+#handoff{position:fixed;inset:0;z-index:20;display:none;align-items:center;justify-content:center;
+  background:rgba(18,21,26,.94);text-align:center;padding:20px}
+#handoff.shown{display:flex}
+#handoff .hand-inner{max-width:460px}
+#handoff h2{font-size:15px;text-transform:none;letter-spacing:.01em;color:#cfe0f5}
+#handoff .hand-note{color:var(--dim);font-size:13px;margin-top:8px}
 </style>
 </head>
 <body>
@@ -234,102 +300,251 @@ 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 untouched by any of this. -->
+     `#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. -->
 <div id="lobby" hidden>
   <header><b><a href="./index.html" class="home">Station Master</a></b> — <span class="dim">Multiplayer</span></header>
 
+  <!-- Whatever brought the player here when it was not their own click: a game that was ended under
+       them, or a lobby that closed. Never a field-level error — those sit with their fields. -->
+  <p class="lb-error" id="lb-notice" role="alert" hidden></p>
+
   <section id="lb-secret-section">
     <h2>Join secret</h2>
-    <p class="ng-note">Whoever is running this server gave you a secret out of band (a chat message, not a public page). It is kept in this browser only, never shown back, and sent with every lobby request.</p>
-    <label class="ng-num"><span>Join secret</span><input id="lb-secret" type="password" autocomplete="off"></label>
+    <!-- Saved: one line, not a password field asking to be filled in again. `lobby.ts` swaps these
+         two, and re-opens the ask automatically when the server answers 403. -->
+    <div id="lb-secret-saved" class="lb-saved" hidden>
+      <span class="dim">Join secret · saved in this browser</span>
+      <button id="lb-secret-change" class="ghost" type="button">Change</button>
+    </div>
+    <div id="lb-secret-ask">
+      <p class="ng-note">Whoever is running this server gave you a secret out of band (a chat message, not a public page). It is kept in this browser only, never shown back, and sent with every lobby request.</p>
+      <label class="ng-num"><span>Join secret</span><input id="lb-secret" type="password" autocomplete="off"></label>
+    </div>
+  </section>
+
+  <!-- EVERY GAME THIS BROWSER IS IN. `localStorage` used to hold exactly ONE multiplayer session, so
+       joining a second silently overwrote the first and locked that seat out for good. Keyed by game
+       now, and this is where they are picked between — and forgotten deliberately rather than by
+       accident. -->
+  <section id="lb-known" hidden>
+    <h2>Games you are in</h2>
+    <p class="ng-note">This browser holds a seat in these. Rejoining needs the token kept here, so
+       <b>Forget</b> is the one thing that cannot be undone from this screen.</p>
+    <div id="lb-known-list"></div>
   </section>
 
   <section id="lb-choice-section">
-    <h2>Create or join a game</h2>
     <label class="ng-num"><span>Your display name</span><input id="lb-name" type="text" autocomplete="off" maxlength="40"></label>
 
-    <h3>Create a new game</h3>
-    <p class="ng-note">You become the host — you choose the mode and, once everyone's seated, start the game. 2 to 4 players.</p>
-    <label class="ng-radio"><input type="radio" name="lb-mode" value="competitive" checked>
-      <span><b>Competitive</b><br><span class="dim">Highest Revenue wins, unless the table misses the combined minimum — then everyone loses.</span></span></label>
-    <label class="ng-radio"><input type="radio" name="lb-mode" value="coop">
-      <span><b>Co-op</b><br><span class="dim">Everyone's Revenue counts as one table score, against the same kind of combined minimum.</span></span></label>
-    <label class="ng-num"><span>Players at the table</span>
-      <select id="lb-players">
-        <option value="2">2</option>
-        <option value="3">3</option>
-        <option value="4" selected>4</option>
-      </select></label>
-    <details id="lb-settings">
-      <summary>Game settings</summary>
-      <p class="ng-note">The same dials the solitaire New Game dialog has. Picking a mode or a table
-         size sets them to that game's defaults; every one stays yours to change. They are fixed when
-         the game is created and cannot be changed once it starts.</p>
+    <!-- TWO DOORS, one panel at a time. Joining used to be a heading at the BOTTOM of the create
+         form: someone sent a code had to scroll past fifteen fields they had no use for. -->
+    <div class="lb-doors">
+      <button id="lb-door-join" class="lb-door active" type="button">Join a game</button>
+      <button id="lb-door-create" class="lb-door" type="button">Create a game</button>
+    </div>
 
-      <h3>Seed</h3>
+    <section id="lb-join-panel">
+      <h2>Join a game</h2>
+      <p class="ng-note">Ask whoever created the game for its code. You will see the whole rule set
+         before you take a seat.</p>
+      <label class="ng-num"><span>Game code</span><input id="lb-code" type="text" autocomplete="off" placeholder="RAIL-1234"></label>
+      <button id="lb-look" type="button">Look up game</button>
+      <p class="lb-error" id="lb-join-err" role="alert"></p>
+
+      <!-- Filled by `/api/lobby/preview` — the config, who is seated, and nothing else. The SEED is
+           never in that response: it decides every shuffle in the game. -->
+      <div id="lb-preview" hidden>
+        <h3>Before you sit down</h3>
+        <div class="lb-preview-head">
+          <div class="lb-invite-code" id="lb-preview-code"></div>
+          <div id="lb-preview-type" class="lb-type"></div>
+          <div id="lb-preview-who" class="dim"></div>
+        </div>
+        <div id="lb-preview-rules" class="rules-list"></div>
+        <button id="lb-join" type="button">Join this game</button>
+      </div>
+    </section>
+
+    <section id="lb-create-panel" hidden>
+      <h2>Create a new game</h2>
+      <p class="ng-note">You become the host — you choose the game type and, once everyone is seated, start the game. 2 to 4 players.</p>
+
+      <!-- TWO COLUMNS WHERE THERE IS ROOM. One 640px-wide column made this form a very long scroll
+           for what is really two short lists: what game this is, and what its rules are. -->
+      <div class="lb-two">
+      <div class="lb-col">
+
+      <!-- THE PARAMETERS, above the type. Changing one of these does NOT make the game Custom: the
+           types are formulas in the table size and the length, so the Revenue floor re-derives and
+           "Co-op, 3 players, 8 days" is still Co-op. -->
+      <div class="lb-params">
+        <label class="ng-num"><span>Seed</span>
+          <input id="lb-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="lb-players">
+            <option value="2">2</option>
+            <option value="3">3</option>
+            <option value="4" selected>4</option>
+          </select></label>
+        <label class="ng-num"><span>Days</span>
+          <input id="lb-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>
-      <input id="lb-seed" type="text" inputmode="numeric" autocomplete="off" placeholder="blank for a random seed">
+      <!-- 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>
+      </div>
 
+      <div class="lb-col">
+      <h3>Game type</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>
+      <label class="ng-radio"><input type="radio" name="lb-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="lb-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="lb-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="lb-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="lb-type-note"></p>
+      </div>
+
+      <!-- FULL WIDTH WHEN IT OPENS. Reported by Jesse: opened inside the right-hand column it made a
+           very long scroll with the left column standing empty beside it. It is a grid child of its
+           own now, spanning both, and its five groups flow into as many columns as fit. -->
+      <details id="lb-settings" class="lb-span">
+        <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
+           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>
-      <label class="ng-radio"><input type="radio" name="lb-hand" value="threeRandom" checked>
-        <span>Three random cards</span></label>
-      <label class="ng-radio"><input type="radio" name="lb-hand" value="sixRandom">
-        <span>Six random cards</span></label>
-      <label class="ng-radio"><input type="radio" name="lb-hand" value="threeTrackThreeOther">
-        <span>Three track and three other</span></label>
+      <div class="set-row" id="lb-hand-row">
+        <label class="ng-radio"><input type="radio" name="lb-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="lb-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="lb-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="lb-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="lb-extra-row">
+        <label class="ng-radio"><input type="radio" name="lb-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="lb-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="lb-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="lb-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. Zero switches an economy off so the
-         others can be read.</p>
-      <label class="ng-num"><span>Passenger revenue per coach</span>
-        <input id="lb-passenger" type="number" min="0" max="5" step="1" value="1"></label>
-      <label class="ng-num"><span>Freight revenue per load</span>
-        <input id="lb-freight" type="number" min="0" max="5" step="1" value="1"></label>
-      <label class="ng-num"><span>Train revenue per transit</span>
-        <input id="lb-transit" type="number" min="0" max="5" step="1" value="0"></label>
+      <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="lb-passenger-row">
+        <label class="ng-num"><span>Passenger revenue per coach</span>
+          <input id="lb-passenger" type="number" min="0" max="5" step="1" value="1"></label>
+        <span class="set-hint" id="lb-passenger-hint"></span>
+      </div>
+      <div class="set-row" id="lb-freight-row">
+        <label class="ng-num"><span>Freight revenue per load</span>
+          <input id="lb-freight" type="number" min="0" max="5" step="1" value="1"></label>
+        <span class="set-hint" id="lb-freight-hint"></span>
+      </div>
+      <div class="set-row" id="lb-transit-row">
+        <label class="ng-num"><span>Train revenue per transit</span>
+          <input id="lb-transit" type="number" min="0" max="5" step="1" value="0"></label>
+        <span class="set-hint" id="lb-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">How long the game runs, and the ways it can end. 0 turns any of these off.
-         The combined-Revenue default is sized for the table you chose above.</p>
-      <label class="ng-num"><span>Days</span>
-        <input id="lb-days" type="number" min="1" max="20" step="1" value="5"></label>
-      <label class="ng-num"><span>Minimum combined Revenue to avoid a loss</span>
-        <input id="lb-minrev" type="number" min="0" step="1" value="60"></label>
-      <label class="ng-num"><span>Collisions in one Day that end the game</span>
-        <input id="lb-colday" type="number" min="0" step="1" value="3"></label>
-      <label class="ng-num"><span>Collisions across the whole game that end it</span>
-        <input id="lb-coltotal" type="number" min="0" step="1" value="5"></label>
-      <label class="ng-num"><span>Allow the opponent-directed cards</span>
-        <input id="lb-pvp" type="checkbox"></label>
-      <p class="ng-note" id="lb-pvp-note">Not yet built (<code>TODO.md</code>) — this has no effect
-         either way until then.</p>
+      <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="lb-minrev-row">
+        <label class="ng-gate"><input type="checkbox" id="lb-minrev-on" checked>
+          <span>Everyone loses if combined Revenue at the end is under</span>
+          <input id="lb-minrev" type="number" min="0" step="1" class="gate-num"></label>
+        <span class="set-hint" id="lb-minrev-hint"></span>
+      </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>
+          <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>
+          <input id="lb-coltotal" type="number" min="0" step="1" class="gate-num"></label>
+        <span class="set-hint" id="lb-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">Appendix B. Off by default; each one changes how the game plays.</p>
-      <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="lb-visibility" type="checkbox"></label>
-      <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="lb-rotation" type="checkbox"></label>
-      <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="lb-toolbox" type="checkbox"></label>
-    </details>
-    <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>
-    <button id="lb-create">Create game</button>
-    <p class="dim" id="lb-create-err" role="alert"></p>
+      <p class="ng-note">Off in every game type; 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>
+          <input id="lb-visibility" type="checkbox"></label>
+        <span class="set-hint" id="lb-visibility-hint"></span>
+      </div>
+      <div class="set-row" id="lb-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="lb-rotation" type="checkbox"></label>
+        <span class="set-hint" id="lb-rotation-hint"></span>
+      </div>
+      <div class="set-row" id="lb-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="lb-toolbox" type="checkbox"></label>
+        <span class="set-hint" id="lb-toolbox-hint"></span>
+      </div>
+      </div>
 
-    <h3>Join a game</h3>
-    <p class="ng-note">Ask whoever created the game for its code.</p>
-    <label class="ng-num"><span>Game code</span><input id="lb-code" type="text" autocomplete="off" placeholder="RAIL-1234"></label>
-    <button id="lb-join">Join game</button>
-    <p class="dim" id="lb-join-err" role="alert"></p>
+      </div>
+      </details>
+
+      <div class="lb-span">
+        <button id="lb-create" type="button">Create game</button>
+        <p class="lb-error" id="lb-create-err" role="alert"></p>
+      </div>
+      </div>
+    </section>
   </section>
 
   <!-- Shown once created or joined, in place of the choice above, until the host starts the game. -->
@@ -337,20 +552,28 @@ ul.blocked li{padding:2px 0}
     <h2>Seating</h2>
     <div class="lb-invite">
       <div>
-        <div class="lb-invite-label">Send this code to your players</div>
+        <div class="lb-invite-label">Send this to your players</div>
         <div class="lb-invite-code" id="lb-gamecode"></div>
       </div>
-      <button id="lb-copy" class="ghost">Copy</button>
+      <button id="lb-copy" class="ghost" type="button">Copy code</button>
+      <button id="lb-copylink" class="ghost" type="button">Copy invite link</button>
       <span class="ng-note" id="lb-copied"></span>
     </div>
-    <p class="ng-note">They enter it under <b>Join a game</b>, along with the same join secret you used.</p>
-    <p class="ng-note">The host may fill an empty seat with a bot, and starts the game once every
-       seat is either a player or a bot. <b>These chairs are not the running order</b> — who sits
-       where along the Division is decided by a D12 roll when the game starts (§4.4), and the map
-       shows the result.</p>
+    <p class="ng-note">They enter the code under <b>Join a game</b>, along with the same join secret
+       you used — the link carries the code, never the secret.</p>
+    <p class="ng-note">The host may fill an empty seat with a bot or clear an occupied one, and
+       starts the game once every seat is either a player or a bot. <b>These chairs are not the
+       running order</b> — who sits where along the Division is decided by a D12 roll when the game
+       starts, and the map shows the result.</p>
     <div id="lb-seats"></div>
+    <p class="lb-warn" id="lb-stream-note" role="status" hidden></p>
     <button id="lb-start" disabled>Start game</button>
-    <p class="dim" id="lb-start-note"></p>
+    <button id="lb-leave" class="ghost" type="button">Leave</button>
+    <p class="lb-error" id="lb-start-note" role="alert"></p>
+
+    <h3>The game you are in</h3>
+    <div id="lb-seating-type" class="lb-type"></div>
+    <div id="lb-seating-rules" class="rules-list"></div>
   </section>
 </div>
 
@@ -363,6 +586,14 @@ ul.blocked li{padding:2px 0}
        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 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
@@ -379,6 +610,12 @@ ul.blocked li{padding:2px 0}
   <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="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
+       play a different game later?" There was no way at all — the page rejoined the same game on
+       every load and nothing let go of it. This keeps your seat — the table waits for you — and
+       your token, and puts you back at the lobby, which lists every game this browser is in. -->
+  <button id="leavegame" hidden title="Go back to the lobby. Your seat is kept and the game waits for you — the lobby lists it under Games you are in, so you can come back or hand the browser to a different game.">Leave game</button>
   <a class="home" href="./replays.html" style="font-size:12px">replays</a>
   <span class="dim build" title="what is actually deployed">__BUILD__</span>
 </header>
@@ -471,60 +708,152 @@ ul.blocked li{padding:2px 0}
   <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>
-    <p class="ng-note">Picking a type just sets the fields below to that type's defaults — every number stays yours to change afterward. Solitaire is the only type that can be dealt today; Competitive and Co-op need a server (coming soon).</p>
-    <label class="ng-radio"><input type="radio" name="ng-mode" value="solitaire" checked>
-      <span><b>Solitaire</b><br><span class="dim">One railroad, one player. Everything below is real today.</span></span></label>
-    <label class="ng-radio"><input type="radio" name="ng-mode" value="competitive">
-      <span><b>Competitive</b><br><span class="dim">Highest Revenue wins, unless the table misses the combined minimum — then everyone loses.</span></span></label>
-    <label class="ng-radio"><input type="radio" name="ng-mode" value="coop">
-      <span><b>Co-op</b><br><span class="dim">Everyone's Revenue counts as one table score, against the same kind of combined minimum.</span></span></label>
+    <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>
 
-    <h3>Seed</h3>
-    <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>
-    <input id="ng-seed" type="text" inputmode="numeric" autocomplete="off" placeholder="blank for a random seed">
+    <p class="ng-note" id="ng-type-note"></p>
 
-    <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>
-    <label class="ng-radio"><input type="radio" name="ng-hand" value="threeRandom" checked>
-      <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">
-      <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>
+    <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">
 
-    <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>
-    <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 of §7. 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’s own Control Point</b><br><span class="dim">You may start one at home, but not in somebody else’s district.</span></span></label>
-    <label class="ng-radio"><input type="radio" name="ng-extra" value="anyOffice" checked>
-      <span><b>Also any player’s Control Point</b><br><span class="dim">The most permissive, and what the game did before this setting existed.</span></span></label>
+      <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>
 
-    <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>
-    <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>
-    <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>
-    <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>
-    <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. It defaults to 0 for that reason.</p>
+      <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>
 
-    <h3>Victory conditions</h3>
-    <p class="ng-note">How long the game runs, and the ways it can end. 0 turns any of these off. The combined-Revenue suggestion updates for Competitive/Co-op — it assumes a 4-player table until there's a lobby to ask who's actually seated.</p>
-    <label class="ng-num"><span>Days</span>
-      <input id="ng-days" type="number" min="1" max="20" step="1" value="5"></label>
-    <label class="ng-num"><span>Minimum combined Revenue to avoid a loss</span>
-      <input id="ng-minrev" type="number" min="0" step="1" value="15"></label>
-    <label class="ng-num"><span>Collisions in one Day that end the game</span>
-      <input id="ng-colday" type="number" min="0" step="1" value="3"></label>
-    <label class="ng-num"><span>Collisions across the whole game that end it</span>
-      <input id="ng-coltotal" type="number" min="0" step="1" value="5"></label>
-    <label class="ng-num"><span>Allow the opponent-directed cards</span>
-      <input id="ng-pvp" type="checkbox"></label>
-    <p class="ng-note" id="ng-pvp-note">Not yet built (<code>TODO.md</code>) — this has no effect either way until then.</p>
+      <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>
+
+      </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>
@@ -534,6 +863,18 @@ ul.blocked li{padding:2px 0}
   </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
+     had nothing to say when the first push never came. This is its own state: it opens on the way
+     into a game, holds a deliberate beat so the game visibly begins, and closes on the first Frame. -->
+<div id="handoff">
+  <div class="hand-inner">
+    <h2 id="handoff-title">Dealing the railroad…</h2>
+    <div id="handoff-note" class="hand-note"></div>
+  </div>
+</div>
+
 <script type="module" src="./web/main.js"></script>
 </body>
 </html>

src/web/presets.ts

@@ -0,0 +1,351 @@
+/**
+ * THE FOUR GAME TYPES, and what "Custom" means.
+ *
+ * Jesse's design, 2026-08-23. A game type is not a mode and not a ruleset — it is a NAMED SET OF
+ * DEFAULTS that the host may then edit. Editing any of them selects `custom`, which keeps the
+ * values and inherits the scoring of the type it was edited away from; clicking a named type again
+ * resets every rule back to it.
+ *
+ * WHY THIS FILE EXISTS RATHER THAN A CONSTANT IN EACH SCREEN. The lobby (`lobby.ts`) and the
+ * solitaire New Game dialog (`main.ts`) ask the same questions, and they had already drifted apart
+ * before this was written: the dialog had "where an Extra may start" and no optional rules, the
+ * lobby had the optional rules and no Extra rule — so a multiplayer game silently played the most
+ * permissive Extra rule and nobody was ever asked. One description of the defaults, imported by
+ * both, is what stops that happening a third time.
+ *
+ * PARAMETERS ARE NOT SETTINGS. Seed, player count and Day count sit ABOVE the type radios on both
+ * screens and never select `custom`: the presets are formulas in players and days, so "Co-op, 3
+ * players, 8 days" is still Co-op and its Revenue floor re-derives. Everything below the radios is
+ * a rule, and changing one is what makes a game Custom.
+ */
+
+import {
+  DEFAULT_MAX_COLLISIONS_PER_DAY,
+  DEFAULT_MAX_COLLISIONS_TOTAL,
+  collectiveRevenueFloor,
+  houseRules,
+} from '../engine/content.ts';
+import type { ExtraStartRule, RevenueRules, StartingHand } from '../engine/content.ts';
+import type { GameConfig, GameMode } from '../engine/state.ts';
+
+export type PresetName = 'solitaire' | 'coop' | 'competitive' | 'cutthroat';
+/** What the radio group answers: one of the four named types, or the state of having edited one. */
+export type GameType = PresetName | 'custom';
+
+/**
+ * Every rule a game type sets, flattened to one value per control.
+ *
+ * Flat rather than shaped like `GameConfig` because this is what the FORM compares against: each key
+ * is one field on screen, so "which fields differ from the preset" is a key-by-key comparison rather
+ * than a walk through nested objects. `configFromSettings` puts the shape back.
+ */
+export type Settings = {
+  startingHand: StartingHand;
+  extraStart: ExtraStartRule;
+  passengerPerCoach: number;
+  freightPerLoad: number;
+  trainPerTransit: number;
+  /** 0 means the condition is off — the engine's convention (`state.ts`). The form draws a checkbox. */
+  minCombinedRevenue: number;
+  maxCollisionsPerDay: number;
+  maxCollisionsTotal: number;
+  reducedVisibility: boolean;
+  employeeRotation: boolean;
+  emergencyToolbox: boolean;
+};
+
+export const SETTING_KEYS: readonly (keyof Settings)[] = [
+  'startingHand',
+  'extraStart',
+  'passengerPerCoach',
+  'freightPerLoad',
+  'trainPerTransit',
+  'minCombinedRevenue',
+  'maxCollisionsPerDay',
+  'maxCollisionsTotal',
+  'reducedVisibility',
+  'employeeRotation',
+  'emergencyToolbox',
+];
+
+export type Preset = {
+  name: PresetName;
+  label: string;
+  /** One line under the radio, saying what winning and losing mean in this type. */
+  blurb: string;
+  /** The engine mode this type is scored under — what a `custom` game inherits. */
+  scoring: GameMode;
+  /**
+   * Whether the 22 opponent-directed cards would be dealt, once they exist. Not a form control any
+   * more: it is a property of the type (`TODO.md` — the cards are unbuilt, so `buildDeck` holds them
+   * out regardless, and a checkbox that cannot do anything is worse than a sentence saying so).
+   */
+  pvpCards: boolean;
+  /**
+   * The Revenue floor this type asks for, as a function of the table and the length. Co-op keeps the
+   * engine's own `collectiveRevenueFloor` (3 per player per Day); Competitive asks two thirds of it,
+   * because a table racing each other is not also pulling in one direction; Cutthroat asks nothing.
+   */
+  revenueFloor: (players: number, days: number) => number;
+  rules: Omit<Settings, 'minCombinedRevenue'>;
+};
+
+const NO_OPTIONAL_RULES = {
+  reducedVisibility: false,
+  employeeRotation: false,
+  emergencyToolbox: false,
+} as const;
+
+/** Every type deals six now (Jesse, 2026-08-23) — the hand limit is three, so the first turn is a
+ * discard whichever three you keep. Solitaire moved with the rest so the two screens agree. */
+const SIX: StartingHand = 'sixRandom';
+
+export const PRESETS: readonly Preset[] = [
+  {
+    name: 'solitaire',
+    label: 'Solitaire',
+    blurb: 'One railroad, one player. The whole Division is yours to run.',
+    scoring: 'solitaire',
+    pvpCards: false,
+    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',
+      passengerPerCoach: 1,
+      freightPerLoad: 1,
+      trainPerTransit: 0,
+      maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
+      maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
+      ...NO_OPTIONAL_RULES,
+    },
+  },
+  {
+    name: 'coop',
+    label: 'Co-op',
+    blurb: 'Everyone’s Revenue is one table score. You win together or lose together.',
+    scoring: 'coop',
+    // Never, even once the cards are built: there is no opponent to point them at when the table is
+    // one side.
+    pvpCards: false,
+    revenueFloor: (players, days) => collectiveRevenueFloor(players, days),
+    rules: {
+      startingHand: SIX,
+      extraStart: 'ownOffice',
+      passengerPerCoach: 1,
+      freightPerLoad: 1,
+      // The one economy that pays every player at once, for work nobody had to do — which is the
+      // co-operative one, so it is the type that switches it on.
+      trainPerTransit: 1,
+      maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
+      maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
+      ...NO_OPTIONAL_RULES,
+    },
+  },
+  {
+    name: 'competitive',
+    label: 'Competitive',
+    blurb: 'Highest Revenue wins — unless the table misses its combined minimum, and then everyone loses.',
+    scoring: 'competitive',
+    pvpCards: true,
+    revenueFloor: (players, days) => 2 * players * days,
+    rules: {
+      startingHand: SIX,
+      extraStart: 'ownOffice',
+      passengerPerCoach: 1,
+      freightPerLoad: 1,
+      trainPerTransit: 0,
+      maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
+      maxCollisionsTotal: DEFAULT_MAX_COLLISIONS_TOTAL,
+      ...NO_OPTIONAL_RULES,
+    },
+  },
+  {
+    name: 'cutthroat',
+    label: 'Cutthroat',
+    blurb: 'Highest Revenue wins, and nothing is shared — the only way everyone loses is three collisions in one Day.',
+    scoring: 'competitive',
+    pvpCards: true,
+    // Off. Cutthroat has no collective obligation of any kind.
+    revenueFloor: () => 0,
+    rules: {
+      startingHand: SIX,
+      // The one type that lets you plant an Extra in somebody else's district.
+      extraStart: 'anyOffice',
+      passengerPerCoach: 1,
+      freightPerLoad: 1,
+      trainPerTransit: 0,
+      maxCollisionsPerDay: DEFAULT_MAX_COLLISIONS_PER_DAY,
+      // Off, with the per-Day check left standing: a table can bleed collisions all game, but three
+      // in one Day still ends it.
+      maxCollisionsTotal: 0,
+      ...NO_OPTIONAL_RULES,
+    },
+  },
+];
+
+export function preset(name: PresetName): Preset {
+  const found = PRESETS.find((p) => p.name === name);
+  if (!found) throw new Error(`no such preset: ${name}`);
+  return found;
+}
+
+/** Every rule a named type sets, at the table size and length the form currently shows. */
+export function presetSettings(name: PresetName, players: number, days: number): Settings {
+  const p = preset(name);
+  return { ...p.rules, minCombinedRevenue: p.revenueFloor(players, days) };
+}
+
+/** The settings a config is actually carrying — the other half of every comparison below. */
+export function settingsOf(config: GameConfig): Settings {
+  const rules = houseRules(config);
+  return {
+    startingHand: rules.startingHand,
+    extraStart: rules.extraStart,
+    passengerPerCoach: rules.revenue.passengerPerCoach,
+    freightPerLoad: rules.revenue.freightPerLoad,
+    trainPerTransit: rules.revenue.trainPerTransit,
+    minCombinedRevenue: config.minCombinedRevenue,
+    maxCollisionsPerDay: config.maxCollisionsPerDay,
+    maxCollisionsTotal: config.maxCollisionsTotal,
+    reducedVisibility: config.optionalRules.reducedVisibility,
+    employeeRotation: config.optionalRules.employeeRotation,
+    emergencyToolbox: config.optionalRules.emergencyToolbox,
+  };
+}
+
+/** Which controls differ from a named type — what the form paints amber and counts in its summary. */
+export function differencesFrom(
+  name: PresetName,
+  settings: Settings,
+  players: number,
+  days: number,
+): (keyof Settings)[] {
+  const want = presetSettings(name, players, days);
+  return SETTING_KEYS.filter((k) => settings[k] !== want[k]);
+}
+
+/**
+ * WHICH TYPE IS THIS, derived rather than stored.
+ *
+ * Nothing writes a type name into `GameConfig` — a saved game is its numbers, and a name in the save
+ * would be one more thing that can disagree with them. So the screens ask this instead, which means
+ * a hand-tuned game that happens to match Competitive exactly reads as Competitive, and that is the
+ * honest answer: it IS one.
+ *
+ * `mode` is part of the comparison, so a Co-op game whose dials happen to equal Competitive's is
+ * still not Competitive.
+ */
+export function presetOf(config: GameConfig, players: number, days: number): GameType {
+  const settings = settingsOf(config);
+  const match = PRESETS.find(
+    (p) => p.scoring === config.mode && differencesFrom(p.name, settings, players, days).length === 0,
+  );
+  return match?.name ?? 'custom';
+}
+
+/**
+ * A `Frame`'s copy of the config, as a `GameConfig` the functions above can read.
+ *
+ * The page has a Frame, never a `GameState` — a remote client holds no game — and the Frame carries
+ * every field these comparisons need. Structurally typed rather than importing `Frame` so this
+ * module stays free of `sim/view.ts`.
+ */
+export function configFromFrame(f: {
+  mode: GameMode;
+  days: number;
+  minCombinedRevenue: number;
+  maxCollisionsPerDay: number;
+  maxCollisionsTotal: number;
+  optionalRules: GameConfig['optionalRules'];
+  houseRules: { startingHand: StartingHand; extraStart: ExtraStartRule; revenue: RevenueRules };
+}): GameConfig {
+  return {
+    mode: f.mode,
+    days: f.days,
+    minCombinedRevenue: f.minCombinedRevenue,
+    maxCollisionsPerDay: f.maxCollisionsPerDay,
+    maxCollisionsTotal: f.maxCollisionsTotal,
+    // Never shown from a Frame — the cards are unbuilt, and the type carries the answer.
+    pvpCardsAllowed: false,
+    optionalRules: f.optionalRules,
+    houseRules: {
+      startingHand: f.houseRules.startingHand,
+      extraStart: f.houseRules.extraStart,
+      revenue: f.houseRules.revenue,
+    },
+  };
+}
+
+/**
+ * The named type a config is NEAREST to, for a screen that has to describe someone else's game.
+ *
+ * The create form always knows which type was clicked, so it compares against that. A join preview
+ * and the seating screen do not — they are handed a finished config and nothing else — and "Custom"
+ * on its own tells a player nothing about what they are joining. Comparing against the same-scoring
+ * type with the fewest differences answers the question they actually have: how far from a normal
+ * game is this, and which normal game?
+ */
+export function closestPreset(
+  config: GameConfig,
+  players: number,
+  days: number,
+): { name: PresetName; differing: (keyof Settings)[] } {
+  const settings = settingsOf(config);
+  const candidates = PRESETS.filter((p) => p.scoring === config.mode);
+  const scored = (candidates.length > 0 ? candidates : PRESETS).map((p) => ({
+    name: p.name,
+    differing: differencesFrom(p.name, settings, players, days),
+  }));
+  return scored.reduce((best, c) => (c.differing.length < best.differing.length ? c : best));
+}
+
+/**
+ * The label a screen shows for the current state of the form — including what a Custom game is being
+ * scored as, which is the one thing a player cannot see from the dials.
+ */
+export function gameTypeLabel(type: GameType, scoring: GameMode): string {
+  if (type !== 'custom') return preset(type).label;
+  const named = PRESETS.find((p) => p.scoring === scoring && p.name !== 'cutthroat');
+  return `Custom — scored as ${named?.label ?? scoring}`;
+}
+
+/** Assembles the config a form's answers describe. `players` reaches the caller separately: it sizes
+ * the lobby's seat array rather than being part of the rules. */
+export function configFromSettings(
+  settings: Settings,
+  scoring: GameMode,
+  days: number,
+  pvpCards: boolean,
+): GameConfig {
+  return {
+    mode: scoring,
+    days,
+    minCombinedRevenue: settings.minCombinedRevenue,
+    maxCollisionsPerDay: settings.maxCollisionsPerDay,
+    maxCollisionsTotal: settings.maxCollisionsTotal,
+    // Inert until the cards are built (`setup.ts`'s `buildDeck` ANDs it with `cardsImplemented`),
+    // and no longer a control on any screen — it is a property of the game type.
+    pvpCardsAllowed: pvpCards,
+    optionalRules: {
+      reducedVisibility: settings.reducedVisibility,
+      employeeRotation: settings.employeeRotation,
+      emergencyToolbox: settings.emergencyToolbox,
+    },
+    houseRules: {
+      startingHand: settings.startingHand,
+      extraStart: settings.extraStart,
+      revenue: {
+        passengerPerCoach: settings.passengerPerCoach,
+        freightPerLoad: settings.freightPerLoad,
+        trainPerTransit: settings.trainPerTransit,
+      },
+    },
+  };
+}
+
+/** The whole config a named type produces, with nothing edited. */
+export function configFromPreset(name: PresetName, players: number, days: number): GameConfig {
+  const p = preset(name);
+  return configFromSettings(presetSettings(name, players, days), p.scoring, days, p.pvpCards);
+}

src/web/replays.ts

@@ -117,7 +117,10 @@ function show(i: number): void {
   // A replay carries the seat names in the frame's own lines rather than a player table, so the
   // solitaire seat is named directly; a multi-player replay reports the index it has.
   const actorName = f.actor === null ? null : `Player ${f.actor + 1}`;
-  $('turnchart').innerHTML = turnChartHtml(f, actorName);
+  // A replay of a multi-player game gets the Fedora too — it is the answer to "why is it asking
+  // THEM", which a replay raises exactly as a live game does.
+  const superName = f.players.length > 1 ? `Player ${f.superintendent + 1}` : null;
+  $('turnchart').innerHTML = turnChartHtml(f, actorName, superName);
   $('vrev').textContent = String(f.revenue);
   $('vpos').textContent = `${at} / ${steps.length - 1}`;
   ($('vscrub') as HTMLInputElement).value = String(at);

src/web/session.ts

@@ -99,9 +99,23 @@ export type Session = {
    * the seat and waits; this is what lets the page say why, instead of going quiet with no
    * explanation. Reflects the last presence push for each seat the server has ever mentioned, not
    * only the ones currently disconnected — a seat that reconnects updates its own entry rather than
-   * disappearing, so the page can tell "never heard from" apart from "was here, then left."
+   * disappearing.
+   *
+   * `seen` is what separates the two absences the page must not conflate: a seat that has connected
+   * at some point and dropped, against one that has never opened the game at all. The server now
+   * reports every other seat on connect (2026-08-23), so this is answerable at the moment a game
+   * starts — which is exactly when "is everyone here?" is the question.
    */
-  presence(): { seat: PlayerIndex; connected: boolean }[];
+  presence(): { seat: PlayerIndex; connected: boolean; seen: boolean }[];
+  /**
+   * Stop listening, for good.
+   *
+   * Only a remote session has anything to close, and only one caller needs it: a player LEAVING a
+   * running game (2026-08-23). Without it the page went back to the lobby with its `EventSource`
+   * still open, so the server — and therefore every other seat — went on reporting them as present
+   * at a table they had walked away from.
+   */
+  close?(): void;
 };
 
 /**
@@ -205,7 +219,24 @@ type Push = {
   frame?: FrameDelta;
   menu: Menu | null;
   lines: { text: string; tone: string }[];
-  presence?: { seat: PlayerIndex; connected: boolean };
+  /** One entry for a change; every other seat at once on the connect push. */
+  presence?: { seat: PlayerIndex; connected: boolean; seen: boolean }[];
+  /**
+   * THE FOUR TRANSIENT SIGNALS, added 2026-08-23.
+   *
+   * A remote session used to return nothing for any of them, so multiplayer had no sound at all, no
+   * timetable flash when the D12 filled a slot, no announcement when a completed run paid the table,
+   * and no highlight on the card you had just drawn — four things solitaire has had all along, and
+   * most of why a multiplayer game felt inert.
+   *
+   * `cues` and `announcement` are SHARED events (a collision anywhere, the Stage bell, a train
+   * leaving the Division) and reach every seat; `justDrawn` is the recipient's own card and nobody
+   * else's — `test/redaction.test.ts` covers exactly that.
+   */
+  cues?: string[];
+  scheduled?: number | null;
+  announcement?: string | null;
+  justDrawn?: string | null;
 };
 
 /**
@@ -239,7 +270,11 @@ export function createRemoteSession(
   let frame: Frame | null = null;
   let menu: Menu | null = null;
   let lines: { text: string; tone: string }[] = [];
-  const presence = new Map<PlayerIndex, boolean>();
+  const presence = new Map<PlayerIndex, { connected: boolean; seen: boolean }>();
+  let cues: string[] = [];
+  let scheduled: number | null = null;
+  let announcement: string | null = null;
+  let justDrawnCard: string | null = null;
   let nextSeq = 1;
   const listeners = new Set<() => void>();
   const changed = (): void => {
@@ -282,7 +317,14 @@ export function createRemoteSession(
       menu = push.menu;
     }
     lines = [...lines, ...push.lines];
-    if (push.presence) presence.set(push.presence.seat, push.presence.connected);
+    for (const p of push.presence ?? []) presence.set(p.seat, { connected: p.connected, seen: p.seen });
+    // Accumulated rather than replaced: two pushes can arrive between two renders, and a cue that
+    // was earned is a cue that should be heard.
+    if (push.cues) cues = [...cues, ...push.cues];
+    if (push.scheduled !== undefined && push.scheduled !== null) scheduled = push.scheduled;
+    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;
     changed();
   };
 
@@ -317,10 +359,32 @@ export function createRemoteSession(
     capabilities: { undo: false, saveLocal: false, newGame: false },
 
     lines: () => lines,
-    takeCues: () => [],
-    takeScheduled: () => null,
-    takeAnnouncement: () => null,
-    justDrawn: () => null,
-    presence: () => [...presence].map(([s, connected]) => ({ seat: s, connected })),
+    // Draining, exactly as the local session's are: each of these marks a moment, so it plays once
+    // and is gone by the next render rather than re-firing on every redraw.
+    takeCues: () => {
+      const out = cues;
+      cues = [];
+      return out;
+    },
+    takeScheduled: () => {
+      const out = scheduled;
+      scheduled = null;
+      return out;
+    },
+    takeAnnouncement: () => {
+      const out = announcement;
+      announcement = null;
+      return out;
+    },
+    justDrawn: () => justDrawnCard,
+    presence: () => [...presence].map(([seat, p]) => ({ seat, connected: p.connected, seen: p.seen })),
+    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
+      // longer on this server".
+      reportedGone = true;
+      source.close();
+      listeners.clear();
+    },
   };
 }

src/web/settings-form.ts

@@ -0,0 +1,353 @@
+/**
+ * THE RULES BLOCK, driven identically on both screens.
+ *
+ * The lobby (`lobby.ts`) and the solitaire New Game dialog (`main.ts`) ask the same eleven questions.
+ * They used to ask them in two hand-written copies and had already drifted — the dialog had "where
+ * an Extra may start" and no optional rules, the lobby the reverse — so this module owns reading,
+ * writing, comparing and annotating the block, and each screen supplies only the id prefix its
+ * markup uses (`lb-` or `ng-`).
+ *
+ * THE MARKUP ITSELF STAYS STATIC IN `play.html`, deliberately. Generating it here would be less
+ * duplication, but `test/web.test.ts` drives the emitted bundle against a hand-built DOM stub with
+ * no HTML parser in it (there is no jsdom in this project, and adding one to test a form is a poor
+ * trade), and the ids in that stub come from scanning the real `play.html`. A test in the same suite
+ * asserts both screens carry every key below, which is the drift guard the shared markup would have
+ * been.
+ */
+
+import { REVENUE_MAX, REVENUE_MIN } from '../engine/content.ts';
+import type { ExtraStartRule, StartingHand } from '../engine/content.ts';
+import { closestPreset, differencesFrom, presetOf, presetSettings, settingsOf } from './presets.ts';
+import type { PresetName, Settings } from './presets.ts';
+import type { GameConfig } from '../engine/state.ts';
+
+/**
+ * How each rule is asked on screen.
+ *
+ * `gated` is the pair introduced 2026-08-23: a checkbox that says whether the condition applies at
+ * all, plus the number it applies at. The engine's convention is that `0` switches these off, which
+ * is exact but unreadable — a Cutthroat game showed two zeroes and left the player to know the
+ * convention. Unchecked still WRITES 0, so nothing under this changed.
+ */
+type Field =
+  | { key: keyof Settings; kind: 'radio'; id: string }
+  | { key: keyof Settings; kind: 'number'; id: string }
+  | { key: keyof Settings; kind: 'checkbox'; id: string }
+  | { key: keyof Settings; kind: 'gated'; id: string };
+
+export const FIELDS: readonly Field[] = [
+  { key: 'startingHand', kind: 'radio', id: 'hand' },
+  { key: 'extraStart', kind: 'radio', id: 'extra' },
+  { key: 'passengerPerCoach', kind: 'number', id: 'passenger' },
+  { key: 'freightPerLoad', kind: 'number', id: 'freight' },
+  { key: 'trainPerTransit', kind: 'number', id: 'transit' },
+  { key: 'minCombinedRevenue', kind: 'gated', id: 'minrev' },
+  { key: 'maxCollisionsPerDay', kind: 'gated', id: 'colday' },
+  { key: 'maxCollisionsTotal', kind: 'gated', id: 'coltotal' },
+  { key: 'reducedVisibility', kind: 'checkbox', id: 'visibility' },
+  { key: 'employeeRotation', kind: 'checkbox', id: 'rotation' },
+  { key: 'emergencyToolbox', kind: 'checkbox', id: 'toolbox' },
+];
+
+/**
+ * What `play.html` must contain for a screen to be able to ask all eleven questions — the exact
+ * attribute text, so `test/web.test.ts` can assert it against the built page.
+ *
+ * THIS IS THE DRIFT GUARD. The two blocks are generated from one template today; this is what says
+ * so tomorrow, when someone edits one of them by hand.
+ */
+export function fieldSelectors(prefix: string): string[] {
+  const out: string[] = [];
+  for (const f of FIELDS) {
+    // A radio group is addressed by NAME — there is no one element carrying the field's id.
+    out.push(f.kind === 'radio' ? `name="${prefix}${f.id}"` : `id="${prefix}${f.id}"`);
+    if (f.kind === 'gated') out.push(`id="${prefix}${f.id}-on"`);
+    out.push(`id="${prefix}${f.id}-row"`, `id="${prefix}${f.id}-hint"`);
+  }
+  return out;
+}
+
+/** The label each field goes under in the read-only view below. */
+const FIELD_LABELS: Record<keyof Settings, string> = {
+  startingHand: 'Starting hand',
+  extraStart: 'An Extra may start at',
+  passengerPerCoach: 'Passenger per coach',
+  freightPerLoad: 'Freight per load',
+  trainPerTransit: 'Train per transit',
+  minCombinedRevenue: 'Combined Revenue floor',
+  maxCollisionsPerDay: 'Collisions in one Day',
+  maxCollisionsTotal: 'Collisions in the game',
+  reducedVisibility: 'Reduced Visibility',
+  employeeRotation: 'Employee Rotation',
+  emergencyToolbox: 'Emergency Toolbox',
+};
+
+const esc = (s: string): string =>
+  s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+
+/**
+ * THE WHOLE RULE SET, READ-ONLY — what a player weighing a join reads before taking a seat, and what
+ * the seating screen keeps showing afterwards.
+ *
+ * Generated rather than a fourth copy of the form: nobody may change these, so form controls would
+ * be a lie, and a `<dl>` says "this is what you are joining" in a third of the space. Fields that
+ * differ from the nearest named type are amber here for the same reason they are amber in the form —
+ * a non-standard game should never be a surprise.
+ */
+export function rulesListHtml(config: GameConfig, players: number, days: number): string {
+  const settings = settingsOf(config);
+  const type = presetOf(config, players, days);
+  const near = closestPreset(config, players, days);
+  const differing = type === 'custom' ? near.differing : [];
+
+  const rows = (keys: (keyof Settings)[]): string =>
+    keys
+      .map((k) => {
+        const changed = differing.includes(k) ? ' class="changed"' : '';
+        return `<dt>${esc(FIELD_LABELS[k])}</dt><dd${changed}>${esc(describe(k, settings[k]))}</dd>`;
+      })
+      .join('');
+
+  const head =
+    `<dl><dt>Players</dt><dd>${players}</dd><dt>Days</dt><dd>${days}</dd>` +
+    `<dt>Opponent-directed cards</dt><dd>not implemented yet</dd></dl>`;
+
+  return (
+    head +
+    `<h4>Opening</h4><dl>${rows(['startingHand', 'extraStart'])}</dl>` +
+    `<h4>Revenue</h4><dl>${rows(['passengerPerCoach', 'freightPerLoad', 'trainPerTransit'])}</dl>` +
+    `<h4>Victory conditions</h4><dl>${rows(['minCombinedRevenue', 'maxCollisionsPerDay', 'maxCollisionsTotal'])}</dl>` +
+    `<h4>Optional rules</h4><dl>${rows(['reducedVisibility', 'employeeRotation', 'emergencyToolbox'])}</dl>`
+  );
+}
+
+/** What a value looks like beside its label — "Co-op default: 75", "Co-op default: six random cards". */
+function describe(key: keyof Settings, value: Settings[keyof Settings]): string {
+  if (typeof value === 'boolean') return value ? 'on' : 'off';
+  if (key === 'startingHand') {
+    const words: Record<StartingHand, string> = {
+      threeRandom: 'three random',
+      sixRandom: 'six random',
+      threeTrackThreeOther: 'three track and three other',
+    };
+    return words[value as StartingHand];
+  }
+  if (key === 'extraStart') {
+    const words: Record<ExtraStartRule, string> = {
+      divisionPointsOnly: 'Division Points only',
+      ownOffice: 'your own Control Point',
+      anyOffice: 'any Control Point',
+    };
+    return words[value as ExtraStartRule];
+  }
+  // A victory condition at 0 is not "0" on screen, it is a condition that does not apply.
+  if (value === 0 && (key === 'minCombinedRevenue' || key === 'maxCollisionsPerDay' || key === 'maxCollisionsTotal')) {
+    return 'off';
+  }
+  return String(value);
+}
+
+export type SettingsForm = {
+  read(): Settings;
+  /** `suggestions` fills the placeholder of a switched-off condition, so ticking it back on has a
+   * number to offer rather than an empty box. */
+  write(values: Settings, suggestions: Settings): void;
+  /**
+   * Paint the block against a named type: every field that differs goes amber and every field gets
+   * its "<Type> default: x" hint. Returns what differs, for the summary line the screen draws.
+   */
+  mark(name: PresetName, players: number, days: number): (keyof Settings)[];
+  /** Custom with no named baseline to compare against — clears the paint rather than lying. */
+  clearMarks(): void;
+  /** Called whenever the player changes any rule; the screen answers by selecting Custom. */
+  onEdit(fn: (key: keyof Settings) => void): void;
+  /** Read-only for the join preview and the seating screen: shown in full, changeable by nobody. */
+  setEditable(on: boolean): void;
+  /** Employee Rotation is meaningless at one player — disabled with a note rather than hidden, so
+   * the two screens still read the same. */
+  setEmployeeRotationAvailable(on: boolean): void;
+};
+
+const $ = <T extends HTMLElement = HTMLElement>(id: string): T | null =>
+  document.getElementById(id) as T | null;
+
+export function settingsForm(prefix: string): SettingsForm {
+  const el = <T extends HTMLElement = HTMLElement>(id: string): T | null => $<T>(`${prefix}${id}`);
+  const radios = (name: string): HTMLInputElement[] =>
+    Array.from(document.querySelectorAll<HTMLInputElement>(`input[name="${prefix}${name}"]`));
+  const checkedRadio = (name: string): string | null =>
+    radios(name).find((r) => r.checked)?.value ?? null;
+
+  let editHandler: ((key: keyof Settings) => void) | null = null;
+  let editable = true;
+
+  function num(id: string, fallback: number): number {
+    const raw = el<HTMLInputElement>(id)?.value ?? '';
+    return raw.trim() === '' || !Number.isFinite(Number(raw)) ? fallback : Math.round(Number(raw));
+  }
+
+  function readGated(id: string): number {
+    // Unchecked IS zero — the engine's "off". The number in the box is kept so re-ticking restores it.
+    if (el<HTMLInputElement>(`${id}-on`)?.checked !== true) return 0;
+    return Math.max(0, num(id, 0));
+  }
+
+  function read(): Settings {
+    return {
+      startingHand: (checkedRadio('hand') ?? 'sixRandom') as StartingHand,
+      extraStart: (checkedRadio('extra') ?? 'anyOffice') as ExtraStartRule,
+      passengerPerCoach: clampRevenue(num('passenger', 1)),
+      freightPerLoad: clampRevenue(num('freight', 1)),
+      trainPerTransit: clampRevenue(num('transit', 0)),
+      minCombinedRevenue: readGated('minrev'),
+      maxCollisionsPerDay: readGated('colday'),
+      maxCollisionsTotal: readGated('coltotal'),
+      reducedVisibility: el<HTMLInputElement>('visibility')?.checked === true,
+      employeeRotation: el<HTMLInputElement>('rotation')?.checked === true,
+      emergencyToolbox: el<HTMLInputElement>('toolbox')?.checked === true,
+    };
+  }
+
+  function write(values: Settings, suggestions: Settings): void {
+    for (const r of radios('hand')) r.checked = r.value === values.startingHand;
+    for (const r of radios('extra')) r.checked = r.value === values.extraStart;
+    setNumber('passenger', values.passengerPerCoach);
+    setNumber('freight', values.freightPerLoad);
+    setNumber('transit', values.trainPerTransit);
+    writeGated('minrev', values.minCombinedRevenue, suggestions.minCombinedRevenue);
+    writeGated('colday', values.maxCollisionsPerDay, suggestions.maxCollisionsPerDay);
+    writeGated('coltotal', values.maxCollisionsTotal, suggestions.maxCollisionsTotal);
+    setChecked('visibility', values.reducedVisibility);
+    setChecked('rotation', values.employeeRotation);
+    setChecked('toolbox', values.emergencyToolbox);
+  }
+
+  function setNumber(id: string, value: number): void {
+    const input = el<HTMLInputElement>(id);
+    if (input) input.value = String(value);
+  }
+
+  function setChecked(id: string, on: boolean): void {
+    const input = el<HTMLInputElement>(id);
+    if (input) input.checked = on;
+  }
+
+  function writeGated(id: string, value: number, suggestion: number): void {
+    const box = el<HTMLInputElement>(`${id}-on`);
+    const input = el<HTMLInputElement>(id);
+    if (box) box.checked = value > 0;
+    if (input) {
+      // A switched-off condition shows an empty box with the suggestion as its placeholder, rather
+      // than a `0` the player has to decode.
+      input.value = value > 0 ? String(value) : '';
+      input.placeholder = String(suggestion);
+      input.disabled = !editable || value === 0;
+    }
+  }
+
+  function mark(name: PresetName, players: number, days: number): (keyof Settings)[] {
+    const want = presetSettings(name, players, days);
+    const differing = differencesFrom(name, read(), players, days);
+    const label = presetLabelOf(name);
+    for (const f of FIELDS) {
+      const row = el(`${f.id}-row`);
+      const hint = el(`${f.id}-hint`);
+      const off = differing.includes(f.key);
+      row?.classList.toggle('changed', off);
+      if (hint) hint.textContent = `${label} default: ${describe(f.key, want[f.key])}`;
+    }
+    return differing;
+  }
+
+  function clearMarks(): void {
+    for (const f of FIELDS) {
+      el(`${f.id}-row`)?.classList.remove('changed');
+      const hint = el(`${f.id}-hint`);
+      if (hint) hint.textContent = '';
+    }
+  }
+
+  function setEditable(on: boolean): void {
+    editable = on;
+    for (const f of FIELDS) {
+      if (f.kind === 'radio') {
+        for (const r of radios(f.id)) r.disabled = !on;
+        continue;
+      }
+      const input = el<HTMLInputElement>(f.id);
+      if (input) {
+        // A gated number stays disabled when its own condition is off, whatever the block's state.
+        const gatedOff = f.kind === 'gated' && el<HTMLInputElement>(`${f.id}-on`)?.checked !== true;
+        input.disabled = !on || gatedOff;
+      }
+      if (f.kind === 'gated') {
+        const box = el<HTMLInputElement>(`${f.id}-on`);
+        if (box) box.disabled = !on;
+      }
+    }
+  }
+
+  function setEmployeeRotationAvailable(on: boolean): void {
+    const input = el<HTMLInputElement>('rotation');
+    if (input) {
+      input.disabled = !on || !editable;
+      if (!on) input.checked = false;
+    }
+    el('rotation-row')?.classList.toggle('unavailable', !on);
+  }
+
+  /** One change handler for every control — the screens all answer it the same way (select Custom). */
+  for (const f of FIELDS) {
+    const fire = (): void => editHandler?.(f.key);
+    if (f.kind === 'radio') {
+      for (const r of radios(f.id)) r.onchange = fire;
+      continue;
+    }
+    const input = el<HTMLInputElement>(f.id);
+    if (input) {
+      input.oninput = fire;
+      input.onchange = fire;
+    }
+    if (f.kind === 'gated') {
+      const box = el<HTMLInputElement>(`${f.id}-on`);
+      if (box) {
+        box.onchange = () => {
+          const number = el<HTMLInputElement>(f.id);
+          if (number) {
+            number.disabled = !box.checked || !editable;
+            // Ticking a condition back on with an empty box takes the suggestion showing in it,
+            // so "on" never means "on, at zero".
+            if (box.checked && number.value.trim() === '') number.value = number.placeholder;
+          }
+          fire();
+        };
+      }
+    }
+  }
+
+  return {
+    read,
+    write,
+    mark,
+    clearMarks,
+    onEdit: (fn) => void (editHandler = fn),
+    setEditable,
+    setEmployeeRotationAvailable,
+  };
+}
+
+function clampRevenue(n: number): number {
+  return Math.max(REVENUE_MIN, Math.min(REVENUE_MAX, n));
+}
+
+/** Kept local rather than imported from `presets.ts`'s `preset()`, which would drag the whole table
+ * in for one word — and this is the only place a hint needs it. */
+function presetLabelOf(name: PresetName): string {
+  const labels: Record<PresetName, string> = {
+    solitaire: 'Solitaire',
+    coop: 'Co-op',
+    competitive: 'Competitive',
+    cutthroat: 'Cutthroat',
+  };
+  return labels[name];
+}

test/advance.test.ts

@@ -1036,7 +1036,8 @@ describe('an Extra starts where the player puts it (Gitea#4)', () => {
    */
   const pending = (trainNumber: number, tier?: 'depot' | 'station'): GameState => {
     const s = game(11);
-    s.pendingExtras = [trainNumber];
+    // Queued by seat 0, who is therefore the one §7 lets place it.
+    s.pendingExtras = [{ trainNumber, player: 0 }];
     s.timetable = s.timetable.map(() => null);
     if (tier) s.officeAreas.get(0)!.tier = tier;
     s.clock.phase = 'newTrain';

test/multiplayer.test.ts

@@ -11,9 +11,10 @@ import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 
 import { advance, pump } from '../src/engine/advance.ts';
-import { applyIntent, areaAtSeat, areaOf } from '../src/engine/apply.ts';
+import { applyIntent, areaAtSeat, areaOf, check } from '../src/engine/apply.ts';
 import { STAGES_PER_DAY, STAGES_PER_SHIFT, crewTrayCount } from '../src/engine/content.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 { coordKey, playerAtSeat, playerLeftOf, seatOf, subdivisions } from '../src/engine/state.ts';
 import { developerBot, playGame } from '../src/sim/bot.ts';
@@ -675,6 +676,105 @@ describe('the New Train phase car-placement round rotates (§7, Gap 9)', () => {
   });
 });
 
+describe('an Extra belongs to the player who played it (§7)', () => {
+  /**
+   * REPORTED BY JESSE 2026-08-23, from a two-player game on StartOS: one seat played a train card
+   * and the OTHER was asked to build the train. For a Timetabled train that is correct — the round
+   * above starts at the Superintendent — but §7 states the Extra rule a paragraph later and it is
+   * the opposite one: "the player who played the card may place the Crew Tray at either Division
+   * Point ... and may load the consist as he chooses."
+   *
+   * The engine could not honour it: `pendingExtras` was a bare `number[]`, so nothing recorded whose
+   * Extra it was and the phase asked whoever the acting order happened to be on. Invisible in
+   * solitaire, where that is always the same person.
+   */
+  const withPendingExtra = (players: number, owner: PlayerIndex) => {
+    const s = game(players);
+    s.clock.phase = 'newTrain';
+    s.timetable = s.timetable.map(() => null);
+    // X22 "Pee-Dee" — a caboose-only Extra, so the consist is short and the round would be visible.
+    s.pendingExtras = [{ trainNumber: 22, player: owner }];
+    return s;
+  };
+
+  it('asks the player who played it where it starts — not whoever the round is on', () => {
+    // The owner is deliberately NOT the Superintendent, which is the case that used to go wrong.
+    const s = withPendingExtra(2, 1 as PlayerIndex);
+    const notSuper = playerLeftOf(s, s.clock.superintendent, 1);
+    s.pendingExtras = [{ trainNumber: 22, player: notSuper }];
+
+    const r = advance(s);
+    assert.equal(r.needsInput, true, 'the phase did not stop to place the Extra');
+    assert.equal(s.clock.currentActor, notSuper, 'the wrong player was asked where the Extra starts');
+  });
+
+  it('refuses another seat placing it, and offers it to nobody else', () => {
+    const s = withPendingExtra(2, 0 as PlayerIndex);
+    const intent = {
+      type: 'newTrain.startExtra' as const,
+      trainNumber: 22,
+      start: { kind: 'divisionPoint' as const, side: 'west' as const },
+    };
+    const theirs = applyIntent(s, 0 as PlayerIndex, intent);
+    assert.ok(theirs.ok, `the owner could not place their own Extra — ${theirs.ok ? '' : theirs.code}`);
+
+    /**
+     * TWO EXTRAS, TWO OWNERS — the case where the guard is actually reachable. The phase stops on
+     * the first pending Extra's owner, so seat 0 is legitimately the current actor; nothing but this
+     * rule stops them placing seat 1's train while they are there.
+     */
+    const both = withPendingExtra(2, 0 as PlayerIndex);
+    both.pendingExtras = [
+      { trainNumber: 22, player: 0 as PlayerIndex },
+      { trainNumber: 24, player: 1 as PlayerIndex },
+    ];
+    advance(both);
+    assert.equal(both.clock.currentActor, 0, 'the first pending Extra should have stopped on its owner');
+    assert.equal(check(both, 0 as PlayerIndex, { ...intent, trainNumber: 24 }), 'NOT_YOUR_EXTRA');
+    const notTheirs = applyIntent(both, 0 as PlayerIndex, { ...intent, trainNumber: 24 });
+    assert.equal(notTheirs.ok, false, 'a seat placed somebody else’s Extra while it was their turn');
+    // And it is not even offered: a menu that lists an action `check` will refuse is a menu lying.
+    assert.equal(
+      legalActions(both, 0 as PlayerIndex).some(
+        (i) => i.type === 'newTrain.startExtra' && i.trainNumber === 24,
+      ),
+      false,
+      'somebody else’s Extra was offered a start point',
+    );
+  });
+
+  it('lets its player load the whole consist, rather than passing the round', () => {
+    // §7: "may load the consist as he chooses" — no going round the table for an Extra.
+    const s = withPendingExtra(2, 0 as PlayerIndex);
+    const owner = 0 as PlayerIndex;
+    const placed = applyIntent(s, owner, {
+      type: 'newTrain.startExtra',
+      trainNumber: 22,
+      start: { kind: 'divisionPoint', side: 'west' },
+    });
+    assert.ok(placed.ok, 'the Extra could not be placed');
+    s.yards.divisionYard.push({ type: 'caboose', loaded: false }, { type: 'caboose', loaded: false });
+
+    const asked: PlayerIndex[] = [];
+    for (let guard = 0; guard < 4; guard++) {
+      const r = advance(s);
+      if (!r.needsInput) break;
+      const actor = s.clock.currentActor!;
+      asked.push(actor);
+      const tray = [...s.trays.values()].find((t) => t.trainIsExtra);
+      assert.ok(tray, 'the Extra has no tray');
+      const result = applyIntent(s, actor, { type: 'newTrain.passCar', trayId: tray.id });
+      if (!result.ok) break;
+    }
+    assert.ok(asked.length > 0, 'nobody was asked to load the Extra');
+    assert.deepEqual(
+      [...new Set(asked)],
+      [owner],
+      `the Extra's consist went round the table (asked ${asked.join(', ')}) instead of staying with its player`,
+    );
+  });
+});
+
 describe('actionMenu is seat-safe (Phase 2 prep)', () => {
   /**
    * REGRESSION. `actionMenu(game, seat)` used `seat` only for the `hand` field — `options`/`direct`/

test/presets.test.ts

@@ -0,0 +1,179 @@
+/**
+ * The four game types (`src/web/presets.ts`) — Jesse's design, 2026-08-23.
+ *
+ * These numbers are a DESIGN, not an implementation detail: they say what Co-op asks of a table and
+ * what Cutthroat refuses to. Pinned here so that changing one is a decision somebody makes on
+ * purpose rather than something a refactor can do quietly.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  PRESETS,
+  closestPreset,
+  configFromPreset,
+  configFromSettings,
+  differencesFrom,
+  gameTypeLabel,
+  preset,
+  presetOf,
+  presetSettings,
+  settingsOf,
+} from '../src/web/presets.ts';
+import type { PresetName } from '../src/web/presets.ts';
+
+const NAMES: PresetName[] = ['solitaire', 'coop', 'competitive', 'cutthroat'];
+
+describe('what each game type is', () => {
+  it('deals six cards in every type — the hand limit is three, so the first turn is a discard', () => {
+    for (const name of NAMES) {
+      assert.equal(presetSettings(name, 4, 5).startingHand, 'sixRandom', `${name} does not deal six`);
+    }
+  });
+
+  it('scores Cutthroat as Competitive, and Co-op as itself', () => {
+    assert.equal(preset('cutthroat').scoring, 'competitive');
+    assert.equal(preset('competitive').scoring, 'competitive');
+    assert.equal(preset('coop').scoring, 'coop');
+    assert.equal(preset('solitaire').scoring, 'solitaire');
+  });
+
+  it('lets the opponent-directed cards into Competitive and Cutthroat only', () => {
+    // Co-op has no opponent to point them at; solitaire has nobody at all. Inert either way until
+    // the cards are built (`setup.ts`), which is why no screen offers this as a control any more.
+    assert.deepEqual(
+      PRESETS.filter((p) => p.pvpCards).map((p) => p.name),
+      ['competitive', 'cutthroat'],
+    );
+  });
+
+  it('pays for a transit in Co-op alone — the one economy that pays everybody at once', () => {
+    assert.equal(presetSettings('coop', 4, 5).trainPerTransit, 1);
+    for (const name of ['solitaire', 'competitive', 'cutthroat'] as PresetName[]) {
+      assert.equal(presetSettings(name, 4, 5).trainPerTransit, 0, `${name} pays for transits`);
+    }
+  });
+
+  it('lets an Extra be planted in another player’s district in Cutthroat only', () => {
+    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');
+  });
+
+  it('leaves every optional rule off, in every type', () => {
+    for (const name of NAMES) {
+      const s = presetSettings(name, 4, 5);
+      assert.deepEqual(
+        [s.reducedVisibility, s.employeeRotation, s.emergencyToolbox],
+        [false, false, false],
+        `${name} switches an optional rule on`,
+      );
+    }
+  });
+});
+
+describe('the Revenue floor is a formula, not a number', () => {
+  /**
+   * Jesse gave these at five Days — Co-op 15 × players, Competitive 10 × players — and they scale,
+   * because a ten-Day game with a five-Day target is not a target. The floor follows the table size
+   * AND the length, which is exactly why both sit above the type radios as parameters rather than
+   * below them as rules.
+   */
+  it('asks 15 per player in Co-op at five Days, and 10 in Competitive', () => {
+    for (const players of [2, 3, 4]) {
+      assert.equal(presetSettings('coop', players, 5).minCombinedRevenue, 15 * players);
+      assert.equal(presetSettings('competitive', players, 5).minCombinedRevenue, 10 * players);
+    }
+  });
+
+  it('scales both ways with the Day count', () => {
+    assert.equal(presetSettings('coop', 3, 8).minCombinedRevenue, 3 * 3 * 8);
+    assert.equal(presetSettings('coop', 3, 3).minCombinedRevenue, 3 * 3 * 3);
+    assert.equal(presetSettings('competitive', 4, 10).minCombinedRevenue, 2 * 4 * 10);
+    assert.equal(presetSettings('competitive', 2, 3).minCombinedRevenue, 2 * 2 * 3);
+  });
+
+  it('asks nothing at all in Cutthroat, and leaves only the per-Day collision check standing', () => {
+    const s = presetSettings('cutthroat', 4, 5);
+    assert.equal(s.minCombinedRevenue, 0, 'Cutthroat has a Revenue floor');
+    assert.equal(s.maxCollisionsTotal, 0, 'Cutthroat caps collisions across the game');
+    assert.equal(s.maxCollisionsPerDay, 3, 'three collisions in one Day still ends a Cutthroat game');
+  });
+});
+
+describe('naming a game from its numbers', () => {
+  it('reads every type back as itself, at every table size and length', () => {
+    for (const name of NAMES) {
+      const players = name === 'solitaire' ? 1 : 3;
+      for (const days of [3, 5, 10]) {
+        const config = configFromPreset(name, players, days);
+        assert.equal(presetOf(config, players, days), name, `${name} at ${days} Days did not read back`);
+      }
+    }
+  });
+
+  it('tells Cutthroat and Competitive apart, though they are scored the same way', () => {
+    const cut = configFromPreset('cutthroat', 4, 5);
+    const comp = configFromPreset('competitive', 4, 5);
+    assert.equal(cut.mode, comp.mode, 'these two are meant to share a scoring mode');
+    assert.equal(presetOf(cut, 4, 5), 'cutthroat');
+    assert.equal(presetOf(comp, 4, 5), 'competitive');
+  });
+
+  it('calls a changed rule Custom, and says which rule', () => {
+    const base = configFromPreset('coop', 4, 5);
+    const settings = { ...settingsOf(base), emergencyToolbox: true };
+    const custom = configFromSettings(settings, 'coop', 5, false);
+    assert.equal(presetOf(custom, 4, 5), 'custom');
+    assert.deepEqual(differencesFrom('coop', settings, 4, 5), ['emergencyToolbox']);
+  });
+
+  it('does not call a Co-op game Competitive just because its dials line up', () => {
+    // The scoring mode is part of the comparison: the same numbers under a different mode are a
+    // different game, and the type is what a player reads to know which.
+    const settings = presetSettings('competitive', 4, 5);
+    const coopScored = configFromSettings(settings, 'coop', 5, false);
+    assert.notEqual(presetOf(coopScored, 4, 5), 'competitive');
+    assert.equal(presetOf(coopScored, 4, 5), 'custom');
+  });
+
+  it('measures a Custom game against the nearest type it is scored as', () => {
+    // A join preview is handed a finished config and nothing else — "Custom" alone would tell a
+    // player nothing about what they are sitting down to.
+    const settings = { ...presetSettings('cutthroat', 4, 5), freightPerLoad: 3 };
+    const config = configFromSettings(settings, 'competitive', 5, true);
+    const near = closestPreset(config, 4, 5);
+    assert.equal(near.name, 'cutthroat', 'a tuned Cutthroat game was measured against something else');
+    assert.deepEqual(near.differing, ['freightPerLoad']);
+  });
+
+  it('says what a Custom game is scored as, since the dials cannot', () => {
+    assert.match(gameTypeLabel('custom', 'coop'), /Co-op/);
+    assert.match(gameTypeLabel('custom', 'competitive'), /Competitive/);
+    assert.equal(gameTypeLabel('cutthroat', 'competitive'), 'Cutthroat');
+  });
+});
+
+describe('the config a form produces', () => {
+  it('carries the type’s scoring mode and its stance on the opponent cards', () => {
+    for (const name of NAMES) {
+      const config = configFromPreset(name, name === 'solitaire' ? 1 : 4, 5);
+      assert.equal(config.mode, preset(name).scoring);
+      assert.equal(config.pvpCardsAllowed, preset(name).pvpCards);
+    }
+  });
+
+  it('spells out every house rule rather than leaving one to a default somewhere else', () => {
+    const config = configFromPreset('competitive', 3, 5);
+    assert.ok(config.houseRules?.startingHand, 'the opening hand was left unnamed');
+    assert.ok(config.houseRules?.extraStart, 'the Extra rule was left unnamed');
+    assert.deepEqual(config.houseRules?.revenue, {
+      passengerPerCoach: 1,
+      freightPerLoad: 1,
+      trainPerTransit: 0,
+    });
+  });
+});

test/server/lobby.test.ts

@@ -10,6 +10,7 @@ import {
   createLobby,
   freshGameCode,
   joinLobby,
+  leaveLobby,
   playerCountAllowed,
   reassignHost,
   setBotSeat,
@@ -250,3 +251,96 @@ describe('game codes', () => {
     assert.match(code, /^[A-Z]+-\d{4}$/);
   });
 });
+
+describe('a name nobody else at the table is using', () => {
+  /**
+   * The display name is not decoration: it labels the district on the Division map, it is what the
+   * turn chart means by "waiting on Jesse", and `record()` puts it in front of every line that
+   * player causes. Two identical names make all three ambiguous, and the names lock at
+   * `Lobby.Start` — so the refusal has to happen at the door.
+   */
+  it('refuses a second player using a name already at the table, whatever the case or spacing', () => {
+    const { lobby } = createLobby(competitive, 'Alice', 'RAIL-0001', 4);
+    for (const attempt of ['Alice', 'alice', '  ALICE  ']) {
+      const result = joinLobby(lobby, attempt);
+      assert.equal(result.ok, false, `"${attempt}" was allowed alongside Alice`);
+      if (!result.ok) assert.equal(result.code, 'NAME_TAKEN');
+    }
+  });
+
+  it('frees the name again when that player leaves', () => {
+    const { lobby, session } = createLobby(competitive, 'Alice', 'RAIL-0001', 4);
+    const joined = joinLobby(lobby, 'Bob');
+    assert.ok(joined.ok);
+    if (!joined.ok) return;
+    const after = leaveLobby(joined.lobby, joined.session.token);
+    const again = joinLobby(after.lobby, 'Bob');
+    assert.equal(again.ok, true, 'a departed player’s name was still held against the table');
+    assert.equal(after.empty, false, 'the host is still seated');
+    assert.equal(after.lobby.hostToken, session.token, 'a non-host leaving moved the host chair');
+  });
+});
+
+describe('leaving a lobby', () => {
+  /**
+   * There was no way out at all before 2026-08-23. Start needs every chair filled and `setBotSeat`
+   * refuses to touch an occupied human seat, so a mis-join or a player who wandered off wedged the
+   * whole table.
+   */
+  const table = () => {
+    const { lobby, session } = createLobby(competitive, 'Alice', 'RAIL-0001', 3);
+    const bob = joinLobby(lobby, 'Bob');
+    assert.ok(bob.ok);
+    if (!bob.ok) throw new Error('Bob could not sit down');
+    const carol = joinLobby(bob.lobby, 'Carol');
+    assert.ok(carol.ok);
+    if (!carol.ok) throw new Error('Carol could not sit down');
+    return { lobby: carol.lobby, alice: session, bob: bob.session, carol: carol.session };
+  };
+
+  it('empties the chair and forgets the token, leaving the rest of the table alone', () => {
+    const { lobby, bob } = table();
+    const after = leaveLobby(lobby, bob.token);
+    assert.equal(after.lobby.seats[1], null, 'the seat was not freed');
+    assert.equal(after.lobby.seats.length, 3, 'the table changed size');
+    assert.ok(!after.lobby.joinOrder.includes(bob.token), 'the departed token is still in the join order');
+    assert.equal((after.lobby.seats[0] as { displayName: string }).displayName, 'Alice');
+    assert.equal((after.lobby.seats[2] as { displayName: string }).displayName, 'Carol');
+  });
+
+  it('names a seat to clear somebody else — what the host’s "remove" does', () => {
+    const { lobby, alice, carol } = table();
+    const after = leaveLobby(lobby, alice.token, 2);
+    assert.equal(after.lobby.seats[2], null, 'the named seat was not cleared');
+    assert.ok(!after.lobby.joinOrder.includes(carol.token));
+    // Seat index IS player index (`lobby.ts`), so nothing may shuffle up to fill the hole.
+    assert.equal((after.lobby.seats[0] as { displayName: string }).displayName, 'Alice');
+    assert.equal((after.lobby.seats[1] as { displayName: string }).displayName, 'Bob');
+  });
+
+  it('passes host rights on when the host is the one who leaves', () => {
+    const { lobby, alice, bob } = table();
+    const after = leaveLobby(lobby, alice.token);
+    assert.equal(after.lobby.hostToken, bob.token, 'the earliest-joined remaining player did not become host');
+    assert.equal(after.empty, false);
+  });
+
+  it('reports the table empty when the last human goes, so the caller can drop it', () => {
+    const { lobby, alice, bob, carol } = table();
+    const one = leaveLobby(lobby, bob.token);
+    const two = leaveLobby(one.lobby, carol.token);
+    assert.equal(two.empty, false, 'Alice is still sitting there');
+    const three = leaveLobby(two.lobby, alice.token);
+    assert.equal(three.empty, true, 'a lobby with nobody human in it did not report itself empty');
+  });
+
+  it('leaves a bot seat to the bot controls, and ignores a token holding no seat', () => {
+    const { lobby, alice } = table();
+    const withBot = setBotSeat(leaveLobby(lobby, alice.token, 1).lobby, 1, true);
+    // `leaveLobby` is about people. A bot is removed with the button that put it there.
+    const after = leaveLobby(withBot, alice.token, 1);
+    assert.deepEqual(after.lobby.seats[1], { kind: 'bot' }, 'leaving cleared a bot seat');
+    const stranger = leaveLobby(withBot, 'not-a-token');
+    assert.equal(stranger.lobby, withBot, 'an unknown token changed the lobby');
+  });
+});

test/server/session.test.ts

@@ -347,3 +347,68 @@ describe('a save survives a release that did not change the rules', () => {
     assert.equal(r.ok, false, 'a truncated replay was returned as a healthy session');
   });
 });
+
+describe('the four transient signals (2026-08-23)', () => {
+  /**
+   * Multiplayer had none of these: `createRemoteSession` answered every one of them with an empty
+   * value, so a game on a server had no sound, no timetable flash, no announcement when a completed
+   * run paid the table, and no badge on the card you had just drawn. They ride on the push now — and
+   * `justDrawn` is the one that has to be careful, because `game.justDrawn` is ONE field for the
+   * whole game and does not say whose card it is.
+   */
+
+  /** Drives the game until the current actor draws a card, and returns that turn's pushes. */
+  const drawSomething = (session: GameSession, players: number): { seat: PlayerIndex; pushes: Map<PlayerIndex, Push> } => {
+    for (let seat = 0 as PlayerIndex; seat < players; seat++) {
+      if (session.connect(seat).menu === null) continue;
+      // Two steps: §6's three options are exclusive, so the turn is spent on drawing before a card
+      // actually leaves the deck.
+      const chose = session.intent(seat, 1, { type: 'localOps.choose', option: 'draw' });
+      assert.equal(chose.accepted, true, 'the actor could not choose to draw');
+      const result = session.intent(seat, 2, { type: 'draw.fromHomeOffice' });
+      assert.equal(result.accepted, true, 'the actor could not draw from the Home Office deck');
+      if (!result.accepted) throw new Error('unreachable');
+      return { seat, pushes: result.pushes };
+    }
+    throw new Error('no seat was able to act');
+  };
+
+  it('sends the drawn card to the seat that drew it, and to nobody else', () => {
+    const session = createSession(42, config, ['Alice', 'Bob', 'Carol']);
+    const { seat, pushes } = drawSomething(session, 3);
+    const mine = pushes.get(seat);
+    assert.ok(mine?.justDrawn, 'the drawing seat was not told which card it drew');
+    for (const [other, push] of pushes) {
+      if (other === seat) continue;
+      assert.equal(
+        push.justDrawn,
+        undefined,
+        `seat ${other} was told which card seat ${seat} drew — that is a hand leak`,
+      );
+    }
+  });
+
+  it('keeps the badge across a reconnect, still only for its owner', () => {
+    const session = createSession(42, config, ['Alice', 'Bob', 'Carol']);
+    const { seat, pushes } = drawSomething(session, 3);
+    const drawn = pushes.get(seat)?.justDrawn;
+    assert.equal(session.connect(seat).justDrawn, drawn, 'a refresh lost the card the player just drew');
+    const other = ((seat + 1) % 3) as PlayerIndex;
+    assert.equal(session.connect(other).justDrawn, undefined, 'a reconnecting seat was told about someone else’s draw');
+  });
+
+  it('sends the shared signals to every seat, identically, and drains them', () => {
+    // A collision anywhere on the Division, the Stage bell, a train running off the end and paying
+    // everyone: these are the table's, not one player's.
+    const session = createSession(42, config, ['Alice', 'Bob', 'Carol']);
+    const { pushes } = drawSomething(session, 3);
+    const cues = [...pushes.values()].map((p) => JSON.stringify(p.cues ?? []));
+    assert.equal(new Set(cues).size, 1, 'seats were sent different sound cues for the same events');
+
+    // Drained: a signal marks a moment, so a later connect must not replay it.
+    const later = session.connect(0 as PlayerIndex);
+    assert.equal(later.cues, undefined, 'a reconnecting client was sent the sounds of what it missed');
+    assert.equal(later.announcement, undefined, 'a reconnecting client was re-sent an old announcement');
+    assert.equal(later.scheduled, undefined, 'a reconnecting client was re-sent an old timetable flash');
+  });
+});

test/web.test.ts

@@ -23,6 +23,8 @@ import { variantsFor } from '../src/engine/track.ts';
 import { divisionSvg, officeSvg } from '../src/sim/board-svg.ts';
 import { ENHANCEMENT_RULES } from '../src/engine/content.ts';
 import { facilitiesHtml, timetableHtml } from '../src/web/panels.ts';
+import { turnChartHtml } from '../src/sim/turnchart.ts';
+import { fieldSelectors } from '../src/web/settings-form.ts';
 import { record, renderHtml } from '../src/sim/replay.ts';
 import { snapshot } from '../src/sim/view.ts';
 import { createGame as createEngineGame } from '../src/engine/setup.ts';
@@ -1525,6 +1527,10 @@ describe('the static build', () => {
       },
       createElement: () => make(),
       addEventListener: () => {},
+      // The shared rules block (`settings-form.ts`) addresses its radio groups by NAME through the
+      // document, since they live in two different screens. Empty is the right answer here: these
+      // suites drive the BOARD, not the New Game dialog.
+      querySelectorAll: () => [],
       body: { appendChild: () => {} },
       // Capture injected stylesheets. The board is SVG styled entirely by class, so a page that
       // renders every card correctly and never loads BOARD_CSS draws them black on black — visibly
@@ -1683,6 +1689,10 @@ describe('the static build', () => {
       },
       createElement: () => make(),
       addEventListener: () => {},
+      // The shared rules block (`settings-form.ts`) addresses its radio groups by NAME through the
+      // document, since they live in two different screens. Empty is the right answer here: these
+      // suites drive the BOARD, not the New Game dialog.
+      querySelectorAll: () => [],
       body: { appendChild: () => {} },
       head: { appendChild: (node: Record<string, unknown>) => void injected.push(node) },
     };
@@ -1764,6 +1774,10 @@ describe('the static build', () => {
       },
       createElement: () => make(),
       addEventListener: () => {},
+      // The shared rules block (`settings-form.ts`) addresses its radio groups by NAME through the
+      // document, since they live in two different screens. Empty is the right answer here: these
+      // suites drive the BOARD, not the New Game dialog.
+      querySelectorAll: () => [],
       body: { appendChild: () => {} },
       head: { appendChild: () => {} },
     };
@@ -2052,7 +2066,8 @@ describe('the static build', () => {
     // since the Extra has not chosen where it starts yet), that group was the only thing offered and
     // it vanished from the page — a legal decision with zero buttons.
     const game = newGame(430);
-    game.state.pendingExtras.push(22); // Extra X22 "Pee-Dee" — one caboose, per-diem.
+    // Solitaire: seat 0 played it, so seat 0 places it (§7).
+    game.state.pendingExtras.push({ trainNumber: 22, player: 0 }); // Extra X22 "Pee-Dee" — one caboose, per-diem.
     game.state.clock.phase = 'newTrain';
     game.state.clock.currentActor = 0;
     assert.equal(currentActor(game), 0, 'a decision should be waiting');
@@ -2466,6 +2481,31 @@ describe('the static build', () => {
     }
   });
 
+  it('names the Superintendent at a table, and stays quiet about it in solitaire', () => {
+    /**
+     * REPORTED BY JESSE 2026-08-23, playing two-player on StartOS: seat 1 played a train card and
+     * seat 2 was asked to build the train. The engine was right — §7 makes a consist up "starting
+     * with the Superintendent and working left" — but nothing on the board said who the
+     * Superintendent WAS, so the question could not be answered from the screen. The Frame has
+     * carried `superintendent` since v0.4.0 and only the standalone replay ever drew it.
+     */
+    const frame = { day: 1, stage: 4, clock: '2:00', phase: 'New Train', phaseKey: 'newTrain', actor: 1 };
+    const table = turnChartHtml(frame, 'Bob', 'Bob');
+    assert.match(table, /Superintendent/, 'the Fedora is not named at a table');
+    assert.match(table, /class="tc-super"/, 'the Fedora has no chip of its own');
+
+    const solo = turnChartHtml(frame, 'Solitaire', null);
+    assert.doesNotMatch(solo, /class="tc-super"/, 'solitaire was told who the Superintendent is');
+
+    // And the phase that raised the question says who builds, where a player will be looking.
+    const src = readFileSync(join(root, 'src/sim/turnchart.ts'), 'utf8');
+    assert.match(
+      src,
+      /starting with the Superintendent and working left/,
+      'the New Train pill does not say whose turn the make-up round starts on',
+    );
+  });
+
   it('offers the same five paces in both replay viewers', () => {
     const standalone = readFileSync(join(root, 'src/sim/replay.ts'), 'utf8');
     const viewer = readFileSync(join(root, 'src/web/replays.html'), 'utf8');
@@ -2489,8 +2529,14 @@ describe('the static build', () => {
     for (const p of phases) {
       assert.match(src, new RegExp(`key: '${p}'`), `no turn-chart pill for the ${p} phase`);
     }
-    // And every pill must carry a tooltip: an icon alone does not explain a phase.
-    const tips = [...src.matchAll(/key: '[a-zA-Z]+',\s*\n\s*label: '[^']+',\s*\n\s*tip: ["']/g)];
+    // And every pill must carry a tooltip: an icon alone does not explain a phase. Comment lines are
+    // allowed to sit between the fields — a tip that needs explaining (the New Train round's order
+    // is one) should be able to carry that explanation next to itself.
+    const tips = [
+      ...src.matchAll(
+        /key: '[a-zA-Z]+',\s*\n(?:\s*\/\/[^\n]*\n)*\s*label: '[^']+',\s*\n(?:\s*\/\/[^\n]*\n)*\s*tip: ["']/g,
+      ),
+    ];
     assert.equal(tips.length, phases.length, 'a turn-chart pill has no tooltip');
 
     const html = readFileSync(join(dist, 'play.html'), 'utf8');
@@ -2557,6 +2603,7 @@ describe('the static build', () => {
           return els.get(id);
         },
         createElement: () => make(), addEventListener: () => {},
+        querySelectorAll: () => [],
         body: { appendChild: () => {} }, head: { appendChild: () => {} },
       };
       g['fetch'] = fetchImpl;
@@ -2616,7 +2663,7 @@ describe('the static build', () => {
     const els = new Map<string, Record<string, unknown>>();
     const make = (id: string): Record<string, unknown> => ({
       textContent: '', style: {}, dataset: {}, onclick: null, disabled: false, innerHTML: '',
-      title: '', hidden: false, classList: { add: () => {}, remove: () => {}, has: () => false },
+      title: '', hidden: false, classList: { add: () => {}, remove: () => {}, has: () => false, toggle: () => {} },
       appendChild: () => {}, addEventListener: () => {}, removeAttribute: () => {},
       querySelector: () => null, querySelectorAll: () => [],
       setAttribute: (k: string, v: string) => { if (k === 'hidden') shown.push(`${id}=${v}`); },
@@ -2629,6 +2676,7 @@ describe('the static build', () => {
         return els.get(id);
       },
       createElement: () => make('?'), addEventListener: () => {},
+      querySelectorAll: () => [],
       body: { appendChild: () => {} }, head: { appendChild: () => {} },
     };
     g['location'] = { search: '?lobby' };
@@ -3154,6 +3202,363 @@ describe('the tray is an engine plus its Rolling Stock', () => {
 
 // ---------------------------------------------------------------------------
 
+describe('the lobby screen', () => {
+  /**
+   * DRIVEN THROUGH THE EMITTED BUNDLE, like the New Game dialog below it. The lobby had no test of
+   * its own at all before 2026-08-23 — every rule in Jesse's game-type design (a type fills the form,
+   * editing a rule makes it Custom, a parameter does not, clicking a type resets the rules under it)
+   * lived only in the code that implements it.
+   */
+  const open = async (
+    search: string,
+    responses: Record<string, unknown> = {},
+    stored: Record<string, string> = {},
+  ) => {
+    execFileSync('node', ['scripts/build-web.ts'], { cwd: root, stdio: 'pipe' });
+    const served = new Set(
+      [...readFileSync(join(dist, 'play.html'), 'utf8').matchAll(/id="([a-zA-Z][\w-]*)"/g)].map((m) => m[1]!),
+    );
+    const els = new Map<string, Record<string, unknown>>();
+    type Radio = {
+      value: string;
+      checked: boolean;
+      disabled: boolean;
+      onchange: (() => void) | null;
+      closest: () => unknown;
+    };
+    /**
+     * A radio knows its row, because a disabled choice is dimmed by dimming the whole label — a bare
+     * `disabled` dot reads as a broken control (Jesse, 2026-08-23).
+     */
+    const group = (values: string[], initial: string): Radio[] =>
+      values.map((value) => ({
+        value,
+        checked: value === initial,
+        disabled: false,
+        onchange: null,
+        closest: () => ({
+          classList: { add: () => {}, remove: () => {}, contains: () => false, toggle: () => {} },
+          querySelector: () => ({ appendChild: () => {} }),
+        }),
+      }));
+    const groups: Record<string, Radio[]> = {
+      'lb-hand': group(['threeRandom', 'sixRandom', 'threeTrackThreeOther'], 'sixRandom'),
+      'lb-extra': group(['divisionPointsOnly', 'ownOffice', 'anyOffice'], 'anyOffice'),
+      'lb-type': group(['solitaire', 'coop', 'competitive', 'cutthroat', 'custom'], 'coop'),
+      'ng-hand': group(['threeRandom', 'sixRandom', 'threeTrackThreeOther'], 'sixRandom'),
+      'ng-extra': group(['divisionPointsOnly', 'ownOffice', 'anyOffice'], 'anyOffice'),
+      'ng-type': group(['solitaire', 'coop', 'competitive', 'cutthroat', 'custom'], 'solitaire'),
+    };
+    const matching = (sel: string): Radio[] => {
+      const name = /name="([^"]+)"/.exec(sel)?.[1] ?? '';
+      const found = groups[name] ?? [];
+      return sel.endsWith(':checked') ? found.filter((r) => r.checked) : found;
+    };
+    const make = (id: string): Record<string, unknown> => {
+      const classes = new Set<string>();
+      let html = '';
+      const node: Record<string, unknown> = {
+        id, value: '', textContent: '', title: '', placeholder: '', className: '',
+        style: {}, dataset: {}, onclick: null, oninput: null, onchange: null,
+        checked: false, disabled: false, hidden: false, open: false, returnValue: '',
+        scrollTop: 0, scrollHeight: 0,
+        classList: {
+          add: (c: string) => void classes.add(c),
+          remove: (c: string) => void classes.delete(c),
+          contains: (c: string) => classes.has(c),
+          has: (c: string) => classes.has(c),
+          toggle: (c: string, on?: boolean) => void (on ?? !classes.has(c) ? classes.add(c) : classes.delete(c)),
+        },
+        addEventListener: () => {}, showModal: () => {}, close: () => {}, focus: () => {},
+        querySelectorAll: (sel: string) => matching(sel),
+        querySelector: (sel: string) => matching(sel)[0] ?? null,
+      };
+      Object.defineProperty(node, 'innerHTML', { get: () => html, set: (v: string) => void (html = v) });
+      return node;
+    };
+    const g = globalThis as Record<string, unknown>;
+    g['document'] = {
+      getElementById: (id: string) => {
+        if (!served.has(id)) return null;
+        if (!els.has(id)) els.set(id, make(id));
+        return els.get(id);
+      },
+      createElement: () => make('style'), addEventListener: () => {},
+      querySelectorAll: (sel: string) => matching(sel),
+      body: { appendChild: () => {} }, head: { appendChild: () => {} },
+    };
+    g['location'] = { search, origin: 'http://box.local', pathname: '/play.html', reload: () => {} };
+    const store = new Map<string, string>(Object.entries(stored));
+    g['localStorage'] = {
+      getItem: (k: string) => store.get(k) ?? null,
+      setItem: (k: string, v: string) => void store.set(k, v),
+      removeItem: (k: string) => void store.delete(k),
+    };
+    g['URLSearchParams'] = NodeURLSearchParams;
+    g['EventSource'] = class { close(): void {} addEventListener(): void {} };
+    g['confirm'] = () => true;
+    // The page holds a beat on the handoff curtain and auto-hides its banners, both through
+    // `window.setTimeout` — a stub with no `window` cannot enter a game at all.
+    g['window'] = { setTimeout: (fn: () => void, ms: number) => setTimeout(fn, ms), clearTimeout };
+    /** Every request the screen makes, so a test can read what it asked for. */
+    const sent: { url: string; body: unknown }[] = [];
+    g['fetch'] = async (url: string, init?: { body?: string }) => {
+      const body = init?.body === undefined ? undefined : JSON.parse(init.body);
+      sent.push({ url, body });
+      const key = Object.keys(responses).find((k) => url.includes(k));
+      return {
+        ok: true,
+        status: 200,
+        json: async () => responses[key ?? ''] ?? { ok: true },
+      };
+    };
+    await import(`file://${join(dist, 'web/main.js')}?t=${Date.now()}-${Math.random()}`);
+    // The element map is built lazily by `getElementById`, so a field the page has not touched yet
+    // is not in it — prime the rest, so a test can type into a box before the page has read it.
+    const doc = g['document'] as { getElementById: (id: string) => unknown };
+    for (const id of served) doc.getElementById(id);
+    return { els, groups, sent };
+  };
+
+  const value = (els: Map<string, Record<string, unknown>>, id: string): string => String(els.get(id)!['value']);
+  const pick = (groups: Record<string, { value: string; checked: boolean; onchange: (() => void) | null }[]>, name: string, v: string) => {
+    const radios = groups[name]!;
+    const chosen = radios.find((r) => r.value === v)!;
+    for (const r of radios) r.checked = r === chosen;
+    chosen.onchange?.();
+  };
+  const chosen = (groups: Record<string, { value: string; checked: boolean }[]>, name: string): string | undefined =>
+    groups[name]!.find((r) => r.checked)?.value;
+
+  it('opens on the join door, with the create form behind it', async () => {
+    // Somebody who was handed a code used to have to scroll past the entire create form to find the
+    // box to type it into.
+    const { els } = await open('?lobby');
+    assert.equal(els.get('lobby')!['hidden'], false, 'the lobby did not open');
+    assert.equal(els.get('lb-join-panel')!['hidden'], false, 'the join door was not the one showing');
+    assert.equal(els.get('lb-create-panel')!['hidden'], true, 'the create form was in the way');
+  });
+
+  it('fills the whole form from the game type, and re-derives the floor from the table', async () => {
+    const { els, groups } = await open('?lobby');
+    // Co-op is the default: 3 per player per Day, and the one type that pays for a transit.
+    assert.equal(value(els, 'lb-minrev'), '60', 'the Co-op floor at four players over five Days');
+    assert.equal(value(els, 'lb-transit'), '1');
+
+    pick(groups, 'lb-type', 'competitive');
+    assert.equal(value(els, 'lb-minrev'), '40', 'Competitive asks two thirds of what Co-op does');
+    assert.equal(value(els, 'lb-transit'), '0', 'Competitive still paid for transits');
+
+    pick(groups, 'lb-type', 'cutthroat');
+    assert.equal(els.get('lb-minrev-on')!['checked'], false, 'Cutthroat still asks a Revenue floor');
+    assert.equal(els.get('lb-coltotal-on')!['checked'], false, 'Cutthroat still caps collisions across the game');
+    assert.equal(els.get('lb-colday-on')!['checked'], true, 'three collisions in a Day must still end it');
+    assert.equal(chosen(groups, 'lb-extra'), 'anyOffice', 'Cutthroat is the type that allows an Extra next door');
+  });
+
+  it('a changed rule selects Custom; a changed parameter does not', async () => {
+    const { els, groups } = await open('?lobby');
+    els.get('lb-players')!['value'] = '2';
+    (els.get('lb-players')!['onchange'] as () => void)();
+    assert.equal(chosen(groups, 'lb-type'), 'coop', 'changing the table size should not change the game type');
+    assert.equal(value(els, 'lb-minrev'), '30', 'the floor did not follow the table size');
+
+    els.get('lb-days')!['value'] = '8';
+    (els.get('lb-days')!['oninput'] as () => void)();
+    assert.equal(chosen(groups, 'lb-type'), 'coop', 'changing the length should not change the game type');
+    assert.equal(value(els, 'lb-minrev'), '48', 'the floor did not follow the Day count');
+
+    els.get('lb-freight')!['value'] = '3';
+    (els.get('lb-freight')!['oninput'] as () => void)();
+    assert.equal(chosen(groups, 'lb-type'), 'custom', 'changing a RULE should have selected Custom');
+    assert.match(String(els.get('lb-type-note')!['textContent']), /scored as Co-op/);
+    assert.match(String(els.get('lb-type-note')!['textContent']), /1 setting differs from Co-op/);
+  });
+
+  it('clicking a type again resets every rule, and leaves the parameters alone', async () => {
+    const { els, groups } = await open('?lobby');
+    els.get('lb-players')!['value'] = '3';
+    (els.get('lb-players')!['onchange'] as () => void)();
+    els.get('lb-seed')!['value'] = '4242';
+    els.get('lb-freight')!['value'] = '3';
+    (els.get('lb-freight')!['oninput'] as () => void)();
+    assert.equal(chosen(groups, 'lb-type'), 'custom');
+
+    pick(groups, 'lb-type', 'coop');
+    assert.equal(value(els, 'lb-freight'), '1', 'the changed rule was not reset');
+    assert.equal(value(els, 'lb-seed'), '4242', 'the seed is a parameter and should have survived');
+    assert.equal(value(els, 'lb-players'), '3', 'the table size is a parameter and should have survived');
+    assert.equal(value(els, 'lb-minrev'), '45', 'the floor was not re-derived for three players');
+  });
+
+  it('creates the game the form describes, and asks the server for it exactly once', async () => {
+    const { els, groups, sent } = await open('?lobby', {
+      '/api/lobby/create': { gameId: 'g1', gameCode: 'RAIL-0001', token: 't1', player: 0 },
+    });
+    els.get('lb-secret')!['value'] = 'letmein';
+    els.get('lb-name')!['value'] = 'Jesse';
+    els.get('lb-players')!['value'] = '3';
+    (els.get('lb-players')!['onchange'] as () => void)();
+    pick(groups, 'lb-type', 'cutthroat');
+    (els.get('lb-create')!['onclick'] as () => void)();
+    await new Promise((r) => setTimeout(r, 20));
+
+    const create = sent.find((r) => r.url.includes('/api/lobby/create'));
+    assert.ok(create, 'the create button sent nothing');
+    const body = create.body as { players: number; displayName: string; config: Record<string, unknown> };
+    assert.equal(body.players, 3);
+    assert.equal(body.displayName, 'Jesse');
+    assert.equal(body.config['mode'], 'competitive', 'Cutthroat is scored as Competitive');
+    assert.equal(body.config['minCombinedRevenue'], 0, 'Cutthroat asks no floor');
+    assert.equal(body.config['maxCollisionsTotal'], 0);
+    assert.equal(body.config['maxCollisionsPerDay'], 3);
+    assert.equal(body.config['pvpCardsAllowed'], true, 'the game type, not a checkbox, decides this now');
+  });
+
+  it('remembers every game this browser is in, not just the last one', async () => {
+    /**
+     * 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 play a different game
+     * later?" There was no way out at all, and worse, `localStorage` held exactly ONE session — so
+     * joining a second game overwrote the first token and locked that seat out for good, which
+     * `TODO.md` had recorded as the nearer half of the lost-token problem.
+     */
+    const two = JSON.stringify({
+      games: {
+        g1: { token: 't1', gameId: 'g1', gameCode: 'RAIL-0001', seat: 0, stage: 'game' },
+        g2: { token: 't2', gameId: 'g2', gameCode: 'HOPPER-4607', stage: 'lobby' },
+      },
+      last: null,
+    });
+    const { els } = await open('?lobby', {}, { 'station-master.remote.v1': two });
+    assert.equal(els.get('lb-known')!['hidden'], false, 'the games this browser is in were not listed');
+    const html = String(els.get('lb-known-list')!['innerHTML']);
+    assert.match(html, /RAIL-0001/);
+    assert.match(html, /HOPPER-4607/, 'only one of the two remembered games was listed');
+    assert.match(html, /in play/, 'a started game is not marked as one');
+    assert.match(html, /waiting to start/, 'a lobby-stage seat is not marked as one');
+  });
+
+  it('carries a session written before the store had more than one game in it', async () => {
+    // The single-record shape, from any build before 2026-08-23. Dropping it would throw away the
+    // game somebody was in the middle of when they updated.
+    const oldShape = JSON.stringify({ token: 't1', gameId: 'g1', gameCode: 'RAIL-0001', seat: 0 });
+    const { els } = await open('?lobby', {}, { 'station-master.remote.v1': oldShape });
+    assert.equal(els.get('lb-known')!['hidden'], false, 'the pre-existing session was forgotten');
+    assert.match(String(els.get('lb-known-list')!['innerHTML']), /RAIL-0001/);
+  });
+
+  it('forgetting one game leaves the others alone', async () => {
+    const two = JSON.stringify({
+      games: {
+        g1: { token: 't1', gameId: 'g1', gameCode: 'RAIL-0001', seat: 0, stage: 'game' },
+        g2: { token: 't2', gameId: 'g2', gameCode: 'HOPPER-4607', seat: 1, stage: 'game' },
+      },
+      last: null,
+    });
+    const { els } = await open('?lobby', {}, { 'station-master.remote.v1': two });
+    const list = els.get('lb-known-list')!;
+    // The stub's innerHTML is a string, so the buttons are found by re-rendering rather than by
+    // querying — drive the handler the page wired instead.
+    assert.match(String(list['innerHTML']), /data-game="g1"/);
+    assert.match(String(list['innerHTML']), /data-game="g2"/);
+  });
+
+  it('shows the whole rule set before a seat is taken, and never the seed', async () => {
+    // A player used to have to sit down before they could read a single rule of the game — and until
+    // this pass there was then no way back out of the chair.
+    const { els, sent } = await open('?lobby', {
+      '/api/lobby/preview': {
+        gameCode: 'RAIL-0001',
+        hostName: 'Jesse',
+        players: 3,
+        seated: [{ seat: 0, who: 'Jesse', bot: false }, { seat: 1, who: null, bot: false }, { seat: 2, who: null, bot: true }],
+        config: {
+          mode: 'competitive', days: 5, minCombinedRevenue: 0, maxCollisionsPerDay: 3, maxCollisionsTotal: 0,
+          pvpCardsAllowed: true,
+          optionalRules: { reducedVisibility: false, employeeRotation: false, emergencyToolbox: false },
+          houseRules: { startingHand: 'sixRandom', extraStart: 'anyOffice', revenue: { passengerPerCoach: 1, freightPerLoad: 1, trainPerTransit: 0 } },
+        },
+      },
+    });
+    els.get('lb-secret')!['value'] = 'letmein';
+    els.get('lb-code')!['value'] = 'rail-0001';
+    (els.get('lb-look')!['onclick'] as () => void)();
+    await new Promise((r) => setTimeout(r, 20));
+
+    const asked = sent.find((r) => r.url.includes('/api/lobby/preview'));
+    assert.ok(asked, 'looking up a game asked the server nothing');
+    assert.match(asked.url, /gameCode=RAIL-0001/, 'the code was not upper-cased on the way out');
+    assert.equal(els.get('lb-preview')!['hidden'], false, 'the preview stayed hidden');
+    assert.equal(els.get('lb-preview-type')!['textContent'], 'Cutthroat');
+    assert.match(String(els.get('lb-preview-who')!['textContent']), /Host: Jesse/);
+    const rules = String(els.get('lb-preview-rules')!['innerHTML']);
+    assert.match(rules, /six random/, 'the opening hand is not on the preview');
+    assert.match(rules, /any Control Point/, 'the Extra rule is not on the preview');
+    assert.match(rules, /Combined Revenue floor<\/dt><dd>off/, 'a switched-off condition should read as off');
+    assert.ok(!/seed/i.test(rules), 'the preview mentions the seed');
+  });
+});
+
+describe('the lobby and the dialog ask the same questions', () => {
+  /**
+   * THE DRIFT GUARD.
+   *
+   * The two screens each carried their own hand-written copy of the rules block and had already
+   * drifted apart before anyone noticed: the dialog had "where an Extra may start" and none of the
+   * three optional rules, the lobby had the optional rules and no Extra rule — so every multiplayer
+   * game silently played the most permissive Extra rule and no host was ever asked about it. The
+   * blocks are generated from one template now; this is what says so tomorrow.
+   */
+  const page = (): string => {
+    execFileSync('node', ['scripts/build-web.ts'], { cwd: root, stdio: 'pipe' });
+    return readFileSync(join(dist, 'play.html'), 'utf8');
+  };
+
+  it('carries every field of the shared block on both screens', () => {
+    const html = page();
+    for (const prefix of ['lb-', 'ng-']) {
+      for (const selector of fieldSelectors(prefix)) {
+        assert.ok(html.includes(selector), `the ${prefix} block is missing ${selector}`);
+      }
+    }
+  });
+
+  it('offers all five game types on both screens', () => {
+    const html = page();
+    for (const prefix of ['lb-', 'ng-']) {
+      for (const type of ['solitaire', 'coop', 'competitive', 'cutthroat', 'custom']) {
+        assert.ok(
+          html.includes(`name="${prefix}type" value="${type}"`),
+          `the ${prefix} screen does not offer ${type}`,
+        );
+      }
+    }
+  });
+
+  it('gives the lobby its own way in and its own way out', () => {
+    // Every one of these is a hole this pass filled: two doors instead of a scroll, a preview before
+    // taking a seat, a leave button, an invite link, and a place to say the connection dropped.
+    const html = page();
+    for (const id of [
+      'lb-door-join', 'lb-door-create', 'lb-look', 'lb-preview', 'lb-preview-rules',
+      'lb-leave', 'lb-copylink', 'lb-stream-note', 'lb-notice', 'lb-secret-saved',
+      'lb-seating-rules', 'handoff',
+    ]) {
+      assert.ok(html.includes(`id="${id}"`), `the lobby is missing #${id}`);
+    }
+  });
+
+  it('no longer offers a control for cards that do not exist', () => {
+    // The opponent-directed cards are unbuilt, and `buildDeck` holds them out however the config is
+    // set — so the checkbox could not do anything, on either screen. The fact is stated in words.
+    const html = page();
+    assert.ok(!html.includes('id="ng-pvp"'), 'the dialog still has the dead PvP checkbox');
+    assert.ok(!html.includes('id="lb-pvp"'), 'the lobby still has the dead PvP checkbox');
+    assert.match(html, /opponent-directed cards[\s\S]{0,120}not implemented yet/i);
+  });
+});
+
 describe('the New Game dialog', () => {
   /**
    * DRIVEN THROUGH THE EMITTED BUNDLE, like the highlight test above, because the thing that can go
@@ -3162,7 +3567,11 @@ describe('the New Game dialog', () => {
    * nothing at all. None of that is visible to a test of `rulesFromUrl` in isolation.
    *
    * A seed alone stopped naming a game the moment the opening hand and the revenue rates became
-   * settings, so what this really pins is that all four ride in the URL and come back out.
+   * settings, so what this really pins is that all of them ride in the URL and come back out.
+   *
+   * REBUILT 2026-08-23 with the five game types. The dialog and the lobby now ask the same eleven
+   * questions through `settings-form.ts`, which addresses its radio groups by NAME through the
+   * DOCUMENT — so the stub keeps one set of groups and answers for both the document and the dialog.
    */
   const load = async (search: string) => {
     execFileSync('node', ['scripts/build-web.ts'], { cwd: root, stdio: 'pipe' });
@@ -3171,33 +3580,47 @@ describe('the New Game dialog', () => {
       [...readFileSync(join(dist, 'play.html'), 'utf8').matchAll(/id="([a-zA-Z][\w-]*)"/g)].map((m) => m[1]!),
     );
     const els = new Map<string, Record<string, unknown>>();
+
+    type Radio = {
+      value: string;
+      checked: boolean;
+      disabled: boolean;
+      onchange: (() => void) | null;
+      closest: () => unknown;
+    };
+    const group = (values: string[], initial: string): Radio[] =>
+      values.map((value) => ({
+        value,
+        checked: value === initial,
+        disabled: false,
+        onchange: null,
+        closest: () => ({
+          classList: { add: () => {}, remove: () => {}, contains: () => false, toggle: () => {} },
+          querySelector: () => ({ appendChild: () => {} }),
+        }),
+      }));
+    // ONE set per page, not one per element: the block is addressed through the document, and a stub
+    // that handed each element its own copy would let a broken selector still pass.
+    const groups: Record<string, Radio[]> = {
+      'ng-hand': group(['threeRandom', 'sixRandom', 'threeTrackThreeOther'], 'sixRandom'),
+      'ng-extra': group(['divisionPointsOnly', 'ownOffice', 'anyOffice'], 'anyOffice'),
+      'ng-type': group(['solitaire', 'coop', 'competitive', 'cutthroat', 'custom'], 'coop'),
+    };
+    const matching = (sel: string): Radio[] => {
+      const name = /name="([^"]+)"/.exec(sel)?.[1] ?? '';
+      const found = groups[name] ?? [];
+      return sel.endsWith(':checked') ? found.filter((r) => r.checked) : found;
+    };
+
     /** Enough of an element for the page to start: the dialog's own API, and a settable `value`. */
     const make = (id: string): Record<string, unknown> => {
       const listeners = new Map<string, (() => void)[]>();
-      const radios = ['threeRandom', 'sixRandom', 'threeTrackThreeOther'].map((value) => ({
-        value,
-        checked: false,
-      }));
-      const extraRadios = ['divisionPointsOnly', 'ownOffice', 'anyOffice'].map((value) => ({
-        value,
-        checked: value === 'anyOffice',
-      }));
-      // The mode radios are real DOM inputs, so `onchange` has to actually fire when a test flips
-      // `checked` — `applyModePreset` is wired to it, not polled.
-      const modeRadios = ['solitaire', 'competitive', 'coop'].map((value) => ({
-        value,
-        checked: value === 'solitaire',
-        onchange: null as (() => void) | null,
-      }));
       let html = '';
       const node: Record<string, unknown> = {
-        id, value: '', textContent: '', title: '', returnValue: '', open: false,
-        style: {}, dataset: {}, onclick: null, scrollTop: 0, scrollHeight: 0,
-        checked: false, disabled: false,
+        id, value: '', textContent: '', title: '', returnValue: '', open: false, placeholder: '',
+        style: {}, dataset: {}, onclick: null, oninput: null, onchange: null, scrollTop: 0, scrollHeight: 0,
+        checked: false, disabled: false, hidden: false, className: '',
         classList: { add: () => {}, remove: () => {}, contains: () => false, toggle: () => {} },
-        radios,
-        modeRadios,
-        extraRadios,
         addEventListener: (type: string, fn: () => void) =>
           void listeners.set(type, [...(listeners.get(type) ?? []), fn]),
         showModal: () => void ((node as { open: boolean }).open = true),
@@ -3205,24 +3628,9 @@ describe('the New Game dialog', () => {
           (node as { open: boolean }).open = false;
           for (const fn of listeners.get('close') ?? []) fn();
         },
-        // Only the radio-group selectors the dialog actually uses; anything else is not this
-        // element's business and answering it with a guess would hide a typo in the real selector.
-        querySelectorAll: (sel: string) =>
-          sel === 'input[name="ng-hand"]'
-            ? radios
-            : sel === 'input[name="ng-mode"]'
-              ? modeRadios
-              : sel === 'input[name="ng-extra"]'
-                ? extraRadios
-                : [],
-        querySelector: (sel: string) =>
-          sel === 'input[name="ng-hand"]:checked'
-            ? (radios.find((r) => r.checked) ?? null)
-            : sel === 'input[name="ng-mode"]:checked'
-              ? (modeRadios.find((r) => r.checked) ?? null)
-              : sel === 'input[name="ng-extra"]:checked'
-                ? (extraRadios.find((r) => r.checked) ?? null)
-                : null,
+        querySelectorAll: (sel: string) => matching(sel),
+        querySelector: (sel: string) => matching(sel)[0] ?? null,
+        focus: () => {},
       };
       Object.defineProperty(node, 'innerHTML', { get: () => html, set: (v: string) => void (html = v) });
       return node;
@@ -3237,6 +3645,7 @@ describe('the New Game dialog', () => {
       },
       createElement: () => make('style'),
       addEventListener: () => {},
+      querySelectorAll: (sel: string) => matching(sel),
       body: { appendChild: () => {} },
       head: { appendChild: () => {} },
     };
@@ -3245,6 +3654,8 @@ describe('the New Game dialog', () => {
       get search() { return nav.search; },
       set search(v: string) { nav.search = v; },
       reload: () => void (nav.reloads += 1),
+      origin: 'http://box.local',
+      pathname: '/play.html',
     };
     const store = new Map<string, string>();
     g['localStorage'] = {
@@ -3254,121 +3665,150 @@ describe('the New Game dialog', () => {
     };
     g['URLSearchParams'] = NodeURLSearchParams;
     g['confirm'] = () => true;
+    g['EventSource'] = class { close(): void {} addEventListener(): void {} };
 
     await import(`file://${join(dist, 'web/main.js')}?t=${Date.now()}-${Math.random()}`);
-    return { els, nav };
+    return { els, nav, groups };
   };
 
+  /** What every field of the block reads, so a test can assert the whole form at once. */
+  const readForm = (els: Map<string, Record<string, unknown>>, groups: Record<string, { value: string; checked: boolean }[]>) => ({
+    hand: groups['ng-hand']!.find((r) => r.checked)?.value,
+    extra: groups['ng-extra']!.find((r) => r.checked)?.value,
+    type: groups['ng-type']!.find((r) => r.checked)?.value,
+    passenger: els.get('ng-passenger')!['value'],
+    freight: els.get('ng-freight')!['value'],
+    transit: els.get('ng-transit')!['value'],
+    days: els.get('ng-days')!['value'],
+    minrev: els.get('ng-minrev')!['value'],
+  });
+
   it('opens on the rules in play, so a second game can be dealt to compare with the first', async () => {
-    // Re-entering four settings for every comparison game is how a comparison silently stops
-    // comparing. The seed is the one field that clears: the same seed twice is not a second sample.
-    const { els } = await load('?seed=430&hand=sixRandom&passenger=2&freight=3&transit=4');
+    // Re-entering settings for every comparison game is how a comparison silently stops comparing.
+    // The seed is the one field that clears: the same seed twice is not a second sample.
+    const { els, groups } = await load('?seed=430&hand=sixRandom&passenger=2&freight=3&transit=4');
     (els.get('newgame')!['onclick'] as () => void)();
 
     const dlg = els.get('newgamedlg')!;
     assert.equal(dlg['open'], true, 'the New game button did not open the dialog');
     assert.equal(els.get('ng-seed')!['value'], '', 'the seed box kept the last game’s seed');
-    assert.equal(els.get('ng-passenger')!['value'], '2');
-    assert.equal(els.get('ng-freight')!['value'], '3');
-    assert.equal(els.get('ng-transit')!['value'], '4');
-    const checked = (dlg['radios'] as { value: string; checked: boolean }[]).filter((r) => r.checked);
-    assert.deepEqual(checked.map((r) => r.value), ['sixRandom'], 'the opening hand in play was not preselected');
+    const form = readForm(els, groups);
+    assert.equal(form.passenger, '2');
+    assert.equal(form.freight, '3');
+    assert.equal(form.transit, '4');
+    assert.equal(form.hand, 'sixRandom', 'the opening hand in play was not preselected');
   });
 
-  it('always reopens on Solitaire, Deal enabled, PvP forced off — the only mode a prior game could be', async () => {
-    const { els } = await load('?seed=430');
-    (els.get('newgame')!['onclick'] as () => void)();
+  it('reopens on Solitaire when the game in play is one, and on Custom when it was tuned', async () => {
+    // The type is DERIVED (`presets.ts`) rather than remembered, so what the dialog says a game is
+    // has to follow from its numbers — including a game whose numbers were hand-edited into the URL.
+    const plain = await load('?seed=430');
+    (plain.els.get('newgame')!['onclick'] as () => void)();
+    assert.equal(readForm(plain.els, plain.groups).type, 'solitaire', 'a default game did not read as Solitaire');
 
-    const dlg = els.get('newgamedlg')!;
-    const modeRadios = dlg['modeRadios'] as { value: string; checked: boolean }[];
-    assert.deepEqual(
-      modeRadios.filter((r) => r.checked).map((r) => r.value),
-      ['solitaire'],
-      'the dialog did not reopen on Solitaire',
+    const tuned = await load('?seed=430&transit=4');
+    (tuned.els.get('newgame')!['onclick'] as () => void)();
+    assert.equal(readForm(tuned.els, tuned.groups).type, 'custom', 'a game paying for transits still read as Solitaire');
+    assert.match(
+      String(tuned.els.get('ng-type-note')!['textContent']),
+      /1 setting differs from Solitaire/,
+      'the note did not say what differs',
     );
-    assert.equal(els.get('ng-deal')!['disabled'], false, 'Deal was disabled for the one dealable mode');
-    assert.equal(els.get('ng-pvp')!['checked'], false, 'PvP defaulted on for Solitaire');
-    assert.equal(els.get('ng-pvp')!['disabled'], true, "Solitaire's PvP checkbox was left editable");
   });
 
-  it('picking Competitive suggests a 4-player floor, turns PvP on, and disables Deal', async () => {
-    const { els } = await load('?seed=430');
+  it('offers the multiplayer types, disabled — one list across both screens, dealt from one of them', async () => {
+    const { els, groups } = await load('?seed=430');
     (els.get('newgame')!['onclick'] as () => void)();
-
-    const dlg = els.get('newgamedlg')!;
-    const modeRadios = dlg['modeRadios'] as { value: string; checked: boolean; onchange: (() => void) | null }[];
-    const competitive = modeRadios.find((r) => r.value === 'competitive')!;
-    for (const r of modeRadios) r.checked = r === competitive;
-    competitive.onchange!();
-
-    assert.equal(els.get('ng-minrev')!['value'], '60', 'the suggested floor is not 3 * 4 players * 5 days');
-    assert.equal(els.get('ng-pvp')!['checked'], true, 'Competitive did not default PvP on');
-    assert.equal(els.get('ng-pvp')!['disabled'], false, "Competitive's PvP checkbox was left disabled");
-    assert.equal(els.get('ng-deal')!['disabled'], true, 'Deal was enabled for a mode with nowhere to go yet');
+    const disabled = groups['ng-type']!
+      .filter((r) => (r as { disabled: boolean }).disabled)
+      .map((r) => r.value);
+    assert.deepEqual(disabled, ['coop', 'competitive', 'cutthroat'], 'the wrong game types are dealable here');
+    // Deal is never disabled here any more: the only types this screen can SELECT are the two it can
+    // deal, so a disabled button would be answering a question the radios no longer ask.
+    assert.ok(
+      readFileSync(join(dist, 'play.html'), 'utf8').includes('id="ng-multiplayer-note"'),
+      'nothing on the dialog says where a multiplayer game comes from',
+    );
   });
 
-  it('picking Co-op forces PvP off — no valid target for those cards when everyone is on one side', async () => {
-    const { els } = await load('?seed=430');
+  it('clicking a game type resets every rule below to it, and leaves the parameters alone', async () => {
+    const { els, groups } = await load('?seed=430&transit=4');
     (els.get('newgame')!['onclick'] as () => void)();
+    els.get('ng-days')!['value'] = '8';
+    (els.get('ng-days')!['oninput'] as () => void)();
+    // 3 × 1 player × 8 days: the floor follows the length, and changing the length is not a rule
+    // change, so this is still Solitaire rather than Custom.
+    assert.equal(readForm(els, groups).minrev, '24', 'the Revenue floor did not follow the Day count');
 
-    const dlg = els.get('newgamedlg')!;
-    const modeRadios = dlg['modeRadios'] as { value: string; checked: boolean; onchange: (() => void) | null }[];
-    const coop = modeRadios.find((r) => r.value === 'coop')!;
-    for (const r of modeRadios) r.checked = r === coop;
-    coop.onchange!();
+    const solitaire = groups['ng-type']!.find((r) => r.value === 'solitaire')!;
+    for (const r of groups['ng-type']!) r.checked = r === solitaire;
+    (solitaire as { onchange: (() => void) | null }).onchange!();
 
-    assert.equal(els.get('ng-pvp')!['checked'], false, 'Co-op defaulted PvP on');
-    assert.equal(els.get('ng-pvp')!['disabled'], true, "Co-op's PvP checkbox was left editable");
-    assert.equal(els.get('ng-deal')!['disabled'], true, 'Deal was enabled for a mode with nowhere to go yet');
+    const form = readForm(els, groups);
+    assert.equal(form.transit, '0', 'clicking the type did not reset the rule that had been changed');
+    assert.equal(form.days, '8', 'clicking the type wiped the Day count, which is a parameter');
+    assert.equal(form.type, 'solitaire');
   });
 
-  it('puts the seed and all three settings into the URL when it deals', async () => {
-    const { els, nav } = await load('?seed=430');
+  it('puts the seed and every setting into the URL when it deals', async () => {
+    const { els, groups, nav: n } = await load('?seed=430');
     (els.get('newgame')!['onclick'] as () => void)();
 
     const dlg = els.get('newgamedlg')!;
     els.get('ng-seed')!['value'] = '99';
-    for (const r of dlg['radios'] as { value: string; checked: boolean }[]) r.checked = r.value === 'threeTrackThreeOther';
+    for (const r of groups['ng-hand']!) r.checked = r.value === 'threeTrackThreeOther';
     els.get('ng-passenger')!['value'] = '5';
     els.get('ng-freight')!['value'] = '0';
     els.get('ng-transit')!['value'] = '2';
+    els.get('ng-toolbox')!['checked'] = true;
     dlg['returnValue'] = 'deal';
     (dlg['close'] as () => void)();
 
     assert.equal(
-      nav.search,
-      '?seed=99&hand=threeTrackThreeOther&extra=anyOffice&passenger=5&freight=0&transit=2&days=5&minrev=15&colday=3&coltotal=5',
+      n.search,
+      '?seed=99&hand=threeTrackThreeOther&extra=anyOffice&passenger=5&freight=0&transit=2' +
+        '&days=5&minrev=15&colday=3&coltotal=5&tool=1',
     );
   });
 
+  it('a switched-off victory condition deals as 0, which is what the engine calls off', async () => {
+    const { els, nav: n } = await load('?seed=430');
+    (els.get('newgame')!['onclick'] as () => void)();
+    const dlg = els.get('newgamedlg')!;
+    els.get('ng-coltotal-on')!['checked'] = false;
+    (els.get('ng-coltotal-on')!['onchange'] as () => void)();
+    dlg['returnValue'] = 'deal';
+    (dlg['close'] as () => void)();
+    assert.match(n.search, /coltotal=0/, 'unticking the total-collision condition did not switch it off');
+  });
+
   it('deals nothing on cancel, and nothing on Esc', async () => {
     // Esc closes a <dialog> with an empty returnValue and fires no submit at all, so "not deal" has
     // to be the test rather than "cancel" — the two arrive identically.
     for (const returnValue of ['cancel', '']) {
-      const { els, nav } = await load('?seed=430');
+      const { els, nav: n } = await load('?seed=430');
       (els.get('newgame')!['onclick'] as () => void)();
       const dlg = els.get('newgamedlg')!;
       dlg['returnValue'] = returnValue;
       (dlg['close'] as () => void)();
-      assert.equal(nav.search, '?seed=430', `closing with "${returnValue}" navigated`);
-      assert.equal(nav.reloads, 0, `closing with "${returnValue}" reloaded`);
+      assert.equal(n.search, '?seed=430', `closing with "${returnValue}" navigated`);
+      assert.equal(n.reloads, 0, `closing with "${returnValue}" reloaded`);
     }
   });
 
   it('reloads when the answers are the URL the page already has, so a re-deal is not a no-op', async () => {
     // Dealing a random seed, disliking it and dealing again at the same settings produces the same
-    // search string — and assigning `location.search` the value it already holds does nothing. Spells
-    // out the victory dials explicitly (rather than leaving them to default) so the URL Deal produces
-    // is byte-identical to the one the page loaded with.
-    const url = '?hand=threeRandom&extra=anyOffice&passenger=1&freight=1&transit=0&days=5&minrev=15&colday=3&coltotal=5';
-    const { els, nav } = await load(url);
+    // search string — and assigning `location.search` the value it already holds does nothing.
+    const url =
+      '?hand=sixRandom&extra=anyOffice&passenger=1&freight=1&transit=0&days=5&minrev=15&colday=3&coltotal=5';
+    const { els, nav: n } = await load(url);
     (els.get('newgame')!['onclick'] as () => void)();
     const dlg = els.get('newgamedlg')!;
     dlg['returnValue'] = 'deal';
     (dlg['close'] as () => void)();
 
-    assert.equal(nav.search, url, 'the URL should be unchanged — that is the whole case');
-    assert.equal(nav.reloads, 1, 'a re-deal at the same settings did nothing at all');
+    assert.equal(n.search, url, 'the URL should be unchanged — that is the whole case');
+    assert.equal(n.reloads, 1, 'a re-deal at the same settings did nothing at all');
   });
 
   it('deals the game the URL describes, and says so in the header', async () => {
@@ -3379,10 +3819,23 @@ describe('the New Game dialog', () => {
     assert.match(String(els.get('houserules')!['title']), /six random cards/i);
   });
 
+  it('names the game type in the header, so a Cutthroat game does not look like a Co-op one', async () => {
+    const { els } = await load('?seed=430');
+    assert.equal(els.get('gametype')!['textContent'], 'Solitaire');
+    assert.match(String(els.get('gametype')!['title']), /Days: 5/, 'the tooltip does not carry the victory conditions');
+  });
+
+  it('deals six cards by default now, matching what the lobby calls Solitaire', async () => {
+    // Jesse, 2026-08-23: every game type opens with six. `SOLO_CONFIG` — the ENGINE's fallback, which
+    // every sim measurement is taken against — deliberately did not move; this is the page's deal.
+    const { els } = await load('');
+    assert.match(String(els.get('houserules')!['textContent']), /6 cards/);
+  });
+
   it('ignores a seed the browser cannot parse rather than refusing to deal', async () => {
     // Blank and unparseable both plainly mean "surprise me"; an error dialog over a typo in an
     // optional box is not worth writing.
-    const { els, nav } = await load('?seed=430');
+    const { els, nav: n } = await load('?seed=430');
     (els.get('newgame')!['onclick'] as () => void)();
     const dlg = els.get('newgamedlg')!;
     els.get('ng-seed')!['value'] = 'not a number';
@@ -3390,8 +3843,8 @@ describe('the New Game dialog', () => {
     (dlg['close'] as () => void)();
 
     assert.equal(
-      nav.search,
-      '?hand=threeRandom&extra=anyOffice&passenger=1&freight=1&transit=0&days=5&minrev=15&colday=3&coltotal=5',
+      n.search,
+      '?hand=sixRandom&extra=anyOffice&passenger=1&freight=1&transit=0&days=5&minrev=15&colday=3&coltotal=5',
       'a bad seed was carried into the URL',
     );
   });