v0.8.0.9 — the bot plans its switching turn, stops wasting its draws, and the engine walks each route once

The developer bot, re-measured decision by decision against the bot before it,
goes from about -0.3 revenue a game to about 4.8:

- plans the whole switching turn before its first Move (sim/switch-planner.ts),
  +2.89 over 1600 paired seeds; closes TODO #53
- takes a face-up card only if it could play it, +1.52 over 1600 seeds
- stops running Second Sections by accident in the New Train phase, +0.32
- lays track by what the district can do afterwards, +0.12 over 6400 seeds,
  run-arounds in 22 of 60 districts against 9

The engine is 2.8x faster with play proven identical: a route cache scoped to
one unchanged position, applyIntent split into prepareIntent + commitEvents,
and less allocation in exploreMoves. npm test now leaves out the bot
simulations, which run as npm run test:sim.

No rule changed; games in progress resume. Rejected candidates and the
Second Section card question are in CHANGELOG.md and TODO.md (#104-#106).

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

src/sim/bot.ts

@@ -22,6 +22,9 @@
 import {
   applyIntent,
   areaOf,
+  extendLimitsIfNeeded,
+  isLockedOut,
+  protoCard,
   canAdvanceLoad,
   destinationsFor,
   facilityCarTypes,
@@ -29,14 +32,15 @@ import {
   ownCutFor,
 } from '../engine/apply.ts';
 import { MAX_CONSIST, nextOfficeTier, officeProfile } from '../engine/content.ts';
-import type { CarType, Hand, TrackGeometry } from '../engine/content.ts';
+import type { CarType, FreightKind, Hand, TrackGeometry } from '../engine/content.ts';
 import type { GameEvent } from '../engine/events.ts';
 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 { canPlaceAt, connectionsFor, exitsFrom, facilityVariants, hasPort, joins, neighbour, opposite, variantsFor } from '../engine/track.ts';
 import type { Port } from '../engine/track.ts';
 import { actingPlayer, coordKey, turnOf } from '../engine/state.ts';
 import type { Facility, GameState, GridCoord, OfficeArea, PlayerIndex, RollingStock, TrackCard } from '../engine/state.ts';
+import { planSwitchingTurn, switchFingerprint } from './switch-planner.ts';
 
 export type BotPolicy = {
   name: string;
@@ -106,7 +110,8 @@ function because(reason: string, intent: Intent): Intent {
  * Every flag here turns something OFF. That is the opposite of how this started — the tweaks were
  * candidates to switch on — and it is the right shape once a candidate has been adopted: what a
  * measured heuristic needs afterwards is a way to ask "is this still worth it?" when the deck or
- * the rules move under it. Both of these were worth about +1.5 revenue together when adopted; if a
+ * the rules move under it. The first two were worth about +1.5 revenue together when adopted, and
+ * planning the switching turn (`noPlanSwitching`) +2.89 on its own; if a
  * rebalance changes the economy, that is a claim to re-test rather than to assume.
  *
  * The candidates that did NOT survive are gone rather than left switched off: preferring coaches at
@@ -121,9 +126,78 @@ export type BotTweaks = {
   noTrainCap?: boolean;
   /** Draw whenever nothing is urgent, as the bot did before it preferred operating. */
   noOperateFirst?: boolean;
-
+  /**
+   * Choose switching Moves one at a time from the rule ladder, as the bot did before it planned the
+   * whole turn (`switch-planner.ts`). Measured at adoption, 2026-09-14: planning was worth
+   * +2.89 ± 0.18 revenue a game (t = 15.79) over 1600 paired seeds, 733 better against 21 worse.
+   */
+  noPlanSwitching?: boolean;
+  /**
+   * Take a face-up train or industry card whether or not it could be played, as the bot did before
+   * 2026-09-14. It then took 20.1 trains and 11.9 industries a game off the Departments and discarded
+   * 20.2 and 11.8, retaking the same card 28.8 times a game. Asking first measured +1.52 ± 0.10
+   * (t = 15.59) over 1600 paired seeds — this ablation was worse on 880 of them and better on 211.
+   */
+  noPlayableTakes?: boolean;
+  /**
+   * Choose where track goes by `bestTrackLay`'s piece rules and the fallback's first legal square, as the
+   * bot did before 2026-09-15, instead of by what the district can DO afterwards (`bestValuedLay`).
+   * Scoring the layout measured +0.118 ± 0.029 (t = 4.14) over 6400 paired seeds, and closed run-arounds
+   * in 22 of 60 districts against 9.
+   */
+  noValueLays?: boolean;
+  /**
+   * Let the New Train phase's fallback take `options[0]`, as the bot did before 2026-09-15. Because
+   * `legalActions` lists `newTrain.secondSection` ahead of the Extra starts, all 26 Second Sections the
+   * bot ran in 60 games were that accident, and 6 of the 20 collisions followed one. Taking a car, a pass
+   * or the Extra's start instead measured +0.32 ± 0.09 (t = 3.64) over 400 paired seeds.
+   */
+  noDeliberateNewTrain?: boolean;
 };
 
+/**
+ * A switching turn planned once and then played a step per decision.
+ *
+ * Keyed by the tweaks object, because that is what one policy owns — the server shares a single
+ * `developerBot` across every bot seat, so the plan inside it is kept per player. Each step is
+ * submitted only while the position still matches the fingerprint the plan expected there; anything
+ * else replans. A switching turn has no randomness, so in practice a plan is made once a turn.
+ */
+type ActivePlan = { steps: Intent[]; keys: string[]; next: number; summary: string };
+const activePlans = new WeakMap<BotTweaks, Map<PlayerIndex, ActivePlan>>();
+
+function plannedSwitch(s: GameState, player: PlayerIndex, options: Intent[], tweaks: BotTweaks): Intent | null {
+  let mine = activePlans.get(tweaks);
+  if (!mine) activePlans.set(tweaks, (mine = new Map()));
+  const here = switchFingerprint(s, player);
+  let active = mine.get(player);
+  if (!active || active.keys[active.next] !== here) {
+    const p = planSwitchingTurn(s, player);
+    active = {
+      steps: p.steps,
+      keys: p.keys,
+      next: 0,
+      summary:
+        `position ${p.rootScore.toFixed(2)} → ${p.score.toFixed(2)} over ${p.expanded} positions` +
+        (p.complete ? '' : ', search budget reached'),
+    };
+    mine.set(player, active);
+  }
+  if (active.next >= active.steps.length) {
+    mine.delete(player);
+    const end = options.find((i) => i.type === 'switch.end');
+    return end ? because(`planned switching turn complete — ${active.summary}`, end) : null;
+  }
+  const want = JSON.stringify(active.steps[active.next]);
+  const match = options.find((i) => JSON.stringify(i) === want);
+  if (!match) {
+    mine.delete(player);
+    return null;
+  }
+  active.next++;
+  return because(`step ${active.next} of ${active.steps.length} of a planned switching turn — ${active.summary}`, match);
+}
+
 /** The bot as it plays today. Every knob off. */
 export const developerBot: BotPolicy = makeDeveloperBot({});
 
@@ -209,6 +283,13 @@ export function makeDeveloperBot(tweaks: BotTweaks): BotPolicy {
         );
         if (match) return because(`the ${w.loaded ? 'loaded' : 'empty'} ${w.type} is what a facility is short of`, match);
       }
+      if (!tweaks.noDeliberateNewTrain) {
+        const move =
+          pickFirst(options, 'newTrain.placeCar', 'newTrain.passCar', 'newTrain.startExtra') ??
+          options.find((i) => i.type !== 'newTrain.secondSection' && i.type !== 'maneuver.redFlags') ??
+          options[0]!;
+        return because('no car on offer is one our facilities need', move);
+      }
       return because('no car on offer is one our facilities need', pickFirst(options, 'newTrain.placeCar', 'newTrain.passCar') ?? options[0]!);
     }
 
@@ -438,7 +519,7 @@ function topOfDepartment(s: GameState, slot: number): string | undefined {
  * In a competitive game the same call reads the other way round — burying a card a rival wants is an
  * attack — which is why the choice belongs to the discarding player and not to the rules.
  */
-function bestDiscard(s: GameState, player: PlayerIndex, options: Intent[]): Intent | null {
+function bestDiscard(s: GameState, player: PlayerIndex, options: Intent[], tweaks: BotTweaks): Intent | null {
   let best: Intent | null = null;
   let bestScore = -Infinity;
   for (const i of options) {
@@ -448,7 +529,7 @@ function bestDiscard(s: GameState, player: PlayerIndex, options: Intent[]): Inte
     // two showing whatever they happened to start with. Measured over 100 games — spreading 2.87
     // revenue, concentrating on the deepest 2.67, indifferent 2.67.
     const top = topOfDepartment(s, i.toSlot);
-    const wanted = isWorthTaking(s, player, i.toSlot);
+    const wanted = isWorthTaking(s, player, i.toSlot, tweaks);
     const depth = s.decks.departments[i.toSlot]?.length ?? 0;
     const score = (top === undefined ? 6 : wanted ? -10 : 2) - Math.min(depth, 4) * 0.5;
     if (score > bestScore) {
@@ -460,10 +541,39 @@ function bestDiscard(s: GameState, player: PlayerIndex, options: Intent[]): Inte
 }
 
 /** A face-up card worth spending the draw on rather than gambling on the deck. */
-function isWorthTaking(s: GameState, player: PlayerIndex, slot: number): boolean {
-  return takingRank(s, player, slot) > 0;
+function isWorthTaking(s: GameState, player: PlayerIndex, slot: number, tweaks: BotTweaks): boolean {
+  return takingRank(s, player, slot, tweaks) > 0;
 }
 
+/**
+ * Could an industry of this kind be laid anywhere right now? Asked of the engine's own placement
+ * rule (`canPlaceAt`) and lockout (`isLockedOut`) rather than a copy: an industry is plain east-west
+ * track, so the only squares worth asking about are empty ones east or west of a card already down.
+ */
+function industrySiteExists(s: GameState, player: PlayerIndex, kind: FreightKind): boolean {
+  const area = areaOf(s, player);
+  if (isLockedOut(area, kind)) return false;
+  const probe = {
+    geometry: { kind: 'facility', facility: kind },
+    baseOperationalRail: true,
+    standing: [],
+    standingWest: 0,
+    facility: null,
+    modifiers: [],
+    enhancements: [],
+  } as unknown as TrackCard;
+  for (const key of area.grid.keys()) {
+    const [row, col] = key.split(',').map(Number);
+    for (const dc of [1, -1]) {
+      const at = { row: row!, col: col! + dc };
+      if (at.row === area.runningRow || area.grid.has(coordKey(at))) continue;
+      if (canPlaceAt(area, at, probe)) return true;
+    }
+  }
+  return false;
+}
+
+
 /**
  * HOW BADLY the face-up card is wanted. 0 means not worth the draw.
  *
@@ -471,14 +581,18 @@ function isWorthTaking(s: GameState, player: PlayerIndex, slot: number): boolean
  * happened to be scanned first — a coin flip on the card that decides whether the district ever
  * becomes a Passenger Facility at all.
  */
-function takingRank(s: GameState, player: PlayerIndex, slot: number): number {
+function takingRank(s: GameState, player: PlayerIndex, slot: number, tweaks: BotTweaks): number {
   const id = topOfDepartment(s, slot);
   if (!id) return 0;
   const k = s.cards.get(id)?.kind;
   if (!k) return 0;
   if (k.kind === 'office') return nextOfficeTier(areaOf(s, player).tier) === k.tier ? 3 : 0;
-  if (k.kind === 'timetabledTrain' || k.kind === 'extraTrain') return 2;
-  if (k.kind === 'freightFacility') return 1;
+  if (k.kind === 'timetabledTrain' || k.kind === 'extraTrain') {
+    return !tweaks.noPlayableTakes && trainWouldOverfillTheOffice(s, player, tweaks) ? 0 : 2;
+  }
+  if (k.kind === 'freightFacility') {
+    return !tweaks.noPlayableTakes && !industrySiteExists(s, player, k.facility) ? 0 : 1;
+  }
   return 0;
 }
 
@@ -741,6 +855,104 @@ function bestFacilityPlay(s: GameState, player: PlayerIndex, options: Intent[]):
   return best;
 }
 
+/**
+ * WHAT A DISTRICT'S TRACK IS WORTH FOR WHAT IT LETS HAPPEN NEXT — the default since 2026-09-15;
+ * `noValueLays` turns it off.
+ *
+ * `bestTrackLay` scores the PIECE — its shape and where it sits — and cannot tell one that opens an
+ * industry site or closes a run-around from one that merely fills a square. This scores the LAYOUT the
+ * piece would leave, so a lay is worth the difference it makes. Every term is something the rules turn
+ * into play: a site is somewhere a held industry can go; a run-around lets a crew pass its own cars
+ * (§A.5); a way off the main is the only road to either; a Running Track straight is what Interlocking
+ * needs. The weights are a starting point to measure, not a result.
+ */
+function layoutValue(area: OfficeArea): number {
+  let v = 0;
+  const reachable = reachableOffMain(area);
+  v += Math.min(reachable.size, 12) * 0.2;
+
+  let ways = 0;
+  let loops = 0;
+  for (const side of SIDES) {
+    for (const col of waysOff(area, side)) {
+      ways++;
+      if (descendFrom(area, col, side).rejoins.size > 0) loops++;
+    }
+  }
+  v += [0, 1.5, 2, 2.5][Math.min(ways, 3)]!;
+  if (loops > 0) v += 6 + Math.min(loops - 1, 1) * 2;
+
+  // Squares an industry could legally be laid on, joined to track a crew can reach.
+  const probe = protoCard({ kind: 'freightFacility', facility: 'mineTipple' }, 0)!;
+  const tried = new Set<string>();
+  let sites = 0;
+  for (const key of reachable) {
+    const [row, col] = key.split(',').map(Number);
+    for (const dc of [1, -1]) {
+      const at = { row: row!, col: col! + dc };
+      const k = coordKey(at);
+      if (tried.has(k) || area.grid.has(k) || at.row === area.runningRow) continue;
+      tried.add(k);
+      if (canPlaceAt(area, at, probe)) sites++;
+    }
+  }
+  v += [0, 2, 3, 3.5][Math.min(sites, 3)]!;
+
+  let mainStraight = false;
+  for (const [key, card] of area.grid) {
+    if (Number(key.split(',')[0]) !== area.runningRow || card.geometry.kind !== 'track') continue;
+    if (card.geometry.geometry === 'straight') mainStraight = true;
+    // A turnout on the main whose leg joins nothing is a hole in the Running Track with no road behind it.
+    if (card.geometry.geometry === 'turnout') {
+      const col = Number(key.split(',')[1]);
+      for (const side of SIDES) {
+        if (!hasPort(card, legPort(side))) continue;
+        const beyond = area.grid.get(`${area.runningRow + side},${col}`);
+        if (!beyond || !joins(card, legPort(side), beyond)) v -= 0.5;
+      }
+    }
+  }
+  if (mainStraight) v += 1.5;
+  return v;
+}
+
+/**
+ * The track lay worth most by `layoutValue`, placed on a copy of the district exactly as the reducer
+ * places it (`protoCard`, `extendLimitsIfNeeded`). With `mustBuild`, only a lay that gains something is
+ * offered, which is the slot `bestTrackLay` fills; without it, the best of whatever is legal, which is
+ * the slot the "play what is in hand" fallback fills. Ties go to the square nearer the Office.
+ */
+function bestValuedLay(s: GameState, player: PlayerIndex, options: Intent[], mustBuild: boolean): Intent | null {
+  const area = areaOf(s, player);
+  const base = layoutValue(area);
+  let best: Intent | null = null;
+  let bestScore = -Infinity;
+  for (const i of options) {
+    if (i.type !== 'card.play' || i.placement === undefined) continue;
+    const kind = s.cards.get(i.cardId)?.kind;
+    if (kind?.kind !== 'track') continue;
+    const built = protoCard(kind, i.variant);
+    if (!built) continue;
+    const after: OfficeArea = {
+      ...area,
+      grid: new Map(area.grid),
+      limitsWest: { ...area.limitsWest },
+      limitsEast: { ...area.limitsEast },
+    };
+    after.grid.set(coordKey(i.placement), built);
+    extendLimitsIfNeeded(after, i.placement);
+    const gain = layoutValue(after) - base;
+    if (mustBuild && gain <= 0.1) continue;
+    const distance = Math.abs(i.placement.row - area.officeCoord.row) * 2 + Math.abs(i.placement.col - area.officeCoord.col);
+    const score = gain - distance * 0.01;
+    if (score > bestScore) {
+      bestScore = score;
+      best = i;
+    }
+  }
+  return best;
+}
+
 function bestTrackLay(s: GameState, player: PlayerIndex, options: Intent[]): Intent | null {
   const area = areaOf(s, player);
 
@@ -1213,7 +1425,7 @@ function followThrough(
       if (!turnOf(s, player).drawnThisTurn) {
         const piles = options.filter(
           (i): i is Extract<Intent, { type: 'draw.fromDepartment' }> =>
-            i.type === 'draw.fromDepartment' && isWorthTaking(s, player, i.slot),
+            i.type === 'draw.fromDepartment' && isWorthTaking(s, player, i.slot, tweaks),
         );
         // Best-ranked pile rather than the first that qualifies: an Office card and a train card
         // both "qualify", and only one of them stops the collisions.
@@ -1221,7 +1433,7 @@ function followThrough(
         // and a train card are face up together 1.6 decisions a game — but ranking them is what the
         // ranking function is for, and a coin flip on the card that decides whether the district
         // ever becomes a Passenger Facility is not worth keeping for its own sake.
-        const useful = piles.sort((a, b) => takingRank(s, player, b.slot) - takingRank(s, player, a.slot))[0];
+        const useful = piles.sort((a, b) => takingRank(s, player, b.slot, tweaks) - takingRank(s, player, a.slot, tweaks))[0];
         if (useful) return because('a face-up card is worth more than a blind draw right now', useful);
         const blind = options.find((i) => i.type === 'draw.fromHomeOffice');
         if (blind) return because('no face-up card is worth taking — gamble on the deck', blind);
@@ -1282,7 +1494,7 @@ function followThrough(
       // STRAIGHTS that Enhancements require, and no Freight Facility has anywhere to go until a
       // district exists. Measured with track absent, the hand held a playable Enhancement on 4,778
       // turns and could legally place one on 33.
-      const track = bestTrackLay(s, player, options);
+      const track = !tweaks.noValueLays ? bestValuedLay(s, player, options, true) : bestTrackLay(s, player, options);
       if (track) return because('lay track — nothing else creates the straights Enhancements need or the spurs freight needs', track);
 
       // Then real development: a card actually laid into the grid. Freight facilities are scored —
@@ -1307,17 +1519,27 @@ function followThrough(
           s.cards.get(i.cardId)?.kind.kind !== 'track',
       );
       if (placed) return because('develop the district with a card that goes on the board', placed);
-      const play = options.find((i) => i.type === 'card.play');
+      const play = !tweaks.noValueLays
+        ? options.find((i) => i.type === 'card.play' && s.cards.get(i.cardId)?.kind.kind !== 'track') ??
+          bestValuedLay(s, player, options, false)
+        : options.find((i) => i.type === 'card.play');
       if (play) return because('play what is in hand', play);
       const end = options.find((i) => i.type === 'draw.end');
       if (end) return because('nothing in hand can be played anywhere legal', end);
       return because(
         'nothing playable — discard onto the Department whose face-up card is least worth keeping reachable',
-        bestDiscard(s, player, options) ?? pickFirst(options, 'card.discard') ?? options[0]!,
+        bestDiscard(s, player, options, tweaks) ?? pickFirst(options, 'card.discard') ?? options[0]!,
       );
     }
 
     case 'switch': {
+      // The planner decides the whole turn; the rules below are its fallback if the position is ever
+      // not the one it planned for, and the whole of switching under `noPlanSwitching`.
+      if (!tweaks.noPlanSwitching) {
+        const planned = plannedSwitch(s, player, options, tweaks);
+        if (planned) return planned;
+      }
+
       /**
        * A MOVE THAT DRAGS THE CREW'S OWN CUT BACK ON IS A WASTED MOVE, so take those off the table
        * before any heuristic gets to choose one.