Add promotion to Dispatch, and measure how repetitive a run is

The mailroom is no longer the whole game. Around turn 50, a player who has
built standing and either Marlene's goodwill or the nerve to ask gets offered
the Dispatch post — and can take it, take it and put Trevor up for the mailroom,
or turn it down, which is a real strategy rather than a mistake and comes back
after a cooldown.

Dispatch is eleven events of its own. The money problem is largely solved up
there and replaced by other people's days depending on yours, including the
mailroom's — which you used to be. Trevor branches on whether you recommended
him: he either runs the mailroom and has opinions about how it used to be run,
or he stays put and starts addressing you by your full title, kindly, in front
of people.

None of this is a promotion mechanic in the engine. It is
`{ path: 'stage', op: 'set', value: 'dispatch' }` on an option, since `stage`
was already how events are filtered. The reserved-write rule now allows it
narrowly — `set` only, and only to a stage that has events, both checked by the
validator, so a typo cannot strand the player in an empty pool. Wages differ by
rank through two upkeep entries gated on `stage`. The hard-times events dropped
their stage entirely: rent is due wherever you work.

The second half of this is the thing the last playtest asked for. A 183-turn
session, and no way to see how much of it was new ground.

`npm run analyze <exported-log.json>` now reports turns against distinct
situations, how often each recurred, which options were most used, which locked
gates players kept meeting, and anything they typed. The retrospective shows the
player-facing version.

It found a regression in this very change on its first run. Dispatch started
with eight events against the mailroom's nineteen, so its two floor events were
46% of every promoted run — one every three turns. Promotion was moving the
player into *thinner* content. Three more events and a weight rebalance took the
top two to 24.5%, and the heaviest recurrence from every ~3 turns to every ~5.
A test now holds that line.

Also corrected: the coverage test was asking whether an archetype ever *took* an
option, which is a property of the bot, not the pack. It had flagged
`rent_bounced.ask_trevor` as dead content when it had been offered, unlocked,
419 times across a sweep and simply never chosen. Options are now checked on
availability; events are still checked on firing.

114 tests. Reasoning in docs/DECISIONS.md §22-24.

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

test/content.test.js

@@ -18,6 +18,7 @@ import { validatePack } from '../src/engine/validate.js';
 import { startGame, currentTurn, takeTurn } from '../src/engine/game.js';
 import { createRng } from '../src/engine/rng.js';
 import { play, sweep, median } from './fixtures/strategies.js';
+import { summarize } from '../src/ui/summary.js';
 
 /** Play `turns` turns with independently-seeded random choices. */
 function randomRun(runSeed, turns, visit = () => {}) {
@@ -40,31 +41,60 @@ test('the pack is valid, with no warnings', () => {
   assert.deepEqual(result.warnings, []);
 });
 
-test('no content is dead: every event and option is reachable by some player', () => {
+test('no content is dead: every event fires and every option becomes available', () => {
   // Across archetypes, not just random play: several things in the pack exist
   // for a player pursuing something, and "broke but well-liked" in particular
   // is a state no single-axis strategy ever reaches.
-  const { firedEvents, takenOptions } = sweep(pack, { seeds: 12, turns: 200 });
+  //
+  // Options are checked on *availability*, not on being taken. Whether a
+  // particular bot picks an option is an artefact of how the bot scores; what
+  // matters is whether a player is ever offered it unlocked.
+  const { firedEvents, offeredOptions } = sweep(pack, { seeds: 12, turns: 250 });
 
   const allEvents = pack.events.map((e) => e.id);
   const allOptions = pack.events.flatMap((e) => e.options.map((o) => `${e.id}.${o.id}`));
   assert.deepEqual(allEvents.filter((e) => !firedEvents.has(e)), [], 'events that can never fire');
-  assert.deepEqual(allOptions.filter((o) => !takenOptions.has(o)), [], 'options that can never be taken');
+  assert.deepEqual(allOptions.filter((o) => !offeredOptions.has(o)), [],
+    'options no player can ever be offered');
 });
 
 test('how you play changes where you end up', () => {
-  const { byStrategy } = sweep(pack, { seeds: 12, turns: 200 });
+  // Measured before promotions land, so this is about how a player handles
+  // money rather than about how fast they got out of the mailroom. Mixing the
+  // two hides the economy behind the career.
+  const { byStrategy } = sweep(pack, { seeds: 12, turns: 35 });
   const finalMoney = (name) => median(byStrategy[name].map((s) => s.money));
+  assert.ok(byStrategy.thrifty.every((s) => s.stage === 'mailroom'),
+    'nobody should be promoted this early');
 
   // The shape that matters: minding the money climbs, ignoring it sinks, and
-  // playing without a plan roughly treads water. Exact figures will move with
+  // playing without a plan roughly treads water. Exact figures move with
   // tuning; the ordering is the design.
-  assert.ok(finalMoney('thrifty') > finalMoney('random'),
-    'a careful player should get ahead');
-  assert.ok(finalMoney('random') > finalMoney('spendthrift'),
-    'a careless player should struggle');
-  assert.ok(finalMoney('thrifty') > 800,
-    `a careful player should be comfortably ahead, was ${finalMoney('thrifty')}`);
+  assert.ok(finalMoney('thrifty') > finalMoney('random'), 'a careful player should get ahead');
+  assert.ok(finalMoney('random') > finalMoney('spendthrift'), 'a careless player should struggle');
+});
+
+test('the promotion is worth taking, and reachable by a deliberate player', () => {
+  const { byStrategy } = sweep(pack, { seeds: 12, turns: 200 });
+
+  const promoted = Object.values(byStrategy).flat().filter((s) => s.stage === 'dispatch');
+  const stayed = Object.values(byStrategy).flat().filter((s) => s.stage === 'mailroom');
+  assert.ok(promoted.length > 0 && stayed.length > 0, 'both outcomes should occur');
+  assert.ok(median(promoted.map((s) => s.money)) > median(stayed.map((s) => s.money)),
+    'the coordinator wage should leave a player better off');
+
+  // A player actually pursuing it should get there mid-run, not at the very
+  // end — the mailroom is a career, not a tutorial.
+  const timings = [];
+  for (let seed = 0; seed < 12; seed++) {
+    let at = null;
+    play(pack, { strategy: 'sociable', seed, turns: 200,
+      visit: ({ state }) => { if (state.stage === 'dispatch' && at === null) at = state.turn; } });
+    if (at) timings.push(at);
+  }
+  assert.equal(timings.length, 12, 'a sociable player should always get the offer');
+  const typical = median(timings);
+  assert.ok(typical > 40 && typical < 90, `promotion landed at turn ${typical}`);
 });
 
 test('hard times is uncommon for a careful player and real for a careless one', () => {
@@ -179,3 +209,53 @@ test('the retrospective has something to read back', () => {
   assert.equal(state.history.length, 60, 'every turn is recorded');
   assert.ok(state.history.every((h) => Array.isArray(h.upkeep)), 'upkeep is recorded per turn');
 });
+
+test('a long run does not collapse onto a handful of situations', () => {
+  // Motivated by a real 183-turn session. Before Dispatch was fleshed out, its
+  // two floor events were 46% of every promoted run — one every three turns.
+  // This is the guardrail on that: variety is a property of the pack, and it
+  // should fail loudly when a stage is too thin for the run it invites.
+  for (const strategy of ['sociable', 'thrifty', 'random']) {
+    const counts = new Map();
+    let turns = 0;
+    play(pack, { strategy, seed: 'variety', turns: 200,
+      visit: ({ turn }) => {
+        counts.set(turn.event.id, (counts.get(turn.event.id) ?? 0) + 1);
+        turns++;
+      } });
+
+    const [topEvent, topCount] = [...counts.entries()].sort((a, b) => b[1] - a[1])[0];
+    const share = topCount / turns;
+    assert.ok(share < 0.25,
+      `${strategy}: "${topEvent}" was ${(share * 100).toFixed(0)}% of turns`);
+
+    // Measured against what was actually reachable: a run that never leaves
+    // the mailroom cannot see Dispatch, and counting that as thin content
+    // would be measuring career progress rather than variety.
+    const visited = new Set([...counts.keys()]
+      .map((id) => pack.events.find((e) => e.id === id).stage)
+      .filter(Boolean));
+    const reachable = pack.events
+      .filter((e) => e.stage === undefined || visited.has(e.stage)).length;
+    assert.ok(counts.size / reachable > 0.6,
+      `${strategy}: saw ${counts.size} of ${reachable} reachable situations in ${turns} turns`);
+  }
+});
+
+test('the retrospective reports how repetitive the run was', () => {
+  const state = play(pack, { strategy: 'sociable', seed: 'repeats', turns: 120 });
+  const summary = summarize(pack, state);
+
+  assert.equal(summary.turns, 120);
+  assert.ok(summary.eventsSeen > 0 && summary.eventsSeen <= summary.eventsTotal);
+  assert.ok(summary.averageTimesSeen > 1, 'a long run repeats situations');
+  assert.equal(
+    summary.averageTimesSeen.toFixed(2),
+    (summary.turns / summary.eventsSeen).toFixed(2),
+    'the average is turns over distinct situations',
+  );
+  assert.ok(summary.mostSeen.count >= summary.averageTimesSeen);
+  assert.ok(summary.repeatedSituations <= summary.eventsSeen);
+  assert.deepEqual(summary.stagesVisited, ['mailroom', 'dispatch'],
+    'the retrospective knows the career moved');
+});