> **Muju update, 2026-09-10:** §2.3 reflects v2.2 with doubled prices. Other

**Muju update, September 16, 2026:** Standard remains the default. The optional
[Phasing ruleset](https://github.com/ethancd/deevgames/blob/master/muju/docs/PHASING-2026-09-16.md) changes turn timing to actions,
mining, upkeep, then promotions and public committed summons. Arrivals resolve
next own turn or refund. Current AI/balance claims apply to Standard only.

> Muju measurements and planning discussion below retain their historical
> baseline; well, queue, hidden-economy and build-time claims are superseded.

# DeevGames — Game Design Dossier

*A synthesis of every game designed or built across two bodies of work — this repo and prior Ethan × Claude conversations — compiled to inform the design of the next game. Repo sources: specs, balance analyses, git history, the napkins (`.claude/napkin.md` and per-project napkins), and the project skills in `.claude/skills/`. Conversation sources are noted by date so they can be retrieved.*

*Updated 2026-07-19 after the repo consolidation: master now contains every game — the wave-2 projects (Might & Magic: Spire, Lution, Mythgarden, Leyline Garden, Rock Stars) are profiled alongside the originals, and the muju balance lab's findings are folded in.*

---

## 1. Portfolio at a Glance

### Repo projects — wave 1

| Project | Genre | Status | Signature idea |
|---|---|---|---|
| **Ninja Tanks** (2013, Rails/jQuery) | 2p simultaneous-action bluffing duel | Shipped at deevgames.com | Decoy/feint fog-of-war: your move and your bluff look identical to the opponent |
| **Blind Loyalty** / **Hex Strike** | Designed board games | Never implemented | Unknown — designs predate the repo's docs |
| **FORGE** (React/TS) | 2p card drafting/auction on an expanding grid | Playable hot-seat; no AI, no online | Counter-bid auction where the outbid player keeps their turn |
| **Muju Hono Tanka** (React/TS) | 2p Go × Chess × StarCraft on a 10×10 grid | Full rules + imperfect-info AI + **balance lab** | Three-phase turns (place → act → queue) + spawn-denial territory |
| **Oracle of Delve** (React/TS) | Mobile-first roguelike dungeon crawler | V0 combat prototype + Playwright e2e harness | Layout-invariance testing methodology |

### Repo projects — wave 2 (consolidated onto master 2026-07-18)

| Project | Genre | Status | Signature idea |
|---|---|---|---|
| **Might & Magic: Spire** | HoMM3-style roguelite ("one hero, no town") | Playable PWA: 3 factions, 3 acts, full combat + economy | Your army of creature stacks **is** your life bar |
| **Lution** | Self-expanding card game vs a live Claude opponent | Playable (local dev server); real matches on record | The deck grows itself: both players design a new card each round, and Claude **codes** them into the game |
| **Mythgarden** (Django + React) | Time-loop farming-sim RPG ("Stardew × Groundhog Day") | **Deployed** at mythgarden.ashkie.com (Fly.io) | Multiplicative score (koin × hearts) + loss-compensating luck |
| **Leyline Garden** (Phaser 3) | Cozy idle/automation — magical plants + delivery networks | Core loop complete, ~225 tests; polish items open | Carry-one-thing fairy + leyline mote-routing over a two-layer iso world |
| **Rock Stars** (geology-quiz) | Kids' flash-card/quiz app (geology + periodic table) | Working, shippable | Closed sets you can fully master; data-driven decks |

### Conversation projects

| Project | Genre | Status | Signature idea |
|---|---|---|---|
| **LUMENGRID** (Jul 2026) | Laser-routing puzzle, 2 worlds × 10 levels | Shipped as artifact | Bitwise-OR light mixing + machine-verified level solvability |
| **Lumen Works** (Jun 2026) | "Miniature Factorio" of light mixing | Superseded by LUMENGRID | Sandbox mode + multi-input combiner (didn't carry forward) |
| **Hexagon Maze** (Sep 2024) | Honeycomb sequence puzzle | Small component | Axial-coordinate hex rendering; origin of the "code me a puzzle" pattern |
| **Halflight** (Jul 2026) | Moonlighter-style delve-and-shop with decaying inventory | Fully art-directed; **standing request for a prototype** | Every gem has a condition-dependent half-life |
| **The Mage Ladder** (Apr 2026) | LLM-as-game-engine research ladder → text-only Mage: the Ascension | Ladder doc with per-rung validation tests | Intent parser → rules validator → paradigm-filtered narration |
| **Palimpsest** (Mar 2026) | Values-alignment game in Homestuck clothing | 4 prototype-ready mechanics scoped | Annotation: an actual LLM misinterpreting you *is* the gameplay |
| **Garden Guardians** (Jan 2026) | 2p co-op cozy deckbuilder for phones | Card list + verbs sketched | Combat-free threat management: nurture / guide / weed |
| **Resonance Roguelike** (Jan 2026) | Rhythm roguelike from Interaction Ritual Chains theory | ~2,500-word spec | Emotional energy as the resource of successful ritual sync |
| **Elemental Magic Chess** (Apr 2025) | Chess + elemental effects | Phased Canvas/Pixi plan | Standard chess underneath; presentation-layer novelty |
| **Dynamic Piece Strength** (Jan 2025) | Mechanic set, no game yet | TS interfaces drafted | Move-recency statuses: exhausted −25% / prepared +15% / rusted / energized |

Three arcs converge. The wave-1 repo arc: a 2013 server-authoritative Rails game with untested jQuery UI → modern client-side React games with pure-function engines, serious AI, and rigorous UI-geometry testing. The conversation arc: single-file artifacts that turned constraints into disciplines (solvability verification, bitmask engines) → ambitious designed-not-built briefs. Wave 2 fuses them: Lution *is* the LLM-native direction shipped; MMS *is* a full roguelite with the balance discipline industrialized; Mythgarden finally shipped a deployed, server-authoritative game; and the whole wave was built with multi-agent orchestration whose lessons are themselves now a reusable asset.

---

## 2. Repo Project Profiles — Wave 1

### 2.1 Ninja Tanks (legacy Rails site)

A two-player, simultaneous-action, hidden-information artillery duel wrapped in a full community site (Devise auth, one-click guest accounts, admin blog, nested comments, PvP matchmaking queue, PvAI).

**Core rules**
- Tanks on a 3-zone track (start at zone 2), 3-card hands; cards have value 1–3 and direction (forward/back).
- Turn phases: Draw → Play → Discard. Drawing more cards than your zone number causes overheating damage; drawing more than a *decoy's* zone shows **fake overheating** to the opponent.
- Each card can be played as **Move**, **Feint**, or **Fire**; two actions in one turn overheats you. Moves resolve before shots (deterministic ordering for simultaneous play).
- **Decoys**: after an arrow play, the opponent sees translucent ghost tanks for both possible positions — real move vs. feint are indistinguishable. Deception threads through every subsystem, including damage tokens that can be fake.
- Position-gated legality: `LEGAL_SHOTS = {1→[3], 2→[2,3], 3→[1,2,3]}` — where you stand determines what you can hit.
- Win at 6+ damage on the opponent's real tank (2 damage per hit; hits on decoys just remove them).

**Architecture lessons**
- Server-authoritative rules engine in Rails models, with a **dry-run validation pass** (`trial_move` on copied "paper tanks") that rejects illegal simultaneous-action combos before mutating state.
- The game's comment thread doubles as **action log + player chat** — cheap, replay-friendly, and narratively flavored ("X moves forward... or do they?").
- Heuristic AI (60% prefer-shot, otherwise random legal action) — pre-search-era; every later project raised this bar.
- Self-admitted gap: the jQuery client had no test coverage. The server logic was tested; the UI was not. (Oracle later inverted and fixed this.)

### 2.2 FORGE (Game 2 of the planned "AZAD MINOR" 4-game series)

Two players build tableaus by bidding astrological symbols (♂♀☿☽, 4 of each to start, **no income — a closed 16-symbol budget**) on cards in an **unbounded, purchase-driven expanding grid**. 82 cards across 6 factions + a neutral General pool; most VP is conditional and evaluated only at game end.

**Signature mechanics**
- **Counter-bid auction**: BUY at cost → opponent may counter at cost+1 → you may final-bid at cost+2. If the original bidder loses the auction, **they keep their turn** — the loser is compensated with tempo. This single rule self-balances the card pool: universally efficient cards get contested into mediocrity (Supply Cache falls from a 2.0 to 0.67 VP/symbol ratio when contested).
- **BURN as the alternative action**: free removal that leaves permanent RUINS blocking adjacency — denial becomes a *spatial* tool, and burn-payoff cards ("+1 per card burned", "+1 per ruins") make it an archetype.
- **Grid expansion**: buying a card flips its face-down neighbors and deals new cards adjacent to them — the market grows organically from where players act. Availability = board geometry, not a static row.
- **Cost composition as protection**: "any"-cost cards are easy for anyone to contest; faction-specific symbol costs are hard to counter-bid, so cost *shape* (not just size) signals contestability.
- **Conditional-VP-as-strings** (19 regex-parsed patterns) + an emojification layer (`★ x 🩸`) — flexible but fragile; a proper enum/DSL is the reuse recommendation.
- **Series hooks**: cards carry inert `game3Effect` combat abilities; the tableau is designed to carry forward as an army into Game 3 *Skirmish*. Games 1 (*Snatch*) and 4 are unbuilt.

**Balance analysis verdict** (docs/BALANCE_ANALYSIS.md, using the strategy-mindset framework): well-balanced, with explicit **triangularity** — High-Efficiency loses to Counter-Bidder loses to Synergy Player loses to High-Efficiency. All archetypes land in a 45–55% win band. Naive "vacuum" ratio analysis was shown to be misleading; contested and synergy-adjusted ratios told the real story.

**Also notable**: a complete **skin architecture** (React context + CSS variables + localStorage + parallel art folders + full card-name remapping) that flips the entire game between "dark cosmic horror" and a kid-friendly cartoon identity without touching mechanics. 66 AI-generated artworks per skin; cost tier drives composition grandeur.

**Gaps**: no AI opponent, no animations, no multiplayer, no series integration. Recent master work was minor UI polish only (card titles wrap at a readable size instead of expanding tiles; modal backdrop-click closes; RUINS cells render diagonal X-lines instead of a text label).

### 2.3 Muju Hono Tanka: Elemental Tactics

Two players occupy opposite corners of a 10×10 grid, combining territorial
control, tactical combat and an economy. Modes are vs AI, pass-and-play and
AI-vs-AI. Tier-1 purchases cost 3/4/5 by element pair, with 4/8 promotion
steps. Muju has two phases: **Place** (public tier-1 purchase and later-turn
promotion), then **Act** (four shared move/attack actions).
Every owned unit collects up to its Mining stat from its square at turn end.
The v2.8 Unequal routes map holds 0/4/8/16 reserves, 504 total: six 8-crystal
home squares per player and two four-square expansions holding 16 each. Plant
Mining is 3/5/8. Existing games keep their stored maps with the current catalogue.

Anchor rectangles, blocked entirely by any enemy inside, connect positioning
to spawning and home defense. Units act immediately after purchase or
promotion, but a newly bought unit cannot promote that turn. Each existing
unit may climb one tier per own turn, paying the cost difference. The exact
18-unit catalogue is defined in `muju/src/game/units.ts`. The elemental triangle,
Cleave, owner-turn healing, and upkeep remain; ten player turns without an attack
kill draw. Black may receive an optional 1–20 starting-crystal handicap. First-player rush strength under the combined rules remains
an open design question.

Both banks are public. The AI uses public-state MCTS and beam/placement plans;
its observation/belief/re-determinization layer is removed. A cancellable
browser worker runs bounded tactical WASM with a JS fallback. General purchases
are planning candidates, outside the exact tactical proof. The static solver
finds distinct profiles and sole-cheapest local task witnesses for all 18 units;
this does not establish whole-game balance.

The balance lab supplies seeded playouts, invariants, replays and income/
purchase/promotion telemetry. Earlier win rates in this dossier describe
historical well/queue rules and do not transfer to the simplification. See
`muju/SPEC.md` and the September 9 mining/placement reports for the current
branch, verification and registered future comparisons. Production release status is recorded by the repository’s publishing workflow.

### 2.4 Oracle of Delve

Mobile-first portrait roguelike: descend ~10 rooms, turn-based elemental combat, draft 1-of-3 gems between rooms, hard/easy path choice gates gem rarity, boss at room 10, 5–10 minute runs. Inspirations: Slay the Spire (draft + paths), Into the Breach (visible turn timeline), Pokémon (elemental weakness/resist), Hades/Downwell (pace/format).

**Designed but unbuilt**: speed-based visible turn timeline with **hidden enemy intent** (you see *when* they act, not *what* they'll do); three attack archetypes (basic / charged / status: Freeze, Burn, Slow); Fire/Ice/Lightning ±50% weakness system; **stat-mod-first → synergy-later gem progression**; path-gated rarity tables (Easy 70/25/5, Hard 40/40/20, Boss 20/40/40); clean scaling formulas.

**Built**: V0 only — one fixed encounter, fixed turn queue, tap-to-attack, win/loss/restart — as a clean immutable pure-function combat engine. Recent master work converted inline styles to Tailwind and added the first **Playwright e2e harness** (a 200-line `combat.spec.ts` pinning the combat screen's full contract: HP displays, attack flow, damage floats, defeat states).

**Its real deliverable is the testing methodology** (LAYOUT_STABILITY_REPORT.md, VISUAL_REGRESSION_TESTING.md, generalized in `.claude/skills/layout-invariance.md`): geometry-first CSS with reserved slots for conditional content; tests asserting on `getBoundingClientRect()` pixels rather than class names, written to fail first; Vitest Browser Mode + Playwright screenshots with committed baselines (jsdom's 0×0 rects pass falsely); explicit overflow policy for every dynamic text region; design for hostile inputs.

---

## 3. Repo Project Profiles — Wave 2

### 3.1 Might & Magic: Spire

A roguelite deckbuilder that "files the serial numbers off HoMM3": *one hero, no town; your army of creature stacks is your life bar; you grow on a node map.* A Slay-the-Spire-style cards/energy prototype was built first and **deliberately retired** mid-project in favor of HoMM3-style army battles — a documented, bold pivot. Target platform: installable offline-first mobile PWA ("Add to Home Screen is the whole distribution story").

**Core loop**: pick a faction hero → climb an upward DAG "Spire" map where **1 node = 1 day** and acts are whole weeks (`ACT_WEEKS=[3,2,1]`) → fight guarded tiles (~45% guarded, portraits match the actual fight) or claim free bonuses → grow via Necromancy, Dwellings, Altars, Shrines, Merchants, and the weekly **Muster** (a multi-buy reinforcement shop on each week's first node — the boss always lands on a Monday, so Muster falls right before every boss) → beat the Act-3 boss. Runs are fully deterministic from a seed.

**Combat spine**: two ranks (front melee / back ranged); shooters hit any rank with no retaliation (strongest profile); flyers reach the back rank but eat retaliation; retaliation is budgeted per round (Griffin 2, Royal Griffin unlimited). Damage uses the HoMM3 A/D curve (+5%/pt attack advantage capped +300%, −2.5%/pt defense capped −70%) against a stack HP pool with kill-chipping. The hero's Attack/Defense add flat to the whole army, so +Attack compounds with stack size. **The enemy intent function drives both the telegraph and the executed action — the telegraph can never lie.**

**The stat trinity** (late redesign): speed → **dodge** (5%/pt, cap 25%, half damage), luck → **crit** (×1.5, same curve), morale → **bonus/frozen actions** — with an elegant **undead neutral-lock** (any "no morale penalty" stack pins the army's morale to 0, so all-undead Necropolis leans on luck instead).

**Growth engine**: Necromancy is the only no-gold compounding growth — `raised = floor(slainHp · pct / 6)`; tuning history is instructive (at the initial 0.10 guess the army *deflated* and win rate was 0%; 0.30 makes a rank-1 hero net-recover). Content scale: 42 creatures, 68 spells, 67 artifacts, 46 heroes, 163 real scraped images, 3 playable factions (Necropolis / Castle / Stronghold) whose dumb-bot win rates land in-band without per-faction tuning. Single constants can be load-bearing: capping boss Bone Dragons at 2 moved greedy-bot win rate **4% → 59%**.

**The balance apparatus** (the project's most distinctive contribution — four documents in evolutionary order):
1. **BALANCE_PROPOSALS.md** — an audit of the original engine tracing every "INERT" verdict through real code (8 of 17 artifacts dead, 9 of 14 abilities pure flavor, Blind "the single most broken spell"), then framing the redesign as a **constraint-satisfaction problem with three nested budget tiers**: LIGHT (additive only, no new subsystem), MEDIUM (one bounded status layer), HEAVY ("effectively a second engine"). It closes with six explicit open questions for the designer.
2. The LIGHT set shipped, plus a BATCH answering the open questions — including the **no-restack rule** (recasting the same stat-mod spell is a no-op; different spells still stack), which closes the buff-stacking exploit with zero new UI.
3. **BREADTH_ANALYSIS.md** — an **S–F ranking of imported content by naive power in the *current* engine** (not how it "should" work), which caught that Castle's imports arrive mostly broken (5 of 7 tier signatures inert) before they shipped, and identified the two cheapest high-leverage activations.
4. **MECHANISMS_AUDIT.md** — an "essentialize" pass giving every mechanism a **dual rating** (gameplay cruciality × thematic cruciality → KEEP / FIX / SIMPLIFY / MERGE / CUT), naming ~12 spine mechanisms and a dead-weight list, and proposing **one high-leverage investment (minimal initiative) that would retroactively justify ~6 already-shipped inert speed mechanics**. (The shipped speed→dodge change is a competing cheaper answer to the same tension — an open design question.)

**Architecture**: pnpm monorepo with a deliberate contract split — `schema` (Zod schemas + canonical fixtures as the keystone contract, built first), `data` (validated scraped content + a REPORT.md that turns silent data loss into flagged gaps), `engine` (headless, pure, seeded, no React — 700-line battle, 1900-line run; tests double as a win-rate-sweep tuning harness), `app` (mobile-first PWA). The app imports its engine only through a contract file, so mock and real engines swap on a flag. Balance philosophy: **every constant is a named lever** — "Ethan vetoes balance by editing the constant, the code reads the constant, tests re-validate."

**Built by multi-agent orchestration**: Phase 0 built the schema + fixtures, then four agents worked in parallel git worktrees (`researcher`, `infra`, `mechanics`, `frontend`) against the shared fixtures, merged through an orchestrator branch. Schema changes routed through the orchestrator; no agent could quietly add a field.

**Unfinished**: no initiative/positions/real AoE geometry (the four AoE nukes still resolve single-target — flagged traps), no spell-school immunity (every Dragon's signature inert), no creature spellcasting, no adventure-map layer; MECHANISMS_AUDIT's dead-weight cuts not yet taken; no live deployment.

### 3.2 Lution

A two-player Fluxx-style card game where **the deck literally grows itself between rounds using a live LLM**. The framing (from STRATEGY.md): *"The card game is the scoreboard. The design round is the game."*

**The loop**: play an inner tableau game to 10 points against Claude → after each inner game, both players **blind-simultaneously design one brand-new card** (the human in the UI; Claude via the Anthropic API) → the new cards are compiled/coded into the running game and become playable next inner game → a keep/steal resolution decides where cards land. Match is first-to-N inner wins. 47 cards currently in the registry across ~8 real played rounds (recorded in NEXT_CARDS.md).

**The "extinction engine"** (keep/steal v3 — the deepest strategic idea in the portfolio):
- The **loser** of the inner game decides: KEEP (each side adds their own design to their own deck — the only guaranteed-survival outcome) or STEAL (a two-pick raid: loser picks first from the winner's design or deck; winner counter-raids the loser's design or deck, minus the just-taken card).
- **Any design not kept or stolen is destroyed.** Picking an existing card *spurns* (destroys) the offered design. Taking a card type *you* created executes it — pure denial. Up to four cards can go extinct in one STEAL round.
- **Registry land-grab**: every effect ever registered — kept, stolen, executed, or spurned — is claimed forever and can never be designed again. Simple effects ("draw 1 card") are premium real estate claimed first; late rounds get baroque because the simple space is settled. If both players design the identical effect, both are voided and destroyed — idiosyncrasy is "collision insurance."
- **No-deixis rule**: card text may not reference creators, rounds, matches, or the real world — enforced mechanically *and* by an LLM semantic judge.
- The strategy guide's own summary: *"Design like a legislator: every law you write will someday be enforced against you."*

**The self-expansion pipeline** (five LLM entry points in `server/claude.ts`):
1. `designCard()` — Messages API (claude-sonnet-5, max_tokens 16000 because adaptive thinking shares the budget) with a prompt containing the full strategy guide, both decks, the complete registry including extinct types, round history, the 11 design rules, and a computed loser/winner **seat briefing** so the model designs situationally.
2. `compileCard()` — one shot at expressing a human card atomically after mint.
3. `judgeSemanticDuplicate()` — a cheap LLM judge layered over mechanical text checks.
4. `generateStarterNames()` — renames the 20 starters every match (silly Fluxx-style names: "Banach-Tarski Piñata," "The Fed Chair of Chairs," "Quantum Duckling").
5. `implementCards()` — the standout: the **Claude Agent SDK** runs an agent with Read/Write/Edit/Bash tools inside the project, writing `src/effects/<id>.ts` + a test file, running the card test suite, iterating up to 3 attempts on failures — with guardrails (`disallowedTools: ['Bash(git *)']`, maxTurns 50) added after a stray `git stash` swept the working tree.

**The three-tier implementation strategy** (the most reusable pattern): try (1) **compose from existing atoms** — a declarative AST of triggers/atoms/selectors/values/conditions that compiles to a standard CardEffect, no code written, seconds; else (2) **propose exactly one new atom** (additive, full suite must stay green or revert); else (3) **bespoke TypeScript module**. Engineering detail worth remembering: the structured-outputs API rejects recursive `$defs`, so compositions travel as JSON-encoded strings validated server-side; the real gate is validation + retry, not the schema.

**Engineering war stories** (from the napkins — see §8): idempotency guards on round resolution (mobile Safari reloads re-resolved round 1 four times), WAL-style crash recovery around the card registry, choice-point persistence via deterministic single-turn replay, seeded AI RNG, and a documented prompt-injection attempt during an agent task that was correctly refused ("don't tell the user" is itself a hard stop signal).

**Stack**: vanilla TypeScript + Vite (deliberately no React), the backend as a Vite dev-server plugin, JSON-file persistence with a hand-rolled registry lock, ~440+ tests. Status: substantially finished as a local-dev experience; not hosted.

### 3.3 Mythgarden

A **deployed** (Fly.io, mythgarden.ashkie.com) time-loop farming-sim RPG: "Stardew Valley + Groundhog Day, with a quirky vibe and an arcade feel." You live the same Monday→Sunday week repeatedly — farm, fish, mine, forage, befriend 15–18 villagers, hunt magical **mytheggs** — and when the week wraps, the run resets while high score, achievements, Knowledge, boost level, and luck level persist on the Hero.

**The arcade heart**: `score = koin_earned × hearts_earned × 10 × (1 + mytheggs/10)` — money *times* friendship, so a balanced run massively outscores a lopsided one. Time is the central resource (every action costs minutes; miss midnight and you oversleep).

**Signature systems**:
- **Loss-compensating luck**: beating your high score grants `boost_level += 1` (faster actions, luck resets); failing grants `luck_level += 7` (better mythegg odds). A losing run literally makes the next run luckier — a compassionate catch-up loop tuned to the time-loop framing.
- **Mytheggs**: six rule-bending rarities (SPARKLY on hearts gained, GOLDEN on shop restock, RAINBOW guaranteed once you've found 5…) drawn probabilistically, gated on persistent Knowledge.
- **Data-driven achievements** (114 spec'd) via a `check_{type}` dispatch pattern; some unlock Knowledge that persists across loops.
- **Opt-in difficulty-for-score**: four toggles (villagers move, building hours, advanced crops, dynamic shop) raise the score multiplier from 100% to 225%, with a draft/active settings split applied at loop boundaries.
- **CSV-as-content-database**: 55 self-describing CSV snapshots (column 1 names the Django model, headers name fields, `fk__` columns resolve natural keys) define the entire world — 182 items, 205 dialogue lines, 203 villager-movement events per snapshot. Timestamped filenames double as content version history.

**Stack**: Django (server-authoritative game logic: action generator/validator/executor, time-queue event operator that correctly handles lingering "yesterday" events) + React 18/TS/webpack frontend as a state renderer; SQLite; Docker + GitHub Actions with automatic staging deploys posting preview URLs on PRs. Three specs (toast message center, settings menu, unclaimed-achievement progress bars) mark the current polish frontier — settings partially wired, the other two unbuilt.

### 3.4 Leyline Garden

A cozy mobile-web idle/automation game: a fairy grows magical plants and builds **leyline** delivery networks across a two-layer isometric world (24×16 diamond grid; Surface + Underground connected by holes the player digs). Phaser 3 + Vite + strict TS, ~225 Vitest tests, 100% procedurally generated pixel art.

**Signature mechanics**: a strict **carry-one-thing constraint** (one resource or seed at a time) makes automation the whole game — you graduate from hand-carrying to drawing 8-directional leylines along which resource **motes** travel (2 tiles/sec, delivery priority chain, stall-if-unaccepted, global 200-mote cap). **Source plants** emit free motes; **transmute plants** consume two accumulated inputs to emit an output — production chains à la mini-Factorio. Weather (sun/rain feeding), a day/night lighting cycle, escalating seed-cost ladders, an endgame Portal sink, and **idle/away simulation** (24h cap, welcome-back summary) round out the loop. Architecture is a clean `src/sim/` (pure engine) vs `src/phaser/` (rendering) split with a pub/sub bridge to a vanilla DOM UI.

**Process contribution**: `.claude/game-dev-context.md` — a shared context file every specialist agent reads before changes and updates after, containing a z-depth hierarchy table, a file-ownership map, and an **"Established Patterns — DO NOT violate"** list encoding hard-won conventions ("if the user says 'make X glow', move the sprite above the lighting overlay — don't add a decorative circle"; iso glows are 2:1 ellipses; feed timing uses the emit-tick counter, not a separate ms timer).

### 3.5 Rock Stars (geology-quiz)

A tablet-friendly, offline, no-backend quiz app for kids — "closed sets you can fully master," states-and-capitals style. React 18 + Vite, fully data-driven decks (Mohs hardness, mineral formulas, geologic time, rock families, ores & metals) with a flexible schema (reversible decks, images, crystal-form rendering, sub-group tag filtering). Training mode (flip cards) and Test mode (multiple choice with same-deck distractors, review list, per-deck/direction best scores in localStorage, crown at 100%). Has quietly grown a whole **periodic-table subsystem** (element tiles, gauntlet modes, celebrations) beyond the documented decks. Images fetched from Wikimedia Commons by script with a manifest + credits file. Household-utility genre: the "games for the kids" lane the player profile asks for, shipped cheaply.

---

## 4. Conversation Project Profiles

### 4.1 Built & playable

**LUMENGRID** (July 2026) — Laser-routing puzzle game, React single-file, mobile-friendly blocky aesthetic. Players route colored beams through mirrors, splitters, and filters to illuminate sockets requiring exact RGB combinations.
- **Engine:** additive light mixing as bitwise OR on color masks (R=1, G=2, B=4). Beams rendered in SVG with screen blend mode so overlapping red + green visually reads yellow.
- **Content:** two worlds × ten levels. W1 teaches mirror rotation, drag repositioning, mixing, filters, splitters, linked toggle-mirrors. W2 introduces composite glass (amber/cyan/magenta two-channel filters → subtractive logic), poison-beam deflection (overfed sockets; the solve is diverting excess color), and swap-drag in tight spaces.
- **Tooling worth stealing:** all 20 levels machine-verified with a standalone Node.js engine script proving each level solvable from its solution sequence and *not* pre-solved from its start state. This verifier pattern generalizes to any deterministic puzzle game.
- **Status:** shipped as artifact; later patched to unlock W2 from the start.

**Lumen Works** (June 2026) — LUMENGRID's predecessor: a "miniature Factorio about combining primary colors of light." Grid-based, live beam simulation, mirrors/prisms/combiners, exact-color targets (over-mixing is not a valid solve). Five levels plus sandbox. Dark synthwave lab aesthetic. Superseded mechanically by LUMENGRID, but the **sandbox mode** and the **combiner** (multi-input, rotatable output) didn't carry forward — both are still worth mining. (Leyline Garden has since independently built the mini-Factorio idea into a full game.)

**Hexagon Maze** (Sept 2024) — Small React component: honeycomb grid, click cells in numbered sequence. Origin point of the "code me up a puzzle in React" pattern; mechanically thin but the axial-coordinate hex rendering code exists.

### 4.2 Designed, not yet built

**Halflight** (July 2026) — *closest to a ready brief.* Fictional 2020s indie game invented from a riff on dollar purchasing power as radioactive decay. Studio: Glowworm Games. Fully art-directed (pixel-art fold-out poster: decay-map taxonomy on the front, biome/gem-concentration world map on the back, Tunic-manual energy).
- **Core loop:** Moonlighter-style — delve for gems by day-equivalent, run a shop with them, except every gem has a condition-dependent half-life. Inventory literally decays.
- **Named mechanics:** decaying inventory, heat/critical mass (stacking hot gems is dangerous), decay-as-mana (spend a gem's remaining decay as a casting resource).
- **Explicit standing request:** a playable React prototype of the core loop. This is the one project where the ask is already on file.

**The Mage Ladder** (April 2026) — An LLM-as-game-engine research program disguised as a prototype sequence. Target: a text-only Mage: the Ascension engine where the LLM parses free-text intent, validates against Sphere mechanics and local Consensus Reality, scores Paradox risk, and narrates through each character's paradigm filter — two players in the same scene see different realities.
- Ten prototypes from **0.0.1** (coin flip + narrator: one bit of player agency, one bit of entropy, does the narrator make it *matter?*) up through D&D-rules text game (0.0.9) to full MtA (0.1).
- A markdown ladder document exists listing, per rung, the software systems to build and the validation tests each must pass.
- Core validation question: can a player try something the designer never anticipated, have it adjudicated consistently, see persistent world-state change, and feel they *discovered* an interaction? Failure modes named: yes-to-everything narrator, tyrannical reviewer.
- Needs: structured world-state, an intent parser/validator split, lightweight NPC agent loops. Explicitly does *not* need graphics, physics, real-time, or content volume.
- **Wave 2 changes this brief's economics**: Lution has already shipped the hard infrastructure — live Claude API calls in a game loop, LLM-as-judge for rule enforcement, structured-output wire constraints, agent-written code with guardrails, and validated declarative ASTs as the LLM's target language.

**Palimpsest** (March 2026) — A values-alignment game wearing Homestuck mechanics, with a GDD written to read like its own subject matter (revisions bleeding through the text). Four prototype-ready mechanics were scoped:
- **Layerlink** — chat with two revisions of the same character simultaneously; one degrading, one who doesn't know you.
- **Peeling** — scrape layers off objects/scenes to expose earlier revisions, paying a Fidelity cost.
- **Personality parser** — constrained natural-language exploration where the parser itself has character.
- **Annotation** — write messages to "the Author" and watch an actual LLM misinterpret them; the alignment gap is the gameplay.

**Garden Guardians** (Jan 2026) — Two-player co-op deckbuilder for phones, designed to play with your spouse in 10–20 minute turn-based sessions around the kids. Aeon's End / Battle of Hogwarts lineage, but deliberately combat-free: fairies tending a garden with illusion and misdirection rather than attack/damage.
- Three fairy actions: **nurture** (grow/heal plants), **guide** (redirect animals), **weed** (remove growth-slowing weeds).
- Sacrifice economics: plants that won't fully mature can be fed to animals to protect higher-value crops.
- First-prototype card list already sketched. Design note from the session: weeds beat pests into prototype 1 because they're the most intuitive garden threat.
- (Leyline Garden now occupies adjacent cozy-garden territory single-player; Garden Guardians remains the *two-player co-op* slot.)

**Resonance Roguelike** (Jan 2026) — Randall Collins' Interaction Ritual Chains theory rendered as a rhythm roguelike: geometric shapes grow through social encounters staged as musical synchronization challenges. A ~2,500-word spec exists. The theoretical spine — emotional energy as the accumulating resource of successful ritual sync — is the distinctive part.

**Elemental Magic Chess** (April 2025) — Chess with elemental visual effects and interactions; a full phased plan exists for a 2D Canvas/Pixi.js browser prototype. Standard chess underneath.

**Dynamic Piece Strength** (Jan 2025) — Tactical board game mechanic set: pieces strengthen or weaken based on move recency. Status taxonomy — **exhausted** (just moved, −25%), **prepared** (waited, +15%), **rusted** (idle too long), **energized** (power-up). TypeScript interfaces drafted. A mechanic in search of a game; pairs naturally with Halflight's decay theme — and with Muju, where move-recency statuses would slot into the existing action-step economy.

### 4.3 Adjacent material

- **D&D campaign (ongoing, July 2026):** solo theatre-of-the-mind 5e with Claude as DM, tone "weird and wondrous." Methan the forest-gnome Wild Magic sorcerer, the Register, Saltstair. A live worldbuilding vein if the new game wants a setting rather than an abstraction.
- **Values-game and superintelligence-play threads:** recurring interest in games as vehicles for alignment intuitions (Palimpsest's Annotation, the Mage ladder's reviewer problem). Lution is the first shipped artifact of this thread — a game whose central opponent-relationship *is* an LLM designing under constraints.

---

## 5. Player Profile (constraints the new game should respect)

- Plays in **10–30 minute interruptible sessions** — family context; games must survive being put down mid-thought. (The repo has form here: schema-versioned localStorage in Muju/FORGE, full run persistence + stale-save tolerance in MMS, idle/away simulation in Leyline, loop-boundary resets in Mythgarden.)
- Sustained engagement comes from **system synergies and discovery-phase depth**: Balatro (100–200 hrs, then exhausted), Slay the Spire, Bloons TD6, Stardew, Hades 2. Loses motivation near completion; the discovery phase is the product. (Lution is a direct answer: a game whose content space *never* closes; MMS's tiered content unlocks and Mythgarden's knowledge/mythegg gating both stretch discovery.)
- Comfortable with abstraction and framework-heavy themes but also genuinely wants **cozy and non-combat** options for family play. (Wave 2 delivered two: Leyline Garden and Rock Stars — the latter for the kids outright.)
- Competitive gaming background; won't be scared off by mechanical density.
- **Fable-5-token-constrained** (napkin): delegate implementation milestones to Sonnet subagents against fully worked-out specs; the main loop is specs + review. Answers to rules questions often arrive as rule *changes* — treat them as spec deltas to implement, not option picks.

---

## 6. Reusable Mechanics Library

**Hidden information & bluffing**
1. Decoy/feint duality — real action and bluff rendered identically to the opponent, down to fake damage tokens (Ninja Tanks).
2. Hidden production queue + public income (Muju) — the asymmetry that makes honest AI belief-tracking tractable; now with matching honest UI ("???" resources + visible-spend-only counter).
3. Visible turn timeline, hidden intent (Oracle) — you know when, not what.
4. Honest telegraph (MMS) — one function drives both the displayed intent and the executed action, so the telegraph structurally cannot lie.

**Auction, market & meta-game dynamics**
5. Counter-bid with retained turn (FORGE) — desirable items tax themselves; losing an auction refunds tempo.
6. Cost composition as contestability signal (FORGE) — specific costs protect, generic costs invite contest.
7. Purchase-driven market expansion (FORGE) — the option space grows spatially from where players act.
8. **The extinction engine** (Lution) — loser-decides keep/steal, two-pick raid, spurn-destroys, creator-execution, permanent registry land-grab. The design layer becomes the real game; the card game is just the scoreboard.
9. Registry land-grab / design-space scarcity (Lution) — every effect ever created is claimed forever; simple effects are premium real estate, so late-game content gets baroque by economic necessity.
10. Collision-voiding (Lution) — identical simultaneous designs destroy each other; idiosyncrasy as insurance.

**Territory & economy**
11. Anchor-rectangle spawning + binary enemy-blocking (Muju) — one rule creates a whole territory game.
12. The well/rope layered-resource model (Muju) — depth-gated extraction as organic tech-gating.
13. Denial with permanence — free BURN leaving adjacency-blocking RUINS (FORGE).
14. Army-as-life-bar (MMS) — no per-fight HP resets; attrition on a persistent army makes combat a war of sustained value.
15. Compounding no-gold growth as a faction identity (MMS Necromancy) — with gold-fed Muster/Dwellings as the alternative sustain path for everyone else.
16. Calendar-structured maps (MMS) — 1 node = 1 day, acts = weeks, the reinforcement shop always lands right before the boss; time structure does pacing work for free.
17. Carry-one-thing constraint → automation as the game (Leyline) — the player's physical limitation is what makes building networks the core verb.
18. Source → transmute production chains with delivery-priority routing (Leyline) — mini-Factorio in a cozy skin.

**Time & decay as resources**
19. Decaying inventory with condition-dependent half-lives (Halflight) — holding value is itself a decision.
20. Decay-as-mana (Halflight) — spend a resource's remaining lifetime as casting fuel.
21. Heat/critical mass (Halflight) — storage layout becomes gameplay.
22. Move-recency statuses (Dynamic Piece Strength) — exhausted −25% / prepared +15% / rusted / energized.
23. Time-loop meta-progression (Mythgarden) — within-run state resets; score/knowledge/boost/luck persist; the loop boundary is also where settings changes apply.
24. Loss-compensating luck (Mythgarden) — a failed run raises next run's rare-drop odds; a compassionate catch-up loop.

**Combat & tactics**
25. Damage as temporary defense erosion (Muju) — combined attacks without HP bookkeeping.
26. Position-gated action legality (Ninja Tanks' LEGAL_SHOTS).
27. Deterministic simultaneous resolution ordering — moves before shots (Ninja Tanks).
28. Combat-free threat verbs (Garden Guardians) — nurture / guide / weed; sacrifice economics replace kill decisions.
29. Two-rank battlefield with role triangle (MMS) — shooters (any rank, no retaliation) vs flyers (reach-back, eat retaliation) vs front wall; retaliation as a per-round budget.
30. The 5%-per-point stat trinity (MMS) — speed→dodge, luck→crit, morale→action economy, all capped at 25%; plus the undead morale neutral-lock as a faction-defining exception.
31. No-restack rule (MMS) — recasting the same buff is a no-op, different buffs still stack; kills the stacking exploit with zero new subsystems.

**Puzzle & systems logic**
32. Bitmask channel mixing (LUMENGRID) — resources as bit flags; exact-match targets where over-delivery fails.
33. Excess-as-hazard (LUMENGRID's poison beams) — the puzzle inverts from "gather enough" to "divert the surplus."
34. Exact-color targets where over-mixing is invalid (Lumen Works).

**LLM-native mechanics**
35. LLM as opponent-designer with full strategic context (Lution) — strategy guide + seat briefing + registry history in the design prompt, so the model plays the metagame, not just the game.
36. LLM as live content compiler (Lution) — agent-written card code, gated by tests, with the three-tier atoms → new-atom → bespoke ladder.
37. LLM-as-judge layered over mechanical checks (Lution) — semantic duplicate detection, no-deixis paraphrase detection.
38. Intent parser / rules validator split (Mage Ladder) — free-text intent, mechanically adjudicated; failure modes: yes-to-everything narrator, tyrannical reviewer.
39. Paradigm-filtered narration (Mage Ladder) — two players in the same scene see different realities.
40. Annotation (Palimpsest) — an actual LLM misinterpreting the player *as* the gameplay.

**Scoring & progression**
41. End-game-only conditional VP with baseVP-0 engine cards (FORGE).
42. Stat-mods-first, synergies-later content roadmap (Oracle).
43. Path-gated rarity as the single risk/reward lever (Oracle).
44. Cross-game continuity hooks — inert fields a sequel activates (FORGE/AZAD MINOR).
45. Multiplicative score across two axes (Mythgarden's koin × hearts) — forces balanced play better than any rule could.
46. Opt-in difficulty-for-score-multiplier with draft/active settings applied at loop boundaries (Mythgarden).
47. Data-driven achievements that unlock persistent Knowledge (Mythgarden) — content scaling without code.
48. Emotional energy as an accumulating ritual-sync resource (Resonance Roguelike).

**Meta/UX**
49. Action log = chat thread with narrative flavor (Ninja Tanks).
50. One-click guest accounts (Ninja Tanks).
51. Full skin architecture — one codebase, multiple audiences (FORGE).
52. AI transparency surfaces — debug console + player-facing "AI Recap" (Muju); Lution's "see what your card became" code reveal and live forge-progress viewer are the same idea for generated content.
53. Sandbox mode alongside authored levels (Lumen Works).
54. Idle/away simulation with a welcome-back summary (Leyline) — respect for interrupted sessions as a feature.
55. Blow-by-blow battle playback including losses, with damage forecasts (MMS) — legibility as a retention feature.

---

## 7. Reusable Technical Assets & Engineering Playbook

**Standardized in the repo** (codified in `.claude/skills/` + napkin "Patterns That Work"):
- **Stack**: React 19 + TypeScript strict + Vite + Tailwind v4 + Vitest (browser mode) + Playwright is the house default — but wave 2 proved deliberate deviations work: vanilla TS (Lution), Phaser 3 (Leyline), Django + React (Mythgarden), pnpm monorepo PWA (MMS). Per-game dev ports: muju 3002, leyline 3003, lution 3004, geology-quiz 5191.
- **Architecture pattern proven repeatedly**: pure immutable game logic in `src/game/` or `src/sim/` or `packages/engine` (state in → state out, seeded RNG, headless), a thin hook/bridge layer, presentation on top. Trivially unit-testable, replay-friendly, AI-simulation-ready. Persistence via localStorage/JSON with schema versions and stale-save tolerance.
- **AI toolkit**: minimax/alpha-beta with optionality-based evaluation (perfect info); observation-split → belief-particles → beam-planner → ISMCTS (hidden info, Muju). Scale difficulty by search budget, never rules.
- **Balance toolkit — three tiers of rigor now exist**:
  1. *Analytical*: the strategy-mindset exploit-hunting pass (FORGE) — vacuum-fallacy-aware ratios, triangularity, 45–55% target bands.
  2. *Audit*: MMS's document ladder — INERT-verdict code tracing, the LIGHT/MEDIUM/HEAVY constraint-satisfaction budget, S–F naive-power ranking of imports *in the current engine*, dual-rated mechanism inventory (KEEP/FIX/SIMPLIFY/MERGE/CUT).
  3. *Empirical*: Muju's balance lab — headless seeded match runner, bot ladder + adversarial probe bots, Wilson CIs, engine-hash stamping, experiment configs, judgment log. The lab found real engine bugs (D13, D14) beyond balance numbers.
- **UI discipline**: layout-invariance (geometry-first CSS, pixel assertions, real-browser tests), ux-affordances checklist, and Lution's mobile patterns (100dvh flex shell with a docked hand strip outside the scroll region; tap-selects-then-confirm instead of tap-plays, to prevent fat-finger misplays).
- **Test discipline**: test-matching (read the implementation first); MMS's canonical-fixture pattern (one instance of every content record, schema-validated, shared by all agents so mocks can't drift); Oracle's Playwright contract specs.

**Proven in wave 2, ready to import:**
- **The three-tier LLM content pipeline** (Lution): declarative atom AST → one additive atom → bespoke module, with server-side validation as the true gate, JSON-string transport for recursive schemas, golden-gate migration rules (test assertions preserved verbatim; import mechanism may adapt), and MTG-style pre-execution snapshot semantics for multi-selector effects.
- **Claude Agent SDK as an in-game code generator** with explicit guardrails: `disallowedTools: ['Bash(git *)']`, maxTurns caps, test-suite gating, retry-with-failure-feedback. Any job agent with Bash needs negative constraints, not just positive instructions.
- **LLM API operational knowledge** (napkin Domain Notes): adaptive thinking shares max_tokens (budget 16000 for design-heavy calls); structured outputs reject recursive $defs and additionalProperties:true; always live-smoke-test schema changes — mocked tests can't catch wire constraints.
- **Contract-first multi-agent orchestration** (MMS): keystone schema + fixtures first → parallel agents in git worktrees, one branch each → orchestrator merges → play one full run end-to-end → dedicated design-doc-then-implement balance passes. Schema changes route through the orchestrator only.
- **Named-lever balance-as-data** (MMS): every formula constant documented as a tunable in one place; tests as the tuning harness; win-rate sweeps as acceptance criteria; load-bearing single constants (bossMaxDragons: 4%→59%) documented as "ugly but essential — don't touch."
- **CSV-as-content-database with a self-describing loader** (Mythgarden): git-diffable world content, timestamped snapshots as version history.
- **Seeded determinism end-to-end** (MMS runs; Lution's replay-based choice-point persistence; Muju's lab) — determinism is what makes idempotent resume, replay, and empirical balance all cheap.
- **Node.js solvability verifier** (LUMENGRID): prove every shipped level solvable-but-not-pre-solved; extends to procedural content ("every generated day's stock must be survivable"). Still not adopted by any repo game — a standing gap.
- **Bitmask color/resource engine** + SVG screen-blend rendering (LUMENGRID); **hex axial-coordinate rendering** (Hexagon Maze); **single-file React game shell** for fast V0s.

---

## 8. Design-Process Lessons (the expensive ones)

1. **Settle the core interaction chart early — then measure before touching it.** Muju's element system shipped three different charts; the balance lab has since proven the current graph is *load-bearing* (removing one edge collapses a whole strategy from 88% to 2–4%) and that fixes belong in cost/build-time levers, not stats or the graph. The CLAUDE.md sync rule (spec, instructions, comments, tests, README all agree) exists because of this churn.
2. **One self-balancing rule beats a page of tuning.** FORGE's retained-turn auction, Muju's spawn-blocking rectangle, MMS's no-restack rule, Lution's loser-decides steal — each does more balancing work than any stat table.
3. **Build the measurement instrument; it pays twice.** Muju's lab produced balance findings *and* found real engine bugs (ID-collision teleports, ghost attacks). Measure-as-shipped before fixing, stamp datasets with engine hashes, report with confidence intervals, and flag coarse instruments as coarse.
4. **Machine-verify your content.** LUMENGRID's solvability verifier; MMS's schema-validated fixtures and win-rate sweeps; Lution's per-card golden tests gating LLM-written code. The un-verified path (FORGE's analytical-only balance) is the outlier now.
5. **Scope redesigns as nested budgets.** MMS's LIGHT/MEDIUM/HEAVY constraint-satisfaction ladder — contradiction-free tiers where each tier only adds primitives the lower ones deliberately avoided — is the reusable answer to "how much do we build?" Pair it with the **retroactive-justification lens**: find the one small subsystem whose addition makes many already-built inert mechanics suddenly matter.
6. **Audit imports by naive power in the *current* engine.** MMS's S–F ranking caught Castle arriving 5/7 inert before shipping. Content breadth outrunning engine breadth is a real failure mode; the substring-matching ability detector is its cheapest bug class.
7. **Essentialize on a schedule.** MMS's dual-rated mechanism inventory (gameplay × thematic cruciality → KEEP/FIX/SIMPLIFY/MERGE/CUT) is the anti-creep discipline; run it before adding, not after drowning.
8. **Docs lag reality in both directions; napkins drift too.** FORGE's README, the portal's "Fully Playable" Oracle label, a root-napkin claim of "enforced" rules that weren't in code ("trust code over napkin"), and geology-quiz's napkin belonging to a *different project entirely* (scaffold-copy orphan). Verify a context file belongs to and matches its project before trusting it; keep superseded rules visible under `[SUPERSEDED]` markers rather than deleting them.
9. **Scope specs into shippable versions and honor them.** Oracle's V0→V3, the Mage Ladder's rungs, Lution's M-milestones, MMS's phased orchestration — the smallest version that answers a real question. The failure mode remains FORGE's fully-spec'd, never-started Phases 2–4.
10. **Keep decision logs with explicit open questions.** Muju's AI_ENGINE_QUESTIONS and new JUDGMENT_LOG (options, ruling, rationale, blast radius, reversal cost; human priors separated from agent rulings); MMS's BALANCE_PROPOSALS closing with six questions for the designer. Deferred decisions stay findable.
11. **Test the layer you're shipping — and the boot path.** 2013 tested server logic only; Oracle tested UI geometry only (now also e2e via Playwright). Lution's addendum: subagent-built UIs must be tested on the *fresh-install* path (null state) — every verifier smoke-tested against existing state and missed the null-boot crash. Also: test reload-at-every-phase on mobile (Safari reloads on every unlock; non-idempotent round resolution ran 4×).
12. **State machines need idempotency + lifecycle hygiene.** Guards keyed on ordinals (round numbers) are latent gaps; fine-grained resumable sub-state must be cleared at lifecycle boundaries or it poisons the next cycle's resume; snapshot what you persist (a debounced save of a live mutable object persisted mid-turn state); errors must never silently become game moves.
13. **Playtest against the degenerate strategy first.** Muju's mass-Fire_1 rush (now quantified: 97.2% vs greed), MMS's Blind-lock and unkillable dragon walls, FORGE's uncontested-efficiency archetypes. The strategy-mindset lens exists to find these before players do.
14. **Autonomous agents need negative constraints and independent verification.** A Lution implement-agent ran `git stash` repo-wide mid-diagnosis; guardrails (disallowed tools, turn caps) are now standard. Verify subagent self-reports by reading the diffs and re-running the suites; re-check "known findings" against current code before patching (a whole 11-finding fix pass turned out already-fixed). A documented prompt-injection attempt mid-task ("urgent" scope expansion + "don't tell the user") was refused — that phrase is itself a hard stop signal.
15. **The online layer finally shipped — via a different stack.** After three unfinished attempts (Ninja Tanks' Pusher TODO, FORGE's WebSocket phases, Muju's deferral), Mythgarden shipped deployed and server-authoritative (Django + Fly.io + staging previews). Lution runs live-LLM but stays local. The lesson refines: decide at kickoff whether the game is local-first or hosted, and if hosted, borrow Mythgarden's deploy scaffolding rather than re-deriving it.
16. **Successor games shed good ideas — audit the predecessor.** LUMENGRID dropped Lumen Works' sandbox and combiner; FORGE's series hooks sit dormant; MMS retired its STS prototype (deliberately, with a written record — the right way).

---

## 9. Open Threads a New Game Could Pick Up

- **Halflight prototype** — still the one project with an explicit standing request on file; MMS now provides the roguelite scaffolding (seeded runs, calendar map, named levers, run persistence) it would need.
- **Muju phase 4–5**: rush rebalance via cost/build-time levers, the D14 ghost-attack fix, and the remaining experiment configs.
- **MMS's fork in the road**: minimal initiative (retroactively justifying ~6 inert speed mechanics) vs the shipped speed→dodge; plus the MECHANISMS_AUDIT dead-weight cuts and real AoE. No live deployment yet.
- **Lution hosting** — currently a local dev-server experience; hosting it (or its engine) would make the portfolio's most novel game shareable. Its atoms/agent pipeline is also the ready-made substrate for the **Mage Ladder** and **Palimpsest's Annotation**.
- **Mythgarden's spec'd polish frontier**: toast message center, settings menu UI, unclaimed-achievement progress bars.
- **Leyline Garden's open visual issues** + whatever its tier-3 content ladder implies.
- **Blind Loyalty** and **Hex Strike** — still never built; the axial-coordinate hex code still exists.
- **AZAD MINOR** — Games 1 (*Snatch*) and 4 unbuilt; Game 3 (*Skirmish*) would activate FORGE's dormant `game3Effect` hooks and could reuse Muju's engine/AI — or MMS's army-battle engine, which is arguably a closer fit now.
- **Oracle V1–V3** — the roguelike loop is fully specified and unbuilt, now with an e2e harness under it. MMS overlaps its territory substantially; decide whether Oracle remains a distinct (mobile-portrait, 5-minute, elemental) product or donates its spec to MMS.
- **Lumen Works' orphaned sandbox mode and combiner**.

---

## 10. Candidate Briefs

Three directions from the conversation history plus one repo-native option — all re-costed after wave 2. Pick one or hybridize.

**A. Halflight: the prototype.** The standing request. Decaying-gem inventory, shop loop, heat/critical mass, decay-as-mana; dynamic-piece-strength statuses slot into gem states; a shop day is a natural 10-minute unit. *Wave-2 re-costing: substantially cheaper than before.* MMS supplies the run structure, seeded determinism, named-lever balance harness, and PWA shell; Mythgarden supplies the shop/day-loop and multiplicative-score thinking; the LUMENGRID verifier discipline applies to procedural gem-batch generation ("every day's stock must be survivable"). The main new build is the decay simulation itself.

**B. Climb the Mage Ladder.** Build rungs 0.0.1–0.0.4 as a real repo: coin-flip narrator → stats → persistent world-state → rules validator, each rung's validation tests as actual test files. *Wave-2 re-costing: Lution already shipped the hard parts* — live Claude calls in a game loop, LLM-as-judge, structured-output wire constraints (recursive-schema workaround, token budgets), agent-written content gated by tests, and a validated declarative AST as the LLM's output language (the atoms architecture is a working model for "Sphere mechanics as a validator"). Ninja Tanks' dry-run validation and Lution's idempotency/lifecycle lessons are the same shape as the intent-validator problem. Palimpsest's Annotation is a natural side-quest on the same infrastructure.
**C. Garden Guardians, digital.** The two-player cozy co-op deckbuilder for phones. Card list and verbs exist; missing the turn engine and a first balance pass. Highest household-utility-per-line-of-code. *Wave-2 re-costing:* Mythgarden proves the hosted server-authoritative path end-to-end (Django, Fly.io, staging previews) — the "online decision" no longer blocks on unknowns; Leyline covers adjacent cozy-garden aesthetics single-player, so this brief's differentiator is squarely the *two-player co-op* experience; Muju's pass-and-play remains the fallback mode. Rock Stars shows the family-audience lane ships fast when scope is disciplined.

**D. (Repo-native) Skirmish / Hex Strike.** A tactical-combat game activating FORGE's dormant `game3Effect` army-import hooks. *Wave-2 re-costing: two engines now compete for the job* — Muju's (grid tactics + imperfect-info AI + balance lab) and MMS's (army stacks, A/D curve, retaliation economy, faction chrome). An army-carrying tactical layer where FORGE tableaus become MMS-style creature stacks is now a mostly-assembly project. Optionally lands on the hex grid Hex Strike promised.

Cross-cutting recommendation, sharpened by wave 2: whichever brief wins, adopt the **three-tier balance toolkit** (strategy-mindset pass at design time → MMS-style mechanism inventory at content lock → a Muju-style headless lab once the engine is pure and seeded), and keep the **napkin + judgment-log discipline** from day one — wave 2's velocity came from orchestrated agents, and every one of its expensive lessons was a coordination or verification lesson, not a design one.

Open question, deliberately left to the project kickoff: whether the new game is *for you* (A or B), *for the household* (C), or *for the studio's existing universe* (D).