v0.7.8 — the setup screen was unreachable for anyone who had ever played

Third report of the same symptom, this time with the build confirmed current on screen, which ruled out v0.7.7's caching fault and left the real cause exposed. v0.7.5 skipped the setup screen whenever load() found a save, reasoned as "a saved game is a game to resume". A browser that has ever played solitaire always has one, so the door could never reach the screen again — and the fresh private window that appeared to vindicate v0.7.7 simply had no save. Two real faults were stacked; the caching one is fixed and had been masking this. The door outranks a saved game now: ?solitaire is a request to set one up, while a bare reload still resumes (pinned by its own test). Since Deal clears the save, the screen carries #ss-resume and says what Deal costs, so the door cannot destroy a game in progress. Also, per Jesse, riding along rather than taking its own release: the splash footer now names both ways to play. 868 tests pass, four new. The reproduction was a failing test written before the fix. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AdG46Ja2PEDBkpqiDazMoX
v0.7.7 — two releases shipped to a browser that never received them
2026-08-29 23:47:44 -04:00 · 2026-08-29 22:23:09 -04:00 · 2026-08-29 19:59:37 -04:00 · 2026-08-29 19:14:37 -04:00 · 2026-08-29 08:43:43 -04:00 · 2026-08-29 07:12:36 -04:00
33 changed files with 4071 additions and 2305 deletions
@@ -19,6 +19,226 @@ page as `v0.1.0 · <sha> · <date>`, so what is deployed can always be identifie

 ---

+## 0.7.8 — 2026-08-30
+
+### The setup screen was unreachable for anyone who had ever played
+
+Third report of the same symptom, and this time the build was confirmed current on screen
+(`0.7.7-mtf7hyxc`), which ruled out the caching fault v0.7.7 had just fixed and left the actual
+cause with nowhere to hide.
+
+**v0.7.5 skipped the setup screen whenever `load()` found a save**, reasoned in its own comment as
+"a saved game is a game to resume". The consequence went unnoticed: a browser that has ever played
+solitaire *always* has a save, so the door could never reach the screen again. Only a browser that
+had never played would see it — which is exactly why a fresh private window appeared to prove
+v0.7.7's cache fix. The private window had no save. Two genuine faults were stacked, the caching one
+was real and is fixed, and it masked this one.
+
+**The door now outranks a saved game.** `?solitaire` is an explicit request to set a game up;
+clicking "Play solitaire" is not a request to resume. A BARE reload still resumes, which is the
+zero-friction case D11 is about and is pinned by its own test.
+
+**Dealing from the door would have destroyed a game in progress**, since `commitNewGame` calls
+`clearSave()` — so the screen now carries `#ss-resume` ("Continue saved game") and states plainly
+that dealing replaces the save. Resuming navigates to the bare URL rather than building a session
+on the spot, so `start()` stays the only place that turns a URL into a game.
+
+**Recorded because the failure was diagnostic, not technical.** The first two attempts each fixed
+something real that was not this, and both were reported as verified. The routing fix in v0.7.6 was
+verified by reading what the server served; v0.7.7's by the same. Neither ever exercised the actual
+path with the actual state a returning player has. The reproduction here is a failing test asserting
+the door with a save present — written before the fix, and it failed with "a saved game swallowed
+the door".
+
+### The splash footer names both ways to play
+
+Was "solitaire runs entirely in your browser — no server code required", written when solitaire was
+the only door. Now: "Multiplayer runs on StartOS server. Solitaire runs entirely in your browser."
+(Jesse, 2026-08-30, asked to ride along with the next change rather than take a release of its own.)
+
+868 tests pass, four of them new.
+
+---
+
+## 0.7.7 — 2026-08-30
+
+### Two releases shipped to a browser that never received them
+
+Jesse installed v0.7.5, clicked **Play solitaire**, and landed in a dealt game instead of the new
+setup screen. v0.7.6 diagnosed that as a routing bug, fixed it, installed, verified — and it happened
+again, identically. The second report is what made the real cause findable: the fix was correct both
+times and neither one ever reached the browser.
+
+**`buildStamp()`'s no-git fallback was the literal `nogit`, and the `.s9pk` build has no git.** The
+Dockerfile copies the working tree in without `.git`, so `git rev-parse` fails there on every
+packaged build — and that string is not only the visible stamp, it is the cache-bust key every module
+URL carries. So v0.7.4, v0.7.5 and v0.7.6 all published `./web/main.js?v=nogit`, byte-identical, and
+a returning player's browser correctly concluded it had the file already. The fallback is now the
+package version plus the build's own timestamp, which is always distinct and needs nothing from the
+environment. Proven rather than assumed: two builds of an identical git-less tree now stamp
+`0.7.6-mtf6l8rm` and `0.7.6-mtf6lant`.
+
+**And the server sent no `Cache-Control` at all**, which is the other half — the pages are the one
+thing that cannot be versioned in their own URL, since a player types the address or follows a
+bookmark, so a cached `play.html` pins that player to the whole build it names including every `?v=`
+inside it. Fixed the exact way round that matters: a request carrying `?v=` may be stored for a year
+and marked `immutable`, and anything else is `no-cache`. `?v=` rather than "not HTML" because
+`build-web.ts` tags the modules and nothing else — a year of `immutable` on an untagged image or on
+the replay manifest would outlive several releases of it.
+
+Neither half is sufficient alone: without the varying tag there is nothing for a fresh page to point
+at, and without the header the fresh page is itself served from cache.
+
+**What this says about the two releases before it.** v0.7.5's setup screen and v0.7.6's door fix were
+both real, both correct, and both verified on `phoenix.local` by reading what the server served —
+which was true, and was never the thing in doubt. What went unverified was the browser, and a
+hard-reload would have told us on the first report. Worth remembering the next time a fix "has had no
+effect": check that it arrived before re-diagnosing it.
+
+864 tests pass, two of them new — one pinning the no-git fallback as something that varies per build,
+one pinning the header rule and that the `?v=` flag actually reaches `serveStatic`.
+
+---
+
+## 0.7.6 — 2026-08-29
+
+### The solitaire door could not reach solitaire
+
+Found by Jesse verifying v0.7.5 on `phoenix.local`: from a browser that had ever held a multiplayer
+seat, clicking **Play solitaire** on the splash landed straight in a Co-op, four-seat lobby left over
+from unrelated earlier testing — not the new setup screen v0.7.5 just shipped.
+
+`start()` checks a browser-remembered multiplayer session (`station-master.remote.v1`) before it ever
+looks at solitaire's own state, and there was nothing distinguishing "clicked Play solitaire" from
+"reloaded mid multiplayer game" — a bare `./play.html` load means both. `?lobby` already solved the
+identical problem for the door on the other side (D11); the solitaire door had no equivalent marker.
+
+The door now links to `./play.html?solitaire`, and `start()` treats that — along with an explicit
+`?seed=` or a `?hand=` the setup screen's own Deal button just wrote — as unambiguous proof this
+navigation means solitaire, checked ahead of the remembered-session lookup rather than only below it.
+The `hand` check matters on its own: without it, pressing Deal would work once and then bounce the
+very next load into the remembered game, since `commitNewGame`'s URL carries `hand=` but not
+`solitaire=`.
+
+862 tests pass, three of them new: the door reaching solitaire past a remembered game, a bare reload
+still correctly resuming one (unchanged behaviour, pinned so the fix does not overreach), and Deal's
+own URL surviving the same bounce.
+
+---
+
+## 0.7.5 — 2026-08-29
+
+### Solitaire asks first, the same way multiplayer already does
+
+Jesse: "let the user choose their options like the start of a multiplayer game"; "asking first is
+the only path." A bare visit to `play.html` used to deal a game on the spot, at whatever defaults
+`gameOptionsFromUrl` fell back to, and the only way to see or change a setting was to open the
+in-game "New game" dialog after the fact — compare a hand you already have, not one you are about
+to be dealt. The lobby has asked this question for every multiplayer game since v0.6.0; solitaire
+never did.
+
+A genuinely fresh visit now lands on a new `#solitairesetup` screen first: game type, starting hand,
+where an Extra may start, the three revenue rates, victory conditions, and the three optional rules
+— then a Deal button. A saved game, an explicit `?seed=`, or a URL a Deal already wrote (`hand` is
+the field every write always sets, so its presence is what tells the difference) all skip straight
+past it, the same way `?lobby` already skips the front doors on an invite link — those are not "no
+plan yet", they are a choice already made, elsewhere.
+
+**One shared block instead of two copies drifting apart.** The in-game dialog, the lobby, and now
+this screen all drive the identical `settings-form.ts` block through one new function,
+`wireGameTypeBlock()` — factored out of what used to be dialog-only code. Only Solitaire can be
+dealt outside the lobby, so the setup screen shows the other four types exactly as the dialog always
+has: present, disabled, with a note pointing at the Multiplayer door. Committing an answer — from
+either the dialog or the setup screen — goes through one `commitNewGame()`, which builds the URL and
+navigates; `start()` is still the only place that turns a URL into a game.
+
+Prefilling is deliberately left to the caller rather than folded into `wireGameTypeBlock` itself:
+the dialog opens on the game CURRENTLY IN PLAY, so redealing to compare keeps comparing against it,
+while the setup screen opens on the plain Solitaire defaults, since there is no live game yet to
+read.
+
+`index.html`'s door copy changed to match: "Start a game" reads "Set up a game" now, and the blurb
+states the floor (15, not "20 Revenue") since that is what a player is agreeing to before they deal.
+
+859 tests pass. **Not yet played in a browser** — verified by `tsc --noEmit`, the full suite, and
+reading the diff, not by loading `play.html` fresh and clicking through it.
+
+---
+
+## 0.7.4 — 2026-08-29
+
+Three rules issues off the tracker, in the order Jesse asked for them: #13, #5, #19. All three are
+rules Jesse has designed or redefined, and two of them turned out to be rules the code claimed to
+have and did not.
+
+### Some Extras must run loaded (Gitea#13)
+
+X17 Campaign, X18 Circus and X19 Military now prefer loaded cars at make-up — "if not loaded, then
+empty, and if none available, run without". It is a preference ORDER, so the rule is asked of the
+Division Yard: an empty is refused only while the yard can still supply a loaded car this train
+would take, per category, and once it cannot the empty is legal and the train may depart short.
+
+The per-stop point is **once per Office Area** rather than once per game (Jesse: "in a multiplayer
+game, each player could score if the circus stops in their area"), and only when the train is fully
+loaded — every non-caboose car, with a coach counting as loaded when occupied. That last detail is
+what makes the rule work for the Campaign Train, which carries one coach and no freight, so "fully
+loaded" is exactly "the candidate is aboard". X17 also GAINS the point; it had `stopThenExpedite`
+and no scoring rule at all.
+
+**Two bugs found doing it.** `ConsistSpec.emptiesOnly` was declared on X13 Appleseed, rendered to
+the player as "(empties only)", and enforced nowhere — the same rule as this issue pointing the
+other way, so it would have been perverse to add one and leave the other. And a set-up out on the
+Mainline paid its point to PLAYER 0 whoever was playing, because `playerAtSeat` needs a seat and off
+the grid the fallback was `0`; scoping the rule to Office Areas removes that rather than patching it.
+
+### The Yard Office is offered, reachable, and can be run into (Gitea#5)
+
+It was implemented, in a form missing all three of the rule's conditions: a qualifying train was
+TELEPORTED onto the card. Nobody was asked, no route was computed — so the card's own printed "that
+can reach the yard office in one move" was unenforced — and because nothing was walked, nothing was
+ever met on the way in.
+
+Now it is offered to the district's owner; reachability is the engine's own move walk, which already
+means what the card means; and cars on the lead collide. The walk COUPLES standing cars rather than
+treating them as obstacles, because that is what a switching move does — so what an arriving train
+would have coupled is what it is about to hit, and `destination.couples` turned out to be the
+fouling signal with no new machinery. Per Jesse's ruling the two failures are kept apart: no route
+means no offer and the history says why; a route that exists but is fouled is offered, and taking it
+crashes.
+
+**This needed a refactor that #19 then reused.** `pendingDecision` was one question asked of one
+player, and `currentActor` hardcoded that. It is a discriminated union now, with `decisionActor` as
+the single place mapping a question to whoever answers it; six copies of `pendingDecision !== null ?
+superintendent : currentActor` across engine, sim, web and tests collapse into `actingPlayer`.
+
+### Red Flags, redesigned (Gitea#19)
+
+The old card protected a stopped train out on the Mainline: offered 4,212 times and played 4 across
+600 games. It is replaced outright by a flag planted on one side of your own Limits, holding the
+next train from that direction — "Flag East holds westbound trains" — spent on the train it stops.
+One card, one train, so there is no lifting action to build and a flag cannot strangle the Division.
+
+It can also be played **out of phase**: when an arrival would certainly collide and the district's
+owner holds the card, the phase breaks in with the question. Offered only to somebody holding one,
+because a prompt with a single button is not a choice and would leak that a collision is coming.
+
+**The bot still never plays it, and the reason changed — measured, not assumed.** It now takes the
+out-of-phase prompt unconditionally, since the engine has already established the danger. Over 200
+solitaire games it plays ZERO, because the prompt needs an arrival that would collide (about one
+game in seven) to coincide with holding the card from a three-card hand out of 121. The anomaly
+exemption in `sim.test.ts` stays, but its comment no longer claims the bot is unwilling; what is
+left to fix is the half of the card a human uses — planting a flag on purpose to buy switching time.
+
+**A bug the redesign walked into**, recorded because the next interruption will meet it too: the
+flag was originally taken down in a `reduce` case, which never fires for an event `advance.ts`
+emits — the phase driver mutates and then describes. The flag stayed up and held every train that
+came. `test/events.test.ts`'s unreduced-event registry is what makes that class of mistake visible,
+and `redFlagSpent` is now on it deliberately.
+
+858 tests pass.
+
+---
+
 ## 0.7.3 — 2026-08-29

 Two issues off the tracker, and they are halves of one thing: the end of a game. Gitea#11 stops the
@@ -132,6 +132,13 @@ is the thing this machinery exists to prevent.
  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.
+- **The Mainline Phase can stop and ask, and there are three questions it asks.** §8.1's clearance
+  ruling goes to the Superintendent; the Yard Office offer and the Red Flag prompt go to the owner of
+  the district a train is arriving at. `pendingDecision` is a discriminated union and `decisionActor`
+  is the single place that maps a question to whoever must answer it — a new question adds a case
+  there and nowhere else. **Ask before the move is committed:** returning `needsClearance` unwinds
+  the whole phase and the driver re-enters from the top, so anything already mutated is applied
+  twice or left half-done.
 - **A game ends by PAUSING, and the first ending is the real one.** Running out of Days, or closing
  short of the combined Revenue floor, puts the game in `awaitingExtension` rather than `finished`:
  the table is asked whether to play one more Day, unanimously, and asked again at the end of every
@@ -34,9 +34,11 @@ Queued 2026-08-21, from playing the StartOS build:

 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.
+7. **Make "Games in Progress" readable** — **ON HOLD, 2026-08-29 (Jesse).** StartOS 0.4.0.2 is
+   expected to improve how action results are displayed, which is most of what makes this unreadable
+   — so wait and see what the platform fixes before rewriting the action around a limitation that
+   may be gone. Re-open it against 0.4.0.2 and re-read the output before designing anything.
+   Reasoning in Multiplayer below.
 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
@@ -106,8 +108,16 @@ Queued 2026-08-22, from the v0.4.9e gameplay-testing report filed as Gitea issue
    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.
+13. **Watch the other players and the bots actually make their moves** — raised by Jesse
+    2026-08-22, and **settled 2026-08-29 as the harder of the two readings**: "I want to be able to
+    watch other players and bots make their moves. It's not fun to do my turn and have magic happen
+    in the background and then have to figure out what others did."
+
+    So this is not the log-legibility fix. It is the ordered, per-action presentation of everyone
+    else's turns — **the same mechanism Gitea#20 step 4 specifies for the common board**, routed to a
+    player's own screen as well. Jesse: "this relates to issue #20 and will require a lot more
+    thinking." Do not start it as a standalone piece; it wants designing with #20. 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.
@@ -215,12 +225,26 @@ Queued 2026-08-29, from building Gitea#11 and #16 (both shipped in v0.7.3, main
    the replay recorder has a `GameState`, so it is a small refactor rather than a one-line swap. Not
    done in v0.7.3 because nothing about it is player-facing and the change earns its own look.

-35. **Extended play has never been played at a real table.** v0.7.3 is tested — engine, server,
-    replay, an all-bot regression — and compiled and exercised headlessly, but nobody has sat down,
-    run a game off the end of its timetable and voted. The multiplayer vote in particular has only
-    been driven through `session.intent`, never through two browsers: what a second player sees while
-    waiting on a first, and whether "waiting on Carol" is legible when Carol has closed her laptop,
-    are both unanswered. Worth being the first thing the next play session does.
+35. **Extended play has never been played at a real table** — but it now works on a real server.
+    **Verified live on phoenix.local, 2026-08-29**, against the installed v0.7.3:0 rather than in
+    tests: a two-seat competitive game (one human client, one bot) was dealt over the HTTP API with
+    `days: 1`, played to the end of its timetable, and reached `awaitingExtension` on Day 2 with
+    `official = { win, winner 0, daysElapsed }` frozen at Day 1 (`config.days`) and votes
+    `[null, null]`. Voting yes as seat 0 was accepted, the bot followed as designed, and the game
+    returned to `active` with `extraDays: 1` and the official outcome **unchanged**. The tally rode
+    the Frame to the client. Both test games were deleted afterwards; the box is back to Jesse's own
+    `WHISTLE-4086` and the `FREIGHT-3230` lobby.
+
+    **The save carry-over claim was also checked rather than asserted**: phoenix held five saves
+    before the update, of which `WHISTLE-4086` resumed and three were already refused by the 0.7.2
+    deck change. After updating to 0.7.3 the log is identical — same game resumed with the same 7
+    intents, same three refusals at the same move with the same code.
+
+    **What is still untested is the part the item is named for: humans, at a table.** Nobody has sat
+    down and played a game off the end of its timetable, and the multiplayer vote has never been
+    driven through two browsers — what a second player sees while waiting on a first, and whether
+    "waiting on Carol" is legible once Carol has closed her laptop, are still unanswered. Worth being
+    the first thing the next play session does.

 36. **There is no per-Stage "this train did not move" signal, so "longest an engine sat on a siding"
    cannot be answered.** Gitea#16 asks for it and the comment on that issue said `trainStoodStill`
@@ -235,6 +259,97 @@ Queued 2026-08-29, from building Gitea#11 and #16 (both shipped in v0.7.3, main
    folds a batch of events AFTER `advance` has already mutated past the moment they describe. Worth
    settling with the badge pass (#33) rather than on its own, since that is the only consumer.

+37. ~~**Bump the StartOS wrapper to 0.7.3, then 0.7.4.**~~ — 0.7.3 done 2026-08-29 (`74aea24` in
+    `station-master-startos`). Submodule pinned to `v0.7.3` (`45580d8`), `current.ts` at `0.7.3:0`,
+    release notes in all five locales, `README.md` and `instructions.md` updated. No new version file
+    and no migration — the outgoing `0.7.2:0`'s `up` was empty, `versions.md`'s common case, so
+    `current.ts` bumped in place. Verified: `npm run check` clean, prettier clean, `make x86` packs
+    as `v0.7.3:0`. **NOT installed on a box and not played** — see #35.
+
+    **Unlike 0.7.2, games in progress survive this one**, and both docs lead with it. No card data
+    changed and the engine changes are additive, so every intent in a 0.7.2 save is still legal;
+    proven rather than assumed by `test/harness.test.ts`, which replays the three files in
+    `public/replays` (all recorded under an older ruleset) and asserts every intent still applies.
+
+    **Bumped again to `0.7.4:0` the same day** (`085b88b`), pinned to `v0.7.4`, and installed on
+    `phoenix.local` — verified there, not merely packed: the resume log shows `WHISTLE-4086` coming
+    back with its 7 intents and all five new engine code paths present in the served build. Both tags
+    are signed and pushed.
+
+    **Keep doing the whole sequence.** Tag the app, fetch the tag into the wrapper's submodule,
+    bump `current.ts` in place (the outgoing `up` has been empty every time, `versions.md`'s common
+    case), rewrite the notes in all five locales, update `README.md` and `instructions.md`, then
+    `npm run check` / prettier / `make x86` / `make install`. `UPDATING.md` in the wrapper is the
+    authority and has not needed changing.
+
+38. ~~**Gitea#13, #5 and #19 — three rules corrections.**~~ — done 2026-08-29 in v0.7.4
+    (`5e34c73`, `2280276`, `19a6a47`), wrapper `085b88b` as `0.7.4:0`, installed on `phoenix.local`.
+    Each issue carries a comment naming its commit and what was ruled, per #30. Reasoning is in
+    `CHANGELOG.md`; what matters here is what they left behind, below.
+
+39. **NONE OF v0.7.4 HAS BEEN PLAYED BY A HUMAN.** The Yard Office offer, the Red Flag hold and its
+    out-of-phase prompt, and the loaded-Extra make-up rules are all tested end to end, packed, and
+    running on `phoenix.local` — and no person has met any of them at a board. Two are interruptions
+    that stop the Mainline Phase and put a question in front of somebody mid-thought, which is
+    exactly the kind of thing only play reveals. Together with #35 this is now the biggest gap in the
+    project: four features shipped without a table.
+
+40. **A save from before v0.7.4 may not replay, and nobody has been told.** The same shape as #32 but
+    for the main line: the Red Flags intent changed shape, a make-up that was legal may now be
+    refused, and a Yard Office arrival asks a question no older history has an answer for. It fails
+    safe — the server declines the save, names the move and leaves the file untouched — and
+    `WHISTLE-4086` did survive on `phoenix.local`, so it is "may not" rather than "will not". Worth a
+    line wherever the build is announced, and worth knowing when a bug report arrives with a save
+    that will not load.
+
+41. **The bot cannot use the half of Red Flags a human would.** It takes the danger prompt
+    unconditionally and still plays zero flags in 200 games, because the prompt needs a colliding
+    arrival to coincide with holding the card. What it never does is plant a flag ON PURPOSE to buy a
+    Stage for switching, which needs it to know it wants time — a notion it does not have. Reasoning
+    and the measurement are under Bot Performance.
+
+42. ~~**Solitaire must ask before it deals, the same way multiplayer's lobby already does.**~~ — done
+    2026-08-29 in v0.7.5. Jesse: "let the user choose their options like the start of a multiplayer
+    game"; "asking first is the only path." A new `#solitairesetup` screen in `play.html` asks the
+    full shared block — game type, starting hand, Extra start, revenue, victory conditions, optional
+    rules — before a genuinely fresh visit deals anything; a saved game, an explicit `?seed=`, or a
+    URL a Deal already wrote all skip past it. The in-game dialog, the lobby and this screen now
+    share one `wireGameTypeBlock()`/`commitNewGame()` pair instead of the dialog carrying its own
+    copy. Reasoning in `CHANGELOG.md`.
+
+    **Played in a browser on `phoenix.local` 2026-08-29, and it found a real bug — fixed same day in
+    v0.7.6.** The splash's "Play solitaire" door landed straight in a leftover Co-op four-seat lobby
+    instead of the new setup screen: `start()` checked a browser-remembered multiplayer session
+    before ever looking at solitaire's own state, and a bare `./play.html` load could not tell "I
+    clicked Play solitaire" apart from "I reloaded mid multiplayer game" — the same class of problem
+    `?lobby` already solved for the door on the other side (D11), just never applied to this one. The
+    door now marks its intent (`?solitaire`), checked ahead of the remembered-session lookup.
+
+    **And it happened AGAIN on v0.7.6, which is what found the real cause — fixed in v0.7.7.** Every
+    packaged build published the same cache-bust key (`?v=nogit`, because the `.s9pk` build has no
+    `.git` for `git rev-parse`), and the server sent no `Cache-Control` at all, so neither release
+    ever reached the browser that asked for it. Both earlier fixes were correct and both were
+    verified by reading what the SERVER served — which was true and was never the thing in doubt.
+    **The lesson worth keeping: when a fix appears to have had no effect, check that it arrived
+    before re-diagnosing it.** A hard-reload would have answered it on the first report.
+
+    **And a THIRD report, 2026-08-30, with the build confirmed current on screen — which is what
+    finally found it. Fixed in v0.7.8.** v0.7.5 skipped the setup screen whenever a save existed
+    ("a saved game is a game to resume"), so any browser that had ever played solitaire could never
+    reach it again; the private window that seemed to vindicate v0.7.7 simply had no save. The door
+    outranks a save now, a bare reload still resumes, and `#ss-resume` keeps the game in progress
+    one button away since Deal clears it.
+
+    **Three attempts, two of them fixing something real that was not the reported fault.** Each was
+    reported as verified, and each verification read what the SERVER served rather than exercising
+    the path with the state a returning player actually has. The thing that worked was a failing
+    test written before the fix. Worth remembering next time a report repeats: reproduce the user's
+    state first, and treat "I verified it" as unearned until something failed the way they described.
+
+    Still not verified past that: nobody has clicked all the way through the setup screen's own
+    fields and confirmed the dealt game matches what was chosen. Worth being an early item in the
+    next play session, alongside #39's four unplayed v0.7.4 features.
+
 ---

 ## Replay / Save Games
@@ -369,21 +484,23 @@ The replay viewer, the save format, and how a game gets shared.

 ## Bot Performance

- [ ] **THE BOT WILL NOT PLAY RED FLAGS, and the reachability canary now says so.** Measured over
-      600 games (2026-08-26): `maneuver.redFlags` is OFFERED **4,212 times**, first in game 5 — the
-      rule is live and constantly available — and the bot PLAYS it **4 times**, first in game 252.
-      It is exempted by name in `sim.test.ts`'s anomaly test alongside `flyingSwitch`, and deleting
-      that line is what proves this fixed.
+- [ ] **THE BOT NEVER PLAYS RED FLAGS — and since Gitea#19 that is deck luck, not unwillingness.**
+      **Re-measured 2026-08-29, after the card was redesigned: `redFlagsSet` fires ZERO times in 200
+      solitaire games.** The old measurement (600 games: OFFERED 4,212 times, PLAYED 4) described a
+      bot that declined a card it was constantly handed. That bot is gone.

-      Two changes compounded to make it rarer without breaking anything: Gitea#14 took Red Flags from
-      5 copies to the sheet's 3, and Gitea#3 shortened most crossings to a single Stage, so the
-      window in which a train is STANDING on a Mainline card — the only place the card may be played
-      — is now usually one Stage wide.
+      Gitea#19 replaced the rule outright: a flag is planted on one side of your own Limits and holds
+      the next train from that direction, and it can be played out of phase when the engine breaks in
+      with "COLLISION RISK! FLAG AGAINST T2?". The bot takes that prompt **unconditionally** — the
+      engine only raises it when an arrival is certainly about to collide, so there is nothing left
+      to judge. It still never plays one, because the prompt needs two things to coincide: an arrival
+      that would collide (0.14 collisions per game, about one game in seven) AND the district's owner
+      holding a Red Flags card at that moment, from a three-card hand drawn out of 121.

-
-What the developer bot can and cannot yet do, measured. Every revenue figure below measured before
-v0.4.7 is low by roughly half a point — see the stub-industry entry — and the rebalance pass should
-not read that drop as a deck problem.
+      **What is left to fix is the OTHER half of the card**, and it is the half a human would use:
+      planting a flag on purpose to buy a Stage for switching. That needs the bot to know it wants
+      time, which it has no notion of today. Until then the anomaly canary in `sim.test.ts` is
+      measuring deck luck rather than reachability, and its comment now says so.

 - [ ] **THE BOT DOES NOT KNOW TO BRING AN EXPEDITED TRAIN BACK TO THE STATION — new in v0.4.9.**
      The `expediteFault` mechanic (§7, Q3) charges 1 Revenue every Mainline Phase an expedited train
@@ -713,11 +830,31 @@ Deferred while planning the server; decisions and reasoning are in `docs/archite
      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.
+      **ANSWERED 2026-08-29, and it is the harder reading.** Jesse: "I want to be able to watch other
+      players and bots make their moves. It's not fun to do my turn and have magic happen in the
+      background and then have to figure out what others did." So the complaint is not that the
+      history panel is hard to read — it is that the moves are not WATCHABLE. Marking the log is a
+      consolation prize, not the fix.
+
+      **This is Gitea#20 step 4, pointed at a player's screen instead of the common board.** That
+      issue — the public common-board display published into Jitsi — already specifies the mechanism,
+      and `docs/plans/jitsi-common-board.md` §"Step 4 — Preserve individual human and bot actions"
+      has the design: a display-step collector inside `GameSession` that captures a projected frame
+      after EVERY successful `submit()`, human and bot alike, deltas it, and emits one step per
+      accepted intent (not one per `GameEvent` — an intent drains automatic work behind it, and the
+      event list is not a complete reducer).
+
+      **The reason it is not simply free once #20 lands** is that the plan deliberately stops short
+      of here: *"Keep player pushes unchanged: players still receive the final coalesced result after
+      all immediately due bots finish."* Extending the step stream to seated players raises questions
+      the common board never has to answer — a spectator can be a second behind, a player waiting to
+      act cannot; and a player animating three bot turns while their own move is due is a game that
+      feels slower, which is the opposite of the complaint. **Jesse, 2026-08-29: "this relates to
+      issue #20 and will require a lot more thinking."** Design it with #20; do not start it alone.
+
+      **The constraint below still binds either way**, and hardest here: the common board is seatless
+      and shows only public state, whereas a step stream sent to a SEATED player is a Frame, and
+      Frames are redacted per seat.

      **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,
@@ -784,8 +921,14 @@ Deferred while planning the server; decisions and reasoning are in `docs/archite
      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
+- [ ] **The StartOS "Games in Progress" action is one long unreadable run-on per game.**
+      **ON HOLD, 2026-08-29 (Jesse): StartOS 0.4.0.2 should make action displays better.** The
+      diagnosis below is that the action-result view collapses newlines — which is exactly the sort
+      of thing a platform release fixes. Re-read the real output on 0.4.0.2 before building anything;
+      the nested-group rewrite may turn out to be unnecessary, and designing around a limitation that
+      has just been lifted is worse than waiting.
+
+      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.
@@ -1,6 +1,6 @@
 {
  "name": "station-master",
-  "version": "0.7.3",
+  "version": "0.7.8",
  "private": true,
  "type": "module",
  "description": "Station Master — a railroad operations game",
@@ -1389,6 +1389,11 @@
  },
  {
   "type": "loadUnload.end"
+  },
+  {
+   "type": "game.extend",
+   "player": 0,
+   "agree": false
  }
 ]
 }
@@ -60,7 +60,21 @@ execFileSync(
 */
 function buildStamp(): string {
  const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')) as { version: string };
-  let git = 'nogit';
+  /**
+   * THE FALLBACK HAS TO BE UNIQUE PER BUILD, because this string is also the cache-bust key.
+   *
+   * It used to be the literal `nogit`, which is exactly what the `.s9pk` build produces — the
+   * Dockerfile copies the working tree in without `.git`, so `git rev-parse` fails there every time.
+   * Every packaged release therefore published `?v=nogit`, byte-identical to the release before it,
+   * and a returning player's browser had no reason to refetch a single module. v0.7.5's setup screen
+   * and v0.7.6's fix to it both shipped correctly to `phoenix.local` and neither reached the browser
+   * that asked for them (Jesse, twice, 2026-08-29 — "setup did not work").
+   *
+   * The version plus the build's own timestamp is always distinct, needs nothing from the
+   * environment, and stays honest: two builds of the same commit ARE two deploys, and a cache key
+   * that says so costs one refetch, while one that lies costs a release nobody receives.
+   */
+  let git = `${pkg.version}-${Date.now().toString(36)}`;
  try {
    const sha = execFileSync('git', ['rev-parse', '--short', 'HEAD'], { cwd: root })
      .toString()
@@ -36,10 +36,11 @@ import type { Direction, MainlineEntry, MainlineKind } from './content.ts';
 import type { GameEvent } from './events.ts';
 // `trainNeedingCars` lives in apply.ts beside `check`'s copy of the same question, so the phase and
 // the legality test cannot disagree about which train is being assembled.
-import { areaAtSeat, areaOf, trainNeedingCars } from './apply.ts';
+import { areaAtSeat, areaOf, occupancyFor, trainNeedingCars } from './apply.ts';
 import { legalActions } from './legal.ts';
-import type { CrewTray, DivisionNode, GameState, Outcome, PlayerIndex, RollingStock, SeatIndex, TrayId } from './state.ts';
-import { cloneTally, coordKey, freshTurns, isExtendable, playerAtSeat, playerLeftOf, pooled, subdivisions, totalRevenue, turnOf } from './state.ts';
+import type { CrewTray, DivisionNode, GameState, GridCoord, Outcome, PlayerIndex, RollingStock, SeatIndex, TrayId } from './state.ts';
+import { cloneTally, coordKey, freshTurns, isExtendable, playerAtSeat, playerLeftOf, pooled, railFacingOf, subdivisions, totalRevenue, turnOf } from './state.ts';
+import { reachableDestinations } from './track.ts';
 import { tallyEvent } from './tally.ts';

 export type AdvanceResult = {
@@ -50,6 +51,31 @@ export type AdvanceResult = {

 const NIGHT_STAGES = new Set([1, 2, 3, 11, 12]);

+/**
+ * IS EVERY CAR ON THIS TRAIN LOADED? (Gitea#13)
+ *
+ * "You only get credit for a circus or campaign train (one point per stop) if you have it fully
+ * loaded. Not much of a circus if all the cars are empty."
+ *
+ * A COACH COUNTS AS LOADED WHEN IT IS OCCUPIED, which is what makes this the right test for the
+ * Campaign Train: X17 carries one coach and no freight, so "fully loaded" is precisely "the
+ * candidate is aboard" (Jesse's ruling, 2026-08-29). The engine already models an occupied coach
+ * as `loaded`, so no second notion is introduced here.
+ *
+ * A CABOOSE IS EXEMPT, and it costs nothing to say so: every caboose in `ROLLING_STOCK_SUPPLY` is
+ * minted `loaded: true` — there is no empty one — so including it would change no outcome today.
+ * It is excluded anyway because a caboose is crew space rather than payload, and a supply table
+ * that grew an empty caboose should not silently start voiding circus points.
+ *
+ * AN EMPTY TRAIN IS NOT FULLY LOADED. A Circus that departed short and carries nothing at all earns
+ * nothing: `every` on an empty list is vacuously true, which would pay the emptiest train of the
+ * lot, so the length is tested first.
+ */
+function fullyLoaded(tray: CrewTray): boolean {
+  const payload = tray.consist.filter((c) => c.type !== 'caboose');
+  return payload.length > 0 && payload.every((c) => c.loaded);
+}
+
 function movesForStage(s: GameState): number {
  return s.config.optionalRules.reducedVisibility && NIGHT_STAGES.has(s.clock.stage)
    ? MOVES_PER_LOCAL_OPS_NIGHT
@@ -420,33 +446,45 @@ function mainlinePhase(s: GameState, events: GameEvent[]): AdvanceResult {
    const where = tray.position;
    const moved = moveTrain(s, id, tray, events);
    /**
-     * X18 CIRCUS TRAIN — "one turn stopped on any track (circus set-up) earns 1 point".
+     * X18 CIRCUS / X17 CAMPAIGN — a Stage spent set up in somebody's Office Area earns a point.
     *
-     * The flag was declared on the profile and read NOWHERE, so the one card in the deck that pays
+     * The flag was declared on the profile and read NOWHERE, so the one card in the deck that paid
     * for standing still paid nothing: reported from a playtest where TX18 sat on a siding for a
-     * full Stage and no point arrived. Claimed once — an Extra runs once and is gone.
+     * full Stage and no point arrived.
+     *
+     * ONCE PER OFFICE AREA (Gitea#13, Jesse 2026-08-29): "once per stop in an office area. In a
+     * multiplayer game, each player could score if the circus stops in their area." So a Circus
+     * touring three districts is paid three times and one parked in the same district all game is
+     * paid once, which `stopPointSeats` records per seat.
+     *
+     * ONLY IN AN OFFICE AREA. It used to pay for standing on the Mainline or at a Division Point
+     * too, and misattributed both: `playerAtSeat` needs a seat, and off the grid there is none, so
+     * the fallback handed the point to PLAYER 0 wherever the train happened to be. Scoping the rule
+     * to Office Areas is what Jesse's ruling says and it removes that bug rather than patching it.
+     *
+     * FULLY LOADED, or nothing. "Not much of a circus if all the cars are empty" — see
+     * `fullyLoaded` below for what that means for a train whose only car is a coach.
     *
     * "Stopped" is measured against the Mainline Phase: the train attempted to move and stayed where
     * it was. A train that is still in the district when the phase runs has not moved either, which
     * is the circus setting up on a siding rather than crossing the Division.
     */
-    if (!tray.stopPointClaimed && trainProfile(tray.trainNumber ?? 0, tray.trainIsExtra)?.rules.stopEarnsPoint) {
+    if (trainProfile(tray.trainNumber ?? 0, tray.trainIsExtra)?.rules.stopEarnsPoint) {
      const stillThere =
        tray.position.at === where.at &&
        (tray.position.at !== 'mainline' || where.at !== 'mainline' || tray.position.index === where.index) &&
        (tray.position.at !== 'grid' ||
          where.at !== 'grid' ||
          (tray.position.coord.row === where.coord.row && tray.position.coord.col === where.coord.col));
-      if (stillThere) {
-        tray.stopPointClaimed = true;
+      // Bound as one value so the grid case narrows: `tray.position` is a union, and testing a
+      // `seat` extracted from it does not tell the compiler which member it came from.
+      const at = tray.position.at === 'grid' ? tray.position : null;
+      const alreadyPaidHere = at !== null && (tray.stopPointSeats ?? []).includes(at.seat);
+      if (stillThere && at !== null && !alreadyPaidHere && fullyLoaded(tray)) {
+        tray.stopPointSeats = [...(tray.stopPointSeats ?? []), at.seat];
        // The point goes to whoever is SITTING in the district it stopped in.
-        const owner = tray.position.at === 'grid' ? playerAtSeat(s, tray.position.seat) : 0;
-        const label =
-          tray.position.at === 'grid'
-            ? `(${tray.position.coord.col},${tray.position.coord.row})`
-            : tray.position.at === 'mainline'
-              ? `Mainline card ${tray.position.index}`
-              : `the ${tray.position.side} Division Point`;
+        const owner = playerAtSeat(s, at.seat);
+        const label = `(${at.coord.col},${at.coord.row})`;
        events.push({ type: 'trainStoodStill', trainNumber: tray.trainNumber ?? 0, where: label });
        const p = s.players[owner];
        if (p) {
@@ -456,7 +494,7 @@ function mainlinePhase(s: GameState, events: GameEvent[]): AdvanceResult {
            player: owner,
            delta: 1,
            total: p.revenue,
-            reason: 'circus set-up — a Stage spent standing still',
+            reason: 'set up in the district — a Stage spent standing still, fully loaded',
          });
        }
      }
@@ -928,9 +966,30 @@ function moveTrain(s: GameState, id: TrayId, tray: CrewTray, events: GameEvent[]
    // Off the end of the card: into the adjoining Limit, then straight to the Office (§8.2).
    const target = index + dir;
    const dest = s.division.nodes[target];
+
+    /**
+     * §11 (Gitea#5) — the Yard Office offer is put BEFORE the train leaves the Mainline card, for
+     * the same reason §8.1's clearance is: `needsClearance` unwinds the whole phase and the driver
+     * re-enters here from the top, so anything already mutated is mutated twice or, worse, left
+     * half-applied. Asking after the `transits` filter below cost the train its place on the card
+     * and it was never seen again — the question was asked and the answer had nowhere to land.
+     */
+    if (dest?.kind === 'office') {
+      /**
+       * §Q, RED FLAGS (Gitea#19) — asked and answered before the train leaves the card, for exactly
+       * the reason the Yard Office offer is (see below): `needsClearance` unwinds the phase.
+       *
+       * Order matters. A flag stops the train OUTSIDE the Limits, so it never reaches the point
+       * where the Yard Office would be offered — flagging is about keeping a train out altogether.
+       */
+      const flagged = redFlagStop(s, id, tray, dest, events);
+      if (flagged === 'ask') return 'needsClearance';
+      if (flagged === 'held') return 'held';
+
+      if (yardOfficeQuestion(s, id, tray, dest.seat, events) === 'ask') return 'needsClearance';
+    }
+
    node.transits = node.transits.filter((t) => t.tray !== id);
-    // Red Flags protect a train while it is stopped here; once it rolls, the flags come in.
-    if (node.redFlagged) node.redFlagged = node.redFlagged.filter((t) => t !== id);

    if (!dest) return 'held';

@@ -966,10 +1025,10 @@ function evaluateClearance(
 ): 'clear' | 'blocked' | 'ask' {
  // A ruling already given for this train is consumed here — this is what stops the driver from
  // re-asking the same question every time it re-evaluates the train.
-  const ruling = s.clock.clearanceRuling;
-  if (ruling && ruling.train === id) {
-    s.clock.clearanceRuling = null;
-    return ruling.allow ? 'clear' : 'blocked';
+  const answer = s.clock.decisionAnswer;
+  if (answer && answer.kind === 'clearance' && answer.train === id) {
+    s.clock.decisionAnswer = null;
+    return answer.allow ? 'clear' : 'blocked';
  }

  const node = s.division.nodes[targetIndex];
@@ -1037,10 +1096,10 @@ function evaluateClearance(
    // from moving". Flagging is per-train rather than per-card, so it protects one specific train
    // where ABS Signals protects everything on the card.
    //
-    // Both of these read the card the OTHER train is standing on rather than the card being
-    // entered. They were the same card while this only looked one card ahead; across a Subdivision
-    // they are not, and the protection belongs where the train it protects actually is.
-    if (onNode?.kind === 'mainline' && (onNode.redFlagged ?? []).includes(other)) return 'blocked';
+    // Red Flags used to protect a stopped train here as well. Gitea#19 replaced that rule outright
+    // (Jesse, 2026-08-29): a flag is now planted on a district's Limits and holds trains coming from
+    // one direction, so it never applies out on the Mainline. ABS Signals is what protects a train
+    // standing on a Mainline card now, and it always did the job better.

    /**
     * ABS Signals — "this is played on a mainline card to prevent collisions. If a collision would
@@ -1065,13 +1124,211 @@ function evaluateClearance(
    }

    // Same direction — the Superintendent must rule (§8.1, fourth condition).
-    s.clock.pendingDecision = { train: id, occupiedBy: other };
+    s.clock.pendingDecision = { kind: 'clearance', train: id, occupiedBy: other };
    events.push({ type: 'clearanceRequested', trainId: id, occupiedBy: other });
    return 'ask';
  }
  return 'clear';
 }

+/**
+ * CAN THIS TRAIN REACH THE YARD OFFICE, AND IS THE LEAD CLEAR? (Gitea#5)
+ *
+ * Three answers, because Jesse's ruling (2026-08-29) splits two failures his issue describes
+ * separately: "if the Yard Office is not accessible in one move, you should not get the option"
+ * and "cars on the tracks you use to get in result in a crash".
+ *
+ *   - `clear`  — a route exists and nothing is standing on it. Offer it; taking it is safe.
+ *   - `fouled` — a route exists and there are cars on it. Offer it; taking it collides.
+ *   - `none`   — no route in one move. Do not offer it, and say why in the history.
+ *
+ * WALKED WITH THE ENGINE'S OWN MOVE RULES rather than a bespoke adjacency test. `exploreMoves`
+ * already means exactly what the card's "in one move" means — any distance without changing
+ * direction, finishing on Operational Rail (§2.4, §A.1) — so using it is what makes the code and
+ * the card agree, which was the whole complaint.
+ *
+ * THE FOULING SIGNAL IS `couples`. The walk does not treat standing cars as obstructions: it
+ * COUPLES them, because that is what a switching move does (§A.4). An arriving train is not
+ * switching, so anything it would have coupled is instead something it is about to hit — the same
+ * reading §8.3 already applies to the Running Track.
+ *
+ * The walk starts at the Office square, where a standard arrival puts the train, and leaves by the
+ * way the train is already facing. Reversing is a separate Move (§A.5), so a Yard Office that can
+ * only be reached by backing up is correctly "not in one move".
+ */
+/**
+ * The flag comes down as it stops the train — one card, one train (Gitea#19).
+ *
+ * MUTATES RATHER THAN EMITTING A REDUCED EVENT, because this is the phase driver: `advance.ts`
+ * changes state directly and then describes what it did, and roughly a third of the event types are
+ * never reduced at all (`README.md`, and `tally.ts` on the same asymmetry). A `redFlagSpent`
+ * reducer case looked right and never fired — the flag stayed up and held every train that came.
+ */
+function spendFlag(
+  office: Extract<DivisionNode, { kind: 'office' }>,
+  tray: CrewTray,
+  side: Direction,
+  events: GameEvent[],
+): 'held' {
+  delete office.redFlag;
+  events.push({ type: 'redFlagSpent', seat: office.seat, side, trainNumber: tray.trainNumber ?? 0 });
+  events.push({
+    type: 'trainHeld',
+    trainNumber: tray.trainNumber ?? 0,
+    reason: 'Red Flags — held short of the Limits',
+  });
+  return 'held';
+}
+
+/**
+ * §Q, RED FLAGS (Gitea#19) — does a flag stop this train, and should its owner be offered one?
+ *
+ * Two jobs, because they are the same moment seen twice: a flag already planted stops the train
+ * outright, and a train about to run into trouble is the cue to offer a flag to somebody holding
+ * the card. "You can play the card normally or out of phase, but only if you need it."
+ *
+ *   - `held`    — a flag was up on the side this train is coming from. It loses this Mainline
+ *                 Phase and the flag comes down with it: one card, one train (Jesse, 2026-08-29).
+ *   - `ask`     — entering would collide and the district's owner holds a Red Flags card.
+ *   - `proceed` — neither.
+ *
+ * WHICH SIDE. A train running WEST arrives from the east, so `FLAG EAST` is what holds it — which
+ * is the example the issue gives, and the reason the flag names a side rather than a heading.
+ */
+function redFlagStop(
+  s: GameState,
+  id: TrayId,
+  tray: CrewTray,
+  dest: Extract<DivisionNode, { kind: 'office' }>,
+  events: GameEvent[],
+): 'held' | 'ask' | 'proceed' {
+  const from: Direction = tray.direction === 'east' ? 'west' : 'east';
+
+  // The answer to a prompt already put. Consumed here so the driver cannot ask twice.
+  const answer = s.clock.decisionAnswer;
+  if (answer && answer.kind === 'redFlag' && answer.train === id) {
+    s.clock.decisionAnswer = null;
+    if (!answer.flag) return 'proceed';
+    // The card was spent planting the flag; it stops this train and comes down again at once.
+    return spendFlag(dest, tray, from, events);
+  }
+
+  if (dest.redFlag === from) return spendFlag(dest, tray, from, events);
+
+  /**
+   * "In actual cases of danger… if there is a train or cars on the track and there will be a
+   * collision, then you break in with a dialog." The two ways an arrival collides are §8.3's own:
+   * no free A/D track, and cars fouling the Running Track. Asked only of a player who can actually
+   * answer — offering a flag to somebody holding no card is a prompt with one button.
+   */
+  const owner = playerAtSeat(s, dest.seat);
+  const holdsFlag = (s.decks.hands.get(owner) ?? []).some((cid) => {
+    const c = s.cards.get(cid);
+    return c?.kind.kind === 'maneuver' && c.kind.key === 'redFlags';
+  });
+  if (!holdsFlag) return 'proceed';
+  if (!arrivalWouldCollide(s, id, tray, dest.seat)) return 'proceed';
+
+  s.clock.pendingDecision = { kind: 'redFlag', train: id, seat: dest.seat, from };
+  return 'ask';
+}
+
+/**
+ * Would this arrival collide? §8.3's two triggers, asked before the train commits.
+ *
+ * Deliberately a READ of the same conditions `arriveAtOffice` enforces rather than a second rule:
+ * if these two ever diverge, the prompt offers a flag against a collision that will not happen, or
+ * stays silent before one that will.
+ */
+function arrivalWouldCollide(s: GameState, id: TrayId, tray: CrewTray, seat: SeatIndex): boolean {
+  const area = areaAtSeat(s, seat);
+  const hasInterlocking = [...area.grid.values()].some((c) => c.enhancements.includes('interlocking'));
+  const full = area.adOccupancy.length >= officeProfile(area.tier).adTracks;
+  // Interlocking turns a full Office into a hold rather than a collision, so it is not danger.
+  if (full && !hasInterlocking) return true;
+
+  // A coach may legally stand at the Office while its engine switches (§A.4's carve-out), so it is
+  // not a hazard to the next arrival. Anything else on the Running Track is.
+  const officeCard = area.grid.get(coordKey(area.officeCoord));
+  return officeCard !== undefined && officeCard.standing.some((c) => c.type !== 'coach');
+}
+
+/**
+ * §11 (Gitea#5) — should the district's owner be asked about the Yard Office, and is there
+ * anything to ask about?
+ *
+ * Returns `ask` only when the offer is real: a coachless train, a Yard Office card in the district,
+ * and a route to it in one move. Everything else is `proceed`, which means the ordinary arrival.
+ *
+ * ALSO THE PLACE THE HISTORY LEARNS WHY NOT. Jesse, 2026-08-29: "make sure this is logged in
+ * history — why can't move so user knows why they can't get to yard." A qualifying train that is
+ * simply never offered the choice looks exactly like the feature being broken, which is how the
+ * missing reachability check went unnoticed for so long.
+ */
+function yardOfficeQuestion(
+  s: GameState,
+  id: TrayId,
+  tray: CrewTray,
+  seat: SeatIndex,
+  events: GameEvent[],
+): 'ask' | 'proceed' {
+  // Already answered: `arriveAtOffice` consumes it. Asking again would loop the phase for ever.
+  const answer = s.clock.decisionAnswer;
+  if (answer && answer.kind === 'yardOffice' && answer.train === id) return 'proceed';
+
+  if (tray.consist.some((c) => c.type === 'coach')) return 'proceed';
+  const area = areaAtSeat(s, seat);
+  if (![...area.grid.values()].some((c) => c.enhancements.includes('yardOffice'))) return 'proceed';
+
+  const route = yardOfficeRoute(s, seat, id, tray);
+  if (route.kind === 'none') {
+    events.push({
+      type: 'trainDiverted',
+      trainNumber: tray.trainNumber ?? 0,
+      to: 'the Office',
+      reason: `the Yard Office could not be offered — ${route.why}`,
+    });
+    return 'proceed';
+  }
+
+  s.clock.pendingDecision = { kind: 'yardOffice', train: id, seat };
+  return 'ask';
+}
+
+type YardOfficeRoute =
+  | { kind: 'clear' | 'fouled'; coord: GridCoord }
+  | { kind: 'none'; why: string };
+
+function yardOfficeRoute(s: GameState, seat: SeatIndex, id: TrayId, tray: CrewTray): YardOfficeRoute {
+  const area = areaAtSeat(s, seat);
+  const target = [...area.grid.entries()].find(([, card]) => card.enhancements.includes('yardOffice'));
+  if (!target) return { kind: 'none', why: 'there is no Yard Office in this district' };
+  const [key] = target;
+  const [row, col] = key.split(',').map(Number);
+  const coord = { row: row!, col: col! };
+
+  const player = playerAtSeat(s, seat);
+  const facing = railFacingOf(tray);
+  const found = reachableDestinations(
+    {
+      area,
+      occupancy: occupancyFor(s, player, id),
+      consistSize: tray.consist.length,
+      self: id,
+    },
+    area.officeCoord,
+    facing,
+  ).find((d) => d.coord.row === coord.row && d.coord.col === coord.col);
+
+  if (!found) {
+    return {
+      kind: 'none',
+      why: 'it cannot be reached from the Office in one move, running the way this train is facing',
+    };
+  }
+  return { kind: found.couples.length > 0 ? 'fouled' : 'clear', coord };
+}
+
 /**
 * §8.3 — arriving at an Office. Collisions here are AUTOMATIC (Gap 2a): if the trigger holds,
 * the collision happens, with no die roll and no judgment.
@@ -1088,22 +1345,51 @@ function arriveAtOffice(
  const hasEnhancement = (key: string): boolean =>
    [...area.grid.values()].some((c) => c.enhancements.includes(key));

-  // Yard Office — "an inbound train with NO COACHES that can make a single move to the yard office
-  // track may arrive there, not at the Train Order Office". It sidesteps the A/D track entirely.
-  const noCoaches = !tray.consist.some((c) => c.type === 'coach');
-  if (noCoaches && hasEnhancement('yardOffice')) {
-    for (const [key, card] of area.grid) {
-      if (!card.enhancements.includes('yardOffice')) continue;
-      const [row, col] = key.split(',').map(Number);
-      tray.position = { at: 'grid', seat, coord: { row: row!, col: col! } };
+  /**
+   * §11, THE YARD OFFICE (Gitea#5) — offered, not imposed.
+   *
+   * "Trains that are only freight (cabooses ok, no coaches allowed) that arrive in a player's area
+   * who has the yard office card get an extra ability. On the turn (mainline phase) that the train
+   * arrives the game will offer that player the option to have that train go directly to the yard
+   * office card instead of the standard office. They can of course still choose to have the train
+   * go to the standard office."
+   *
+   * WHAT THIS USED TO DO, and why all three of the rule's conditions were missing: a qualifying
+   * train was TELEPORTED onto the Yard Office card. The player was never asked, no route was ever
+   * computed — so the card's own printed text, "that can reach the yard office in one move", was
+   * unenforced — and because nothing was walked, nothing was ever met on the way in.
+   *
+   * The answer comes back through `pendingDecision`, so this returns `needsClearance` and is
+   * re-entered once the player has answered. `yardOfficeOffer` below is where the route is walked.
+   */
+  /**
+   * The answer to the offer `yardOfficeQuestion` put before the train left the Mainline card.
+   * Absent — because the train has no Yard Office, or no route to it, or carries coaches — this
+   * falls straight through to the ordinary arrival below.
+   */
+  const answer = s.clock.decisionAnswer;
+  if (answer && answer.kind === 'yardOffice' && answer.train === id) {
+    s.clock.decisionAnswer = null;
+    const route = answer.take ? yardOfficeRoute(s, seat, id, tray) : { kind: 'none' as const };
+    if (route.kind !== 'none') {
+      tray.position = { at: 'grid', seat, coord: route.coord };
      events.push({
        type: 'trainDiverted',
        trainNumber: tray.trainNumber ?? 0,
        to: 'the Yard Office',
        reason: 'no coaches, so it need not occupy the Train Order Office',
      });
+      /**
+       * Cars on the lead are a COLLISION, not a coupling — the same §8.3 rule that governs the
+       * Running Track, and the third of the three things this implementation was missing. An
+       * arriving train is at speed and is not expecting them (§A.4).
+       */
+      if (route.kind === 'fouled') {
+        collide(s, playerAtSeat(s, seat), [id], events, 'cars fouling the lead into the Yard Office', 'the Yard Office');
+      }
      return 'moved';
    }
+    // Declined: fall through to the standard Office, with its own capacity and collision rules.
  }

  // Gap 2d — no room at the station is a collision, and it is the local player's fault (§10).
@@ -1216,7 +1502,6 @@ function collide(
      if (n.kind !== 'mainline') continue;
      n.transits = n.transits.filter((t) => t.tray !== id);
      if (n.holding) n.holding = n.holding.filter((t) => t !== id);
-      if (n.redFlagged) n.redFlagged = n.redFlagged.filter((t) => t !== id);
    }
    /**
     * AND OFF THE A/D TRACK, for exactly the same reason as the transit above.
@@ -58,6 +58,8 @@ import {
  carsOn,
  coordKey,
  cutTowards,
+  decisionActor,
+  officeNodeFor,
  isOperationalRail,
  playerAtSeat,
  pooled,
@@ -124,7 +126,12 @@ function trayCoord(s: GameState, trayId: TrayId): GridCoord | null {
 }

 /** A tray sitting on the Office card occupies an A/D track (§2.1). */
-function occupancyFor(s: GameState, player: PlayerIndex, self: TrayId): Occupancy {
+/**
+ * Exported for `advance.ts`'s Yard Office walk (Gitea#5), which has to ask the SAME occupancy
+ * question a switching move asks — a second copy would be free to drift into a different answer
+ * about which cards are free.
+ */
+export function occupancyFor(s: GameState, player: PlayerIndex, self: TrayId): Occupancy {
  const area = areaOf(s, player);
  return {
    trayAt: (c) => {
@@ -792,11 +799,42 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
  // The clearance ruling is the one intent that arrives out of turn order: it interrupts the
  // automatic Mainline Phase and goes to the Superintendent (§8.1, fourth condition).
  if (i.type === 'mainline.clearance') {
-    if (s.clock.pendingDecision === null) return 'NO_PENDING_DECISION';
+    if (s.clock.pendingDecision?.kind !== 'clearance') return 'NO_PENDING_DECISION';
    if (s.clock.superintendent !== player) return 'NOT_SUPERINTENDENT';
    return null;
  }

+  /**
+   * §Q (Gitea#19) — the Red Flag prompt, the third interruption of the Mainline Phase.
+   *
+   * Only ever raised for a player who holds the card, so `flag: true` can always be paid for; the
+   * card is checked again here because `check` is the authority and a hand can change between the
+   * prompt being raised and answered.
+   */
+  if (i.type === 'mainline.redFlag') {
+    if (s.clock.pendingDecision?.kind !== 'redFlag') return 'NO_RED_FLAG_PROMPT';
+    if (decisionActor(s) !== player) return 'NOT_YOUR_TURN';
+    if (!i.flag) return null;
+    const held = (s.decks.hands.get(player) ?? []).find((id) => {
+      const c = s.cards.get(id);
+      return c?.kind.kind === 'maneuver' && c.kind.key === 'redFlags';
+    });
+    if (!held) return 'NO_SUCH_CARD';
+    return null;
+  }
+
+  /**
+   * §11 (Gitea#5) — the Yard Office offer, the second interruption of the Mainline Phase.
+   *
+   * Goes to the district's owner rather than the Superintendent, which is the whole reason
+   * `pendingDecision` became a union. `decisionActor` is the single place that mapping lives.
+   */
+  if (i.type === 'mainline.yardOffice') {
+    if (s.clock.pendingDecision?.kind !== 'yardOffice') return 'NO_YARD_OFFICE_OFFER';
+    if (decisionActor(s) !== player) return 'NOT_YOUR_TURN';
+    return null;
+  }
+
  if (!isActor(s, player)) return 'NOT_YOUR_TURN';

  switch (i.type) {
@@ -1006,14 +1044,9 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
      const card = s.cards.get(i.cardId);
      if (!card || !(s.decks.hands.get(player) ?? []).includes(i.cardId)) return 'NO_SUCH_CARD';
      if (card.kind.kind !== 'maneuver' || card.kind.key !== 'redFlags') return 'WRONG_INTENT';
-      const tray = s.trays.get(i.trayId);
-      if (!tray) return 'NO_SUCH_TRAY';
-      // "A STOPPED train is prevented from being hit" — it protects a train that is standing on a
-      // Mainline card, which is the only place a rear-ender can happen.
-      if (tray.position.at !== 'mainline') return 'NO_PLACEMENT';
-      const node = s.division.nodes[tray.position.index];
-      if (!node || node.kind !== 'mainline') return 'NO_PLACEMENT';
-      if ((node.redFlagged ?? []).includes(i.trayId)) return 'OPTION_ALREADY_CHOSEN';
+      // §Q (Gitea#19) — a flag goes on your OWN Limits. There is no target train to name and no
+      // placement to find: the district is yours, and the only question is which side.
+      if (officeNodeFor(s, seatOf(s, player))?.redFlag === i.side) return 'ALREADY_FLAGGED';
      return null;
    }

@@ -1159,7 +1192,7 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
      // This was not enforced at all: any car could be added in any quantity, so Train 9 "Heavy
      // Freight" — a card calling for 3 freight AND a caboose — was made up with four hoppers and
      // no caboose. Fewer is allowed; more, or of the wrong category, is not.
-      return acceptsCar(tray, i.carType) ? null : 'NO_SUITABLE_CAR';
+      return acceptsCar(tray, i.carType, i.loaded, s.yards.divisionYard) ? null : 'NO_SUITABLE_CAR';
    }

    case 'newTrain.secondSection': {
@@ -1571,6 +1604,12 @@ function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
        : [vote];
    }

+    case 'mainline.yardOffice': {
+      const pending = s.clock.pendingDecision;
+      const trainId = pending?.kind === 'yardOffice' ? pending.train : '';
+      return [{ type: 'yardOfficeRuled', player, trainId, take: i.take }];
+    }
+
    case 'localOps.choose':
      return [{ type: 'localOpsOptionChosen', player, option: i.option }];

@@ -1804,10 +1843,25 @@ function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
      ];
    }

-    case 'maneuver.redFlags': {
-      const tray = s.trays.get(i.trayId)!;
-      const index = tray.position.at === 'mainline' ? tray.position.index : -1;
-      return [{ type: 'redFlagsSet', player, cardId: i.cardId, trayId: i.trayId, node: index }];
+    case 'maneuver.redFlags':
+      return [{ type: 'redFlagsSet', player, cardId: i.cardId, seat: seatOf(s, player), side: i.side }];
+
+    case 'mainline.redFlag': {
+      const pending = s.clock.pendingDecision;
+      const trainId = pending?.kind === 'redFlag' ? pending.train : '';
+      const seat = pending?.kind === 'redFlag' ? pending.seat : 0;
+      const side = pending?.kind === 'redFlag' ? pending.from : 'east';
+      if (!i.flag) return [{ type: 'redFlagRuled', player, trainId, flag: false }];
+      const cardId =
+        i.cardId ??
+        (s.decks.hands.get(player) ?? []).find((id) => {
+          const c = s.cards.get(id);
+          return c?.kind.kind === 'maneuver' && c.kind.key === 'redFlags';
+        })!;
+      return [
+        { type: 'redFlagsSet', player, cardId, seat, side },
+        { type: 'redFlagRuled', player, trainId, flag: true },
+      ];
    }

    case 'maneuver.flyingSwitch': {
@@ -2005,6 +2059,13 @@ export function reduce(s: GameState, e: GameEvent): void {
      s.status = 'finished';
      break;

+    // §11 (Gitea#5) — the same shape as `clearanceGiven`: clear the question, record the answer for
+    // the arriving train to consume, or the driver asks again for ever.
+    case 'yardOfficeRuled':
+      s.clock.pendingDecision = null;
+      s.clock.decisionAnswer = { kind: 'yardOffice', train: e.trainId, take: e.take };
+      break;
+
    case 'localOpsOptionChosen':
      turnOf(s, e.player).option = e.option;
      break;
@@ -2229,14 +2290,23 @@ export function reduce(s: GameState, e: GameEvent): void {
    }

    case 'redFlagsSet': {
-      const node = s.division.nodes[e.node];
-      if (node?.kind === 'mainline') {
-        node.redFlagged = [...(node.redFlagged ?? []), e.trayId];
-      }
+      const node = officeNodeFor(s, e.seat);
+      if (node) node.redFlag = e.side;
      spendCard(s, e.player, e.cardId);
      break;
    }

+    /**
+     * §Q (Gitea#19) — `redFlagSpent` is NOT reduced, deliberately. It is emitted only by the phase
+     * driver, which mutates state itself and then describes it (`advance.ts`'s `spendFlag`), so a
+     * case here would be dead code that reads as the live one.
+     */
+
+    case 'redFlagRuled':
+      s.clock.pendingDecision = null;
+      s.clock.decisionAnswer = { kind: 'redFlag', train: e.trainId, flag: e.flag };
+      break;
+
    case 'flyingSwitch': {
      const tray = s.trays.get(e.trayId);
      const area = areaOf(s, e.player);
@@ -2593,7 +2663,7 @@ export function reduce(s: GameState, e: GameEvent): void {
    case 'clearanceGiven':
      s.clock.pendingDecision = null;
      // Recorded for the asking train to consume; otherwise the driver asks again forever.
-      s.clock.clearanceRuling = { train: e.trainId, allow: e.allow };
+      s.clock.decisionAnswer = { kind: 'clearance', train: e.trainId, allow: e.allow };
      break;

    default:
@@ -2996,7 +3066,20 @@ function extendLimitsIfNeeded(area: OfficeArea, placed: GridCoord): void {
 * this. A second copy stalled the game outright: the phase believed a car could be added while
 * `check` rejected every option, so the Stage never completed.
 */
-export function acceptsCar(tray: CrewTray, carType: CarType): boolean {
+export function acceptsCar(
+  tray: CrewTray,
+  carType: CarType,
+  /**
+   * Whether the car being offered is loaded, and what the Division Yard still holds.
+   *
+   * Both optional so that a caller asking the SHAPE question — "does this card take a car of this
+   * category at all?" — need not answer the loading question. `trainNeedingCars` asks the shape
+   * question of every car in the yard; `check` asks the full one about a specific car a player has
+   * named. Omitting them skips the loading rules rather than guessing at them.
+   */
+  loaded?: boolean,
+  yard?: readonly RollingStock[],
+): boolean {
  const profile = trainProfile(tray.trainNumber ?? 0, tray.trainIsExtra);
  if (!profile) return true;

@@ -3019,6 +3102,40 @@ export function acceptsCar(tray: CrewTray, carType: CarType): boolean {
  const types = profile.consist.freightTypes;
  if (adding === 'freight' && types && !types.includes(carType)) return false;

+  if (loaded === undefined) return true;
+
+  /**
+   * X13 APPLESEED — "may drop MTs but not pick up anything", and its consist prints EMPTIES ONLY.
+   *
+   * `emptiesOnly` was declared on the card, RENDERED to the player as "(empties only)" by both
+   * `web/game.ts` and `sim/view.ts`, and enforced by nothing: the Appleseed could be made up with
+   * loaded cars while its own card said it could not. Found while building Gitea#13, which is the
+   * same rule pointing the other way, and fixed with it rather than left as the odd one out.
+   *
+   * A caboose is exempt. Every caboose in `ROLLING_STOCK_SUPPLY` is `loaded: true` — there is no
+   * such thing as an empty one — so applying this to the caboose would bar the Appleseed from the
+   * caboose its own consist calls for.
+   */
+  if (profile.consist.emptiesOnly && loaded && adding !== 'caboose') return false;
+
+  /**
+   * MUST RUN LOADED (Gitea#13) — a preference order, not a flat requirement.
+   *
+   * "If not loaded, then empty, and if none available, run without." So an EMPTY is refused only
+   * while the yard can still supply a loaded car this train would accept; once it cannot, the empty
+   * becomes legal and the train may also simply depart short. Asked of the yard rather than
+   * remembered on the tray, because the yard is what the rule is about and it changes under the
+   * train as other consists are built.
+   *
+   * The caboose is exempt for the same reason as above.
+   */
+  if (profile.rules.mustRunLoaded && !loaded && adding !== 'caboose' && yard) {
+    const loadedAvailable = yard.some(
+      (c) => c.loaded && cat(c.type) === adding && acceptsCar(tray, c.type),
+    );
+    if (loadedAvailable) return false;
+  }
+
  return true;
 }

@@ -3059,11 +3176,21 @@ export function isBeingMadeUp(tray: CrewTray): boolean {
 export function trainNeedingCars(s: GameState): TrayId | null {
  for (const [id, tray] of s.trays) {
    if (!isBeingMadeUp(tray)) continue;
-    // Consists are specified by CATEGORY — "Freight (2)" is any two freight cars — so any car in
-    // the yard is potentially suitable unless the card narrows it. Ask the SAME predicate `check`
-    // uses: a separate copy of this test stalled the game, because the phase believed a car could
-    // be added while `check` rejected every option, so the Stage never ended.
-    if (s.yards.divisionYard.some((c) => acceptsCar(tray, c.type))) return id;
+    /**
+     * Consists are specified by CATEGORY — "Freight (2)" is any two freight cars — so any car in
+     * the yard is potentially suitable unless the card narrows it. Ask the SAME predicate `check`
+     * uses: a separate copy of this test stalled the game, because the phase believed a car could
+     * be added while `check` rejected every option, so the Stage never ended.
+     *
+     * ASKED PER CAR, WITH ITS LOADED STATE, since Gitea#13. The shape question alone is no longer
+     * the same question `check` answers: an `emptiesOnly` train looking at a yard of nothing but
+     * loaded cars, or a `mustRunLoaded` train offered only empties while loaded ones remain, would
+     * both be told a car was available and then refused every one of them — the very stall this
+     * comment was written about.
+     */
+    if (s.yards.divisionYard.some((c) => acceptsCar(tray, c.type, c.loaded, s.yards.divisionYard))) {
+      return id;
+    }
  }
  return null;
 }
@@ -434,6 +434,19 @@ export type TrainRules = {
  /** X17 Campaign, X18 Circus: a scheduled stop that does something. */
  stopEarnsPoint?: boolean;
  stopThenExpedite?: boolean;
+  /**
+   * MUST RUN LOADED (Gitea#13) — X17 Campaign, X18 Circus, X19 Military.
+   *
+   * "I've redefined some of the extra trains that they have to run full boxcars (not just any crazy
+   * stuff) — military trains, circus trains, etc. If not loaded, then empty, and if none available,
+   * run without." So it is a PREFERENCE ORDER enforced at make-up, not a flat requirement: a loaded
+   * car of an acceptable type must be taken while one is in the Division Yard; only once none is
+   * left may an empty be taken; and a train may still depart short (§8.2 already allows fewer cars
+   * than the card lists).
+   *
+   * Distinct from `ConsistSpec.emptiesOnly`, which is the opposite rule for X13 Appleseed.
+   */
+  mustRunLoaded?: boolean;
  /**
   * `copiesNextScheduled` was here and is DELETED. No train card ever carried it: a Second Section
   * is a Maneuver card played on a train that is due out, and it has its own intent
@@ -492,9 +505,9 @@ export const EXTRA_TRAINS: readonly TrainProfile[] = [
  { number: 14, isExtra: true, name: 'Fruit Growers Express', speed: 'fast', direction: 'playerChoice', consist: { freight: 2, coach: 0, caboose: 1, freightTypes: ['reefer'] }, rules: { expedite: true, note: 'Reefers only. May pick up one extra loaded reefer.' } },
  { number: 15, isExtra: true, name: 'Yard Xfer', speed: 'slow', direction: 'playerChoice', consist: { freight: 2, coach: 0, caboose: 1 }, rules: {} },
  { number: 16, isExtra: true, name: 'Light Engine Move', speed: 'fast', direction: 'playerChoice', consist: { freight: 0, coach: 0, caboose: 0 }, rules: { noSwitching: true, note: 'No cars at all.' } },
-  { number: 17, isExtra: true, name: 'Campaign Train', speed: 'fast', direction: 'playerChoice', consist: { freight: 0, coach: 1, caboose: 0 }, rules: { noSwitching: true, stopThenExpedite: true, note: 'One turn at station (speeches) then expedite.' } },
-  { number: 18, isExtra: true, name: 'Circus Train', speed: 'slow', direction: 'playerChoice', consist: { freight: 2, coach: 1, caboose: 1 }, rules: { noSwitching: true, stopEarnsPoint: true, note: 'One turn stopped on any track (circus set-up) earns 1 point.' } },
-  { number: 19, isExtra: true, name: 'Military Train', speed: 'slow', direction: 'playerChoice', consist: { freight: 1, coach: 2, caboose: 0 }, rules: { noSwitching: true, noPassengerWork: true, expedite: true } },
+  { number: 17, isExtra: true, name: 'Campaign Train', speed: 'fast', direction: 'playerChoice', consist: { freight: 0, coach: 1, caboose: 0 }, rules: { noSwitching: true, stopThenExpedite: true, stopEarnsPoint: true, mustRunLoaded: true, note: 'One turn at station (speeches) then expedite. Earns a point per Office Area if the candidate is aboard.' } },
+  { number: 18, isExtra: true, name: 'Circus Train', speed: 'slow', direction: 'playerChoice', consist: { freight: 2, coach: 1, caboose: 1 }, rules: { noSwitching: true, stopEarnsPoint: true, mustRunLoaded: true, note: 'One turn stopped in an Office Area (circus set-up) earns 1 point, once per Area, if fully loaded.' } },
+  { number: 19, isExtra: true, name: 'Military Train', speed: 'slow', direction: 'playerChoice', consist: { freight: 1, coach: 2, caboose: 0 }, rules: { noSwitching: true, noPassengerWork: true, expedite: true, mustRunLoaded: true, note: 'Troops and materiel: runs loaded where the yard can supply it.' } },
  { number: 20, isExtra: true, name: "Director's private car", speed: 'slow', direction: 'playerChoice', consist: { freight: 2, coach: 1, caboose: 0 }, rules: { noPassengerWork: true } },
  { number: 21, isExtra: true, name: 'Freight Extra', speed: 'slow', direction: 'playerChoice', consist: { freight: 3, coach: 0, caboose: 1 }, rules: {} },
  { number: 22, isExtra: true, name: 'Pee-Dee', speed: 'slow', direction: 'playerChoice', consist: { freight: 0, coach: 0, caboose: 1 }, rules: { pickUpEmptiesOnly: true, note: 'Per-diem train. May only pick up MTs.' } },
@@ -87,7 +87,12 @@ export type GameEvent =
  /** `variant` is the chosen orientation (Gap 11); it must be replayable, so it rides the event. */
  | { type: 'cardPlayed'; player: PlayerIndex; cardId: CardId; placement?: GridCoord; variant?: number }
  | { type: 'mainlineModified'; player: PlayerIndex; cardId: CardId; node: number; key: string; became?: string }
-  | { type: 'redFlagsSet'; player: PlayerIndex; cardId: CardId; trayId: TrayId; node: number }
+  /** §Q (Gitea#19) — a flag planted on one side of a district's Limits. */
+  | { type: 'redFlagsSet'; player: PlayerIndex; cardId: CardId; seat: SeatIndex; side: Direction }
+  /** §Q (Gitea#19) — the flag stopped a train and came down with it. One card, one train. */
+  | { type: 'redFlagSpent'; seat: SeatIndex; side: Direction; trainNumber: number }
+  /** §Q (Gitea#19) — the district's owner answered the out-of-phase "flag against this train?". */
+  | { type: 'redFlagRuled'; player: PlayerIndex; trainId: TrayId; flag: boolean }
  | {
      type: 'trainsDestroyed';
      player: PlayerIndex;
@@ -212,6 +217,8 @@ export type GameEvent =
   * ending that COULD have been played past and was not is a decision the table made, and the log
   * should say so rather than simply stopping.
   */
-  | { type: 'playConcluded'; declinedBy: PlayerIndex };
+  | { type: 'playConcluded'; declinedBy: PlayerIndex }
+  /** §11 (Gitea#5) — the district's owner answered the Yard Office offer. */
+  | { type: 'yardOfficeRuled'; player: PlayerIndex; trainId: TrayId; take: boolean };

 export type EventType = GameEvent['type'];
@@ -120,10 +120,24 @@ export type Intent =
   */
  | { type: 'mainline.modify'; cardId: CardId; node: number }
  /**
-   * Red Flags — protect a stopped train. The flagged train cannot be hit; an approaching train is
-   * held instead of colliding.
+   * §Q, RED FLAGS (Gitea#19) — plant a flag on one side of your own district.
+   *
+   * "If played, asked FLAG EAST or FLAG WEST. That stops all trains from entering your limits from
+   * that direction (i.e. Flag East holds westbound trains). You can do this if you see a problem or
+   * wish to complete switching."
+   *
+   * `side` names the side of the district the flag goes on, so a train arriving from that side is
+   * held. It REPLACES the old rule, which was played on a stopped train out on the Mainline and
+   * protected it from a rear-ender: measured at 4,212 offers and 4 plays across 600 games, a
+   * mechanic nobody used. ABS Signals already protects a train standing on a Mainline card.
   */
-  | { type: 'maneuver.redFlags'; cardId: CardId; trayId: TrayId }
+  | { type: 'maneuver.redFlags'; cardId: CardId; side: Direction }
+  /**
+   * The same card, played OUT OF PHASE at the moment of danger (Gitea#19) — "COLLISION RISK! FLAG
+   * AGAINST T2?". Answers a pending `redFlag` decision; `flag: false` declines and lets the
+   * collision happen. The side is not asked for: the train is already coming from one.
+   */
+  | { type: 'mainline.redFlag'; flag: boolean; cardId?: CardId }
  /**
   * Flying Switch — cut cars off behind the engine and roll them into an adjacent industry, without
   * the engine entering it.
@@ -168,7 +182,16 @@ export type Intent =
   * resumed server would refuse the save with `NO_ACTOR`. The server checks this against the seat
   * it authenticated (`NOT_YOUR_TURN`), so it is a record, never a claim.
   */
-  | { type: 'game.extend'; player: PlayerIndex; agree: boolean };
+  | { type: 'game.extend'; player: PlayerIndex; agree: boolean }
+  /**
+   * §11 (Gitea#5) — take the Yard Office, or the standard Office.
+   *
+   * Interrupts the Mainline Phase like `mainline.clearance`, and like it goes to one named player:
+   * whoever sits in the district the train is arriving at. Offered only when a route exists, so
+   * `take: true` always has somewhere to go — though it may still meet cars on the lead and crash,
+   * which is the point of the rule.
+   */
+  | { type: 'mainline.yardOffice'; take: boolean };

 export type IntentType = Intent['type'];

@@ -301,7 +324,13 @@ export type RejectionCode =
  /** §3.3 (Gitea#11) — `game.extend` when the game is not waiting on an extension vote. */
  | 'NOT_AWAITING_EXTENSION'
  /** §3.3 (Gitea#11) — this seat has already voted on this extension. */
-  | 'ALREADY_VOTED';
+  | 'ALREADY_VOTED'
+  /** §11 (Gitea#5) — answering a Yard Office offer that is not open. */
+  | 'NO_YARD_OFFICE_OFFER'
+  /** §Q (Gitea#19) — answering a Red Flag prompt that is not open. */
+  | 'NO_RED_FLAG_PROMPT'
+  /** §Q (Gitea#19) — this district already has a flag on that side. */
+  | 'ALREADY_FLAGGED';

 export type Rejection = { code: RejectionCode; message: string };

@@ -85,11 +85,20 @@ function candidates(s: GameState, player: PlayerIndex): Intent[] {
    return out;
  }

-  // The clearance ruling arrives out of turn order and goes to the Superintendent (§8.1).
-  if (s.clock.pendingDecision !== null) {
+  // The two interruptions of the Mainline Phase. Each goes to one named player — `check` is the
+  // authority on which — so both are generated here and filtered there.
+  if (s.clock.pendingDecision?.kind === 'clearance') {
    out.push({ type: 'mainline.clearance', allow: true });
    out.push({ type: 'mainline.clearance', allow: false });
  }
+  if (s.clock.pendingDecision?.kind === 'yardOffice') {
+    out.push({ type: 'mainline.yardOffice', take: true });
+    out.push({ type: 'mainline.yardOffice', take: false });
+  }
+  if (s.clock.pendingDecision?.kind === 'redFlag') {
+    out.push({ type: 'mainline.redFlag', flag: true });
+    out.push({ type: 'mainline.redFlag', flag: false });
+  }

  switch (s.clock.phase) {
    case 'localOps':
@@ -110,7 +119,8 @@ function candidates(s: GameState, player: PlayerIndex): Intent[] {
  for (const cardId of s.decks.hands.get(player) ?? []) {
    const k = s.cards.get(cardId)?.kind;
    if (k?.kind !== 'maneuver' || k.key !== 'redFlags') continue;
-    for (const [trayId] of s.trays) out.push({ type: 'maneuver.redFlags', cardId, trayId });
+    // §Q (Gitea#19) — a flag goes on one side of your own district, so the only choice is which.
+    for (const side of ['east', 'west'] as const) out.push({ type: 'maneuver.redFlags', cardId, side });
  }

  out.push({ type: 'redFlag.play' });
@@ -424,7 +424,7 @@ export function createGame(opts: SetupOptions): GameState {
      phase: 'localOps',
      currentActor: superintendent,
      pendingDecision: null,
-      clearanceRuling: null,
+      decisionAnswer: null,
      superintendent,
      actorOffset: 0,
    },
@@ -445,20 +445,27 @@ export type CrewTray = {
  position: NodeRef;
  movesUsed: number;
  /**
-   * X18 Circus Train — "one turn stopped on any track (circus set-up) earns 1 point", claimed once.
+   * X18 Circus / X17 Campaign — Office Areas this train has already been paid for setting up in
+   * (Gitea#13).
   *
-   * Recorded on the tray rather than the player because it is the TRAIN that sets up, and an Extra
-   * runs once and is gone; there is no second visit to claim it on.
+   * "Once per stop in an office area. In a multiplayer game, each player could score if the circus
+   * stops in their area" (Jesse, 2026-08-29). So the claim is per SEAT, not per train: a Circus
+   * touring three districts is paid three times, and one that parks in the same district for six
+   * Stages is paid once.
+   *
+   * Recorded on the tray, which also gives the other half of Jesse's ruling for free — "if the
+   * circus train gets recycled and played a second time as a second extra, then it could again
+   * score points later too". A train is made up onto a FRESH tray object every time, so a re-played
+   * Extra starts with an empty list and no reset code is needed.
   */
-  stopPointClaimed?: boolean;
+  stopPointSeats?: SeatIndex[];
  /**
   * X17 Campaign Train — "one turn at station (speeches) then expedite".
   *
   * It makes its speech at the first Office it reaches: that arrival is an ordinary stop, and from
   * then on the train is expedited — it may be switched normally, but it faults (Q3) if it is left
   * off the Office square when a Mainline Phase begins. Recorded on the tray for the same reason as
-   * `stopPointClaimed` — it is the TRAIN that stops, and an Extra runs once, so there is no later
-   * visit to hang it on.
+   * `stopPointSeats` — it is the TRAIN that stops, and a re-played Extra gets a fresh tray.
   */
  speechMade?: boolean;
 };
@@ -518,10 +525,23 @@ export type DivisionNode =
       * "Player sets orientation", so the direction is chosen when the card is placed.
       */
      gradeUp?: Direction;
-      /** Red Flags protecting a stopped train here, by tray. */
-      redFlagged?: TrayId[];
    }
-  | { kind: 'office'; seat: SeatIndex };
+  | {
+      kind: 'office';
+      seat: SeatIndex;
+      /**
+       * §Q, RED FLAGS (Gitea#19) — the side of this district a flag is planted on.
+       *
+       * "If played, asked FLAG EAST or FLAG WEST. That stops all trains from entering your limits
+       * from that direction (i.e. Flag East holds westbound trains)." So the value names the SIDE,
+       * and a train arriving from that side is held: a westbound train comes from the east.
+       *
+       * SPENT ON THE TRAIN IT STOPS (Jesse's ruling, 2026-08-29). One card, one train — the flag
+       * comes down as it is used, so there is no lifting action to build, nothing to forget, and a
+       * flag cannot quietly strangle the Division.
+       */
+      redFlag?: Direction;
+    };

 /** Ordered west to east. For N players: N Office nodes and N+1 Mainline cards. */
 export type Division = { nodes: DivisionNode[] };
@@ -585,10 +605,42 @@ export type Yards = {
 export type Phase = 'localOps' | 'newTrain' | 'mainline' | 'loadUnload' | 'shiftChange';

 /** §8.1 fourth condition — the Superintendent rules on a following train. */
-export type SuperintendentClearance = {
-  train: TrayId;
-  occupiedBy: TrayId;
-};
+/**
+ * AN INTERRUPTION TO THE AUTOMATIC MAINLINE PHASE — a question the driver cannot answer itself.
+ *
+ * There was one of these and it was hardcoded to one question asked of one player: the §8.1
+ * clearance ruling, always to the Superintendent. Gitea#5 and Gitea#19 each need to stop the same
+ * phase and ask a DIFFERENT player something different, so the shape is a union and `decisionActor`
+ * below decides who answers.
+ *
+ * Every member names the `train` the question is about, because the answer has to be matched back
+ * to it — see `DecisionAnswer`.
+ */
+export type PendingDecision =
+  /** §8.1 — a following train in the same Subdivision. The Superintendent rules. */
+  | { kind: 'clearance'; train: TrayId; occupiedBy: TrayId }
+  /**
+   * §11 (Gitea#5) — an inbound freight may take the Yard Office instead of the Train Order Office.
+   * Asked of whoever sits in `seat`, on the Mainline Phase the train arrives.
+   */
+  | { kind: 'yardOffice'; train: TrayId; seat: SeatIndex }
+  /**
+   * §Q (Gitea#19) — a train is about to enter this district into a collision, and its owner holds a
+   * Red Flags card. "You can play the card normally or out of phase, but only if you need it."
+   */
+  | { kind: 'redFlag'; train: TrayId; seat: SeatIndex; from: Direction };
+
+/**
+ * The answer, waiting to be consumed by the train that asked.
+ *
+ * Without this the driver would re-evaluate the same train, ask the same question, and never
+ * advance. Keyed by `kind` as well as `train` so an answer can never be mistaken for the reply to a
+ * different question about the same train.
+ */
+export type DecisionAnswer =
+  | { kind: 'clearance'; train: TrayId; allow: boolean }
+  | { kind: 'yardOffice'; train: TrayId; take: boolean }
+  | { kind: 'redFlag'; train: TrayId; flag: boolean };

 export type Clock = {
  day: number;
@@ -597,13 +649,10 @@ export type Clock = {
  phase: Phase;
  /** Exactly one player may act at a time. Null during automatic Mainline movement. */
  currentActor: PlayerIndex | null;
-  /** Interrupts the Mainline Phase to ask the Superintendent (§8.1). */
-  pendingDecision: SuperintendentClearance | null;
-  /**
-   * The Superintendent's answer, waiting to be consumed by the train that asked. Without this the
-   * driver would re-evaluate the same train and ask the same question forever.
-   */
-  clearanceRuling: { train: TrayId; allow: boolean } | null;
+  /** Interrupts the Mainline Phase to ask a player something (§8.1, §11). */
+  pendingDecision: PendingDecision | null;
+  /** The answer to `pendingDecision`, waiting to be consumed by the train that asked. */
+  decisionAnswer: DecisionAnswer | null;
  superintendent: PlayerIndex;
  /**
   * How far round the table the current phase has got. Acting order starts at the Superintendent
@@ -1131,6 +1180,40 @@ export function playerAtSeat(state: GameState, seat: SeatIndex): PlayerIndex {
  return p;
 }

+/** This seat's node on the Division — where its Limits, and any Red Flag on them, live. */
+export function officeNodeFor(
+  state: GameState,
+  seat: SeatIndex,
+): Extract<DivisionNode, { kind: 'office' }> | null {
+  for (const n of state.division.nodes) if (n.kind === 'office' && n.seat === seat) return n;
+  return null;
+}
+
+/**
+ * WHO MUST ANSWER the interruption, or null when nothing is pending.
+ *
+ * The one place that knows which player each kind of question goes to. §8.1's clearance is the
+ * Superintendent's ruling wherever it happens; the Yard Office is offered to whoever sits in the
+ * district the train is arriving at, because it is their card and their yard.
+ */
+export function decisionActor(state: GameState): PlayerIndex | null {
+  const d = state.clock.pendingDecision;
+  if (!d) return null;
+  return d.kind === 'clearance' ? state.clock.superintendent : playerAtSeat(state, d.seat);
+}
+
+/**
+ * WHOSE MOVE IT IS RIGHT NOW — a pending interruption's owner if there is one, else the phase's
+ * own actor.
+ *
+ * Written out six times across the engine, the sim, the web client and the tests as
+ * `pendingDecision !== null ? superintendent : currentActor`, which stopped being right the moment
+ * a second kind of question existed. One copy now, so a new decision kind cannot be half-adopted.
+ */
+export function actingPlayer(state: GameState): PlayerIndex | null {
+  return decisionActor(state) ?? state.clock.currentActor;
+}
+
 /** Where this player is sitting, and therefore which Office Area is theirs. */
 /**
 * The player `n` seats to the LEFT of this one, wrapping round the table.
@@ -101,7 +101,13 @@ function sendJson(res: ServerResponse, status: number, body: unknown): void {
  res.end(text);
 }

-async function serveStatic(distDir: string, urlPath: string, res: ServerResponse): Promise<void> {
+async function serveStatic(
+  distDir: string,
+  urlPath: string,
+  res: ServerResponse,
+  /** The request's `?v=` build tag, when it has one — see the `Cache-Control` note below. */
+  buildTagged = false,
+): Promise<void> {
  const rel = urlPath === '/' ? '/index.html' : urlPath;
  // `normalize` collapses `..`, and the join is then checked to still be inside `distDir` — a request
  // for `/../../etc/passwd` must not escape the one directory this is allowed to read from.
@@ -113,7 +119,27 @@ async function serveStatic(distDir: string, urlPath: string, res: ServerResponse
  try {
    const info = await stat(full);
    if (!info.isFile()) throw new Error('not a file');
-    res.writeHead(200, { 'Content-Type': MIME[extname(full)] ?? 'application/octet-stream', 'Content-Length': info.size });
+    /**
+     * ONLY A URL CARRYING A BUILD TAG MAY BE CACHED, AND NOTHING ELSE MAY BE.
+     *
+     * Nothing here sent a `Cache-Control` at all before, so a browser applied its own heuristic to
+     * the pages as much as the modules. The pages are the one thing that CANNOT be versioned in
+     * their own URL — a player types the address or follows a bookmark — so a cached `play.html`
+     * pins that player to the entire build it names, including every `?v=` tag inside it. That is
+     * half of why v0.7.5 and v0.7.6 did not reach the browser that asked for them; `build-web.ts`
+     * publishing `?v=nogit` on every packaged release was the other half, and neither is enough on
+     * its own.
+     *
+     * `?v=` is the exact condition rather than "not HTML": `build-web.ts` tags the modules and the
+     * script tags that load them, and tags NOTHING else. An untagged URL — an image, the replay
+     * manifest — has no way to announce a change, so a year of `immutable` on one would outlive
+     * several releases of whatever it holds.
+     */
+    res.writeHead(200, {
+      'Content-Type': MIME[extname(full)] ?? 'application/octet-stream',
+      'Content-Length': info.size,
+      'Cache-Control': buildTagged ? 'public, max-age=31536000, immutable' : 'no-cache',
+    });
    createReadStream(full).pipe(res);
  } catch {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
@@ -281,7 +307,7 @@ export function startServer(opts: ServerOptions): void {
        // Unset means the routes are not here — indistinguishable from any other unknown path, so
        // nothing advertises an administrative surface to someone probing for one.
        if (!opts.adminSecret) {
-          await serveStatic(opts.distDir, url.pathname, res);
+          await serveStatic(opts.distDir, url.pathname, res, url.searchParams.has('v'));
          return;
        }
        if (req.headers['x-admin-secret'] !== opts.adminSecret) {
@@ -700,7 +726,7 @@ export function startServer(opts: ServerOptions): void {
        return;
      }

-      await serveStatic(opts.distDir, url.pathname, res);
+      await serveStatic(opts.distDir, url.pathname, res, url.searchParams.has('v'));
    })().catch((err: unknown) => {
      sendJson(res, 500, { error: err instanceof Error ? err.message : 'internal error' });
    });
@@ -35,7 +35,7 @@ import type { Intent } from '../engine/intents.ts';
 import { legalActions } from '../engine/legal.ts';
 import { connectionsFor, exitsFrom, facilityVariants, hasPort, joins, neighbour, opposite, variantsFor } from '../engine/track.ts';
 import type { Port } from '../engine/track.ts';
-import { coordKey, turnOf } from '../engine/state.ts';
+import { actingPlayer, coordKey, turnOf } from '../engine/state.ts';
 import type { Facility, GameState, GridCoord, OfficeArea, PlayerIndex, RollingStock, TrackCard } from '../engine/state.ts';

 export type BotPolicy = {
@@ -154,10 +154,23 @@ export function makeDeveloperBot(tweaks: BotTweaks): BotPolicy {
    const clearance = ruleOnClearance(options);
    if (clearance) return because('the Superintendent must rule on a following train', clearance);

+    /**
+     * §11 (Gitea#5) — the bot keeps its trains at the Train Order Office.
+     *
+     * A deliberate policy, not an oversight, and the cautious half of a real choice: the Yard Office
+     * frees an A/D track, which is worth something on a busy district, but the lead into it may be
+     * fouled and the bot does not read its own yard well enough to tell (`TODO.md`, Bot
+     * Performance — it cannot spot a car at a stub industry either). Declining is always safe, and
+     * it keeps the balance harness comparable with every measurement taken before this rule existed.
+     * Worth revisiting when the bot can judge the lead.
+     */
+    const yardOffice = options.find((i) => i.type === 'mainline.yardOffice' && i.take === false);
+    if (yardOffice) return because('the bot does not judge the lead into a yard, so it stays at the Office', yardOffice);
+
    // Red Flags come before anything else — protection is only worth playing at the moment the
    // collision is actually pending, and that moment passes.
    const flags = worthFlagging(s, options);
-    if (flags) return because('a train of ours is stopped on a Mainline card with another train on it — Red Flags now or not at all', flags);
+    if (flags) return because('the engine says this arrival collides, and we hold a Red Flag — now or never', flags);

    // --- Load/Unload: spend every worker, then end. Each is a point, or a step toward one.
    //
@@ -1030,19 +1043,20 @@ function facilityWantsAt(
 }

 /**
- * Red Flags — "any time". Worth spending only when a train of ours is stopped out on the Mainline
- * with another train on the same card, which is the situation that becomes a rear-ender.
+ * §Q, RED FLAGS (Gitea#19) — spent only at the moment of danger.
+ *
+ * The card was redefined: it plants a directional flag on your own Limits rather than protecting a
+ * stopped train out on the Mainline, so the old heuristic ("is a train of ours sharing a Mainline
+ * card") no longer describes anything the card does.
+ *
+ * The bot now flags ONLY through the out-of-phase prompt, which the engine raises exactly when an
+ * arrival would collide (`redFlagStop`). That is a better policy than the old one and a much
+ * simpler one: the engine has already established the danger, so there is nothing for the bot to
+ * judge. It never plants a flag speculatively — it cannot tell whether it wants time to switch, and
+ * a flag spent early is a flag not there when a train is actually bearing down.
 */
-function worthFlagging(s: GameState, options: Intent[]): Intent | null {
-  for (const i of options) {
-    if (i.type !== 'maneuver.redFlags') continue;
-    const tray = s.trays.get(i.trayId);
-    if (!tray || tray.position.at !== 'mainline') continue;
-    const node = s.division.nodes[tray.position.index];
-    if (node?.kind !== 'mainline') continue;
-    if (node.transits.length > 1) return i;
-  }
-  return null;
+function worthFlagging(_s: GameState, options: Intent[]): Intent | null {
+  return options.find((i) => i.type === 'mainline.redFlag' && i.flag === true) ?? null;
 }

 /** A one-line account of which Load/Unload action was taken, and why it ranked first. */
@@ -1904,8 +1918,7 @@ export function playGame(
      continue;
    }

-    const actor =
-      s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
+    const actor = actingPlayer(s);
    if (actor === null) break;

    const options = legalActions(s, actor);
@@ -218,10 +218,19 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
          ? `Realignment: Mainline card ${e.node} converted to ${e.became}`
          : `Played ${e.key} on Mainline card ${e.node}`,
      };
+    case 'redFlagSpent':
+      return {
+        tone: 'good',
+        text: `RED FLAG — Train ${e.trainNumber} stopped short of the ${e.side === 'east' ? 'Eastern' : 'Western'} Limits. The flag comes down with it.`,
+      };
+    case 'redFlagRuled':
+      return e.flag
+        ? { tone: 'plain', text: `Player ${e.player} flagged the approaching train` }
+        : { tone: 'plain', text: `Player ${e.player} waved the train through` };
    case 'redFlagsSet':
      return {
        tone: 'good',
-        text: `Red Flags set out to protect train ${e.trayId} on Mainline card ${e.node} — an approaching train must stop`,
+        text: `RED FLAGS set out on the ${e.side === 'east' ? 'Eastern' : 'Western'} Limits — the next train from that way is held short`,
      };
    case 'flyingSwitch':
      return {
@@ -498,6 +507,12 @@ export function narrate(e: GameEvent, ctx: NarrateContext = {}): Narration {
      return { tone: 'clock', text: `── The table plays on: Day ${e.day} is added to the timetable ──` };
    case 'playConcluded':
      return { tone: 'clock', text: '── The railroad is put to bed. Final results stand. ──' };
+
+    // -- §11, the Yard Office (Gitea#5)
+    case 'yardOfficeRuled':
+      return e.take
+        ? { tone: 'plain', text: `Player ${e.player} sent ${train(e.trainId)} into the Yard Office` }
+        : { tone: 'plain', text: `Player ${e.player} kept ${train(e.trainId)} at the Train Order Office` };
  }
 }

@@ -34,6 +34,7 @@ import type { Intent } from '../engine/intents.ts';
 import { legalActions } from '../engine/legal.ts';
 import { createGame } from '../engine/setup.ts';
 import type { Facility, GameConfig, GameState } from '../engine/state.ts';
+import { actingPlayer } from '../engine/state.ts';
 import { developerBot, lastChoiceReason } from './bot.ts';
 import { carLabel, cuesFor, idleNote, isVisible, narrate } from './narrate.ts';
 // The view-model lives in its own module so the browser build can import it without dragging in
@@ -135,7 +136,7 @@ export function record(seed: number, length: GameLength, maxSteps = 100_000): Re
    if (s.status === 'finished') break;
    if (!r.needsInput) continue;

-    const actor = s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
+    const actor = actingPlayer(s);
    if (actor === null) break;
    const options = legalActions(s, actor);
    if (options.length === 0) break;
@@ -1043,7 +1043,24 @@ export function describeIntent(s: GameState, i: Intent): string {
      return `${cardName(s, i.cardId)} on ${shortWhere} — ${where}${effect ? `; ${effect}` : ''}`;
    }
    case 'maneuver.redFlags':
-      return `set Red Flags to protect ${trainName(s, i.trayId)} — an approaching train must stop short`;
+      return (
+        `FLAG ${i.side === 'east' ? 'EAST' : 'WEST'} — hold the next ${i.side === 'east' ? 'westbound' : 'eastbound'} ` +
+        'train short of your Limits, so you can finish switching'
+      );
+    // §Q, the out-of-phase play (Gitea#19) — "COLLISION RISK! FLAG AGAINST T2?"
+    case 'mainline.redFlag':
+      return i.flag
+        ? 'FLAG IT — stop the train short of your Limits, spending a Red Flags card'
+        : 'wave it through — let it come in';
+    /**
+     * §11, the Yard Office (Gitea#5). The offer interrupts the Mainline Phase, so the label has to
+     * carry the whole question — there is no surrounding context on screen to lean on, and the
+     * player is being asked about a train they were not otherwise thinking about.
+     */
+    case 'mainline.yardOffice':
+      return i.take
+        ? 'take the YARD OFFICE — straight into the yard, leaving the Train Order Office free'
+        : 'keep it at the Train Order Office — the ordinary arrival, onto an A/D track';
    // §3.3, extended play (Gitea#11). The results screen draws its own buttons, but a bot reads its
    // options through this list like any other, and the label is what the history says it chose.
    case 'game.extend':
@@ -1055,9 +1072,12 @@ export function describeIntent(s: GameState, i: Intent): string {
    case 'mainline.clearance': {
      // The §8.1 ruling is the sharpest decision in the game and read "grant clearance" — no hint
      // that granting it risks a rear-ender, or that refusing merely costs time.
+      // Narrowed to the clearance question: `pendingDecision` is a union since Gitea#5, and only
+      // this member names a train ahead.
      const pending = s.clock.pendingDecision;
-      const who = pending ? trainName(s, pending.train) : 'the train';
-      const ahead = pending ? trainName(s, pending.occupiedBy) : 'the train ahead';
+      const clearance = pending?.kind === 'clearance' ? pending : null;
+      const who = clearance ? trainName(s, clearance.train) : 'the train';
+      const ahead = clearance ? trainName(s, clearance.occupiedBy) : 'the train ahead';
      // NOT "risks a collision, −5". A rear-end on a Mainline card is described by §10 and is what
      // ABS Signals exists to prevent, but no such collision is implemented — granting clearance is
      // currently free. Saying otherwise invents a consequence the engine will never deliver.
@@ -1097,7 +1117,24 @@ export function describeIntent(s: GameState, i: Intent): string {
    case 'redFlag.play':
      return 'play your red flag';
    case 'maneuver.redFlags':
-      return `set Red Flags to protect ${trainName(s, i.trayId)} — an approaching train must stop short`;
+      return (
+        `FLAG ${i.side === 'east' ? 'EAST' : 'WEST'} — hold the next ${i.side === 'east' ? 'westbound' : 'eastbound'} ` +
+        'train short of your Limits, so you can finish switching'
+      );
+    // §Q, the out-of-phase play (Gitea#19) — "COLLISION RISK! FLAG AGAINST T2?"
+    case 'mainline.redFlag':
+      return i.flag
+        ? 'FLAG IT — stop the train short of your Limits, spending a Red Flags card'
+        : 'wave it through — let it come in';
+    /**
+     * §11, the Yard Office (Gitea#5). The offer interrupts the Mainline Phase, so the label has to
+     * carry the whole question — there is no surrounding context on screen to lean on, and the
+     * player is being asked about a train they were not otherwise thinking about.
+     */
+    case 'mainline.yardOffice':
+      return i.take
+        ? 'take the YARD OFFICE — straight into the yard, leaving the Train Order Office free'
+        : 'keep it at the Train Order Office — the ordinary arrival, onto an A/D track';
    // §3.3, extended play (Gitea#11). The results screen draws its own buttons, but a bot reads its
    // options through this list like any other, and the label is what the history says it chose.
    case 'game.extend':
@@ -30,6 +30,7 @@ import type { Intent } from '../engine/intents.ts';
 import { legalActions } from '../engine/legal.ts';
 import { createGame } from '../engine/setup.ts';
 import type { CardId, GameConfig, GameState, PlayerIndex } from '../engine/state.ts';
+import { actingPlayer } from '../engine/state.ts';
 import { playerAtSeat } from '../engine/state.ts';
 import { cuesFor, narrate } from '../sim/narrate.ts';
 // Import from the view module, NOT replay.ts — replay.ts writes files and reads process.argv,
@@ -266,6 +267,7 @@ export type Game = {
 /** How each intent kind is introduced in the action list, in the order they should appear. */
 const GROUP_ORDER: readonly { prefix: string; title: string }[] = [
  { prefix: 'mainline.clearance', title: 'Superintendent — rule on this train' },
+  { prefix: 'mainline.yardOffice', title: 'Where does this train arrive?' },
  { prefix: 'localOps.choose', title: 'Local Operations — choose ONE' },
  { prefix: 'switch.', title: 'Switching' },
  // Specific before general: `startsWith` means a bare `draw.` would swallow all three, and the
@@ -334,9 +336,9 @@ export function drain(game: Game): void {
 /** Whose turn it is, or null if the game is over or waiting on nothing. */
 export function currentActor(game: Game): PlayerIndex | null {
  if (game.state.status !== 'active') return null;
-  return game.state.clock.pendingDecision !== null
-    ? game.state.clock.superintendent
-    : game.state.clock.currentActor;
+  // `actingPlayer` (state.ts) knows which player each kind of interruption goes to — the
+  // Superintendent for a §8.1 clearance, the district's owner for a Yard Office offer.
+  return actingPlayer(game.state);
 }

 /** Every legal action right now, grouped for display. Empty when there is nothing to decide. */
@@ -465,13 +467,26 @@ export function actionGroups(game: Game): { options: Intent[]; groups: ActionGro
       */
      if (prefix === 'mainline.clearance') {
        const pending = game.state.clock.pendingDecision;
-        if (pending) {
+        if (pending?.kind === 'clearance') {
          headed =
            `Superintendent — may ${trainName(game.state, pending.train)} follow ` +
            `${trainName(game.state, pending.occupiedBy)} onto the same Mainline card?`;
        }
      }

+      /**
+       * §11 (Gitea#5) — the Yard Office offer interrupts the Mainline Phase, so it arrives with no
+       * context around it: the player was not thinking about this train a moment ago.
+       */
+      if (prefix === 'mainline.yardOffice') {
+        const pending = game.state.clock.pendingDecision;
+        if (pending?.kind === 'yardOffice') {
+          headed =
+            `${trainName(game.state, pending.train)} is arriving with no coaches — ` +
+            'take it into the Yard Office, or hold it at the Train Order Office?';
+        }
+      }
+
      /**
       * A PENDING EXTRA IS ITS OWN QUESTION, and its own heading.
       *
@@ -79,13 +79,13 @@ footer{margin-top:26px;color:var(--dim);font-size:11px;display:flex;gap:18px;fle
      <span class="go" id="door-multiplayer-go">Set up a game &rarr;</span>
    </a>

-    <a class="door" href="./play.html">
+    <a class="door" href="./play.html?solitaire">
      <h2>Play solitaire</h2>
-      <p>Play by yourself and run the entire division for five full days. Your goal is 20 Revenue.
-         Your game data is saved in your browser &mdash; if you close the tab and reopen this site
+      <p>Play by yourself and run the entire division for five full days. Clear the Revenue floor of
+         15 by the end or the game is a loss. Your game data is saved in your browser &mdash; if you close the tab and reopen this site
         without clearing your cache, your game is preserved and you can continue automatically.
         During the game you can also explicitly save your progress for later replay.</p>
-      <span class="go">Start a game &rarr;</span>
+      <span class="go">Set up a game &rarr;</span>
    </a>

    <a class="door" href="./replays.html">
@@ -100,7 +100,7 @@ footer{margin-top:26px;color:var(--dim);font-size:11px;display:flex;gap:18px;fle

  <footer>
    <span>build <span id="build">__BUILD__</span></span>
-    <span>solitaire runs entirely in your browser &mdash; no server code required</span>
+    <span>Multiplayer runs on StartOS server. Solitaire runs entirely in your browser.</span>
  </footer>
 </main>

@@ -37,6 +37,7 @@ import {
 } from './presets.ts';
 import type { GameType, PresetName } from './presets.ts';
 import { settingsForm } from './settings-form.ts';
+import type { SettingsForm } from './settings-form.ts';

 const SAVE_KEY = 'station-master.save.v1';
 const SETTINGS_KEY = 'station-master.settings.v1';
@@ -628,12 +629,15 @@ function noteFirstFrame(f: Frame): void {
  );
 }

-/** 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. */
-function showScreen(which: 'lobby' | 'gameui'): void {
+/** Toggles the three mutually-exclusive top-level screens `play.html` defines — `#lobby` (Phase 4),
+ * `#gameui` (the board, whether local or remote), and `#solitairesetup` (asked before the first
+ * solitaire deal, the same way `#lobby` is asked before the first multiplayer one — Jesse,
+ * 2026-08-29). All three start `hidden` in the markup so none ever flashes before `start()` decides
+ * which one this load actually needs. */
+function showScreen(which: 'lobby' | 'gameui' | 'solitairesetup'): void {
  document.getElementById('lobby')!.hidden = which !== 'lobby';
  document.getElementById('gameui')!.hidden = which !== 'gameui';
+  document.getElementById('solitairesetup')!.hidden = which !== 'solitairesetup';
 }

 /**
@@ -714,10 +718,29 @@ function start(): void {
    return;
  }

+  /**
+   * ASKING FOR SOLITAIRE BEATS RESUMING A MULTIPLAYER SESSION TOO — same reasoning as `?lobby`
+   * above, for the door on the other side. A browser that has ever held a multiplayer seat carries
+   * `remembered` forever (`loadRemote` finds it below), and a bare `./play.html` load could not tell
+   * "I clicked Play solitaire" apart from "I reloaded mid-game" — so the splash's solitaire door
+   * always lost to whatever multiplayer game or lobby this browser last touched, and could never
+   * actually reach solitaire. Found 2026-08-29 verifying v0.7.5 on `phoenix.local`: the door landed
+   * back in a Co-op, four-seat LOBBY from unrelated earlier testing rather than solitaire's own new
+   * setup screen. The door now marks its intent explicitly, the same way `?lobby` already does —
+   * and so does everything else that already means "this is a solitaire navigation": an explicit
+   * `?seed=` (a shared or bookmarked deal) and `?hand=` (the setup screen's own Deal button writes
+   * it on every commit, so landing back here with it set is that navigation, not a bare reload).
+   * Checked here, ahead of `remembered`, rather than only below with `saved` — otherwise Deal would
+   * work once and then bounce the very next load into whatever multiplayer game this browser last
+   * touched, since its URL carries `hand=` but not `solitaire=`.
+   */
+  const wantsSolitaire =
+    params.get('solitaire') !== null || params.get('seed') !== null || params.has('hand');
+
  // 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();
+  const remembered = wantsSolitaire ? null : loadRemote();
  if (remembered && remembered.stage === 'game' && remembered.seat !== undefined) {
    beginRemote({ ...remembered, seat: remembered.seat });
    return;
@@ -739,16 +762,43 @@ function start(): void {
    return;
  }

-  showScreen('gameui');
+  // A saved game carries its OWN rules and re-deals itself under them, whatever the URL says — see
+  // `configFor`. Read once, here, so the same answer decides both whether to ask before dealing and
+  // (below) whether to restore.
+  const saved = load();
  const requested = params.get('seed');
+
+  /**
+   * ASK BEFORE THE FIRST DEAL, THE SAME WAY THE LOBBY ASKS BEFORE THE FIRST MULTIPLAYER GAME
+   * (Jesse, 2026-08-29 — "let the user choose their options like the start of a multiplayer game";
+   * "asking first is the only path").
+   *
+   * Three things answer the question and so skip the screen, in this order of precedence:
+   * `hand` (every `commitNewGame` write sets it, so this navigation IS the Deal button landing back
+   * here to deal), `seed` (a specific deal someone chose to share or bookmark), and — only when the
+   * player did not explicitly ask to set one up — an existing save, which is a game to resume.
+   *
+   * THE DOOR OUTRANKS A SAVED GAME, and getting that wrong is what made this feature unreachable
+   * for three releases. v0.7.5 skipped the screen whenever `load()` found ANYTHING, reasoned as "a
+   * saved game is a game to resume" — but a browser that has ever played solitaire always has one,
+   * so the door could never reach the screen again. Reported three times (Jesse, 2026-08-29 twice
+   * and 2026-08-30); a private window appeared to absolve it only because it had never played and
+   * so had no save. Clicking "Play solitaire" is a request to set a game up, not to resume one — a
+   * BARE reload is the resume case, and still is. `#ss-resume` is what keeps the save reachable, so
+   * this costs nobody the game they were playing.
+   */
+  const askedToSetUp = params.get('solitaire') !== null;
+  if (requested === null && !params.has('hand') && (askedToSetUp || !saved)) {
+    showScreen('solitairesetup');
+    runSolitaireSetup(params, saved !== null);
+    return;
+  }
+
+  showScreen('gameui');
  // 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, solitaireDefaults(gameOptionsFromUrl(params)));
  session = local;
-
-  // A saved game carries its OWN rules and re-deals itself under them, whatever the URL says — see
-  // `configFor`. That is why the restore happens after the session is built rather than feeding it.
-  const saved = load();
  if (saved && requested === null) local.restore(saved);

  applyCapabilities();
@@ -1895,58 +1945,77 @@ if (leaveBtn) {
  };
 }

-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;
-  const ngForm = settingsForm('ng-');
-
 /**
-   * THE SAME FIVE GAME TYPES THE LOBBY OFFERS, and the same shared rules block under them.
+ * ONE GAME-TYPE BLOCK, WIRED — the type radios, the shared rules form beneath them, and the small
+ * glue between them (which type is currently selected, what its note says, how Days feeds the
+ * floor). The in-game "New game" dialog (`ng-`) and the pre-game setup screen (`ss-`, Gitea
+ * "let the user choose their options like the start of a multiplayer game", 2026-08-29) both need
+ * an identical copy of this — factored out once so the two cannot drift apart the way the rules
+ * block itself already had before `settings-form.ts` existed to stop it.
 *
-   * The dialog used to carry its own copy of the questions and its own idea of the defaults, which
-   * is how it ended up with "where an Extra may start" that the lobby did not have and none of the
-   * three optional rules that it did. Both screens now read `presets.ts` and drive their block
-   * through `settings-form.ts`; only Solitaire can actually be DEALT here, so the three multiplayer
-   * types are shown disabled rather than hidden — what this screen offers and what the lobby offers
-   * should read as one list, not two.
+ * PREFILLING IS DELIBERATELY LEFT TO THE CALLER. The dialog opens on the game CURRENTLY IN PLAY
+ * (so redealing to compare keeps comparing); the setup screen opens on the plain Solitaire
+ * defaults, because there is no game yet to read. `setBase` plus a direct `form.write(...)` is the
+ * seam that lets each caller do its own version of "what do these fields show at first paint"
+ * without this function having to guess which one it is wiring.
 */
-  let ngBase: PresetName = 'solitaire';
-  let ngType: GameType = 'solitaire';
-  /** As in the lobby: the floor is derived from the length until the player sets one themselves. */
-  let ngFloorTyped = false;
+type WiredGameType = {
+  form: SettingsForm;
+  days(): number;
+  refresh(): void;
+  /** The common case: prefill straight from a named type's own defaults, then repaint. */
+  selectPreset(name: PresetName): void;
+  /** The dialog's case: the caller writes the form itself (from a live game), then calls `refresh`
+   * — this only sets which type that write should be compared against. */
+  setBase(name: PresetName, type: GameType): void;
+};

-  const ngDays = (): number => {
-    const raw = Number(field<HTMLInputElement>('ng-days').value);
+function wireGameTypeBlock(prefix: string, root: ParentNode): WiredGameType {
+  const field = <T extends HTMLElement>(id: string): T => document.getElementById(`${prefix}${id}`) as T;
+  const form = settingsForm(prefix);
+
+  let base: PresetName = 'solitaire';
+  let type: GameType = 'solitaire';
+  /** As in the lobby: the floor is derived from the length until the player sets one themselves. */
+  let floorTyped = false;
+
+  const days = (): number => {
+    const raw = Number(field<HTMLInputElement>('days').value);
    return Number.isFinite(raw) && raw >= 1 ? Math.round(raw) : 5;
  };

-  const ngTypeRadios = (): HTMLInputElement[] =>
-    Array.from(dlg.querySelectorAll<HTMLInputElement>('input[name="ng-type"]'));
+  const typeRadios = (): HTMLInputElement[] =>
+    Array.from(root.querySelectorAll<HTMLInputElement>(`input[name="${prefix}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');
+  function refresh(): void {
+    const differing = form.mark(base, 1, days());
+    if (differing.length > 0) type = 'custom';
+    else if (type === 'custom') type = base;
+    for (const r of typeRadios()) r.checked = r.value === type;
+    const note = field<HTMLElement>('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;
+      type === 'custom'
+        ? `${gameTypeLabel('custom', preset(base).scoring)} · ${differing.length} ` +
+          `${differing.length === 1 ? 'setting differs' : 'settings differ'} from ${preset(base).label}.`
+        : preset(type as PresetName).blurb;
  }

-  function ngSelectPreset(name: PresetName): void {
-    ngBase = name;
-    ngType = name;
-    ngFloorTyped = false;
-    const values = presetSettings(name, 1, ngDays());
-    ngForm.write(values, values);
-    ngRefresh();
+  function selectPreset(name: PresetName): void {
+    base = name;
+    type = name;
+    floorTyped = false;
+    const values = presetSettings(name, 1, days());
+    form.write(values, values);
+    refresh();
  }

-  for (const r of ngTypeRadios()) {
+  function setBase(name: PresetName, t: GameType): void {
+    base = name;
+    type = t;
+    floorTyped = false;
+  }
+
+  for (const r of typeRadios()) {
    // 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).
@@ -1964,33 +2033,99 @@ if (newBtn && dlg) {
    r.onchange = () => {
      if (!r.checked) return;
      if (r.value === 'custom') {
-        ngType = 'custom';
-        ngRefresh();
+        type = 'custom';
+        refresh();
        return;
      }
-      ngSelectPreset(r.value as PresetName);
+      selectPreset(r.value as PresetName);
    };
  }

-  ngForm.onEdit((key) => {
-    if (key === 'minCombinedRevenue') ngFloorTyped = true;
-    ngType = 'custom';
-    ngRefresh();
+  form.onEdit((key) => {
+    if (key === 'minCombinedRevenue') floorTyped = true;
+    type = 'custom';
+    refresh();
  });

  // 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);
+  field<HTMLInputElement>('days').oninput = () => {
+    if (!floorTyped) {
+      const values = form.read();
+      const want = presetSettings(base, 1, days());
+      form.write({ ...values, minCombinedRevenue: want.minCombinedRevenue }, want);
    }
-    ngRefresh();
+    refresh();
  };

  // "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);
+  // block still visible, so every screen that offers it reads the same.
+  form.setEmployeeRotationAvailable(false);
+
+  return { form, days, refresh, selectPreset, setBase };
+}
+
+/**
+ * THE COMMIT — reads a wired block's answers and turns them into a URL, the same path `?seed=`
+ * already took: `start()` reads it back out, so there is exactly one place that turns a URL into a
+ * game, whichever screen produced it.
+ */
+function commitNewGame(wired: WiredGameType, seedFieldValue: string): void {
+  const asked = seedFieldValue.trim();
+  // 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 settings = wired.form.read();
+  const rules = houseRules({
+    houseRules: {
+      startingHand: settings.startingHand,
+      extraStart: settings.extraStart,
+      discardTimetabled: settings.discardTimetabled,
+      revenue: {
+        passengerPerCoach: settings.passengerPerCoach,
+        freightPerLoad: settings.freightPerLoad,
+        trainPerTransit: settings.trainPerTransit,
+      },
+    },
+  });
+  const victory: NewGameOptions = {
+    days: Math.max(1, wired.days()),
+    minCombinedRevenue: settings.minCombinedRevenue,
+    maxCollisionsPerDay: settings.maxCollisionsPerDay,
+    maxCollisionsTotal: settings.maxCollisionsTotal,
+    optionalRules: {
+      reducedVisibility: settings.reducedVisibility,
+      // Never on at a table of one, whatever the box says — the control is disabled for the same
+      // reason, and this is the half that reaches the engine.
+      employeeRotation: false,
+      emergencyToolbox: settings.emergencyToolbox,
+    },
+  };
+
+  clearSave();
+  const next = rulesToUrl(rules, victory, seed);
+  // Assigning the search string the page ALREADY has does nothing at all, which reads as a button
+  // that did not work — and it is the common case: deal a random seed, decide it was a bad deal,
+  // deal another at the same settings. Reload instead, and `start()` rolls a fresh seed.
+  if (next === location.search) location.reload();
+  else location.search = next;
+}
+
+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;
+
+  /**
+   * THE SAME FIVE GAME TYPES THE LOBBY OFFERS, and the same shared rules block under them.
+   *
+   * The dialog used to carry its own copy of the questions and its own idea of the defaults, which
+   * is how it ended up with "where an Extra may start" that the lobby did not have and none of the
+   * three optional rules that it did. Every screen now reads `presets.ts` and drives its 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.
+   */
+  const ng = wireGameTypeBlock('ng-', dlg);

  /**
   * ASK FOR ALL OF IT, rather than documenting URL parameters in the title bar.
@@ -2019,65 +2154,65 @@ if (newBtn && dlg) {

    field<HTMLInputElement>('ng-seed').value = '';
    field<HTMLInputElement>('ng-days').value = String(f.days);
-    ngBase = 'solitaire';
-    ngType = 'solitaire';
-    ngFloorTyped = false;
+    ng.setBase('solitaire', 'solitaire');
    // 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();
+    ng.form.write(settingsOf(configFromFrame(f)), presetSettings('solitaire', 1, f.days));
+    ng.refresh();
    dlg.showModal();
  };

  /**
   * One handler for every way the dialog can close — the Deal button, the Cancel button, and Esc,
   * which `<dialog>` answers with an empty `returnValue` and no submit event at all.
-   *
-   * 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.
   */
  dlg.addEventListener('close', () => {
    if (dlg.returnValue !== 'deal') return;
-
-    const asked = field<HTMLInputElement>('ng-seed').value.trim();
-    // 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 settings = ngForm.read();
-    const rules = houseRules({
-      houseRules: {
-        startingHand: settings.startingHand,
-        extraStart: settings.extraStart,
-        discardTimetabled: settings.discardTimetabled,
-        revenue: {
-          passengerPerCoach: settings.passengerPerCoach,
-          freightPerLoad: settings.freightPerLoad,
-          trainPerTransit: settings.trainPerTransit,
-        },
-      },
+    commitNewGame(ng, field<HTMLInputElement>('ng-seed').value);
  });
-    const victory: NewGameOptions = {
-      days: Math.max(1, ngDays()),
-      minCombinedRevenue: settings.minCombinedRevenue,
-      maxCollisionsPerDay: settings.maxCollisionsPerDay,
-      maxCollisionsTotal: settings.maxCollisionsTotal,
-      optionalRules: {
-        reducedVisibility: settings.reducedVisibility,
-        // Never on at a table of one, whatever the box says — the control is disabled for the same
-        // reason, and this is the half that reaches the engine.
-        employeeRotation: false,
-        emergencyToolbox: settings.emergencyToolbox,
-      },
-    };
+}

-    clearSave();
-    const next = rulesToUrl(rules, victory, seed);
-    // Assigning the search string the page ALREADY has does nothing at all, which reads as a button
-    // that did not work — and it is the common case: deal a random seed, decide it was a bad deal,
-    // deal another at the same settings. Reload instead, and `start()` rolls a fresh seed.
-    if (next === location.search) location.reload();
-    else location.search = next;
-  });
+/**
+ * THE PRE-GAME SETUP SCREEN — asked before the FIRST solitaire deal, the same way `#lobby` is
+ * already asked before the first multiplayer one (Jesse, 2026-08-29: "let the user choose their
+ * options like the start of a multiplayer game"; "asking first is the only path").
+ *
+ * Only reached for a genuinely fresh visit — `start()` is what decides that; by the time this runs,
+ * there is no saved game and no URL already carrying a deal's answers. It opens on the plain
+ * Solitaire defaults, since there is no live game to compare against yet, and reuses the identical
+ * `wireGameTypeBlock`/`commitNewGame` pair the in-game dialog uses — the two are one design, not two.
+ */
+function runSolitaireSetup(params: URLSearchParams, hasSave = false): void {
+  const screen = document.getElementById('solitairesetup');
+  const dealBtn = document.getElementById('ss-deal');
+  if (!screen || !dealBtn) return;
+
+  const ss = wireGameTypeBlock('ss-', screen);
+  // A `?seed=` with no other rules params still means SOMETHING — a shared or bookmarked link
+  // naming a specific deal — so it is honoured as a prefill rather than discarded because this
+  // visit happened to be routed through the screen that now asks first.
+  const seedField = document.getElementById('ss-seed') as HTMLInputElement | null;
+  if (seedField) seedField.value = params.get('seed') ?? '';
+
+  /**
+   * THE WAY BACK TO A GAME IN PROGRESS, and the reason the door is allowed to outrank a save at all.
+   * Dealing from here calls `clearSave()`, so a player who reached this screen from the splash — by
+   * clicking "Play solitaire", which nobody reads as "throw away what I was playing" — needs their
+   * game one button away and needs to be told what Deal costs.
+   *
+   * Resuming is a navigation to the BARE url rather than a session built here: `start()` already
+   * resumes a save on a bare load, and routing both paths through it keeps one place that turns a
+   * URL into a game.
+   */
+  const resumeBtn = document.getElementById('ss-resume');
+  const savedNote = document.getElementById('ss-saved-note');
+  if (resumeBtn) {
+    resumeBtn.hidden = !hasSave;
+    resumeBtn.onclick = () => void (location.search = '');
+  }
+  if (savedNote) savedNote.hidden = !hasSave;
+
+  ss.selectPreset('solitaire');
+  dealBtn.onclick = () => commitNewGame(ss, seedField?.value ?? '');
 }

 const zoomOutBtn = document.getElementById('zoomout') as HTMLButtonElement | null;
@@ -80,7 +80,7 @@ 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:1040px;margin:0 auto;padding:14px}
+#lobby,#solitairesetup{max-width:1040px;margin:0 auto;padding:14px}
 /* The create form is two short lists, not one long one: what game this is on the left, what its
   rules are on the right. Collapses to one column where there is no room for two. */
 .lb-two{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1.1fr);gap:22px;align-items:start}
@@ -96,8 +96,8 @@ section{background:var(--panel);border:1px solid var(--line);border-radius:7px;
 .ng-radio.disabled{opacity:.45;cursor:not-allowed}
 .ng-radio.disabled:hover{background:none}
 .lb-why{color:#e0b060;font-size:11px}
-#lobby h2{margin-top:0}
-#lobby h3{margin-bottom:2px}
+#lobby h2,#solitairesetup h2{margin-top:0}
+#lobby h3,#solitairesetup h3{margin-bottom:2px}
 .lb-seat{display:flex;align-items:center;gap:8px;padding:5px 0;border-bottom:1px solid var(--line)}
 .lb-seat:last-child{border-bottom:none}
 .lb-seat .who{flex:1}
@@ -592,6 +592,193 @@ ul.blocked li{padding:2px 0}
  </section>
 </div>

+<!-- ===================================================================
+     SOLITAIRE SETUP — the same question multiplayer already asks first,
+     now asked here too (Jesse, 2026-08-29): a genuinely fresh visit deals
+     nothing until this screen's own Deal button is pressed. A saved game,
+     an explicit `?seed=`, or a URL already carrying a Deal's answers (any
+     of the shared block's fields — `hand` names the one always written)
+     all skip straight past this screen, exactly as `?lobby` already skips
+     past it into the lobby: those are not "no plan yet", they are a
+     choice already made, elsewhere.
+
+     THE SAME BLOCK THE DIALOG AND THE LOBBY USE, same shared module
+     (`settings-form.ts`), same order — three screens are one design now
+     instead of two. Only Solitaire can be dealt from here, so the other
+     four types are shown exactly as the in-game dialog shows them: present,
+     disabled, with a note pointing at the Multiplayer door instead.
+     ==================================================================== -->
+<div id="solitairesetup" hidden>
+  <header><b><a href="./index.html" class="home">Station Master</a></b> — <span class="dim">Solitaire</span></header>
+
+  <section>
+    <h2>New solitaire game</h2>
+    <p class="ng-note">One railroad, one player, five full days by default — everything below is
+       yours to change before you deal. Clearing the Revenue floor wins; falling short loses.</p>
+
+    <div class="lb-params">
+      <label class="ng-num"><span>Seed</span>
+        <input id="ss-seed" type="text" inputmode="numeric" autocomplete="off" placeholder="blank for a random seed"></label>
+      <label class="ng-num"><span>Days</span>
+        <input id="ss-days" type="number" min="1" max="20" step="1" value="5"></label>
+    </div>
+    <p class="ng-note">The same seed and the same settings always deal the same railroad, so a game
+       can be shared, compared or replayed. Leave it blank for a random one.</p>
+
+    <h3>Game type</h3>
+    <div class="set-row" id="ss-type-row">
+      <label class="ng-radio"><input type="radio" name="ss-type" value="solitaire" checked>
+        <span><b>Solitaire</b><br><span class="dim">One railroad, one player. The whole Division is yours to run.</span></span></label>
+      <label class="ng-radio"><input type="radio" name="ss-type" value="coop">
+        <span><b>Co-op</b><br><span class="dim">Everyone&#8217;s Revenue is one table score. You win together or lose together.</span></span></label>
+      <label class="ng-radio"><input type="radio" name="ss-type" value="competitive">
+        <span><b>Competitive</b><br><span class="dim">Highest Revenue wins — unless the table misses its combined minimum, and then everyone loses.</span></span></label>
+      <label class="ng-radio"><input type="radio" name="ss-type" value="cutthroat">
+        <span><b>Cutthroat</b><br><span class="dim">Highest Revenue wins, and nothing is shared — the only way everyone loses is three collisions in one Day.</span></span></label>
+      <label class="ng-radio"><input type="radio" name="ss-type" value="custom">
+        <span><b>Custom</b><br><span class="dim">Whatever you set below. Selected for you the moment you change a rule; it is scored as the type you started from.</span></span></label>
+    </div>
+
+    <p class="ng-note" id="ss-type-note"></p>
+
+    <details id="ss-settings" open>
+      <summary>Game settings</summary>
+      <p class="ng-note">Every rule the game type sets, and every one of them yours to change.
+         Changing any of them selects <b>Custom</b>; clicking a type again resets all of them back
+         to it.</p>
+      <div class="set-groups">
+
+      <div class="set-group">
+      <h3>Starting hand</h3>
+      <p class="ng-note">What you are dealt before the first turn. The hand limit is three either
+         way — deal six and the first turn is spent choosing which of them to keep.</p>
+      <div class="set-row" id="ss-hand-row">
+        <label class="ng-radio"><input type="radio" name="ss-hand" value="threeRandom">
+          <span><b>Three random cards</b><br><span class="dim">The original rule. At the hand limit already, and no guarantee of track.</span></span></label>
+        <label class="ng-radio"><input type="radio" name="ss-hand" value="sixRandom" checked>
+          <span><b>Six random cards</b><br><span class="dim">Twice the choice, still no guaranteed track — the first turn is a discard.</span></span></label>
+        <label class="ng-radio"><input type="radio" name="ss-hand" value="threeTrackThreeOther">
+          <span><b>Three random track and three random non-track cards</b><br><span class="dim">Dealt from two piles, so the district you can build is dealt rather than waited for.</span></span></label>
+        <span class="set-hint" id="ss-hand-hint"></span>
+      </div>
+      </div>
+
+      <div class="set-group">
+      <h3>Where an Extra may start</h3>
+      <p class="ng-note">The player who plays an Extra Train card chooses where its Crew Tray goes,
+         and the place decides which way it runs — a Division Point sends it away from itself; in the
+         middle of the railroad the player picks east or west. The Division Points and the Interchange
+         belong to nobody and are always available. Starting one inside a district is the part that
+         favours a seat, so it is set here. An Office must be a Control Point whatever this says: a
+         Whistle Post never qualifies.</p>
+      <div class="set-row" id="ss-extra-row">
+        <label class="ng-radio"><input type="radio" name="ss-extra" value="divisionPointsOnly">
+          <span><b>Division Points and the Interchange only</b><br><span class="dim">The strictest reading. Every Extra begins on shared ground.</span></span></label>
+        <label class="ng-radio"><input type="radio" name="ss-extra" value="ownOffice">
+          <span><b>Also the playing player&#8217;s own Control Point</b><br><span class="dim">You may start one at home, but not in somebody else&#8217;s district.</span></span></label>
+        <label class="ng-radio"><input type="radio" name="ss-extra" value="anyOffice">
+          <span><b>Also any player&#8217;s Control Point</b><br><span class="dim">The most permissive — an Extra may be planted in another player&#8217;s district.</span></span></label>
+        <span class="set-hint" id="ss-extra-hint"></span>
+      </div>
+      </div>
+
+      <div class="set-group">
+      <h3>Revenue</h3>
+      <p class="ng-note">What each piece of work pays, 0 to 5. A coach pays when it is boarded and
+         again when it is detrained; a load pays when it is made up and again when it is broken. Zero
+         switches an economy off so the others can be read.</p>
+      <div class="set-row" id="ss-passenger-row">
+        <label class="ng-num"><span>Passenger revenue per coach</span>
+          <input id="ss-passenger" type="number" min="0" max="5" step="1" value="1"></label>
+        <span class="set-hint" id="ss-passenger-hint"></span>
+      </div>
+      <div class="set-row" id="ss-freight-row">
+        <label class="ng-num"><span>Freight revenue per load</span>
+          <input id="ss-freight" type="number" min="0" max="5" step="1" value="1"></label>
+        <span class="set-hint" id="ss-freight-hint"></span>
+      </div>
+      <div class="set-row" id="ss-transit-row">
+        <label class="ng-num"><span>Train revenue per transit</span>
+          <input id="ss-transit" type="number" min="0" max="5" step="1" value="0"></label>
+        <span class="set-hint" id="ss-transit-hint"></span>
+      </div>
+      <p class="ng-note">A transit pays every player, once, when a train runs off the end of the
+         Division — the one thing nobody has to work for.</p>
+      </div>
+
+      <div class="set-group">
+      <h3>Victory conditions</h3>
+      <p class="ng-note">The ways this game can end badly. How long it runs is set above, in Days.</p>
+      <div class="set-row" id="ss-minrev-row">
+        <label class="ng-gate"><input type="checkbox" id="ss-minrev-on" checked>
+          <span>You lose if Revenue at the end is under</span>
+          <input id="ss-minrev" type="number" min="0" step="1" class="gate-num"></label>
+        <span class="set-hint" id="ss-minrev-hint"></span>
+      </div>
+      <div class="set-row" id="ss-colday-row">
+        <label class="ng-gate"><input type="checkbox" id="ss-colday-on" checked>
+          <span>The game ends in a loss if collisions in one Day reach</span>
+          <input id="ss-colday" type="number" min="0" step="1" class="gate-num"></label>
+        <span class="set-hint" id="ss-colday-hint"></span>
+      </div>
+      <div class="set-row" id="ss-coltotal-row">
+        <label class="ng-gate"><input type="checkbox" id="ss-coltotal-on" checked>
+          <span>The game ends in a loss after this many collisions in the whole game</span>
+          <input id="ss-coltotal" type="number" min="0" step="1" class="gate-num"></label>
+        <span class="set-hint" id="ss-coltotal-hint"></span>
+      </div>
+      <p class="ng-note">The opponent-directed cards — Derail, Watertower, Hobo Jungle and the
+         nineteen others, along with the seven that answer them — are not implemented yet, so no game
+         type deals them whatever else is set here.</p>
+      </div>
+
+      <div class="set-group">
+      <h3>Optional rules</h3>
+      <p class="ng-note">Off in every game type; each one changes how the game plays.</p>
+      <div class="set-row" id="ss-visibility-row">
+        <label class="ng-num"><span>Reduced Visibility — five switching Moves instead of six in the
+          night Stages (1&ndash;3 and 11&ndash;12)</span>
+          <input id="ss-visibility" type="checkbox"></label>
+        <span class="set-hint" id="ss-visibility-hint"></span>
+      </div>
+      <div class="set-row" id="ss-rotation-row">
+        <label class="ng-num"><span>Employee Rotation — meaningless at a table of one, shown here so
+          this screen and the lobby read as one list</span>
+          <input id="ss-rotation" type="checkbox" disabled></label>
+        <span class="set-hint" id="ss-rotation-hint"></span>
+      </div>
+      <div class="set-row" id="ss-toolbox-row">
+        <label class="ng-num"><span>Emergency Toolbox — start holding a Red Flag, so a hand of four;
+          play or discard down to three on the first turn</span>
+          <input id="ss-toolbox" type="checkbox"></label>
+        <span class="set-hint" id="ss-toolbox-hint"></span>
+      </div>
+      <div class="set-row" id="ss-tossloco-row">
+        <label class="ng-num"><span>A Timetabled train may be discarded — toss it face-up to a
+          Department slot. Turn this off and a train card can only ever be played onto the timetable.
+          An Extra is never discardable either way</span>
+          <input id="ss-tossloco" type="checkbox"></label>
+        <span class="set-hint" id="ss-tossloco-hint"></span>
+      </div>
+      </div>
+
+      </div>
+    </details>
+
+    <!-- Shown only when `station-master.save.v1` holds a game. Dealing from this screen CLEARS that
+         save (`commitNewGame` calls `clearSave`), so without a way back the door would be a way to
+         lose a game in progress — and the door is reached by clicking "Play solitaire", which nobody
+         reads as "discard what I was playing". -->
+    <p class="ng-note" id="ss-saved-note" hidden>You have a solitaire game in progress. Dealing a new
+       one below replaces it &mdash; there is no undo for that.</p>
+
+    <menu class="ng-buttons">
+      <button id="ss-resume" type="button" hidden>Continue saved game</button>
+      <button id="ss-deal" type="button">Deal</button>
+    </menu>
+  </section>
+</div>
+
 <div id="gameui" hidden>
 <div class="topbar">
 <header>
@@ -26,6 +26,7 @@ import { createGame } from '../engine/setup.ts';
 import { snapshot } from '../sim/view.ts';
 import type { Intent } from '../engine/intents.ts';
 import { SOLO_CONFIG } from './game.ts';
+import { actingPlayer } from '../engine/state.ts';

 type Save = { seed: number; history: Intent[] };
 type Entry = { file: string; title: string; note?: string; seed?: number };
@@ -69,7 +70,7 @@ function rebuild(save: Save): { steps: Step[]; stoppedEarly: boolean } {
  push(pump(s));
  let stoppedEarly = false;
  for (const intent of save.history) {
-    const actor = s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
+    const actor = actingPlayer(s);
    if (actor === null || s.status !== 'active') break;
    const r = applyIntent(s, actor, intent);
    if (!r.ok) {
@@ -495,7 +495,7 @@ describe('the Superintendent clearance interrupt (§8.1)', () => {
    assert.equal(r.needsInput, true, 'the phase must stop and ask');
    assert.notEqual(s.clock.pendingDecision, null);
    assert.equal(s.clock.pendingDecision!.train, 'behind');
-    assert.equal(s.clock.pendingDecision!.occupiedBy, 'ahead');
+    assert.equal((s.clock.pendingDecision as { occupiedBy: string }).occupiedBy, 'ahead');
  });

  it('does not ask when the train ahead is coming the other way — that is an absolute bar', () => {
@@ -541,7 +541,7 @@ describe('the Superintendent clearance interrupt (§8.1)', () => {
  it('clears the decision once the Superintendent rules', () => {
    const s = game();
    s.clock.phase = 'mainline';
-    s.clock.pendingDecision = { train: 'a', occupiedBy: 'b' };
+    s.clock.pendingDecision = { kind: 'clearance', train: 'a', occupiedBy: 'b' };
    const r = applyIntent(s, 0, { type: 'mainline.clearance', allow: false });
    assert.ok(r.ok);
    assert.equal(s.clock.pendingDecision, null);
@@ -749,43 +749,156 @@ describe('MILESTONE: a full solitaire game runs headless', () => {
  });
 });

-describe('X18 Circus Train — a point for standing still', () => {
-  it('pays once for a Stage spent stopped, and never again', () => {
+describe('X18 Circus / X17 Campaign — a point for setting up (Gitea#13)', () => {
  /**
-     * REPORTED: "Circus train TX18 was stopped on a siding for a full Stage and I did not get my
-     * Revenue point." It never could: `stopEarnsPoint` was declared on the profile and read
-     * NOWHERE, along with eight other special-train rules. The one card in the deck that pays for
-     * standing still paid nothing.
+   * REPORTED originally: "Circus train TX18 was stopped on a siding for a full Stage and I did not
+   * get my Revenue point." It never could: `stopEarnsPoint` was declared on the profile and read
+   * NOWHERE, along with eight other special-train rules.
+   *
+   * REDEFINED by Gitea#13 (Jesse, 2026-08-29), and these tests carry the three parts of that
+   * ruling: the point is paid ONCE PER OFFICE AREA rather than once per game, only when the train
+   * is FULLY LOADED, and only in an Office Area at all.
   */
-    const s = game();
+  const circusAt = (s: GameState, seat: number, coord: { row: number; col: number }, consist: unknown[]) => {
    s.clock.phase = 'mainline';
    s.trays.set('circus', {
      id: 'circus', trainNumber: 18, trainIsExtra: true, engineAt: 0,
-      consist: [], direction: 'east',
-      position: { at: 'grid', seat: 0, coord: { row: -1, col: 0 } },
+      consist, direction: 'east',
+      position: { at: 'grid', seat, coord },
      movesUsed: 0,
    } as never);
    // A card under it, so the crew is somewhere real rather than off the grid.
-    areaOf(s, 0).grid.set('-1,0', {
+    areaOf(s, seat as never).grid.set(`${coord.row},${coord.col}`, {
      geometry: { kind: 'track', geometry: 'straight' },
      baseOperationalRail: true, standing: [], facility: null, modifiers: [], enhancements: [],
    } as never);
+  };

+  const loaded = [
+    { type: 'boxcar', loaded: true },
+    { type: 'boxcar', loaded: true },
+    { type: 'coach', loaded: true },
+    { type: 'caboose', loaded: true },
+  ];
+
+  const runPhase = (s: GameState) => {
+    s.clock.phase = 'mainline';
+    s.movedThisPhase = new Set();
+    return pump(s);
+  };
+
+  it('pays a fully loaded Circus for a Stage spent set up', () => {
+    const s = game();
+    circusAt(s, 0, { row: -1, col: 0 }, loaded);
    const before = s.players[0]!.revenue;
-    const first = pump(s);
    assert.ok(
-      first.some((e) => e.type === 'trainStoodStill' && e.trainNumber === 18),
+      pump(s).some((e) => e.type === 'trainStoodStill' && e.trainNumber === 18),
      'the Circus Train stood still for a Stage and earned nothing',
    );
    assert.equal(s.players[0]!.revenue, before + 1, 'the point was not paid');
+  });

-    // "One turn stopped" — once. A train that goes on standing there does not keep earning.
-    const paidAgain = () => {
+  it('pays once per Office Area, however long it parks there', () => {
+    // "Once per stop in an office area" — a train that goes on standing in the same district does
+    // not keep earning. This is the half that was already true, for a different reason.
+    const s = game();
+    circusAt(s, 0, { row: -1, col: 0 }, loaded);
+    pump(s);
+    assert.ok(!runPhase(s).some((e) => e.type === 'trainStoodStill'),
+      'the Circus collected twice for the same set-up');
+    assert.ok(!runPhase(s).some((e) => e.type === 'trainStoodStill'),
+      'the Circus collected a third time for the same set-up');
+  });
+
+  it('pays AGAIN in a different district — each player can be visited', () => {
+    /**
+     * The half that is new. "In a multiplayer game, each player could score if the circus stops in
+     * their area" — so the claim is per seat, and a touring Circus is paid by each district it sets
+     * up in. Before Gitea#13 this paid once per GAME and the second district got nothing.
+     */
+    const s = createGame({
+      id: 'g', seed: 5, config: baseConfig({ mode: 'competitive' }), playerNames: ['A', 'B'],
+    });
+    circusAt(s, 0, { row: -1, col: 0 }, loaded);
+    pump(s);
+    const paidFirst = s.players.map((p) => p.revenue);
+
+    // The same train, moved into the other player's district.
+    const tray = s.trays.get('circus')!;
+    areaOf(s, 1 as never).grid.set('-1,0', {
+      geometry: { kind: 'track', geometry: 'straight' },
+      baseOperationalRail: true, standing: [], facility: null, modifiers: [], enhancements: [],
+    } as never);
+    tray.position = { at: 'grid', seat: 1, coord: { row: -1, col: 0 } } as never;
+
+    assert.ok(runPhase(s).some((e) => e.type === 'trainStoodStill'),
+      'the Circus set up in a second district and earned nothing');
+    const owner = s.seating[1]!;
+    assert.equal(
+      s.players[owner]!.revenue,
+      paidFirst[owner]! + 1,
+      'the point did not go to whoever sits in the district it stopped in',
+    );
+  });
+
+  it('pays nothing when the cars are empty — "not much of a circus"', () => {
+    const s = game();
+    circusAt(s, 0, { row: -1, col: 0 }, [
+      { type: 'boxcar', loaded: false },
+      { type: 'coach', loaded: true },
+      { type: 'caboose', loaded: true },
+    ]);
+    const before = s.players[0]!.revenue;
+    assert.ok(!pump(s).some((e) => e.type === 'trainStoodStill'),
+      'an empty car aboard still collected the set-up point');
+    assert.equal(s.players[0]!.revenue, before, 'Revenue moved for a train that was not full');
+  });
+
+  it('pays nothing to a train carrying nothing at all', () => {
+    // `every` on an empty list is vacuously true, so the emptiest train of the lot is exactly the
+    // one a careless test would pay.
+    const s = game();
+    circusAt(s, 0, { row: -1, col: 0 }, []);
+    assert.ok(!pump(s).some((e) => e.type === 'trainStoodStill'),
+      'a Circus carrying nothing was paid for setting up');
+  });
+
+  it('pays nothing for standing out on the Mainline', () => {
+    /**
+     * It used to, and it misattributed the point: `playerAtSeat` needs a seat, there is none off
+     * the grid, and the fallback handed it to PLAYER 0 wherever the train was standing. Jesse's
+     * ruling scopes the rule to Office Areas, which removes the bug rather than patching it.
+     */
+    const s = game();
    s.clock.phase = 'mainline';
-      s.movedThisPhase = new Set();
-      return pump(s).some((e) => e.type === 'trainStoodStill');
-    };
-    assert.ok(!paidAgain(), 'the Circus Train collected a second time for the same set-up');
+    const index = s.division.nodes.findIndex((n) => n.kind === 'mainline');
+    s.trays.set('circus', {
+      id: 'circus', trainNumber: 18, trainIsExtra: true, engineAt: 0,
+      consist: loaded, direction: 'east',
+      position: { at: 'mainline', index },
+      movesUsed: 0,
+    } as never);
+    const before = s.players[0]!.revenue;
+    pump(s);
+    assert.equal(s.players[0]!.revenue, before, 'a Mainline set-up paid a point');
+  });
+
+  it('pays the Campaign Train only when its candidate is aboard', () => {
+    // X17 carries one coach and no freight, so "fully loaded" is exactly "the coach is occupied".
+    // It earned nothing at all before Gitea#13 — it had `stopThenExpedite` and no scoring rule.
+    const occupied = game();
+    circusAt(occupied, 0, { row: -1, col: 0 }, [{ type: 'coach', loaded: true }]);
+    occupied.trays.get('circus')!.trainNumber = 17;
+    const beforeOccupied = occupied.players[0]!.revenue;
+    pump(occupied);
+    assert.equal(occupied.players[0]!.revenue, beforeOccupied + 1, 'a full Campaign Train earned nothing');
+
+    const empty = game();
+    circusAt(empty, 0, { row: -1, col: 0 }, [{ type: 'coach', loaded: false }]);
+    empty.trays.get('circus')!.trainNumber = 17;
+    const beforeEmpty = empty.players[0]!.revenue;
+    pump(empty);
+    assert.equal(empty.players[0]!.revenue, beforeEmpty, 'an empty Campaign Train was paid for its speech');
  });
 });

@@ -1291,7 +1404,7 @@ describe('an Extra starts where the player puts it (Gitea#4)', () => {
      const r = advance(s);
      assert.equal(r.needsInput, true, 'the phase must stop and ask');
      assert.equal(s.clock.pendingDecision?.train, tray.id);
-      assert.equal(s.clock.pendingDecision?.occupiedBy, 'ahead');
+      assert.equal((s.clock.pendingDecision as { occupiedBy: string } | null)?.occupiedBy, 'ahead');

      // HOLD keeps it in the yard.
      assert.ok(applyIntent(s, s.clock.superintendent, { type: 'mainline.clearance', allow: false }).ok);
@@ -956,7 +956,7 @@ describe('the Superintendent clearance ruling (§8.1)', () => {
    const s = game();
    s.clock.phase = 'mainline';
    s.clock.currentActor = null; // nobody's turn — yet the Superintendent must still rule
-    s.clock.pendingDecision = { train: 'tray0', occupiedBy: 'tray1' };
+    s.clock.pendingDecision = { kind: 'clearance', train: 'tray0', occupiedBy: 'tray1' };
    const r = applyIntent(s, 0, { type: 'mainline.clearance', allow: false });
    assert.ok(r.ok);
    assert.equal(s.clock.pendingDecision, null);
@@ -964,7 +964,7 @@ describe('the Superintendent clearance ruling (§8.1)', () => {

  it('is refused to a player who is not the Superintendent', () => {
    const s = game();
-    s.clock.pendingDecision = { train: 'tray0', occupiedBy: 'tray1' };
+    s.clock.pendingDecision = { kind: 'clearance', train: 'tray0', occupiedBy: 'tray1' };
    s.clock.superintendent = 1;
    assert.equal(check(s, 0, { type: 'mainline.clearance', allow: true }), 'NOT_SUPERINTENDENT');
  });
@@ -14,7 +14,7 @@ import { applyIntent, areaOf, check, hasDistrictEnhancement, isProtectedFromDera
 import { ENHANCEMENT_RULES, enhancementRule, trainProfile } from '../src/engine/content.ts';
 import { createGame } from '../src/engine/setup.ts';
 import type { GameConfig, GameState, GridCoord, TrackCard } from '../src/engine/state.ts';
-import { coordKey, subdivisions, turnOf } from '../src/engine/state.ts';
+import { coordKey, decisionActor, subdivisions, turnOf } from '../src/engine/state.ts';

 const config: GameConfig = {
  mode: 'solitaire',
@@ -287,17 +287,124 @@ describe('Interlocking and Yard Office relieve the Office', () => {
    assert.equal(s.players[0]!.revenue, -5);
  });

-  it('diverts a coachless train to the Yard Office', () => {
+  /**
+   * §11, THE YARD OFFICE (Gitea#5) — offered, not imposed, and only down a route that exists.
+   *
+   * Jesse: "you have to ask if non-coach trains wish to go in there, rather than to the office",
+   * "if the Yard Office is not accessible in one move, you should not get the option", and cars on
+   * the way in "result in a crash". All three were missing: the train was teleported onto the card.
+   */
+  const answer = (s: GameState, take: boolean) => {
+    const who = decisionActor(s);
+    assert.notEqual(who, null, 'nothing was pending, so there was nothing to answer');
+    const r = applyIntent(s, who!, { type: 'mainline.yardOffice', take });
+    assert.ok(r.ok, 'the district owner could not answer the Yard Office offer');
+    advance(s);
+  };
+
+  it('OFFERS the Yard Office to the district owner rather than diverting automatically', () => {
    const s = game();
    const card = straight();
    card.enhancements.push('yardOffice');
-    addCard(s, at(-1, 0), card);
+    addCard(s, at(0, 2), card);
    const id = inbound(s, [{ type: 'hopper', loaded: true }]);

    advance(s);
+    assert.equal(s.clock.pendingDecision?.kind, 'yardOffice', 'the phase did not stop to ask');
+    assert.equal(decisionActor(s), 0, 'the question went to the wrong player');
    const pos = s.trays.get(id)!.position;
-    assert.ok(pos.at === 'grid' && pos.coord.row === -1, 'arrived at the Yard Office');
-    assert.ok(!areaOf(s, 0).adOccupancy.includes(id), 'did not take an A/D track');
+    assert.ok(pos.at !== 'grid' || pos.coord.col !== 2, 'the train moved before anyone answered');
+  });
+
+  it('takes the Yard Office when the owner says yes', () => {
+    const s = game();
+    const card = straight();
+    card.enhancements.push('yardOffice');
+    addCard(s, at(0, 2), card);
+    const id = inbound(s, [{ type: 'hopper', loaded: true }]);
+
+    advance(s);
+    answer(s, true);
+    const pos = s.trays.get(id)!.position;
+    assert.ok(pos.at === 'grid' && pos.coord.col === 2, 'did not arrive at the Yard Office');
+    assert.ok(!areaOf(s, 0).adOccupancy.includes(id), 'took an A/D track anyway');
+    assert.equal(s.players[0]!.revenue, 0, 'a clear lead should not have collided');
+  });
+
+  it('goes to the Train Order Office when the owner says no', () => {
+    // "They can of course still choose to have the train go to the standard office."
+    const s = game();
+    const card = straight();
+    card.enhancements.push('yardOffice');
+    addCard(s, at(0, 2), card);
+    const id = inbound(s, [{ type: 'hopper', loaded: true }]);
+
+    advance(s);
+    answer(s, false);
+    assert.ok(areaOf(s, 0).adOccupancy.includes(id), 'declining did not put it on an A/D track');
+  });
+
+  it('does not offer what cannot be reached, and says why in the history', () => {
+    /**
+     * Jesse, 2026-08-29: "make sure this is logged in history — why can't move so user knows why
+     * they can't get to yard." A silent absence is indistinguishable from a broken feature, which
+     * is how the missing reachability check survived this long.
+     */
+    const s = game();
+    const card = straight();
+    card.enhancements.push('yardOffice');
+    // Far off the Running Track, with nothing laid between: no route in one move.
+    addCard(s, at(3, 4), card);
+    inbound(s, [{ type: 'hopper', loaded: true }]);
+
+    const events = advance(s).events;
+    assert.equal(s.clock.pendingDecision, null, 'offered a Yard Office it cannot reach');
+    const said = events.find(
+      (e) => e.type === 'trainDiverted' && e.reason.includes('could not be offered'),
+    );
+    assert.ok(said, `nothing in the history explains why:\n${JSON.stringify(events, null, 1)}`);
+    assert.match(
+      (said as { reason: string }).reason,
+      /one move/,
+      'the reason does not say it is out of reach in one move',
+    );
+  });
+
+  it('offers a fouled lead, and taking it collides', () => {
+    /**
+     * The third missing condition. "Just like other trains finding cars on the tracks you use to
+     * get into either result in a crash" — and Jesse's ruling keeps the OFFER: a route that exists
+     * is offered, and the consequence of taking it is the player's. §8.3 already reads cars in the
+     * path of an arriving train as a collision rather than a coupling.
+     */
+    const s = game();
+    const card = straight();
+    card.enhancements.push('yardOffice');
+    addCard(s, at(0, 2), card);
+    // A car standing on the lead between the Office and the yard.
+    areaOf(s, 0).grid.get(coordKey(at(0, 1)))!.standing = [{ type: 'boxcar', loaded: false }];
+    const id = inbound(s, [{ type: 'hopper', loaded: true }]);
+
+    advance(s);
+    assert.equal(s.clock.pendingDecision?.kind, 'yardOffice', 'a fouled lead was not offered at all');
+
+    answer(s, true);
+    assert.equal(s.players[0]!.revenue, -5, 'running through standing cars did not collide');
+    assert.ok(!s.trays.has(id), 'the train survived the collision');
+  });
+
+  it('declining a fouled lead is safe — the standard Office is unaffected', () => {
+    const s = game();
+    const card = straight();
+    card.enhancements.push('yardOffice');
+    addCard(s, at(0, 2), card);
+    areaOf(s, 0).grid.get(coordKey(at(0, 1)))!.standing = [{ type: 'boxcar', loaded: false }];
+    const id = inbound(s, [{ type: 'hopper', loaded: true }]);
+
+    advance(s);
+    answer(s, false);
+    assert.equal(s.players[0]!.revenue, 0, 'declining the Yard Office still cost a collision');
+    assert.ok(areaOf(s, 0).adOccupancy.includes(id), 'the train did not reach the Office');
  });

  it('does not divert a train carrying coaches', () => {
@@ -48,6 +48,15 @@ const KNOWN_UNREDUCED = [
  'dispatchBonusUsed',
  'expediteFault',
  'phaseBegan',
+  /**
+   * §Q, Red Flags (Gitea#19). The flag comes down inside the phase driver as it stops a train, so
+   * this is described rather than reduced like everything else here.
+   *
+   * ADDED DELIBERATELY, and it cost a bug first: the flag was originally taken down in a `reduce`
+   * case, which never fires for an event `advance.ts` emits — so it stayed up and held every train
+   * that came. That is precisely the failure this list exists to make visible.
+   */
+  'redFlagSpent',
  // Employee Rotation moves `seating` in the phase driver and then describes what it did, which is
  // the pattern every entry on this list follows.
  'seatsRotated',
@@ -28,7 +28,7 @@ import {
 import { createGame } from '../src/engine/setup.ts';
 import type { GameEvent } from '../src/engine/events.ts';
 import type { GameConfig, GameState, GridCoord, TrackCard } from '../src/engine/state.ts';
-import { coordKey, turnOf } from '../src/engine/state.ts';
+import { coordKey, decisionActor, turnOf } from '../src/engine/state.ts';
 import { snapshot } from '../src/sim/view.ts';

 const config: GameConfig = {
@@ -317,77 +317,177 @@ describe('Realignment converts one Mainline type to another', () => {
  });
 });

-describe('Red Flags protect a stopped train', () => {
-  /** A slow train `behind` closing on a stopped train `ahead`, both eastbound on node 1. */
-  function rearEnder(s: GameState) {
-    const node = pinned(s, 1, 'plains');
-    node.transits.push({ tray: 'ahead', stagesRemaining: 2, stagesTotal: 2, direction: 'east' });
-    s.trays.set('ahead', {
-      id: 'ahead', trainNumber: 4, trainIsExtra: false, engineAt: 0,
-      consist: [], direction: 'east', position: { at: 'mainline', index: 1 }, movesUsed: 0,
+describe('Red Flags hold a train out of your Limits (Gitea#19)', () => {
+  /**
+   * REPLACES the old rule outright (Jesse, 2026-08-29). Red Flags used to be played on a stopped
+   * train out on the Mainline and protected it from a rear-ender — measured at 4,212 offers and 4
+   * plays across 600 games, a mechanic nobody used. ABS Signals already does that job better.
+   *
+   * Now: "If played, asked FLAG EAST or FLAG WEST. That stops all trains from entering your limits
+   * from that direction (i.e. Flag East holds westbound trains)." Spent on the train it stops —
+   * one card, one train.
+   */
+
+  /** A westbound train one Stage from entering seat 0's district from the east. */
+  function approaching(s: GameState) {
+    const officeIndex = s.division.nodes.findIndex((n) => n.kind === 'office' && n.seat === 0);
+    const node = pinned(s, officeIndex + 1, 'plains');
+    node.transits.push({ tray: 'inbound', stagesRemaining: 1, stagesTotal: 1, direction: 'west' });
+    s.trays.set('inbound', {
+      id: 'inbound', trainNumber: 9, trainIsExtra: false, engineAt: 0,
+      consist: [{ type: 'hopper', loaded: true }], direction: 'west',
+      position: { at: 'mainline', index: officeIndex + 1 }, movesUsed: 0,
    });
-    s.trays.set('behind', {
-      id: 'behind', trainNumber: 2, trainIsExtra: false, engineAt: 0,
-      consist: [], direction: 'east', position: { at: 'divisionPoint', side: 'west' }, movesUsed: 0,
-    });
-    const dp = s.division.nodes[0];
-    if (dp?.kind === 'divisionPoint') dp.holding.push('behind');
    s.clock.phase = 'mainline';
    s.movedThisPhase = new Set();
-    return node;
+    return s.division.nodes[officeIndex] as Extract<typeof s.division.nodes[0], { kind: 'office' }>;
  }

-  it('holds the approaching train instead of letting it close', () => {
+  it('FLAG EAST holds a westbound train short of the Limits', () => {
    const s = game();
-    const node = rearEnder(s);
-    node.redFlagged = ['ahead'];
+    const office = approaching(s);
+    office.redFlag = 'east';

    advance(s);
-    assert.deepEqual(
-      s.trays.get('behind')!.position,
-      { at: 'divisionPoint', side: 'west' },
-      'the flagged train must not be approached',
-    );
+    const pos = s.trays.get('inbound')!.position;
+    assert.equal(pos.at, 'mainline', 'the flagged train came in anyway');
+    assert.ok(!areaOf(s, 0).adOccupancy.includes('inbound'), 'it reached an A/D track');
  });

-  it('comes in when the protected train rolls', () => {
+  it('is spent on the train it stops — one card, one train', () => {
    const s = game();
-    const node = rearEnder(s);
-    node.redFlagged = ['ahead'];
-    // Bring the protected train to the end of its crossing so it leaves the card.
-    node.transits[0]!.stagesRemaining = 1;
+    const office = approaching(s);
+    office.redFlag = 'east';

-    for (let i = 0; i < 12 && (node.redFlagged?.length ?? 0) > 0; i++) advance(s);
-    assert.deepEqual(node.redFlagged, [], 'flags come in once the train moves off');
+    advance(s);
+    assert.equal(office.redFlag, undefined, 'the flag stayed up after stopping a train');
  });

-  it('only protects a train out on the Mainline', () => {
+  it('lets the train in on the next Mainline Phase', () => {
+    // "Loses one Mainline Phase" — it buys a Stage to clear the lead, not permanent protection.
+    const s = game();
+    const office = approaching(s);
+    office.redFlag = 'east';
+    advance(s);
+
+    s.clock.phase = 'mainline';
+    s.movedThisPhase = new Set();
+    advance(s);
+    assert.ok(areaOf(s, 0).adOccupancy.includes('inbound'), 'the train never came in');
+  });
+
+  it('does not hold a train coming from the OTHER side', () => {
+    // "Flag East holds westbound trains" — an eastbound train arrives from the west.
+    const s = game();
+    const office = approaching(s);
+    office.redFlag = 'west';
+
+    advance(s);
+    assert.ok(areaOf(s, 0).adOccupancy.includes('inbound'), 'a west flag held a train from the east');
+    assert.equal(office.redFlag, 'west', 'the wrong-side flag was spent');
+  });
+
+  it('is played on a side, not on a train', () => {
    const s = game();
-    rearEnder(s);
    s.clock.phase = 'localOps';
    s.clock.currentActor = 0;
    const cardId = hand(s, 'maneuver', 'redFlags');

-    assert.equal(
-      check(s, 0, { type: 'maneuver.redFlags', cardId, trayId: 'behind' }),
-      'NO_PLACEMENT',
-      'a train sitting at a Division Point cannot be rear-ended',
-    );
-    assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, trayId: 'ahead' }), null);
+    assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, side: 'east' }), null);
+    assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, side: 'west' }), null);
  });

-  it('will not double-flag the same train', () => {
+  it('will not double-flag the same side', () => {
    const s = game();
-    const node = rearEnder(s);
    s.clock.phase = 'localOps';
    s.clock.currentActor = 0;
    const cardId = hand(s, 'maneuver', 'redFlags');
-    node.redFlagged = ['ahead'];
+    const officeIndex = s.division.nodes.findIndex((n) => n.kind === 'office' && n.seat === 0);
+    const office = s.division.nodes[officeIndex] as { redFlag?: string };
+    office.redFlag = 'east';

-    assert.equal(
-      check(s, 0, { type: 'maneuver.redFlags', cardId, trayId: 'ahead' }),
-      'OPTION_ALREADY_CHOSEN',
-    );
+    assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, side: 'east' }), 'ALREADY_FLAGGED');
+    assert.equal(check(s, 0, { type: 'maneuver.redFlags', cardId, side: 'west' }), null,
+      'the other side should still be free');
+  });
+});
+
+describe('Red Flags offered at the moment of danger (Gitea#19)', () => {
+  /**
+   * "In actual cases of danger… if there is a train or cars on the track and there will be a
+   * collision, then you break in with a dialog that says COLLISION RISK! FLAG AGAINST T2? This way,
+   * you can play the card normally or out of phase, but only if you need it."
+   *
+   * The engine establishes the danger, so the player is never asked to judge it — which is also why
+   * the bot can now use this card at all. It is offered ONLY to somebody holding one.
+   */
+  function dangerous(s: GameState, giveCard: boolean) {
+    const officeIndex = s.division.nodes.findIndex((n) => n.kind === 'office' && n.seat === 0);
+    const node = pinned(s, officeIndex + 1, 'plains');
+    node.transits.push({ tray: 'inbound', stagesRemaining: 1, stagesTotal: 1, direction: 'west' });
+    s.trays.set('inbound', {
+      id: 'inbound', trainNumber: 9, trainIsExtra: false, engineAt: 0,
+      consist: [{ type: 'hopper', loaded: true }], direction: 'west',
+      position: { at: 'mainline', index: officeIndex + 1 }, movesUsed: 0,
+    });
+    // A hopper fouling the Running Track: §8.3 makes this arrival a collision.
+    const area = areaOf(s, 0);
+    area.grid.get(coordKey(area.officeCoord))!.standing = [{ type: 'hopper', loaded: false }];
+    if (giveCard) hand(s, 'maneuver', 'redFlags');
+    s.clock.phase = 'mainline';
+    s.movedThisPhase = new Set();
+  }
+
+  it('breaks in to offer the flag when an arrival would collide', () => {
+    const s = game();
+    dangerous(s, true);
+    advance(s);
+    assert.equal(s.clock.pendingDecision?.kind, 'redFlag', 'no prompt before a certain collision');
+    assert.equal(decisionActor(s), 0, 'the prompt went to the wrong player');
+  });
+
+  it('flagging holds the train and costs the card', () => {
+    const s = game();
+    dangerous(s, true);
+    advance(s);
+    const before = (s.decks.hands.get(0) ?? []).length;
+
+    const r = applyIntent(s, 0, { type: 'mainline.redFlag', flag: true });
+    assert.ok(r.ok, 'the flag was refused');
+    advance(s);
+
+    assert.equal(s.players[0]!.revenue, 0, 'the collision happened anyway');
+    assert.equal(s.trays.get('inbound')!.position.at, 'mainline', 'the train came in regardless');
+    assert.equal((s.decks.hands.get(0) ?? []).length, before - 1, 'the card was not spent');
+  });
+
+  it('declining lets the collision happen', () => {
+    const s = game();
+    dangerous(s, true);
+    advance(s);
+
+    assert.ok(applyIntent(s, 0, { type: 'mainline.redFlag', flag: false }).ok);
+    advance(s);
+    assert.equal(s.players[0]!.revenue, -5, 'waving it through did not collide');
+  });
+
+  it('does not offer a flag to a player holding none', () => {
+    // A prompt with one button is not a choice, and it leaks that a collision is coming.
+    const s = game();
+    dangerous(s, false);
+    advance(s);
+    assert.equal(s.clock.pendingDecision, null, 'offered a flag to a player with no card');
+    assert.equal(s.players[0]!.revenue, -5, 'the collision should have happened');
+  });
+
+  it('stays quiet when the arrival is safe', () => {
+    const s = game();
+    dangerous(s, true);
+    // Clear the hazard: nothing fouling the Running Track, and room at the Office.
+    const area = areaOf(s, 0);
+    area.grid.get(coordKey(area.officeCoord))!.standing = [];
+    advance(s);
+    assert.equal(s.clock.pendingDecision, null, 'interrupted the phase for a safe arrival');
  });
 });

@@ -770,6 +870,100 @@ describe('a turnout may be laid on top of a card already down', () => {
  });
 });

+describe('extras that must run loaded, and one that must not (Gitea#13)', () => {
+  /**
+   * "I've redefined some of the extra trains that they have to run full boxcars — military trains,
+   * circus trains, etc. If not loaded, then empty, and if none available, run without."
+   *
+   * A PREFERENCE ORDER, so every test here is about what the DIVISION YARD still holds. The rule
+   * has nothing to say about a train once it is running; it decides which car may be taken next.
+   */
+  const madeUp = (trainNumber: number) => {
+    const s = game();
+    s.clock.phase = 'newTrain';
+    s.trays.set('t', {
+      id: 't', trainNumber, trainIsExtra: true, engineAt: 0,
+      consist: [], direction: 'east', position: { at: 'divisionPoint', side: 'west' }, movesUsed: 0,
+    });
+    return s;
+  };
+  const place = (carType: string, loaded: boolean) =>
+    ({ type: 'newTrain.placeCar', trayId: 't', carType, loaded }) as never;
+  /** Leaves the Division Yard holding exactly the cars described. */
+  const stockYard = (s: ReturnType<typeof madeUp>, cars: { type: string; loaded: boolean }[]) => {
+    s.yards.divisionYard.length = 0;
+    s.yards.divisionYard.push(...(cars as never[]));
+  };
+
+  it('refuses an empty while the yard can still supply a loaded one (X18 Circus)', () => {
+    const s = madeUp(18);
+    stockYard(s, [{ type: 'boxcar', loaded: true }, { type: 'boxcar', loaded: false }]);
+    assert.equal(check(s, 0, place('boxcar', false)), 'NO_SUITABLE_CAR',
+      'an empty was accepted while a loaded boxcar was still in the yard');
+    assert.equal(check(s, 0, place('boxcar', true)), null, 'the loaded boxcar was refused');
+  });
+
+  it('accepts an empty once the yard has no loaded car of that kind left', () => {
+    // "If not loaded, then empty." The rule releases as soon as the yard cannot supply.
+    const s = madeUp(18);
+    stockYard(s, [{ type: 'boxcar', loaded: false }]);
+    assert.equal(check(s, 0, place('boxcar', false)), null,
+      'an empty was refused when the yard held no loaded car at all');
+  });
+
+  it('does not let a loaded car of the WRONG category unlock the rule', () => {
+    // A loaded coach is no reason to refuse an empty boxcar: the preference is per category, since
+    // that is the slot the car is competing for.
+    const s = madeUp(18);
+    stockYard(s, [{ type: 'coach', loaded: true }, { type: 'boxcar', loaded: false }]);
+    assert.equal(check(s, 0, place('boxcar', false)), null,
+      'a loaded coach blocked an empty boxcar');
+  });
+
+  it('exempts the caboose, which is never empty in the supply', () => {
+    const s = madeUp(18);
+    stockYard(s, [{ type: 'caboose', loaded: true }, { type: 'boxcar', loaded: true }]);
+    assert.equal(check(s, 0, place('caboose', true)), null, 'the caboose its card calls for was refused');
+  });
+
+  it('applies to the Military train too', () => {
+    const s = madeUp(19);
+    stockYard(s, [{ type: 'coach', loaded: true }, { type: 'coach', loaded: false }]);
+    assert.equal(check(s, 0, place('coach', false)), 'NO_SUITABLE_CAR',
+      'the Military train took an empty coach over a loaded one');
+  });
+
+  it('leaves trains without the rule alone', () => {
+    // X21 Freight Extra has no loading rule: an empty is as good as a loaded one.
+    const s = madeUp(21);
+    stockYard(s, [{ type: 'boxcar', loaded: true }, { type: 'boxcar', loaded: false }]);
+    assert.equal(check(s, 0, place('boxcar', false)), null,
+      'a train with no loading rule was made to prefer loaded cars');
+  });
+
+  it('REGRESSION: X13 Appleseed is empties-only, and now the rules say so too', () => {
+    /**
+     * `ConsistSpec.emptiesOnly` was declared on the card, RENDERED to the player as "(empties only)"
+     * by `web/game.ts` and `sim/view.ts`, and enforced by NOTHING — `acceptsCar` never read it. So
+     * the Appleseed could be made up with loaded cars while its own card said it could not. Found
+     * while building Gitea#13, which is the same rule pointing the other way.
+     */
+    const s = madeUp(13);
+    stockYard(s, [{ type: 'boxcar', loaded: true }, { type: 'boxcar', loaded: false }]);
+    assert.equal(check(s, 0, place('boxcar', true)), 'NO_SUITABLE_CAR',
+      'the Appleseed took a loaded car despite printing "empties only"');
+    assert.equal(check(s, 0, place('boxcar', false)), null, 'the Appleseed refused an empty');
+  });
+
+  it('still lets the Appleseed take the caboose its consist calls for', () => {
+    // Every caboose in ROLLING_STOCK_SUPPLY is minted loaded, so an unexempted empties-only rule
+    // would bar the one car the card explicitly lists.
+    const s = madeUp(13);
+    stockYard(s, [{ type: 'caboose', loaded: true }]);
+    assert.equal(check(s, 0, place('caboose', true)), null, 'the empties-only rule ate the caboose');
+  });
+});
+
 describe("a train is made up to its card's consist (§8.2)", () => {
  it('takes a caboose when the card calls for one, and refuses a fourth freight car', () => {
    // Train 9 "Heavy Freight" is freight 3 + caboose 1. It was being made up with FOUR hoppers and
@@ -363,21 +363,29 @@ describe('end-of-game statistics', () => {
     * and so removing this line is what proves the bot has been fixed.
     */
    /**
-     * RED FLAGS JOINS IT (Gitea#3), and for the same reason — the rule is reachable and the bot will
-     * not take it.
+     * RED FLAGS JOINS IT, and the reason CHANGED with Gitea#19 — the exemption stays, but it no
+     * longer means what it used to.
     *
-     * MEASURED over 600 games: `maneuver.redFlags` is OFFERED 4,212 times, first in game 5 — so the
-     * rule is live and constantly available. The bot PLAYS it 4 times, first in game 252. At 200
-     * games this canary sees nothing and calls it unreachable, which is the opposite of the truth.
+     * IT USED TO MEAN "the bot will not take it": measured over 600 games under the old rule,
+     * `maneuver.redFlags` was OFFERED 4,212 times and PLAYED 4. The card protected a stopped train
+     * out on the Mainline, it was always available, and the bot simply declined it.
     *
-     * It got rarer for two compounding reasons, neither of them a broken rule: Gitea#14 took Red
-     * Flags from 5 copies to the sheet's 3, and Gitea#3 shortened most crossings to a single Stage,
-     * so the window in which a train is STANDING on a Mainline card — the only place the card may be
-     * played — is now usually one Stage wide.
+     * SINCE Gitea#19 the bot would take it every time — `worthFlagging` accepts the out-of-phase
+     * prompt unconditionally, because the engine only raises that prompt when an arrival is
+     * certainly about to collide, so there is nothing left for the bot to judge. It still never
+     * plays one. MEASURED after the redesign, 200 solitaire games: `redFlagsSet` fires ZERO times.
     *
-     * The bot's unwillingness is the thing worth fixing, and it is in TODO.md under Bot Performance.
-     * Exempted BY NAME so the other forty-odd checks stay live, and so deleting this line is what
-     * proves the bot has learned to use it.
+     * The reason is now arithmetic rather than judgement, and it is worth writing down because it
+     * says what would actually change it. The prompt needs two things to coincide — an arrival that
+     * would collide (0.14 collisions per game, so roughly one game in seven) AND the district's
+     * owner holding a Red Flags card at that moment, out of a three-card hand drawn from 121. The
+     * bot also never plants a flag speculatively, which is the other half of the card and the half
+     * a human would use to buy time for switching.
+     *
+     * So this canary is measuring deck luck, not reachability. `test/mainline-cards.test.ts`
+     * exercises both halves of the rule end to end on a hand-built board, which is where the
+     * behaviour is actually pinned. Removing this line still proves something worth proving — that
+     * the bot has learned to plant a flag on purpose rather than only when handed one.
     */
    const KNOWN_UNREACHABLE_BY_THE_BOT = ['event flyingSwitch', 'event redFlagsSet'];
    const found = anomalies(report.perGame);
@@ -1224,7 +1224,7 @@ describe('the page explains itself', () => {
      id: 'tray3', trainNumber: 7, trainIsExtra: false, engineAt: 0,
      consist: [], direction: 'east', position: { at: 'mainline', index: 1 }, movesUsed: 0,
    });
-    s.clock.pendingDecision = { train: 'tray2', occupiedBy: 'tray3' };
+    s.clock.pendingDecision = { kind: 'clearance', train: 'tray2', occupiedBy: 'tray3' };

    const allow = describeIntent(s, { type: 'mainline.clearance', allow: true });
    const hold = describeIntent(s, { type: 'mainline.clearance', allow: false });
@@ -2622,10 +2622,42 @@ describe('the static build', () => {
      assert.ok(!/https?:\/\//.test(html.replace(/<!--[\s\S]*?-->/g, '')), `${name} fetches something external`);
    }
    const splash = readFileSync(join(dist, 'index.html'), 'utf8');
-    assert.match(splash, /href="\.\/play\.html"/, 'the splash does not link to the game');
+    // `?solitaire` marks the door's intent explicitly (2026-08-29) so a browser that remembers a
+    // multiplayer session cannot swallow it — see `start()`'s own comment on `wantsSolitaire`.
+    assert.match(splash, /href="\.\/play\.html\?solitaire"/, 'the splash does not link to the game');
    assert.match(splash, /href="\.\/replays\.html"/, 'the splash does not link to the replays');
  });

+  it('cache-busts with a tag that varies per build even where there is no git', () => {
+    /**
+     * THE BUG THIS PINS COST TWO RELEASES. `buildStamp`'s no-git fallback was the literal `nogit`,
+     * and the `.s9pk` Dockerfile copies the working tree in WITHOUT `.git` — so every packaged
+     * release published `?v=nogit`, byte-identical to the one before it, and a returning player's
+     * browser refetched nothing. v0.7.5's setup screen and v0.7.6's fix to it both installed
+     * correctly on `phoenix.local` and neither reached the browser that asked for them.
+     *
+     * Asserted against the SCRIPT rather than a built page, because the property is about what the
+     * fallback does when `git rev-parse` fails, which a normal build here never exercises.
+     */
+    const src = readFileSync(join(root, 'scripts/build-web.ts'), 'utf8');
+    const fallback = /let git = ([^;]+);/.exec(src)?.[1] ?? '';
+    assert.ok(fallback !== '', 'the no-git fallback moved and this test cannot see it any more');
+    assert.doesNotMatch(fallback, /^'nogit'$|^"nogit"$/, 'the no-git fallback is a constant again');
+    assert.match(fallback, /Date\.now\(\)/, 'the no-git fallback carries nothing that varies per build');
+  });
+
+  it('lets a build-tagged URL be cached and nothing else', () => {
+    // The other half of the same bug: the pages carry the `?v=` tags but cannot be versioned in
+    // their own URL, so a cached `play.html` pins a player to the whole build it names. Only a
+    // request that actually carries `?v=` may be stored — an untagged image or the replay manifest
+    // has no way to announce a change.
+    const src = readFileSync(join(root, 'src/server/http.ts'), 'utf8');
+    assert.match(src, /'Cache-Control':\s*buildTagged\s*\?/, 'static responses no longer vary their caching');
+    assert.match(src, /immutable/, 'a tagged asset is not allowed to be cached at all');
+    assert.match(src, /serveStatic\(opts\.distDir, url\.pathname, res, url\.searchParams\.has\('v'\)\)/,
+      'the ?v= tag is not reaching serveStatic, so every response falls back to no-cache');
+  });
+
  it('opens the multiplayer door from the splash, straight into the lobby', () => {
    // This door sat `disabled` and labelled "Coming soon" from before the server existed until
    // v0.5.2 — Phases 2-4 built a working lobby and nothing ever linked to it, so a player with a
@@ -3815,18 +3847,20 @@ describe('the lobby and the dialog ask the same questions', () => {
    return readFileSync(join(dist, 'play.html'), 'utf8');
  };

-  it('carries every field of the shared block on both screens', () => {
+  it('carries every field of the shared block on all three screens', () => {
+    // `ss-` joined `lb-`/`ng-` 2026-08-29: the pre-game solitaire setup screen drives the identical
+    // block ("asking first is the only path"). Same drift guard, one more prefix.
    const html = page();
-    for (const prefix of ['lb-', 'ng-']) {
+    for (const prefix of ['lb-', 'ng-', 'ss-']) {
      for (const selector of fieldSelectors(prefix)) {
        assert.ok(html.includes(selector), `the ${prefix} block is missing ${selector}`);
      }
    }
  });

-  it('offers all five game types on both screens', () => {
+  it('offers all five game types on all three screens', () => {
    const html = page();
-    for (const prefix of ['lb-', 'ng-']) {
+    for (const prefix of ['lb-', 'ng-', 'ss-']) {
      for (const type of ['solitaire', 'coop', 'competitive', 'cutthroat', 'custom']) {
        assert.ok(
          html.includes(`name="${prefix}type" value="${type}"`),
@@ -3873,7 +3907,7 @@ describe('the New Game dialog', () => {
   * questions through `settings-form.ts`, which addresses its radio groups by NAME through the
   * DOCUMENT — so the stub keeps one set of groups and answers for both the document and the dialog.
   */
-  const load = async (search: string) => {
+  const load = async (search: string, stored: Record<string, string> = {}) => {
    execFileSync('node', ['scripts/build-web.ts'], { cwd: root, stdio: 'pipe' });

    const served = new Set(
@@ -3905,6 +3939,13 @@ describe('the New Game dialog', () => {
      'ng-hand': group(['threeRandom', 'sixRandom', 'threeTrackThreeOther'], 'sixRandom'),
      'ng-extra': group(['divisionPointsOnly', 'ownOffice', 'anyOffice'], 'anyOffice'),
      'ng-type': group(['solitaire', 'coop', 'competitive', 'cutthroat', 'custom'], 'coop'),
+      // The pre-game setup screen (Gitea, "asking first is the only path", 2026-08-29) drives the
+      // same shared block under the `ss-` prefix — one set here too, matching the markup's own
+      // `checked` defaults rather than the dialog's (Solitaire, not Co-op: there is no live game to
+      // reopen on, so the static default IS the Solitaire default).
+      'ss-hand': group(['threeRandom', 'sixRandom', 'threeTrackThreeOther'], 'sixRandom'),
+      'ss-extra': group(['divisionPointsOnly', 'ownOffice', 'anyOffice'], 'anyOffice'),
+      'ss-type': group(['solitaire', 'coop', 'competitive', 'cutthroat', 'custom'], 'solitaire'),
    };
    const matching = (sel: string): Radio[] => {
      const name = /name="([^"]+)"/.exec(sel)?.[1] ?? '';
@@ -3957,7 +3998,7 @@ describe('the New Game dialog', () => {
      origin: 'http://box.local',
      pathname: '/play.html',
    };
-    const store = new Map<string, string>();
+    const store = new Map<string, string>(Object.entries(stored));
    g['localStorage'] = {
      getItem: (k: string) => store.get(k) ?? null,
      setItem: (k: string, v: string) => void store.set(k, v),
@@ -4142,11 +4183,105 @@ describe('the New Game dialog', () => {
    assert.match(String(els.get('gametype')!['title']), /Days: 5/, 'the tooltip does not carry the victory conditions');
  });

+  it('asks before the first deal — a bare visit shows the setup screen, not a dealt game', async () => {
+    // Jesse, 2026-08-29: "let the user choose their options like the start of a multiplayer game";
+    // "asking first is the only path". A saved game, an explicit seed, or a URL a Deal already wrote
+    // (checked via `hand`, below) all skip this screen — nothing else does.
+    const { els } = await load('');
+    assert.equal(els.get('solitairesetup')!['hidden'], false, 'the setup screen stayed hidden');
+    assert.equal(els.get('gameui')!['hidden'], true, 'a game was dealt before anyone chose anything');
+  });
+
+  it('the solitaire door reaches the setup screen even when a solitaire game is saved', async () => {
+    /**
+     * REPORTED THREE TIMES BY JESSE (2026-08-29, twice, and 2026-08-30). v0.7.5 skipped the setup
+     * screen whenever `load()` found a save, reasoned as "a saved game is a game to resume" — but
+     * that means ANY browser that has ever played solitaire can never reach the setup screen from
+     * the door again, which is the whole feature. The private window that appeared to prove the
+     * caching fix had simply never played, so its `localStorage` was empty.
+     *
+     * The door is an explicit request to set a game up. A BARE reload still resumes (below).
+     */
+    const save = JSON.stringify({ seed: 12345, history: [] });
+    const { els } = await load('?solitaire', { 'station-master.save.v1': save });
+    assert.equal(els.get('solitairesetup')!['hidden'], false, 'a saved game swallowed the door');
+    assert.equal(els.get('gameui')!['hidden'], true, 'the saved game was resumed instead of asking');
+  });
+
+  it('offers a way back to the saved game, since dealing from the door destroys it', async () => {
+    // Deal calls `clearSave()`. The door is reached by clicking "Play solitaire", which nobody reads
+    // as "discard what I was playing" — so the save has to be one button away, and the cost of Deal
+    // has to be stated. Resuming navigates to the bare URL and lets `start()` do it.
+    const save = JSON.stringify({ seed: 12345, history: [] });
+    const { els, nav } = await load('?solitaire', { 'station-master.save.v1': save });
+    assert.equal(els.get('ss-resume')!['hidden'], false, 'no way back to the game in progress');
+    assert.equal(els.get('ss-saved-note')!['hidden'], false, "Deal's cost to the save is not stated");
+    (els.get('ss-resume')!['onclick'] as () => void)();
+    assert.equal(nav.search, '', 'resuming did not go back to the plain resume path');
+  });
+
+  it('hides the resume button when there is no saved game to go back to', async () => {
+    const { els } = await load('?solitaire');
+    assert.equal(els.get('ss-resume')!['hidden'], true, 'a resume button with nothing to resume');
+    assert.equal(els.get('ss-saved-note')!['hidden'], true, 'warns about replacing a save that does not exist');
+  });
+
+  it('a bare reload still resumes a saved solitaire game rather than asking again', async () => {
+    // The other half: `?solitaire` is what changed, not resuming itself. Reopening the tab must not
+    // put a question in front of somebody who just wants their game back (D11's zero-friction case).
+    const save = JSON.stringify({ seed: 12345, history: [] });
+    const { els } = await load('', { 'station-master.save.v1': save });
+    assert.equal(els.get('gameui')!['hidden'], false, 'a bare reload did not resume the saved game');
+    assert.equal(els.get('solitairesetup')!['hidden'], true, 'the setup screen interrupted a resume');
+  });
+
+  it('the solitaire door reaches solitaire even when this browser remembers a multiplayer game', async () => {
+    // Found 2026-08-29 verifying v0.7.5 on phoenix.local: a browser with ANY remembered multiplayer
+    // seat (`station-master.remote.v1`) could never reach solitaire's setup screen at all — a bare
+    // `./play.html` load and the splash's "Play solitaire" door were indistinguishable from a reload
+    // mid-multiplayer-game, and `start()` checked the remembered session first. The door now marks
+    // its intent with `?solitaire`, the same way `?lobby` already does for the door on the other side.
+    const remembered = JSON.stringify({
+      games: { g1: { token: 't1', gameId: 'g1', gameCode: 'FREIGHT-3230', seat: 0, stage: 'game' } },
+      last: 'g1',
+    });
+    const { els } = await load('?solitaire', { 'station-master.remote.v1': remembered });
+    assert.equal(els.get('solitairesetup')!['hidden'], false, 'the door lost to the remembered game');
+    assert.equal(els.get('gameui')!['hidden'], true, 'the remembered multiplayer game was resumed instead');
+  });
+
+  it('a bare reload still resumes a remembered multiplayer game, unlike the solitaire door', async () => {
+    // The other half of the fix above: `?solitaire` must be what changed, not remembered-session
+    // resume itself, which is the correct behaviour for an actual reload mid-game (D11/D14).
+    const remembered = JSON.stringify({
+      games: { g1: { token: 't1', gameId: 'g1', gameCode: 'FREIGHT-3230', seat: 0, stage: 'game' } },
+      last: 'g1',
+    });
+    const { els } = await load('', { 'station-master.remote.v1': remembered });
+    assert.equal(els.get('gameui')!['hidden'], false, 'a bare reload did not resume the remembered game');
+    assert.equal(els.get('solitairesetup')!['hidden'], true, 'the setup screen wrongly took priority');
+  });
+
+  it("the setup screen's own Deal does not bounce into a remembered multiplayer game", async () => {
+    // The same bug one level deeper: `commitNewGame` writes `?hand=...`, not `?solitaire=...`, so the
+    // very next load after pressing Deal has to be recognised as a solitaire navigation too — checked
+    // via `hand`, the same signal `start()` already uses to skip the setup screen a second time.
+    const remembered = JSON.stringify({
+      games: { g1: { token: 't1', gameId: 'g1', gameCode: 'FREIGHT-3230', seat: 0, stage: 'game' } },
+      last: 'g1',
+    });
+    const { els } = await load('?hand=sixRandom', { 'station-master.remote.v1': remembered });
+    assert.equal(els.get('gameui')!['hidden'], false, "the Deal button's own URL was not honoured");
+    assert.equal(els.get('solitairesetup')!['hidden'], true, 'the setup screen re-asked its own answer');
+  });
+
  it('deals six cards by default now, matching what the lobby calls Solitaire', async () => {
    // Jesse, 2026-08-23: every game type opens with six. `SOLO_CONFIG` — the ENGINE's fallback, which
-    // every sim measurement is taken against — deliberately did not move; this is the page's deal.
-    const { els } = await load('');
-    assert.match(String(els.get('houserules')!['textContent']), /6 cards/);
+    // every sim measurement is taken against — deliberately did not move; this is what the setup
+    // screen deals when nothing on it is touched, the same way the dialog always has.
+    const { els, nav } = await load('');
+    (els.get('ss-deal')!['onclick'] as () => void)();
+    assert.match(nav.search, /hand=sixRandom/, "the setup screen's own default was not six cards");
  });

  it('ignores a seed the browser cannot parse rather than refusing to deal', async () => {
Author	SHA1	Message	Date
Jesse.MarkowitzandClaude Sonnet 5	193800a649	v0.7.8 — the setup screen was unreachable for anyone who had ever played Third report of the same symptom, this time with the build confirmed current on screen, which ruled out v0.7.7's caching fault and left the real cause exposed. v0.7.5 skipped the setup screen whenever load() found a save, reasoned as "a saved game is a game to resume". A browser that has ever played solitaire always has one, so the door could never reach the screen again — and the fresh private window that appeared to vindicate v0.7.7 simply had no save. Two real faults were stacked; the caching one is fixed and had been masking this. The door outranks a saved game now: ?solitaire is a request to set one up, while a bare reload still resumes (pinned by its own test). Since Deal clears the save, the screen carries #ss-resume and says what Deal costs, so the door cannot destroy a game in progress. Also, per Jesse, riding along rather than taking its own release: the splash footer now names both ways to play. 868 tests pass, four new. The reproduction was a failing test written before the fix. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AdG46Ja2PEDBkpqiDazMoX	2026-08-29 23:47:44 -04:00
Jesse.MarkowitzandClaude Sonnet 5	af68aac78d	v0.7.7 — two releases shipped to a browser that never received them buildStamp()'s no-git fallback was the literal "nogit", and the .s9pk Dockerfile copies the tree in without .git — so git rev-parse fails on every packaged build. That string is also the cache-bust key every module URL carries, so v0.7.4, v0.7.5 and v0.7.6 all published ./web/main.js?v=nogit, byte-identical, and returning browsers refetched nothing. v0.7.5's setup screen and v0.7.6's door fix were both correct and neither arrived. The fallback is now the package version plus the build timestamp, always distinct. And serveStatic sent no Cache-Control at all, which is the other half — a cached play.html pins a player to the whole build it names. A request carrying ?v= is now immutable for a year; everything else is no-cache. ?v= rather than "not HTML" because build-web.ts tags the modules and nothing else. Neither half is sufficient alone. 864 tests pass, two new. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AdG46Ja2PEDBkpqiDazMoX	2026-08-29 22:23:09 -04:00
Jesse.MarkowitzandClaude Sonnet 5	b4f09f05cb	v0.7.6 — the solitaire door could not reach solitaire Found by Jesse playing v0.7.5 on phoenix.local: a browser that had ever held a multiplayer seat could not reach the new solitaire setup screen at all. start() checked a browser-remembered multiplayer session before ever looking at solitaire's own state, and a bare ./play.html load could not tell "clicked Play solitaire" apart from "reloaded mid multiplayer game" — the same problem ?lobby already solved for the door on the other side, never applied to this one. The door now links to ./play.html?solitaire, and start() treats that, an explicit ?seed=, or the setup screen's own ?hand= (written by every Deal) as proof this navigation means solitaire — checked ahead of the remembered-session lookup rather than only below it. 862 tests pass, three new. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AdG46Ja2PEDBkpqiDazMoX	2026-08-29 19:59:37 -04:00
Jesse.MarkowitzandClaude Sonnet 5	3e961496b0	v0.7.5 — solitaire asks before it deals, the same way multiplayer already does A new #solitairesetup screen in play.html asks the full shared game-options block — type, starting hand, Extra start, revenue, victory conditions, optional rules — before a genuinely fresh visit deals a game. A saved game, an explicit ?seed=, or a URL a Deal already wrote all skip past it, same as ?lobby already skips the front doors on an invite link. The in-game dialog, the lobby and this screen now share one wireGameTypeBlock()/commitNewGame() pair instead of the dialog carrying its own copy of the questions. 859 tests pass. Not yet played in a browser. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AdG46Ja2PEDBkpqiDazMoX	2026-08-29 19:14:37 -04:00
Jesse.MarkowitzandClaude Opus 5	a02d1fcffe	TODO: v0.7.4 is shipped and installed, and four features are unplayed Records the close of the 2026-08-29 session. #38, done: Gitea#13, #5 and #19 in v0.7.4, wrapper 085b88b as 0.7.4:0, installed on phoenix.local. Each issue carries a comment naming its commit and what was ruled, per the standing instruction in #30 — auto-closing alone leaves no record of which release answered a report. #37 extended: the wrapper went 0.7.3 then 0.7.4 the same day, and the sequence is written down rather than rediscovered next time. Both tags signed and pushed. Three things the session leaves behind, and the first is the one that matters: #39 — NOTHING FROM v0.7.4 HAS BEEN PLAYED BY A HUMAN, and nor has extended play from v0.7.3 (#35). Four features shipped without a table between them. Two of them are interruptions that stop the Mainline Phase and put a question in front of somebody mid-thought, which is exactly what only play reveals. #40 — a save from before v0.7.4 may not replay, and nobody has been told. Same shape as #32 for the playtest line. It fails safe and WHISTLE-4086 did survive on phoenix, so "may not" rather than "will not". #41 — the bot still cannot use the half of Red Flags a human would: planting a flag on purpose to buy a Stage for switching. It takes the danger prompt unconditionally and still plays zero in 200 games. Also de-duplicates #35, where an earlier edit left the superseded paragraph appended to the rewritten one. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAgJSmeV8zrMh55Mj85ESb	2026-08-29 08:43:43 -04:00
Jesse.MarkowitzandClaude Opus 5	19a6a47ab6	v0.7.4 — Red Flags hold a train out of your Limits (Gitea#19) "If played, asked FLAG EAST or FLAG WEST. That stops all trains from entering your limits from that direction (i.e. Flag East holds westbound trains). You can do this if you see a problem or wish to complete switching." REPLACES the old rule outright, per Jesse's call. Red Flags used to be played on a stopped train out on the Mainline and protected it from a rear-ender: offered 4,212 times and played 4 across 600 games, a mechanic nobody used, and ABS Signals already does that job better. The flag is now planted on one side of your own district and holds the next train arriving from that side. SPENT ON THE TRAIN IT STOPS. One card, one train, so there is no lifting action to build, nothing to forget, and a flag cannot quietly strangle the Division. The held train loses one Mainline Phase and comes in on the next — it buys a Stage to clear the lead, which is what "wish to complete switching" asks for. PLAYABLE OUT OF PHASE, which is the other half of the issue: when an arrival would certainly collide and the district's owner holds the card, the phase breaks in and asks. Offered ONLY to somebody holding one — a prompt with a single button is not a choice, and it would leak that a collision is coming. The danger is read from §8.3's own two triggers rather than restated, so the prompt cannot offer a flag against a collision that will not happen. Built on the decision union Gitea#5 introduced: this adds a `redFlag` case and nothing else structural. THE BOT STILL NEVER PLAYS IT, AND I MEASURED RATHER THAN ASSUMED. It now takes the out-of-phase prompt unconditionally — the engine has already established the danger, so there is nothing left to judge — and over 200 solitaire games `redFlagsSet` fires ZERO times. The prompt needs an arrival that would collide (0.14 per game, about one game in seven) to coincide with holding the card from a three-card hand out of 121. So the anomaly exemption in sim.test.ts stays, but its comment no longer claims the bot is unwilling: it is measuring deck luck. What is left to fix is the half of the card a human would use, planting a flag on purpose to buy switching time, and TODO.md now says that instead of the old finding. A BUG WORTH RECORDING, because the next interruption will meet it too: the flag was originally taken down in a `reduce` case, which never fires for an event advance.ts emits — the phase driver mutates state and then describes it. The flag stayed up and held every train that came. test/events.test.ts's unreduced-event registry is what makes that class of mistake visible, and `redFlagSpent` is on it deliberately now, with the reasoning. 858 tests pass. Closes #19 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAgJSmeV8zrMh55Mj85ESb	2026-08-29 07:12:36 -04:00
Jesse.MarkowitzandClaude Opus 5	228027637b	The Yard Office is offered, reachable, and can be run into (Gitea#5) "Trains that are only freight (cabooses ok, no coaches allowed) that arrive in a player's area who has the yard office card get an extra ability… the game will offer that player the option… They can of course still choose to have the train go to the standard office." It was implemented, in a stripped form missing all three conditions: a qualifying train was TELEPORTED onto the Yard Office card. Nobody was asked, no route was computed — so the card's own printed "that can reach the yard office in one move" was unenforced — and because nothing was walked, nothing was ever met on the way. All three now hold: - OFFERED to whoever sits in the district, interrupting the Mainline Phase on the turn the train arrives. Declining is an ordinary arrival onto an A/D track. - REACHABILITY is the engine's own move walk. `exploreMoves` already means what the card means — any distance without changing direction, finishing on Operational Rail (§2.4, §A.1) — so using it is what makes code and card agree. Reversing is a separate Move, so a yard that can only be reached by backing up is correctly out of reach. - CARS ON THE LEAD COLLIDE. The walk does not treat standing cars as obstacles; it COUPLES them, because that is what a switching move does. An arriving train is not switching, so what it would have coupled is what it is about to hit — the same reading §8.3 already applies to the Running Track. `destination.couples` is therefore the fouling signal, and it needed no new machinery. Per Jesse's ruling (2026-08-29) the two failures his issue names are kept apart: no route means no offer, with the history saying why ("make sure this is logged in history — why can't move so user knows why they can't get to yard"); a route that exists but is fouled IS offered, and taking it crashes. A silent absence is indistinguishable from a broken feature, which is how the missing check survived. THE SHARED REFACTOR THIS NEEDED. `pendingDecision` was one question asked of one player — §8.1's clearance, always the Superintendent — and `currentActor` hardcoded that. It is a discriminated union now, with `decisionActor` as the single place that maps a question to whoever must answer it, and `clearanceRuling` generalised to `decisionAnswer`. Six copies of `pendingDecision !== null ? superintendent : currentActor` across the engine, the sim, the web client and the tests collapse into `actingPlayer`; they had already stopped being right the moment a second kind of question existed. Gitea#19 needs the same machinery and now only has to add a case. A BUG THE FIRST CUT WALKED INTO, worth recording because it is a trap the next interruption will meet too: the offer must be put BEFORE the train is taken off its Mainline card. `needsClearance` unwinds the whole phase and the driver re-enters from the top, so asking after the `transits` filter cost the train its place on the card and the answer had nowhere to land. §8.1 gets this right by asking before it commits, and the Yard Office now does the same. The developer bot declines: the Yard Office frees an A/D track, but the lead may be fouled and the bot cannot read its own yard well enough to tell (`TODO.md`, Bot Performance). Declining is always safe and keeps the harness comparable with every measurement taken before this rule existed. 851 tests pass. Closes #5 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAgJSmeV8zrMh55Mj85ESb	2026-08-29 06:57:31 -04:00
Jesse.MarkowitzandClaude Opus 5	5e34c73b16	Extras that must run loaded, and a circus paid per district (Gitea#13) "I've redefined some of the extra trains that they have to run full boxcars — military trains, circus trains, etc. If not loaded, then empty, and if none available, run without." MAKE-UP. X17 Campaign, X18 Circus and X19 Military carry `mustRunLoaded`. It is a preference order rather than a flat requirement, so the rule is asked of the DIVISION YARD: an empty is refused only while the yard can still supply a loaded car this train would accept, and once it cannot, the empty is legal and the train may still depart short. Per category, since that is the slot the car competes for — a loaded coach is no reason to refuse an empty boxcar. SCORING, per Jesse's ruling (2026-08-29): "once per stop in an office area. In a multiplayer game, each player could score if the circus stops in their area." So `stopPointClaimed` (a boolean, once per game) becomes `stopPointSeats` (the seats already paid). A Circus touring three districts is paid three times; one parked in the same district all game is paid once. The other half of the ruling — "if the circus train gets recycled and played a second time as a second extra, then it could again score points later too" — needs no code: a train is made up onto a fresh tray every time, so a re-played Extra starts with an empty list. The point now requires the train to be FULLY LOADED, meaning every non-caboose car loaded. A coach counts as loaded when occupied, which is what makes this the right test for the Campaign Train: X17 carries one coach and no freight, so "fully loaded" is exactly "the candidate is aboard". X17 also GAINS the per-stop point — it had `stopThenExpedite` and no scoring rule at all, and Jesse's "credit for a circus or campaign train (one point per stop)" says it should score. TWO BUGS FIXED ALONG THE WAY: - `ConsistSpec.emptiesOnly` was declared on X13 Appleseed, RENDERED to the player as "(empties only)" by both web/game.ts and sim/view.ts, and enforced by nothing — `acceptsCar` never read it, so the Appleseed could be made up loaded while its own card said otherwise. It is the same rule as this issue pointing the other way, and it would have been perverse to add one and leave the other. - Setting up out on the Mainline paid a point to PLAYER 0 whoever was playing: `playerAtSeat` needs a seat, off the grid there is none, and the fallback was `0`. Scoping the rule to Office Areas is what the ruling says and removes the misattribution rather than patching it. Both loading rules exempt the caboose: every caboose in ROLLING_STOCK_SUPPLY is minted loaded, so an unexempted rule would bar the one car a consist lists by name. `trainNeedingCars` now asks the full question per car rather than the shape question. It shares its predicate with `check` precisely to avoid the stall its own comment describes, and the shape question stopped being the same question: an empties-only train facing a yard of loaded cars would have been told a car was available and then refused every one. The two published replays that stopped replaying under the new rules were retired and re-recorded with save-replay.ts, which verifies each candidate before writing it. That is what test/harness.test.ts is for and what its comment prescribes. 846 tests pass. Closes #13 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAgJSmeV8zrMh55Mj85ESb	2026-08-29 06:44:13 -04:00
Jesse.MarkowitzandClaude Opus 5	9ae8e9e09d	TODO: extended play verified against the running server on phoenix.local v0.7.3:0 is installed. #35 keeps its heading — nobody has played this at a table with humans — but the engine and server half is no longer merely compiled. Dealt a two-seat competitive game over the HTTP API with days: 1, played it to the end of its timetable, and watched it reach `awaitingExtension` with the official result frozen at config.days. Voted yes; the bot followed; the game returned to active with extraDays: 1 and the official outcome unchanged. Both test games were deleted afterwards. The carry-over claim was checked the same way rather than asserted. phoenix held five saves before the update, one resumable; after it the resume log is identical — same game, same 7 intents, same three refusals at the same move with the same code. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAgJSmeV8zrMh55Mj85ESb	2026-08-29 06:04:55 -04:00
Jesse.MarkowitzandClaude Opus 5	5865c3a6b7	TODO: the wrapper is on 0.7.3, and #13 is the harder reading after all Three updates from the 2026-08-29 session, none of them code. #37, new and already done: the StartOS wrapper is bumped to 0.7.3 (`74aea24` in station-master-startos). Recorded with what was verified — check, prettier, pack — and what was not: it is not installed on a box and has not been played, which is #35 and still open. #13 is settled, and as the reading that costs more. Jesse: "I want to be able to watch other players and bots make their moves. It's not fun to do my turn and have magic happen in the background and then have to figure out what others did." The entry had explicitly left open which of two things was meant — a log-legibility problem or a new view — and it is the second. It is Gitea#20 step 4 pointed at a player's screen rather than the common board, and `docs/plans/jitsi-common-board.md` already has the mechanism; what it does not have is the seated-player half, which that plan deliberately excludes. Jesse: "this relates to issue #20 and will require a lot more thinking." Marked to be designed with #20, not started alone. #7 is on hold: StartOS 0.4.0.2 is expected to improve action displays, and the diagnosis behind that item is that the action-result view collapses newlines — exactly the sort of thing a platform release fixes. Re-read the real output before designing around a limitation that may have been lifted. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAgJSmeV8zrMh55Mj85ESb	2026-08-29 05:07:36 -04:00