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

test/advance.test.ts

@@ -7,7 +7,7 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 
-import { advance, pump } from '../src/engine/advance.ts';
+import { advance, badlyMadeUp, pump } from '../src/engine/advance.ts';
 import { applyIntent, areaOf, check, isBeingMadeUp } from '../src/engine/apply.ts';
 import { EXPEDITE_FAULT_PENALTY, HAND_LIMIT, MAX_CONSIST, STAGES_PER_DAY, TOTAL_ROLLING_STOCK } from '../src/engine/content.ts';
 import { legalActions } from '../src/engine/legal.ts';
@@ -1582,3 +1582,121 @@ describe('§8.1 counts only trains AHEAD of the one departing (Gitea#26)', () =>
     );
   });
 });
+
+// ---------------------------------------------------------------------------
+
+/**
+ * §7's make-up round is silent about what it could NOT do, and that silence was reported from a
+ * table (2026-09-16): "train 5, the sparrow, has no coaches, which seems strange."
+ *
+ * The Sparrow's card calls for three coaches and nothing else. Every coach in that game had ended
+ * up in the Classification Yard, which §2.2 returns only when the Division Yard runs bare — and the
+ * Division Yard still held 46 freight cars, so it never would. `trainNeedingCars` therefore answered
+ * "nothing to ask for" exactly as it answers "everything is full", the phase moved on, and the train
+ * ran the length of the Division empty with no line anywhere saying why.
+ */
+describe('a train the Division Yard cannot supply says so', () => {
+  /** Puts one train in the yard-filling state, with a yard holding only `types`. */
+  const readyToFill = (yard: { type: string; loaded: boolean }[]) => {
+    const s = game();
+    // Stage 1's train is 1/2, the Crack Limited — coaches only, which is the shape that goes short.
+    s.timetable = Array(STAGES_PER_DAY).fill(null);
+    s.timetable[0] = 1;
+    s.yards.divisionYard = yard as never;
+    s.yards.classificationYard = [{ type: 'coach', loaded: false }] as never;
+    s.clock.stage = 1;
+    s.clock.phase = 'newTrain';
+    return s;
+  };
+
+  it('reports the shortfall, with the cars, the waiting pile and why it will not come back', () => {
+    // A yard of pure freight: nothing the Crack Limited will take.
+    const s = readyToFill([
+      { type: 'boxcar', loaded: true },
+      { type: 'hopper', loaded: false },
+    ]);
+    const { events } = advance(s);
+    const short = events.find((e) => e.type === 'makeUpShort');
+    assert.ok(short, 'a train that could be given nothing reported nothing');
+    assert.equal(short.type === 'makeUpShort' && short.placed, 0);
+    assert.ok(
+      short.type === 'makeUpShort' && short.missing.includes('coach'),
+      'the report did not name the category the yard could not supply',
+    );
+    assert.ok(
+      short.type === 'makeUpShort' && short.waiting === 1,
+      'the report did not count the cars waiting in the Classification Yard',
+    );
+    assert.ok(
+      short.type === 'makeUpShort' && short.divisionYardHolds === 2,
+      'the report did not say how far the Division Yard is from bare, which is what §2.2 turns on',
+    );
+  });
+
+  it('says nothing when the round can still be asked for a car', () => {
+    // The same train, with coaches available: the phase must STOP for them rather than report.
+    const s = readyToFill([
+      { type: 'coach', loaded: true },
+      { type: 'coach', loaded: true },
+    ]);
+    const { events, needsInput } = advance(s);
+    assert.equal(needsInput, true, 'the phase should be waiting for a car to be placed');
+    assert.equal(
+      events.some((e) => e.type === 'makeUpShort'),
+      false,
+      'a train that can still be filled was reported short',
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+
+/**
+ * §8.2 and the Small Yard's nose sort, together — Jesse's ruling of 2026-09-17 was "any train may
+ * sort to the nose, and it is held if it cannot depart".
+ *
+ * The holding half already existed and needed no new code, which is worth pinning precisely because
+ * it is easy to assume otherwise: `badlyMadeUp` is deliberately DIRECTION-FREE, so a train with its
+ * whole consist ahead of the engine is a PUSHING train and fit to run. What §8.2 refuses is a
+ * broken-backed train — the engine buried among its own cars — and a caboose anywhere but the end
+ * away from the engine.
+ */
+describe('a train sorted to the nose is judged by §8.2, not by where the engine is', () => {
+  const tray = (consist: { type: string; loaded: boolean }[], engineAt: number) =>
+    ({ consist, engineAt }) as unknown as CrewTray;
+
+  it('lets a pushing train run — the whole consist ahead of the engine is made up', () => {
+    const pushing = tray([{ type: 'caboose', loaded: true }, { type: 'boxcar', loaded: true }], 2);
+    assert.equal(
+      badlyMadeUp(pushing),
+      null,
+      'a pushing train was refused; §8.2 is enforced direction-free on purpose',
+    );
+  });
+
+  it('holds a train whose engine is buried among its own cars', () => {
+    const buried = tray(
+      [{ type: 'boxcar', loaded: true }, { type: 'hopper', loaded: true }, { type: 'caboose', loaded: true }],
+      1,
+    );
+    const why = badlyMadeUp(buried);
+    assert.ok(why !== null, 'a broken-backed train was allowed to leave the Office');
+    assert.match(why, /engine is buried/, `the hold did not say why: ${why}`);
+  });
+
+  it('holds a train whose caboose is not at the end away from the engine', () => {
+    // Exactly the arrangement asked for at the table: caboose second from the rear.
+    const wanted = tray(
+      [
+        { type: 'hopper', loaded: true },
+        { type: 'tank', loaded: false },
+        { type: 'caboose', loaded: true },
+        { type: 'boxcar', loaded: true },
+      ],
+      0,
+    );
+    const why = badlyMadeUp(wanted);
+    assert.ok(why !== null, 'a train with its caboose mid-consist was allowed to leave');
+    assert.match(why, /caboose must be at the rear/, `the hold did not say why: ${why}`);
+  });
+});