v0.7.1 — a caboose is not a load, a Day that says it ended, and a train you may throw away

Four issues off the Gitea tracker, all of them things a player saw at the board. Reasoning for
every item, and what was verified how: CHANGELOG.md.

- Gitea#8: X22 Pee-Dee refused every caboose, including the one it was made up with, so setting it
  out stranded the train. All six cabooses are minted loaded because §2.2's "coloured is loaded,
  white is empty" doubles as a piece count in the supply table; one read of the flag took that
  literally. A caboose carries the crew, not freight, so it is never a load.
- Gitea#10: a Day turns over inside the phases that run themselves, so it passes between one click
  and the next — and both transient signals fade before a player reading the board notices. A modal
  stops and waits, carrying the standings, the Days left and the combined target. Suppressed on the
  first frame, on Undo stepping back across a rollover, and on the Day the game ends.
- Gitea#9, which SUPERSEDES Gitea#6 from three days ago: a Timetabled train may be tossed face-up
  to a Department slot, where a rival may pick it up — the second half of the ruling needed no code,
  since that is where every discard already goes. An Extra still may not. A New Game setting on this
  line (discardTimetabled, on by default), the plain rule on the 0.4.9 line.
- Gitea#2 is not an engine bug: the rules are implemented exactly, and running the coach pool dry is
  Jesse's ruling to keep — "part of the strategy". What was wrong is that the game said nothing. A
  blocked platform now gives its reason, from the engine's own predicate, including how many coaches
  are stranded in Classification and what brings them back.

The same four ship as v0.4.9g on the playtest line.

Closes #2
Closes #8
Closes #9
Closes #10

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

.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,725 @@ page as `v0.1.0 · <sha> · <date>`, so what is deployed can always be identifie
 
 ---
 
+## 0.7.1 — 2026-08-25
+
+Four issues off the Gitea tracker, all of them things a player saw at the board. Two are engine or
+page bugs, one is a rules ruling that supersedes a ruling from three days earlier, and the fourth
+turned out not to be a bug at all — the fix there is that the game now says so. The same four ship
+as **0.4.9g** on the 0.4.9 line.
+
+### A caboose is not a load (Gitea#8)
+
+**REPORTED:** X22 Pee-Dee could not couple a caboose — including the one it was made up with. Drop
+it at the end of a sweep and it was stranded there, which makes a train whose whole card is a
+restriction ("may only pick up MTs") unplayable rather than merely restricted.
+
+`ROLLING_STOCK_SUPPLY` mints all six cabooses as `{ loaded: 6, empty: 0 }`, because §2.2's "a
+coloured car is loaded, a white car is empty" is doing double duty there as a PIECE COUNT and there
+is no white caboose to make a train up from. So `.loaded` carries two meanings, and the second one
+escaped in exactly one place: `pickUpEmptiesOnly`'s `fresh.some((c) => c.loaded)`. Every other read
+of the flag in `apply.ts` is already scoped to a coach or to a named car type.
+
+`carriesLoad` now answers the question the rule is actually asking — a caboose carries the crew, not
+freight, so it is never a load — and the restriction itself is untouched: a loaded car alongside the
+caboose still refuses. `trainRules` says so on the card ("A caboose is not a load"), because a player
+reading "EMPTIES ONLY" has no way to know which reading the game took.
+
+### The Day rolls over and says so (Gitea#10)
+
+**REPORTED:** "As the game rolls off the end of the day, you get a dialog saying such. Hard to keep
+track of time."
+
+Nothing on screen was wrong. The clock, the turn chart and the timetable all said which Day it was.
+What is wrong is WHEN it changes: a Day turns over inside the phases that run themselves, so it
+happens between one click and the next, while the player is watching the board and waiting for their
+turn. The two transient signals the page already had are both gone before that — the phase banner at
+2.6s, the announcement flash at 4.2s. A modal is the whole request: it stops, and it waits.
+
+`dayEndHtml` writes it from the frame AFTER the rollover, so the Day that ended is `f.day - 1`.
+It carries the standings in **Revenue order** rather than seat order (the question at the end of a
+Day is who is ahead), the Days left to run, and the combined target — reported against the whole
+table's Revenue, because `minCombinedRevenue` is a combined floor and one player's score against a
+four-player target reads as hopeless when the table is comfortably ahead. Collisions appear only
+where §3.4 actually scores them: competitive and co-op, and only when a dial is non-zero. A solitaire
+game carries the default dials and enforces neither, so printing a collision budget there would put a
+rule on screen that this game does not have.
+
+Three suppressions, each of them a way it would otherwise lie:
+
+- **the first frame** — arriving in a game already on Day 3 is not Day 2 ending, and a page reloaded
+  mid-game would announce a rollover that happened before it was watching;
+- **the Day going DOWN** — that is Undo stepping back across the rollover, not a Day passing. Undo
+  also clears `lastDay`, so replaying forward through the same rollover does not announce it twice;
+- **the Day the game ends on** — the outcome panel is the thing to read then. Verified by playing a
+  full solitaire game through: the dialog fires four times in a 5-Day game, not five.
+
+### A Timetabled train may be thrown away (Gitea#9)
+
+**REPORTED:** "Timetabled trains are at the choice of the player — they can either play or discard.
+If someone else wants to pick it up, they are more than able to. The reason: I don't want, if you
+decide to play a game longer than five days, to decide that maybe there are too many trains, the
+stations are jammed, and the railroad doesn't need any more. You can toss it. Someone else might
+disagree and pick it up."
+
+This **supersedes Gitea#6**, shipped three days earlier in 0.6.2, which made every train card
+unconditionally undiscardable. Two things narrow it:
+
+- an **Extra** is still never discardable. It never joins the timetable, so it can never be what
+  jams it, and the only rule it would dodge by being thrown away is the hand limit;
+- the Timetabled half is a **New Game setting** — `discardTimetabled`, on by default — because
+  Jesse's reasoning is explicitly about games run LONGER than five days, and a five-Day game may well
+  want Gitea#6's pressure back. Jesse asked for it as a setting on this line and as the plain rule on
+  the 0.4.9 line, which has no scaffolding for one; both play the same game at main's default.
+
+**The second half of the ruling needed no code at all.** "Someone else might pick it up" — a discard
+already goes face-up onto a Department pile, and a Department pile is exactly what a rival draws
+from. Only the first half was a change.
+
+**One place decides, and the card says which rule refused.** `keepReason` returns the sentence a
+player should read, or `null` if the card may go; `check`, the hand panel and the blocked "End Local
+Operations" button all ask it. It returns a SENTENCE rather than a boolean because there are now two
+distinct reasons — "an Extra is never discarded" and "not in this game" — and the panel that used to
+hard-code one of them would now tell half the players the wrong thing. It reaches the page as the
+Frame's `handKeepWhy`, replacing text `panels.ts` and `main.ts` each wrote for themselves.
+
+**Two places would have dropped the setting silently**, both found by looking rather than by `tsc` —
+`HouseRuleOverrides`' fields are all optional, so omitting one compiles and falls back to the
+default. The New Game dialog's close handler builds its own `houseRules` object (the comment
+directly above it warns of exactly this: "a setting missing from here is a setting the dialog
+silently discards"), and `presets.ts`'s Frame-to-config path, which is how a JOINER is shown someone
+else's game — a setting dropped there shows them a rule the table is not playing.
+
+**Gitea#6's corner survives, narrowed.** A hand of four undiscardable trains still has exactly one
+legal way on — play one — with nothing in the engine computing "you must play a train". With the
+setting on, the only hand that reaches it is four Extras; with it off, any four trains, as before.
+Both are pinned by tests.
+
+### Why nothing is moving on the platform (Gitea#2)
+
+**REPORTED:** "The Sparrow pulled into the station with two loaded coaches. There are two passengers
+on the platform. Four porters. My thought was to unload two and load two. I never get the chance to
+load the last two."
+
+**The engine is not deviating from the rules**, and this was checked step by step against the
+reported save. §9.2 discards the white coach into the Classification Yard on boarding and draws one
+from the Division Yard on de-training; §2.2 returns the Classification Yard only when the Division
+Yard is empty. All three are implemented exactly. What bites is the interaction: both halves of every
+passenger cycle consume coaches one-way, and a single global refill condition over a pile of six
+commodities means they do not come back. Traced over the reported game the coach pool goes 8+/8− on
+Day 1 to 0+/1− by Day 5, with eight coaches stranded in Classification behind ~60 other cars.
+
+**Jesse's ruling is that the shortage stays** — "it is possible to run out, that's part of the
+strategy" — so the three balance options written up in `TODO.md` are declined rather than deferred.
+
+What was unambiguously a bug is that the game said **nothing**. A Porter action that cannot be taken
+is simply absent from the menu, and `impediments()` — the panel whose entire job is "why is nothing
+moving?" — opened with `if (!f || f.kind !== 'freight') continue`, so a platform had never had
+anything to say for itself. The player was not merely blocked; he was given no reason.
+
+A Passenger Facility now reports both directions: passengers standing with no train to take them, a
+train whose card bars Porters from working it, a Terminals-only train at a lesser Office, every coach
+already full, the red slots full, the same-district rule, and the coach shortage itself — that last
+one naming how many coaches are sitting in Classification and the condition that brings them back,
+because a yard visibly full of cars that will not yield one coach is the state that looks like a
+broken game. The reason text comes from `passengerRefusal`, the engine's own predicate (exported for
+this), so what is on screen is the rule that actually refused rather than a second guess at it.
+
+**A second defect fell out of fixing it.** The row's name is read off `card.geometry.facility`, which
+a Passenger Facility does not have — it rides on the `office` card — so every passenger impediment
+would have read `facility 0,0` beside a freight row saying `mineTipple 1,-3`. It is named by the
+Office Area's tier now (`terminal 0,0`), and there is exactly one Office per Area, so that tier is
+the card's own.
+
+Verified by replaying the reported save (`playtests/station-master-seed947338225-day5(1).json`)
+through `fromSave` and printing the panel. Worth noting for anyone who tries it: that save is a
+v0.4.9-line recording and stops at intent 250 of 323 on the 0.7 engine, because Gitea#4, #6 and #7
+changed the rules its later intents were recorded against. That is expected divergence, not a
+save-format bug — a replay reproduces a game from decisions, and the decisions no longer mean the
+same thing.
+
+---
+
+## 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
+0.6.2 produced — this repairs the path that publishes it.
+
+### The host moved to FileBrowser Quantum
+
+Found trying to publish the 0.4.9f playtest build: every deploy died with
+`login failed: 404 404 page not found`. The File Browser instance has been upgraded to
+**FileBrowser Quantum**, a fork whose API differs from the v2.63 one `deploy-web.ts` was written
+against. Three things moved at once, each fatal on its own:
+
+1. **Auth is a session COOKIE**, not a JWT returned in the response body and sent back as `X-Auth:`.
+   A deploy that ignored the cookie would authenticate and then be rejected by every upload.
+2. **The password is a header** — `X-Password`, URL-encoded — not a JSON body field.
+3. **The path is a query parameter** (`?path=`), and every resource call must also name a
+   **`source`**: Quantum can serve several named stores and refuses any call that does not say which
+   ("no source provided"). The v2.63 API had no such concept at all.
+
+Rewritten against the running instance's own bundle rather than guessed — the same discipline the
+v2.63 version was written with, and worth repeating: the bundle at `/public/static/assets/index-*.js`
+is **gzip-compressed**, so it has to go through `gunzip` before it can be grepped. Each path was then
+confirmed against the live host by response code, which is the cheap way to tell a moved endpoint
+from a bad password without holding a password: **an endpoint that exists answers 401, one that does
+not answers 404.**
+
+The source is discovered from `GET /api/settings/sources` — one configured source is used silently,
+and several makes the script stop and list them rather than deploy the site into the wrong store.
+`FB_SOURCE` overrides it; `FB_OTP` carries a two-factor code.
+
+**Verified by deploying with it**, not by reading: 0.4.9f went up this way. This commit is the same
+file, byte-identical, brought across to the main line — both branches had carried the same broken
+script, so deploying 0.6.x would have failed in exactly the same way.
+
+### Housekeeping
+
+`dist-test/` removed — an untracked hand-made copy of a v0.6.2 `dist/` build, referenced by no
+script and no test. `build-web.ts` hardcodes `dist` and wipes it on every run, so nothing in the repo
+could have produced that directory or would ever read it. `.gitignore` is deliberately unchanged:
+the answer for a directory that should not exist is to delete it, not to hide it.
+
+---
+
+## 0.6.2 — 2026-08-22
+
+Three more from the v0.4.9e gameplay-testing round, now filed as Gitea issues: **#4** extras did not
+start where the player said, **#6** train cards could be discarded, **#7** four train cards had the
+wrong coach counts. Two further bugs were found underneath #4 and are fixed with it. **Gitea#2 is
+diagnosed but NOT fixed** — it needs a ruling, and the reasoning is in `TODO.md` under Play Balance.
+
+The same change ships as **0.4.9f** on the 0.4.9 line.
+
+### Gitea#4 — an Extra starts where the player puts it
+
+**REPORTED:** "When extras are played the player doing so may choose where the extra starts. They may
+choose either division point. And if the interchange mainline card has been played, they may start
+the extra on that card and choose the direction from there. If there is potential for conflict with
+other trains in that area the superintendent may hold the extra."
+
+Only one Division Point was ever offered, chosen by the train's number parity, plus any Control Point.
+Confirmed against a live game before touching anything: a pending X17 offered exactly one placement.
+
+**The number no longer decides an Extra's direction — the START does.** This supersedes a ruling
+recorded in `content.ts` ("the number decides, like everything else on the timetable") and the two
+cannot both hold: an odd, westbound Extra placed at the WEST end would leave the Division on its
+first move having crossed nothing, and be paid the completion Revenue for the run. A Division Point
+now runs the train away from itself; at an Interchange or a Control Point, where both ways are real
+runs, the player says which. Timetabled trains are unchanged. The Extra cards were always printed
+`direction: 'playerChoice'` and the engine had been overriding it; they now mean it.
+
+**The Interchange start is a YARD, not a spot on the running line.** This is what makes §7's last
+clause work. An Extra started there stands in the card's yard, off the road, and highballs onto the
+card itself at a later Mainline Phase. Three things follow, all of them Jesse's rule: placing it can
+never force a collision however busy the card is; a guaranteed collision holds it in the yard for
+another Stage and it tries again; a potential collision is the Superintendent's to rule on. Those last
+two are exactly `evaluateClearance`'s `blocked` and `ask`, so the Extra leaves the yard through the
+same §8.1 check a train leaves a Division Point through — **nothing new decides collisions.**
+
+**Where an Extra may start is now a setting** (`extraStart`), because the Division Points and the
+Interchange belong to nobody and a player's own district does not: `divisionPointsOnly` /
+`ownOffice` / `anyOffice`, in the New Game dialog, defaulting to `anyOffice` — what the engine did
+before the setting existed, so the 0.4.9 playtest line does not change under its testers mid-release.
+A Whistle Post never qualifies at any setting.
+
+`atSeat` on the intent is kept as a legacy field: absent `start`, it replays exactly as it always
+meant, so a save written before the choice existed is unaffected.
+
+### Found underneath #4: an Extra started away from a Division Point ran empty
+
+`isBeingMadeUp` tested the position alone — "standing at a Division Point" — which was the whole
+truth while that was the only place to build a train. **The Control Point start has therefore been
+shipping since it was added with a train that could never be given a consist**, and the Interchange
+start would have shipped the same way, against a report that says an Extra started there "would be
+Loaded with cars". A `beingMadeUp` flag now marks exactly those trays and is cleared the moment the
+train starts running, rather than a second positional rule — a train that ARRIVED at an Office must
+never be fillable from the Division Yard, which is the bug `isBeingMadeUp` was tightened to kill.
+
+**Found by playing it, not by the tests**, which had only ever asserted where the tray landed.
+
+### Found underneath #4: a collision left the wreck on the card
+
+`collide` deleted the trains from `s.trays` and left their `Transit` entries sitting on the Mainline
+card they died on. `evaluateClearance` counts every transit as an occupant, so **one rear-end
+collision permanently poisoned that card**: every later train was either held against a ghost or put
+to the Superintendent about one. The only other place a transit is removed is a train rolling off the
+far end, which a destroyed train never does. Found because the Interchange highball clears through
+that same occupant list.
+
+### The Mainline cards were rolled, not dealt
+
+`buildDivision` drew uniformly from the nine card TYPES **with replacement**, so a Division could be
+dealt two Interchanges or two Tunnels, and Plains — printed twice in the deck — carried the same
+weight as cards printed once. `docs/StationMaster-Mainline-Deck-v0.4.5.md` had flagged the mismatch
+as needing correction; "an Extra may start at the Interchange if one is on the board" is what forced
+it, since that only reads as a rule if the board holds at most one. Now dealt from `MAINLINE_DECK`
+without replacement, verified over 1600 deals across 1–4 players.
+
+**This re-deals every seed**, which retired the published replays (re-recorded) — and also, noticed
+only after the fact, the saved games in `docs/`. Jesse's Gitea#2 repro now replays 250 of 323 intents
+instead of reaching the reported position. Two saves there (`seed493290760-day2`, `seed58228926-day6`)
+were already dead at 2 intents before any of this, retired by some earlier change and never noticed,
+because the replay-fidelity test guards `public/replays` and nothing else.
+
+### Gitea#6 — a train card is never discarded
+
+**REPORTED:** "Players are not allowed to discard Train cards. They may keep the card in their hand
+for multiple stages and even multiple days, but they may not discard it. If a player has three train
+cards in their hand, and they draw a fourth, then they must play one of those cards." Extras count.
+
+The interesting property is that **the forced play needed no mechanism**. A train cannot be discarded,
+and `draw.end` already refuses while the hand is over the limit, so a player holding four trains has
+exactly one legal way to conclude the turn without anything ever computing "you must play a train".
+The corner cannot trap anyone: playing a train card is unconditionally legal — `card.play`'s train
+case refuses only a board placement, and a card played into a full timetable still leaves the hand.
+Confirmed in a running game: a hand of four trains offers zero discards, no `draw.end`, four plays.
+
+The bot needed no rule either. `legal.ts` filters candidates through `check`, so the option stopped
+being offered, and the developer bot already reaches for `card.play` before a discard. Over 400 games:
+400/400 finished, revenue unmoved, **trains scheduled 1.2 → 1.3** — the rule's intended effect.
+
+**The player is told, on the card and on the button.** `handDiscardable` on the Frame marks what may
+be shed; the hand panel says so in the train's own tooltip, and when every card held is a train the
+blocked end-turn button changes its text. That is the Gitea#2 lesson applied early: a rule the player
+cannot see is a board with nothing to click and no reason given.
+
+### Gitea#7 — coach counts on four train cards
+
+**1/2 Crack Limited 3 coaches → 2. 5/6 The Sparrow 2 → 3.** A change to the cards, not a
+transcription fix, so `Trains3.pdf` and the transcription in `implications.md` §5 keep the original
+numbers with a footnote; `content.ts` and `StationMaster-Home-Deck-v0.4.5.md` carry what the game
+plays. Both consists remain inside the four-car Crew Tray limit.
+
+A test had to follow: `multiplayer.test.ts` used Train 1 *because* it had three cars, to exercise a
+placement round that wraps at two players. It now uses Train 5, which has the three coaches.
+
+### The `content.ts` comment pass
+
+Asked for after #7 raised "where do we actually keep track of train cards?" — the answer being five
+documents of three vintages. **No data changed; only comments.** Four were factually wrong:
+
+- `// Offices — Depot 4, Station 2, Terminal 1` — the real copies are 8/4/2, doubled by Q12 long ago.
+- A doc pointed at **`DEALT_DECK_SIZE`, which has never existed**; the symbol is `SOLITAIRE_DECK_SIZE`,
+  defined eight lines below the comment that could not name it.
+- "the ten Mainline card types" — there are nine kinds; ten only holds if both Division Points count
+  as one.
+- "the developer bot averages 7.0 Revenue against a target of 20", in the present tense. 7.0 was
+  measured while `trainPerTransit` still defaulted to 1, and the next paragraph explains that setting
+  was defaulted to 0 for being worth ~5.4 of it. Re-measured over 400 games at current defaults: about
+  **zero**. Replaced with an instruction to run the harness rather than trust a number in a comment.
+
+**And every Enhancement row cited its implementation as `file.ts:NNN`, and every citation had
+rotted** — `apply.ts:405` for Small Yard was pointing ~440 lines short, stale long before this
+release. All eight now name functions, which do not move, with a note never to cite a line number
+there. Swept `src/`: no others remain.
+
+**Card counts came out of the comments**, Jesse's call — they move with play balance, so a comment
+that prints one is stale at the next retune. Kept: figures attributed to the recovered source sheet
+(a fixed document, and the audit trail for the transcription) and dated experimental findings.
+
+### Documentation queued, not built
+
+`TODO.md` gains an item for a card reference **generated from `content.ts`** so it cannot disagree
+with the game, in six sections — Mainline, then Home Deck Trains / Track / Industry / Modifiers /
+PVP. Each card wants its name, effect, placement, and the part only the implementation knows: whether
+its printed effect resolves yet. Deliberately no card counts. `enhancementText()` and
+`mainlineDescription()` are the model.
+
+### Not in this release
+
+**Gitea#2** — the Sparrow arrives with two loaded coaches, two passengers wait, four porters stand
+idle, and only one action can be taken. Reproduced and diagnosed: the engine is faithful to §9.2 and
+§2.2 at every step, but both directions of porter work move coaches one-way into a Classification
+Yard that returns only when the Division Yard is bare of all ~60 cars. Three ways out are written up
+in `TODO.md`; the choice is Jesse's. The unambiguous half — `impediments()` skips passenger
+facilities entirely, so a blocked platform gives the player no reason at all — is also still open.
+
+---
+
+## 0.6.1 — 2026-08-22
+
+Six bugs came back from a gameplay-testing session on 0.4.9d. Five are fixed here; the sixth could not
+be reproduced and is written up in `TODO.md` with the two questions that would pin it down. The same
+change ships as **0.4.9e** on the 0.4.9 line, cut from the v0.4.9d commit — the engine files the fixes
+touch are identical across the two lines, so the patch applied cleanly both ways.
+
+### Two trains at one platform answered to one button
+
+**REPORTED:** "Operating two trains in a station: the select button does not work. Regardless of which
+you pick, it is always one train, not the other."
+
+It did not work because there was nothing for it to do. `porter.board` and `porter.detrain` carried
+**no tray at all** — `{ type, at }` and nothing else — so there was one "board passengers at (0,0)"
+button however many trains were standing at the platform, and the reducer walked `adOccupancy` and
+filled the first empty coach it met. The roster chip the player clicked chose which crew the board
+DREW and nothing else. Two independent things were wrong at once:
+
+- `check` asked whether SOME train at the Office had an empty coach, skipping any whose card refuses
+  passenger work (`refusesPassengers`, `refusesThisOffice`). The reducer did not skip those. So with a
+  Military train and an ordinary one at the same platform, `check` said yes on behalf of the ordinary
+  one and the reducer boarded the Military.
+- The action list collapses identical labels, and "board passengers at (0,0)" describes both trains —
+  the same trap that once ate a turnout's second rotation and a Department discard.
+
+Both intents now carry an optional `trayId`, one function (`passengerWork`) resolves which train and
+which coach for `check`, `execute` and the reducer alike, `legal.ts` enumerates one candidate per
+train standing at the Office, and the label names it: *"board passengers at (0,0) onto Train 9"*.
+`trayId` is OPTIONAL for the reason `switch.move`'s `via` is — intents are the canonical record every
+save and undo replay against, and absent still means "the first eligible train".
+
+The events carry `trayId` and `coachIndex` rather than leaving the reducer to find them again, which
+is the lesson `unloadBegan`'s `carIndex` already taught: a reducer that re-derives the target is a
+second implementation of the rule, and it disagreed with the first.
+
+### A load could be made and broken without going anywhere
+
+**REPORTED, twice over:** "Freight House: boxcars loaded cannot be immediately unloaded. In the game
+we'll put the chip upside down in the tray to indicate." And: "Passenger stations: passengers just
+boarded cannot be immediately unloaded."
+
+They could. A Freight House permits both directions, so the boxcar its own Laborers had just loaded
+was standing on its own industry track, loaded, with an empty of that type in the Division Yard and a
+free red box — every gate said yes. Passengers were worse: `porter.board` filled a coach and
+`porter.detrain` looked for "a loaded coach on a train at the Office", which is the coach that had
+just been filled. Full Revenue at both ends of a movement that never happened, for one Porter action.
+
+**Jesse's rule, and it is wider than the report:** freight or passengers loaded anywhere in an Office
+Area may not be unloaded anywhere in that same Office Area — not at another facility, not in a later
+Stage. A train has to carry them to a different district. So a load carries a stamp naming the SEAT
+that made it (`RollingStock.origin`), and the stamp never expires; `laborer.beginUnload` and
+`porter.detrain` refuse a car stamped with the district they are standing in, with a rejection code of
+its own (`LOADED_IN_THIS_DISTRICT`) because "the car is loaded, the Laborer is free, the boxes are
+clear, and the only thing wrong is where it came from" deserves better than "wrong car".
+
+**A seat, not a player**, because Employee Rotation moves players between chairs and the district
+stays with the chair. **Undefined, not −1**, for "no origin": the Division Yard opens with loaded cars
+and loaded coaches out of the common supply, and those are exactly the inbound traffic a solitaire
+district lives on — a sentinel inside `SeatIndex`'s own range is not a sentinel. And `pooled` strips
+the stamp at every yard push, because the stamp belongs to the LOAD: a train can retire at a Division
+Point with freight still aboard, and that car must not carry a district it left three Days ago into
+whatever train is made up from it next.
+
+**Measured: −0.60 ± 0.10 Revenue a game** (t = −6.1) over 400 paired deals — 78 deals worse, 3 better,
+319 unchanged. That shape is the point. This is not a nerf spread across the game; it is a narrow
+piece of free Revenue coming off the board, and on four deals in five the bot never took it.
+
+The screen's version of the upside-down chip: a car or coach loaded by this district reads *"loaded
+boxcar (loaded here)"* on the card, in the tray and in the facility panel.
+
+### The Grocer's Warehouse shipped, and the Refinery received
+
+**REPORTED:** "Grocer's warehouse should be receive only, does not ship anything out." And:
+"Refinery: only ships out tanks, does not receive anything."
+
+Both were `flow: 'both'` in `content.ts`, put there deliberately and for a reason that has since
+collapsed. `card-reference.md` read: *"'Freight House' is not a card. It is the collective term for a
+freight facility that loads and unloads — the Grocer's Warehouse and the Oil Refinery."* If that were
+true, §9.3's "Passenger Facilities and Freight Houses permit cars to move each direction" named
+exactly those two, and they had to be two-way. But the engine has dealt a `freightHouse` card since
+before v0.4.9 — 6 copies, one slot each direction — so §9.3 names it, and the argument evaporates.
+
+The card set says the same thing without needing the rules text. All three Refinery modifiers —
+Pipelines, Oil Depot, Viscosity Breakers — grant **+1 outbound**; a two-way Refinery would be the only
+industry in the game with no card able to raise one of its two directions.
+`StationMaster-Home-Deck-v0.4.5.md` prints "Refinery · Outbound · 1 out / 0 in" and "Grocer's
+Warehouse · Inbound · 0 out / 1 in".
+
+So the Refinery ships and the Grocer's receives, and the **Freight House is the one two-way industry**
+— which also means the only same-district load-and-unload the district rule above has to refuse is a
+Freight House unloading its own work. The two fixes meet exactly where the report said they would.
+
+A consequence worth naming rather than discovering: an **Ice House beside a Grocer's Warehouse is now
+a dead card**, its +1 outbound dropped on a direction the host does not have. That is the design, not
+an oversight — the Home Deck sheet says so outright, and names the Truck Dock's inbound grant beside
+the outbound-only Packing Sheds as the other example. `suppressedGrants` already reports it on the
+page. It does mean the v0.4.7 note in `TODO.md` that opened these two facilities up was half wrong,
+and it is annotated there rather than deleted: the *machinery* it built (an industry's printed flow is
+absolute; drop the grant, never open the direction) is exactly what makes this correction land.
+
+### Not reproduced: cars left behind when backing up over them
+
+**REPORTED:** "When I back up to collect standing cars and, further down the tracks, the caboose, I
+get the caboose but the cars remain. I can later drive right through them."
+
+Not found, and not for want of looking. Cars on plain track on the way; cars spotted at an INDUSTRY on
+the way (Jesse's own guess at the shape); the train's own cut on the square it is pulling out of; a
+stale `standingWest`; an industry locked by MEN AT WORK. Every one couples the lot, and the last
+correctly blocks the whole route rather than letting the crew past. Three of them are now pinned in
+`apply.test.ts` so the case, when it is found, is somewhere none of them cover.
+
+The reason it is hard to make happen is structural: coupling is mandatory (§A.4) and `exploreMoves`
+accumulates what it meets card by card, so a route that reaches the caboose has already met everything
+between. `carsOn` is the single answer to "what is standing here", and the movement walk, the sweep in
+`carsCoupled` and every renderer all ask it — so cars a train can drive through would have to be cars
+that are on screen and not in `carsOn`, and there is no such place.
+
+There was one way to MAKE such a place, and it is closed: `flyingSwitch`'s reducer wrote the cut
+straight into `industryTrack`, which is not where `carsOn` looks on a Passenger Facility. `check`
+refuses a non-freight target so it never fired, but a trap that needs another rule to stay unsprung is
+still a trap; it goes through `carsOn` now.
+
+`TODO.md` carries the two questions that would settle it: was there a second route to the caboose, and
+what did the move button say it would couple. The label names every car, so "couples caboose" and
+"couples 2 boxcars, caboose" are different bugs — the first is route selection, the second the sweep.
+
+### Also
+
+- **An unload never checks the facility's commodity** — found reading `laborer.beginUnload` for the
+  district rule, not from play. It gates on `allows.inbound`, a loaded car, a matching empty in the
+  yard and room in the red box, but never on `facilityCarTypes`, which `freightAgent.stockOutbound`
+  does check. So a Freight House will unload a hopper. Left alone and logged: the district rule now
+  refuses the one same-Office pairing that made it easy to reach, and the fix is a rule question about
+  what an industry will accept, not a one-line guard.
+- **Both published replays that had gone dead were re-recorded** (`save-replay.ts 400 --top 3`). A save
+  is a save from a particular ruleset, so a rules change retires the files that no longer replay —
+  `harness.test.ts` catches it, which is what that test is for.
+
 ## 0.6.0 — 2026-08-21
 
 Three queued items, and the last of them is the one that matters most.

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,
+**Solitaire is playable in a browser and multiplayer runs against a server.** The solitaire game runs
-imports nothing outside itself, and never touches `Math.random`, so a static host is all it needs.
+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
+The current version is in [`package.json`](package.json), and every page stamps it with the commit
-  rules were found and closed; three more came after, and are in `TODO.md`: where the Local's coach
+and build date, so what is deployed can always be identified from the page itself. This section
-  stands while its engine works (a §A.4 question), Poling — the one card in the deck with no defined
+deliberately no longer names one: it went stale for six releases.
-  behaviour — and whether a Heavy Grade's orientation is rolled or chosen at setup.
+
+- **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
+- **Code** — the engine, the bot, the balance harness, the replay viewer, the playable page, and the
-  game can be saved, shared, replayed and stepped back through.
+  server. 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
+- **Multiplayer — built and running.** `src/server/` serves a lobby (create, join, preview, leave,
-  separate, turn state is per player, and the page talks to a `Session` rather than to the engine, so
+  add a bot, start, and a stream), turn submission, per-session state and persistence, with its own
-  a remote one drops in without the page changing — but there is no server, no turn submission and no
+  tests under `test/server/`. Games survive a release rather than being destroyed by one. A player
-  per-player push), the 22 opponent-directed cards, and real audio.
+  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 —
+Balance is *not* where it should be, and this file no longer quotes a figure for it. It used to say
-of which ~5.4 was the "one Revenue per train that completes its run" rule, so the working freight and
+"the developer bot averages 7.0 Revenue against a target of 20", which stopped being true the moment
-passenger economy is still only ~2. That rule is now a **setting that defaults to off**, along with
+the transit rule it names was defaulted to off — that rule was worth ~5.4 of the 7.0, for traffic
-the passenger and freight rates and the opening hand, so the economy can be read on its own and the
+nobody had to work. Measured at the current defaults the bot means about **zero**.
-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
+The three rates — passenger per coach, freight per load, train per transit — are **settings fixed when
-deck.
+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
+│   └── web/            ← the playable site: splash, game, lobby, replay viewer
-└── test/
+└── 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
+- **A game is one of four TYPES, and a type is a set of defaults rather than a ruleset.** Co-op,
-  largest category — so a district is built from what you draw, and building it costs you the
+  Competitive, Cutthroat and Solitaire (`src/web/presets.ts`) each name an opening hand, an Extra
-  industry or train you drew instead. The opening hand is the exception, and it is now **chosen when
+  rule, three revenue rates and the victory conditions; picking one fills the form, and changing any
-  the game is dealt**: three random cards (the default, and the prototype rule), six random cards, or
+  of them selects **Custom**, which keeps the scoring of the type it came from. The type is *derived*
-  three track and three other from two separately shuffled piles. The last of those is the only one
+  from the numbers rather than stored, so a saved game carries no name that can disagree with what it
-  that guarantees you a district to build; deal six and you open over the limit of three, so the
+  actually is. Both screens that deal a game — the lobby and the New Game dialog — ask the same
-  first turn is spent choosing. See `TODO.md`.
+  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
@@ -121,6 +160,14 @@ is the thing this machinery exists to prevent.
   it was worth more than the entire freight and passenger economy put together, for traffic nobody
   has to work. A seed alone therefore no longer names a game — the settings ride in the URL beside
   it, and every save records the rules it was dealt under.
+- **A load may not be broken in the district that made it.** Freight or passengers loaded anywhere in
+  an Office Area cannot be unloaded anywhere in that same Office Area — not at another facility, not
+  in a later Stage. A train has to carry them to a different district first. The printed game turns
+  the chip upside down in the tray; here the load carries the seat that made it (`RollingStock.origin`
+  in `src/engine/state.ts`) and it never expires. Without it a Freight House could unload the boxcar
+  its own Laborers had just loaded and a platform could detrain the passengers it had just boarded,
+  each paying Revenue at both ends for a load that went nowhere: worth **0.60 ± 0.10 Revenue a game**
+  to the developer bot over 400 paired deals, on 78 of them.
 - **A turnout can be laid on top of a card already down.** It upgrades a straight at any rotation, or
   a curve whose arc matches its own diverging leg — both strict port supersets of what they replace,
   so an upgrade can never sever an existing join. Without it a district could only hang off track that

TODO.md

@@ -4,7 +4,9 @@ Things worth coming back to. Anything noted here should either get done or get a
 not to — the point is that nothing quietly evaporates.
 
 Grouped by what kind of work it is — Next, Replay/Save Games, Bot Performance, Play Balance,
-Multiplayer, Rules Questions, Other — and ordered within each by how much it is currently costing us.
+Multiplayer, Display, Rules Questions, Other — and ordered within each by how much it is currently
+costing us. **Display** was split out of Other on 2026-08-22, when a session at the board produced
+seven items about the screen rather than the rules; the "most recent action" entry moved with it.
 Reorganized 2026-08-20 from a flat list; nothing below changed, only where it lives. Two duplicate
 entries (Heavy Grade orientation, the Local's coach) were merged into one each, and the industry-table
 item that had been sitting in a "these are all done" section without actually being done was moved out
@@ -30,7 +32,154 @@ Queued 2026-08-21, from playing the StartOS build:
 6. ~~**Stop every release destroying every game in progress**~~ — done in v0.6.0, by replaying the
    save rather than comparing version strings.
 
-Nothing else queued at the moment.
+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** — 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):
+
+9. ~~**Two trains in one station answer to one button**~~ — done in v0.4.9e / the release below.
+10. ~~**A Freight House can unload the boxcar it just loaded; a platform can detrain the passengers
+    it just boarded**~~ — done in v0.4.9e / the release below.
+11. ~~**The Grocer's Warehouse ships and the Refinery receives**~~ — done in v0.4.9e / the release
+    below: both are one-way again.
+12. **NOT REPRODUCED: cars left behind when backing up over them** — see Rules Questions below. The
+    one report of the six that is still open, and it needs a board from whoever filed it.
+
+Queued 2026-08-22, from the v0.4.9e gameplay-testing report filed as Gitea issues.
+
+12a. ~~**Gitea#4 — confirm that extra trains start properly**~~ — done in the release below. Either
+    Division Point, the Interchange with a direction chosen there, a Control Point gated by a new
+    `extraStart` house rule, and the Superintendent's hold on the way out of the Interchange yard.
+    Reasoning in `docs/rules/implications.md` §7.
+
+12d. ~~**Gitea#7 — coach counts on four train cards**~~ — done in the release below. 1/2 Crack
+    Limited 3 coaches → 2, 5/6 The Sparrow 2 → 3. A change to the cards, so `Trains3.pdf` and the
+    transcription in `docs/rules/implications.md` §5 keep the original numbers with a footnote;
+    `src/engine/content.ts` and `docs/StationMaster-Home-Deck-v0.4.5.md` carry what the game plays.
+
+12c. ~~**Gitea#6 — players may not discard train cards**~~ — done in the release below. Timetabled
+    and Extra alike; the forced play falls out of the hand limit rather than needing a mechanism of
+    its own. Reasoning in `docs/rules/implications.md` §6.2.
+
+12b. ~~**Gitea#2 — four porters, two passengers on the platform, and only one may be worked**~~ —
+    RULED AND FIXED in the release below, though not the way the report implies. The engine is
+    faithful to the written rules at every step; what bites is that BOTH directions of porter work
+    move coaches one-way into a Classification Yard that comes back only when the Division Yard is
+    bare of all ~60 cars. Sixteen coaches in the game, and the reported save runs dry on Day 5 with
+    eight of them stranded in Classification. **Jesse's ruling: the shortage stays** — "it is
+    possible to run out, that's part of the strategy" — so the three balance options in Play Balance
+    below are declined, not deferred. What was actually wrong is that the game said NOTHING: a Porter
+    action that cannot be taken is simply absent from the menu, and the "why is nothing moving?"
+    panel covered freight facilities only. That half is fixed.
+
+12e. ~~**Gitea#8 — the per-diem train could not couple a caboose**~~ — done in the release below.
+    `ROLLING_STOCK_SUPPLY` mints all six cabooses `loaded: true` because §2.2's "coloured is loaded,
+    white is empty" doubles as a PIECE COUNT there and there is no white caboose. X22 Pee-Dee, whose
+    whole card is "may only pick up MTs", read that literally and refused every caboose including the
+    one it was made up with — set it out and the train was stranded, which made it unplayable rather
+    than merely restricted. A caboose carries the crew, not freight, so it is never a load.
+
+12g. ~~**Gitea#9 — a Timetabled train may be discarded**~~ — done in the release below, and it
+    SUPERSEDES Gitea#6 (item 12c above), shipped three days earlier. A Timetabled train may be tossed
+    face-up to a Department slot, where a rival may pick it up — which needed no machinery, since
+    that is where every discard already goes. An Extra still may not: it never joins the timetable,
+    so it can never be what jams it. On this line the Timetabled half is a New Game setting
+    (`discardTimetabled`, on by default), because Jesse's reasoning is about games run longer than
+    five Days; the 0.4.9 line takes the plain rule. Reasoning in `docs/rules/implications.md` §6.2.
+
+12f. ~~**Gitea#10 — a dialog when the Day rolls over**~~ — done in the release below. "Hard to keep
+    track of time." Nothing on screen was wrong — the clock, the turn chart and the timetable all
+    said which Day it was — but a Day turns over inside the phases that run themselves, so it passes
+    between one click and the next, and the two transient signals the page had (the phase banner at
+    2.6s, the announcement flash at 4.2s) are both gone before a player reading the board notices.
+    A modal stops and waits, and carries the standings, the Days left and the combined target.
+    Suppressed on the first frame, on Undo stepping back across a rollover, and on the Day the game
+    ends — the outcome panel is the thing to read then.
+
+13. **Show me the other players' moves, bots included** — raised by Jesse 2026-08-22 from playing a
+    multiplayer game. Reasoning in Multiplayer below.
+
+14. **INVESTIGATE: stamp the history with wall-clock time** — even if nothing displays it yet, so
+    "how long did that turn take" can be answered afterwards. Reasoning in Replay / Save Games below.
+    Half of it already exists server-side and is read by nothing.
+
+15. **INVESTIGATE: a "most recent action" line under the status block** — above the Division map,
+    saying what just happened in the same words the history uses. Reasoning in Display below;
+    overlaps item 13 and should be decided with it.
+
+15a. **Build documentation FROM the implementation, starting with a card reference** — raised by
+    Jesse 2026-08-22. Reasoning in Other below. The prompt for it was finding train card data spread
+    across five documents of three different vintages, one of them superseded.
+
+Queued 2026-08-22, from a session looking at the screen rather than the rules. All Display below.
+
+16. **Three explicit display options for the Office map** — always hidden, always on, auto-hide. All
+    three modes already exist; only the BUTTON is a cycle, and it cannot reach every one of them.
+17. **The same three options for the Division map**, which today cannot be hidden at all. Auto there
+    means something different and useful: hide it now, bring it back at the end of the phase.
+18. **Give every phase a visible beat.** The automatic phases are not too fast — they are never
+    drawn at all, because `pump` runs them all before the page renders once.
+19. **Turn the track art vertical on a Division card laid vertically** — a side lane currently reads
+    as stacked left-right segments rather than one continuous run.
+20. **Run the inter-row connector round the OUTSIDE**, draw it as rail rather than a plain line, and
+    give the corners an angled piece.
+21. **The Division Point captions overflow the map**, and the buffer stops point the wrong way once
+    the route wraps.
+22. **Fill the dead centre of the Division map with the common board** — timetable, yards, the
+    Department and Salvage decks. Then the map is what everyone shares and the right column is yours.
+23. **History: newest at the top?** Plus the timestamps question from item 14, which lands here.
+24. **Put the viewer's own district at the BOTTOM of the Division map** and wrap the table around
+    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.
+
+Queued 2026-08-25, from releasing 0.7.1 / 0.4.9g. **Both are blocked on the two commits being made
+and pushed** — they were still uncommitted when the session ended.
+
+30. **Close the Gitea issues by hand, each with a comment naming the commit that fixed it.** Raised
+    by Jesse 2026-08-25. `Closes #<n>` is in the main commit message and will auto-close #2, #8, #9
+    and #10 when it reaches the default branch, but auto-closing leaves the issue with no record of
+    WHICH commit or WHICH release answered it — and #9 supersedes #6, which nothing on #6 will ever
+    say. So each issue wants a comment of its own: the commit SHA on both lines, the version each
+    shipped in (0.7.1 and 0.4.9g), and for #2 and #9 the ruling that decided it, since neither was
+    fixed the way the report implies. #6 wants a comment too, pointing at #9. The token and the API
+    calls are in the workspace's `AGENTS.local.md`.
+
+31. **Bump the StartOS wrapper to 0.7.1.** `station-master-startos` is clean, on `master`, pinned to
+    `v0.7.0` and versioned `0.7.0:3`. Once v0.7.1 is tagged: move the submodule pin to the tag, set
+    `startos/versions/current.ts` to **`0.7.1:0`** (a new upstream tag resets the downstream digit —
+    `UPDATING.md`), and write release notes in all five locales. **No new version FILE and no
+    migration** — `current.ts`'s `migrations.up` is empty, so nothing is carried from 0.7.0, and a
+    0.7.0 save replays under 0.7.1 unchanged (its intents cannot contain a Timetabled discard,
+    because that was illegal when they were recorded). `instructions.md` and `README.md` both name
+    0.7.0 and both need the three user-visible changes: the Day-end dialog, the Timetabled discard
+    and its New Game checkbox, and the reasons a blocked platform now gives. Remember the branch
+    trap: the game pushes to `main`, the wrapper to `master`.
 
 ---
 
@@ -38,6 +187,46 @@ Nothing else queued at the moment.
 
 The replay viewer, the save format, and how a game gets shared.
 
+- [ ] **INVESTIGATE: stamp the history with wall-clock time.** Raised by Jesse 2026-08-22: "store a
+      date/time stamp with the history information. Even if it's not displayed immediately, someone
+      could tell afterwards, or later if we decide to display it — how long things took between
+      different turns and actions."
+
+      **Half of this is already built and nothing reads it.** `server/session.ts` closes a
+      `TurnTiming { player, phase, day, stage, startedAt, endedAt }` every time the acting player,
+      phase, Day or Stage changes, and `persistence.appendTiming` writes each one to the game's
+      timings file. So every multiplayer game on the box already has per-turn wall-clock on disk.
+      Nothing displays it, and nothing has ever read it back. **First job is to look at that file
+      from a real game** — the answer to "how long do turns take" may be sitting there already.
+
+      **Solitaire has none of it.** `game.log` is `{ text, tone }[]` and a save is
+      `{ seed, config, history }`. There is no clock anywhere on that path.
+
+      **The constraint, and it is deliberate rather than an oversight** (stated twice in
+      `server/session.ts`): wall-clock is kept OUT of `history` because a replay must reproduce a game
+      from decisions alone. Do not put a timestamp on an `Intent`. It would ride into every save,
+      change the save format, and make two recordings of the same game unequal for no gain — the
+      engine has no clock and must stay deterministic.
+
+      **And a timestamp on a log LINE does not survive.** `game.log` is rebuilt by `fromSave` on
+      undo, on restore and in the replay viewer, so a time recorded on a line is gone the first time
+      the player takes a move back. Whatever is built has to be a SIDECAR — times keyed by intent
+      index, written only on the live path — and every consumer has to handle its absence, because a
+      replayed or imported game legitimately has no clock at all. That absence is the honest answer,
+      not a hole to fill with `createdAt` (the same call `lastMoveAt` already makes, and for the same
+      reason).
+
+      **The open question is granularity**, and it is Jesse's to settle: per INTENT (every draw,
+      every Move — finest, biggest sidecar, and the only thing that answers "how long between
+      actions") or per TURN SPAN (what already exists, one row per player-phase, and enough for "how
+      long between turns"). Per span is free today; per intent is new work on both the solitaire and
+      the multiplayer paths.
+
+      **What it would feed if built:** the "Games in Progress" admin view (item 7 above, which already
+      shows `lastMoveAt`), a post-game "that Day took 40 minutes" summary, and any future pacing
+      question about whether a 12-Stage Day is too long at a real table — which is the sort of thing
+      only a table can tell us and only a clock can record.
+
 - [ ] **INVESTIGATE: how would a player publish a replay so other people can watch it?** Today
       "Save replay" downloads a JSON file to the player's own machine, and the only way it reaches
       the site is by sending it to Jesse to drop into `public/replays/` and redeploy. The question is
@@ -313,6 +502,49 @@ number until the rules stop moving.
       needs a stocked green box AND a spotted car AND a free Laborer to line up in the same Stage.
       Measure how many Stages have all three before changing any heuristic — the answer may be that
       the economy, not the bot, is what caps freight.
+- [ ] **Gitea#2 — passenger operations starve themselves of coaches, and the game says nothing.**
+      Reported from v0.4.9e play: the Sparrow pulls into the Terminal with two loaded coaches, two
+      passengers wait on the platform, four porters are unused, and only ONE of the four intended
+      actions can be taken. Reproduced from the save (`docs/station-master-seed947338225-day5(1).json`,
+      Day 5 Stage 11): the Division Yard holds **1 empty coach and 0 loaded**, while the
+      Classification Yard holds **4 loaded and 4 empty** that cannot come back.
+
+      **The engine is not deviating from the rules.** Checked step by step: §9.2 discards the white
+      coach into the Classification Yard on boarding, draws the white coach from the Division Yard on
+      de-training, and §2.2 returns the Classification Yard only when the Division Yard is empty. All
+      three are implemented exactly. The problem is the interaction — a single global refill
+      condition over a pile holding six commodities with very different demand, where coaches (16 of
+      ~60 cars) are consumed by both halves of every passenger cycle. Traced over the reported game
+      the coach pool goes 8+/8− to 0+/1− by Day 5.
+
+      **RULED — the shortage stays, and none of the three is being built.** Jesse: "it is possible
+      to run out, that's part of the strategy." For the record, the options were (a) refill when the
+      Division Yard is dry of the type-and-state being asked for rather than dry of everything; (b)
+      the same trigger but return only the cars of that type; (c) leave the rules alone and raise the
+      coach count in `ROLLING_STOCK_SUPPLY`. All three are declined. What shipped instead is the
+      EXPLANATION — the impediments panel now says the Division Yard has no white coach, how many are
+      stranded in Classification, and that Classification returns only when the Division Yard is
+      bare. Running dry is a position to play out of, not a broken game, once the screen says so.
+
+- [x] **A blocked PASSENGER facility produces no impediment at all — FIXED.** `impediments()`
+      (`src/sim/narrate.ts`) opened with `if (!f || f.kind !== 'freight') continue`, so the "why
+      nothing is moving" panel had never had anything to say about a platform. That was the second
+      half of Gitea#2 and the half that was unambiguously a bug: the player above was not merely
+      blocked, he was given no reason — the button simply was not there. A platform now reports
+      passengers with no train, a train the card bars Porters from working, full coaches, full red
+      slots, the same-district rule, and the coach shortage itself — the last naming how many coaches
+      are stranded in Classification and what brings them back. The reason comes from
+      `passengerRefusal`, the engine's own predicate, so the panel cannot drift from the rule that
+      actually refused. Fixing the label found a second defect: a Passenger Facility rides on the
+      `office` card, so every passenger row would have read `facility 0,0` next to `mineTipple 1,-3`;
+      it is named by its tier now.
+
+- [ ] **The log lowercases the first letter of every narration it attributes to a player**, so
+      `EXTRA X18 started…` renders as `Player Solitaire eXTRA X18 started…` (`src/web/game.ts`:1065,
+      `n.text.charAt(0).toLowerCase()`). Harmless-looking and it hits every line that opens with an
+      all-caps keyword — `TRAIN 1 MADE UP`, `COLLISION`, `EXTRA`. Found while playing the Interchange
+      start; predates it. Wants a rule that leaves an already-capitalised word alone.
+
 - [ ] **The rolling stock supply is a guess.** `ROLLING_STOCK_SUPPLY` (coach 8+8, boxcar 10+10,
       hopper 8+8, reefer 5+5, tank 6+6, caboose 6) is marked provisional in `content.ts` and was
       scaled alongside the Gap 12 industry increase. Now that the Classification Yard returns stock
@@ -374,6 +606,178 @@ number until the rules stop moving.
 
 Deferred while planning the server; decisions and reasoning are in `docs/architecture/multiplayer.md`.
 
+- [ ] **I CANNOT SEE WHAT THE OTHER PLAYERS DID — BOTS INCLUDED.** Raised by Jesse 2026-08-22 from
+      playing a multiplayer game on StartOS: "on my display I need to see other players' moves, even
+      if they are a bot."
+
+      **What the code already does**, checked rather than assumed: `game.log` is ONE shared log and
+      `linesSince(seat)` (`server/session.ts`) sends every seat everything in it, so a bot's turn is
+      not silently dropped — `driveBots` plays through `submit()`, which calls `record(game, events,
+      actor)`, and `record` prefixes any event carrying a `player` with "Player <name>". So the moves
+      *are* arriving, attributed, in the history panel. Whatever is wrong is not that they were never
+      sent, and that is worth knowing before anything is built.
+
+      **What is genuinely missing is the BOARD.** `snapshot(s, …, viewer)` builds `cells` from
+      `areaOf(s, viewer)` alone, so a Frame contains the viewer's own Office Area and nobody else's.
+      Another player can move a train the length of their district and the only trace on your screen
+      is a line of text. The Division map is the one shared picture, and it shows trains on the
+      Mainline, not switching inside a district.
+
+      **Not yet established: which of the two Jesse means.** "I need to see other players' moves" fits
+      both "the history panel is not telling me" (a legibility problem — the panel scrolls, a bot can
+      take a dozen actions between your turns, and nothing marks where your last turn ended) and "I
+      want to watch their railroad" (a Frame problem). Ask before building: the first is an afternoon,
+      the second is a new view.
+
+      **The constraint on the second**, and it is the one that must not be got wrong: a district's
+      BOARD is public — cards on the table, cars standing on them, trains — and a player's HAND,
+      Revenue detail and drawn cards are not. `test/redaction.test.ts` exists precisely to catch a
+      Frame that leaks the wrong half, and it works by serialising a seat's whole Frame and asserting
+      no other seat's secrets appear anywhere in it. Any "show me their district" feature has to
+      extend that test in the same commit, not after it.
+
+      **A cheap first move that is right either way:** mark the log where the viewer's own last turn
+      ended, so "what happened while I was waiting" is a readable block rather than a scroll. That
+      needs no new data on the Frame — `sentLines` already knows the boundary.
+
+- [ ] **A LOST SESSION TOKEN LOCKS A PLAYER OUT OF A RUNNING GAME PERMANENTLY.** Raised by Jesse
+      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.
+      The token lives only in that one browser, and nothing else will accept an identity claim.
+      `/api/lobby/join` resolves a code against `lobbies`, and a started game is removed from
+      `lobbies` at `Lobby.Start`, so typing the game code answers `no open lobby with that code` —
+      the same answer a typo gets.
+
+      **The server knows exactly who you are and cannot be told.** Each game's `sessions.json`
+      holds `{ token, gameId, player, displayName }` and survives restarts — read off the box:
+      `HOPPER-4607: player 0 = Jesse | token df9e04c7…`. Everything needed is on disk; there is no
+      door. `lobby-and-sessions.md` §1 says "presenting the token IS the rejoin", which was a fair
+      assumption when a game lasted an afternoon and is a much worse one now that a game survives
+      an update (v0.6.0) and can sit for weeks.
+
+      **A second, nearer limit: `REMOTE_KEY` is a single `localStorage` key**, so a browser
+      remembers exactly one multiplayer game. Join a second and the first token is overwritten and
+      gone, with the same lockout. D13 says one game at a time is expected but "deliberately not
+      enforced" — the client enforces it by forgetting.
+
+      Three ways out, and the third is the one that fits what is already built:
+
+      1. **Show the player their own rejoin link** — a URL carrying the token in the fragment, to
+         copy and keep. No new server state, and the fragment never reaches the server. It is still
+         a credential in a link, so it lands in history and in whatever they paste it into.
+      2. **Rejoin by game code + display name + join secret — do not do this.** Every player holds
+         the join secret, so any of them could claim another's seat by typing their name.
+      3. **An administrator action, "Get Rejoin Link"** — pick a game and a player, get a URL to
+         send them. Gated by the admin secret, so only whoever runs the box can issue one, and no
+         player can impersonate another. Fits the existing admin-action pattern exactly.
+
+      **(1) and (3) together**, most likely: the player keeps their own link, and the administrator
+      can reissue one when they did not. Keying remembered sessions by `gameId` — with a picker
+      when the browser holds more than one — fixes the single-key limit at the same time. Jesse has
+      not yet decided whether a token in a URL is acceptable; the alternative is a bare token
+      pasted into a field, which is uglier and stays out of history.
+
+- [ ] **The StartOS "Games in Progress" action is one long unreadable run-on per game.** Raised by
+      Jesse 2026-08-22 after using it against four games. Lives in the WRAPPER repo
+      (`station-master-startos`, `startos/actions/gamesInProgress.ts`), whose `AGENTS.md` says work
+      belongs in issues on that repo rather than a `TODO.md` — recorded here because this is where
+      the project's list actually is; move it if that policy is meant to bind.
+
+      **What he asked for**, taking the current output field by field: a separator between the
+      players and the Day/Stage line; the phase in parentheses rather than after an em dash
+      (`Day 1, Stage 1 (Local Ops)`); a separator before "Waiting on"; one after the waiting-on
+      player and seat, before the start time; and one between the start time and the last-move
+      time.
+
+      **Why they are all missing at once, most likely.** `describe()` joins its lines with `\n`,
+      so the intent was one field per line. Every separator Jesse is missing is exactly where a
+      newline is — which says the StartOS action-result view does not render newlines in a
+      `single`'s value, and collapses the lot into one line. Worth confirming in the UI before
+      designing around it, since the whole diagnosis rests on it.
+
+      **The structural fix, better than adding separators.** `ActionResultMember` can itself be a
+      `group` (`osBindings/ActionResultMember.d.ts` — "a new group of nested values, experienced by
+      the user as an accordion dropdown"), so groups nest. Each game can be a collapsible group
+      whose members are individual `single` rows — Players, Position, Waiting on, Started, Last
+      move — instead of one string. That gives every field its own labelled row, makes the
+      separator question disappear rather than answering it, and collapses cleanly when there are
+      many games. Do this rather than punctuating the run-on.
+
+      **Sorting, also asked for**, and worth having once a box holds more than a handful: by game
+      name, by start time, or by last-move time, ascending or descending. An action's input spec is
+      built at open time, so a `Value.select` for the field and another for the direction costs
+      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
@@ -772,10 +1176,457 @@ Deferred while planning the server; decisions and reasoning are in `docs/archite
 
 ---
 
+## Display
+
+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
+      Office deck"*, *"played right-hand turnout at (−3, 0)"*. His own note: "I'm not sure that's
+      what's going to make the most sense, but I think it's something that should be investigated."
+
+      **The text already exists and is already correct.** `describeIntent` and `narrate` produce
+      exactly those sentences, and `record()` attributes them with the player's name. Nothing new has
+      to be written to say what happened — this is placement, not content.
+
+      **The slot is real but crowded.** Between `#turnchart` and `<main>` in `play.html` there are
+      already three transient banners: `#phasenote` (a phase CHANGED, auto-hides), `#announce` (a
+      one-shot announcement — a train completing its run pays everyone), and `#presence` (someone is
+      disconnected). A permanent fourth line has to not compete with them, and the palette is already
+      spoken for: violet reports where you are, amber means clickable, green and red mean good and
+      bad (`turnchart.ts`). A "what just happened" line is none of those.
+
+      **Two placements, and they are different features.** Put it in the page and it is the play
+      screen's. Put it in `turnChartHtml` and it appears in **both replay viewers** too, which is
+      probably a feature — a replay stepping frame by frame has exactly this question — but it makes
+      the change three screens wide.
+
+      **The question behind it is the unit, and it is why this should be decided with item 13.** In
+      solitaire "most recent action" is right: you took it, you are looking straight at it. In
+      multiplayer the thing you actually missed is everything that happened while you were WAITING,
+      which is many actions and possibly a whole bot turn — and one line showing only the last of
+      them may be the least useful line on the page. Item 13's cheap first move (mark the log where
+      your own last turn ended) answers that better. They may both be right, and one may make the
+      other pointless; deciding them separately risks building both and needing neither.
+
+- [ ] **INVESTIGATE: three explicit display options for the Office map — always hidden, always on,
+      auto-hide.** Raised by Jesse 2026-08-22.
+
+      **All three modes already exist.** `districtMode` is `'auto' | 'open' | 'closed'`, persisted to
+      `localStorage` with the sound and zoom settings (`main.ts`). Nothing needs adding to the model.
+
+      **What is wrong is that the button is a CYCLE, and it cannot reach every state.** The handler is
+      `districtMode = districtMode === 'auto' ? (open ? 'closed' : 'open') : 'auto'` — so from `auto`
+      you land on whichever pin is the OPPOSITE of what auto is doing right now, which depends on the
+      phase, and every second press goes back to `auto`. You can never get from `open` to `closed`
+      without passing through `auto`, and which of the two you can reach at all changes as the game
+      moves between phases. That is why it does not feel like a setting.
+
+      **Likely three buttons or a three-way segmented control**, one per mode, showing which is
+      current — the label work is already done and is worth keeping: it says what pressing it DOES
+      ("always showing — click for auto-hide") rather than what the panel is currently doing, which
+      was a deliberate fix and should survive whatever replaces the cycle.
+
+- [ ] **INVESTIGATE: the same three options for the Division map, where `auto` means something
+      different.** Raised by Jesse 2026-08-22.
+
+      **Today it cannot be hidden at all.** `#division` is a plain `<div>` in an unnamed `<section>`
+      in `play.html` with no toggle and no fold rule — `#district` has `.folded` styling and a button,
+      the Division has neither.
+
+      **`auto` here is not the Office's `auto`, and that is the point.** The Office folds by PHASE
+      (`FOCUS_PHASES` — open during Local Operations and Cargo, folded otherwise). Jesse's Division
+      rule is "hide it NOW, and bring it back at the end of this phase": you fold the map away to get
+      room while switching or working cargo, and it returns of its own accord when you are done. So
+      it is a one-shot with an expiry, not a standing rule — the state has to remember WHICH phase it
+      was hidden during, and clear itself when `f.phaseKey` moves off that one. Different enough from
+      `districtMode` that sharing an implementation with it would probably be a mistake.
+
+      **Hidden and shown stay put** until pressed again, exactly as the Office's pins do.
+
+- [ ] **INVESTIGATE: give every phase a visible beat — perhaps one second.** Raised by Jesse
+      2026-08-22, watching a game play: New Train, Mainline and the shift change "look like they are
+      being skipped entirely". His suggestion: move to the phase, take a visible beat so the second
+      row shows it changed, then move on.
+
+      **They are not too fast. They are never drawn.** `pump()` (`advance.ts`) loops `advance()` until
+      something needs input, and `drain()` renders ONCE after the whole batch. So every automatic
+      phase between one click and the next resolves without the page ever painting it. A minimum dwell
+      time on its own therefore fixes nothing — the page has to step `advance()` one call at a time
+      and render between, which makes this an async pump with a queue rather than a `sleep`.
+
+      **`#phasenote` already exists for exactly this feeling** — it announces that the phase CHANGED,
+      because "the page can change out from under a player between one click and the next" — but with
+      only the final phase ever drawn it can only ever announce the last transition of the batch.
+      Stepping the pump is what would let it announce each one.
+
+      **This is where it meets item 15.** Jesse's own example: during the New Train beat the "most
+      recent action" line would read *"no new trains to build out"* — which is a sentence nothing
+      currently produces, because a phase that does nothing emits no event to narrate. Some of these
+      beats would need a line written for them, and deciding which is part of the same investigation.
+
+      **The obvious risk, worth stating before anyone builds it:** a second per phase is four seconds
+      of enforced waiting per Stage, forty-eight per Day, and a player who has seen it a hundred times
+      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."
+
+      **It does, and the cause is one line.** `divisionSvg` draws every cell's rail with
+      `rail(c.x + 6, c.y + 32, c.x + c.w - 6)` — horizontal, unconditionally, whatever side of the
+      table the cell was laid on. **`railV` already exists**, is already used for the connector
+      between stacked cells, and takes the same shape turned ninety degrees. So the cell needs to know
+      which lane it is in (`dir[i]` is `'top' | 'right' | 'bottom' | 'left'`, known at layout time and
+      currently not stored on the cell) and pick the one that matches.
+
+      Everything else inside a side cell — the name, the capacity line, the train chips — is laid out
+      horizontally too, so this is bigger than swapping one call: it is deciding whether a side cell is
+      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. **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
+      the first cell in the next. So the route leaves the top row's rightmost Limits downward out of
+      its underside, when it should leave from its right-hand side; and on the bottom row it enters
+      through the top edge when it should come in from the right. Jesse: "it should be on the outside
+      circumference of the display."
+
+      **What it is drawn WITH is wrong too.** That connector is a single `<path class="bs-turn">`
+      — one plain polyline — while every other join on the map is `rail()` or `railV()`, two rails
+      with cross ties. The connector between two stacked cells down a side already uses `railV`, which
+      is why the vertical run looks like track and the corners do not.
+
+      **And the corners want an angled piece**, Jesse's wish-list item: a 45° rail between the
+      horizontal and vertical runs rather than a right-angled elbow, matching how the district's own
+      track geometry works (everything leaving a card's north or south edge does so at 45°). That
+      would want a `railD` beside `rail` and `railV`.
+
+      All three are the same drawing pass and should be done together. Note the current elbow routes
+      through `(ay + by) / 2` — the middle of the board — which is the space the item below wants to
+      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. **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
+      the board and print clipped mid-word — and it works for a single row. It does not survive a
+      wrap: a Running Track cell is 78px wide and the caption is not, and `boardW`/`boardH` are
+      computed from CELL extents plus `PAD = 22`, never from the text. **The viewBox does not know the
+      captions exist**, so any caption wider than its cell plus the padding is outside it. This is the
+      same class of bug as the one the comment above the code says was already fixed once; the fix
+      solved the one-row case.
+
+      **The buffer stops.** Both are drawn on the HORIZONTAL ends of their cell — `first.x - 9` and
+      `last.x + last.w + 9` — regardless of which side of the table the cell was laid on. With one row
+      that is right: the line ends to the left and to the right. Wrapped, the East Division Point can
+      end up on the bottom row or down a side, and its stop still points right, into the board rather
+      than away from the route. Jesse's read is that it belongs at the top there. The correct rule is
+      probably "away from the neighbour it joins", which is derivable rather than a special case — and
+      it depends on the vertical-card question above, so do that one first.
+
+- [ ] **INVESTIGATE: fill the dead centre of the Division map with the common board.** Raised by
+      Jesse 2026-08-22: with three or four seats the map is a ring with a large empty middle, while
+      the timetable sits in a column on the far right.
+
+      **The proposal, in his words:** move the timetable into the middle; maybe the yards, "because
+      that is too applicable to everybody"; maybe the Department and Salvage decks as well, since
+      those apply to all players. "Then the Division map becomes the common board area. The
+      right-hand side — your move, your cards, your facilities, what's blocked — is your side of
+      things."
+
+      **That is a genuinely good division of the screen** and it names a principle the layout does not
+      currently have: SHARED in the middle, YOURS on the right. Worth writing down as the rule even if
+      the move itself is deferred, because it decides where anything new belongs.
+
+      **What makes it awkward.** The middle is only empty at three and four seats — at one seat there
+      is no middle at all, and at two the rows face each other across a gap the width of `SIDE_GAP`.
+      So whatever goes there needs somewhere else to live at low seat counts, which is close to
+      building both layouts. And the map is an SVG built by `divisionSvg` while the timetable, yards
+      and decks are HTML panels (`panels.ts`), so "put them in the middle" means either
+      foreign-objecting HTML into the SVG or positioning HTML over it — neither free, and the map is
+      embedded into the replay by `toString()`, which constrains what it may reach for.
+
+- [ ] **INVESTIGATE: seat the viewer at the bottom of the Division map and wrap the table around
+      them.** Raised by Jesse 2026-08-22: "consider that the player being displayed is always at the
+      bottom of the display, and the rest of the table is wrapped around. This would give something
+      of a feel of sitting at an actual table with my cards in front of me and the other players in
+      front of me as well." His own note: not a decision, something to think about.
+
+      **It needs no new data.** `divisionSvg` already takes `roster.viewer` — "the player this map is
+      being drawn for" — and `main.ts` already passes it. The layout is a fixed lane order,
+      `top → right → bottom → left`, filled in ROUTE order west to east; rotating means offsetting
+      which lane the first seat lands in so the viewer's own district comes out on `bottom`. That is
+      an index shift in one array, not a new layout engine.
+
+      **The strongest argument for it is already in the code.** The map marks your district with a
+      colour AND spells out "(you)", and the comment says why: "a colour alone cannot say which of
+      four railroads is the reader's, and that is the first thing anybody wants to know at a table
+      they just sat down at." A fixed position answers that structurally — you would know before
+      reading anything. The marker stays as reinforcement rather than being the only signal.
+
+      **What it costs is the other thing the map says.** The section is headed "The Division — west
+      to east" and the route is a LINE, not a loop: it starts at the West Division Point and ends at
+      the East one, with buffer stops at both and a deliberately open gap between them. Today that
+      line starts top-left, where a reader starts reading. Rotate it and west starts wherever your
+      seat put it — and the open gap, which is the thing that stops the ring being read as a loop,
+      moves with it. Sometimes it would land behind you, out of the eye's path, which is exactly
+      where the one feature that says "this is not a circle" should not be.
+
+      **So the question is which of the two the map is FOR**, and it may not have the same answer at
+      every seat count. At one seat there is nothing to rotate. At two it is a swap, and free. At
+      three, rotating changes which way the horseshoe opens. At four it moves the break in the
+      square. A rule like "rotate at three and four, leave one and two alone" is defensible but has
+      to be decided rather than fallen into.
+
+      **One caller has no viewer at all**: the site's replay viewer calls `divisionSvg(f.division)`
+      with no roster (`web/replays.ts`). A replay watches every seat and belongs to none, so it has
+      nothing to rotate around — the feature has to degrade cleanly to today's layout there, which is
+      an argument for building it as an optional rotation rather than as the layout.
+
+      **Same drawing pass as items 19, 20 and 22** — vertical track art, the corner connectors and
+      the dead centre. All four move cells around the ring or change what is drawn inside them, and
+      doing them one at a time means laying the map out four times.
+
+- [ ] **INVESTIGATE: history newest-at-the-top, and timestamps on it.** Raised by Jesse 2026-08-22.
+
+      **Timestamps** are item 14 above — the same question, and it should be answered once. Whether
+      the history DISPLAYS a time is downstream of whether one is recorded at all, and of the sidecar
+      constraint written up there.
+
+      **Order.** Today `main.ts` renders `session.lines().slice(-60)` oldest-first and then sets
+      `log.scrollTop = log.scrollHeight`, so the newest line is at the bottom and the panel scrolls
+      itself down to it. Reversing is nearly free — reverse the slice, drop the auto-scroll — and it
+      does what Jesse wants: a glance at the top is always the most recent thing.
+
+      **Two things that are not free.** The cap is `slice(-60)`, so "scroll back through the history"
+      reaches sixty lines and stops however it is ordered; a real scrollback means raising or removing
+      that cap and deciding what the panel does with a thousand lines. And the log carries PHASE
+      HEADINGS (`t-phase`) that read forwards — a heading introduces the lines under it — so reversing
+      the list puts each heading below the lines it announces. That has to be handled or the panel
+      reads as nonsense at exactly the boundaries it exists to mark.
+
+      **Worth deciding together with item 15**, which proposes pulling the single most recent line out
+      of this panel entirely. If that lands, the argument for reversing the panel is weaker.
+
+---
+
+## Rules Questions
+
+- [ ] **NOT REPRODUCED: "when I back up to collect standing cars and, further down the tracks, the
+      caboose, I get the caboose but the cars remain. I can later drive right through them."**
+      Reported against v0.4.9d by a playtester (not Jesse, who forwarded it and could not add detail;
+      his guess was that the cars were spotted at an industry).
+
+      **What was tried, all of which works.** Cars on plain track on the way to the caboose; cars
+      SPOTTED AT AN INDUSTRY on the way; the train's own cut standing on the square it is pulling out
+      of; a stale `standingWest` on the intermediate card; the industry locked by MEN AT WORK (which
+      correctly blocks the whole route rather than letting the crew past). Every one couples the lot.
+      The first three are pinned in `apply.test.ts` — "backing up over a cut to something beyond it
+      takes both" — so if the case is found later it is somewhere none of them cover.
+
+      **Why it is hard to make happen.** Coupling is mandatory (§A.4) and `exploreMoves` accumulates
+      what it meets card by card, so a route that reaches the caboose has already met everything
+      between. `carsOn` (`state.ts`) is the SINGLE answer to "what is standing here", and the movement
+      walk, the sweep in `carsCoupled` and every renderer all ask it — so cars a train can drive
+      through would have to be cars that are on screen and not in `carsOn`, and there is no such
+      place. (One route to one was closed anyway: `flyingSwitch`'s reducer wrote the cut straight into
+      `industryTrack`, which for a Passenger Facility is not where `carsOn` looks. `check` refuses a
+      non-freight target, so it never fired.)
+
+      **The two questions that would settle it**, for whoever has the board: was there a SECOND route
+      to the caboose — a parallel row, or a turnout — so the move could have gone round the cars? And
+      what did the move button say it would couple? The label names every car (`describeIntent`), so a
+      button that read "couples caboose" and one that read "couples 2 boxcars, caboose" are different
+      bugs: the first is route selection, the second is the sweep.
+
+- [ ] **An unload does not check the facility's commodity.** `laborer.beginUnload` gates on
+      `allows.inbound`, a loaded car, an empty of that type in the Division Yard and room in the red
+      box — but never on `facilityCarTypes(f)`, which `freightAgent.stockOutbound` does check. So a
+      Freight House (boxcars) will unload a hopper. Found reading the code for the v0.4.9e district
+      rule, not from play. Low impact today because the district rule now refuses the only same-Office
+      pairing that made it easy to hit, and because the bot spots matching cars — but it is a rule the
+      engine states in one direction and not the other.
+
+---
+
 ## Other
 
 Doesn't fit the above.
 
+- [ ] **THE 0.4.9 PLAYTEST LINE IS BEHIND ON A RULES RULING, and that was checked rather than
+      assumed.** Recorded 2026-08-23, when Jesse asked whether any of v0.7.0 needed porting to the
+      `playtest` branch. Almost none of it does — that line has no lobby and no server, and the
+      `undo()` config fix is inert there because its `GameConfig` carries no victory dials, so
+      `configWith` only ever varies the house rules the save already restores.
+
+      **But one v0.5.0 ruling is a CODE difference the testers do not have.** §A.4, the Local's
+      coach: `main`'s `apply.ts` reads `if (dropRules.coachStaysOnStationTrack && cut.some(coach) &&
+      !atOffice)`, and `playtest`'s is the same line **without `&& !atOffice`** — so on that build a
+      coach still may not be set out at the Office. The other two questions the 0.4.9 README calls
+      open are documentation-only there (Poling is already at 0 copies; Heavy Grade behaves
+      identically and even deals the Mainline deck without replacement, so the correction applies
+      word for word).
+
+      **Jesse's call, 2026-08-23: do not port it now.** A settled rules change is not a playtest bug
+      fix, and pushing one into the build people are mid-playtest on would invalidate the feedback
+      that build exists to collect. Recorded so the divergence is a decision rather than a surprise —
+      and so the 0.4.9 README is not "corrected" to match `main`'s wording, which would then describe
+      behaviour that build does not have.
+
+- [ ] **Documentation generated from the implementation, not written alongside it.** Raised by Jesse
+      2026-08-22, immediately after Gitea#7 changed the coach counts on four train cards and the
+      answer to "where do we keep track of that?" turned out to be **five places of three different
+      vintages**: `src/engine/content.ts` (the truth), `docs/StationMaster-Home-Deck-v0.4.5.md` (a
+      readable per-card table, a version-stamped snapshot), `docs/rules/implications.md` §5 (the
+      transcription of `Trains3.pdf`, deliberately frozen at what the design SAYS),
+      `docs/Trains3.pdf` (the artwork), and `docs/rules/card-reference.md` (an invented placeholder
+      catalogue, banner-marked SUPERSEDED, whose train table still looks authoritative if you land in
+      the middle of the file). Every hand-maintained one of those drifts the moment a card changes,
+      and this release proved it.
+
+      **The deliverable, at minimum: a reference document for every card that can be played**,
+      generated from `content.ts` so it cannot disagree with the game. Sections, in order:
+
+      1. **Mainline cards** — the Division's own deck, dealt at setup rather than held in hand.
+      2. **Home Deck Cards — Trains**
+      3. **Home Deck Cards — Track**
+      4. **Home Deck Cards — Industry**
+      5. **Home Deck Cards — Modifiers**
+      6. **Home Deck Cards — PVP**
+
+      Each card wants its name, what it does, where it may be placed, and — the part only the
+      implementation knows — **whether its printed effect actually resolves yet**. `content.ts`
+      already carries that last one for Enhancements (`EnhancementRule.effect`, live / dormantSolo /
+      unbuilt, each row citing the file that reads it); the same honesty is what makes a generated
+      reference worth more than a transcription. `enhancementText()` and `mainlineDescription()` are
+      the model: prose composed from the data, so a tooltip cannot drift from the rule it describes.
+
+      **Deliberately NOT including card counts per category.** Jesse's call in the same breath: the
+      counts move with play balance, so a document that prints them is stale on the next retune. The
+      same rule was applied to `content.ts`'s own comments on 2026-08-22 — see the pass recorded in
+      CHANGELOG for what came out and what was kept.
+
+      Not started. Worth deciding first whether this is a build step writing Markdown into `docs/`,
+      or a page on the site beside the replay viewer — the site can render it from the same view-model
+      the game uses, which argues for the second.
+
 - [ ] **Real audio, as committed assets.** Everything the game plays is synthesised from oscillators
       (`src/web/sound.ts`), which was the honest choice for a site that fetches nothing — but it is a
       placeholder, not the finished sound. Sound therefore defaults to OFF.
@@ -828,6 +1679,13 @@ Doesn't fit the above.
       made for the other three, not an assumption that the same correction applies, since raising or
       lowering Laborer counts is also a balance question, not only a docs one.
 
+      **v0.4.9e narrows it.** The Direction column for the Grocer's Warehouse and the Oil Refinery was
+      the wrong half of that v0.5.0 pass and has been put back to one-way each, from gameplay testing
+      and Jesse's confirmation. The *numbers* in those two rows are still the card reference's own
+      (1 Laborer, 3–4 track) and still unverified against the engine, so this entry stands as written
+      for all five industries — what changed is only that the two rows the v0.5.0 pass claimed to have
+      re-verified turn out to have been re-verified against a premise rather than against a card.
+
 ---
 
 ## Done, kept for the reasoning
@@ -1019,7 +1877,14 @@ Doesn't fit the above.
       tooltip briefly told players four working cards did nothing, which is worse than the bare label
       it replaced — `enhancements.test.ts` had passing tests for all four the whole time.
 - [x] **A modifier's grant can land on a direction its host cannot use, and nothing says so —
-      corrected in v0.4.7.** The earlier "no bug" verdict below was wrong. The reasoning had been that
+      corrected in v0.4.7, and the correction was itself half wrong.** *(v0.4.9e: the ORIGINAL verdict
+      was right about the Grocer's.* A Grocer's Warehouse **is** inbound-only — gameplay testing said
+      so and Jesse confirmed it — so the Ice House's outbound grant beside one is genuinely dead, the
+      way the Truck Dock's inbound grant beside the outbound-only Packing Sheds is. What survives from
+      v0.4.7 is the machinery and the decision behind it: an industry's printed flow is absolute, the
+      grant is dropped rather than the direction opened, and `suppressedGrants` says so on the page.
+      What does not survive is opening the two facilities up. Original v0.4.7 note follows.)*
+      The earlier "no bug" verdict below was wrong. The reasoning had been that
       a Grocer's Warehouse is inbound-only. It is not — the card reference says "Both" — so the grant
       was being dropped on a direction the facility should have had. Reported again in play as
       "grocer's warehouse didn't get extra outbound slot for truck dock". The suppression machinery
@@ -1108,6 +1973,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-Home-Deck-v0.4.5.md

@@ -98,11 +98,18 @@ Playing a timetabled train card rolls the seeded D12 and places its number in th
 
 The listed consist is a maximum, not a minimum: a train may depart with fewer cars, but must not exceed the listed categories, put a car behind a caboose, or leave with the engine buried among cars. A Crew Tray holds no more than four rolling-stock cars.
 
+> **Changed 2026-08-22 (Gitea#7), Jesse's call:** the coach counts on **1/2 Crack Limited** and
+> **5/6 The Sparrow** were swapped — the Limited drops from three coaches to two, the Sparrow rises
+> from two to three. This is a change to the CARDS, not a correction to this table: `Trains3.pdf` and
+> the transcription in [`rules/implications.md`](rules/implications.md) §5 still show the original
+> numbers, and are right about what the printed cards said. `src/engine/content.ts` and this table
+> carry what the game plays.
+
 | Train | Speed | Direction | Listed maximum consist | Implemented special rule |
 | --- | --- | --- | --- | --- |
-| 1/2 Crack Limited | Fast | 1 west / 2 east | 3 coaches | No switching; passenger work only at Terminals; expedited. |
+| 1/2 Crack Limited | Fast | 1 west / 2 east | **2 coaches** | No switching; passenger work only at Terminals; expedited. |
 | 3/4 Express | Fast | 3 west / 4 east | 2 freight | May exchange at most one freight car at each grid location during its switching turn; expedited. |
-| 5/6 The Sparrow | Fast | 5 west / 6 east | 2 coaches | No switching; expedited. |
+| 5/6 The Sparrow | Fast | 5 west / 6 east | **3 coaches** | No switching; expedited. |
 | 7/8 Local | Slow | 7 west / 8 east | 1 freight, 1 coach | Its coach may not be set out during switching. |
 | 9/10 Heavy Freight | Slow | 9 west / 10 east | 3 freight, 1 caboose | — |
 | 11/12 Drag Freight | Slow | 11 west / 12 east | 2 freight, 1 caboose | — |

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

@@ -38,16 +38,20 @@ 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. |
 | Trestle | 60 mph. |
 | Interchange | 60 mph. A train may be reordered there only through the card’s printed “sort cars” concept; the current engine does **not** provide a Mainline sorting action for it. |
 
-### PDF/code mismatch requiring correction
+### PDF/code mismatch — CORRECTED
 
-`src/engine/content.ts` defines nine `MAINLINE_PROFILES` types: one Plains entry plus the eight other terrain types above. `setup.ts` selects uniformly from that nine-type list. The second Plains card shown in `Mainline Cards.pdf` is therefore not represented as a duplicate card or as extra Plains weight in setup. If the PDF inventory is authoritative, the setup selection needs a second Plains entry (or an equivalent weighted selection).
+**Was:** `src/engine/content.ts` defines nine `MAINLINE_PROFILES` types: one Plains entry plus the eight other terrain types above. `setup.ts` selected uniformly from that nine-type list, **with replacement**. The second Plains card shown in `Mainline Cards.pdf` was therefore not represented as a duplicate card or as extra Plains weight in setup — and, worse than a weighting error, a Division could be dealt two Interchanges, two Tunnels or two Trestles, none of which the deck contains.
+
+**Now:** `MAINLINE_DECK` in `content.ts` is the inventory table above — ten drawable cards, Plains twice and the other eight once each — and `buildDivision` deals from it without replacement. The two Division Point cards are not in that deck: they are the fixed ends of the Division, laid by `buildDivision` itself rather than drawn.
+
+The Interchange is what forced the correction. §7 lets an Extra be started at the Interchange "if one is on the board" (see `docs/rules/implications.md`, §7), which only reads as a rule if the board can hold at most one.
 
 The executable state represents East and West Division Points as fixed end nodes, not as card records. They are functionally present at the ends of the Division, but are not represented as the two PDF cards in the deck/state model.
 
@@ -66,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.Create  { secret, config, displayName, players, seed }  →  { gameId, gameCode, token, player }
-Lobby.Join   { secret, gameCode, displayName }  →  { 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
+mode              : solitaire | competitive | coop
-victory       : firstToTarget | highestAfterDays
+days              : how long the game runs
-length        : short | standard | campaign
+minCombinedRevenue, maxCollisionsPerDay, maxCollisionsTotal   (0 = that condition is off)
-optionalRules : { reducedVisibility, sisterTrains, employeeRotation, emergencyToolbox }
+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/card-reference.md

@@ -42,14 +42,14 @@ Operational Rail wheel icon, an industry track of the stated length, Laborer ico
 | --- | --- | --- | ---: | ---: | ---: | ---: | ---: |
 | Mine Tipple | Hopper | Outbound only | 3 | 3 | — | 4 | 2 |
 | Produce Shed | Reefer | Outbound only | 2 | 2 | — | 3 | 2 |
-| Grocer's Warehouse | Boxcar | Both | 1 | 1 | 1 | 3 | 3 |
+| Grocer's Warehouse | Boxcar or reefer | Inbound only | 1 | — | 1 | 3 | 3 |
-| Oil Refinery | Tank car | Both | 1 | 1 | 1 | 4 | 3 |
+| Oil Refinery | Tank car | Outbound only | 1 | 1 | — | 4 | 3 |
-| Power Plant | Hopper | Inbound only | 3 | — | 3 | 4 | 2 |
+| Power Plant | Hopper or tank car | Inbound only | 3 | — | 3 | 4 | 2 |
 | Freight House | Boxcar | Both | 1 | 1 | 1 | — | 6 |
 
 Directions follow the commodity: coal originates at a Mine Tipple and is consumed at a Power Plant;
-produce ships out; a warehouse and a refinery do both. This gives §9 all three of its cases —
+produce ships out; a warehouse receives. This gives §9 all three of its cases — outbound-only,
-outbound-only, inbound-only, and both.
+inbound-only, and both — with the **Freight House the one card that does both**.
 
 **"Freight House" IS a card** (corrected v0.5.0) — a sixth industry, dealt 6 copies, one Laborer and
 one slot each direction. An earlier pass here read §9.3/Appendix A's "Passenger Facilities and
@@ -57,6 +57,15 @@ Freight Houses permit cars to move each direction" as meaning "Freight House" wa
 *collective term* for the Grocer's Warehouse and the Oil Refinery, never a card of its own — that
 reading was wrong; the engine deals it as a real sixth industry (`content.ts`'s `freightHouse`
 profile) and this table follows the engine.
+
+**The Grocer's Warehouse and the Oil Refinery are ONE-WAY** (corrected v0.4.9e). The Direction column
+read "Both" for both of them, and that was the *other half* of the same mistaken reading: if "Freight
+House" named those two, §9.3 had to be describing them, so they had to be two-way. Once the Freight
+House is its own card the argument evaporates, and playtesting settled it — "Grocer's Warehouse
+should be receive only, does not ship anything out"; "Refinery: only ships out tanks, does not
+receive anything" (Jesse). `StationMaster-Home-Deck-v0.4.5.md` prints both that way, and the modifier
+set agrees: all three Refinery modifiers (Pipelines, Oil Depot, Viscosity Breakers) grant **+1
+outbound**, which would be an odd card set for a facility that receives half the time.
 <!-- TODO v0.5.0: Mine Tipple, Produce Shed and Power Plant above (3/3/4, 2/2/3, 3/3/4) were NOT
      re-verified against the engine in this pass — only Grocer's Warehouse, Oil Refinery and Freight
      House were. `mineTipple` and `powerPlant` in `content.ts` are also base 1/1/1, same as the three
@@ -91,9 +100,10 @@ deliberately slower industries, unable to quite keep up with a dedicated player.
 That is why Laborer counts track Outbound capacity: Mine Tipple 3/3, Power Plant 3/3, Produce Shed
 2/2, Grocer's Warehouse 2/2. The numbers are derived from the action budget, not chosen freely.
 
-The Oil Refinery is the exception at 3 Laborers against 2+2 capacity, and deliberately so: it serves
+<!-- The paragraph that stood here explained the Oil Refinery's third Laborer as the price of serving
-two flows through one three-box pipeline, so its pipeline stays fuller than a one-way facility's and
+     two flows through one pipeline. It serves one flow (v0.4.9e), so the explanation is gone with the
-the third Laborer is earning its keep.
+     premise; whether the Laborer count is still right is part of the same unverified block flagged
+     above and in TODO.md. -->
 
 Even so, Laborers are rarely what limits a player — spotting the empty car and hauling the loaded one
 away both cost switching actions from the same budget. See §7.
@@ -269,12 +279,12 @@ with all boxes full:
 | Car | Facility demand | Supply | Headroom |
 | --- | ---: | ---: | --- |
 | Hopper | Mine Tipple 3×2 + Power Plant 3×2 = 12 | 12 | exactly met |
-| Tank | Oil Refinery (2+2)×2 = 8 | 8 | exactly met |
+| Tank | Oil Refinery 2×2 = 4 | 8 | 4 spare (was "exactly met" while the Refinery was two-way) |
-| Boxcar | Grocer's (2+2)×2 = 8 | 12 | 4 spare |
+| Boxcar | Grocer's 2×2 = 4 | 12 | 8 spare (same correction) |
 | Reefer | Produce Shed 2×2 = 4 | 8 | 4 spare |
 | Coach | Terminal 4+4, per Office | 16 | scales with Office count |
 
-Hoppers and tank cars are exactly met in the theoretical worst case, which cannot occur in practice —
+Hoppers are exactly met in the theoretical worst case, which cannot occur in practice —
 only 10 freight facility cards exist across a 52-card deck shared by all players, and the §2.2
 Classification Yard recycle returns stock to the Division Yard whenever it empties. Both are worth
 watching in playtesting.

docs/rules/glossary.md

@@ -25,7 +25,7 @@ Every defined term, alphabetized for lookup. The core comes from the Definitions
 | **Extra Train** | A one-and-done train; its card returns to the Salvage Yard on completion. Head-on card image, so the drawing player picks its direction. Numbered with an "X" prefix; the following number gives its seniority, and it yields to the Timetabled train of that number. | §2.3, §8 |
 | **Facility** | A business which loads/unloads cargo and freight. | §2.5 |
 | **Freight Facility** | Mine Tipples, Produce Sheds, Grocer's Warehouses, Oil Refineries, Power Plants, Freight Houses. Some allow only outbound, some only inbound, some both. Per-card values in §12.5. | §9, §12.5 |
-| **Freight House** | A sixth Freight Facility card (corrected v0.5.0 — an earlier pass here read it as a collective term for the Grocer's Warehouse and the Oil Refinery rather than a card of its own; it is dealt like any other industry). Permits both directions, the same as a Grocer's Warehouse or Oil Refinery. | §9.3, §12.5 |
+| **Freight House** | A sixth Freight Facility card (corrected v0.5.0 — an earlier pass here read it as a collective term for the Grocer's Warehouse and the Oil Refinery rather than a card of its own; it is dealt like any other industry). **The only industry that permits both directions** — the Grocer's Warehouse receives and the Oil Refinery ships, one way each (v0.4.9e). | §9.3, §12.5 |
 | **Highball** | When a train holding at an Office automatically departs. | §2.4 |
 | **Home Office** | The primary face-down deck cards are drawn from. 52 cards. | §2.6, §12.1 |
 | **Hopper** | Coal rolling stock (brown = loaded, white = empty). | §2.2 |

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`.
 
@@ -488,13 +510,19 @@ Hotel) are what grow them.
 
 | # | Name | Speed | Consist | Rule |
 | --- | --- | --- | --- | --- |
-| 1/2 | Crack Limited | Fast | 3 coaches | Stop at Terminals only. No switching. Expedite. |
+| 1/2 | Crack Limited | Fast | 3 coaches † | Stop at Terminals only. No switching. Expedite. |
 | 3/4 | Express | Fast | 2 freight | May drop or pick up one freight car at every location. Expedite. |
-| 5/6 | The Sparrow | Fast | 2 coaches | No switching. Expedite. |
+| 5/6 | The Sparrow | Fast | 2 coaches † | No switching. Expedite. |
 | 7/8 | Local | Slow | 1 freight + 1 coach | Coach must remain on station track if switching. |
 | 9/10 | Heavy Freight | Slow | 3 freight + caboose | |
 | 11/12 | Drag Freight | Slow | 2 freight + caboose | |
 
+† **The two coach counts have since been swapped by Jesse** (Gitea#7, 2026-08-22): the Crack Limited
+now carries **2** coaches and The Sparrow **3**. The table above is left as `Trains3.pdf` prints it,
+because that is what this section is for — what the design SAYS. What the game plays is
+`src/engine/content.ts`, with the per-card table in
+[`../StationMaster-Home-Deck-v0.4.5.md`](../StationMaster-Home-Deck-v0.4.5.md).
+
 ### Extras (X13–X22) — ten distinct trains, not four generic ones
 
 Appleseed Extra (MT freight only, may drop but not pick up), Fruit Growers Express (reefers only),
@@ -536,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 | |
@@ -544,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.
@@ -785,3 +817,153 @@ Crossing is counted in Stages (Q1), so both trains simply run their counters dow
 Until this is settled the clearance buttons describe only what the engine actually does — they say
 the train "closes up behind" rather than promising a −5 risk that cannot occur. Wording that invents
 a consequence is worse than wording that under-sells one.
+
+---
+
+## §7 — where an Extra starts, and which way it runs
+
+**Reported from playing v0.4.9e** (Gitea#4): "When extras are played the player doing so may choose
+where the extra starts. They may choose either division point. And if the interchange mainline card
+has been played, they may start the extra on that card and choose the direction from there. If there
+is potential for conflict with other trains in that area the superintendent may hold the extra."
+
+**This supersedes an earlier ruling**, and the supersession is the interesting part. §2.3 gives every
+train its direction from its number — odd runs west, even runs east — and an earlier pass extended
+that to Extras explicitly: *"the number decides, like everything else on the timetable."* That reading
+cannot survive "either Division Point". An odd Extra placed at the WEST end would run west, leave the
+Division on its first move having crossed nothing, and be paid the completion Revenue for the run.
+
+So for **Extras only**, the start decides the direction:
+
+| Start | Direction |
+| --- | --- |
+| Western Division Point | east |
+| Eastern Division Point | west |
+| Interchange | player's choice |
+| Control Point (any Office above a Whistle Post) | player's choice |
+
+A timetabled train is unchanged: its number still decides. The Extra cards were always printed
+`direction: 'playerChoice'` (§5) and the engine had been overriding it; they now mean it.
+
+### The Interchange start is a YARD, not a spot on the running line
+
+§7's last clause — "the superintendent may hold the extra" — is what settles how this is modelled.
+An Extra started at an Interchange stands in that card's **yard**, off the running line, and highballs
+onto the card itself at a later Mainline Phase. Three things follow, all of them Jesse's rule rather
+than an implementation convenience:
+
+1. **Placing it can never force a collision**, however busy the card is. It is not on the road yet.
+2. **A guaranteed collision holds it in the yard** for another Stage, and it tries again next Stage.
+3. **A potential collision is the Superintendent's to rule on.**
+
+Those last two are exactly §8.1's two answers — an absolute bar against a facing train, a judgment
+call against a following one — so the Extra leaves the yard through the same clearance check a train
+leaves a Division Point through. Nothing new decides collisions.
+
+The Interchange keeps its printed "sort cars in new order" concept, still unimplemented (§6). Being
+the card with a Yard Limit is what makes it the one Mainline card a train can be made up on.
+
+### Which starts are offered is a setting
+
+The Division Points and the Interchange sit on shared ground and belong to nobody; starting an Extra
+inside a player's own district does not. That is a table preference rather than a rule, so it is set
+when the game is dealt (`extraStart`): Division Points and Interchange only, plus the playing
+player's own Control Point, or plus any player's Control Point. A **Whistle Post never qualifies at
+any setting** — being a place an Extra can start is part of what upgrading buys (§11).
+
+### Two bugs found underneath it
+
+- **The Mainline cards were rolled, not dealt.** `buildDivision` drew uniformly from the nine card
+  TYPES **with replacement**, so a Division could be dealt two Interchanges or two Tunnels, and
+  Plains — printed twice in the deck — carried the same weight as cards printed once.
+  `docs/StationMaster-Mainline-Deck-v0.4.5.md` had already flagged the mismatch as needing
+  correction; "an Extra may start at the Interchange if one is on the board" is what forced it, since
+  that only reads as a rule if the board holds at most one. Now dealt from the printed ten-card deck
+  without replacement.
+- **An Extra started anywhere but a Division Point ran empty.** `isBeingMadeUp` asked only "is this
+  tray standing at a Division Point", which was the whole truth while that was the only place to
+  build a train — so the Control Point start had shipped since it was added with a train that could
+  never be given a consist, and the Interchange start would have shipped the same way. Found by
+  playing it, not by the tests, which had only ever asserted where the tray landed.
+
+---
+
+## §6.2 — which train cards may be discarded
+
+**SUPERSEDED ONCE. Read both rulings; the second narrows the first.**
+
+**Gitea#6, v0.4.9e playtest:** "Players are not allowed to discard Train cards. They may keep the
+card in their hand for multiple stages and even multiple days, but they may not discard it. If a
+player has three train cards in their hand, and they draw a fourth, then they must play one of those
+cards." Extras counted: an Extra is a train.
+
+**Gitea#9, 2026-08-24 — the ruling in force:** "Timetabled trains are at the choice of the player:
+they can either play or discard. If someone else wants to pick it up, they are more than able to.
+The reason: I don't want, if you decide to play a game longer than five days, to decide that maybe
+there are too many trains, the stations are jammed, and the railroad doesn't need any more. You can
+toss it. Someone else might disagree and pick it up."
+
+So the rule is now:
+
+- a **Timetabled** train may be discarded;
+- an **Extra** may not. It never joins the timetable, so it can never be what jams it, and the only
+  rule it would dodge by being thrown away is the hand limit;
+- **on `main` the Timetabled half is a New Game setting** (`discardTimetabled`, on by default),
+  because Jesse's reasoning is explicitly about LONG games and a five-Day game may well want
+  Gitea#6's pressure. The 0.4.9 playtest line has no scaffolding for a setting and takes the plain
+  rule. Both lines behave identically at their defaults.
+
+**"Someone else might disagree and pick it up" needed no machinery.** A discard already goes face-up
+onto a Department pile, and a Department pile is exactly what a rival draws from. The second half of
+the ruling was already built; only the first half was a change.
+
+§6.2 as transcribed says only "the player must reduce his hand to no more than three cards" with no
+exception for any card type, so both of these are rulings rather than gaps — the prototype rules do
+not address it either way.
+
+### It needs no forcing mechanism, and that is the point
+
+The interesting property of the rule is that the forced play falls out of two rules that already
+exist rather than needing a third:
+
+1. an undiscardable card is not among the ways to shed a card; and
+2. `draw.end` already refuses while the hand is over the limit (§6.2).
+
+A player holding four undiscardable trains therefore has exactly one legal way to conclude the turn —
+play one — without anything in the engine ever computing "you must play a train". The corner cannot
+lock a player in, because **playing a train card is unconditionally legal**: `card.play`'s train case
+refuses only a board placement, and a train card played when the timetable is full still leaves the
+hand (it simply schedules nothing). Confirmed by playing it: such a hand offers zero discards, no
+`draw.end`, and four plays.
+
+**Gitea#9 does not retire that corner, it narrows the way in.** With the setting on, the only hand
+that reaches it is four Extras; with the setting off it is any four trains, exactly as before.
+
+### One place decides, and the card says which rule refused
+
+`keepReason` (`src/engine/apply.ts`) returns the sentence a player should read, or `null` if the card
+may be discarded. `check`, the hand panel and the blocked "End Local Operations" button all ask it,
+so none of them can drift from the rule. It returns a SENTENCE rather than a boolean because there
+are now two distinct reasons — "an Extra is never discarded" and "not in this game" — and a panel
+that hard-codes one of them tells half the players the wrong thing. It reaches the page as the
+Frame's `handKeepWhy`.
+
+The bot needed no rule of its own either. `legal.ts` enumerates candidates and filters them through
+`check`, so the option stops being offered; and the developer bot already reaches for `card.play`
+before it reaches for a discard. Measured over 400 games: 400/400 finished, revenue unmoved, and
+**trains scheduled 1.2 → 1.3** — the rule's intended effect, small because a bot rarely held four.
+
+### Consequences
+
+- **Two of the three published replays discarded train cards** (2 and 15 of them) and were retired
+  and re-recorded. Jesse's call: "I'm okay with retiring the replays that no longer work under those
+  old rules."
+- **The opening six-card hand is not exempt.** Under *six random cards* a player opens holding six
+  against a limit of three; if four or more are trains, they all go onto the timetable on turn one.
+  Jesse's call: "If the opening hand has lots of trains, then lots of trains will be placed on the
+  board." Rare — roughly 1.5% of deals — but deliberate.
+- **The player is told, on the card and on the button.** `handDiscardable` on the Frame marks which
+  cards may be shed, the hand panel says so in the card's own tooltip, and when EVERY card held is a
+  train the blocked end-turn button changes its text to say a train must be played. That is the
+  Gitea#2 lesson applied: a rule the player cannot see is a board with nothing to click and no reason
+  given.

docs/rules/open-questions.md

@@ -670,10 +670,15 @@ balance work was possible.
 | --- | --- | --- | ---: | ---: | ---: | ---: |
 | Mine Tipple | Hopper | Outbound | 3 | 3 | — | 4 |
 | Produce Shed | Reefer | Outbound | 2 | 2 | — | 3 |
-| Grocer's Warehouse | Boxcar | Both | 2 | 2 | 2 | 3 |
+| Grocer's Warehouse | Boxcar | Inbound | 2 | — | 2 | 3 |
-| Oil Refinery | Tank | Both | 3 | 2 | 2 | 4 |
+| Oil Refinery | Tank | Outbound | 3 | 2 | — | 4 |
 | Power Plant | Hopper | Inbound | 3 | — | 3 | 4 |
 
+*Amended v0.4.9e.* The warehouse and the refinery were briefly "Both", on the reading that "Freight
+House" was a collective term for exactly those two and therefore what §9.3's "permit cars to move
+each direction" described. The Freight House turned out to be a card of its own (v0.5.0), and
+playtesting confirmed the one-way reading the sheet always printed.
+
 *Rationale.* Directions follow the commodity and give §9 all three of its stated cases. Bulk
 industries get more Laborers and a 4-car track so the types feel distinct when choosing what to
 build — but the counts stay moderate because Laborers are **not** the binding constraint (see 10e),

docs/rules/rules-v0.2.md

@@ -736,8 +736,8 @@ Modifier effects, and track geometries — is catalogued in
 | --- | --- | --- | ---: | ---: | ---: | ---: |
 | Mine Tipple | Hopper | Outbound | 3 | 3 | — | 4 |
 | Produce Shed | Reefer | Outbound | 2 | 2 | — | 3 |
-| Grocer's Warehouse | Boxcar | Both | 2 | 2 | 2 | 3 |
+| Grocer's Warehouse | Boxcar | Inbound | 2 | — | 2 | 3 |
-| Oil Refinery | Tank | Both | 3 | 2 | 2 | 4 |
+| Oil Refinery | Tank | Outbound | 3 | 2 | — | 4 |
 | Power Plant | Hopper | Inbound | 3 | — | 3 | 4 |
 
 | Office | Porters | Green slots | Red slots |
@@ -755,8 +755,10 @@ Modifier effects, and track geometries — is catalogued in
 | Section Gang | +1 Laborer or +1 Porter |
 
 **"Freight House"** (§9.3, Appendix A) is a Freight Facility card (corrected v0.5.0 — previously
-read as not a card, only a collective term for a facility that both loads and unloads). It permits
+read as not a card, only a collective term for a facility that both loads and unloads). It is the
-both directions, the same as the Grocer's Warehouse and the Oil Refinery.
+**only** industry that permits both directions: the Grocer's Warehouse receives and the Oil Refinery
+ships, one way each (corrected v0.4.9e from playtesting — the "Both" reading was the other half of
+the same mistake about what "Freight House" meant).
 
 ---
 

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.0",
+  "version": "0.7.1",
   "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.

scripts/deploy-web.ts

@@ -1,11 +1,29 @@
 /**
- * Build the solitaire site and push it to a File Browser instance.
+ * Build the solitaire site and push it to a FileBrowser instance.
  *
- * Written against File Browser v2.63's REST API, read from its own bundle rather than guessed:
+ * REWRITTEN FOR **FileBrowser Quantum** (2026-08-23). The host was upgraded from File Browser v2.63
+ * to the Quantum fork, whose API is different in three ways at once, and every deploy failed with
+ * `login failed: 404 404 page not found` — the old `/api/login` simply is not there any more.
  *
- *   POST /api/login                          {username, password, recaptcha} -> JWT as plain text
+ * Read from the running instance's own bundle rather than guessed, the same way the v2.63 version
- *   POST /api/resources/<dir>/               X-Auth: <jwt>                   -> create a directory
+ * was (`/public/static/assets/index-*.js`, gzipped — pipe it through `gunzip` before grepping), and
- *   POST /api/resources/<file>?override=true X-Auth: <jwt>, body = bytes     -> upload
+ * each path confirmed against the live host by the response code: an endpoint that exists answers a
+ * bad password with **401**, one that does not answers **404**.
+ *
+ *   POST /api/auth/login?username=<u>&recaptcha=
+ *        headers X-Password: <urlencoded>, X-Secret: <otp or empty>   -> sets a session COOKIE
+ *   GET  /api/settings/sources                                        -> the named sources
+ *   POST /api/resources?path=<p>&source=<s>&isDir=true                -> create a directory
+ *   POST /api/resources?path=<p>&source=<s>&override=true  body=bytes -> upload
+ *
+ * THREE THINGS MOVED, and each would break on its own:
+ *   1. AUTH IS A COOKIE, not an `X-Auth: <jwt>` header. Login returns no usable token in its body;
+ *      the session arrives in `Set-Cookie` and every later request has to carry it back.
+ *   2. THE PASSWORD IS A HEADER, `X-Password`, URL-encoded — not a JSON body field.
+ *   3. THE PATH IS A QUERY PARAMETER, `?path=`, not part of the URL, and every resource call also
+ *      needs a **`source`** naming which configured store to write to. Quantum throws "no source
+ *      provided" without it. `FB_SOURCE` names it; left unset, the sole configured source is used,
+ *      and if there is more than one this stops and lists them rather than guessing.
  *
  * File Browser is the STORE, not the server — Start9 Pages serves the uploaded folder as the site.
  * So the job here is simply to land the built files in the right folder, intact.
@@ -18,6 +36,8 @@
  * Optional:
  *   FB_URL       default https://phoenix.local:58157
  *   FB_DEST      default websites/stationmaster — the folder Start9 Pages serves from
+ *   FB_SOURCE    which configured source to write to; discovered automatically when there is one
+ *   FB_OTP       the one-time code, if the account has two-factor enabled
  *   FB_INSECURE  set to 1 for a self-signed certificate (usual for a .local StartOS host)
  *   SITE_URL     default https://65.78.82.12:54697/ — the public address Start9 Pages serves at
  *   --dry-run    list what would be sent, contact nothing
@@ -44,6 +64,8 @@ const URL_BASE = (process.env['FB_URL'] ?? 'https://phoenix.local:58157').replac
 const DEST = `/${(process.env['FB_DEST'] ?? 'websites/stationmaster').replace(/^\/+|\/+$/g, '')}`;
 const USER = process.env['FB_USER'] ?? '';
 const PASS = process.env['FB_PASS'] ?? '';
+const OTP = process.env['FB_OTP'] ?? '';
+const SOURCE_ENV = process.env['FB_SOURCE'] ?? '';
 const DRY = process.argv.includes('--dry-run');
 
 /**
@@ -75,37 +97,80 @@ const CONTENT_TYPES: Record<string, string> = {
   '.txt': 'text/plain',
 };
 
+/**
+ * Log in and return the session cookie every later request must carry.
+ *
+ * The password goes in a HEADER and URL-encoded, which is Quantum's own client does
+ * (`X-Password: encodeURIComponent(password)`). The body carries nothing useful on success — the
+ * session is in `Set-Cookie`, so a deploy that ignored the cookie would authenticate and then be
+ * rejected by every upload.
+ */
 async function login(): Promise<string> {
-  const res = await fetch(`${URL_BASE}/api/login`, {
+  const url = `${URL_BASE}/api/auth/login?username=${encodeURIComponent(USER)}&recaptcha=`;
+  const res = await fetch(url, {
     method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
+    headers: { 'X-Password': encodeURIComponent(PASS), 'X-Secret': OTP },
-    body: JSON.stringify({ username: USER, password: PASS, recaptcha: '' }),
   });
   const body = await res.text();
-  if (!res.ok) throw new Error(`login failed: ${res.status} ${body || res.statusText}`);
+  if (!res.ok) {
-  if (!body.trim()) throw new Error('login returned an empty token');
+    // 401 here is a wrong username/password; 404 would mean this build has moved the API again.
-  return body.trim();
+    throw new Error(`login failed: ${res.status} ${body || res.statusText}`);
-}
-
-async function makeDir(jwt: string, path: string): Promise<void> {
-  // Trailing slash is what marks a directory in this API. A 409 means it already exists, which is
-  // the normal case on every deploy after the first.
-  const res = await fetch(`${URL_BASE}/api/resources${encodePath(path)}/`, {
-    method: 'POST',
-    headers: { 'X-Auth': jwt },
-  });
-  if (!res.ok && res.status !== 409) {
-    throw new Error(`could not create ${path}: ${res.status} ${await res.text()}`);
   }
+  const cookies = res.headers.getSetCookie();
+  if (cookies.length === 0) throw new Error('login succeeded but set no session cookie');
+  return cookies.map((c) => c.split(';')[0]).join('; ');
 }
 
-async function upload(jwt: string, localPath: string, remotePath: string): Promise<void> {
+/**
+ * WHICH STORE TO WRITE TO. Quantum can serve several named sources and refuses any resource call
+ * that does not name one ("no source provided"), which is the parameter the v2.63 API had no
+ * concept of. One configured source is the normal case and is used without asking; more than one is
+ * ambiguous, and guessing would silently deploy the site into the wrong store.
+ */
+async function resolveSource(cookie: string): Promise<string> {
+  if (SOURCE_ENV) return SOURCE_ENV;
+  const res = await fetch(`${URL_BASE}/api/settings/sources`, { headers: { cookie } });
+  if (!res.ok) throw new Error(`could not list sources: ${res.status} ${await res.text()}`);
+  const names = Object.keys((await res.json()) ?? {});
+  if (names.length === 1) return names[0]!;
+  if (names.length === 0) throw new Error('the server reports no sources at all');
+  throw new Error(`several sources configured (${names.join(', ')}) — pick one with FB_SOURCE=<name>`);
+}
+
+function resourceUrl(source: string, path: string, extra: Record<string, string>): string {
+  const params = new URLSearchParams({ path, source, ...extra });
+  return `${URL_BASE}/api/resources?${params}`;
+}
+
+async function makeDir(cookie: string, source: string, path: string): Promise<void> {
+  const res = await fetch(resourceUrl(source, path, { isDir: 'true' }), {
+    method: 'POST',
+    headers: { cookie },
+  });
+  if (res.ok) return;
+  /**
+   * "Already there" is the normal case on every deploy after the first, and Quantum is not
+   * consistent about which code it reports it with. So the two failures worth stopping for are
+   * named — a rejected session, and a server that broke — and every other 4xx is treated as the
+   * directory already existing. A directory that genuinely is not there fails loudly at the upload
+   * a moment later, which is a better place to find out than a guess here.
+   */
+  const fatal = res.status === 401 || res.status === 403 || res.status >= 500;
+  if (fatal) throw new Error(`could not create ${path}: ${res.status} ${await res.text()}`);
+}
+
+async function upload(
+  cookie: string,
+  source: string,
+  localPath: string,
+  remotePath: string,
+): Promise<void> {
   const bytes = readFileSync(localPath);
   const ext = remotePath.slice(remotePath.lastIndexOf('.'));
-  const res = await fetch(`${URL_BASE}/api/resources${encodePath(remotePath)}?override=true`, {
+  const res = await fetch(resourceUrl(source, remotePath, { override: 'true' }), {
     method: 'POST',
     headers: {
-      'X-Auth': jwt,
+      cookie,
       'Content-Type': CONTENT_TYPES[ext] ?? 'application/octet-stream',
       'Content-Length': String(bytes.byteLength),
     },
@@ -114,11 +179,6 @@ async function upload(jwt: string, localPath: string, remotePath: string): Promi
   if (!res.ok) throw new Error(`upload ${remotePath} failed: ${res.status} ${await res.text()}`);
 }
 
-/** Encode each segment but keep the separators, so a path stays a path. */
-function encodePath(p: string): string {
-  return p.split('/').map(encodeURIComponent).join('/');
-}
-
 // ---------------------------------------------------------------------------
 
 console.log('building…');
@@ -147,15 +207,16 @@ if (DRY) {
     );
   }
 
-  const jwt = await login();
+  const cookie = await login();
-  console.log('logged in');
+  const source = await resolveSource(cookie);
+  console.log(`logged in — writing to source "${source}"`);
 
-  await makeDir(jwt, DEST);
+  await makeDir(cookie, source, DEST);
-  for (const d of dirs) await makeDir(jwt, `${DEST}/${d}`);
+  for (const d of dirs) await makeDir(cookie, source, `${DEST}/${d}`);
 
   let done = 0;
   for (const f of files) {
-    await upload(jwt, join(dist, f), `${DEST}/${f}`);
+    await upload(cookie, source, join(dist, f), `${DEST}/${f}`);
     done++;
     console.log(`  [${String(done).padStart(2)}/${files.length}] ${f}`);
   }

src/engine/advance.ts

@@ -39,7 +39,7 @@ import type { GameEvent } from './events.ts';
 import { areaAtSeat, areaOf, trainNeedingCars } from './apply.ts';
 import { legalActions } from './legal.ts';
 import type { CrewTray, DivisionNode, GameState, PlayerIndex, RollingStock, SeatIndex, TrayId } from './state.ts';
-import { coordKey, freshTurns, playerAtSeat, playerLeftOf, subdivisions, totalRevenue, turnOf } from './state.ts';
+import { coordKey, freshTurns, playerAtSeat, playerLeftOf, pooled, subdivisions, totalRevenue, turnOf } from './state.ts';
 
 export type AdvanceResult = {
   events: GameEvent[];
@@ -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) {
+  const extra = s.pendingExtras[0];
-    s.clock.currentActor = actorAt(s, s.clock.actorOffset % s.players.length);
+  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 };
@@ -456,6 +471,9 @@ function enterMainline(
   );
   node.transits.push({ tray: id, stagesRemaining: stages, stagesTotal: stages, direction: tray.direction });
   tray.position = { at: 'mainline', index };
+  // It is running now, so it is no longer being assembled (state.ts). A train at a Division Point
+  // needs no equivalent: leaving one changes its position, which is what that case reads.
+  delete tray.beingMadeUp;
 
   /**
    * OUT OF THE DISTRICT, AND THE SPUR PORT GOES WITH IT.
@@ -653,6 +671,43 @@ function moveTrain(s: GameState, id: TrayId, tray: CrewTray, events: GameEvent[]
     const node = s.division.nodes[index];
     if (!node || node.kind !== 'mainline') return 'held';
 
+    /**
+     * §7/§8.1 — AN EXTRA HIGHBALLING OUT OF THE INTERCHANGE'S YARD.
+     *
+     * Standing in `holding` rather than crossing in `transits` (state.ts), which is the position an
+     * Extra started at an Interchange begins in. It leaves exactly the way a train at a Division
+     * Point does — clearance first, then onto the running line — except that the card it enters is
+     * the one it is already standing beside rather than the next one along.
+     *
+     * That reuse is the whole point of modelling the yard separately: Jesse's rule is "a guaranteed
+     * collision holds it at the Interchange for another Stage and it tries again; a potential one is
+     * the Superintendent's to hold", and those are precisely `evaluateClearance`'s `blocked` and
+     * `ask`. Nothing new decides collisions here.
+     */
+    if (node.holding?.includes(id)) {
+      const clearance = evaluateClearance(s, id, tray, index, events);
+      if (clearance === 'blocked') {
+        events.push({
+          type: 'trainHeld',
+          trainNumber: tray.trainNumber ?? 0,
+          reason: 'held in the Interchange — the Subdivision ahead is occupied',
+        });
+        return 'held';
+      }
+      if (clearance === 'ask') return 'needsClearance';
+
+      node.holding = node.holding.filter((t) => t !== id);
+      enterMainline(s, node, id, tray, index);
+      events.push({
+        type: 'trainHighballed',
+        trainNumber: tray.trainNumber ?? 0,
+        from: 'the Interchange',
+        to: 'the Mainline',
+        why: 'it was made up in the yard and the Subdivision was clear, so its run begins',
+      });
+      return 'moved';
+    }
+
     const transit = node.transits.find((t) => t.tray === id);
     if (!transit) return 'held';
 
@@ -959,12 +1014,33 @@ function collide(
       consist: [...tray.consist],
     });
     // Gap 2c — engines and cabooses return to the Division Yard, everything else to Classification.
+    // `pooled` because a car reaching a yard is back in the common supply: the load's origin stamp
+    // (state.ts) belongs to the load, not to the car that happened to be carrying it.
     for (const car of tray.consist) {
-      if (car.type === 'caboose') s.yards.divisionYard.push(car);
+      if (car.type === 'caboose') s.yards.divisionYard.push(pooled(car));
-      else s.yards.classificationYard.push(car);
+      else s.yards.classificationYard.push(pooled(car));
     }
     s.trays.delete(id);
     s.freeTrays.push(id);
+    /**
+     * TAKE THE WRECK OFF THE CARD.
+     *
+     * Nothing did. `s.trays.delete` removed the train and left its `Transit` sitting on the Mainline
+     * card it died on, and `evaluateClearance` counts every transit as an occupant — so a rear-end
+     * collision (the caller at "ran into the train ahead") permanently poisoned that card: every
+     * later train was either held against a ghost or put to the Superintendent about one. The only
+     * other place a transit is removed is a train rolling off the far end, which a destroyed train
+     * never does.
+     *
+     * Found while adding the Interchange start, which clears onto the running line through that
+     * same occupant list.
+     */
+    for (const n of s.division.nodes) {
+      if (n.kind !== 'mainline') continue;
+      n.transits = n.transits.filter((t) => t.tray !== id);
+      if (n.holding) n.holding = n.holding.filter((t) => t !== id);
+      if (n.redFlagged) n.redFlagged = n.redFlagged.filter((t) => t !== id);
+    }
   }
 
   if (lost.length > 0) {
@@ -1031,9 +1107,10 @@ function retireTrain(
   side: Direction,
   events: GameEvent[],
 ): void {
+  // `pooled` — see `trainsDestroyed` above; a load's origin stamp does not survive the yard.
   for (const car of tray.consist) {
-    if (car.type === 'caboose') s.yards.divisionYard.push(car);
+    if (car.type === 'caboose') s.yards.divisionYard.push(pooled(car));
-    else s.yards.classificationYard.push(car);
+    else s.yards.classificationYard.push(pooled(car));
   }
   s.trays.delete(id);
   s.freeTrays.push(id);

src/engine/apply.ts

@@ -33,9 +33,9 @@ import {
   officeProfile,
   trainProfile,
 } from './content.ts';
-import type { CarType, FreightKind, Hand, MainlineKind, ModifierKind, ModifierProfile, TrackGeometry, TrainRules } from './content.ts';
+import type { CarType, Direction, FreightKind, Hand, MainlineKind, ModifierKind, ModifierProfile, TrackGeometry, TrainRules } from './content.ts';
 import type { GameEvent } from './events.ts';
-import type { Intent, RejectionCode } from './intents.ts';
+import type { ExtraStart, Intent, RejectionCode } from './intents.ts';
 import type {
   CardId,
   CrewTray,
@@ -59,6 +59,7 @@ import {
   cutTowards,
   isOperationalRail,
   playerAtSeat,
+  pooled,
   railFacingOf,
   seatOf,
   spaceOn,
@@ -388,17 +389,11 @@ export function canStartLoad(f: Facility): boolean {
 }
 
 /** §9.2 — boarding needs a loaded coach in a green slot and a train with an empty coach. */
-export function canBoard(s: GameState, player: PlayerIndex, at: GridCoord): boolean {
+export function canBoard(s: GameState, player: PlayerIndex, at: GridCoord, trayId?: TrayId): boolean {
   const f = facilityAt(s, player, at);
   if (!f || f.kind !== 'passenger' || portersLeft(f) < 1) return false;
   if (!f.outboundBox.some((c) => c.type === 'coach' && c.loaded)) return false;
-  // §7 — a train whose card refuses passenger work, or which is not booked to stop here, is not a
+  return passengerWork(s, player, 'board', trayId) !== null;
-  // train these passengers can board however many empty coaches it is carrying.
-  return trainAtOfficeWith(
-    s, player,
-    (c) => c.type === 'coach' && !c.loaded,
-    (t) => !refusesPassengers(t) && !refusesThisOffice(s, player, t),
-  );
 }
 
 /**
@@ -413,29 +408,159 @@ export function canBoard(s: GameState, player: PlayerIndex, at: GridCoord): bool
  * de-training MINTED a coach: the loaded one went to the red box and a new empty one appeared in the
  * train. Measured at 1.29 cars a game created out of nothing across the two inbound paths.
  */
-export function canDetrain(s: GameState, player: PlayerIndex, at: GridCoord): boolean {
+export function canDetrain(s: GameState, player: PlayerIndex, at: GridCoord, trayId?: TrayId): boolean {
   const f = facilityAt(s, player, at);
   if (!f || f.kind !== 'passenger' || portersLeft(f) < 1) return false;
   if (f.inboundBox.length >= f.capacity.inbound) return false;
   if (!s.yards.divisionYard.some((c) => c.type === 'coach' && !c.loaded)) return false;
-  return trainAtOfficeWith(
+  return passengerWork(s, player, 'detrain', trayId) !== null;
-    s, player,
-    (c) => c.type === 'coach' && c.loaded,
-    (t) => !refusesPassengers(t) && !refusesThisOffice(s, player, t),
-  );
 }
 
-function trainAtOfficeWith(
+/**
+ * A Timetabled or Extra train card (§6.2) — the one place that decides what "a train card" means.
+ */
+export function isTrainCard(s: GameState, cardId: CardId): boolean {
+  const kind = s.cards.get(cardId)?.kind.kind;
+  return kind === 'timetabledTrain' || kind === 'extraTrain';
+}
+
+/**
+ * WHY THIS CARD CANNOT BE THROWN AWAY, or `null` if it can (§6.2, Gitea#9 superseding Gitea#6).
+ *
+ * The one place that answers the question, so `check`, the hand panel and the blocked "End Local
+ * Operations" button all give the same reason rather than three hand-written approximations of it.
+ * Gitea#6 made every train card unconditionally undiscardable; Gitea#9 narrows that:
+ *
+ *   - a TIMETABLED train is discardable unless the `discardTimetabled` house rule is off. Jesse's
+ *     reasoning is about a long game whose timetable has filled up — "the stations are jammed and
+ *     the railroad doesn't need any more. You can toss it";
+ *   - an EXTRA is never discardable. It never joins the timetable, so it cannot jam it, and the
+ *     rule it would otherwise dodge is the hand limit.
+ *
+ * Returns the sentence rather than a code because it is written for a player, and the two cases
+ * fail for genuinely different reasons — "not in this game" and "not ever".
+ */
+export function keepReason(s: GameState, cardId: CardId): string | null {
+  const kind = s.cards.get(cardId)?.kind.kind;
+  if (kind === 'extraTrain') {
+    return 'An Extra is never discarded. It runs once and ends in the Salvage Yard, so it can only ' +
+      'be played — hold it for as many Stages and Days as you like.';
+  }
+  if (kind === 'timetabledTrain' && !houseRules(s.config).discardTimetabled) {
+    return 'A train card is never discarded in this game. The only way it leaves your hand is onto ' +
+      'the timetable — hold it for as many Stages and Days as you like.';
+  }
+  return null;
+}
+
+/**
+ * WHERE AN EXTRA STARTS AND WHICH WAY IT RUNS — the one answer `check`, `execute` and the reducer
+ * all use, so a placement can never be checked against one square and made on another.
+ *
+ * §7 lets the player who played the card choose the start, and Jesse's ruling makes the start
+ * decide the direction rather than the number (`runDirection`'s comment carries the supersession):
+ *
+ * - a DIVISION POINT runs the train away from itself — the west end runs east, the east end west.
+ *   `direction` on the intent is ignored rather than refused, because there is only one answer;
+ * - an INTERCHANGE or a CONTROL POINT sits in the middle of the railroad, where both ways are real
+ *   runs, so the intent must say which.
+ *
+ * Which of those are on offer is the `extraStart` house rule. The two that belong to nobody — the
+ * Division Points and the Interchange — are always available; an Office is a seat's own ground and
+ * is gated, to `ownOffice` (the player who played the card) or `anyOffice`.
+ *
+ * Returns a refusal code rather than throwing, so `check` can hand it straight back.
+ */
+export function resolveExtraStart(
   s: GameState,
   player: PlayerIndex,
-  pred: (c: RollingStock) => boolean,
+  i: { trainNumber: number; atSeat?: SeatIndex | null; start?: ExtraStart; direction?: Direction },
-  trayOk: (t: CrewTray) => boolean = () => true,
+): { at: ExtraStart; direction: Direction } | RejectionCode {
-): boolean {
+  /**
+   * A save written before the choice existed. `atSeat` null meant the Division Point the NUMBER
+   * sent the train to, a seat meant that Office, and both ran in the number's direction — so that
+   * is what these replay as, whatever the rules say today.
+   */
+  if (!i.start) {
+    const direction = runDirection(i.trainNumber);
+    if (i.atSeat === null || i.atSeat === undefined) {
+      return { at: { kind: 'divisionPoint', side: startingDivisionPoint(i.trainNumber) }, direction };
+    }
+    return { at: { kind: 'office', seat: i.atSeat }, direction };
+  }
+
+  const start = i.start;
+  if (start.kind === 'divisionPoint') {
+    if (!s.division.nodes.some((n) => n.kind === 'divisionPoint' && n.side === start.side)) {
+      return 'NO_SUCH_DIVISION_POINT';
+    }
+    // Away from the end it is standing at. Nothing else is a run.
+    return { at: start, direction: start.side === 'west' ? 'east' : 'west' };
+  }
+
+  if (i.direction === undefined) return 'NO_DIRECTION_CHOSEN';
+
+  if (start.kind === 'mainline') {
+    const node = s.division.nodes[start.node];
+    if (!node || node.kind !== 'mainline') return 'NO_SUCH_CARD';
+    // The Interchange is the one Mainline card an Extra may be made up on — it is the one with a
+    // yard. `sortsCars` is what the card prints and the only thing that distinguishes it.
+    if (!mainlineProfile(node.card).sortsCars) return 'NOT_AN_INTERCHANGE';
+    return { at: start, direction: i.direction };
+  }
+
+  const rule = houseRules(s.config).extraStart;
+  if (rule === 'divisionPointsOnly') return 'OFFICE_STARTS_NOT_ALLOWED';
+  if (rule === 'ownOffice' && start.seat !== seatOf(s, player)) return 'NOT_YOUR_OFFICE';
+  const area = s.officeAreas.get(start.seat);
+  if (!area) return 'NO_SUCH_FACILITY';
+  // A Control Point is any Office above a Whistle Post (§8). A Whistle Post is not one, which is
+  // the whole reason upgrading buys a place for an Extra to start — and no setting of the house
+  // rule lets one in.
+  if (!officeProfile(area.tier).isControlPoint) return 'NOT_A_CONTROL_POINT';
+  return { at: start, direction: i.direction };
+}
+
+/**
+ * WHICH TRAIN, AND WHICH COACH ON IT — the one answer `check`, `execute` and the reducer all use.
+ *
+ * TWO PLAYTEST BUGS SHARED ONE CAUSE HERE. Reported against v0.4.9d: "operating two trains in a
+ * station, the select button does not work — regardless of which you pick, it is always one train,
+ * not the other". `porter.board` carried no tray at all, so `check` asked whether SOME train at the
+ * Office had an empty coach and the reducer then walked `adOccupancy` and filled the first one it
+ * found. The two were not even asking the same question: `check` skipped a train whose card refuses
+ * passenger work and the reducer did not, so a Military train could be boarded as long as some other
+ * train at the platform was eligible. The intent now names its tray (`intents.ts`) and this is the
+ * one place that resolves it.
+ *
+ * And "passengers just boarded cannot be immediately unloaded": a coach carries the district that
+ * filled it (`RollingStock.origin`), and a homegrown coach is not a coach these passengers may
+ * alight from — they have to be carried to a different Office Area first.
+ *
+ * `trayId` absent means "any eligible train", which is what every intent recorded before this
+ * existed meant, so an old save replays unchanged.
+ */
+function passengerWork(
+  s: GameState,
+  player: PlayerIndex,
+  dir: 'board' | 'detrain',
+  trayId?: TrayId,
+): { trayId: TrayId; coachIndex: number } | null {
   const area = areaOf(s, player);
-  return area.adOccupancy.some((id) => {
+  const seat = seatOf(s, player);
-    const t = s.trays.get(id);
+  const wanted = (c: RollingStock): boolean =>
-    return !!t && trayOk(t) && t.consist.some(pred);
+    c.type === 'coach' && (dir === 'board' ? !c.loaded : c.loaded && c.origin !== seat);
-  });
+  for (const id of area.adOccupancy) {
+    if (trayId !== undefined && id !== trayId) continue;
+    const tray = s.trays.get(id);
+    if (!tray) continue;
+    // §7 — a train whose card refuses passenger work, or which is not booked to stop here, is not a
+    // train these passengers can board however many empty coaches it is carrying.
+    if (refusesPassengers(tray) || refusesThisOffice(s, player, tray)) continue;
+    const coachIndex = tray.consist.findIndex(wanted);
+    if (coachIndex >= 0) return { trayId: id, coachIndex };
+  }
+  return null;
 }
 
 // ---------------------------------------------------------------------------
@@ -466,6 +591,21 @@ function freightWorkedKey(trayId: TrayId, at: GridCoord): string {
 
 const isFreight = (c: RollingStock): boolean => c.type !== 'coach' && c.type !== 'caboose';
 
+/**
+ * IS THIS CAR CARRYING A LOAD? A CABOOSE NEVER IS, whatever its `loaded` flag says.
+ *
+ * `ROLLING_STOCK_SUPPLY` mints all six cabooses as `{ loaded: 6, empty: 0 }` because §2.2's
+ * "a coloured car is loaded, a white car is empty" is doing double duty there as a PIECE COUNT,
+ * and a caboose has no white version — there is no such thing as an empty one to make up a train
+ * from. Every other reading of `.loaded` in this file is already scoped to a coach or to a named
+ * car type, so the flag's second meaning only ever escaped here.
+ *
+ * Reported as Gitea#8: X22 Pee-Dee, whose whole card is "may only pick up MTs", could not couple a
+ * caboose at all — including the one it was made up with. Drop it and it was stranded, which made
+ * the train unplayable rather than merely restricted.
+ */
+const carriesLoad = (c: RollingStock): boolean => c.loaded && c.type !== 'caboose';
+
 /**
  * May this train work these freight cars on this square?
  *
@@ -565,17 +705,35 @@ function refusesThisOffice(s: GameState, player: PlayerIndex, tray: CrewTray): b
  * this works out whether a card is the reason. Without it a Military train standing at the platform
  * reported "no train at the Office", which is both wrong and unhelpful.
  */
-function passengerRefusal(
+export function passengerRefusal(
   s: GameState,
   player: PlayerIndex,
   at: GridCoord,
   dir: 'board' | 'detrain',
+  trayId?: TrayId,
 ): RejectionCode {
   const area = areaOf(s, player);
-  const trains = area.adOccupancy.map((id) => s.trays.get(id)).filter((t): t is CrewTray => !!t);
+  const trains = area.adOccupancy
+    .filter((id) => trayId === undefined || id === trayId)
+    .map((id) => s.trays.get(id))
+    .filter((t): t is CrewTray => !!t);
   if (trains.length > 0 && trains.every((t) => refusesThisOffice(s, player, t))) return 'NOT_A_TERMINAL';
   if (trains.length > 0 && trains.every(refusesPassengers)) return 'NO_PASSENGER_WORK';
   if (trains.length === 0) return 'NO_TRAIN_AT_OFFICE';
+  /**
+   * EVERY LOADED COACH ABOARD BOARDED HERE — so the refusal is the district rule, not "no loaded
+   * coach". Told apart because the two read as opposite situations to a player: one is an empty
+   * train, the other is a train full of passengers who have not been anywhere yet.
+   */
+  if (
+    dir === 'detrain' &&
+    trains.some((t) => t.consist.some((c) => c.type === 'coach' && c.loaded)) &&
+    trains.every((t) =>
+      t.consist.every((c) => !(c.type === 'coach' && c.loaded) || c.origin === seatOf(s, player)),
+    )
+  ) {
+    return 'LOADED_IN_THIS_DISTRICT';
+  }
 
   /**
    * A TRAIN IS STANDING THERE, so say what is actually missing.
@@ -662,7 +820,7 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
          */
         if (rules.noSwitching) return 'PICKUP_NOT_ALLOWED';
         if (rules.dropOnly) return 'PICKUP_NOT_ALLOWED';
-        if (rules.pickUpEmptiesOnly && fresh.some((c) => c.loaded)) return 'EMPTIES_ONLY';
+        if (rules.pickUpEmptiesOnly && fresh.some(carriesLoad)) return 'EMPTIES_ONLY';
         const freight = fresh.filter(isFreight).length;
         if (freight > 0 && !freightBudgetLeft(s, player, tray, i.to, freight)) return 'FREIGHT_WORKED_HERE';
       }
@@ -765,11 +923,30 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
       return checkPlay(s, player, i.cardId, i.placement, i.variant, i.node);
     }
 
+    /**
+     * §6.2 — WHICH TRAIN CARDS MAY BE THROWN AWAY (Gitea#9, superseding Gitea#6).
+     *
+     * `keepReason` holds the rule; this asks it. A Timetabled train is discardable unless the
+     * `discardTimetabled` house rule is off, and an Extra never is.
+     *
+     * WHERE THE DISCARD GOES IS THE OTHER HALF OF THE RULING. "If someone else wants to pick it up,
+     * they are more than able to" — a discard goes face-up on a Department pile, which is exactly
+     * where a rival can draw it from, so the second half needed no machinery at all.
+     *
+     * The corner Gitea#6 created still exists when the setting is off, and is still deliberate: a
+     * player holding four undiscardable trains has one way forward, which is to PLAY one. `draw.end`
+     * refuses while the hand is over the limit, and playing a train card is unconditionally legal
+     * (`card.play`'s `timetabledTrain` case refuses only a board placement), so it can never lock.
+     *
+     * `legal.ts` enumerates candidates and filters them through here, so an undiscardable card
+     * simply stops being offered; the bot needs no separate rule.
+     */
     case 'card.discard': {
       if (!inPhase(s, 'localOps')) return 'WRONG_PHASE';
       const hand = s.decks.hands.get(player) ?? [];
       if (!hand.includes(i.cardId)) return 'CARD_NOT_IN_HAND';
       if (i.toSlot < 0 || i.toSlot > 2) return 'SLOT_EMPTY';
+      if (keepReason(s, i.cardId) !== null) return 'TRAINS_ARE_NEVER_DISCARDED';
       return null;
     }
 
@@ -788,8 +965,9 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
       if (rule.gradeOnly && mainlineProfile(node.card).speed.kind !== 'grade') return 'NOT_A_GRADE';
       if (rule.requiresOnCard && !on.includes(rule.requiresOnCard)) return 'NOT_CONNECTED';
       // "Not while a train is on it" — realigning under a moving train is exactly the situation the
-      // restriction exists to prevent.
+      // restriction exists to prevent. A train standing in the Interchange's yard counts: it is on
-      if (node.transits.length > 0) return 'TRAIN_ON_CARD';
+      // the card, and it is about to pull out onto the very rail being relaid.
+      if (node.transits.length > 0 || (node.holding?.length ?? 0) > 0) return 'TRAIN_ON_CARD';
       if (rule.key === 'realignment' && !REALIGNMENTS.some((r) => r.from === node.card)) {
         return 'NO_PLACEMENT';
       }
@@ -914,14 +1092,22 @@ 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';
-      if (i.atSeat === null) return null;
+      const where = resolveExtraStart(s, player, i);
-      // A Control Point is any Office above a Whistle Post (§8). A Whistle Post is not one, which is
+      if (typeof where === 'string') return where;
-      // the whole reason upgrading buys a place for an Extra to start.
+      if (where.at.kind === 'divisionPoint') return null;
-      const area = s.officeAreas.get(i.atSeat);
+      if (where.at.kind === 'mainline') {
-      if (!area) return 'NO_SUCH_FACILITY';
+        // Nothing to refuse. The train is made up in the Interchange's yard, off the running line,
-      if (!officeProfile(area.tier).isControlPoint) return 'NOT_A_CONTROL_POINT';
+        // so however busy the card is this cannot be the collision §7 says it must not force. What
+        // it may not do is get OUT — that is §8.1's question, asked at the Mainline Phase.
+        return null;
+      }
+      const area = s.officeAreas.get(where.at.seat)!;
       // It still has to fit: an Extra starting here takes an A/D track like any other arrival.
       return area.adOccupancy.length >= officeProfile(area.tier).adTracks ? 'NO_FREE_AD_TRACK' : null;
     }
@@ -981,7 +1167,8 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
       if (!f) return 'NO_SUCH_FACILITY';
       if (f.porters < 1) return 'NO_PORTERS_HERE';
       if (portersLeft(f) < 1) return 'RESOURCE_SPENT';
-      return canBoard(s, player, i.at) ? null : passengerRefusal(s, player, i.at, 'board');
+      if (i.trayId !== undefined && !s.trays.has(i.trayId)) return 'NO_SUCH_TRAY';
+      return canBoard(s, player, i.at, i.trayId) ? null : passengerRefusal(s, player, i.at, 'board', i.trayId);
     }
 
     case 'porter.detrain': {
@@ -990,7 +1177,8 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
       if (!f) return 'NO_SUCH_FACILITY';
       if (f.porters < 1) return 'NO_PORTERS_HERE';
       if (portersLeft(f) < 1) return 'RESOURCE_SPENT';
-      return canDetrain(s, player, i.at) ? null : passengerRefusal(s, player, i.at, 'detrain');
+      if (i.trayId !== undefined && !s.trays.has(i.trayId)) return 'NO_SUCH_TRAY';
+      return canDetrain(s, player, i.at, i.trayId) ? null : passengerRefusal(s, player, i.at, 'detrain', i.trayId);
     }
 
     case 'laborer.startLoad': {
@@ -1026,6 +1214,19 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
       if (laborersLeft(f) < 1) return 'RESOURCE_SPENT';
       const car = f.industryTrack.cars[i.carIndex];
       if (!car || !car.loaded) return 'WRONG_CAR_TYPE';
+      /**
+       * A LOAD MAY NOT BE BROKEN IN THE DISTRICT THAT MADE IT (Jesse's ruling, v0.4.9e).
+       *
+       * Reported from playtesting v0.4.9d: "Freight House: boxcars loaded cannot be immediately
+       * unloaded." They could — a Freight House permits both directions, so the car its own Laborers
+       * had just loaded was standing on its own track, loaded, with an empty of that type in the
+       * yard, and every gate below said yes. Full Revenue at both ends for a load that never moved.
+       *
+       * The rule is district-wide and permanent, not "not at this facility" and not "not this
+       * Stage": the stamp says which Office Area made the load, and it never expires. Traffic runs
+       * BETWEEN districts, which is what the lockout pairs in `content.ts` exist to force.
+       */
+      if (car.origin === seatOf(s, player)) return 'LOADED_IN_THIS_DISTRICT';
       /**
        * §9.3 — "*Requirements: a load on the industry's track AND AN EMPTY CAR OF THAT TYPE IN THE
        * DIVISION YARD. The first Laborer replaces the load with an empty car of that type.*"
@@ -1584,8 +1785,13 @@ function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
       return [{ type: 'facilityUnjammed', player, at: i.at, from: i.from, stock }];
     }
 
-    case 'newTrain.startExtra':
+    case 'newTrain.startExtra': {
-      return [{ type: 'extraStarted', player, trainNumber: i.trainNumber, atSeat: i.atSeat }];
+      // `check` has already accepted this, so the resolve cannot fail here.
+      const where = resolveExtraStart(s, player, i) as { at: ExtraStart; direction: Direction };
+      return [
+        { type: 'extraStarted', player, trainNumber: i.trainNumber, at: where.at, direction: where.direction },
+      ];
+    }
 
     case 'newTrain.placeCar':
       return [
@@ -1617,17 +1823,23 @@ function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
      * `passengerPerCoach` (`content.ts`). Half a passenger movement is half the work, and the rate
      * is named per COACH because a Porter handles exactly one coach per action.
      */
-    case 'porter.board':
+    case 'porter.board': {
+      // `check` has already established there is one; resolving it HERE, once, is what stops the
+      // reducer from finding a different train than the one the rules were tested against.
+      const work = passengerWork(s, player, 'board', i.trayId)!;
       return [
-        { type: 'passengersBoarded', player, at: i.at },
+        { type: 'passengersBoarded', player, at: i.at, ...work },
         ...earns(s, player, houseRules(s.config).revenue.passengerPerCoach, 'boarding'),
       ];
+    }
 
-    case 'porter.detrain':
+    case 'porter.detrain': {
+      const work = passengerWork(s, player, 'detrain', i.trayId)!;
       return [
-        { type: 'passengersDetrained', player, at: i.at },
+        { type: 'passengersDetrained', player, at: i.at, ...work },
         ...earns(s, player, houseRules(s.config).revenue.passengerPerCoach, 'detraining'),
       ];
+    }
 
     case 'laborer.startLoad': {
       const f = facilityAt(s, player, i.at)!;
@@ -1956,9 +2168,14 @@ export function reduce(s: GameState, e: GameEvent): void {
       const card = area.grid.get(coordKey(e.to));
       if (tray && card) {
         tray.consist = tray.consist.slice(0, tray.consist.length - e.stock.length);
-        const track = card.facility?.industryTrack;
+        // `carsOn` is the one function that knows WHERE cars stand on a given card — an industry
-        if (track) track.cars.push(...e.stock);
+        // track for a freight facility, the card itself for everything else. Written out longhand
-        else card.standing.push(...e.stock);
+        // here it was a second copy of that rule, and the copy was wrong for a Passenger Facility:
+        // it has an `industryTrack` too (an empty one, `setup.ts`), so a cut pushed into an Office
+        // would have landed somewhere `carsOn` cannot see — cars on the board that no train can
+        // couple and no walk is blocked by. `check` refuses a non-freight target, so this never
+        // fired; a trap that needs another rule to stay unsprung is still a trap.
+        carsOn(card).push(...e.stock);
       }
       turnOf(s, e.player).movesRemaining -= 1;
       spendCard(s, e.player, e.cardId);
@@ -2049,7 +2266,8 @@ export function reduce(s: GameState, e: GameEvent): void {
       const f = facilityAt(s, e.player, e.at)!;
       const idx = f.inboundBox.findIndex((c) => c.type === e.stock.type && c.loaded === e.stock.loaded);
       if (idx >= 0) f.inboundBox.splice(idx, 1);
-      s.yards.classificationYard.push(e.stock);
+      // `pooled` — a car back in a yard is back in the common supply, carrying nothing (state.ts).
+      s.yards.classificationYard.push(pooled(e.stock));
       turnOf(s, e.player).freightAgentUsed = true;
       break;
     }
@@ -2064,7 +2282,7 @@ export function reduce(s: GameState, e: GameEvent): void {
         const idx = box.findIndex((c) => c.type === e.stock.type);
         if (idx >= 0) box.splice(idx, 1);
       }
-      s.yards.classificationYard.push(e.stock);
+      s.yards.classificationYard.push(pooled(e.stock));
       turnOf(s, e.player).freightAgentUsed = true;
       break;
     }
@@ -2082,7 +2300,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':
@@ -2106,45 +2325,85 @@ export function reduce(s: GameState, e: GameEvent): void {
       break;
     }
 
+    /**
+     * THE THREE PLACES AN EXTRA MAY BE MADE UP (§7, Jesse's ruling) — and all three leave it
+     * STANDING somewhere it must later highball out of, never already running.
+     */
     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 = runDirection(e.trainNumber);
+      const { direction } = e;
-      if (e.atSeat === null) {
+      const base = {
-        const side = startingDivisionPoint(e.trainNumber);
+        id: trayId, trainNumber: e.trainNumber, trainIsExtra: true, engineAt: 0,
-        s.trays.set(trayId, {
+        consist: [] as RollingStock[], direction, movesUsed: 0,
-          id: trayId, trainNumber: e.trainNumber, trainIsExtra: true, engineAt: 0, consist: [],
+        // The queue is emptied here, before a single car goes on, so the tray carries the owner
-          direction, position: { at: 'divisionPoint', side }, movesUsed: 0,
+        // 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
+      // one, so writing it here would be inventing state the DP path has always done without.
+      const facing = { facing: direction === 'west' ? ('w' as const) : ('e' as const),
+                       railFacing: direction === 'west' ? ('w' as const) : ('e' as const) };
+
+      if (e.at.kind === 'divisionPoint') {
+        const side = e.at.side;
+        s.trays.set(trayId, { ...base, position: { at: 'divisionPoint', side } });
         const dp = s.division.nodes.find((n) => n.kind === 'divisionPoint' && n.side === side);
         if (dp?.kind === 'divisionPoint') dp.holding.push(trayId);
-      } else {
+        break;
-        // Starting at a Control Point: it stands on the Office card and takes an A/D track, exactly
-        // as though it had arrived there.
-        const area = areaAtSeat(s, e.atSeat);
-        s.trays.set(trayId, {
-          id: trayId, trainNumber: e.trainNumber, trainIsExtra: true, engineAt: 0, consist: [],
-          direction, facing: direction === 'west' ? 'w' : 'e', railFacing: direction === 'west' ? 'w' : 'e',
-          position: { at: 'grid', seat: e.atSeat, coord: area.officeCoord }, movesUsed: 0,
-        });
-        area.adOccupancy.push(trayId);
       }
+
+      if (e.at.kind === 'mainline') {
+        /**
+         * IN THE INTERCHANGE'S YARD, NOT ON THE MAINLINE — the distinction §7 turns on.
+         *
+         * `holding` rather than `transits`, so the card can be nose to tail with traffic and this
+         * placement still forces no collision. It joins the running line at a later Mainline Phase
+         * through `evaluateClearance`, which is what gives the Superintendent the hold Jesse asked
+         * for: an automatic one against a facing train, a ruling against a following one.
+         */
+        const node = s.division.nodes[e.at.node];
+        s.trays.set(trayId, {
+          ...base, ...facing, beingMadeUp: true, position: { at: 'mainline', index: e.at.node },
+        });
+        if (node?.kind === 'mainline') (node.holding ??= []).push(trayId);
+        break;
+      }
+
+      // Starting at a Control Point: it stands on the Office card and takes an A/D track, exactly
+      // as though it had arrived there.
+      const area = areaAtSeat(s, e.at.seat);
+      s.trays.set(trayId, {
+        ...base, ...facing, beingMadeUp: true,
+        position: { at: 'grid', seat: e.at.seat, coord: area.officeCoord },
+      });
+      area.adOccupancy.push(trayId);
       break;
     }
 
+    /**
+     * THE TRAIN AND THE COACH THE PLAYER PICKED, not "the first one on the A/D tracks".
+     *
+     * This used to walk `adOccupancy` and fill the first empty coach it met, which is why two trains
+     * standing at one station both answered to whichever chip was clicked (v0.4.9d playtest), and
+     * why it could fill a coach on a train whose card refuses passenger work — `check` skipped such
+     * a train and the reducer did not. `e.trayId`/`e.coachIndex` are exactly what `passengerWork`
+     * resolved for `check`, carried on the event rather than looked up again here.
+     */
     case 'passengersBoarded': {
       const f = facilityAt(s, e.player, e.at)!;
-      const area = areaOf(s, e.player);
       const idx = f.outboundBox.findIndex((c) => c.type === 'coach' && c.loaded);
       const loaded = f.outboundBox.splice(idx, 1)[0]!;
-      for (const id of area.adOccupancy) {
+      const tray = s.trays.get(e.trayId);
-        const tray = s.trays.get(id);
+      if (tray && tray.consist[e.coachIndex]) {
-        const ci = tray?.consist.findIndex((c) => c.type === 'coach' && !c.loaded) ?? -1;
+        s.yards.classificationYard.push(pooled(tray.consist[e.coachIndex]!));
-        if (tray && ci >= 0) {
+        /**
-          s.yards.classificationYard.push(tray.consist[ci]!);
+         * Stamped with the district that filled it — the chip turned upside down in the tray. These
-          tray.consist[ci] = loaded;
+         * passengers may not alight anywhere in this Office Area; the train has to carry them to a
-          break;
+         * different one. See `RollingStock.origin` in state.ts.
-        }
+         */
+        tray.consist[e.coachIndex] = { ...loaded, origin: seatOf(s, e.player) };
       }
       f.usedThisStage.porters += 1;
       break;
@@ -2152,21 +2411,18 @@ export function reduce(s: GameState, e: GameEvent): void {
 
     case 'passengersDetrained': {
       const f = facilityAt(s, e.player, e.at)!;
-      const area = areaOf(s, e.player);
+      const tray = s.trays.get(e.trayId);
-      for (const id of area.adOccupancy) {
+      if (tray && tray.consist[e.coachIndex]) {
-        const tray = s.trays.get(id);
+        // The empty coach comes OUT OF THE DIVISION YARD, as §9.2 says. It used to be conjured,
-        const ci = tray?.consist.findIndex((c) => c.type === 'coach' && c.loaded) ?? -1;
+        // which minted a coach on every de-training. Throws now, for the reason in `unloadBegan`.
-        if (tray && ci >= 0) {
+        const yi = s.yards.divisionYard.findIndex((c) => c.type === 'coach' && !c.loaded);
-          // The empty coach comes OUT OF THE DIVISION YARD, as §9.2 says. It used to be conjured,
+        if (yi < 0) throw new Error('passengersDetrained: no empty coach in the Division Yard');
-          // which minted a coach on every de-training. Throws now, for the reason in `unloadBegan`.
+        const empty = s.yards.divisionYard.splice(yi, 1)[0]!;
-          const yi = s.yards.divisionYard.findIndex((c) => c.type === 'coach' && !c.loaded);
+        refillDivisionYardIfEmpty(s);
-          if (yi < 0) throw new Error('passengersDetrained: no empty coach in the Division Yard');
+        // The arriving coach goes into the red box carrying nothing: the journey it was stamped for
-          const empty = s.yards.divisionYard.splice(yi, 1)[0]!;
+        // is over, and the box feeds straight back to a yard through the Freight Agent.
-          refillDivisionYardIfEmpty(s);
+        f.inboundBox.push(pooled(tray.consist[e.coachIndex]!));
-          f.inboundBox.push(tray.consist[ci]!);
+        tray.consist[e.coachIndex] = empty;
-          tray.consist[ci] = empty;
-          break;
-        }
       }
       f.usedThisStage.porters += 1;
       break;
@@ -2202,8 +2458,14 @@ export function reduce(s: GameState, e: GameEvent): void {
       workTrack(f)[workTrack(f).length - 1] = null;
       const ci = f.industryTrack.cars.findIndex((c) => !c.loaded && c.type === e.carType);
       if (ci >= 0) {
-        s.yards.classificationYard.push(f.industryTrack.cars[ci]!);
+        s.yards.classificationYard.push(pooled(f.industryTrack.cars[ci]!));
-        f.industryTrack.cars[ci] = { type: e.carType, loaded: true };
+        /**
+         * THE LOAD IS STAMPED WITH THE DISTRICT THAT MADE IT — the chip turned upside down in the
+         * tray. `laborer.beginUnload` refuses a car stamped with the district it is standing in, so
+         * this load now has to leave the Office Area on a train before anyone can break it. See
+         * `RollingStock.origin` in state.ts for the rule and why it is a seat.
+         */
+        f.industryTrack.cars[ci] = { type: e.carType, loaded: true, origin: seatOf(s, e.player) };
       }
       f.usedThisStage.laborers += 1;
       break;
@@ -2688,9 +2950,16 @@ export function acceptsCar(tray: CrewTray, carType: CarType): boolean {
 /**
  * §7 — IS THIS TRAY THE ONE BEING MADE UP?
  *
- * A train is made up where it is built, standing at a Division Point, and only until its consist
+ * A train is made up where it is built and only until its consist matches its card. Everything else
- * matches its card. Everything else with a Crew Tray — a train working your district, a train
+ * with a Crew Tray — a train working your district, a train halfway across the Division — is
- * halfway across the Division — is running, not being assembled.
+ * running, not being assembled.
+ *
+ * WHERE that is used to be the whole test: "standing at a Division Point". True while a Division
+ * Point was the only place to build one, and wrong once an Extra could be started at a Control Point
+ * or in an Interchange's yard (§7) — those trains were never offered a car and ran empty. The extra
+ * clause is `beingMadeUp` (state.ts), a flag set on exactly those trays and cleared when they start
+ * running, rather than a second positional rule: a train STANDING at an Office is usually one that
+ * arrived, and must not be fillable from the yard.
  *
  * SHARED with the New Train Phase, which uses it to decide whether to stop and ask. It has to be:
  * `check` accepted any tray with room in its consist, so during a New Train Phase the Division Yard
@@ -2700,7 +2969,7 @@ export function acceptsCar(tray: CrewTray, carType: CarType): boolean {
  */
 export function isBeingMadeUp(tray: CrewTray): boolean {
   if (tray.trainNumber === null) return false;
-  if (tray.position.at !== 'divisionPoint') return false;
+  if (tray.position.at !== 'divisionPoint' && !tray.beingMadeUp) return false;
   const profile = trainProfile(tray.trainNumber, tray.trainIsExtra);
   if (!profile) return false;
   return tray.consist.length < consistSize(profile.consist);

src/engine/content.ts

@@ -3,8 +3,8 @@
  *
  * TRANSCRIBED FROM THE RECOVERED DESIGN FILES (2026-07-30):
  *   docs/Deck cards2.xlsx   — the complete card list and counts
- *   docs/Trains3.pdf        — all 22 train cards
+ *   docs/Trains3.pdf        — the train cards
- *   docs/Mainline Cards.pdf — the ten Mainline card types
+ *   docs/Mainline Cards.pdf — the Mainline card types, and the two Division Points
  *   docs/tracks.png         — card art
  *
  * This replaced an invented 52-card placeholder. See docs/rules/implications.md for what changed
@@ -60,13 +60,17 @@ export type TrackProfile = {
 /**
  * TRACK IS IN THE HOME OFFICE DECK, and is drawn and played like any other card.
  *
- * 96 dealt of the sheet's 104 (column B of `docs/Deck cards2.xlsx`) — the 8 sharp curves are dealt
+ * Every row's dealt count is in `copiesInDeck` below; the sharp curves are dealt zero, see below.
- * zero, see below. An earlier reading made track a
+ * How many that comes to is `TRACK_IN_DECK`, computed rather than written down — it moves with
- * separate per-player supply of 26 pieces, sitting outside the deck and laid one a turn. That came
+ * balance work, so a number in this comment would be wrong before long.
- * from misreading the sheet's LAST column, headed "Track Per Player" — 8/4/4/1/1/4/4 = 26, which is
+ *
- * a note about each player's likely share of 104 across four players, not a second stack of cards.
+ * An earlier reading made track a separate per-player supply, sitting outside the deck and laid one
- * The sheet's own totals settle it: "Sum other 115", "Total track 104", and a grand total of 231
+ * a turn. That came from misreading the sheet's LAST column, headed "Track Per Player" —
- * once the 12 start cards are counted. 115 + 104 + 12 = 231.
+ * 8/4/4/1/1/4/4 = 26, which is a note about each player's likely share across four players, not a
+ * second stack of cards. The sheet's own totals settle it: "Sum other 115", "Total track 104", and a
+ * grand total of 231 once the 12 start cards are counted. 115 + 104 + 12 = 231. Those are figures
+ * from `docs/Deck cards2.xlsx`, a fixed document, and stay here as the audit trail for the
+ * transcription — they are not claims about what the game deals today.
  *
  * It matters well beyond bookkeeping. Track competes for the draw with industry, trains and
  * enhancements, so building a district is paid for in cards you did not draw instead — and the
@@ -89,10 +93,10 @@ export const TRACK_CARDS: readonly TrackProfile[] = [
    * SHARP CURVES ARE DEALT ZERO COPIES — Jesse's call, and the same treatment as Poling.
    *
    * The only thing that made them different from an ordinary curve was `moveCost: 2`, and nothing
-   * ever charged it: every switching move costs exactly 1, hard-coded. So the 8 cards in the deck
+   * ever charged it: every switching move costs exactly 1, hard-coded. So they were geometric
-   * were geometric duplicates of the curves, taking 8 draws from a deck the rebalance already thinks
+   * duplicates of the curves, taking draws from a deck the rebalance already thinks is too diluted.
-   * is too diluted. They come out rather than having the Move cost built, because a per-card movement
+   * They come out rather than having the Move cost built, because a per-card movement cost is a
-   * cost is a change to the Move model and the rebalance can wait.
+   * change to the Move model and the rebalance can wait.
    *
    * The rows stay in the catalogue at zero, exactly as Poling does, so the design is still visible
    * and the geometry still works if they are ever dealt again.
@@ -103,10 +107,10 @@ export const TRACK_CARDS: readonly TrackProfile[] = [
   { geometry: 'turnout', hand: 'left', name: 'Turnout (left)', copiesInDeck: 16, isOperationalRail: false, moveCost: 1 },
 ];
 
-/** 96 — the sheet's "Total track" of 104, less the 8 sharp curves now dealt at zero. */
+/** Summed from `copiesInDeck` above, never written down — it moves whenever the deck is retuned. */
 export const TRACK_IN_DECK = TRACK_CARDS.reduce((n, t) => n + t.copiesInDeck, 0);
 
-/** Start cards, placed at setup and never shuffled: 4 Whistle Posts, 8 Limits. */
+/** Start cards, placed at setup and never shuffled. */
 export const WHISTLE_POST_SUPPLY = 4;
 export const LIMITS_SUPPLY = 8;
 
@@ -116,7 +120,7 @@ export function trackProfile(geometry: TrackGeometry, hand: Hand): TrackProfile
 }
 
 // ---------------------------------------------------------------------------
-// Offices — Depot 4, Station 2, Terminal 1
+// Offices — the upgrade ladder: Whistle Post, Depot, Station, Terminal
 // ---------------------------------------------------------------------------
 
 export type OfficeProfile = {
@@ -139,13 +143,12 @@ export type OfficeProfile = {
  * passenger modifier cards (Waiting Area, Restaurant, Hotel).
  */
 /**
- * Office cards. `copiesInDeck` was **doubled** (Depot 4→8, Station 2→4, Terminal 1→2) — Q12.
+ * Office cards. Every tier's `copiesInDeck` was **doubled** against the recovered design — Q12.
  *
  * Players always start at a Whistle Post, which has ONE A/D track, so a second arrival is an
  * automatic collision (§8.3, Gap 2a). Measured at the original density, 25 of 100 games never drew
  * a Depot and never escaped: they averaged **−6.0** revenue against **−0.4** for games that
- * upgraded at least once, and 25 of 26 collisions happened at Whistle Post. Escaping needed one of
+ * upgraded at least once, and 25 of 26 collisions happened at Whistle Post.
- * 4 Depot cards in 111, roughly a 59% chance across a game's draws.
  *
  * Upgrades are strictly sequential (Gap 3b, no skipping), so Station and Terminal are rarer than
  * their raw counts imply — Terminal needs all three cards in order. Station and Terminal were
@@ -153,9 +156,10 @@ export type OfficeProfile = {
  *
  * PROVISIONAL — re-evaluate. This was chosen to remove a 25% chance of an unwinnable opening deal,
  * not from the recovered design, and it is a blunt instrument: it lifts the whole office ladder and
- * dilutes every other category slightly (deck 133 → 140). Revisit once the victory target is
+ * dilutes every other category slightly. Revisit once the victory target is settled and freight is
- * settled and freight is carrying its intended share; the right answer may instead be fewer
+ * carrying its intended share; the right answer may instead be fewer Terminals, a cheaper first
- * Terminals, a cheaper first upgrade, or more A/D capacity at Whistle Post.
+ * upgrade, or more A/D capacity at Whistle Post. The counts themselves are in the rows below, which
+ * is the only place they should be read from.
  */
 export const OFFICE_PROFILES: readonly OfficeProfile[] = [
   { tier: 'whistlePost', name: 'Whistle Post', isControlPoint: false, isPassengerFacility: false, adTracks: 1, porters: 0, passengerOut: 0, passengerIn: 0, copiesInDeck: 0 },
@@ -199,13 +203,14 @@ export type IndustryProfile = {
 
 /**
  * Industry density (Gap 12). The recovered sheet lists 9 industries in a 115-card deck; the
- * prototype ran 10 in 52. At 9-in-115 a game saw 1.6 Freight Facilities, freight was 10% of gross
+ * prototype ran 10 in 52. At the sheet's density a game saw 1.6 Freight Facilities, freight was 10%
- * revenue, and `carsCoupled` fired 4 times per 100 games — the freight loop, which is the point of
+ * of gross revenue, and `carsCoupled` fired 4 times per 100 games — the freight loop, which is the
- * the game, effectively never ran.
+ * point of the game, effectively never ran.
  *
- * Each industry's `copies` is TRIPLED, giving 27 in 133. That restores roughly the prototype's
+ * Each industry's `copies` is TRIPLED against the sheet, which restores roughly the prototype's
  * ratio while preserving the sheet's proportions exactly: the outbound/inbound balance and the
- * lockout structure are unchanged, because every kind scales by the same factor.
+ * lockout structure are unchanged, because every kind scales by the same factor. The multiplier is
+ * the decision; the resulting totals are in the rows below and move with every retune.
  */
 /**
  * LOCKOUTS, from the sheet's "Lockouts" column verbatim:
@@ -231,42 +236,51 @@ export const INDUSTRY_PROFILES: readonly IndustryProfile[] = [
   { kind: 'freightHouse', name: 'Freight House', carTypes: ['boxcar'], flow: 'both', baseOut: 1, baseIn: 1, baseLoaders: 1, lockouts: ['grocersWarehouse'], copies: 6 },
   { kind: 'mineTipple', name: 'Mine Tipple', carTypes: ['hopper'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['powerPlant'], copies: 6 },
   /**
-   * BOTH DIRECTIONS, per the card reference — this was `outbound` and it contradicted the rules.
+   * OUTBOUND ONLY. A Refinery ships oil out and receives nothing; reported from playtesting and
+   * confirmed by Jesse (v0.4.9e): "only ships out tanks, does not receive anything".
    *
-   * `card-reference.md`: "Oil Refinery | Tank car | Both | 3 | 2 | 2 | 4", and in prose — "'Freight
+   * It was briefly `flow: 'both'`, on the reading that "'Freight House' is not a card — it is the
-   * House' is not a card. It is the collective term for a freight facility that loads *and* unloads
+   * collective term for a freight facility that loads *and* unloads, the Grocer's Warehouse and the
-   * — the Grocer's Warehouse and the Oil Refinery." §9.3's "Passenger Facilities and Freight Houses
+   * Oil Refinery", which made §9.3's "Passenger Facilities and Freight Houses permit cars to move
-   * permit cars to move each direction" therefore names exactly these two, and the engine had both
+   * each direction" name exactly those two. That premise is dead: `glossary.md` and
-   * of them one-way.
+   * `rules-v0.2.md` corrected the Freight House to a card of its own, dealt like any other industry,
+   * so §9.3 names the Freight House and nothing else, and card-reference.md's "Both" column loses
+   * the only argument it had.
    *
-   * The consequence was silent: `usableGrant` drops a Modifier's grant on a direction its host
+   * The card set says the same thing on its own. All three Refinery modifiers — Pipelines, Oil
-   * cannot use, so every +1 inbound beside a Refinery went nowhere.
+   * Depot, Viscosity Breakers — grant `+1 outbound`; a two-way Refinery would be the one industry in
-   *
+   * the game with no way to raise the direction it is supposed to use half its capacity on.
-   * The base numbers stay at the engine's own scale (1 per direction it allows) rather than the card
+   * `StationMaster-Home-Deck-v0.4.5.md` prints it "Outbound, 1 out / 0 in".
-   * reference's 2/2 — every industry here is scaled down the same way, Mine Tipple included, and
-   * raising one of them alone would be a balance change rather than a correction. Flagged in TODO.
    */
-  { kind: 'refinery', name: 'Refinery', carTypes: ['tank'], flow: 'both', baseOut: 1, baseIn: 1, baseLoaders: 1, lockouts: ['powerPlant'], copies: 3 },
+  { kind: 'refinery', name: 'Refinery', carTypes: ['tank'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['powerPlant'], copies: 3 },
   { kind: 'powerPlant', name: 'Power Plant', carTypes: ['hopper', 'tank'], flow: 'inbound', baseOut: 0, baseIn: 1, baseLoaders: 1, lockouts: ['mineTipple', 'refinery'], copies: 6 },
   { kind: 'packingSheds', name: 'Packing Sheds', carTypes: ['reefer'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['grocersWarehouse'], copies: 3 },
   /**
-   * BOTH DIRECTIONS — see the Refinery above; "Grocer's Warehouse | Boxcar | Both | 2 | 2 | 2 | 3".
+   * INBOUND ONLY — the mirror of the Refinery above, and the same correction. Reported from
+   * playtesting and confirmed by Jesse (v0.4.9e): "Grocer's Warehouse should be receive only, does
+   * not ship anything out". `StationMaster-Home-Deck-v0.4.5.md` prints it "Inbound, 0 out / 1 in".
    *
-   * Reported from play: "grocer's warehouse didn't get extra outbound slot for truck dock." It could
+   * THE ICE HOUSE IS THEREFORE A DEAD CARD BESIDE A GROCER'S, and that is the design, not an
-   * not: the Truck Dock printed +1 outbound at the time and this was `flow: 'inbound'`, so the grant
+   * oversight: `usableGrant` drops a Modifier's grant on a direction its host cannot use, and the
-   * was dropped on a direction the facility did not have. The same trap still swallows an Ice House
+   * Home Deck sheet says so outright — "a bonus beside a facility that cannot use its direction is
-   * set beside a Grocer's that has been left one-way.
+   * not usable", naming the Truck Dock's inbound bonus beside the outbound-only Packing Sheds as the
-   *
+   * other example. The Truck Dock (+1 inbound) and Local Small Groceries (+1 Laborer) are the two
-   * `TODO.md` had previously recorded this as "checked, and there is no bug" on the reasoning that a
+   * that do work here.
-   * Grocer's is inbound-only. That premise was the bug.
    */
-  { kind: 'grocersWarehouse', name: "Grocer's Warehouse", carTypes: ['boxcar', 'reefer'], flow: 'both', baseOut: 1, baseIn: 1, baseLoaders: 1, lockouts: ['packingSheds', 'freightHouse'], copies: 3 },
+  { kind: 'grocersWarehouse', name: "Grocer's Warehouse", carTypes: ['boxcar', 'reefer'], flow: 'inbound', baseOut: 0, baseIn: 1, baseLoaders: 1, lockouts: ['packingSheds', 'freightHouse'], copies: 3 },
 ];
 
 /** Legacy alias; the engine still reads FREIGHT_PROFILES in places. */
 export const FREIGHT_PROFILES = INDUSTRY_PROFILES;
 
-/** §9.3 — the collective term for an industry that both loads and unloads. */
+/**
+ * §9.3 — "Passenger Facilities and Freight Houses permit cars to move each direction".
+ *
+ * ONE CARD ANSWERS TO THIS NOW: the Freight House itself. It was briefly three, while the Refinery
+ * and the Grocer's Warehouse were also `both` on a reading of the term the glossary has since
+ * corrected — a Freight House is a card, not a collective noun. Kept as a predicate on `flow`
+ * rather than a comparison against the kind, because it is the DIRECTION §9.3 is talking about.
+ */
 export function isFreightHouse(p: IndustryProfile): boolean {
   return p.flow === 'both';
 }
@@ -278,7 +292,7 @@ export function industryProfile(kind: FreightKind): IndustryProfile {
 }
 
 // ---------------------------------------------------------------------------
-// Modifiers — 17 industry + 6 passenger, each tied to specific hosts
+// Modifiers — passenger and industry, each tied to specific hosts
 // ---------------------------------------------------------------------------
 
 export type ModifierKind =
@@ -347,7 +361,7 @@ export function modifierProfile(kind: ModifierKind): ModifierProfile {
 }
 
 // ---------------------------------------------------------------------------
-// Trains — 22 cards, named, with speed class and individual rules
+// Trains — named, with a speed class and individual printed rules
 // ---------------------------------------------------------------------------
 
 export type TrainSpeed = 'fast' | 'slow';
@@ -411,11 +425,18 @@ function pair(odd: number, name: string, speed: TrainSpeed, consist: ConsistSpec
 }
 
 export const TIMETABLED_TRAINS: readonly TrainProfile[] = [
-  ...pair(1, 'Crack Limited', 'fast', { freight: 0, coach: 3, caboose: 0 },
+  /**
+   * COACH COUNTS ON 1/2 AND 5/6 WERE SWAPPED BY JESSE (Gitea#7, v0.4.9e playtest): the Crack Limited
+   * drops from three coaches to two, and The Sparrow rises from two to three. A change to the card
+   * faces themselves, not a transcription fix — `Trains3.pdf` and the tables that transcribe it
+   * still print the old numbers, so `docs/rules/card-reference.md` is the place that now carries
+   * what the cards say.
+   */
+  ...pair(1, 'Crack Limited', 'fast', { freight: 0, coach: 2, caboose: 0 },
     { terminalsOnly: true, noSwitching: true, expedite: true, note: 'Stop at Terminals only.' }),
   ...pair(3, 'Express', 'fast', { freight: 2, coach: 0, caboose: 0 },
     { oneFreightPerLocation: true, expedite: true, note: 'May drop or pick up one freight car at every location.' }),
-  ...pair(5, 'The Sparrow', 'fast', { freight: 0, coach: 2, caboose: 0 },
+  ...pair(5, 'The Sparrow', 'fast', { freight: 0, coach: 3, caboose: 0 },
     { noSwitching: true, expedite: true }),
   ...pair(7, 'Local', 'slow', { freight: 1, coach: 1, caboose: 0 },
     { coachStaysOnStationTrack: true, note: 'Maximum one freight, one coach.' }),
@@ -443,11 +464,18 @@ export const EXTRA_TRAINS: readonly TrainProfile[] = [
 export const ALL_TRAINS: readonly TrainProfile[] = [...TIMETABLED_TRAINS, ...EXTRA_TRAINS];
 
 /**
- * §2.3 — ODD RUNS WEST, EVEN RUNS EAST. The number is the direction, for an Extra as much as for a
+ * §2.3 — ODD RUNS WEST, EVEN RUNS EAST. The number is the direction for a TIMETABLED train.
- * timetabled train, and the Division Point it starts at is therefore the one it runs away from.
  *
- * Extras print `direction: 'playerChoice'`, which the engine read as "always eastbound from the West
+ * NOT for an Extra any more. Extras print `direction: 'playerChoice'` and now mean it (Jesse's
- * Division Point". Jesse's ruling: the number decides, like everything else on the timetable.
+ * ruling, superseding "the number decides, like everything else on the timetable"): the player who
+ * played the card picks where it starts, and the start decides the direction — a Crew Tray placed
+ * at the Western Division Point runs east and one at the Eastern runs west, because the alternative
+ * is a train that leaves the Division on its first move having crossed nothing. Where the start is
+ * NOT an end of the Division — an Interchange, or a Control Point — both ways are real runs and the
+ * player says which. `resolveExtraStart` in apply.ts is where that happens.
+ *
+ * Still read for an Extra in one place: replaying a save written before the choice existed, where
+ * `newTrain.startExtra` carries only the legacy `atSeat` field.
  */
 export function runDirection(trainNumber: number): Direction {
   return trainNumber % 2 === 0 ? 'east' : 'west';
@@ -476,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
+ * Speed as printed. `60` and `30` appear on the cards; Hilly prints P60/F30, and Heavy Grade prints
- * prints "G" with the player setting orientation.
+ * "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.
@@ -503,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'] },
@@ -518,6 +555,29 @@ export const MAINLINE_PROFILES: readonly MainlineProfile[] = [
   { kind: 'interchange', name: 'Interchange', speed: { kind: 'uniform', value: 60 }, trainsMayPass: false, sortsCars: true, entryPoints: ['start', 'sortCars'] },
 ];
 
+/**
+ * THE MAINLINE DECK AS PRINTED, dealt WITHOUT replacement.
+ *
+ * `MAINLINE_PROFILES` above is a list of card TYPES, one entry each. It is not the deck, and setup
+ * used it as one: `buildDivision` drew uniformly from those types with replacement, which made two
+ * Interchanges (or two Trestles, or two Tunnels) an ordinary outcome and gave Plains the same weight
+ * as everything else although the deck prints two of it. `Mainline Cards.pdf` is the
+ * inventory, transcribed in `docs/StationMaster-Mainline-Deck-v0.4.5.md`, which had already flagged
+ * the mismatch as needing correction.
+ *
+ * It matters more than card flavour now that an Extra may start at an Interchange (§7): "if an
+ * Interchange is on the board" has to mean a card there is at most one of, not a type the deal can
+ * hand out twice.
+ *
+ * The two Division Point cards in that inventory are not here — they are the fixed ends of the
+ * Division, laid by `buildDivision` itself rather than drawn. Plains appears twice because the deck
+ * prints it twice; every other type once. The list below is the deck, so it is not counted here.
+ */
+export const MAINLINE_DECK: readonly MainlineKind[] = [
+  'plains', 'plains', 'curves', 'hilly', 'heavyGrade',
+  'doubleTrack', 'uncontrolledSiding', 'tunnel', 'trestle', 'interchange',
+];
+
 /**
  * How many Stages a train needs to cross a Mainline card.
  *
@@ -613,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
+ * WHICH WAY THE GRADE CLIMBS, AND WHY NO PLAYER CHOOSES 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.
+ * 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,
@@ -684,9 +756,9 @@ export type SimpleCard = {
    * The opponent-directed card this exists SOLELY to answer.
    *
    * A defence with nothing to defend against is a dead draw, exactly as the attack itself would be.
-   * The 22 Space-use and Action cards are held out of every deck until they are implemented (Q6),
+   * The Space-use and Action cards are held out of every deck until they are implemented (Q6), and
-   * and these go with them — named here rather than in a list somewhere else so the pairing is
+   * these go with them — named here rather than in a list somewhere else so the pairing is visible
-   * visible on the card, and so they come back together when their attacker does.
+   * on the card, and so they come back together when their attacker does.
    */
   answers?: string;
 };
@@ -732,39 +804,48 @@ export type EnhancementRule = {
    *                     opponent-directed card that a solitaire deck does not contain (Q6).
    *   - `unbuilt`     — nothing reads it at all. The effect is recorded here and not yet written.
    *
-   * Seven of the ten are live. Each row below cites the file that reads it, because the first
+   * Most are live. Each row below cites the file that reads it — the row is the answer, and no
-   * attempt at this table got FIVE of the ten wrong: it was filled in by grepping for four helper
+   * tally is kept here, because a tally is one more thing to forget when a card is implemented.
-   * function names and reading "no match" as "no implementation", when Interlocking, Yard Office,
+   *
-   * Small Yard and ABS Signals are all read directly by key — and all four are covered by tests in
+   * The first attempt at this table got FIVE of the ten wrong: it was filled in by grepping for four
-   * `enhancements.test.ts` that were passing the whole time. The result was a tooltip telling players
+   * helper function names and reading "no match" as "no implementation", when Interlocking, Yard
-   * that four working cards did nothing, which is worse than the bare label it replaced.
+   * Office, Small Yard and ABS Signals are all read directly by key — and all four are covered by
+   * tests in `enhancements.test.ts` that were passing the whole time. The result was a tooltip
+   * telling players that four working cards did nothing, which is worse than the bare label it
+   * replaced.
    *
    * KEEP THIS HONEST, AND CHECK THE CITATION. Implementing one of these means changing its value in
    * the same commit; otherwise the card goes on apologising for something it now does. It is data
    * rather than something derived because "is this key read anywhere" is not a question the type
-   * system can answer — but a claim here without a file reference beside it is a claim nobody checked.
+   * system can answer — but a claim here without a reference beside it is a claim nobody checked.
+   *
+   * CITE THE FUNCTION, NEVER THE LINE NUMBER. Every one of these rows once carried a `file.ts:NNN`
+   * and every one of them had rotted — `apply.ts:405` for Small Yard was pointing four hundred lines
+   * short by the time anyone looked. A line number is a citation that decays silently on the next
+   * edit anywhere above it, which is the opposite of what this note is for.
    */
   effect: 'live' | 'dormantSolo' | 'unbuilt';
 };
 
 export const ENHANCEMENT_RULES: readonly EnhancementRule[] = [
-  // Holds an arrival at the Limits instead of colliding when the Office is full — advance.ts:770.
+  // Holds an arrival at the Limits instead of colliding when the Office is full — `arriveAtOffice`.
   { key: 'interlocking', placement: 'runningTrackStraight', effect: 'live' },
-  // Wired at apply.ts:1738, but it answers Derail, an Action card the solitaire deck omits (Q6).
+  // Wired in `isProtectedFromDerail`, but it answers Derail, an Action card the solo deck omits (Q6).
   { key: 'facingPointLocks', placement: 'onCard', requiresInDistrict: 'interlocking', effect: 'dormantSolo' },
-  // Diverts a coachless arrival away from the Train Order Office — advance.ts:750.
+  // Diverts a coachless arrival away from the Train Order Office — `arriveAtOffice`.
   { key: 'yardOffice', placement: 'secondaryTrackStraight', effect: 'live' },
-  // Lets a consist be re-ordered for one Move — apply.ts:405.
+  // Lets a consist be re-ordered for one Move — `check`'s `switch.sortConsist` case.
   { key: 'smallYard', placement: 'secondaryTrackStraight', effect: 'live' },
-  // Wired at apply.ts:1743, but it removes a Watertower, a Space-use card the solo deck omits.
+  // Wired in `watertowersRemovable`, but it removes a Watertower, a Space-use card the solo deck omits.
   { key: 'waterColumn', placement: 'runningTrackStraight', effect: 'dormantSolo' },
   // The only one with NO code path at all: nothing anywhere reads `overpass`.
   { key: 'overpass', placement: 'onCard', effect: 'unbuilt' },
   { key: 'telegraph', placement: 'runningTrackStraight', dispatchBonus: 4, effect: 'live' },
   { key: 'telephone', placement: 'onCard', requiresOnSameCard: 'telegraph', dispatchBonus: 8, effect: 'live' },
   { key: 'radio', placement: 'onCard', requiresOnSameCard: 'telephone', dispatchBonus: 12, effect: 'live' },
-  // Stored on the Mainline node rather than in `enhancements[]` — apply.ts:1461, read at
+  // Stored on the Mainline node rather than in `enhancements[]` — written by `reduce`'s
-  // advance.ts:599 (no rear-ending) and advance.ts:721 (the follower holds instead of being ruled on).
+  // `enhancementPlaced`, read in `moveTrain` (no rear-ending) and `evaluateClearance` (the follower
+  // holds instead of being ruled on).
   { key: 'absSignals', placement: 'mainlineCard', effect: 'live' },
 ];
 
@@ -855,11 +936,15 @@ export type StockSupply = { type: CarType; loaded: number; empty: number };
 /**
  * NOT in the recovered files — still the provisional figure.
  *
- * Scaled up alongside the Gap 12 industry increase. Worst-case demand (every copy of every
+ * Scaled up alongside the Gap 12 industry increase. The rule it was set by, rather than the numbers
- * industry in play at full capacity) is boxcar 15, hopper 12, tank 9, reefer 6; the supply must
+ * it produced: worst-case demand for a car type is every copy of every industry that uses it, in
- * cover that, since a Division Yard that runs dry starves the freight loop the increase exists to
+ * play at full capacity, and the supply must cover that — a Division Yard that runs dry starves the
- * feed. Lockouts and district size mean the worst case cannot actually occur, so this carries
+ * freight loop the increase exists to feed. Lockouts and district size mean the worst case cannot
- * deliberate headroom.
+ * actually occur, so this carries deliberate headroom. RE-DERIVE IT FROM `INDUSTRY_PROFILES`
+ * whenever industry copies move; a figure written here would not survive the next retune.
+ *
+ * Coaches are the type this rule does NOT cover, because no industry asks for one — their demand
+ * comes from passenger work, and Gitea#2 is the open report that the supply is short (see TODO.md).
  */
 export const ROLLING_STOCK_SUPPLY: readonly StockSupply[] = [
   { type: 'coach', loaded: 8, empty: 8 },
@@ -893,11 +978,11 @@ export const STAGES_PER_SHIFT = 3;
 export const HAND_LIMIT = 3;
 
 /**
- * The split opening deal: 3 track cards and 3 others, from two separately shuffled piles
+ * The split opening deal — track cards and others, from two separately shuffled piles (`setup.ts`).
- * (`setup.ts`). One of the three `StartingHand` options below, not the only one any more.
+ * One of the three `StartingHand` options below, not the only one any more.
  *
- * Six against a limit of three on purpose — the first turn is spent choosing which district you can
+ * Deliberately over the hand limit: the first turn is spent choosing which district you can afford
- * afford to build.
+ * to build. The two constants below are the deal.
  */
 export const OPENING_TRACK = 3;
 export const OPENING_OTHER = 3;
@@ -931,10 +1016,16 @@ export const OPENING_DEALS: Readonly<Record<StartingHand, { any: number; track:
 /**
  * WHAT THE THREE WORKING ECONOMIES PAY.
  *
- * Balance is the open problem in this game — the developer bot averages 7.0 Revenue against a target
+ * Balance is the open problem in this game, and the way to settle it is to play it at several
- * of 20, of which most came from traffic nobody had to work — and the way to settle it is to play it
+ * settings rather than to keep re-deriving it. So the three rates are dials, set when the game is
- * at several settings rather than to keep re-deriving it. So the three rates are dials, set when the
+ * dealt and fixed for its duration.
- * game is dealt and fixed for its duration.
+ *
+ * DO NOT WRITE A CURRENT BALANCE FIGURE HERE. This said "the developer bot averages 7.0 Revenue
+ * against a target of 20" long after that stopped being true: 7.0 was measured while
+ * `trainPerTransit` still defaulted to 1, and the paragraph below explains that this very setting
+ * was then defaulted to 0 for being worth ~5.4 of it. Re-measured 2026-08-22 over 400 games at the
+ * current defaults, the developer bot means about ZERO. Run `node src/sim/harness.ts 400 standard`
+ * for today's number rather than trusting one written here.
  *
  * `passengerPerCoach` and `freightPerLoad` each pay on BOTH halves of their cycle: a coach pays when
  * it is boarded and again when it is detrained, a load pays when it is made up outbound and again
@@ -951,10 +1042,53 @@ export type RevenueRules = {
   trainPerTransit: number;
 };
 
-export type HouseRules = { startingHand: StartingHand; revenue: RevenueRules };
+/**
+ * WHERE AN EXTRA MAY BE STARTED — a setting, because the table disagrees about it.
+ *
+ * §7 gives an Extra "either Division Point", and Jesse's ruling adds the Interchange to that base
+ * set: both are places on the shared Division that belong to nobody, so neither favours a seat.
+ * Starting one inside a player's own district is the part that does, which is what this dials.
+ *
+ * - `divisionPointsOnly` — the Division Points and the Interchange. No Office start at all.
+ * - `ownOffice` — those, plus a Control Point in the district of the player who played the card.
+ * - `anyOffice` — those, plus a Control Point in ANY player's district.
+ *
+ * A Whistle Post never qualifies however this is set: an Office has to be a Control Point to start
+ * an Extra, which is part of what upgrading buys (§11).
+ */
+export type ExtraStartRule = 'divisionPointsOnly' | 'ownOffice' | 'anyOffice';
+
+export type HouseRules = {
+  startingHand: StartingHand;
+  revenue: RevenueRules;
+  extraStart: ExtraStartRule;
+  /**
+   * §6.2 — MAY A TIMETABLED TRAIN BE THROWN AWAY? (Gitea#9, superseding Gitea#6.)
+   *
+   * Jesse: "Timetabled trains are at the choice of the player — they can either play or discard. If
+   * someone else wants to pick it up, they are more than able to. The reason: I don't want, if you
+   * decide to play a game longer than five days, to decide that maybe there are too many trains, the
+   * stations are jammed, and the railroad doesn't need any more. You can toss it. Someone else might
+   * disagree and pick it up."
+   *
+   * A setting rather than a flat rule because Jesse asked for it as one — the reasoning above is
+   * about LONG games, and a five-Day game may well want the pressure Gitea#6 created. Discarding
+   * puts the card face-up on a Department pile, so "someone else might pick it up" needs no
+   * machinery of its own: that is where every discard already goes.
+   *
+   * AN EXTRA IS NEVER DISCARDED WHATEVER THIS SAYS. Gitea#9 is about the timetable filling up, and
+   * an Extra never joins it — it runs once and ends in the Salvage Yard, so it cannot jam anything.
+   */
+  discardTimetabled: boolean;
+};
 
 /** What a caller may name — any subset, down to none — resolved by `houseRules()`. */
-export type HouseRuleOverrides = { startingHand?: StartingHand; revenue?: Partial<RevenueRules> };
+export type HouseRuleOverrides = {
+  startingHand?: StartingHand;
+  revenue?: Partial<RevenueRules>;
+  extraStart?: ExtraStartRule;
+  discardTimetabled?: boolean;
+};
 
 /** The dialog's range. Zero is a real setting: it switches an economy off so the others can be read. */
 export const REVENUE_MIN = 0;
@@ -963,6 +1097,14 @@ export const REVENUE_MAX = 5;
 export const DEFAULT_HOUSE_RULES: HouseRules = {
   startingHand: 'threeRandom',
   revenue: { passengerPerCoach: 1, freightPerLoad: 1, trainPerTransit: 0 },
+  // `anyOffice` is what the engine did before the setting existed, so a game dealt without naming
+  // it plays the way it always has. Jesse's call, so the 0.4.9 playtest line does not change under
+  // its testers in the middle of a bugfix release.
+  extraStart: 'anyOffice',
+  // Gitea#9's ruling is the default, so a game dealt without naming it plays the rule Jesse most
+  // recently gave rather than the one it replaced. This keeps main and the 0.4.9 playtest line —
+  // which has no setting and simply allows it — playing the same game.
+  discardTimetabled: true,
 };
 
 /**
@@ -977,6 +1119,11 @@ export const DEFAULT_HOUSE_RULES: HouseRules = {
 export const LEGACY_HOUSE_RULES: HouseRules = {
   startingHand: 'threeTrackThreeOther',
   revenue: { passengerPerCoach: 1, freightPerLoad: 1, trainPerTransit: 1 },
+  // An Extra could always be started at a Control Point in these games, in any district.
+  extraStart: 'anyOffice',
+  // These games predate Gitea#6 as well as Gitea#9: a train card could simply be discarded. `true`
+  // is what they were played under, and a replay that discards a Timetabled train needs it.
+  discardTimetabled: true,
 };
 
 /** A whole, valid rule set from a config that may carry none, some, or out-of-range values. */
@@ -995,6 +1142,8 @@ export function houseRules(config: { houseRules?: HouseRuleOverrides }): HouseRu
       freightPerLoad: clamp(rev.freightPerLoad, d.revenue.freightPerLoad),
       trainPerTransit: clamp(rev.trainPerTransit, d.revenue.trainPerTransit),
     },
+    extraStart: given.extraStart ?? d.extraStart,
+    discardTimetabled: given.discardTimetabled ?? d.discardTimetabled,
   };
 }
 
@@ -1004,6 +1153,12 @@ export const STARTING_HAND_LABELS: readonly { value: StartingHand; label: string
   { value: 'sixRandom', label: 'Six random cards' },
   { value: 'threeTrackThreeOther', label: 'Three random track and three random non-track cards' },
 ];
+/** What the dialog calls each `ExtraStartRule`, in the order it offers them. */
+export const EXTRA_START_LABELS: readonly { value: ExtraStartRule; label: string }[] = [
+  { value: 'divisionPointsOnly', label: 'Division Points and the Interchange only' },
+  { value: 'ownOffice', label: 'Also the playing player\u2019s own Control Point' },
+  { value: 'anyOffice', label: 'Also any player\u2019s Control Point' },
+];
 export const MAX_CONSIST = 4;
 export const MOVES_PER_LOCAL_OPS = 6;
 export const MOVES_PER_LOCAL_OPS_NIGHT = 5;
@@ -1056,7 +1211,8 @@ export function lengthProfile(length: GameLength): LengthProfile {
 
 /**
  * Cards that can only be played AT another player (Q6). In a solitaire game they have no legal
- * target, so they are removed from the deck rather than sitting in hand as 19% dead draws.
+ * target, so they are removed from the deck rather than sitting in hand as dead draws — which, when
+ * this was written, was very nearly a fifth of the deck.
  */
 export const OPPONENT_ONLY_CATEGORIES: readonly string[] = ['spaceUse', 'action'];
 
@@ -1064,8 +1220,10 @@ export function isOpponentOnly(category: string): boolean {
   return OPPONENT_ONLY_CATEGORIES.includes(category);
 }
 
-/** How many cards `DEFENCE_ONLY_CARDS` accounts for — 7: two Facing Point Locks of each kind, two
+/**
- * Water Columns and one Overpass. */
+ * How many cards `DEFENCE_ONLY_CARDS` accounts for. Summed from the rows rather than written down:
+ * which cards qualify is `SimpleCard.answers`, and the total moves whenever one is added.
+ */
 export const DEFENCE_ONLY_COPIES =
   ENHANCEMENT_CARDS.filter((c) => c.answers).reduce((n, c) => n + c.copies, 0) +
   MAINLINE_MODIFIER_CARDS.filter((c) => c.answers).reduce((n, c) => n + c.copies, 0);
@@ -1088,17 +1246,19 @@ export function deckComposition(): { category: string; count: number }[] {
 
 /**
  * The whole CATALOGUE, including cards not currently dealt. Not the size of any deck in play — see
- * `DEALT_DECK_SIZE`, which is what `buildDeck` actually returns.
+ * `SOLITAIRE_DECK_SIZE` below, which is what `buildDeck` actually deals. (This pointed at a
+ * `DEALT_DECK_SIZE` that has never existed.)
  */
 export const DECK_SIZE = deckComposition().reduce((n, c) => n + c.count, 0);
 
 /**
- * The deck actually dealt, in every mode: the catalogue less the 22 opponent-directed cards.
+ * The deck actually dealt, in every mode: the catalogue less the opponent-directed cards, less the
+ * defensive cards that exist only to answer them.
  *
  * Named for solitaire because Q6 dropped them there first, and kept under that name because the
  * number is the same either way. They are out of the competitive deck too until they are
- * implemented — `checkPlay` answers both categories NOT_IMPLEMENTED, so dealing them would make ~9%
+ * implemented — `checkPlay` answers both categories NOT_IMPLEMENTED, so dealing them would make a
- * of draws reject. See `buildDeck`.
+ * meaningful share of draws reject outright. See `buildDeck`.
  */
 export const SOLITAIRE_DECK_SIZE =
   deckComposition()

src/engine/events.ts

@@ -19,8 +19,8 @@
  * reconstruct the whole board to draw one frame.
  */
 
-import type { CarType, OfficeTier } from './content.ts';
+import type { CarType, Direction, OfficeTier } from './content.ts';
-import type { LocalOpsOption } from './intents.ts';
+import type { ExtraStart, LocalOpsOption } from './intents.ts';
 import type { CardId, GridCoord, PlayerIndex, RollingStock, SeatIndex, TrayId } from './state.ts';
 
 export type GameEvent =
@@ -156,15 +156,34 @@ export type GameEvent =
    */
   | { type: 'trainCompleted'; trainNumber: number; isExtra: boolean; side: 'east' | 'west'; consist: RollingStock[] }
   /** An Extra took a Crew Tray and started its run — at a Division Point, or at a Control Point. */
-  | { type: 'extraStarted'; player: PlayerIndex; trainNumber: number; atSeat: SeatIndex | null }
+  /**
+   * Carries the RESOLVED start and direction (`resolveExtraStart`), not the raw intent fields, so
+   * the reducer never re-answers a question `check` already answered — the same shape as
+   * `passengersBoarded` carrying its tray and coach index.
+   */
+  | {
+      type: 'extraStarted';
+      player: PlayerIndex;
+      trainNumber: number;
+      at: ExtraStart;
+      direction: Direction;
+    }
   | { type: 'carPlacedOnTrain'; player: PlayerIndex; trayId: TrayId; stock: RollingStock }
   | { type: 'carPassed'; player: PlayerIndex; trayId: TrayId }
   | { type: 'dispatchBonusUsed'; key: string; bonus: number; trainNumber: number; againstTrain: number }
   | { type: 'clearanceRequested'; trainId: TrayId; occupiedBy: TrayId }
   | { type: 'clearanceGiven'; trainId: TrayId; allow: boolean }
   // -- load / unload
-  | { type: 'passengersBoarded'; player: PlayerIndex; at: GridCoord }
+  /**
-  | { type: 'passengersDetrained'; player: PlayerIndex; at: GridCoord }
+   * `trayId` and `coachIndex` name the TRAIN and the COACH the Porter worked, rather than leaving the
+   * reducer to find them again — the same lesson as `unloadBegan`'s `carIndex` below. Re-deriving
+   * "the first empty coach on the first train at the Office" is how two trains standing at one
+   * station both answered to one roster chip (v0.4.9d playtest), and how a coach the player had not
+   * chosen got filled. Required, not optional: an event is a fact, and a fact that has to be looked
+   * up against live state cannot render standalone in a replay.
+   */
+  | { type: 'passengersBoarded'; player: PlayerIndex; at: GridCoord; trayId: TrayId; coachIndex: number }
+  | { type: 'passengersDetrained'; player: PlayerIndex; at: GridCoord; trayId: TrayId; coachIndex: number }
   | { type: 'loadStarted'; player: PlayerIndex; at: GridCoord; carType: CarType }
   | { type: 'loadAdvanced'; player: PlayerIndex; at: GridCoord; fromBox: number; toBox: number }
   | { type: 'unloadCompleted'; player: PlayerIndex; at: GridCoord; carType: CarType }

src/engine/intents.ts

@@ -13,6 +13,17 @@ import type { CardId, GridCoord, PlayerIndex, SeatIndex, TrayId } from './state.
 
 export type LocalOpsOption = 'switch' | 'draw' | 'freightAgent';
 
+/**
+ * Where an Extra is placed when it is started (§7).
+ *
+ * `mainline` names a node index in `division.nodes` and is only ever an Interchange; `office` names
+ * a SEAT, which is what an Office Area belongs to, and only ever a Control Point.
+ */
+export type ExtraStart =
+  | { kind: 'divisionPoint'; side: Direction }
+  | { kind: 'mainline'; node: number }
+  | { kind: 'office'; seat: SeatIndex };
+
 export type Intent =
   | { type: 'localOps.choose'; option: LocalOpsOption }
   // -- switch (§6.1, Appendix A)
@@ -74,12 +85,31 @@ export type Intent =
   | { type: 'newTrain.placeCar'; trayId: TrayId; carType: CarType; loaded: boolean }
   | { type: 'newTrain.passCar'; trayId: TrayId }
   /**
-   * §7 — "the player who played the card may place the Crew Tray in either division point for
+   * §7 — "the player who played the card may place the Crew Tray at EITHER Division Point for
-   * immediate departure", extended by Jesse: an Extra starts at the Division Point its NUMBER sends
+   * immediate departure", plus Jesse's ruling on where else and which way.
-   * it to (odd runs west, even east, exactly as a timetabled train), or at any Control Point — any
+   *
-   * Office above a Whistle Post — at the player's choice. `atSeat` null means the Division Point.
+   * The number does not decide an Extra's direction — the START does. Either Division Point may be
+   * chosen and the train runs away from it (west end runs east, east end runs west, since the other
+   * reading is a train that leaves the Division having crossed nothing). At an Interchange or a
+   * Control Point, which are in the middle of the railroad, both ways are real runs and `direction`
+   * says which; it is required there and ignored at a Division Point.
+   *
+   * WHICH STARTS ARE OFFERED is the `extraStart` house rule (content.ts) — Division Points and the
+   * Interchange always, Offices by setting.
+   *
+   * `atSeat` IS LEGACY AND WRITE-ONCE. Saves written before this choice existed carry only that
+   * field: `null` meant "the Division Point this train's number sends it to" and a seat meant that
+   * Office, both running in the number's direction. `start` absent is exactly what those saves said,
+   * so they replay unchanged; everything written from now on carries `start` and `atSeat` is
+   * omitted. `resolveExtraStart` (apply.ts) is the single place that reads either.
    */
-  | { type: 'newTrain.startExtra'; trainNumber: number; atSeat: SeatIndex | null }
+  | {
+      type: 'newTrain.startExtra';
+      trainNumber: number;
+      atSeat?: SeatIndex | null;
+      start?: ExtraStart;
+      direction?: Direction;
+    }
   /** Q9 — run a second, identical section behind a train that is due out this Stage. */
   | { type: 'newTrain.secondSection'; trainNumber: number }
   // -- Mainline Phase (§8.1) — the Superintendent's clearance ruling
@@ -101,8 +131,18 @@ export type Intent =
   | { type: 'maneuver.flyingSwitch'; cardId: CardId; trayId: TrayId; count: number; to: GridCoord }
   | { type: 'redFlag.play' }
   // -- Load/Unload Phase (§9)
-  | { type: 'porter.board'; at: GridCoord }
+  /**
-  | { type: 'porter.detrain'; at: GridCoord }
+   * `trayId` names the train the Porter works — reported from playtesting v0.4.9d as "operating two
+   * trains in a station, the select button does not work: regardless of which you pick, it is always
+   * one train, not the other". It was: neither intent carried a train, so the reducer took the first
+   * one on the A/D tracks and the roster chip the player had clicked changed nothing but the drawing.
+   *
+   * OPTIONAL, like `switch.move`'s `via` and for the same reason: intents are the canonical record
+   * `undo` and every save replay against, and absent means what it has always meant — the first
+   * eligible train at the Office.
+   */
+  | { type: 'porter.board'; at: GridCoord; trayId?: TrayId }
+  | { type: 'porter.detrain'; at: GridCoord; trayId?: TrayId }
   /** §9.3 — the first Laborer step: Green Loading Slot -> MEN. */
   | { type: 'laborer.startLoad'; at: GridCoord }
   | { type: 'laborer.advanceLoad'; at: GridCoord; box: number }
@@ -199,6 +239,17 @@ export type RejectionCode =
    * the Laborers can move it out of the box.
    */
   | 'NO_EMPTY_CAR_SPOTTED'
+  /**
+   * §9 (Jesse's ruling, v0.4.9e) — freight or passengers loaded anywhere in an Office Area may not
+   * be unloaded anywhere in that same Office Area. The load has to be carried out of the district by
+   * a train first; a Freight House may not break the load it just made, and passengers may not
+   * detrain at the platform they boarded from.
+   *
+   * Distinct from the other refusals because the car IS loaded, the Laborer IS free and the boxes
+   * ARE clear: the only thing wrong with it is where it came from, and a player looking at a loaded
+   * boxcar standing on their own industry track deserves to be told that rather than "wrong car".
+   */
+  | 'LOADED_IN_THIS_DISTRICT'
   | 'NO_PORTERS_HERE'
   | 'NO_PASSENGERS_WAITING'
   | 'NO_EMPTY_COACH'
@@ -207,8 +258,25 @@ 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';
+  | 'NO_FREE_AD_TRACK'
+  // -- §7, where an Extra may be started (`resolveExtraStart`)
+  | 'NO_SUCH_DIVISION_POINT'
+  /** Only the Interchange has a yard an Extra can be made up in. */
+  | 'NOT_AN_INTERCHANGE'
+  /** In the middle of the railroad both ways are real runs, so the intent has to say which. */
+  | 'NO_DIRECTION_CHOSEN'
+  /** The `extraStart` house rule is `divisionPointsOnly`. */
+  | 'OFFICE_STARTS_NOT_ALLOWED'
+  /** The `extraStart` house rule is `ownOffice` and this is somebody else's district. */
+  | 'NOT_YOUR_OFFICE'
+  /**
+   * §6.2, Jesse's ruling (Gitea#6) — a train card is never discarded. Hold it as long as you like;
+   * the only way it leaves your hand is onto the timetable.
+   */
+  | 'TRAINS_ARE_NEVER_DISCARDED';
 
 export type Rejection = { code: RejectionCode; message: string };
 

src/engine/legal.ts

@@ -13,7 +13,7 @@
  */
 
 import type { CarType, Hand, TrackGeometry } from './content.ts';
-import { enhancementRule } from './content.ts';
+import { enhancementRule, mainlineProfile } from './content.ts';
 import { check, areaOf, destinationsFor } from './apply.ts';
 import type { Intent } from './intents.ts';
 import type { GameState, GridCoord, PlayerIndex } from './state.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) {
@@ -271,14 +271,30 @@ function newTrainCandidates(s: GameState): Intent[] {
     out.push({ type: 'newTrain.secondSection', trainNumber: due });
   }
   /**
-   * Where a pending Extra starts: its own Division Point, decided by its number, or any Control
+   * WHERE A PENDING EXTRA MAY START (§7, Jesse's ruling) — every candidate offered, with `check`
-   * Point. `check` refuses a Whistle Post and a full Office, so every seat is offered and the rules
+   * doing the filtering, so "is this a Control Point" and "does the house rule allow it" have one
-   * do the filtering — one implementation of "is this a Control Point", not two.
+   * implementation each rather than two.
+   *
+   * BOTH Division Points, not the one the number dictates: an Extra's direction comes from where it
+   * 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
-    out.push({ type: 'newTrain.startExtra', trainNumber, atSeat: null });
+  // 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 } });
+    }
+    for (const [node, n] of s.division.nodes.entries()) {
+      if (n.kind !== 'mainline' || !mainlineProfile(n.card).sortsCars) continue;
+      for (const direction of ['west', 'east'] as const) {
+        out.push({ type: 'newTrain.startExtra', trainNumber, start: { kind: 'mainline', node }, direction });
+      }
+    }
     for (const seat of s.officeAreas.keys()) {
-      out.push({ type: 'newTrain.startExtra', trainNumber, atSeat: seat });
+      for (const direction of ['west', 'east'] as const) {
+        out.push({ type: 'newTrain.startExtra', trainNumber, start: { kind: 'office', seat }, direction });
+      }
     }
   }
   return out;
@@ -288,9 +304,21 @@ function loadUnloadCandidates(s: GameState, player: PlayerIndex): Intent[] {
   const out: Intent[] = [];
   const area = areaOf(s, player);
 
+  /**
+   * ONE OPTION PER TRAIN STANDING AT THE OFFICE, not one per square.
+   *
+   * Reported from playtesting v0.4.9d: "operating two trains in a station, the select button does
+   * not work — regardless of which you pick, it is always one train, not the other". There was only
+   * ever ONE `board passengers` button, because the intent carried no train; the roster chip chose
+   * what the board drew and nothing else. Now each eligible train is its own candidate, and `check`
+   * filters the ones whose card, consist or passengers rule them out.
+   */
+  const traysHere = area.adOccupancy.filter((id) => s.trays.has(id));
   for (const coord of facilityCoords(s, player)) {
-    out.push({ type: 'porter.board', at: coord });
+    for (const trayId of traysHere) {
-    out.push({ type: 'porter.detrain', at: coord });
+      out.push({ type: 'porter.board', at: coord, trayId });
+      out.push({ type: 'porter.detrain', at: coord, trayId });
+    }
     const f = area.grid.get(`${coord.row},${coord.col}`)?.facility;
     if (f) {
       out.push({ type: 'laborer.startLoad', at: coord });

src/engine/setup.ts

@@ -17,7 +17,7 @@ import {
   MODIFIER_PROFILES,
   OFFICE_PROFILES,
   OPENING_DEALS,
-  MAINLINE_PROFILES,
+  MAINLINE_DECK,
   houseRules,
   mainlineProfile,
   TRACK_CARDS,
@@ -224,11 +224,27 @@ function buildPassengerFacility(tier: Parameters<typeof officeProfile>[0]): NonN
  * placed between each player"), which is what gives the Division its terrain and therefore its
  * crossing times.
  */
+/**
+ * THE MAINLINE CARDS ARE DEALT FROM A DECK, NOT ROLLED.
+ *
+ * `MAINLINE_PROFILES` is a list of card TYPES and this drew from it uniformly WITH replacement, so
+ * a Division could be handed two Interchanges or two Tunnels, and Plains — printed twice in the
+ * deck — carried the same weight as cards printed once. `MAINLINE_DECK` is the printed inventory
+ * (`docs/StationMaster-Mainline-Deck-v0.4.5.md`, which flagged this as needing correction), and the
+ * deal is now a deal: take cards out of it and do not put them back.
+ *
+ * The Extra-start rules are what forced the issue. "An Extra may start at the Interchange if one is
+ * on the board" only reads as a rule if the board can hold at most one.
+ *
+ * A Division needs `players + 1` cards, so four players draw five from ten and the deck is never
+ * close to exhausted; the throw is there because a silent short Division would be very hard to see.
+ */
 function buildDivision(players: number, rng: Rng): DivisionNode[] {
   const nodes: DivisionNode[] = [];
-  const kinds = MAINLINE_PROFILES.map((m) => m.kind);
+  const deck = [...MAINLINE_DECK];
   const mainline = (): DivisionNode => {
-    const card = kinds[rng.nextInt(kinds.length)]!;
+    if (deck.length === 0) throw new Error('the Mainline deck ran out — too many players for it');
+    const card = deck.splice(rng.nextInt(deck.length), 1)[0]!;
     const node: DivisionNode = { kind: 'mainline', card, transits: [] };
     if (mainlineProfile(card).speed.kind === 'grade') {
       /**
@@ -238,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

@@ -55,7 +55,47 @@ export function coordKey(c: GridCoord): string {
 // ---------------------------------------------------------------------------
 
 /** §2.2 — a coloured car is loaded, a white car is empty. */
-export type RollingStock = { type: CarType; loaded: boolean };
+export type RollingStock = {
+  type: CarType;
+  loaded: boolean;
+  /**
+   * WHICH OFFICE AREA MADE THIS LOAD — the physical game's chip turned upside down in the tray.
+   *
+   * Reported from playtesting v0.4.9d as two bugs with one cause: a boxcar loaded at a Freight
+   * House could be unloaded at that same Freight House on the next Laborer action, and passengers
+   * who had just boarded could be detrained again before the train turned a wheel. Both paid full
+   * Revenue at each end for a load that never went anywhere.
+   *
+   * Jesse's rule (v0.4.9e): freight or passengers loaded anywhere in an Office Area may not be
+   * unloaded ANYWHERE in that same Office Area — not at another facility, not in a later Stage.
+   * They have to be carried by a train to a different Office Area. So the stamp is the SEAT, which
+   * is what an Office Area belongs to (Employee Rotation moves players between chairs; the district
+   * stays with the chair), and it never expires.
+   *
+   * A SEAT, NOT A PLAYER, and undefined rather than -1 for "no origin": the Division Yard opens with
+   * loaded cars and loaded coaches that were made up off-Division (`ROLLING_STOCK_SUPPLY`), and
+   * those are exactly the inbound traffic a solitaire district lives on. A sentinel inside
+   * `SeatIndex`'s own value range is not a sentinel — see `card.play`'s `node` in intents.ts.
+   *
+   * Stripped by `pooled` whenever a car goes back to a yard: the stamp belongs to the LOAD, and a
+   * car returning to the common supply is carrying nothing.
+   */
+  origin?: SeatIndex;
+};
+
+/**
+ * A car returning to the common pool — the Division or Classification Yard — with its load's origin
+ * stamp taken off.
+ *
+ * Every yard push goes through this. A loaded car CAN reach a yard still loaded (a train retires at
+ * a Division Point with freight aboard, `advance.ts`), and without this it would carry a stamp from
+ * a district it left several Days ago into whatever train is made up from it next.
+ */
+export function pooled(car: RollingStock): RollingStock {
+  if (car.origin === undefined) return car;
+  const { origin: _origin, ...rest } = car;
+  return rest;
+}
 
 // ---------------------------------------------------------------------------
 // Track and Office Area
@@ -314,6 +354,32 @@ export type CrewTray = {
   /** null while a local crew is switching without a train card. */
   trainNumber: number | null;
   trainIsExtra: boolean;
+  /**
+   * STILL BEING ASSEMBLED, somewhere that is not a Division Point.
+   *
+   * `isBeingMadeUp` used to read the position alone — "standing at a Division Point" — which was
+   * true of every train being built when the only place to build one WAS a Division Point. An Extra
+   * may now be started at a Control Point or in an Interchange's yard (§7), and those trains could
+   * not be given a consist at all: they ran empty, and so did every Control Point Extra since that
+   * option was added. Jesse's report says it plainly — an Extra started at the Interchange "would be
+   * loaded with cars".
+   *
+   * Set when such an Extra is placed and cleared the moment it starts running (`enterMainline`), so
+   * it names a train that is being made up rather than one that merely happens to be standing
+   * somewhere. That distinction is load-bearing: a train that ARRIVED at an Office must never be
+   * fillable from the Division Yard, which is the "cars appearing on a train nobody was making up"
+   * 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`.
    *
@@ -430,6 +496,20 @@ export type DivisionNode =
       kind: 'mainline';
       card: MainlineKind;
       transits: Transit[];
+      /**
+       * TRAINS STANDING IN THE INTERCHANGE'S YARD — not out on the running line.
+       *
+       * Only an Interchange ever has these. An Extra started there (§7, Jesse's ruling) is made up
+       * in the yard beside the Mainline, which is why placing it can never be a collision however
+       * busy the card is: it is not on the road yet. It highballs onto this same card at a later
+       * Mainline Phase, through the ordinary §8.1 clearance check — held automatically against a
+       * facing train, put to the Superintendent against a following one — and becomes a `Transit`
+       * at that moment, exactly like a train leaving a Division Point.
+       *
+       * A tray listed here has `position.at === 'mainline'` with this node's index and NO entry in
+       * `transits`. That pair is what distinguishes standing from crossing.
+       */
+      holding?: TrayId[];
       absSignals?: boolean;
       /** Brakeman / Airbrakes / Helpers / Realignment laid on this card. */
       modifiers?: string[];
@@ -760,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/board-svg.ts

@@ -196,15 +196,30 @@ export function divisionSvg(nodes: DivisionView[], roster?: DivisionRoster | nul
       continue;
     }
     const dp = n.kind === 'dp';
+    /**
+     * A train in the Interchange's yard is drawn on the card but counted against nothing.
+     *
+     * It is not on the running line — that is the whole distinction §7 rests on — so it cannot take
+     * the card's capacity. It still has to be SEEN: an Extra made up here would otherwise be a train
+     * the player just placed that appears nowhere on the map.
+     */
+    const inYard = n.yard ?? [];
+    const onRoad = n.trains.flat();
+    const free = n.capacity === null ? '' : `${Math.max(0, n.capacity - onRoad.length)} of ${n.capacity} free`;
     push({
       kind: dp ? 'dp' : 'ml',
       label: n.label,
-      sub: n.capacity === null ? 'no limit — trains queue' : `${Math.max(0, n.capacity - n.trains.flat().length)} of ${n.capacity} free`,
+      sub: n.capacity === null
-      trains: n.trains.flat(),
+        ? 'no limit — trains queue'
+        : [free, inYard.length > 0 ? `${inYard.length} in the yard` : ''].filter(Boolean).join(' · '),
+      trains: [...onRoad, ...inYard],
       cap: n.capacity,
       tip: dp
         ? 'A Division Point — the end of the line. Trains both enter and leave the Division here (odd numbers run west, even run east), and queue without limit'
         : `${n.label} — Mainline${n.gradeUp ? `, climbs ${n.gradeUp === 'east' ? 'east' : 'west'}` : ''}${n.modifiers.length ? ` · ${n.modifiers.join(' · ')}` : ''}` +
+          (inYard.length > 0
+            ? `\n\n${inYard.length} train${inYard.length === 1 ? '' : 's'} standing in the yard, not on the running line — waiting to highball onto this card`
+            : '') +
           // What the card actually DOES. The name alone left Hilly and Uncontrolled Siding as
           // words with no gameplay attached — reported exactly that way.
           (n.what ? `\n\n${n.what}` : ''),

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

@@ -17,8 +17,8 @@
 
 import { MAX_CONSIST } from '../engine/content.ts';
 import { adTrackCount, coordKey, seatOf, turnOf } from '../engine/state.ts';
-import type { GameState, GridCoord, PlayerIndex, RollingStock, TrayId } from '../engine/state.ts';
+import type { GameState, GridCoord, PlayerIndex, RollingStock, SeatIndex, TrayId } from '../engine/state.ts';
-import { areaOf, canAdvanceLoad, canStartLoad, facilityCarType, facilityCarTypes, laborersLeft, movesFor, portersLeft } from '../engine/apply.ts';
+import { areaOf, canAdvanceLoad, canBoard, canDetrain, canStartLoad, facilityCarType, facilityCarTypes, laborersLeft, movesFor, passengerRefusal, portersLeft } from '../engine/apply.ts';
 import type { GameEvent } from '../engine/events.ts';
 
 // ---------------------------------------------------------------------------
@@ -34,11 +34,20 @@ export function clockTime(stage: number): string {
   return CLOCK[stage - 1] ?? `Stage ${stage}`;
 }
 
-export function carLabel(c: RollingStock): string {
+/**
+ * `homeSeat` is the district the page is being drawn for. Give it, and a load THIS district made
+ * says so — the printed game's answer is to turn the chip upside down in the tray, and this is the
+ * screen's. A load may not be broken in the Office Area that made it (state.ts `RollingStock.origin`),
+ * so "loaded here" is the difference between a boxcar worth switching and one that has to leave the
+ * district first. Omit it and the label is what it always was, which is what the replay viewers and
+ * the history lines want: they describe a board, not a seat's view of one.
+ */
+export function carLabel(c: RollingStock, homeSeat?: SeatIndex): string {
   // A caboose carries the crew, not freight, so "loaded caboose" is nonsense on the page even
   // though the supply marks every caboose loaded. Name it plainly.
   if (c.type === 'caboose') return 'caboose';
-  return `${c.loaded ? 'loaded' : 'empty'} ${c.type}`;
+  const label = `${c.loaded ? 'loaded' : 'empty'} ${c.type}`;
+  return homeSeat !== undefined && c.origin === homeSeat ? `${label} (loaded here)` : label;
 }
 
 export function carsLabel(cars: RollingStock[]): string {
@@ -258,16 +267,33 @@ 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`,
       };
-    case 'extraStarted':
+    /**
+     * WHERE THE PLAYER PUT IT, not where its number would have sent it.
+     *
+     * An Extra's direction comes from its start now (§7, Jesse's ruling), so the line that used to
+     * explain the number's parity would be explaining a rule that no longer applies to this train.
+     */
+    case 'extraStarted': {
+      const where =
+        e.at.kind === 'divisionPoint'
+          ? `the ${e.at.side === 'west' ? 'Western' : 'Eastern'} Division Point`
+          : e.at.kind === 'mainline'
+            ? "the Interchange's yard"
+            : `the Control Point in seat ${e.at.seat}`;
+      const why =
+        e.at.kind === 'divisionPoint'
+          ? 'the end it runs away from — an Extra may start at either, and the end chooses the run'
+          : e.at.kind === 'mainline'
+            ? 'made up off the running line, so it highballs onto the Mainline once the Subdivision ' +
+              'is clear and may be held in the yard until it is'
+            : 'an Extra may begin at any Office above a Whistle Post, and the player chooses the run';
       return {
         tone: 'good',
-        text:
+        text: `EXTRA X${e.trainNumber} started at ${where}, running ${e.direction} — ${why}`,
-          e.atSeat === null
-            ? `EXTRA X${e.trainNumber} started at the ${e.trainNumber % 2 === 0 ? 'Western' : 'Eastern'} Division Point, running ${e.trainNumber % 2 === 0 ? 'east' : 'west'} — odd numbers run west and even run east (§2.3), so its number chose the end`
-            : `EXTRA X${e.trainNumber} started at the Control Point in seat ${e.atSeat}, running ${e.trainNumber % 2 === 0 ? 'east' : 'west'} — an Extra may begin at any Office above a Whistle Post instead of at a Division Point`,
       };
+    }
     case 'trainMadeUp':
       return {
         tone: 'good',
@@ -356,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`,
       };
     }
@@ -374,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'})`)
@@ -385,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.`,
       };
     }
@@ -394,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.`,
@@ -414,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
@@ -498,14 +524,124 @@ export type Impediment = { where: string; why: string; severity: 'stuck' | 'wait
  * This is the panel that should answer the standing questions: whether facilities jam, whether
  * trains are held for want of a crew, whether the Office is about to cause a collision.
  */
+/** `coordKey`'s inverse — the grid is keyed by string and the engine predicates take coordinates. */
+function uncoordKey(key: string): GridCoord {
+  const [row, col] = key.split(',').map(Number);
+  return { row: row ?? 0, col: col ?? 0 };
+}
+
+/**
+ * One of `passengerRefusal`'s codes, in words a player can act on.
+ *
+ * `NO_EMPTY_COACH_IN_YARD` gets the longest answer because it is the one that looks like a broken
+ * game: the Division Yard is visibly full of cars, and the single type that has run out is the one
+ * §9.2 needs. Where the missing coaches ARE, and the condition that brings them back, is the whole
+ * of what the player needs to know — §2.2 returns the Classification Yard only when the Division
+ * Yard is bare, so a yard with fifty freight cars in it will not refill for a long time.
+ */
+function passengerReason(
+  s: GameState,
+  player: PlayerIndex,
+  at: GridCoord,
+  dir: 'board' | 'detrain',
+): string {
+  const code = passengerRefusal(s, player, at, dir);
+  switch (code) {
+    case 'NO_TRAIN_AT_OFFICE':
+      return dir === 'board'
+        ? 'passengers waiting, no train at the platform to take them'
+        : 'no train at the platform';
+    case 'NOT_A_TERMINAL':
+      return 'the only train here stops at Terminals only — Porters may not work it at this Office';
+    case 'NO_PASSENGER_WORK':
+      return 'the only train here is one its card bars Porters from working';
+    case 'NO_EMPTY_COACH':
+      return 'passengers waiting, but every coach on the train is already full';
+    case 'INBOUND_BOX_FULL':
+      return 'arrivals aboard, but the red Unloading slots are all occupied';
+    case 'LOADED_IN_THIS_DISTRICT':
+      return 'the loaded coaches all boarded here — passengers must be carried to another Office ' +
+        'Area before they can alight';
+    case 'NO_EMPTY_COACH_IN_YARD': {
+      const stuck = s.yards.classificationYard.filter((c) => c.type === 'coach').length;
+      const total = s.yards.divisionYard.length;
+      return (
+        'arrivals aboard, but §9.2 needs a white empty coach from the Division Yard to swap in and ' +
+        `there is none left${stuck > 0 ? ` — ${stuck} ${stuck === 1 ? 'coach is' : 'coaches are'} in the Classification Yard` : ''}. ` +
+        `Classification returns only when the Division Yard is bare, and it still holds ${total} cars.`
+      );
+    }
+    default:
+      return `Porters cannot work here (${code})`;
+  }
+}
+
 export function impediments(s: GameState, player: PlayerIndex = 0): Impediment[] {
   const out: Impediment[] = [];
   const area = areaOf(s, player);
 
   for (const [key, card] of area.grid) {
     const f = card.facility;
-    if (!f || f.kind !== 'freight') continue;
+    if (!f) continue;
-    const name = card.geometry.kind === 'facility' ? card.geometry.facility : 'facility';
+    /**
+     * A Freight Facility names itself off its own card; a Passenger Facility does NOT — it rides on
+     * the `office` card, so `geometry.kind` is `'office'` and it fell through to the literal
+     * "facility". Every passenger impediment therefore read `facility 0,0`, next to a freight row
+     * saying `mineTipple 1,-3`. The Office Area's tier is the name it should carry, and there is
+     * exactly one Office per Area, so `area.tier` is that card's own.
+     */
+    const name =
+      card.geometry.kind === 'facility'
+        ? card.geometry.facility
+        : card.geometry.kind === 'office'
+          ? area.tier
+          : 'facility';
+
+    /**
+     * WHY THE PORTERS ARE STANDING THERE (Gitea#2).
+     *
+     * "Note that the sparrow (with two loaded coaches) pulled into the station. There are two
+     * passengers on the platform. Four porters. My thought was to unload two and load two. I never
+     * get the chance to load the last two."
+     *
+     * The engine was right — §9.2 needs a white coach out of the Division Yard to de-train into,
+     * §2.2 returns the Classification Yard only when the Division Yard is BARE, and the Division
+     * Yard was one empty coach short with eight more sitting in Classification unable to come back.
+     * Jesse's ruling is that the shortage stays: "it is possible to run out — that's part of the
+     * strategy." What was missing was any way to SEE it. A Porter action that cannot be taken is
+     * simply absent from the menu, and this panel — the one that answers "why is nothing moving?" —
+     * covered freight facilities only, so the platform had nothing to say for itself at all.
+     *
+     * The reason comes from `passengerRefusal`, the engine's own, so what is on screen is the rule
+     * that actually refused rather than a second guess at it.
+     */
+    if (f.kind === 'passenger') {
+      if (portersLeft(f) > 0) {
+        const coord = uncoordKey(key);
+        // Passengers standing on the platform with nothing carrying them away.
+        if (f.outboundBox.some((c) => c.type === 'coach' && c.loaded) && !canBoard(s, player, coord)) {
+          out.push({
+            where: `${name} ${key}`,
+            why: passengerReason(s, player, coord, 'board'),
+            severity: 'waiting',
+          });
+        }
+        // A coach full of arrivals that cannot be emptied.
+        const arriving = area.adOccupancy.some((id) =>
+          s.trays.get(id)?.consist.some((c) => c.type === 'coach' && c.loaded && c.origin !== seatOf(s, player)),
+        );
+        if (arriving && !canDetrain(s, player, coord)) {
+          out.push({
+            where: `${name} ${key}`,
+            why: passengerReason(s, player, coord, 'detrain'),
+            severity: 'stuck',
+          });
+        }
+      }
+      continue;
+    }
+
+    if (f.kind !== 'freight') continue;
     const want = facilityCarType(f);
 
     // A load that cannot move, with Laborers standing by, is the worst state a facility reaches:
@@ -536,7 +672,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',
       });
     }
@@ -557,7 +693,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',
       });
     }
@@ -642,7 +778,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',
         );
@@ -665,7 +801,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

@@ -18,7 +18,9 @@ import {
   laborersLeft,
   movesFor,
   ownCutFor,
+  keepReason,
   portersLeft,
+  resolveExtraStart,
   selectDestination,
 } from '../engine/apply.ts';
 import {
@@ -44,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';
@@ -323,6 +325,14 @@ export type DivisionView = {
   /** Office nodes only: whose district this is. */
   /** Which SEAT's district this is — a position on the Division, not a player. */
   seat?: number;
+  /**
+   * Interchange only: trains standing in its yard, not out on the running line (state.ts).
+   *
+   * Separate from `trains` for the same reason `switching` is separate from an Office's A/D list —
+   * they are not occupying the thing whose capacity is being counted. An Extra made up here has to
+   * be VISIBLE, though, or the player who placed it has a train that exists nowhere on the map.
+   */
+  yard?: TrainChip[];
   /**
    * Office nodes only: crews working BELOW the Running Track.
    *
@@ -364,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`
@@ -469,6 +489,25 @@ export type Frame = {
   hand: string[];
   /** What each hand card does, in the same order — names alone are not a playable hand. */
   handWhat: string[];
+  /**
+   * Whether each hand card may be DISCARDED, in the same order.
+   *
+   * The player has to be told which cards those are, not merely find that a button is missing —
+   * that silence is the whole of the Gitea#2 complaint, where a blocked platform left the board with
+   * nothing to click and no reason. Named for the rule rather than for trains, since it answers the
+   * question the panel is asking.
+   */
+  handDiscardable: boolean[];
+  /**
+   * WHY a card may not be discarded, in the same order; `null` where it may.
+   *
+   * Carried rather than written on the page because §6.2 now fails for two different reasons
+   * (Gitea#9): an Extra is never discardable, and a Timetabled train is not discardable only when
+   * the `discardTimetabled` house rule is off. A panel that hard-codes one sentence tells half the
+   * players the wrong thing, and a panel that reconstructs the rule is a second implementation of
+   * it. `keepReason` is the engine's own, so the card says the rule that actually refused.
+   */
+  handKeepWhy: (string | null)[];
   deck: number;
   /** The face-up card on top of each Department pile — the only one that may be drawn. */
   departments: string[];
@@ -560,6 +599,7 @@ const FACILITY_NAMES: Record<string, string> = {
 function facilityView(
   card: { geometry: { kind: string; facility?: string }; facility: unknown; modifiers?: string[] },
   officeName: string,
+  viewerSeat: SeatIndex,
 ): FacilityView | null {
   const f = (card as { facility: import('../engine/state.ts').Facility | null }).facility;
   // Passenger facilities were excluded entirely, so the Office's green and red slots never
@@ -581,7 +621,9 @@ function facilityView(
     maw: (f.menAtWork ?? []).map((l) => (l ? `${l.type} ${l.dir === 'out' ? '→' : '←'}` : null)),
     red: f.inboundBox.map(carLabel),
     redCap: f.capacity.inbound,
-    track: f.industryTrack.cars.map(carLabel),
+    // Marked when this district made the load: the spotted car is exactly where a player is looking
+    // when they ask why the Laborer will not unload it.
+    track: f.industryTrack.cars.map((c) => carLabel(c, viewerSeat)),
     laborers: `${laborersLeft(f)}/${f.laborers}`,
     porters: `${portersLeft(f)}/${f.porters}`,
     canFinish: canFinishHere(f),
@@ -672,7 +714,9 @@ function trainsOnCard(s: GameState, viewerSeat: SeatIndex, key: string): CellVie
     out.push({
       trayId: id,
       label: t.trainNumber === null ? 'crew' : `T${t.trainIsExtra ? 'X' : ''}${t.trainNumber}`,
-      cars: t.consist.map(carLabel),
+      // A coach filled at THIS Office reads "loaded coach (loaded here)" — those passengers may not
+      // alight in the district that boarded them, and the tray is where a player looks for that.
+      cars: t.consist.map((c) => carLabel(c, viewerSeat)),
       engineAt: Math.max(0, Math.min(t.consist.length, t.engineAt)),
       facing: railFacingOf(t),
       what: t.trainNumber === null ? 'A local crew — no timetable, no card, no special rules.' : trainRules(t),
@@ -728,6 +772,11 @@ function sampleDetail(s: GameState, kind: string, list: Intent[]): string {
   return shown.join('; ') + (more > 0 ? ` … and ${more} more distinct` : '');
 }
 
+/** " onto Train 8", or nothing at all when the intent names no train (an old save, or one train). */
+function onto(s: GameState, trayId: string | undefined, joiner: string): string {
+  return trayId === undefined ? '' : `${joiner}${trainName(s, trayId)}`;
+}
+
 /** One readable line for a single intent. */
 export function describeIntent(s: GameState, i: Intent): string {
   // X,Y — east/west then north/south, not the internal row/col storage order.
@@ -907,18 +956,39 @@ export function describeIntent(s: GameState, i: Intent): string {
       return `advance load in box ${i.box} at ${at(i.at)}`;
     case 'laborer.beginUnload':
       return `begin unloading car ${i.carIndex} at ${at(i.at)}`;
+    /**
+     * NAME THE TRAIN. The action list drops duplicate labels within a crew, and with two trains
+     * standing at one station "board passengers at (0,0)" describes both — which is half of why the
+     * v0.4.9d playtest found that picking a train changed nothing. The intent now carries the tray;
+     * the label has to say so or the second button is thrown away before the menu sees it.
+     */
     case 'porter.board':
-      return `board passengers at ${at(i.at)}`;
+      return `board passengers at ${at(i.at)}${onto(s, i.trayId, ' onto ')}`;
     case 'porter.detrain':
-      return `detrain passengers at ${at(i.at)}`;
+      return `detrain passengers at ${at(i.at)}${onto(s, i.trayId, ' from ')}`;
+    /**
+     * NAME THE PLACE AND THE DIRECTION, because the player is choosing both.
+     *
+     * This used to explain why the Extra had no choice — "it runs west, so that is the end it
+     * starts from". It has one now (§7, Jesse's ruling), and every candidate is on screen at once,
+     * so each label has to be distinguishable from its three or four siblings at a glance.
+     */
     case 'newTrain.startExtra': {
-      const runs = i.trainNumber % 2 === 0 ? 'east' : 'west';
+      const where = resolveExtraStart(s, s.clock.currentActor ?? 0, i);
-      if (i.atSeat === null) {
+      if (typeof where === 'string') return `start Extra X${i.trainNumber}`;
-        const end = i.trainNumber % 2 === 0 ? 'Western' : 'Eastern';
+      const { direction } = where;
-        return `start Extra X${i.trainNumber} at the ${end} Division Point — it runs ${runs}, so that is the end it starts from`;
+      if (where.at.kind === 'divisionPoint') {
+        const end = where.at.side === 'west' ? 'Western' : 'Eastern';
+        return `start Extra X${i.trainNumber} at the ${end} Division Point — it runs ${direction} from there`;
       }
-      const tier = officeProfile(areaAtSeat(s, i.atSeat).tier).name;
+      if (where.at.kind === 'mainline') {
-      return `start Extra X${i.trainNumber} at the ${tier} in seat ${i.atSeat} — a Control Point, so it may begin its ${runs}bound run there instead`;
+        return (
+          `start Extra X${i.trainNumber} ${direction}bound in the Interchange — it is made up in the ` +
+          'yard and highballs onto the Mainline once the Subdivision is clear'
+        );
+      }
+      const tier = officeProfile(areaAtSeat(s, where.at.seat).tier).name;
+      return `start Extra X${i.trainNumber} ${direction}bound at the ${tier} in seat ${where.at.seat} — a Control Point, so it may begin its run there`;
     }
 
     case 'newTrain.placeCar':
@@ -1059,7 +1129,7 @@ export function snapshot(
     else if (g.kind === 'spaceUse') label = prettyKey(g.key);
     else label = geometryLabel(g.geometry);
 
-    const fv = facilityView(card as never, officeProfile(area.tier).name);
+    const fv = facilityView(card as never, officeProfile(area.tier).name, viewerSeat);
     if (fv) facilities.push(fv);
 
     cells.push({
@@ -1074,7 +1144,7 @@ export function snapshot(
       enhancementsWhat: card.enhancements.map((k) => enhancementText(k) ?? prettyKey(k)),
       trains: trainsOnCard(s, viewerSeat, key),
       adTracks: card.geometry.kind === 'office' ? officeProfile(area.tier).adTracks : null,
-      cars: carsOn(card).map(carLabel),
+      cars: carsOn(card).map((c) => carLabel(c, viewerSeat)),
       standingWest: card.standingWest,
       facility: fv,
     });
@@ -1143,6 +1213,9 @@ export function snapshot(
           };
         })],
         capacity: MAINLINE_PROFILES.find((m) => m.kind === n.card)?.trainsMayPass ? 2 : 1,
+        // Drawn at the start of the card: the yard is beside the rail, and this is the end the
+        // train will pull out of. It counts against nothing — see `yard` on DivisionView.
+        yard: (n.holding ?? []).map((id) => ({ ...trainChip(s, id), region: 0 })),
         modifiers: [
           ...(n.modifiers ?? []).map(prettyKey),
           ...(n.absSignals ? ['ABS Signals'] : []),
@@ -1231,6 +1304,8 @@ export function snapshot(
      */
     hand: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => cardName(s, id)),
     handWhat: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => cardDescription(s, id)),
+    handDiscardable: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => keepReason(s, id) === null),
+    handKeepWhy: [...(s.decks.hands.get(viewer) ?? [])].reverse().map((id) => keepReason(s, id)),
     deck: s.decks.homeOffice.length,
     departments: s.decks.departments.map((pile) => {
       const top = pile[pile.length - 1];
@@ -1259,6 +1334,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,
@@ -1509,7 +1586,9 @@ export function trainRules(t: {
   }
   if (p.rules.noPassengerWork) parts.push('NO PASSENGER WORK — Porters may not board or detrain it');
   if (p.rules.dropOnly) parts.push('MAY DROP BUT NOT PICK UP — it cannot couple anything');
-  if (p.rules.pickUpEmptiesOnly) parts.push('EMPTIES ONLY — it may not couple a loaded car');
+  if (p.rules.pickUpEmptiesOnly) {
+    parts.push('EMPTIES ONLY — it may not couple a loaded car. A caboose is not a load.');
+  }
   if (p.rules.stopThenExpedite) {
     parts.push('STOPS ONCE FOR SPEECHES, then runs expedited from its next Office onward');
   }

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
+ * Everything in `#lobby` (`play.html`) is owned here: the join-secret gate, the two doors (join a
- * game by code, and the seating screen up to `Lobby.Start`. `main.ts` calls `runLobby` once, at
+ * game, create one), the read-only preview a player reads BEFORE taking a seat, and the seating
- * `start()`, only when there is no stored session to reconnect with — see `main.ts`'s own comment
+ * screen up to `Lobby.Start`.
- * on why a stored `{token, gameId, seat}` skips this module entirely.
+ *
+ * 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 {
-import { STARTING_HAND_LABELS, houseRules } from '../engine/content.ts';
+  closestPreset,
-import type { StartingHand } from '../engine/content.ts';
+  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
+ * Shows `#lobby` and drives it. `resume` re-enters the seating screen for a browser that already
- * `onReady` exactly once — the instant `Lobby.Start` fires, from WHICHEVER browser tab started it.
+ * holds a seat (a reload before the host started) rather than starting at the doors.
- * 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`.
  */
-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'
+            ? `Bot ${botNumber}`
-            : `${occupant.displayName}${isYou ? ' (you)' : ''}${isSeatHost ? ' — host' : ''}`;
+            : `${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
+     * being read off it and retyped. Two buttons because they are two different acts: the CODE is
-     * and can be refused outright, so a failure says the code is there to be selected rather than
+     * what you read aloud on a call and works at whatever address each player reaches the box by;
-     * silently doing nothing.
+     * 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');
+    const say = (m: string): void => {
-    copyBtn.onclick = () => {
+      $('lb-copied').textContent = m;
-      const say = (m: string): void => {
+      setTimeout(() => ($('lb-copied').textContent = ''), 4000);
-        $('lb-copied').textContent = m;
+    };
-        setTimeout(() => ($('lb-copied').textContent = ''), 4000);
+    const copy = (text: string, ok: string): void => {
-      };
       void navigator.clipboard
-        ?.writeText(lobby.gameCode)
+        ?.writeText(text)
-        .then(() => say('Copied.'))
+        .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
+    startBtn.textContent = 'Start game';
-      ? waiting === 0
+    $('lb-start-note').textContent = '';
-        ? ''
+    const waitNote = $('lb-stream-note');
-        : `Waiting on ${waiting} more ${waiting === 1 ? 'player' : 'players'} — add a bot to any empty chair to start now.`
+    if (waitNote.dataset['reason'] !== 'stream') {
-      : 'Waiting for the host to start the game.';
+      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 ??
+     * A DEAD LOBBY AND A BLIP LOOK IDENTICAL HERE, so ask — the same shape `session.ts` already uses
-      'competitive') as 'competitive' | 'coop';
+     * for the game stream, which the lobby never got.
-  const chosenPlayers = (): number => Number($<HTMLSelectElement>('lb-players').value) || 4;
+     *
-  const num = (id: string): number => Number($<HTMLInputElement>(id).value);
+     * 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
-   * Mode and table size only move the DEFAULTS, exactly as the solitaire dialog's own presets do —
+     * `EventSource` is already retrying and the note is all that is needed. Or it is gone, and
-   * every field stays editable afterwards, so "Co-op, 3 players" is a starting point rather than a
+     * sitting on a frozen seating screen is the one thing that must not happen.
-   * 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.
+    source.onerror = () => {
-   */
+      if (done) return;
-  function applyDefaults(): void {
+      streamNote('Connection lost — retrying. You can leave and rejoin if this does not clear.');
-    const c = defaultMultiplayerConfig(chosenMode(), chosenPlayers());
+      void getJson(`/api/session?token=${encodeURIComponent(token)}`).then(({ status, body }) => {
-    const rules = houseRules(c);
+        if (done) return;
-    $<HTMLInputElement>('lb-days').value = String(c.days);
+        if (status === 200) {
-    $<HTMLInputElement>('lb-minrev').value = String(c.minCombinedRevenue);
+          done = true;
-    $<HTMLInputElement>('lb-colday').value = String(c.maxCollisionsPerDay);
+          source?.close();
-    $<HTMLInputElement>('lb-coltotal').value = String(c.maxCollisionsTotal);
+          handlers.onReady({ token, gameId, seat: body['player'] as PlayerIndex, gameCode });
-    $<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'));
           return;
         }
-        setError('lb-create-err', '');
+        void getJson(
-        enterSeating(body['gameId'] as string, body['token'] as string);
+          `/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 = () => {
+  if (resume) enterSeating(resume.gameId, resume.token, resume.gameCode);
-    const displayName = $<HTMLInputElement>('lb-name').value.trim();
+}
-    const gameCode = $<HTMLInputElement>('lb-code').value.trim();
+
-    if (displayName === '' || gameCode === '') {
+/** The lobby-wide message slot: why you are looking at this screen, when it was not your own click. */
-      setError('lb-join-err', 'enter a display name and a game code');
+export function notice(message: string): void {
-      return;
+  const el = document.getElementById('lb-notice');
-    }
+  if (!el) return;
-    void postJson('/api/lobby/join', { secret: secret(), gameCode, displayName }).then(({ status, body }) => {
+  el.textContent = message;
-      if (status !== 200) {
+  el.hidden = message === '';
-        setError('lb-join-err', String(body['error'] ?? 'could not join that game'));
+}
-        return;
+
-      }
+/** Prefills the code from an invite link and opens the join door on it. */
-      setError('lb-join-err', '');
+export function prefillCode(code: string): void {
-      enterSeating(body['gameId'] as string, body['token'] as string);
+  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

@@ -10,24 +10,33 @@ import { TURNCHART_CSS, turnChartHtml } from '../sim/turnchart.ts';
 import type { Frame } from '../sim/view.ts';
 import { seatLabel } from '../sim/view.ts';
 import type { Menu, Save } from './game.ts';
-import { PANEL_CSS, blockedHtml, facilitiesHtml, pilesHtml, timetableHtml, yardHtml } from './panels.ts';
+import { PANEL_CSS, blockedHtml, dayEndHtml, facilitiesHtml, pilesHtml, timetableHtml, yardHtml } from './panels.ts';
 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 { HouseRuleOverrides, HouseRules, RevenueRules, StartingHand } from '../engine/content.ts';
+import type { ExtraStartRule, HouseRuleOverrides, HouseRules, RevenueRules, StartingHand } from '../engine/content.ts';
 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';
@@ -149,6 +158,13 @@ let zoom = settings.zoom;
  * ended or what happened in between. Reported exactly that way.
  */
 let lastPhase: string | null = null;
+/**
+ * The Day the page last drew, so a Day rolling over can be shown as a dialog (Gitea#10).
+ *
+ * Null until the first frame: arriving in a game already on Day 3 is not Day 2 ending, and a page
+ * reloaded mid-game would otherwise announce a rollover that happened before it was watching.
+ */
+let lastDay: number | null = null;
 /**
  * WHICH CREW THE BOARD IS DRAWING, when the district holds more than one.
  *
@@ -226,7 +242,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);
 }
 
 /**
@@ -270,10 +290,29 @@ 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');
   if (STARTING_HAND_LABELS.some((o) => o.value === hand)) rules.startingHand = hand as StartingHand;
+  const extra = params.get('extra');
+  if (EXTRA_START_LABELS.some((o) => o.value === extra)) rules.extraStart = extra as ExtraStartRule;
+  // §6.2 (Gitea#9). This one defaults ON, so the URL only ever has to carry the OFF case — `?toss=0`.
+  // Read the same way the optional rules are: present and not "0" means on.
+  const toss = params.get('toss');
+  if (toss !== null) rules.discardTimetabled = toss !== '0';
 
   const revenue: Partial<RevenueRules> = {};
   for (const [param, key] of Object.entries(RULE_PARAMS)) {
@@ -293,30 +332,302 @@ 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,
+      discardTimetabled: options.houseRules?.discardTimetabled ?? p.discardTimetabled,
+      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);
   params.set('hand', rules.startingHand);
+  // The dialog answers reach `start()` through the URL and nowhere else, so a setting missing from
+  // here is a setting the dialog silently discards.
+  params.set('extra', rules.extraStart);
+  // Written only when OFF, for the reason the optional rules are written only when on: this one
+  // defaults to on, so `toss=1` on every link would say nothing and cost a parameter.
+  if (!rules.discardTimetabled) params.set('toss', '0');
   for (const [param, key] of Object.entries(RULE_PARAMS)) params.set(param, String(rules.revenue[key]));
   for (const [param, key] of Object.entries(VICTORY_PARAMS)) {
     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 DAY ROLLING OVER, as a dialog that has to be dismissed (Gitea#10).
+ *
+ * "As the game rolls off the end of the day, you get a dialog saying such. Hard to keep track of
+ * time." Nothing on screen was wrong — the clock, the turn chart and the timetable all said which
+ * Day it was — but a Day turns over inside the phases that run themselves, so it happens while the
+ * player is looking at the board waiting for their next turn. The two transient signals the page
+ * already had are both gone in under five seconds.
+ *
+ * Not shown when:
+ *   - this is the first frame (`lastDay === null`) — arriving on Day 3 is not Day 2 ending;
+ *   - the Day went DOWN, which is Undo stepping back across the rollover, not a Day passing;
+ *   - the game finished on that rollover, when the outcome panel is the thing to read instead.
+ */
+function noteDayEnd(f: Frame): void {
+  const previous = lastDay;
+  lastDay = f.day;
+  if (previous === null || f.day <= previous) return;
+  if (f.status !== 'active') return;
+  const dlg = document.getElementById('dayenddlg') as HTMLDialogElement | null;
+  const body = document.getElementById('dayendbody');
+  if (!dlg || !body) return;
+  body.innerHTML = dayEndHtml(f);
+  // A second rollover cannot happen while this one is open, but a redraw can — `showModal` throws
+  // on an already-open dialog rather than doing nothing.
+  if (!dlg.open) dlg.showModal();
+}
+
+/**
+ * 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. */
@@ -332,12 +643,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.
+  // look like, forever. This is its own state now rather than a borrowed line in the DISCONNECT
-  $('presence').textContent = '… connecting to the game';
+  // 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
@@ -360,16 +673,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);
+  runLobby(lobbyHandlers);
-  const note = document.getElementById('lb-create-err');
+  // The lobby's own notice slot, not the create form's error line: the player may well have been a
-  if (note) {
+  // joiner, and with the two doors that line is behind a panel they are not looking at.
-    note.textContent =
+  notice(
-      'That game is no longer on this server — it was either ended by whoever runs it, or the ' +
+    '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.';
+      'service was updated, which does not carry games in progress across. Create or join a new one.',
-  }
+  );
 }
 
 /**
@@ -382,21 +698,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) {
+  if (remembered && remembered.stage === 'game' && remembered.seat !== undefined) {
-    beginRemote(remembered);
+    beginRemote({ ...remembered, seat: remembered.seat });
     return;
   }
-
+  /**
-  // The splash's "Play multiplayer" door (index.html) lands here — straight into the lobby,
+   * A SEAT TAKEN BUT NOT YET PLAYING — this browser reloaded while the lobby was still seating.
-  // rather than dealing a solitaire game first and leaving the player to find the in-game
+   *
-  // Multiplayer button themselves.
+   * The lobby stream answers all three cases from here without another route: it pushes the seating
-  if (params.get('lobby') !== null) {
+   * 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;
   }
 
@@ -404,7 +743,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
@@ -439,6 +778,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);
 }
 
 /**
@@ -483,16 +824,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
+  const name = (seat: PlayerIndex): string =>
-    .presence()
+    f.players.find((pl) => pl.index === seat)?.name ?? `Seat ${seatLabel(seat)}`;
-    .filter((p) => !p.connected)
+  const presence = session.presence();
-    .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`;
+   * 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.
@@ -529,6 +921,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
@@ -803,10 +1196,20 @@ function render(): void {
 
   // -- log
   const log = $('log');
-  log.innerHTML = session.lines()
+  const allLines = session.lines();
-    .slice(-60)
+  const shownLines = allLines.slice(-60);
-    .map((l) => `<div class="line t-${l.tone}">${esc(l.text)}</div>`)
+  /**
-    .join('');
+   * 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;
 
   /**
@@ -826,19 +1229,14 @@ function render(): void {
   }
   lastPhase = f.phaseKey;
 
+  noteDayEnd(f);
+
   /**
    * A train completing its run pays every player and nobody took a turn to cause it, so it is said
    * 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) {
+  if (announcement) flashAnnounce(announcement);
-    const el = $('announce');
-    el.textContent = announcement;
-    el.className = 'shown';
-    window.setTimeout(() => {
-      if (el.textContent === announcement) el.className = '';
-    }, 4200);
-  }
 
   renderDistrict(f);
   renderActions(menu, f, justSet);
@@ -883,6 +1281,9 @@ function renderUndo(): void {
     // A phase change is announced by comparing against the last frame drawn. Stepping BACK into a
     // different phase is not that event, so the banner is suppressed rather than fired backwards.
     lastPhase = null;
+    // Same for the Day: `noteDayEnd` already ignores a Day going down, but undoing back across a
+    // rollover and then replaying forward through it would announce the same Day ending twice.
+    lastDay = null;
   };
 }
 
@@ -1068,13 +1469,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>`
       : '';
 
@@ -1157,7 +1558,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.
@@ -1171,7 +1572,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>`;
   }
@@ -1221,9 +1622,30 @@ function renderActions(
   ) {
     // The hand being counted is the ACTOR's — they are the one who cannot end the turn.
     const hand = f.handCount;
+    /**
+     * WHEN NOTHING IN HAND MAY BE DISCARDED, SAY SO AND SAY WHAT TO DO INSTEAD.
+     *
+     * §6.2 (Gitea#9) leaves two kinds of undiscardable card — an Extra always, and a Timetabled
+     * train in a game whose `discardTimetabled` rule is off. Either way a player holding nothing but
+     * those has exactly one way forward: play one. The rule creates that corner deliberately and
+     * needs no machinery, but it must not be a corner the player has to infer from a discard button
+     * that has quietly stopped appearing. The reason is the card's own (`handKeepWhy`), so this says
+     * what actually refused rather than assuming which of the two rules is in force.
+     */
+    const stuck = f.handDiscardable.length > 0 && f.handDiscardable.every((d) => !d);
+    const why = f.handKeepWhy.find((w) => w !== null) ?? '';
+    const tip = stuck
+      ? 'You may not end a turn holding more than three cards, and every card you hold is one that ' +
+        `cannot be thrown away. ${why} The only way on is to play one.`
+      : '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 — where a rival may pick ' +
+        'it up.';
     html +=
-      `<div class="grp"><button class="act blocked" disabled data-tip="§6.2 — 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.">` +
+      `<div class="grp"><button class="act blocked" disabled data-tip="${tip.replace(/"/g, '&quot;')}">` +
-      `End Local Operations — play or discard down to three first (holding ${hand})</button></div>`;
+      (stuck
+        ? `End Local Operations — play a train card first, they cannot be discarded (holding ${hand})`
+        : `End Local Operations — play or discard down to three first (holding ${hand})`) +
+      `</button></div>`;
   }
 
   el.innerHTML = html;
@@ -1330,7 +1752,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.`);
   };
 }
 
@@ -1338,38 +1788,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) —
+   * THE SAME FIVE GAME TYPES THE LOBBY OFFERS, and the same shared rules block under them.
-   * 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.
    *
-   * Only Solitaire can be dealt today — Deal disables itself for the other two, with a note, rather
+   * The dialog used to carry its own copy of the questions and its own idea of the defaults, which
-   * than pretending a click would do something (`RemoteSession` is Phase 2).
+   * 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 {
+  let ngBase: PresetName = 'solitaire';
-    const days = 5;
+  let ngType: GameType = 'solitaire';
-    const players = mode === 'solitaire' ? 1 : 4;
+  /** As in the lobby: the floor is derived from the length until the player sets one themselves. */
-    field<HTMLInputElement>('ng-days').value = String(days);
+  let ngFloorTyped = false;
-    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);
 
-    // No valid target for these cards in Solitaire or Co-op — forced off, not merely defaulted off.
+  const ngDays = (): number => {
-    const pvp = field<HTMLInputElement>('ng-pvp');
+    const raw = Number(field<HTMLInputElement>('ng-days').value);
-    pvp.checked = mode === 'competitive';
+    return Number.isFinite(raw) && raw >= 1 ? Math.round(raw) : 5;
-    pvp.disabled = mode !== 'competitive';
+  };
 
-    field<HTMLButtonElement>('ng-deal').disabled = mode !== 'solitaire';
+  const ngTypeRadios = (): HTMLInputElement[] =>
-    field<HTMLElement>('ng-multiplayer-note').style.visibility = mode === 'solitaire' ? 'hidden' : 'visible';
+    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"]')) {
+  function ngSelectPreset(name: PresetName): void {
-    input.onchange = () => applyModePreset(input.value as Mode);
+    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.
    *
@@ -1379,8 +1890,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
+   * comparison silently stops comparing. Which TYPE that is comes out of the comparison — a game
-   * previous session could actually have been, since Deal is disabled for the other two.
+   * 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
@@ -1394,23 +1906,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;
-    }
-    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);
+    ngBase = 'solitaire';
-    field<HTMLInputElement>('ng-colday').value = String(f.maxCollisionsPerDay);
+    ngType = 'solitaire';
-    field<HTMLInputElement>('ng-coltotal').value = String(f.maxCollisionsTotal);
+    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();
   };
 
@@ -1420,8 +1924,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;
@@ -1430,22 +1932,31 @@ 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 settings = ngForm.read();
     const rules = houseRules({
       houseRules: {
-        ...(STARTING_HAND_LABELS.some((o) => o.value === picked) ? { startingHand: picked as StartingHand } : {}),
+        startingHand: settings.startingHand,
+        extraStart: settings.extraStart,
+        discardTimetabled: settings.discardTimetabled,
         revenue: {
-          passengerPerCoach: Number(field<HTMLInputElement>('ng-passenger').value),
+          passengerPerCoach: settings.passengerPerCoach,
-          freightPerLoad: Number(field<HTMLInputElement>('ng-freight').value),
+          freightPerLoad: settings.freightPerLoad,
-          trainPerTransit: Number(field<HTMLInputElement>('ng-transit').value),
+          trainPerTransit: settings.trainPerTransit,
         },
       },
     });
     const victory: NewGameOptions = {
-      days: Math.max(1, Math.round(Number(field<HTMLInputElement>('ng-days').value)) || 5),
+      days: Math.max(1, ngDays()),
-      minCombinedRevenue: Math.max(0, Math.round(Number(field<HTMLInputElement>('ng-minrev').value)) || 0),
+      minCombinedRevenue: settings.minCombinedRevenue,
-      maxCollisionsPerDay: Math.max(0, Math.round(Number(field<HTMLInputElement>('ng-colday').value)) || 0),
+      maxCollisionsPerDay: settings.maxCollisionsPerDay,
-      maxCollisionsTotal: Math.max(0, Math.round(Number(field<HTMLInputElement>('ng-coltotal').value)) || 0),
+      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

@@ -31,8 +31,18 @@ export function cardRow(name: string, why: string, playable: boolean | null): st
 }
 
 export function handHtml(f: Frame, canPlay: (boolean | null)[] = []): string {
+  // §6.2 — 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. The sentence comes off the Frame
+  // (`handKeepWhy`) rather than being written here, because since Gitea#9 there are two of them and
+  // which one applies depends on the card AND the game's rules.
   return f.hand.length
-    ? f.hand.map((h, i) => cardRow(h, f.handWhat[i] ?? '', canPlay[i] ?? null)).join('')
+    ? f.hand
+        .map((h, i) => {
+          const what = f.handWhat[i] ?? '';
+          const held = f.handKeepWhy[i];
+          return cardRow(h, held ? [what, held].filter(Boolean).join(' · ') : what, canPlay[i] ?? null);
+        })
+        .join('')
     : '<span class="dim">empty</span>';
 }
 
@@ -143,6 +153,70 @@ export function timetableHtml(f: Frame, justSet: number | null): string {
   return `<div class="tt">${slots}</div>`;
 }
 
+/**
+ * THE DAY THAT JUST ENDED — the body of the dialog `main.ts` puts up at every Day rollover.
+ *
+ * Reported as Gitea#10: "as the game rolls off the end of the day, you get a dialog saying such.
+ * Hard to keep track of time." The clock was on screen the whole time, but a Day turns over inside
+ * the automatic phases — between one click and the next — and neither the phase banner (2.6s) nor
+ * the announcement flash (4.2s) survives long enough to be noticed by someone reading the board.
+ * A modal is the point: it stops, and it waits to be dismissed.
+ *
+ * It is written from the FRAME AFTER the rollover, so `f.day` is the Day about to start and the one
+ * that ended is the Day before it. Standings are in Revenue order rather than seat order: the
+ * question at the end of a Day is who is ahead.
+ */
+export function dayEndHtml(f: Frame): string {
+  const ended = f.day - 1;
+  const left = f.days - ended;
+  const standings = [...f.players]
+    .sort((a, b) => b.revenue - a.revenue || a.seat - b.seat)
+    .map(
+      (p) =>
+        `<tr${p.index === f.viewer ? ' class="you"' : ''}><td>${esc(p.name)}` +
+        `${p.index === f.viewer ? ' <span class="dim">(you)</span>' : ''}</td>` +
+        `<td class="num">${p.revenue}</td></tr>`,
+    )
+    .join('');
+
+  // The target is a COMBINED floor in every mode that sets one, so it is reported against the whole
+  // table's Revenue rather than the viewer's — showing one player's score against a four-player
+  // target reads as a hopeless position when the table may be comfortably ahead.
+  const combined = f.players.reduce((n, p) => n + p.revenue, 0);
+  const target =
+    f.minCombinedRevenue > 0
+      ? `<p>Combined Revenue <b>${combined}</b> against a target of <b>${f.minCombinedRevenue}</b>.</p>`
+      : '';
+
+  /**
+   * Only when the game is actually scored on collisions.
+   *
+   * Two conditions, both of them `advance.ts`'s own: `0` on a dial turns that check off, and the
+   * checks run in COMPETITIVE AND CO-OP ONLY (§3.4). A solitaire game carries the default dials on
+   * its config and enforces neither, so reporting a collision budget there would put a rule on
+   * screen that this game does not have.
+   */
+  const scoredOnCollisions =
+    (f.mode === 'competitive' || f.mode === 'coop') &&
+    (f.maxCollisionsTotal > 0 || f.maxCollisionsPerDay > 0);
+  const collisions = scoredOnCollisions
+    ? `<p>Collisions: <b>${f.collisionsToday}</b> today, <b>${f.collisionsTotal}</b> in all.</p>`
+    : '';
+
+  const ahead =
+    left <= 0
+      ? '<p>That was the last Day on the timetable.</p>'
+      : `<p><b>Day ${f.day} of ${f.days}</b> begins now — ${left} ${left === 1 ? 'Day' : 'Days'} left to run.</p>`;
+
+  return (
+    `<h3 class="dayend-h">Day ${ended} has ended</h3>` +
+    ahead +
+    `<table class="dayend-t"><tbody>${standings}</tbody></table>` +
+    target +
+    collisions
+  );
+}
+
 export function blockedHtml(f: Frame): string {
   return f.blocked.length === 0
     ? '<li class="dim">nothing blocked</li>'
@@ -281,7 +355,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.'
@@ -397,4 +471,12 @@ ul.blocked{margin:0;padding-left:18px}
 .fstat.good{background:rgba(40,140,60,.28)}
 .fstat.bad{background:rgba(190,50,50,.38);font-weight:700}
 .fstat.idle{opacity:.6}
+/* THE DAY-END DIALOG (Gitea#10). The dialog chrome is play.html's; these are its contents, here
+   because dayEndHtml is here — a panel and its styling stay together. */
+.dayend-h{font-size:15px;text-transform:none;letter-spacing:0;color:#e6e9ee;margin:0 0 8px}
+.dayend-t{border-collapse:collapse;margin:9px 0;min-width:210px}
+.dayend-t td{padding:3px 12px 3px 0;border-top:1px solid #2c333d}
+.dayend-t tr:first-child td{border-top:0}
+.dayend-t .num{text-align:right;font-variant-numeric:tabular-nums;font-weight:700;padding-right:0}
+.dayend-t .you td{color:#8fd6a0}
 `;

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,258 @@ 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>
+    <!-- Saved: one line, not a password field asking to be filled in again. `lobby.ts` swaps these
-    <label class="ng-num"><span>Join secret</span><input id="lb-secret" type="password" autocomplete="off"></label>
+         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>
+    <!-- TWO DOORS, one panel at a time. Joining used to be a heading at the BOTTOM of the create
-    <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>
+         form: someone sent a code had to scroll past fifteen fields they had no use for. -->
-    <label class="ng-radio"><input type="radio" name="lb-mode" value="competitive" checked>
+    <div class="lb-doors">
-      <span><b>Competitive</b><br><span class="dim">Highest Revenue wins, unless the table misses the combined minimum — then everyone loses.</span></span></label>
+      <button id="lb-door-join" class="lb-door active" type="button">Join a game</button>
-    <label class="ng-radio"><input type="radio" name="lb-mode" value="coop">
+      <button id="lb-door-create" class="lb-door" type="button">Create a game</button>
-      <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>
-    <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>
 
-      <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>
+      <div class="set-row" id="lb-hand-row">
-        <span>Three random cards</span></label>
+        <label class="ng-radio"><input type="radio" name="lb-hand" value="threeRandom">
-      <label class="ng-radio"><input type="radio" name="lb-hand" value="sixRandom">
+          <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>
-        <span>Six random cards</span></label>
+        <label class="ng-radio"><input type="radio" name="lb-hand" value="sixRandom" checked>
-      <label class="ng-radio"><input type="radio" name="lb-hand" value="threeTrackThreeOther">
+          <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>
-        <span>Three track and three other</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
+      <p class="ng-note">What each piece of work pays, 0 to 5. A coach pays when it is boarded and
-         others can be read.</p>
+         again when it is detrained; a load pays when it is made up and again when it is broken. Zero
-      <label class="ng-num"><span>Passenger revenue per coach</span>
+         switches an economy off so the others can be read.</p>
-        <input id="lb-passenger" type="number" min="0" max="5" step="1" value="1"></label>
+      <div class="set-row" id="lb-passenger-row">
-      <label class="ng-num"><span>Freight revenue per load</span>
+        <label class="ng-num"><span>Passenger revenue per coach</span>
-        <input id="lb-freight" type="number" min="0" max="5" step="1" value="1"></label>
+          <input id="lb-passenger" type="number" min="0" max="5" step="1" value="1"></label>
-      <label class="ng-num"><span>Train revenue per transit</span>
+        <span class="set-hint" id="lb-passenger-hint"></span>
-        <input id="lb-transit" type="number" min="0" max="5" step="1" value="0"></label>
+      </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.
+      <p class="ng-note">The ways this game can end badly. Each one is switched on or off in its own
-         The combined-Revenue default is sized for the table you chose above.</p>
+         right; how long the game runs is set above, with the table size.</p>
-      <label class="ng-num"><span>Days</span>
+      <div class="set-row" id="lb-minrev-row">
-        <input id="lb-days" type="number" min="1" max="20" step="1" value="5"></label>
+        <label class="ng-gate"><input type="checkbox" id="lb-minrev-on" checked>
-      <label class="ng-num"><span>Minimum combined Revenue to avoid a loss</span>
+          <span>Everyone loses if combined Revenue at the end is under</span>
-        <input id="lb-minrev" type="number" min="0" step="1" value="60"></label>
+          <input id="lb-minrev" type="number" min="0" step="1" class="gate-num"></label>
-      <label class="ng-num"><span>Collisions in one Day that end the game</span>
+        <span class="set-hint" id="lb-minrev-hint"></span>
-        <input id="lb-colday" type="number" min="0" step="1" value="3"></label>
+      </div>
-      <label class="ng-num"><span>Collisions across the whole game that end it</span>
+      <div class="set-row" id="lb-colday-row">
-        <input id="lb-coltotal" type="number" min="0" step="1" value="5"></label>
+        <label class="ng-gate"><input type="checkbox" id="lb-colday-on" checked>
-      <label class="ng-num"><span>Allow the opponent-directed cards</span>
+          <span>The game ends and everyone loses if collisions in one Day reach</span>
-        <input id="lb-pvp" type="checkbox"></label>
+          <input id="lb-colday" type="number" min="0" step="1" class="gate-num"></label>
-      <p class="ng-note" id="lb-pvp-note">Not yet built (<code>TODO.md</code>) — this has no effect
+        <span class="set-hint" id="lb-colday-hint"></span>
-         either way until then.</p>
+      </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>
+      <p class="ng-note">Off in every game type; each one changes how the game plays.</p>
-      <label class="ng-num"><span>Reduced Visibility — five switching Moves instead of six in the
+      <div class="set-row" id="lb-visibility-row">
-        night Stages (1&ndash;3 and 11&ndash;12)</span>
+        <label class="ng-num"><span>Reduced Visibility — five switching Moves instead of six in the
-        <input id="lb-visibility" type="checkbox"></label>
+          night Stages (1&ndash;3 and 11&ndash;12)</span>
-      <label class="ng-num"><span>Employee Rotation — at the end of each Day everyone moves one chair
+          <input id="lb-visibility" type="checkbox"></label>
-        left and takes over the next station up the line. Your Revenue and the Fedora go with you;
+        <span class="set-hint" id="lb-visibility-hint"></span>
-        the district stays where it is</span>
+      </div>
-        <input id="lb-rotation" type="checkbox"></label>
+      <div class="set-row" id="lb-rotation-row">
-      <label class="ng-num"><span>Emergency Toolbox — everyone starts holding a Red Flag, so a hand of
+        <label class="ng-num"><span>Employee Rotation — at the end of each Day everyone moves one
-        four; play or discard down to three on the first turn</span>
+          chair left and takes over the next station up the line. Your Revenue and the Fedora go with
-        <input id="lb-toolbox" type="checkbox"></label>
+          you; the district stays where it is</span>
-    </details>
+          <input id="lb-rotation" type="checkbox"></label>
-    <p class="ng-note">Every chair has to be taken before the game can start — by a person or by a
+        <span class="set-hint" id="lb-rotation-hint"></span>
-       bot. Pick the size of the table now; it cannot change once the game is created.</p>
+      </div>
-    <button id="lb-create">Create game</button>
+      <div class="set-row" id="lb-toolbox-row">
-    <p class="dim" id="lb-create-err" role="alert"></p>
+        <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 class="set-row" id="lb-tossloco-row">
+        <label class="ng-num"><span>A Timetabled train may be discarded — toss it face-up to a
+          Department slot, where a rival may pick it up. Turn this off and a train card can only ever
+          be played onto the timetable. An Extra is never discardable either way</span>
+          <input id="lb-tossloco" type="checkbox"></label>
+        <span class="set-hint" id="lb-tossloco-hint"></span>
+      </div>
+      </div>
 
-    <h3>Join a game</h3>
+      </div>
-    <p class="ng-note">Ask whoever created the game for its code.</p>
+      </details>
-    <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>
+      <div class="lb-span">
-    <p class="dim" id="lb-join-err" role="alert"></p>
+        <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 +559,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">They enter the code under <b>Join a game</b>, along with the same join secret
-    <p class="ng-note">The host may fill an empty seat with a bot, and starts the game once every
+       you used — the link carries the code, never the secret.</p>
-       seat is either a player or a bot. <b>These chairs are not the running order</b> — who sits
+    <p class="ng-note">The host may fill an empty seat with a bot or clear an occupied one, and
-       where along the Division is decided by a D12 roll when the game starts (§4.4), and the map
+       starts the game once every seat is either a player or a bot. <b>These chairs are not the
-       shows the result.</p>
+       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 +593,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 +617,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,51 +715,159 @@ 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>
+    <div class="set-row" id="ng-type-row">
-    <label class="ng-radio"><input type="radio" name="ng-mode" value="solitaire" checked>
+      <label class="ng-radio"><input type="radio" name="ng-type" value="solitaire">
-      <span><b>Solitaire</b><br><span class="dim">One railroad, one player. Everything below is real today.</span></span></label>
+        <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-mode" value="competitive">
+      <label class="ng-radio"><input type="radio" name="ng-type" value="coop" 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>
+        <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-mode" value="coop">
+      <label class="ng-radio"><input type="radio" name="ng-type" value="competitive">
-      <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>
+        <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" id="ng-type-note"></p>
-    <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">
 
-    <h3>Starting hand</h3>
+    <details id="ng-settings" open>
-    <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>
+      <summary>Game settings</summary>
-    <label class="ng-radio"><input type="radio" name="ng-hand" value="threeRandom" checked>
+      <p class="ng-note">Every rule the game type sets, and every one of them yours to change.
-      <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>
+         Changing any of them selects <b>Custom</b>; clicking a type again resets all of them back
-    <label class="ng-radio"><input type="radio" name="ng-hand" value="sixRandom">
+         to it.</p>
-      <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>
+      <div class="set-groups">
-    <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>
 
-    <h3>Revenue</h3>
+      <div class="set-group">
-    <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>
+      <h3>Starting hand</h3>
-    <label class="ng-num"><span>Passenger revenue per coach</span>
+      <p class="ng-note">What each player is dealt before the first turn. The hand limit is three
-      <input id="ng-passenger" type="number" min="0" max="5" step="1" value="1"></label>
+         either way — deal six and the first turn is spent choosing which of them to keep.</p>
-    <label class="ng-num"><span>Freight revenue per load</span>
+      <div class="set-row" id="ng-hand-row">
-      <input id="ng-freight" type="number" min="0" max="5" step="1" value="1"></label>
+        <label class="ng-radio"><input type="radio" name="ng-hand" value="threeRandom">
-    <label class="ng-num"><span>Train revenue per transit</span>
+          <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>
-      <input id="ng-transit" type="number" min="0" max="5" step="1" value="0"></label>
+        <label class="ng-radio"><input type="radio" name="ng-hand" value="sixRandom" checked>
-    <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>
+          <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>Victory conditions</h3>
+      <div class="set-group">
-    <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>
+      <h3>Where an Extra may start</h3>
-    <label class="ng-num"><span>Days</span>
+      <p class="ng-note">The player who plays an Extra Train card chooses where its Crew Tray goes,
-      <input id="ng-days" type="number" min="1" max="20" step="1" value="5"></label>
+         and the place decides which way it runs — a Division Point sends it away from itself; in the
-    <label class="ng-num"><span>Minimum combined Revenue to avoid a loss</span>
+         middle of the railroad the player picks east or west. The Division Points and the Interchange
-      <input id="ng-minrev" type="number" min="0" step="1" value="15"></label>
+         belong to nobody and are always available. Starting one inside a district is the part that
-    <label class="ng-num"><span>Collisions in one Day that end the game</span>
+         favours a seat, so it is set here. An Office must be a Control Point whatever this says: a
-      <input id="ng-colday" type="number" min="0" step="1" value="3"></label>
+         Whistle Post never qualifies.</p>
-    <label class="ng-num"><span>Collisions across the whole game that end it</span>
+      <div class="set-row" id="ng-extra-row">
-      <input id="ng-coltotal" type="number" min="0" step="1" value="5"></label>
+        <label class="ng-radio"><input type="radio" name="ng-extra" value="divisionPointsOnly">
-    <label class="ng-num"><span>Allow the opponent-directed cards</span>
+          <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>
-      <input id="ng-pvp" type="checkbox"></label>
+        <label class="ng-radio"><input type="radio" name="ng-extra" value="ownOffice">
-    <p class="ng-note" id="ng-pvp-note">Not yet built (<code>TODO.md</code>) — this has no effect either way until then.</p>
+          <span><b>Also the playing player&#8217;s own Control Point</b><br><span class="dim">You may start one at home, but not in somebody else&#8217;s district.</span></span></label>
+        <label class="ng-radio"><input type="radio" name="ng-extra" value="anyOffice">
+          <span><b>Also any player&#8217;s Control Point</b><br><span class="dim">The most permissive — an Extra may be planted in another player&#8217;s district.</span></span></label>
+        <span class="set-hint" id="ng-extra-hint"></span>
+      </div>
+      </div>
+
+      <div class="set-group">
+      <h3>Revenue</h3>
+      <p class="ng-note">What each piece of work pays, 0 to 5. A coach pays when it is boarded and
+         again when it is detrained; a load pays when it is made up and again when it is broken. Zero
+         switches an economy off so the others can be read.</p>
+      <div class="set-row" id="ng-passenger-row">
+        <label class="ng-num"><span>Passenger revenue per coach</span>
+          <input id="ng-passenger" type="number" min="0" max="5" step="1" value="1"></label>
+        <span class="set-hint" id="ng-passenger-hint"></span>
+      </div>
+      <div class="set-row" id="ng-freight-row">
+        <label class="ng-num"><span>Freight revenue per load</span>
+          <input id="ng-freight" type="number" min="0" max="5" step="1" value="1"></label>
+        <span class="set-hint" id="ng-freight-hint"></span>
+      </div>
+      <div class="set-row" id="ng-transit-row">
+        <label class="ng-num"><span>Train revenue per transit</span>
+          <input id="ng-transit" type="number" min="0" max="5" step="1" value="0"></label>
+        <span class="set-hint" id="ng-transit-hint"></span>
+      </div>
+      <p class="ng-note">A transit pays every player, once, when a train runs off the end of the
+         Division — the one thing nobody has to work for.</p>
+      </div>
+
+      <div class="set-group">
+      <h3>Victory conditions</h3>
+      <p class="ng-note">The ways this game can end badly. Each one is switched on or off in its own
+         right; how long the game runs is set above, with the table size.</p>
+      <div class="set-row" id="ng-minrev-row">
+        <label class="ng-gate"><input type="checkbox" id="ng-minrev-on" checked>
+          <span>Everyone loses if combined Revenue at the end is under</span>
+          <input id="ng-minrev" type="number" min="0" step="1" class="gate-num"></label>
+        <span class="set-hint" id="ng-minrev-hint"></span>
+      </div>
+      <div class="set-row" id="ng-colday-row">
+        <label class="ng-gate"><input type="checkbox" id="ng-colday-on" checked>
+          <span>The game ends and everyone loses if collisions in one Day reach</span>
+          <input id="ng-colday" type="number" min="0" step="1" class="gate-num"></label>
+        <span class="set-hint" id="ng-colday-hint"></span>
+      </div>
+      <div class="set-row" id="ng-coltotal-row">
+        <label class="ng-gate"><input type="checkbox" id="ng-coltotal-on" checked>
+          <span>The game ends and everyone loses after this many collisions in the whole game</span>
+          <input id="ng-coltotal" type="number" min="0" step="1" class="gate-num"></label>
+        <span class="set-hint" id="ng-coltotal-hint"></span>
+      </div>
+      <p class="ng-note">The opponent-directed cards — Derail, Watertower, Hobo Jungle and the
+         nineteen others, along with the seven that answer them — are not implemented yet, so no game
+         type deals them whatever else is set here.</p>
+      </div>
+
+      <div class="set-group">
+      <h3>Optional rules</h3>
+      <p class="ng-note">Off in every game type; each one changes how the game plays.</p>
+      <div class="set-row" id="ng-visibility-row">
+        <label class="ng-num"><span>Reduced Visibility — five switching Moves instead of six in the
+          night Stages (1&ndash;3 and 11&ndash;12)</span>
+          <input id="ng-visibility" type="checkbox"></label>
+        <span class="set-hint" id="ng-visibility-hint"></span>
+      </div>
+      <div class="set-row" id="ng-rotation-row">
+        <label class="ng-num"><span>Employee Rotation — at the end of each Day everyone moves one
+          chair left and takes over the next station up the line. Your Revenue and the Fedora go with
+          you; the district stays where it is</span>
+          <input id="ng-rotation" type="checkbox"></label>
+        <span class="set-hint" id="ng-rotation-hint"></span>
+      </div>
+      <div class="set-row" id="ng-toolbox-row">
+        <label class="ng-num"><span>Emergency Toolbox — everyone starts holding a Red Flag, so a hand
+          of four; play or discard down to three on the first turn</span>
+          <input id="ng-toolbox" type="checkbox"></label>
+        <span class="set-hint" id="ng-toolbox-hint"></span>
+      </div>
+      <div class="set-row" id="ng-tossloco-row">
+        <label class="ng-num"><span>A Timetabled train may be discarded — toss it face-up to a
+          Department slot, where a rival may pick it up. Turn this off and a train card can only ever
+          be played onto the timetable. An Extra is never discardable either way</span>
+          <input id="ng-tossloco" type="checkbox"></label>
+        <span class="set-hint" id="ng-tossloco-hint"></span>
+      </div>
+      </div>
+
+      </div>
+    </details>
 
     <menu class="ng-buttons">
       <span class="ng-note" id="ng-multiplayer-note" style="margin:0 auto 0 0">Use the <b>Multiplayer</b> button instead — it creates or joins a game on this server.</span>
@@ -525,6 +877,31 @@ ul.blocked li{padding:2px 0}
   </form>
 </dialog>
 
+<!-- THE DAY ROLLING OVER (Gitea#10). A Day turns inside the automatic phases, so it happens
+     between one click and the next; the phase banner and the announcement flash both fade before
+     someone reading the board notices them. A modal stops and waits, which is the whole request:
+     "hard to keep track of time". Filled by `dayEndHtml` and opened from `render()`. -->
+<dialog id="dayenddlg" aria-labelledby="de-title">
+  <form method="dialog">
+    <div id="dayendbody"></div>
+    <menu class="ng-buttons">
+      <button value="ok" id="de-ok" type="submit">Carry on</button>
+    </menu>
+  </form>
+</dialog>
+
+<!-- THE HANDOFF, between `Lobby.Start` and the first Frame.
+     `beginRemote` used to write "… connecting to the game" into `#presence` — the DISCONNECT banner,
+     whose job is `⚠ waiting on Alice`. It worked only because the first render overwrote it, and it
+     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,365 @@
+/**
+ * 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;
+  /** §6.2 (Gitea#9) — may a Timetabled train be thrown away? An Extra never may, whatever this says. */
+  discardTimetabled: boolean;
+};
+
+export const SETTING_KEYS: readonly (keyof Settings)[] = [
+  'startingHand',
+  'extraStart',
+  'passengerPerCoach',
+  'freightPerLoad',
+  'trainPerTransit',
+  'minCombinedRevenue',
+  'maxCollisionsPerDay',
+  'maxCollisionsTotal',
+  'reducedVisibility',
+  'employeeRotation',
+  'emergencyToolbox',
+  'discardTimetabled',
+];
+
+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,
+  /**
+   * ON in every type (Gitea#9). Jesse's ruling is the rule now, and the setting exists so a table
+   * can put Gitea#6's pressure back rather than so a type can choose for them — the reasoning is
+   * about how long a game runs, which is a dial the table already sets for itself.
+   */
+  discardTimetabled: true,
+} 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,
+    discardTimetabled: rules.discardTimetabled,
+  };
+}
+
+/** 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; discardTimetabled: boolean };
+}): 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,
+      // Carried like the rest: this path describes SOMEONE ELSE'S game to a joiner, so a setting
+      // dropped here shows them a rule the table is not playing (§6.2, Gitea#9).
+      discardTimetabled: f.houseRules.discardTimetabled,
+      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,
+      discardTimetabled: settings.discardTimetabled,
+      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: () => [],
+    // Draining, exactly as the local session's are: each of these marks a moment, so it plays once
-    takeScheduled: () => null,
+    // and is gone by the next render rather than re-firing on every redraw.
-    takeAnnouncement: () => null,
+    takeCues: () => {
-    justDrawn: () => null,
+      const out = cues;
-    presence: () => [...presence].map(([s, connected]) => ({ seat: s, connected })),
+      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,358 @@
+/**
+ * THE RULES BLOCK, driven identically on both screens.
+ *
+ * The lobby (`lobby.ts`) and the solitaire New Game dialog (`main.ts`) ask the same twelve 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' },
+  { key: 'discardTimetabled', kind: 'checkbox', id: 'tossloco' },
+];
+
+/**
+ * What `play.html` must contain for a screen to be able to ask all twelve 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',
+  discardTimetabled: 'A Timetabled train may be discarded',
+  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>Train cards</h4><dl>${rows(['discardTimetabled'])}</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,
+      discardTimetabled: el<HTMLInputElement>('tossloco')?.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);
+    setChecked('tossloco', values.discardTimetabled);
+  }
+
+  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

@@ -8,12 +8,12 @@ import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 
 import { advance, pump } from '../src/engine/advance.ts';
-import { applyIntent, areaOf, check } from '../src/engine/apply.ts';
+import { applyIntent, areaOf, check, isBeingMadeUp } from '../src/engine/apply.ts';
-import { EXPEDITE_FAULT_PENALTY, HAND_LIMIT, STAGES_PER_DAY, TOTAL_ROLLING_STOCK } from '../src/engine/content.ts';
+import { EXPEDITE_FAULT_PENALTY, HAND_LIMIT, MAX_CONSIST, STAGES_PER_DAY, TOTAL_ROLLING_STOCK } from '../src/engine/content.ts';
 import { legalActions } from '../src/engine/legal.ts';
 import { createGame } from '../src/engine/setup.ts';
 import { developerBot } from '../src/sim/bot.ts';
-import type { CrewTray, GameConfig, GameState } from '../src/engine/state.ts';
+import type { CrewTray, DivisionNode, GameConfig, GameState } from '../src/engine/state.ts';
 import { coordKey, railFacingOf } from '../src/engine/state.ts';
 
 const baseConfig = (over: Partial<GameConfig> = {}): GameConfig => ({
@@ -1019,19 +1019,25 @@ describe('the history says WHY a train moved, and says it truthfully', () => {
 
 // ---------------------------------------------------------------------------
 
-describe('an Extra starts where its number sends it, or at a Control Point', () => {
+describe('an Extra starts where the player puts it (Gitea#4)', () => {
   /**
-   * REPORTED: "Extras should start at Eastern or Western Division point based on their numbers. Even
+   * REPORTED, v0.4.9e: "When extras are played the player doing so may choose where the extra
-   * trains run to the east (start at western DP), odd run to the west (start at eastern DP). They
+   * starts. They may choose either division point. And if the interchange mainline card has been
-   * can also start at a control point (any office except whistlepost) at player's choice."
+   * played, they may start the extra on that card and choose the direction from there. If there is
+   * potential for conflict with other trains in that area the superintendent may hold the extra."
    *
-   * Every Extra used to launch eastbound from the West Division Point, hardcoded, with the
+   * This SUPERSEDES the earlier ruling these tests used to assert — "the number decides, like
-   * simplification flagged in a comment — so half the Extras ran the wrong way and the Control Point
+   * everything else on the timetable" — for Extras only. The number still decides for a timetabled
-   * option did not exist at all.
+   * train. The reason the two cannot both hold: an odd (westbound) Extra placed at the WEST end
+   * would leave the Division on its first move having crossed nothing, and be paid for the run.
+   *
+   * So: the start decides the direction. A Division Point runs the train away from itself; in the
+   * middle of the railroad — an Interchange, a Control Point — the player says which way.
    */
   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';
@@ -1045,6 +1051,14 @@ describe('an Extra starts where its number sends it, or at a Control Point', ()
     return tray;
   };
 
+  /** Turn one Mainline card into an Interchange, and say which node it is. */
+  const withInterchange = (s: GameState): number => {
+    const i = s.division.nodes.findIndex((n) => n.kind === 'mainline');
+    const node = s.division.nodes[i]!;
+    if (node.kind === 'mainline') node.card = 'interchange';
+    return i;
+  };
+
   it('stops for the decision instead of launching the train itself', () => {
     const s = pending(17);
     assert.equal(s.clock.phase, 'newTrain');
@@ -1055,36 +1069,46 @@ describe('an Extra starts where its number sends it, or at a Control Point', ()
     );
   });
 
-  it('sends an odd Extra west from the EASTERN Division Point', () => {
+  it('offers BOTH Division Points, not the one the number would dictate', () => {
-    // §2.3 — odd runs west. It therefore starts at the end it runs away from.
     const s = pending(17);
-    assert.ok(applyIntent(s, 0, { type: 'newTrain.startExtra', trainNumber: 17, atSeat: null }).ok);
+    const sides = legalActions(s, 0)
-    const tray = started(s);
+      .filter((i) => i.type === 'newTrain.startExtra' && i.start?.kind === 'divisionPoint')
-    assert.equal(tray.direction, 'west');
+      .map((i) => (i.type === 'newTrain.startExtra' && i.start?.kind === 'divisionPoint' ? i.start.side : ''));
-    assert.equal(tray.position.at === 'divisionPoint' && tray.position.side, 'east');
+    assert.deepEqual([...sides].sort(), ['east', 'west']);
   });
 
-  it('sends an even Extra east from the WESTERN Division Point', () => {
+  it('runs an Extra AWAY from the Division Point it was placed at, whatever its number', () => {
-    const s = pending(18);
+    // X17 is odd. Under the superseded rule it could only ever start at the East end and run west.
-    assert.ok(applyIntent(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, atSeat: null }).ok);
+    for (const [side, direction] of [['west', 'east'], ['east', 'west']] as const) {
-    const tray = started(s);
+      const s = pending(17);
-    assert.equal(tray.direction, 'east');
+      const r = applyIntent(s, 0, {
-    assert.equal(tray.position.at === 'divisionPoint' && tray.position.side, 'west');
+        type: 'newTrain.startExtra', trainNumber: 17, start: { kind: 'divisionPoint', side },
+      });
+      assert.ok(r.ok, `the ${side} Division Point was refused: ${r.ok ? '' : r.code}`);
+      const tray = started(s);
+      assert.equal(tray.direction, direction, `an Extra at the ${side} end must run ${direction}`);
+      assert.equal(tray.position.at === 'divisionPoint' && tray.position.side, side);
+    }
   });
 
-  it('refuses a Whistle Post, which is not a Control Point', () => {
+  it('refuses a Whistle Post, which is not a Control Point, at every setting of the house rule', () => {
-    const s = pending(18);
+    for (const extraStart of ['divisionPointsOnly', 'ownOffice', 'anyOffice'] as const) {
-    assert.equal(s.officeAreas.get(0)!.tier, 'whistlePost');
+      const s = pending(18);
-    assert.equal(
+      s.config = { ...s.config, houseRules: { ...s.config.houseRules, extraStart } };
-      check(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, atSeat: 0 }),
+      assert.equal(s.officeAreas.get(0)!.tier, 'whistlePost');
-      'NOT_A_CONTROL_POINT',
+      const code = check(s, 0, {
-    );
+        type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'office', seat: 0 }, direction: 'east',
+      });
+      assert.ok(code !== null, `a Whistle Post was allowed under ${extraStart}`);
+    }
   });
 
   it('starts at a Control Point when the player picks one, taking an A/D track', () => {
     // Upgrading the Office is what buys this: a Depot is a Control Point, a Whistle Post is not.
     const s = pending(18, 'depot');
-    const r = applyIntent(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, atSeat: 0 });
+    const r = applyIntent(s, 0, {
+      type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'office', seat: 0 }, direction: 'west',
+    });
     assert.ok(r.ok, `starting at the Depot was refused: ${r.ok ? '' : r.code}`);
     const tray = started(s);
     const area = s.officeAreas.get(0)!;
@@ -1095,16 +1119,240 @@ describe('an Extra starts where its number sends it, or at a Control Point', ()
       'the Extra did not start on the Office card',
     );
     assert.ok(area.adOccupancy.includes(tray.id), 'it did not take an A/D track');
-    assert.equal(tray.direction, 'east', 'an even Extra still runs east from wherever it starts');
+    // The point of the change: an EVEN Extra running WEST, because the player said so.
+    assert.equal(tray.direction, 'west', 'the direction the player chose was not honoured');
+  });
+
+  it('needs a direction anywhere that is not an end of the Division', () => {
+    const s = pending(18, 'depot');
+    assert.equal(
+      check(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'office', seat: 0 } }),
+      'NO_DIRECTION_CHOSEN',
+    );
+  });
+
+  it('honours the extraStart house rule for Office starts, and never for the shared ground', () => {
+    for (const [extraStart, code] of [
+      ['divisionPointsOnly', 'OFFICE_STARTS_NOT_ALLOWED'],
+      ['anyOffice', null],
+    ] as const) {
+      const s = pending(18, 'depot');
+      s.config = { ...s.config, houseRules: { ...s.config.houseRules, extraStart } };
+      assert.equal(
+        check(s, 0, {
+          type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'office', seat: 0 }, direction: 'east',
+        }),
+        code,
+        `office start under ${extraStart}`,
+      );
+      // The Division Points belong to nobody, so no setting ever closes them.
+      assert.equal(
+        check(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'divisionPoint', side: 'west' } }),
+        null,
+      );
+    }
+  });
+
+  it('starts at an Interchange in the players yard, not out on the running line', () => {
+    const s = pending(18);
+    const node = withInterchange(s);
+    const r = applyIntent(s, 0, {
+      type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'mainline', node }, direction: 'east',
+    });
+    assert.ok(r.ok, `the Interchange was refused: ${r.ok ? '' : r.code}`);
+    const tray = started(s);
+    const card = s.division.nodes[node]!;
+    assert.equal(tray.direction, 'east');
+    assert.deepEqual(tray.position, { at: 'mainline', index: node });
+    assert.ok(card.kind === 'mainline' && card.holding?.includes(tray.id), 'it is not in the yard');
+    assert.equal(card.kind === 'mainline' && card.transits.length, 0, 'it was put on the running line');
+  });
+
+  it('refuses any Mainline card that is not an Interchange', () => {
+    const s = pending(18);
+    const plains = s.division.nodes.findIndex((n) => n.kind === 'mainline');
+    const node = s.division.nodes[plains]!;
+    if (node.kind === 'mainline') node.card = 'plains';
+    assert.equal(
+      check(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'mainline', node: plains }, direction: 'east' }),
+      'NOT_AN_INTERCHANGE',
+    );
+  });
+
+  it('may be started at an Interchange however busy the card is — the yard forces no collision', () => {
+    const s = pending(18);
+    const node = withInterchange(s);
+    const card = s.division.nodes[node]!;
+    // Nose to tail with opposing traffic. §7: placing here still must not force a collision.
+    if (card.kind === 'mainline') {
+      card.transits.push({ tray: 'tray9', stagesRemaining: 2, stagesTotal: 2, direction: 'west' });
+    }
+    assert.equal(
+      check(s, 0, { type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'mainline', node }, direction: 'east' }),
+      null,
+    );
+  });
+
+  /**
+   * §7's last clause, and the reason the Interchange start is modelled as a yard at all: "If there
+   * is potential for conflict with other trains in that area the superintendent may hold the extra."
+   *
+   * Jesse's split: a GUARANTEED collision holds the train at the Interchange for another Stage and
+   * it tries again; a POTENTIAL one is the Superintendent's to rule on. Those are exactly §8.1's
+   * two answers, so the Extra highballs out of the yard through `evaluateClearance` — the same
+   * check a train leaving a Division Point goes through — rather than through anything new.
+   */
+  describe('highballing out of the Interchange yard', () => {
+    /** A pending X18 sitting in the yard of an Interchange, with the terrain pinned. */
+    const inYard = (): { s: GameState; node: number; tray: CrewTray } => {
+      const s = pending(18);
+      const node = withInterchange(s);
+      const r = applyIntent(s, 0, {
+        type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'mainline', node }, direction: 'east',
+      });
+      assert.ok(r.ok, `the Interchange was refused: ${r.ok ? '' : r.code}`);
+      s.clock.phase = 'mainline';
+      s.movedThisPhase = new Set();
+      return { s, node, tray: started(s) };
+    };
+
+    const card = (s: GameState, node: number): Extract<DivisionNode, { kind: 'mainline' }> => {
+      const n = s.division.nodes[node]!;
+      assert.equal(n.kind, 'mainline');
+      return n as Extract<DivisionNode, { kind: 'mainline' }>;
+    };
+
+    it('pulls out onto the card at the next Mainline Phase when the Subdivision is clear', () => {
+      const { s, node, tray } = inYard();
+      advance(s);
+      const n = card(s, node);
+      assert.deepEqual(n.holding, [], 'it never left the yard');
+      assert.ok(n.transits.some((t) => t.tray === tray.id), 'it is not on the running line');
+    });
+
+    it('is held in the yard by a facing train, and tries again the next Stage', () => {
+      const { s, node, tray } = inYard();
+      // Westbound, against an eastbound Extra: §8.1 calls that an absolute bar, not a judgment call.
+      card(s, node).transits.push({ tray: 'facing', stagesRemaining: 2, stagesTotal: 2, direction: 'west' });
+      s.trays.set('facing', {
+        id: 'facing', trainNumber: 3, trainIsExtra: false, engineAt: 0, consist: [],
+        direction: 'west', position: { at: 'mainline', index: node }, movesUsed: 0,
+      });
+
+      const r = advance(s);
+      assert.equal(r.needsInput ?? false, false, 'a guaranteed collision is not a question to ask');
+      assert.equal(s.clock.pendingDecision, null);
+      assert.ok(card(s, node).holding?.includes(tray.id), 'it was not held in the yard');
+      assert.ok(
+        !card(s, node).transits.some((t) => t.tray === tray.id),
+        'it pulled out in front of a train coming the other way',
+      );
+      assert.ok(s.trays.has(tray.id), 'the Extra was destroyed rather than held');
+
+      // AND IT TRIES AGAIN. The Extra waits in the yard, not on the pending list, so once the road
+      // clears the next Mainline Phase takes it out with no further intervention.
+      s.trays.delete('facing');
+      card(s, node).transits = [];
+      s.clock.phase = 'mainline';
+      s.movedThisPhase = new Set();
+      advance(s);
+      assert.deepEqual(card(s, node).holding, [], 'it did not try again once the road was clear');
+      assert.ok(card(s, node).transits.some((t) => t.tray === tray.id), 'it never pulled out');
+    });
+
+    it('puts a following train to the Superintendent rather than holding it automatically', () => {
+      const { s, node, tray } = inYard();
+      // Same direction: §8.1's judgment call, which is what "may hold the extra" means.
+      card(s, node).transits.push({ tray: 'ahead', stagesRemaining: 2, stagesTotal: 2, direction: 'east' });
+      s.trays.set('ahead', {
+        id: 'ahead', trainNumber: 4, trainIsExtra: false, engineAt: 0, consist: [],
+        direction: 'east', position: { at: 'mainline', index: node }, movesUsed: 0,
+      });
+
+      const r = advance(s);
+      assert.equal(r.needsInput, true, 'the phase must stop and ask');
+      assert.equal(s.clock.pendingDecision?.train, tray.id);
+      assert.equal(s.clock.pendingDecision?.occupiedBy, 'ahead');
+
+      // HOLD keeps it in the yard.
+      assert.ok(applyIntent(s, s.clock.superintendent, { type: 'mainline.clearance', allow: false }).ok);
+      advance(s);
+      assert.ok(card(s, node).holding?.includes(tray.id), 'the Superintendent held it and it left anyway');
+    });
+  });
+
+  /**
+   * FOUND BY PLAYING IT, not by the tests above: an Extra started anywhere but a Division Point was
+   * never offered a car and ran empty.
+   *
+   * `isBeingMadeUp` asked only "is this tray standing at a Division Point", which was the whole
+   * truth while that was the only place to build a train. The Control Point start has therefore
+   * shipped since it was added with a train that could not be loaded, and the Interchange start
+   * would have shipped the same way — against Jesse's report, which says an Extra started at the
+   * Interchange "would be Loaded with cars".
+   */
+  describe('an Extra started away from a Division Point can still be made up', () => {
+    const fill = (s: GameState): string[] => {
+      for (let i = 0; i < MAX_CONSIST + 1; i++) {
+        const options = legalActions(s, s.clock.currentActor ?? 0).filter((a) => a.type === 'newTrain.placeCar');
+        if (options.length === 0) break;
+        assert.ok(applyIntent(s, s.clock.currentActor ?? 0, options[0]!).ok);
+      }
+      return started(s).consist.map((c) => c.type);
+    };
+
+    it('takes a consist in the Interchange yard', () => {
+      const s = pending(18);
+      const node = withInterchange(s);
+      assert.ok(applyIntent(s, 0, {
+        type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'mainline', node }, direction: 'east',
+      }).ok);
+      assert.ok(fill(s).length > 0, 'the Extra was never offered a car and would have run empty');
+    });
+
+    it('takes a consist at a Control Point', () => {
+      const s = pending(18, 'depot');
+      assert.ok(applyIntent(s, 0, {
+        type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'office', seat: 0 }, direction: 'east',
+      }).ok);
+      assert.ok(fill(s).length > 0, 'the Extra was never offered a car and would have run empty');
+    });
+
+    it('stops being made up the moment it starts running', () => {
+      // Otherwise a train out on the Mainline could be handed cars from the Division Yard — the
+      // "cars appearing on a train nobody was making up" bug `isBeingMadeUp` exists to prevent.
+      const s = pending(18);
+      const node = withInterchange(s);
+      assert.ok(applyIntent(s, 0, {
+        type: 'newTrain.startExtra', trainNumber: 18, start: { kind: 'mainline', node }, direction: 'east',
+      }).ok);
+      const tray = started(s);
+      s.clock.phase = 'mainline';
+      s.movedThisPhase = new Set();
+      advance(s);
+      assert.equal(s.trays.get(tray.id)?.beingMadeUp, undefined, 'a running train is still being made up');
+      assert.equal(isBeingMadeUp(s.trays.get(tray.id)!), false);
+    });
+  });
+
+  it('replays a save written before the choice existed exactly as it meant it', () => {
+    /**
+     * A save is a seed and a list of intents, so an intent whose meaning moves is a save that
+     * quietly replays as a different game. The legacy shape carried only `atSeat`: null meant the
+     * Division Point the NUMBER sent it to, running in the number's direction.
+     */
+    const s = pending(17);
+    assert.ok(applyIntent(s, 0, { type: 'newTrain.startExtra', trainNumber: 17, atSeat: null }).ok);
+    const tray = started(s);
+    assert.equal(tray.direction, 'west', 'the legacy intent stopped meaning what it meant');
+    assert.equal(tray.position.at === 'divisionPoint' && tray.position.side, 'east');
   });
 
   it('takes the Extra off the pending list once, whichever end it started from', () => {
     const s = pending(17);
-    assert.ok(applyIntent(s, 0, { type: 'newTrain.startExtra', trainNumber: 17, atSeat: null }).ok);
+    const at = { type: 'newTrain.startExtra', trainNumber: 17, start: { kind: 'divisionPoint', side: 'east' } } as const;
+    assert.ok(applyIntent(s, 0, at).ok);
     assert.deepEqual(s.pendingExtras, []);
-    assert.equal(
+    assert.equal(check(s, 0, at), 'NO_EXTRA_PENDING');
-      check(s, 0, { type: 'newTrain.startExtra', trainNumber: 17, atSeat: null }),
-      'NO_EXTRA_PENDING',
-    );
   });
 });

test/apply.test.ts

@@ -7,6 +7,7 @@ import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 
 import { applyIntent, check, areaOf, facilityCarTypes, movesFor, reduce } from '../src/engine/apply.ts';
+import { pump } from '../src/engine/advance.ts';
 import { HAND_LIMIT, INDUSTRY_PROFILES, MAX_CONSIST, MOVES_PER_LOCAL_OPS, officeProfile } from '../src/engine/content.ts';
 import type { Intent } from '../src/engine/intents.ts';
 import { legalActions } from '../src/engine/legal.ts';
@@ -261,6 +262,189 @@ describe('Local Operations: drawing (§6.2)', () => {
     assert.equal(check(s, 0, { type: 'draw.end' }), null, 'the turn cannot be ended even at the limit');
   });
 
+  describe('which train cards may be discarded (Gitea#9, superseding Gitea#6)', () => {
+    /**
+     * Gitea#6's ruling, v0.4.9e playtest, was that NO train card may be discarded. Gitea#9 narrows
+     * it — Jesse, 2026-08-24: "Timetabled trains are at the choice of the player: they can either
+     * play or discard. If someone else wants to pick it up, they are more than able to. The reason:
+     * I don't want, if you decide to play a game longer than five days, to decide that maybe there
+     * are too many trains, the stations are jammed, and the railroad doesn't need any more."
+     *
+     * So a Timetabled train is discardable, an EXTRA still is not — it never joins the timetable, so
+     * it cannot be what jams it — and whether the Timetabled half applies is a New Game setting,
+     * because the reasoning is about long games and a five-Day game may want Gitea#6's pressure.
+     *
+     * Note there is still no FORCING mechanism, and deliberately so: the corner is what the two
+     * existing rules produce together whenever the setting is off.
+     */
+    const handOf = (s: GameState, kinds: string[]): string[] => {
+      // Hand-pick cards of the wanted kinds straight out of the catalogue, so the test does not
+      // depend on what the shuffle happened to deal.
+      const picked: string[] = [];
+      for (const want of kinds) {
+        for (const [id, card] of s.cards) {
+          if (card.kind.kind !== want || picked.includes(id)) continue;
+          picked.push(id);
+          break;
+        }
+      }
+      assert.equal(picked.length, kinds.length, 'the catalogue is missing a card this test needs');
+      s.decks.hands.set(0, picked);
+      return picked;
+    };
+
+    /** The same game with the setting turned off — Gitea#6's rule, still reachable. */
+    const strictGame = (): GameState =>
+      createGame({
+        id: 'g',
+        seed: 77,
+        config: { ...config, houseRules: { ...(config.houseRules ?? {}), discardTimetabled: false } },
+        playerNames: ['Jesse'],
+      });
+
+    it('lets a Timetabled train be discarded, and still refuses an Extra', () => {
+      const s = game();
+      applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
+      const [timetabled, extra, track] = handOf(s, ['timetabledTrain', 'extraTrain', 'track']);
+      assert.equal(
+        check(s, 0, { type: 'card.discard', cardId: timetabled!, toSlot: 0 }),
+        null,
+        'Gitea#9 allows this and it was refused',
+      );
+      assert.equal(
+        check(s, 0, { type: 'card.discard', cardId: extra!, toSlot: 0 }),
+        'TRAINS_ARE_NEVER_DISCARDED',
+        'an Extra never joins the timetable, so Gitea#9 does not reach it',
+      );
+      assert.equal(check(s, 0, { type: 'card.discard', cardId: track!, toSlot: 0 }), null);
+    });
+
+    it('puts the discarded train where a rival can pick it up', () => {
+      // The other half of the ruling — "if someone else wants to pick it up, they are more than able
+      // to" — needed no machinery, because a discard already goes face-up onto a Department pile.
+      const s = game();
+      applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
+      const [timetabled] = handOf(s, ['timetabledTrain', 'track']);
+      assert.ok(applyIntent(s, 0, { type: 'card.discard', cardId: timetabled!, toSlot: 1 }).ok);
+      const pile = s.decks.departments[1]!;
+      assert.equal(pile[pile.length - 1], timetabled, 'the train is not face-up on the pile');
+    });
+
+    it('offers the discard as a legal action, so the bot can take it', () => {
+      const s = game();
+      applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
+      const [timetabled, extra] = handOf(s, ['timetabledTrain', 'extraTrain', 'track']);
+      const offered = legalActions(s, 0).filter((i) => i.type === 'card.discard');
+      assert.ok(
+        offered.some((i) => i.type === 'card.discard' && i.cardId === timetabled),
+        'a Timetabled train was not offered as a discard',
+      );
+      assert.ok(
+        !offered.some((i) => i.type === 'card.discard' && i.cardId === extra),
+        'an Extra was offered as a discard',
+      );
+    });
+
+    it('keeps Gitea#6 reachable when the setting is off', () => {
+      const s = strictGame();
+      applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
+      const [timetabled, extra, track] = handOf(s, ['timetabledTrain', 'extraTrain', 'track']);
+      for (const id of [timetabled!, extra!]) {
+        assert.equal(
+          check(s, 0, { type: 'card.discard', cardId: id, toSlot: 0 }),
+          'TRAINS_ARE_NEVER_DISCARDED',
+        );
+      }
+      assert.equal(check(s, 0, { type: 'card.discard', cardId: track!, toSlot: 0 }), null);
+    });
+
+    it('leaves PLAYING a train as the only way out of a hand of four, setting off', () => {
+      const s = strictGame();
+      applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
+      const four = handOf(s, ['timetabledTrain', 'timetabledTrain', 'timetabledTrain', 'extraTrain']);
+      assert.ok(four.length > HAND_LIMIT, 'this test needs a hand over the limit');
+
+      // Over the limit, so the turn cannot be ended...
+      assert.equal(check(s, 0, { type: 'draw.end' }), 'HAND_LIMIT');
+      // ...and not one of them may be discarded...
+      for (const id of four) {
+        assert.equal(check(s, 0, { type: 'card.discard', cardId: id, toSlot: 0 }), 'TRAINS_ARE_NEVER_DISCARDED');
+      }
+      // ...but playing one is always legal, so the player is never actually stuck.
+      assert.equal(check(s, 0, { type: 'card.play', cardId: four[0]! }), null);
+      assert.ok(applyIntent(s, 0, { type: 'card.play', cardId: four[0]! }).ok);
+      assert.equal(s.decks.hands.get(0)!.length, HAND_LIMIT);
+      assert.equal(check(s, 0, { type: 'draw.end' }), null, 'playing a train did not free the turn');
+    });
+
+    it('a hand of four Extras is the corner that survives Gitea#9 with the setting ON', () => {
+      // Gitea#9 does not reach an Extra, so the deadlock-that-is-not-a-deadlock is still real in a
+      // default game — worth pinning, since it is now the ONLY way to reach it.
+      const s = game();
+      applyIntent(s, 0, { type: 'localOps.choose', option: 'draw' });
+      const four = handOf(s, ['extraTrain', 'extraTrain', 'extraTrain', 'extraTrain']);
+      assert.equal(check(s, 0, { type: 'draw.end' }), 'HAND_LIMIT');
+      for (const id of four) {
+        assert.equal(check(s, 0, { type: 'card.discard', cardId: id, toSlot: 0 }), 'TRAINS_ARE_NEVER_DISCARDED');
+      }
+      assert.ok(applyIntent(s, 0, { type: 'card.play', cardId: four[0]! }).ok);
+      assert.equal(check(s, 0, { type: 'draw.end' }), null);
+    });
+
+    it('lets a train be held across Stages and into the next Day', () => {
+      // "They may keep the card in their hand for multiple stages and even multiple days." Nothing
+      // sweeps a hand at a Stage or Day boundary, and this is what says so out loud. An Extra is
+      // used, because it is the card that still cannot be got rid of any other way.
+      const s = game();
+      const [extra] = handOf(s, ['extraTrain', 'track']);
+      const startDay = s.clock.day;
+
+      // Play out Stages by taking whatever ends the current turn, until the Day turns over.
+      for (let guard = 0; guard < 400 && s.clock.day === startDay; guard++) {
+        pump(s);
+        const actor = s.clock.currentActor;
+        if (actor === null) break;
+        const options = legalActions(s, actor);
+        const end = options.find((i) => i.type.endsWith('.end')) ?? options[0];
+        if (!end) break;
+        applyIntent(s, actor, end);
+      }
+
+      assert.ok(s.clock.day > startDay, `the Day never turned (stopped at ${s.clock.day}/${s.clock.stage})`);
+      assert.ok(
+        (s.decks.hands.get(0) ?? []).includes(extra!),
+        'the train did not survive being held into the next Day',
+      );
+      assert.equal(
+        check(s, 0, { type: 'card.discard', cardId: extra!, toSlot: 0 }),
+        'TRAINS_ARE_NEVER_DISCARDED',
+        'a Day boundary made an Extra discardable',
+      );
+    });
+
+    it('tells the player on the card itself which of the two rules applies', () => {
+      // The Gitea#2 lesson: a rule the player cannot see is a board with nothing to click and no
+      // reason given. Since Gitea#9 there are TWO reasons, so the card has to say which.
+      const s = game();
+      handOf(s, ['timetabledTrain', 'extraTrain', 'track']);
+      const f = snapshot(s, [], null);
+      // `hand` is reversed for display, so compare as a set rather than by position.
+      assert.deepEqual([...f.handDiscardable].sort(), [false, true, true]);
+      const said = f.handKeepWhy.filter((w): w is string => w !== null);
+      assert.equal(said.length, 1, 'exactly one card in this hand may not be discarded');
+      assert.match(said[0]!, /An Extra is never discarded/);
+
+      const strict = strictGame();
+      handOf(strict, ['timetabledTrain', 'extraTrain', 'track']);
+      const sf = snapshot(strict, [], null);
+      assert.deepEqual([...sf.handDiscardable].sort(), [false, false, true]);
+      assert.ok(
+        sf.handKeepWhy.some((w) => w !== null && /never discarded in this game/.test(w)),
+        'the setting being off is not explained on the card',
+      );
+    });
+  });
+
   it('discards face up ON TOP of a chosen Department, burying what was there', () => {
     // The choice of WHICH Department is the strategy: a card put on an empty-ish pile is an offer, a
     // card put on top of one a rival wants takes that card out of reach. Overwriting the slot — what
@@ -1286,9 +1470,11 @@ describe("a Modifier grants only what its host's flow can use", () => {
      * and saying so is what the panel is for. Losing it FOREVER was the bug: the upgrade applied
      * only the difference between two tiers and knew nothing about what had been discarded.
      *
-     * This used to be written against an Ice House on a Grocer's Warehouse. That case no longer
+     * This used to be written against an Ice House on a Grocer's Warehouse, which suppresses again
-     * suppresses anything, because the Grocer's is a both-direction facility — which was the other
+     * now that the Grocer's is inbound-only (v0.4.9e). The Office was chosen instead because the
-     * half of the same report.
+     * suppression there is TEMPORARY — an upgrade can lift it — and losing the grant forever across
+     * that upgrade was the bug. A Grocer's never ships, so its Ice House is suppressed permanently
+     * and tests nothing about the upgrade path.
      */
     const s = game();
     const area = areaOf(s, 0);
@@ -1897,3 +2083,268 @@ describe('the switching job a player actually does: put a car in a siding, take
     );
   });
 });
+
+// ---------------------------------------------------------------------------
+
+/**
+ * The v0.4.9d playtest, three reports with two causes.
+ *
+ * "Freight House: boxcars loaded cannot be immediately unloaded", "passenger stations: passengers
+ * just boarded cannot be immediately unloaded" — one rule, `RollingStock.origin`. And "operating two
+ * trains in a station: the select button does not work, regardless of which you pick it is always
+ * one train, not the other" — the porter intents carrying no tray.
+ */
+describe('a load may not be broken in the district that made it (v0.4.9e)', () => {
+  const office = (s: GameState) => areaOf(s, 0).grid.get(coordKey(areaOf(s, 0).officeCoord))!.facility!;
+
+  /** An Office that can work passengers, with someone waiting and Porters to hand. */
+  function platform(s: GameState): void {
+    const f = office(s);
+    f.allows = { outbound: true, inbound: true };
+    f.porters = 4;
+    f.capacity = { outbound: 2, inbound: 2 };
+    f.outboundBox = [{ type: 'coach', loaded: true }];
+    s.yards.divisionYard.push({ type: 'coach', loaded: false });
+    s.clock.phase = 'loadUnload';
+    s.clock.currentActor = 0;
+  }
+
+  /** A tray standing on an A/D track at the Office. */
+  function atOffice(s: GameState, consist: CrewTray['consist']): string {
+    const id = s.freeTrays.pop()!;
+    s.trays.set(id, {
+      id, trainNumber: null, trainIsExtra: false, engineAt: 0, consist,
+      direction: 'east', position: { at: 'grid', seat: 0, coord: areaOf(s, 0).officeCoord }, movesUsed: 0,
+    });
+    areaOf(s, 0).adOccupancy.push(id);
+    return id;
+  }
+
+  /** A Freight House with a load staged, an empty spotted, and Laborers enough to finish. */
+  function freightHouse(s: GameState, coord: GridCoord): void {
+    areaOf(s, 0).grid.set(coordKey(coord), {
+      geometry: { kind: 'facility', facility: 'freightHouse' },
+      baseOperationalRail: true,
+      standing: [],
+      standingWest: 0,
+      facility: {
+        kind: 'freight', subtype: 'freightHouse',
+        allows: { outbound: true, inbound: true },
+        outboundBox: [{ type: 'boxcar', loaded: true }],
+        inboundBox: [],
+        capacity: { outbound: 1, inbound: 1 },
+        menAtWork: [null, null, null],
+        industryTrack: { cars: [{ type: 'boxcar', loaded: false }] },
+        laborers: 9, porters: 0,
+        usedThisStage: { laborers: 0, porters: 0 },
+      },
+      modifiers: [], enhancements: [],
+    } as TrackCard);
+    s.yards.divisionYard.push({ type: 'boxcar', loaded: false }, { type: 'boxcar', loaded: false });
+    s.clock.phase = 'loadUnload';
+    s.clock.currentActor = 0;
+  }
+
+  /** Walk a staged load all the way onto the spotted car. */
+  function finishLoad(s: GameState, coord: GridCoord): void {
+    applyIntent(s, 0, { type: 'laborer.startLoad', at: coord });
+    for (const box of [0, 1, 2]) applyIntent(s, 0, { type: 'laborer.advanceLoad', at: coord, box });
+  }
+
+  it('refuses to unload the boxcar the Freight House just loaded', () => {
+    const s = game();
+    const coord = at(-1, 0);
+    freightHouse(s, coord);
+    finishLoad(s, coord);
+    const f = areaOf(s, 0).grid.get(coordKey(coord))!.facility!;
+    assert.deepEqual(f.industryTrack.cars.map((c) => c.loaded), [true], 'the load never reached the car');
+    assert.equal(f.industryTrack.cars[0]!.origin, 0, 'the load is not stamped with the district that made it');
+    assert.equal(
+      check(s, 0, { type: 'laborer.beginUnload', at: coord, carIndex: 0 }),
+      'LOADED_IN_THIS_DISTRICT',
+    );
+    // And it is not merely absent from the menu by accident — the menu agrees with `check`.
+    assert.ok(
+      !legalActions(s, 0).some((i) => i.type === 'laborer.beginUnload'),
+      'the unload was still offered',
+    );
+  });
+
+  it('unloads a load that came from somewhere else', () => {
+    // The mirror, and the reason the rule is a stamp rather than a per-facility flag: a car made up
+    // at a Division Point out of the common supply carries no origin, and is exactly the inbound
+    // traffic a district lives on.
+    const s = game();
+    const coord = at(-1, 0);
+    freightHouse(s, coord);
+    const f = areaOf(s, 0).grid.get(coordKey(coord))!.facility!;
+    f.industryTrack.cars = [{ type: 'boxcar', loaded: true }];
+    assert.equal(check(s, 0, { type: 'laborer.beginUnload', at: coord, carIndex: 0 }), null);
+  });
+
+  it('refuses to detrain the passengers this Office just put aboard', () => {
+    const s = game();
+    platform(s);
+    const tray = atOffice(s, [{ type: 'coach', loaded: false }]);
+    assert.ok(applyIntent(s, 0, { type: 'porter.board', at: areaOf(s, 0).officeCoord, trayId: tray }).ok);
+    const coach = s.trays.get(tray)!.consist[0]!;
+    assert.equal(coach.loaded, true, 'nobody boarded');
+    assert.equal(coach.origin, 0, 'the coach is not stamped with the Office that filled it');
+    assert.equal(
+      check(s, 0, { type: 'porter.detrain', at: areaOf(s, 0).officeCoord, trayId: tray }),
+      'LOADED_IN_THIS_DISTRICT',
+    );
+  });
+
+  it('detrains passengers who boarded somewhere else', () => {
+    const s = game();
+    platform(s);
+    const tray = atOffice(s, [{ type: 'coach', loaded: true }]);
+    assert.equal(check(s, 0, { type: 'porter.detrain', at: areaOf(s, 0).officeCoord, trayId: tray }), null);
+  });
+
+  it('takes the origin stamp off a coach that reaches the red box', () => {
+    // The stamp belongs to the LOAD. A coach going into the inbound box has finished its journey and
+    // heads back to a yard from there; carrying the stamp on would poison the common supply.
+    const s = game();
+    platform(s);
+    const tray = atOffice(s, [{ type: 'coach', loaded: true, origin: 1 }]);
+    assert.ok(applyIntent(s, 0, { type: 'porter.detrain', at: areaOf(s, 0).officeCoord, trayId: tray }).ok);
+    assert.equal(office(s).inboundBox[0]!.origin, undefined, 'the stamp survived the red box');
+  });
+});
+
+describe('two trains in one station are told apart (v0.4.9e)', () => {
+  function twoAtOffice(s: GameState): [string, string] {
+    const area = areaOf(s, 0);
+    const f = area.grid.get(coordKey(area.officeCoord))!.facility!;
+    f.allows = { outbound: true, inbound: true };
+    f.porters = 4;
+    f.capacity = { outbound: 2, inbound: 2 };
+    f.outboundBox = [{ type: 'coach', loaded: true }, { type: 'coach', loaded: true }];
+    s.clock.phase = 'loadUnload';
+    s.clock.currentActor = 0;
+    const ids: string[] = [];
+    for (let n = 0; n < 2; n++) {
+      const id = s.freeTrays.pop()!;
+      s.trays.set(id, {
+        id, trainNumber: null, trainIsExtra: false, engineAt: 0,
+        consist: [{ type: 'coach', loaded: false }],
+        direction: 'east', position: { at: 'grid', seat: 0, coord: area.officeCoord }, movesUsed: 0,
+      });
+      area.adOccupancy.push(id);
+      ids.push(id);
+    }
+    return [ids[0]!, ids[1]!];
+  }
+
+  it('offers boarding on each train, not once for the platform', () => {
+    // REPORTED: "operating two trains in a station, the select button does not work — regardless of
+    // which you pick, it is always one train, not the other." There was one button, because the
+    // intent carried no train at all.
+    const s = game();
+    const [a, b] = twoAtOffice(s);
+    const boards = legalActions(s, 0).filter((i) => i.type === 'porter.board');
+    assert.deepEqual(
+      boards.map((i) => (i as { trayId?: string }).trayId).sort(),
+      [a, b].sort(),
+      'both trains at the platform must be offered',
+    );
+  });
+
+  it('boards the train the player named, not the first on the A/D tracks', () => {
+    const s = game();
+    const [a, b] = twoAtOffice(s);
+    assert.ok(applyIntent(s, 0, { type: 'porter.board', at: areaOf(s, 0).officeCoord, trayId: b }).ok);
+    assert.equal(s.trays.get(b)!.consist[0]!.loaded, true, 'the named train did not get the passengers');
+    assert.equal(s.trays.get(a)!.consist[0]!.loaded, false, 'the other train was filled instead');
+  });
+
+  it('still works for an intent that names no train, so old saves replay', () => {
+    // `trayId` is optional for the same reason `switch.move`'s `via` is: intents are the canonical
+    // record every save and every undo replays against.
+    const s = game();
+    const [a] = twoAtOffice(s);
+    assert.ok(applyIntent(s, 0, { type: 'porter.board', at: areaOf(s, 0).officeCoord }).ok);
+    assert.equal(s.trays.get(a)!.consist[0]!.loaded, true, 'the first eligible train should have taken them');
+  });
+});
+
+/**
+ * Reported from the v0.4.9d playtest and NOT reproduced: "when I back up to collect standing cars
+ * and, further down the tracks, the caboose, I get the caboose but the cars remain. I can later
+ * drive right through them."
+ *
+ * Coupling is mandatory (§A.4) and the walk accumulates what it meets card by card, so cars the
+ * engine can see always couple — which means cars a train can drive through are cars the engine does
+ * not think are there. Nothing found: `carsOn` is the single answer to "what is standing here" and
+ * the movement walk, the sweep and every renderer all ask it. These pin the shapes that were tried,
+ * so if the case is found later it is somewhere none of them cover.
+ */
+describe('backing up over a cut to something beyond it takes both (v0.4.9d report)', () => {
+  const boxcar = () => ({ type: 'boxcar' as const, loaded: false });
+  const caboose = () => ({ type: 'caboose' as const, loaded: false });
+
+  /** A Freight House card, with cars spotted on its industry track. */
+  function industry(cars: TrackCard['standing']): TrackCard {
+    return {
+      geometry: { kind: 'facility', facility: 'freightHouse' },
+      baseOperationalRail: true, standing: [], standingWest: 0,
+      facility: {
+        kind: 'freight', subtype: 'freightHouse',
+        allows: { outbound: true, inbound: true },
+        outboundBox: [], inboundBox: [], capacity: { outbound: 1, inbound: 1 },
+        menAtWork: [null, null, null], industryTrack: { cars: [...cars] },
+        laborers: 1, porters: 0, usedThisStage: { laborers: 0, porters: 0 },
+      },
+      modifiers: [], enhancements: [],
+    } as TrackCard;
+  }
+
+  const empty = (s: GameState, ...coords: GridCoord[]): void => {
+    for (const c of coords) {
+      assert.deepEqual(carsOn(areaOf(s, 0).grid.get(coordKey(c))!), [], `cars left standing at (${c.col},${c.row})`);
+    }
+  };
+
+  it('takes a cut standing on plain track on the way to the caboose', () => {
+    const s = game();
+    addCard(s, at(0, 2), straight());
+    addCard(s, at(0, 1), straight([boxcar(), boxcar()]));
+    addCard(s, at(0, 0), straight([caboose()]));
+    const id = placeTray(s, at(0, 2));
+    applyIntent(s, 0, { type: 'localOps.choose', option: 'switch' });
+    assert.ok(applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(0, 0), reverse: true }).ok);
+    assert.deepEqual(s.trays.get(id)!.consist.map((c) => c.type), ['boxcar', 'boxcar', 'caboose']);
+    empty(s, at(0, 1), at(0, 0));
+  });
+
+  it('takes cars SPOTTED AT AN INDUSTRY on the way, not just the destination', () => {
+    // Jesse's best guess at the reported shape. An industry card is plain east-west track carrying a
+    // facility, and `carsOn` reads its industry track rather than the card — so this is the case
+    // where the two could have come apart.
+    const s = game();
+    addCard(s, at(0, 2), straight());
+    addCard(s, at(0, 1), industry([boxcar(), boxcar()]));
+    addCard(s, at(0, 0), straight([caboose()]));
+    const id = placeTray(s, at(0, 2));
+    applyIntent(s, 0, { type: 'localOps.choose', option: 'switch' });
+    assert.ok(applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(0, 0), reverse: true }).ok);
+    assert.deepEqual(s.trays.get(id)!.consist.map((c) => c.type), ['boxcar', 'boxcar', 'caboose']);
+    empty(s, at(0, 1), at(0, 0));
+  });
+
+  it("takes the train's own cut off the square it is standing on as well", () => {
+    const s = game();
+    addCard(s, at(0, 1), straight());
+    addCard(s, at(0, 0), straight([caboose()]));
+    const id = placeTray(s, at(0, 1), [boxcar(), boxcar()]);
+    applyIntent(s, 0, { type: 'localOps.choose', option: 'switch' });
+    // Set the pair out behind the engine, pull forward, then back up past them to the caboose.
+    assert.ok(applyIntent(s, 0, { type: 'switch.dropCars', trayId: id, count: 2 }).ok);
+    assert.equal(carsOn(areaOf(s, 0).grid.get(coordKey(at(0, 1)))!).length, 2);
+    assert.ok(applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(0, 0), reverse: true }).ok);
+    assert.deepEqual(s.trays.get(id)!.consist.map((c) => c.type), ['boxcar', 'boxcar', 'caboose']);
+    empty(s, at(0, 1), at(0, 0));
+  });
+});

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';
@@ -626,14 +627,16 @@ describe('the New Train phase car-placement round rotates (§7, Gap 9)', () => {
    * `tray.consist.length` instead, which is already exactly that counter and resets per train.
    */
   it('cycles Superintendent-then-left, one car per player, wrapping as the round repeats', () => {
-    // Train 1, "Crack Limited" — 3 coaches, no freight or caboose (content.ts) — small enough to
+    // Train 5, "The Sparrow" — 3 coaches, no freight or caboose (content.ts) — small enough to
     // exercise both a player count that wraps (2p: seats 0,1,0) and one that doesn't (3p: 0,1,2).
+    // It was Train 1 until Gitea#7 swapped the coach counts on 1/2 and 5/6; the test needs a
+    // THREE-car consist and the Crack Limited now carries two, so it follows the three coaches.
     for (const players of [2, 3]) {
       const s = game(players);
       s.clock.phase = 'newTrain';
       s.trays.set('t1', {
         id: 't1',
-        trainNumber: 1,
+        trainNumber: 5,
         trainIsExtra: false,
         engineAt: 0,
         consist: [],
@@ -673,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/replay.test.ts

@@ -11,8 +11,10 @@ import assert from 'node:assert/strict';
 import { pump } from '../src/engine/advance.ts';
 import { DEFAULT_MAX_COLLISIONS_PER_DAY, DEFAULT_MAX_COLLISIONS_TOTAL, collectiveRevenueFloor } from '../src/engine/content.ts';
 import type { GameEvent } from '../src/engine/events.ts';
+import { areaOf } from '../src/engine/apply.ts';
 import { createGame } from '../src/engine/setup.ts';
-import type { GameConfig } from '../src/engine/state.ts';
+import { coordKey } from '../src/engine/state.ts';
+import type { GameConfig, GameState } from '../src/engine/state.ts';
 import { developerBot, playGame } from '../src/sim/bot.ts';
 import { impediments, isVisible, narrate, phaseLabel } from '../src/sim/narrate.ts';
 import { compress, rehydrateCells, record, renderHtml } from '../src/sim/replay.ts';
@@ -57,8 +59,8 @@ const SAMPLES: GameEvent[] = [
   { type: 'carPassed', player: 0, trayId: 't0' },
   { type: 'clearanceRequested', trainId: 't1', occupiedBy: 't0' },
   { type: 'clearanceGiven', trainId: 't1', allow: false },
-  { type: 'passengersBoarded', player: 0, at: { row: 0, col: 0 } },
+  { type: 'passengersBoarded', player: 0, at: { row: 0, col: 0 }, trayId: 't0', coachIndex: 0 },
-  { type: 'passengersDetrained', player: 0, at: { row: 0, col: 0 } },
+  { type: 'passengersDetrained', player: 0, at: { row: 0, col: 0 }, trayId: 't0', coachIndex: 0 },
   { type: 'loadStarted', player: 0, at: { row: 1, col: 0 }, carType: 'hopper' },
   { type: 'loadAdvanced', player: 0, at: { row: 1, col: 0 }, fromBox: 0, toBox: 1 },
   { type: 'unloadCompleted', player: 0, at: { row: 1, col: 0 }, carType: 'hopper' },
@@ -138,6 +140,91 @@ describe('impediments', () => {
   });
 });
 
+/**
+ * Gitea#2 — "four porters, two passengers on the platform, and I never get the chance to work them."
+ *
+ * The engine was faithful at every step; what was missing was any way to SEE why. A Porter action
+ * that cannot be taken is simply absent from the menu, and this panel — the one that answers "why is
+ * nothing moving?" — opened with `f.kind !== 'freight'`, so a platform had never had anything to say
+ * for itself at all.
+ */
+describe('a blocked platform says why (Gitea#2)', () => {
+  /** Raise the Whistle Post to a working Terminal: the tier's printed numbers, applied directly. */
+  function platform(s: GameState) {
+    const area = areaOf(s, 0);
+    area.tier = 'terminal';
+    const card = area.grid.get(coordKey(area.officeCoord))!;
+    const f = card.facility!;
+    f.allows = { outbound: true, inbound: true };
+    f.porters = 3;
+    f.capacity = { outbound: 3, inbound: 3 };
+    return { area, f };
+  }
+
+  /** A tray standing on an A/D track at the Office, carrying whatever it is given. */
+  function atOffice(s: GameState, consist: { type: 'coach'; loaded: boolean; origin?: number }[]): void {
+    const area = areaOf(s, 0);
+    const id = s.freeTrays.pop()!;
+    s.trays.set(id, {
+      id, trainNumber: null, trainIsExtra: false, engineAt: 0, consist,
+      direction: 'east', position: { at: 'grid', seat: 0, coord: area.officeCoord }, movesUsed: 0,
+    });
+    area.adOccupancy.push(id);
+  }
+
+  it('reports passengers standing on a platform with no train to take them', () => {
+    // The whole of the bug's second half: before this, `impediments` returned an EMPTY list here.
+    const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
+    const { f } = platform(s);
+    f.outboundBox = [{ type: 'coach', loaded: true }];
+    const found = impediments(s, 0);
+    const platformRow = found.find((b) => /platform/.test(b.why));
+    assert.ok(platformRow, `nothing reported for the platform:\n${JSON.stringify(found, null, 2)}`);
+    assert.match(platformRow.why, /passengers waiting, no train at the platform/);
+    assert.equal(platformRow.severity, 'waiting');
+  });
+
+  it('names the Office by its tier rather than the word "facility"', () => {
+    // A Passenger Facility rides on the `office` card, so the freight branch's `geometry.facility`
+    // is not there to read and every passenger row read `facility 0,0` next to `mineTipple 1,-3`.
+    const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
+    const { f } = platform(s);
+    f.outboundBox = [{ type: 'coach', loaded: true }];
+    const row = impediments(s, 0).find((b) => /platform/.test(b.why))!;
+    assert.match(row.where, /^terminal /, `the Office is unnamed: ${row.where}`);
+  });
+
+  it('explains the coach shortage that made the game look broken', () => {
+    // The reported state: a train in with passengers to set down, red slots free, four porters —
+    // and §9.2 needs a white coach out of the Division Yard to swap in. There was none, with eight
+    // more sitting in the Classification Yard that §2.2 returns only when the Division Yard is BARE.
+    const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
+    const { f } = platform(s);
+    atOffice(s, [{ type: 'coach', loaded: true, origin: 1 }]);
+    s.yards.divisionYard = s.yards.divisionYard.filter((c) => !(c.type === 'coach' && !c.loaded));
+    s.yards.classificationYard = [
+      { type: 'coach', loaded: false },
+      { type: 'coach', loaded: false },
+    ];
+    const row = impediments(s, 0).find((b) => /§9\.2/.test(b.why));
+    assert.ok(row, `the coach shortage was not explained:\n${JSON.stringify(impediments(s, 0), null, 2)}`);
+    assert.equal(row.severity, 'stuck', 'a train that cannot be emptied is stuck, not merely waiting');
+    assert.match(row.why, /2 coaches are in the Classification Yard/, `where the coaches are is not said: ${row.why}`);
+    assert.match(row.why, /Classification returns only when the Division Yard is bare/);
+    assert.ok(f.inboundBox.length === 0, 'the red slots were free — the shortage is the only cause');
+  });
+
+  it('says nothing about a platform that is working fine', () => {
+    // Passengers waiting AND a train with an empty coach to take them: no impediment.
+    const s = createGame({ id: 'g', seed: 5, config, playerNames: ['p'] });
+    const { f } = platform(s);
+    f.outboundBox = [{ type: 'coach', loaded: true }];
+    atOffice(s, [{ type: 'coach', loaded: false }]);
+    const found = impediments(s, 0).filter((b) => /platform|§9\.2|Porters/.test(b.why));
+    assert.deepEqual(found, [], `a working platform reported an impediment:\n${JSON.stringify(found, null, 2)}`);
+  });
+});
+
 describe('replay recording', () => {
   const rec = record(1234, 'standard');
 

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/setup.test.ts

@@ -22,6 +22,7 @@ import {
   deckComposition,
   isFreightHouse,
   lengthProfile,
+  MAINLINE_DECK,
   mainlineCardCount,
   nextOfficeTier,
   officeProfile,
@@ -183,23 +184,30 @@ describe('card catalogue (component 1)', () => {
     }
   });
 
-  it('identifies the both-direction industries the card reference names', () => {
+  it('names the Freight House and nothing else as the two-way industry', () => {
     /**
-     * `card-reference.md`: "'Freight House' is not a card. It is the collective term for a freight
+     * §9.3 — "Passenger Facilities and Freight Houses permit cars to move each direction". ONE card
-     * facility that loads *and* unloads — the Grocer's Warehouse and the Oil Refinery." The table
+     * answers to that.
-     * agrees: both are "Both", and only the Power Plant is inbound-only.
      *
-     * The engine had the Refinery as outbound-only and the Grocer's as inbound-only, so §9.3's
+     * This briefly asserted three. `card-reference.md` reads "'Freight House' is not a card. It is
-     * "Passenger Facilities and Freight Houses permit cars to move each direction" named neither of
+     * the collective term for a freight facility that loads *and* unloads — the Grocer's Warehouse
-     * them — and every Modifier grant on the missing direction was silently dropped, which is how
+     * and the Oil Refinery", and on that premise the Refinery and the Grocer's were both made
-     * "grocer's warehouse didn't get extra outbound slot for truck dock" was reported.
+     * `flow: 'both'`. The premise is dead: `glossary.md` and `rules-v0.2.md` corrected the Freight
+     * House to a card of its own, dealt like any other industry, so §9.3 names it and the table's
+     * "Both" column loses its only argument.
      *
-     * `freightHouse` is still in this list because the engine deals it as a CARD, which the rules say
+     * Reported from playtesting v0.4.9d and confirmed by Jesse: the Refinery only ships tanks out,
-     * it is not. That is a deck-composition question, recorded in TODO.md, not something to quietly
+     * the Grocer's Warehouse only receives. `StationMaster-Home-Deck-v0.4.5.md` prints both that way,
-     * delete six cards over.
+     * and so does the modifier set — all three Refinery modifiers grant outbound.
      */
     const houses = FREIGHT_PROFILES.filter(isFreightHouse).map((f) => f.kind);
-    assert.deepEqual(houses.sort(), ['freightHouse', 'grocersWarehouse', 'refinery']);
+    assert.deepEqual(houses.sort(), ['freightHouse']);
+    const refinery = FREIGHT_PROFILES.find((f) => f.kind === 'refinery')!;
+    assert.equal(refinery.flow, 'outbound');
+    assert.deepEqual([refinery.baseOut, refinery.baseIn], [1, 0]);
+    const grocers = FREIGHT_PROFILES.find((f) => f.kind === 'grocersWarehouse')!;
+    assert.equal(grocers.flow, 'inbound');
+    assert.deepEqual([grocers.baseOut, grocers.baseIn], [0, 1]);
   });
 
   it('starts every industry at one car out and one loader', () => {
@@ -406,6 +414,42 @@ describe('game setup (component 2)', () => {
     }
   });
 
+  it('deals the Mainline cards from the printed deck, without replacement', () => {
+    /**
+     * `buildDivision` drew uniformly from the nine card TYPES with replacement, so a Division could
+     * be dealt two Interchanges (or two Tunnels), and Plains — printed twice in the deck — carried
+     * the same weight as cards printed once. That became a rules question rather than a flavour one
+     * when an Extra gained the right to start "at the Interchange if one is on the board" (§7): the
+     * board has to hold at most one for that to mean anything.
+     *
+     * Swept over many seeds because a single deal cannot tell a deck from a die.
+     */
+    const seen = new Map<string, number>();
+    for (let seed = 0; seed < 400; seed++) {
+      for (const players of [1, 2, 3, 4]) {
+        const g = createGame({
+          id: 'deck', seed,
+          config: players === 1 ? solitaireConfig : { ...solitaireConfig, mode: 'competitive' },
+          playerNames: Array.from({ length: players }, (_, i) => `P${i}`),
+        });
+        const cards = g.division.nodes.flatMap((n) => (n.kind === 'mainline' ? [n.card] : []));
+        assert.equal(cards.length, mainlineCardCount(players));
+        const counts = new Map<string, number>();
+        for (const c of cards) {
+          const n = (counts.get(c) ?? 0) + 1;
+          counts.set(c, n);
+          seen.set(c, (seen.get(c) ?? 0) + 1);
+          // Plains is the one card printed twice; nothing else may be dealt twice at all.
+          assert.ok(n <= (c === 'plains' ? 2 : 1), `${c} dealt ${n} times at seed ${seed}`);
+        }
+      }
+    }
+    // Every card in the deck reachable, so the deal is not quietly missing one.
+    for (const kind of new Set(MAINLINE_DECK)) {
+      assert.ok((seen.get(kind) ?? 0) > 0, `${kind} was never dealt in 400 seeds`);
+    }
+  });
+
   it('opens with the whole railroad as one Subdivision', () => {
     // §8 — every Office is a Whistle Post, which is not a Control Point.
     const g = newSolitaireGame();

test/sim.test.ts

@@ -388,13 +388,22 @@ describe('switching accomplishes something (regression)', () => {
     // no switching at all (§9.2 works coaches straight off the A/D track), so an entire Local
     // Operations action was wasted.
     /**
-     * ACROSS SEEDS, because one game cannot tell a fixed bug from a lucky deal. Measured over these
+     * ACROSS SEEDS, because one game cannot tell a fixed bug from a lucky deal — and the sample has
-     * 16: thirteen show no oscillation at all and three reach a run of five, so the shuttling is a
+     * to be big enough that it cannot tell a lucky DEAL from a fixed bug either.
-     * minority behaviour rather than the every-game waste this test was written to catch. The bar is
+     *
-     * therefore a RATE — most games clean — plus a ceiling on how bad the worst may get. The residual
+     * It was 16 hand-picked seeds against a bar of 70% clean, on a measurement of 13/16. Dealing the
-     * is recorded in TODO.md with the rest of the bot work.
+     * Mainline cards from the printed deck instead of rolling them (`buildDivision`) re-dealt every
+     * one of those boards and the same 16 came back 11/16, which read as a regression and was not
+     * one: re-measured over 80 seeds the rate is **70.0% clean, worst run 5** — the identical
+     * behaviour, and 13/16 was the lucky draw. A bar sitting exactly on the true rate fails half the
+     * time it is moved.
+     *
+     * So: a wider sweep, and a bar well below the measured rate. What the test is really guarding is
+     * the every-game waste it was written for, which shows up as a rate near ZERO, not as a few
+     * points of drift. The ceiling on the worst run is the sharp half of the assertion and is
+     * unchanged. The residual is recorded in TODO.md with the rest of the bot work.
      */
-    const seeds = [1234, 5, 77, 430, 202, 999, 21, 555, 4321, 31337, 60606, 7777, 123456, 888, 31, 42];
+    const seeds = Array.from({ length: 48 }, (_, i) => i + 1);
     let clean = 0;
     let worstAnywhere = 0;
     for (const seed of seeds) {
@@ -426,7 +435,7 @@ describe('switching accomplishes something (regression)', () => {
     }
 
     assert.ok(
-      clean >= seeds.length * 0.7,
+      clean >= seeds.length * 0.55,
       `only ${clean}/${seeds.length} games were free of aimless shuttling`,
     );
     assert.ok(worstAnywhere <= 5, `a crew oscillated ${worstAnywhere + 1} times without doing any work`);
@@ -476,8 +485,10 @@ describe('switching accomplishes something (regression)', () => {
      * grew faster, which is traffic rather than aimlessness, and there are two new sources of it:
      * Extras now start at the Division Point their NUMBER sends them to, so westbound Extras exist
      * at all (measured 32 west / 29 east across 60 deals, against every single one launching
-     * eastbound from the West Division Point before); and the Grocer's Warehouse ships as well as
+     * eastbound from the West Division Point before); and the Grocer's Warehouse briefly shipped as
-     * receives, so there is more switching worth doing.
+     * well as received, which was more switching worth doing. That second source is gone again in
+     * v0.4.9e — the Grocer's is inbound-only, as it always was on the sheet — and the ratio still
+     * clears the floor, so the figure is left where it is rather than re-tuned to one release.
      *
      * A crew that shuttles for its own sake would show this ratio climbing while `work` stood still.
      * Logged in TODO.md with the rest of the bot drift rather than quietly absorbed.
@@ -1072,12 +1083,13 @@ describe('the freight figures count both halves (regression)', () => {
     // that on: an unload needs an inbound industry built, reachable, and a loaded car spotted at it,
     // and whether the bot manages all three on a given deal is luck, not the thing under test.
     /**
-     * FORTY DEALS, up from twelve, and the reason is a rules correction rather than flakiness.
+     * FORTY DEALS, up from twelve, and the reason was a rules correction rather than flakiness.
      *
-     * The Grocer's Warehouse is a BOTH-direction facility now — `card-reference.md` always said so —
+     * The Grocer's Warehouse was briefly a both-direction facility, so the bot shipped from it as
-     * where the engine had it inbound-only. So the bot can ship from it as well as receive, and it
+     * well as receiving and deals producing at least one completed unload fell from 12 in 40 to 6 in
-     * often does: deals producing at least one completed unload went from 12 in 40 to 6 in 40, while
+     * 40. v0.4.9e put it back to inbound-only, which is what the sheet always printed. The wider
-     * unloads themselves are unharmed (30 completed across the 40 measured after the change).
+     * sample is kept: the precondition it protects — that some deal in the batch actually completes
+     * an unload — is worth having whichever way the rule goes.
      *
      * The subject here is the INSTRUMENT — does `freightUnload` count Revenue earned rather than
      * unloads started — and `unloads > 0` is only the precondition that makes the comparison mean

test/train-rules.test.ts

@@ -74,6 +74,8 @@ const west = (s: GameState, n = 2): GridCoord => {
 };
 
 const boxcar = (loaded = false): RollingStock => ({ type: 'boxcar', loaded });
+/** As `ROLLING_STOCK_SUPPLY` mints them: there is no empty caboose in the game. */
+const caboose = (): RollingStock => ({ type: 'caboose', loaded: true });
 const coach = (loaded = false): RollingStock => ({ type: 'coach', loaded });
 
 // ---------------------------------------------------------------------------
@@ -141,6 +143,23 @@ describe('§7 — what a train may couple', () => {
       'EMPTIES_ONLY',
     );
   });
+
+  it('X22 Pee-Dee may still couple a caboose, which is not a load (Gitea#8)', () => {
+    // Every caboose in the game is minted `loaded: true` because the supply table's loaded/empty
+    // split doubles as a piece count. Taken literally that left the per-diem train unable to pick
+    // up ANY caboose, its own included: set it out at the end of a sweep and it was stranded there.
+    const s = game();
+    switching(s, 22, true, [], [caboose()]);
+    assert.equal(check(s, 0, { type: 'switch.move', trayId: 't', to: west(s), reverse: false }), null);
+
+    // The restriction itself is untouched — a loaded car alongside the caboose still refuses.
+    const withLoad = game();
+    switching(withLoad, 22, true, [], [caboose(), boxcar(true)]);
+    assert.equal(
+      check(withLoad, 0, { type: 'switch.move', trayId: 't', to: west(withLoad), reverse: false }),
+      'EMPTIES_ONLY',
+    );
+  });
 });
 
 describe('§7 — one freight car per location (trains 3/4)', () => {