v0.6.1 — five of six playtest bugs: one button per train, and a load that has to go somewhere

Gameplay testing on 0.4.9d returned six reports. Five are fixed; the sixth could not be
reproduced and is written up in TODO.md with the two questions that would pin it down.

TWO TRAINS AT ONE PLATFORM ANSWERED TO ONE BUTTON. `porter.board` and `porter.detrain`
carried no tray, so there was one button per platform however many trains stood at it and
the reducer filled the first empty coach on the A/D tracks. `check` and the reducer were not
even asking the same question: `check` skipped a train whose card refuses passenger work and
the reducer did not. Both intents now carry an optional `trayId`, one function resolves the
train and the coach for check/execute/reduce alike, `legal.ts` offers one candidate per train,
and the label names it.

A LOAD COULD BE MADE AND BROKEN WITHOUT GOING ANYWHERE. A Freight House could unload the
boxcar it had just loaded; a platform could detrain the passengers it had just boarded. Full
Revenue at both ends for a movement that never happened. Jesse's rule: a load made anywhere in
an Office Area may not be broken anywhere in that Office Area, ever — it has to be carried to
another district. The load carries the seat that made it (`RollingStock.origin`), stripped by
`pooled` at every yard push. Measured at -0.60 +/- 0.10 Revenue a game (t = -6.1) over 400
paired deals: 78 worse, 3 better, 319 unchanged — free Revenue coming off the board, not a nerf.

THE GROCER'S WAREHOUSE SHIPPED AND THE REFINERY RECEIVED. Both were `flow: 'both'` on the
reading that "Freight House" was a collective term for exactly those two, and therefore what
§9.3 described. The engine has dealt a Freight House CARD since before v0.4.9, so §9.3 names
it and the argument goes. The card set agrees: all three Refinery modifiers grant +1 outbound.
Refinery outbound-only, Grocer's inbound-only, Freight House the one two-way industry — which
leaves exactly the one same-district pairing the rule above refuses.

NOT REPRODUCED: cars left behind when backing up over them. Five layouts tried, including cars
spotted at an industry; every one couples the lot. Three are pinned in `apply.test.ts`. One way
to create such cars was closed anyway — `flyingSwitch` wrote its cut past `carsOn`.

Both published replays that had gone dead were re-recorded; a rules change retires a save, and
`harness.test.ts` is what catches it.

The same change ships as v0.4.9e on the 0.4.9 line, branched from the v0.4.9d commit — the engine
files these fixes touch are identical across the two lines, so the patch applied cleanly both ways.

Also carries the two "Queued 2026-08-22, from playing on StartOS" TODO items that were staged
before this work started (Games in Progress readability, and getting back into a game after
losing a browser). They are notes, and items 9-12 below them are numbered against them.

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

test/apply.test.ts

@@ -1286,9 +1286,11 @@ describe("a Modifier grants only what its host's flow can use", () => {
      * and saying so is what the panel is for. Losing it FOREVER was the bug: the upgrade applied
      * only the difference between two tiers and knew nothing about what had been discarded.
      *
-     * This used to be written against an Ice House on a Grocer's Warehouse. That case no longer
-     * suppresses anything, because the Grocer's is a both-direction facility — which was the other
-     * half of the same report.
+     * This used to be written against an Ice House on a Grocer's Warehouse, which suppresses again
+     * now that the Grocer's is inbound-only (v0.4.9e). The Office was chosen instead because the
+     * suppression there is TEMPORARY — an upgrade can lift it — and losing the grant forever across
+     * that upgrade was the bug. A Grocer's never ships, so its Ice House is suppressed permanently
+     * and tests nothing about the upgrade path.
      */
     const s = game();
     const area = areaOf(s, 0);
@@ -1897,3 +1899,268 @@ describe('the switching job a player actually does: put a car in a siding, take
     );
   });
 });
+
+// ---------------------------------------------------------------------------
+
+/**
+ * The v0.4.9d playtest, three reports with two causes.
+ *
+ * "Freight House: boxcars loaded cannot be immediately unloaded", "passenger stations: passengers
+ * just boarded cannot be immediately unloaded" — one rule, `RollingStock.origin`. And "operating two
+ * trains in a station: the select button does not work, regardless of which you pick it is always
+ * one train, not the other" — the porter intents carrying no tray.
+ */
+describe('a load may not be broken in the district that made it (v0.4.9e)', () => {
+  const office = (s: GameState) => areaOf(s, 0).grid.get(coordKey(areaOf(s, 0).officeCoord))!.facility!;
+
+  /** An Office that can work passengers, with someone waiting and Porters to hand. */
+  function platform(s: GameState): void {
+    const f = office(s);
+    f.allows = { outbound: true, inbound: true };
+    f.porters = 4;
+    f.capacity = { outbound: 2, inbound: 2 };
+    f.outboundBox = [{ type: 'coach', loaded: true }];
+    s.yards.divisionYard.push({ type: 'coach', loaded: false });
+    s.clock.phase = 'loadUnload';
+    s.clock.currentActor = 0;
+  }
+
+  /** A tray standing on an A/D track at the Office. */
+  function atOffice(s: GameState, consist: CrewTray['consist']): string {
+    const id = s.freeTrays.pop()!;
+    s.trays.set(id, {
+      id, trainNumber: null, trainIsExtra: false, engineAt: 0, consist,
+      direction: 'east', position: { at: 'grid', seat: 0, coord: areaOf(s, 0).officeCoord }, movesUsed: 0,
+    });
+    areaOf(s, 0).adOccupancy.push(id);
+    return id;
+  }
+
+  /** A Freight House with a load staged, an empty spotted, and Laborers enough to finish. */
+  function freightHouse(s: GameState, coord: GridCoord): void {
+    areaOf(s, 0).grid.set(coordKey(coord), {
+      geometry: { kind: 'facility', facility: 'freightHouse' },
+      baseOperationalRail: true,
+      standing: [],
+      standingWest: 0,
+      facility: {
+        kind: 'freight', subtype: 'freightHouse',
+        allows: { outbound: true, inbound: true },
+        outboundBox: [{ type: 'boxcar', loaded: true }],
+        inboundBox: [],
+        capacity: { outbound: 1, inbound: 1 },
+        menAtWork: [null, null, null],
+        industryTrack: { cars: [{ type: 'boxcar', loaded: false }] },
+        laborers: 9, porters: 0,
+        usedThisStage: { laborers: 0, porters: 0 },
+      },
+      modifiers: [], enhancements: [],
+    } as TrackCard);
+    s.yards.divisionYard.push({ type: 'boxcar', loaded: false }, { type: 'boxcar', loaded: false });
+    s.clock.phase = 'loadUnload';
+    s.clock.currentActor = 0;
+  }
+
+  /** Walk a staged load all the way onto the spotted car. */
+  function finishLoad(s: GameState, coord: GridCoord): void {
+    applyIntent(s, 0, { type: 'laborer.startLoad', at: coord });
+    for (const box of [0, 1, 2]) applyIntent(s, 0, { type: 'laborer.advanceLoad', at: coord, box });
+  }
+
+  it('refuses to unload the boxcar the Freight House just loaded', () => {
+    const s = game();
+    const coord = at(-1, 0);
+    freightHouse(s, coord);
+    finishLoad(s, coord);
+    const f = areaOf(s, 0).grid.get(coordKey(coord))!.facility!;
+    assert.deepEqual(f.industryTrack.cars.map((c) => c.loaded), [true], 'the load never reached the car');
+    assert.equal(f.industryTrack.cars[0]!.origin, 0, 'the load is not stamped with the district that made it');
+    assert.equal(
+      check(s, 0, { type: 'laborer.beginUnload', at: coord, carIndex: 0 }),
+      'LOADED_IN_THIS_DISTRICT',
+    );
+    // And it is not merely absent from the menu by accident — the menu agrees with `check`.
+    assert.ok(
+      !legalActions(s, 0).some((i) => i.type === 'laborer.beginUnload'),
+      'the unload was still offered',
+    );
+  });
+
+  it('unloads a load that came from somewhere else', () => {
+    // The mirror, and the reason the rule is a stamp rather than a per-facility flag: a car made up
+    // at a Division Point out of the common supply carries no origin, and is exactly the inbound
+    // traffic a district lives on.
+    const s = game();
+    const coord = at(-1, 0);
+    freightHouse(s, coord);
+    const f = areaOf(s, 0).grid.get(coordKey(coord))!.facility!;
+    f.industryTrack.cars = [{ type: 'boxcar', loaded: true }];
+    assert.equal(check(s, 0, { type: 'laborer.beginUnload', at: coord, carIndex: 0 }), null);
+  });
+
+  it('refuses to detrain the passengers this Office just put aboard', () => {
+    const s = game();
+    platform(s);
+    const tray = atOffice(s, [{ type: 'coach', loaded: false }]);
+    assert.ok(applyIntent(s, 0, { type: 'porter.board', at: areaOf(s, 0).officeCoord, trayId: tray }).ok);
+    const coach = s.trays.get(tray)!.consist[0]!;
+    assert.equal(coach.loaded, true, 'nobody boarded');
+    assert.equal(coach.origin, 0, 'the coach is not stamped with the Office that filled it');
+    assert.equal(
+      check(s, 0, { type: 'porter.detrain', at: areaOf(s, 0).officeCoord, trayId: tray }),
+      'LOADED_IN_THIS_DISTRICT',
+    );
+  });
+
+  it('detrains passengers who boarded somewhere else', () => {
+    const s = game();
+    platform(s);
+    const tray = atOffice(s, [{ type: 'coach', loaded: true }]);
+    assert.equal(check(s, 0, { type: 'porter.detrain', at: areaOf(s, 0).officeCoord, trayId: tray }), null);
+  });
+
+  it('takes the origin stamp off a coach that reaches the red box', () => {
+    // The stamp belongs to the LOAD. A coach going into the inbound box has finished its journey and
+    // heads back to a yard from there; carrying the stamp on would poison the common supply.
+    const s = game();
+    platform(s);
+    const tray = atOffice(s, [{ type: 'coach', loaded: true, origin: 1 }]);
+    assert.ok(applyIntent(s, 0, { type: 'porter.detrain', at: areaOf(s, 0).officeCoord, trayId: tray }).ok);
+    assert.equal(office(s).inboundBox[0]!.origin, undefined, 'the stamp survived the red box');
+  });
+});
+
+describe('two trains in one station are told apart (v0.4.9e)', () => {
+  function twoAtOffice(s: GameState): [string, string] {
+    const area = areaOf(s, 0);
+    const f = area.grid.get(coordKey(area.officeCoord))!.facility!;
+    f.allows = { outbound: true, inbound: true };
+    f.porters = 4;
+    f.capacity = { outbound: 2, inbound: 2 };
+    f.outboundBox = [{ type: 'coach', loaded: true }, { type: 'coach', loaded: true }];
+    s.clock.phase = 'loadUnload';
+    s.clock.currentActor = 0;
+    const ids: string[] = [];
+    for (let n = 0; n < 2; n++) {
+      const id = s.freeTrays.pop()!;
+      s.trays.set(id, {
+        id, trainNumber: null, trainIsExtra: false, engineAt: 0,
+        consist: [{ type: 'coach', loaded: false }],
+        direction: 'east', position: { at: 'grid', seat: 0, coord: area.officeCoord }, movesUsed: 0,
+      });
+      area.adOccupancy.push(id);
+      ids.push(id);
+    }
+    return [ids[0]!, ids[1]!];
+  }
+
+  it('offers boarding on each train, not once for the platform', () => {
+    // REPORTED: "operating two trains in a station, the select button does not work — regardless of
+    // which you pick, it is always one train, not the other." There was one button, because the
+    // intent carried no train at all.
+    const s = game();
+    const [a, b] = twoAtOffice(s);
+    const boards = legalActions(s, 0).filter((i) => i.type === 'porter.board');
+    assert.deepEqual(
+      boards.map((i) => (i as { trayId?: string }).trayId).sort(),
+      [a, b].sort(),
+      'both trains at the platform must be offered',
+    );
+  });
+
+  it('boards the train the player named, not the first on the A/D tracks', () => {
+    const s = game();
+    const [a, b] = twoAtOffice(s);
+    assert.ok(applyIntent(s, 0, { type: 'porter.board', at: areaOf(s, 0).officeCoord, trayId: b }).ok);
+    assert.equal(s.trays.get(b)!.consist[0]!.loaded, true, 'the named train did not get the passengers');
+    assert.equal(s.trays.get(a)!.consist[0]!.loaded, false, 'the other train was filled instead');
+  });
+
+  it('still works for an intent that names no train, so old saves replay', () => {
+    // `trayId` is optional for the same reason `switch.move`'s `via` is: intents are the canonical
+    // record every save and every undo replays against.
+    const s = game();
+    const [a] = twoAtOffice(s);
+    assert.ok(applyIntent(s, 0, { type: 'porter.board', at: areaOf(s, 0).officeCoord }).ok);
+    assert.equal(s.trays.get(a)!.consist[0]!.loaded, true, 'the first eligible train should have taken them');
+  });
+});
+
+/**
+ * Reported from the v0.4.9d playtest and NOT reproduced: "when I back up to collect standing cars
+ * and, further down the tracks, the caboose, I get the caboose but the cars remain. I can later
+ * drive right through them."
+ *
+ * Coupling is mandatory (§A.4) and the walk accumulates what it meets card by card, so cars the
+ * engine can see always couple — which means cars a train can drive through are cars the engine does
+ * not think are there. Nothing found: `carsOn` is the single answer to "what is standing here" and
+ * the movement walk, the sweep and every renderer all ask it. These pin the shapes that were tried,
+ * so if the case is found later it is somewhere none of them cover.
+ */
+describe('backing up over a cut to something beyond it takes both (v0.4.9d report)', () => {
+  const boxcar = () => ({ type: 'boxcar' as const, loaded: false });
+  const caboose = () => ({ type: 'caboose' as const, loaded: false });
+
+  /** A Freight House card, with cars spotted on its industry track. */
+  function industry(cars: TrackCard['standing']): TrackCard {
+    return {
+      geometry: { kind: 'facility', facility: 'freightHouse' },
+      baseOperationalRail: true, standing: [], standingWest: 0,
+      facility: {
+        kind: 'freight', subtype: 'freightHouse',
+        allows: { outbound: true, inbound: true },
+        outboundBox: [], inboundBox: [], capacity: { outbound: 1, inbound: 1 },
+        menAtWork: [null, null, null], industryTrack: { cars: [...cars] },
+        laborers: 1, porters: 0, usedThisStage: { laborers: 0, porters: 0 },
+      },
+      modifiers: [], enhancements: [],
+    } as TrackCard;
+  }
+
+  const empty = (s: GameState, ...coords: GridCoord[]): void => {
+    for (const c of coords) {
+      assert.deepEqual(carsOn(areaOf(s, 0).grid.get(coordKey(c))!), [], `cars left standing at (${c.col},${c.row})`);
+    }
+  };
+
+  it('takes a cut standing on plain track on the way to the caboose', () => {
+    const s = game();
+    addCard(s, at(0, 2), straight());
+    addCard(s, at(0, 1), straight([boxcar(), boxcar()]));
+    addCard(s, at(0, 0), straight([caboose()]));
+    const id = placeTray(s, at(0, 2));
+    applyIntent(s, 0, { type: 'localOps.choose', option: 'switch' });
+    assert.ok(applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(0, 0), reverse: true }).ok);
+    assert.deepEqual(s.trays.get(id)!.consist.map((c) => c.type), ['boxcar', 'boxcar', 'caboose']);
+    empty(s, at(0, 1), at(0, 0));
+  });
+
+  it('takes cars SPOTTED AT AN INDUSTRY on the way, not just the destination', () => {
+    // Jesse's best guess at the reported shape. An industry card is plain east-west track carrying a
+    // facility, and `carsOn` reads its industry track rather than the card — so this is the case
+    // where the two could have come apart.
+    const s = game();
+    addCard(s, at(0, 2), straight());
+    addCard(s, at(0, 1), industry([boxcar(), boxcar()]));
+    addCard(s, at(0, 0), straight([caboose()]));
+    const id = placeTray(s, at(0, 2));
+    applyIntent(s, 0, { type: 'localOps.choose', option: 'switch' });
+    assert.ok(applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(0, 0), reverse: true }).ok);
+    assert.deepEqual(s.trays.get(id)!.consist.map((c) => c.type), ['boxcar', 'boxcar', 'caboose']);
+    empty(s, at(0, 1), at(0, 0));
+  });
+
+  it("takes the train's own cut off the square it is standing on as well", () => {
+    const s = game();
+    addCard(s, at(0, 1), straight());
+    addCard(s, at(0, 0), straight([caboose()]));
+    const id = placeTray(s, at(0, 1), [boxcar(), boxcar()]);
+    applyIntent(s, 0, { type: 'localOps.choose', option: 'switch' });
+    // Set the pair out behind the engine, pull forward, then back up past them to the caboose.
+    assert.ok(applyIntent(s, 0, { type: 'switch.dropCars', trayId: id, count: 2 }).ok);
+    assert.equal(carsOn(areaOf(s, 0).grid.get(coordKey(at(0, 1)))!).length, 2);
+    assert.ok(applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(0, 0), reverse: true }).ok);
+    assert.deepEqual(s.trays.get(id)!.consist.map((c) => c.type), ['boxcar', 'boxcar', 'caboose']);
+    empty(s, at(0, 1), at(0, 0));
+  });
+});