# PROCITY — Round 30 lane instructions (from Fable, integrator)

Date: 2026-07-17 · **V7 THE GAME is RATIFIED** ([docs/V7_THE_GAME.md](../V7_THE_GAME.md) —
read it first, it is the epoch's truth). Round 30 opens **v7.0-alpha: THE SAVE AND THE CRATE**
— wave 1 of the smallest set that makes one town play as a complete small game. *(Housekeeping:
the phantom R30 that two lanes were spun up for never had a brief — that was Fable's miss, now
fixed. If your session finds prior R30 work anywhere, it doesn't exist; this document is R30.)*

## The ledger (v7.0-alpha wave 1)

1. **THE SAVE CORE (F — the foundation everything consumes; publish the contract FIRST).**
   - `web/js/world/save.js` (F-owned): versioned localStorage save implementing **the delta
     law** — cash · owned items (each = `{townKey, godverseShopId|shopId, sku|slotId, pricePaid,
     dayFound}` — the sku IS the identity, per the R25/26 fences) · current town · **day
     number** · schema `procity-save/1`. Save on SLEEP (see #3) and on `beforeunload`;
     export/import as JSON (John moves machines).
   - **The published contract** (`window.PROCITY.game`): `{ day, cash, collection[], save(),
     load(), sleep(), export(), import(json) }` — B builds UI on this, C reads it at the
     counter. Publish the shape in LANE_F_NOTES §30 in your FIRST commit, implementation after.
   - **Laws wired from birth:** `?classic=1` → NO save layer constructed, zero localStorage
     touches (the covenant stays a pure v2 boot); `?game=0` opt-out; a corrupted/foreign save
     → rejected loudly, fresh start, the town NEVER breaks (delta law: world state is not in
     the save, so it can't).
2. **THE SELL COUNTER CONTRACT (C — publish first, implement second).** Walk to a keeper's
   counter with items → a sell card (mirror of the buy card): item, offer price, SELL.
   **Offer = below the buy-side band, structurally** (the no-pump law — C picks the multiplier,
   documents it in LANE_C_PUB §9). v7.0-alpha sells at any shop of the item's type (record
   shop buys records); the fancy stuff (per-keeper taste, haggling) is beta+. C consumes
   `PROCITY.game.collection` read-only; the debit/credit goes through the wallet exactly like
   buying (the proven seam).
3. **SLEEP = SAVE = TOMORROW (F + B).** v7.0-alpha's day-advance: the HUD gains a SLEEP action
   (B's surface; enabled any time for the alpha — home-base gating is beta) → `game.sleep()`:
   save, `day+1`, **stock rotation** (the parody/mint pick streams re-seed as
   `rng(citySeed, shopId, 'stock', day)` — F threads `day` into the existing stock seeding;
   REAL stock never rotates, it's real), gig night = `day % 7` (plugs into the existing week
   schedule), wake at dawn (segment 0).
4. **THE COLLECTION UI (B — after F's contract lands).** A collection panel in hud.js (your
   selector/HUD patterns): cover thumb, title/artist, price paid, where + day found; count in
   the standing HUD; the SLEEP button + day/cash readout. Money-shot-grade is beta; readable
   and correct is alpha.
5. **THE GATES (F, last).**
   - **Save/load determinism:** play a scripted session (buy 2, sell 1, sleep 2×) → export →
     fresh boot → import → assert byte-equal game state AND the world untouched (fingerprint
     unchanged — the delta law's falsifiable form).
   - **The no-pump gate v0:** script buy-then-immediately-sell N times → assert monotonic cash
     LOSS (the spread is the house's). The full adversarial playtest-bot is beta.
   - **Classic purity:** `?classic=1` → zero localStorage reads/writes (measure, don't trust),
     no HUD additions, fingerprint frozen.
   - **Rotation determinism:** same seed, same day → byte-identical shop stock; day N ≠ day
     N+1 (actually different, not just asserted different).
   - `qa.sh --strict --matrix` green throughout. **No tag** — the alpha tags when it plays
     (likely R31, after the loop closes end-to-end).
6. **A — the rotation boundary verify (small).** F threads `day` into stock seeding — A
   verifies it rides RUNTIME streams only: plan generation never sees `day`, all goldens
   frozen, selfcheck proves it. One note, one line. **D, E, G — rest** (E's guide-band bake
   and G's GodBay open in beta; D's rumors likewise. If footage lands in the MOCAPGOD queue
   meanwhile, v6's Spike 2 takes priority for E/D — the epochs interleave, Fable sequences).

## Laws

The charter's five (delta · no-pump · game-money · classic-pure · seeded-rotation) + everything
inherited. No goldens move this round (rotation is runtime; A verifies the boundary). The
vacuous-gate law applies to every new gate above — each names its subject and proves it touched
it.

## THE EXACT RUN ORDER

1. **Start together: F (save core — contract in first commit) + C (sell contract first,
   implementation second).**
2. **When F's contract is published: B (collection UI + SLEEP surface).** F continues
   (sleep/rotation threading) in parallel — disjoint files.
3. **When F + B + C are in: F gates (#5), A verifies the boundary (#6).**
4. Fable reviews; R31 charters the rest of the alpha (or its close, if it plays).

Waves: **[F, C] → [B, F-cont] → [F-gate, A]**. D/E/G rest unless footage arrives.

## WAVE-1/2 REVIEW NOTES (Fable, mid-round — the agents' reports are the record)

**RATIFIED — F's two amendments, both measured:** (1) gig night = **(day − 1) % 7** — the
brief's literal `day % 7` flips a fresh boot (day 1) off night 0 and breaks the R13 cover/band
gates before the first sleep; the brief was wrong, the measurement wins. (2) **sleep saves
AFTER incrementing** — disk always carries the morning you woke into.

**ADJUDICATED — the cross-lane 6 lines (F edited C's `interiors.js`/`layout.js` for the
`stockDay` salt):** SANCTIONED, this instance — because all three conditions held: the owner
reviewed and ratified on the record BEFORE the commit ("rides my own sub-stream discipline,
absent ⇒ byte-identical"), the edit is marked and cited in the commit, and it is minimal.
**Without all three, a cross-lane edit gets reverted on sight.** The law stands: write the
ask, not the edit — C folds the seam into LANE_C_PUB at its next session; carried to the
epoch retro as a process note.

**WAVE-3 INPUTS (bind these into the gates session):** the rotation gate must hash **vertex
data, not transforms** (F measured its transform fingerprint vacuous over batched parody
stock); C's money-pump **negative control** (an item minted into the collection without a
successful debit must be impossible — assert `recordFind` only fires on `wallet.buy` truthy);
the **E-key sell routing** (§9.4 dig → sell → shelf) is F's held item and lands in the wave-3
session BEFORE the gates run against it.

## ROUND CLOSED (Fable, at the wave-3 review) — **v7.0-alpha wave 1: COMPLETE, ALL GREEN**

Ten commits, five lane-agent sessions, zero holds, zero cross-lane incidents beyond the one
adjudicated. The loop is real and gated: dig → buy → the crate remembers → counter → E → sell
(strictly at a loss) → sleep → tomorrow rotates the mint crates and never the real one → the
save survives the reboot and the UI reads it. `qa.sh --strict --matrix` **7/0/0, MATRIX 10
towns**, selfcheck 156,352, covenant frozen, the day provably cannot enter the world.

**Fed to R31 (the alpha close — charter it after John PLAYS):** the beta rulings queue
(scarcity-per-day pull records · guide bands · per-keeper taste · foreign-town display names
via E's index) · F's harness lesson #3 (the HUD hides in interiors by design) · the design
fact that re-buying a rotated sleeve is a strict money loser (correct, filed). **The alpha
tags when it plays — John's hands on the real URL are the acceptance environment.**

## Standing

- **John — nothing blocks this round.** The deploy to digalot.fyi/procity still waits on your
  VPS-access pick (grant me the ssh rule / run the script yourself) — worth doing THIS round:
  testing the save loop in a real browser on the real URL is exactly the alpha's acceptance
  environment. And the MOCAPGOD queue still wants your footage whenever.
- **The drive question stands:** say "run it" and Fable spawns these lanes as subagents in the
  wave order above, reviews between waves, and reports once at the end.