v0.8.0.14 — the coaches that never come back, and a district that ends at its own sign

Six reports from the Day 2-3 playtest of v0.8.0.13.

GAMES IN PROGRESS DO NOT SURVIVE THIS ONE. Modifiers are now bounded by the
Limits, which makes a once-legal move illegal, so a save holding one is refused
at that move: whistle-6945.day3.stage10 stops at intent 528 of 539. Jesse's call,
knowing it strands the game on the box. The file is untouched and v0.8.0.13
still finishes it.

The Sparrow running empty and Tom unable to unload his passengers are the same
shortage from opposite ends, and both are the rules working as printed. §9.2
boarding discards the emptied coach into the CLASSIFICATION yard, detraining
draws a fresh empty out of the DIVISION yard, and §2.2 sends Classification back
only when the Division Yard runs bare — so coaches move one way. Measured over
the save: sixteen in the Division Yard at setup, zero from Day 2 Stage 8 to the
end, fifteen piled in Classification, the Division Yard steady at 46-47 freight
cars with no prospect of going bare. Jesse's ruling is Gitea#2's: the shortage
stays and the game says so. A train made up short now reports what its card
wanted and why none is coming (`makeUpShort` — `trainNeedingCars` answered null
for "done" and for "cannot be done" alike, so the phase moved on in silence); the
yard panel warns while the condition lasts; the Depot's blocked panel was right
all along.

The modifier outside the Limits was working as designed and the design was
Jesse's own call, now reversed. What decided it is what the board shows — a card
beyond your own sign, in territory §8.1 and §10 reason about. The case that
motivated the exemption was checked on the reported move rather than argued away:
the Power Plant sat at (-1,3) against a sign at column 3 and two spots inside
were free, legal and adjacent.

Switching filled the history with coordinates — a line per move, plus one per
mandatory coupling. It is still LOGGED in full; what the panel draws is the line
saying somebody switched, the first move, work at an INDUSTRY (named, not a
coordinate), the Small Yard sort, and a closing summary. The suppressed lines are
still WRITTEN, marked `trace`: dropping them outright was the first attempt and
the step-queue suite caught it, because dwellForStep pays nothing for a step that
said nothing, so the board stopped replaying switching at all. The last move
rides in the closing line rather than being kept in place — nothing knows a move
was the last until the turn is over, by which time the line has been streamed to
every client and cannot be revised. Two things fell out of reading those lines:
every move ended with a tutorial sentence the opener already gives, and the move
count said "of 6" with the six hardcoded, which is wrong on a night Stage.

Make-up lines name their train — they all read "the train being made up", so
looking back for train 10 found nothing under that name — and "a empty tank" is
now "an empty tank". The Small Yard's options read as the train they would build
instead of `[1,2,3,0]`; the one Jesse wanted was the first of five and unreadable.
Two of those five were junk: bringing the last car to the end is the identity and
would have spent a Move, and a two-car reversal duplicated its only real option.
Both are filtered by the resulting order, not by the case that made them.

A Small Yard may now put cars AHEAD of the engine, which was Jesse's own open
question. Two sources disagreed and the design notes won: the v0.4.5 card text
says the sort puts the engine at the nose, implications.md says "any order,
including cars ahead of the engine". `engineAt` is optional on the intent, so
older saves replay to the same train. The menu did not multiply — the engine is a
separate short list against the consist as it stands, eight options for a
four-car train rather than twenty. §8.2 needed no new code: badlyMadeUp is
deliberately direction-free, so a PUSHING train is fit to run and only a
broken-backed one is held. The button warns by asking that predicate rather than
copying it, and immediately earned itself — every one of train 10's eight options
is refused, the one asked for at the table included, because that train carries a
caboose and each sort moves it off the rear. That is the right answer rather than
a gap: the train is already made up, so every offer would break it, and the labels
say which is which. A made-up order is always on the menu for a train that needs
one, because "bring car k to the tail" is enumerated for every car and the caboose
is one of them.

Labels read WEST TO EAST, with the engine drawn as the board's own ◀ / ▶ arrow.
"Front to back" is not a direction a table can read — which end is the front
depends on which way the train points — and board-svg has reversed east-facing
consists since v0.8.0, so the button now describes the same train as the picture.

The Freight Agent, Porter and Laborer groups now say what the role is for, where
the role is chosen. Tom reached for the Freight Agent to detrain passengers,
which is a Porter's action in the Cargo phase; both halves were working and
neither was visible.

TODO closes #107 (the nose sort) and gains #108 (the coach ratchet, with the
measurement, to revisit on a second game's data).

999 fast tests and 35 sim tests pass.

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

src/sim/view.ts

@@ -10,7 +10,7 @@
  * drift into two different pictures of the same board.
  */
 
-import { isExpedited, regionOfTransit } from '../engine/advance.ts';
+import { badlyMadeUp, isExpedited, regionOfTransit } from '../engine/advance.ts';
 import {
   areaAtSeat,
   areaOf,
@@ -1036,8 +1036,65 @@ export function describeIntent(s: GameState, i: Intent): string {
       const end = i.fromNose ? 'off the front' : 'off the back';
       return `set out ${carsLabel(cut)} ${end}`;
     }
-    case 'switch.sortConsist':
-      return `re-order consist [${i.order.join(',')}]`;
+    case 'switch.sortConsist': {
+      /**
+       * THE TRAIN IT WOULD MAKE, DRAWN THE WAY THE BOARD DRAWS IT.
+       *
+       * This read `re-order consist [1,2,3,0]` — the engine's own array indices offered to a person
+       * — and the option Jesse wanted was the first of five and unidentifiable (playtest,
+       * 2026-09-17). Naming the cars fixed that and left a second ambiguity he caught immediately:
+       * a list "front to back" means nothing at a table looking at a map, because which end is the
+       * front depends on which way the train is pointed.
+       *
+       * SO IT IS LAID OUT WEST TO EAST, exactly as `board-svg.ts` lays the crew strip: the consist
+       * is stored nose first, and a train facing EAST is reversed so its nose lands at the east end
+       * where it actually is. The engine is the same ◀ / ▶ arrow the board uses, seated where it
+       * will be, so "ahead of the engine" and "behind the engine" are read off the picture rather
+       * than asserted in words — and the button and the board cannot disagree.
+       */
+      const sorting = s.trays.get(i.trayId);
+      if (!sorting) return `re-order consist [${i.order.join(',')}]`;
+      const after = i.order.map((n) => sorting.consist[n]!).filter((c) => c !== undefined);
+      const engineAt = i.engineAt ?? 0;
+      const facing = railFacingOf(sorting);
+
+      const items = after.map((c) => carLabel(c));
+      items.splice(engineAt, 0, facing === 'w' ? '◀ ENGINE' : 'ENGINE ▶');
+      // West on the left, like the map and like the crew strip on the board.
+      const strip = (facing === 'e' ? [...items].reverse() : items).join(' · ');
+
+      /**
+       * WHAT IT WOULD MEAN, from §8.2's own predicate rather than a copy of it: a train with its
+       * whole consist ahead of the engine is a PUSHING train and fit to run, a buried engine is not,
+       * and a caboose has to ride at the end away from the engine. Numbered trains only — a local
+       * crew has no card and never departs, so a departure verdict on one is noise.
+       */
+      const unfit =
+        sorting.trainNumber === null
+          ? null
+          : badlyMadeUp({ ...sorting, consist: after, engineAt });
+      // `badlyMadeUp` leads with "not made up — ", which reads as a stutter in front of HELD. The
+      // reason after it is the part worth showing, so the prefix comes off.
+      const because = unfit?.replace(/^not made up — /, '') ?? '';
+      const verdict =
+        sorting.trainNumber === null
+          ? ''
+          : unfit === null
+            ? ' · MADE UP, ready to leave'
+            : ` · HELD at the Office: ${because}`;
+
+      // A sort that only moves the engine says which errand it is running, rather than reprinting a
+      // car order that has not changed.
+      const sameOrder = i.order.every((n, at) => n === at);
+      const lead = sameOrder
+        ? engineAt === 0
+          ? 'pull the engine back to the front'
+          : engineAt === after.length
+            ? 'put the whole consist ahead of the engine'
+            : `move the engine behind ${engineAt} car${engineAt === 1 ? '' : 's'}`
+        : 're-order';
+      return `${lead} — west to east: ${strip}${verdict}`;
+    }
     case 'freightAgent.stockOutbound': {
       /**
        * "stock a coach at (0, 0)" reads as putting a CAR on the track, and was reported as exactly