Add the interface, then rebuild the economy around the first playtest

The MVP is playable: a turn screen, a career retrospective, an optional
feedback widget, local-storage autosave with file export/import, and a build
that flattens everything into one self-contained HTML file.

A turn has two phases — the scenario and its options, then what the choice did
and, separately, what the day cost regardless. Numbers that move without the
player seeing why are most of what makes them meaningless. Locked options are
shown greyed with the requirement spelled out rather than hidden, so a player
can see the door they cannot open yet.

The interface is named entirely by the pack. `pack.display` maps a state path to
a label, a format and an order, which is why the header reads "Standing" for a
path called `reputation` and why debt disappears while it is zero.

The first playtest then found three things, all of them fair.

*"Wasn't clear what daily drain was for."* The ledger was labelling changes by
the path that moved — "Money −$18" — when the upkeep entry that caused them had
a perfectly good name. It now says "Coffee, transit, lunch". The labels were in
the data the whole time and never reached the screen.

*"Should probably pay rent weekly / get paid every other week… would be good to
have day of week and week # shown."* Packs can now declare a calendar, and the
engine derives the day name, cycle and index from the turn number before the
event is drawn — so content can require a Friday and the header can say
"Thursday · Week 2 · Day 12". Upkeep entries take `every` and `offset`, making
wages fall on alternate Fridays and rent every Monday. The turn screen carries
a diary line — "Wages tomorrow · Rent in 4 days" — computed generically from
whatever a pack schedules.

*"Always in debt — could never get ahead."* The old economy bled $25 a day
regardless of play. It is now roughly break-even at baseline, with a
`spare_shift` event that appears *because* you are broke: the way out of a hole
should be visible from inside it. Across archetypes a careful player ends around
$1,400, an unplanned one treads water, and a careless one sinks into real debt.

That retune broke the coverage test, usefully. Random play stopped reaching hard
times at all, which made the entire debt branch look dead — it was not, since
random play is not a plausible player. Coverage is now the union across five
archetypes, including one that is broke *and* well-liked, because the "ask a
friend for money" options sit in a state no single-axis strategy reaches.

Not covered by any of this: styling and dark mode, which only a human with a
browser can check. This machine has none that can render a page.

109 tests. Reasoning in docs/DECISIONS.md §14-21.

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

README.md

@@ -25,25 +25,52 @@ currently playable only from a test harness.
 | Turn loop, per-turn upkeep | done |
 | Content validator + reachability tests | done |
 | Corporate Ladder pack — 17 events, 2 characters | done |
-| UI | not started |
-| Save to local storage, export/import | not started |
-| Feedback widget and log export | not started |
-| Retrospective screen | not started |
+| Turn screen, retrospective, feedback widget | done |
+| Local-storage save, file export/import | done |
+| Single-file build | done |
+| Calendar, scheduled wages and rent | done |
+| Played in a real browser | done — first playtest 2026-09-09 |
 
-## Running
+The first playtest confirmed the interface, saves and the exported log all work
+in a real browser. Its findings — an unexplained daily drain, no sense of the
+week, and an economy nobody could get ahead in — are what the calendar and the
+retuned economy are for.
+
+Note that the development machine has no browser that can render a page, so the
+UI tests drive the real modules against a minimal fake DOM. That covers wiring,
+not layout: **styling and dark mode are only ever verified by a human opening
+it.**
+
+## Playing it
 
 ```sh
-npm test          # engine test suite (node's built-in runner, no dependencies)
-npm run serve     # static server on :8080 for development
+npm run serve     # then open http://localhost:8080
+```
+
+A server is needed during development because browsers refuse ES module imports
+over `file://`. If port 8080 is taken, run `python3 -m http.server <port>`
+instead.
+
+To hand the game to someone else:
+
+```sh
+npm run build     # writes dist/theladder.html
+```
+
+That is one self-contained file with the stylesheet and every module inlined.
+It plays by double-clicking it — no server, no network, nothing installed.
+
+```sh
+npm test          # 109 tests: engine, content, UI wiring, and the build
 ```
 
 There are no runtime dependencies and no build step for development. Node is
-used only to run tests and, later, the single-file build.
+used only to run the tests and the single-file build.
 
 ## Layout
 
 ```
-src/engine/     the game engine — imports nothing from content/
+src/engine/     the game engine — imports nothing from content/, or from src/ui/
   paths.js        dotted-path get/set over state
   conditions.js   generic predicates: { path, op, value }, all/any/not
   effects.js      generic mutations: add/set/push/remove, with clamping
@@ -52,8 +79,14 @@ src/engine/     the game engine — imports nothing from content/
   game.js         the turn loop
   rng.js          seeded, serializable RNG
   validate.js     load-time content checking
+src/ui/         screens, formatting and the app controller
+  app.js          the only module that names a content pack
+  screens/        the turn screen and the retrospective
+  format.js       state paths and conditions rendered as English
+src/io/         local-storage save, file export/import, the feedback log
 content/        content packs (settings)
-test/           engine tests, run against a fixture pack, never real content
+tools/build.js  flattens everything into one self-contained HTML file
+test/           engine tests against a fixture pack; content and UI tests
 docs/           DECISIONS.md — why things are the way they are
 Planning/       the original design documents
 ```
@@ -120,8 +153,24 @@ Conditions may read engine bookkeeping (`turn`, `stage`, `seen.<eventId>`,
 `lastSeen.<eventId>`) as well as pack state. Effects may not write it.
 
 A pack also declares `upkeep` — a list of `{ label, requires?, effects }`
-applied at the end of every turn, after the choice. Corporate Ladder uses it for
-wages, living costs, and a loan service charge that steps up as the debt grows.
+applied at the end of a turn, after the choice. Adding `every` and `offset`
+makes an entry periodic rather than daily: Corporate Ladder pays wages on
+alternate Fridays (`{ every: 14, offset: 4 }`), charges rent every Monday, and
+adds a loan service charge that steps up as the debt grows.
+
+A pack may also declare a `calendar`:
+
+```js
+calendar: {
+  cycleLength: 7,
+  cycleName: 'Week',
+  unitNames: ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'],
+},
+```
+
+The engine derives `calendar.index`, `calendar.cycle` and `calendar.name` from
+the turn number before each event is drawn, so content can require a Friday and
+the interface can title the turn. Declare no calendar and there is no week.
 
 Run `validatePack(pack)` when loading in development — it catches undeclared
 paths, unknown characters, unusable ids, unreachable events and stages with no