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

src/io/download.js

@@ -0,0 +1,30 @@
+// Handing the player a file.
+//
+// Object URLs are revoked on the next frame rather than immediately: Safari
+// has historically cancelled the download if the URL goes away too soon.
+
+export function downloadText(filename, text, type = 'application/json') {
+  const url = URL.createObjectURL(new Blob([text], { type }));
+  const link = document.createElement('a');
+  link.href = url;
+  link.download = filename;
+  document.body.append(link);
+  link.click();
+  link.remove();
+  requestAnimationFrame(() => URL.revokeObjectURL(url));
+}
+
+/** Read a File the player picked, as text. */
+export function readFile(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result));
+    reader.onerror = () => reject(new Error('Could not read that file.'));
+    reader.readAsText(file);
+  });
+}
+
+/** A timestamp suffix that sorts, for filenames. */
+export function stamp(date = new Date()) {
+  return date.toISOString().slice(0, 19).replace(/[:T]/g, '-');
+}

src/io/feedback-log.js

@@ -0,0 +1,103 @@
+// The feedback and instrumentation log.
+//
+// Deliberately separate from the save: this is research data for the designer,
+// not part of anyone's career. It is exported on its own and never merged into
+// a save file.
+//
+// Each entry records more than the spec's minimum, for two reasons. The full
+// before/after diff makes "what did that choice actually do" answerable months
+// later without replaying anything. The list of options that were *offered but
+// locked* is the strongest available signal that a choice set is too narrow —
+// players rarely type into a comment box, but the gates they keep bouncing off
+// are recorded whether they say anything or not.
+
+const KEY = 'theladder.feedback.v1';
+const FORMAT = 1;
+
+function safely(action, fallback = null) {
+  try {
+    return action();
+  } catch {
+    return fallback;
+  }
+}
+
+function readRaw() {
+  return safely(() => {
+    const raw = localStorage.getItem(KEY);
+    return raw ? JSON.parse(raw) : [];
+  }, []) ?? [];
+}
+
+function writeRaw(entries) {
+  return safely(() => {
+    localStorage.setItem(KEY, JSON.stringify(entries));
+    return true;
+  }, false);
+}
+
+/**
+ * Record a turn. `record` is what takeTurn returned; `state` is the state it
+ * produced, carried for the seed and the running totals at that moment.
+ */
+export function logTurn(record, state, pack) {
+  const entries = readRaw();
+  entries.push({
+    logged_at: new Date().toISOString(),
+    pack_id: pack.id,
+    pack_version: pack.version ?? null,
+    seed: state.meta.seed,
+    turn_id: `${state.meta.seed}:${record.turn}`,
+    turn: record.turn,
+    stage: record.stage,
+    event_id: record.eventId,
+    action_taken: record.optionId,
+    action_label: record.optionLabel,
+    changes: record.changes,
+    upkeep: record.upkeep,
+    offered: record.offered,
+    rating: null,
+    comment: null,
+    desired_but_unavailable_action: null,
+  });
+  writeRaw(entries);
+  return entries.at(-1);
+}
+
+/**
+ * Attach the player's feedback to a turn already logged. Feedback arrives
+ * after the choice — often several seconds after — so it is a second write
+ * rather than part of the first.
+ */
+export function attachFeedback(turnId, { rating, comment, desiredAction }) {
+  const entries = readRaw();
+  const entry = entries.findLast((e) => e.turn_id === turnId);
+  if (!entry) return false;
+  if (rating !== undefined) entry.rating = rating;
+  if (comment !== undefined) entry.comment = comment || null;
+  if (desiredAction !== undefined) entry.desired_but_unavailable_action = desiredAction || null;
+  return writeRaw(entries);
+}
+
+export function readLog() {
+  return readRaw();
+}
+
+export function clearLog() {
+  return safely(() => { localStorage.removeItem(KEY); return true; }, false);
+}
+
+/** How many entries carry actual player feedback, for the export summary. */
+export function feedbackCount(entries = readRaw()) {
+  return entries.filter((e) => e.rating || e.comment || e.desired_but_unavailable_action).length;
+}
+
+export function serializeLog(entries = readRaw()) {
+  return JSON.stringify({
+    format: FORMAT,
+    exported_at: new Date().toISOString(),
+    turns_logged: entries.length,
+    turns_with_feedback: feedbackCount(entries),
+    entries,
+  }, null, 2);
+}

src/io/save.js

@@ -0,0 +1,77 @@
+// Saving and loading.
+//
+// Local storage is the live save; the file export exists so a cleared cache or
+// a crashed browser does not take a career with it. A save is the whole game
+// state and nothing else — the engine keeps no state outside it, so this is a
+// complete record by construction.
+
+const KEY = 'theladder.save.v1';
+const FORMAT = 1;
+
+/** Local storage throws in private windows and when site data is blocked. */
+function safely(action, fallback = null) {
+  try {
+    return action();
+  } catch {
+    return fallback;
+  }
+}
+
+export function saveLocal(state) {
+  return safely(() => {
+    localStorage.setItem(KEY, JSON.stringify({ format: FORMAT, savedAt: new Date().toISOString(), state }));
+    return true;
+  }, false);
+}
+
+export function loadLocal() {
+  return safely(() => {
+    const raw = localStorage.getItem(KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    return parsed?.state ?? null;
+  });
+}
+
+export function clearLocal() {
+  return safely(() => { localStorage.removeItem(KEY); return true; }, false);
+}
+
+/** True if the browser will actually remember anything. */
+export function storageAvailable() {
+  return safely(() => {
+    const probe = '__theladder_probe__';
+    localStorage.setItem(probe, '1');
+    localStorage.removeItem(probe);
+    return true;
+  }, false);
+}
+
+/** A save file's contents, as a string ready to be downloaded. */
+export function serializeSave(state) {
+  return JSON.stringify({ format: FORMAT, savedAt: new Date().toISOString(), state }, null, 2);
+}
+
+/**
+ * Parse an imported save, refusing anything that is not one. A file from a
+ * different pack is rejected by name rather than loaded into a game whose
+ * events and characters do not match it.
+ */
+export function parseSave(text, expectedPackId) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new Error('That file is not valid JSON.');
+  }
+  const state = parsed?.state;
+  if (!state || typeof state !== 'object' || !state.meta || typeof state.turn !== 'number') {
+    throw new Error('That does not look like a saved game.');
+  }
+  if (expectedPackId && state.meta.packId !== expectedPackId) {
+    throw new Error(
+      `That save is from "${state.meta.packId}", but this is "${expectedPackId}".`,
+    );
+  }
+  return state;
+}