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

CHANGELOG.md

@@ -19,6 +19,80 @@ page as `v0.1.0 · <sha> · <date>`, so what is deployed can always be identifie
 
 ---
 
+## 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

README.md

@@ -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

TODO.md

@@ -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,7 +225,25 @@ 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,
+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. 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
@@ -235,6 +263,23 @@ 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.**~~ — 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.
+
+    **The v0.7.3 tag is made locally and signed, but not pushed** — agents cannot push to
+    `origin`. Until Jesse pushes it, the tag exists only here and in the wrapper's submodule clone;
+    the recorded pin is the commit SHA, which is already on `origin`, so the wrapper is not blocked
+    on it.
+
 ---
 
 ## Replay / Save Games
@@ -369,21 +414,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 +760,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 +851,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.

package.json

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

public/replays/seed-1917398.json

@@ -1389,6 +1389,11 @@
   },
   {
    "type": "loadUnload.end"
+  },
+  {
+   "type": "game.extend",
+   "player": 0,
+   "agree": false
   }
  ]
 }

src/engine/advance.ts

@@ -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.

src/engine/apply.ts

@@ -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;
 }

src/engine/content.ts

@@ -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.' } },

src/engine/events.ts

@@ -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'];

src/engine/intents.ts

@@ -120,10 +120,24 @@ export type Intent =
    */
   | { type: 'mainline.modify'; cardId: CardId; node: number }
   /**
-   * Red Flags — protect a stopped train. The flagged train cannot be hit; an approaching train is
-   * held instead of colliding.
+   * §Q, RED FLAGS (Gitea#19) — plant a flag on one side of your own district.
+   *
+   * "If played, asked FLAG EAST or FLAG WEST. That stops all trains from entering your limits from
+   * that direction (i.e. Flag East holds westbound trains). You can do this if you see a problem or
+   * wish to complete switching."
+   *
+   * `side` names the side of the district the flag goes on, so a train arriving from that side is
+   * held. It REPLACES the old rule, which was played on a stopped train out on the Mainline and
+   * protected it from a rear-ender: measured at 4,212 offers and 4 plays across 600 games, a
+   * mechanic nobody used. ABS Signals already protects a train standing on a Mainline card.
    */
-  | { type: 'maneuver.redFlags'; cardId: CardId; trayId: TrayId }
+  | { type: 'maneuver.redFlags'; cardId: CardId; side: Direction }
+  /**
+   * The same card, played OUT OF PHASE at the moment of danger (Gitea#19) — "COLLISION RISK! FLAG
+   * AGAINST T2?". Answers a pending `redFlag` decision; `flag: false` declines and lets the
+   * collision happen. The side is not asked for: the train is already coming from one.
+   */
+  | { type: 'mainline.redFlag'; flag: boolean; cardId?: CardId }
   /**
    * Flying Switch — cut cars off behind the engine and roll them into an adjacent industry, without
    * the engine entering it.
@@ -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 };
 

src/engine/legal.ts

@@ -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' });

src/engine/setup.ts

@@ -424,7 +424,7 @@ export function createGame(opts: SetupOptions): GameState {
       phase: 'localOps',
       currentActor: superintendent,
       pendingDecision: null,
-      clearanceRuling: null,
+      decisionAnswer: null,
       superintendent,
       actorOffset: 0,
     },

src/engine/state.ts

@@ -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.

src/sim/bot.ts

@@ -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);

src/sim/narrate.ts

@@ -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` };
   }
 }
 

src/sim/replay.ts

@@ -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;

src/sim/view.ts

@@ -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':

src/web/game.ts

@@ -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.
        *

src/web/replays.ts

@@ -26,6 +26,7 @@ import { createGame } from '../engine/setup.ts';
 import { snapshot } from '../sim/view.ts';
 import type { Intent } from '../engine/intents.ts';
 import { SOLO_CONFIG } from './game.ts';
+import { actingPlayer } from '../engine/state.ts';
 
 type Save = { seed: number; history: Intent[] };
 type Entry = { file: string; title: string; note?: string; seed?: number };
@@ -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) {

test/advance.test.ts

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

test/apply.test.ts

@@ -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');
   });

test/enhancements.test.ts

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

test/events.test.ts

@@ -48,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',

test/mainline-cards.test.ts

@@ -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

test/sim.test.ts

@@ -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);

test/web.test.ts

@@ -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 });