Files
claudeanderic dbb89ce9c5 Night 2: 40-card Magic-style duel, PvP with owned decks, polite Wikimedia client, Android mining (#23)
Night 2 (2026-11-17), from the `claude/wikideck` fork's `night/2026-11-17` branch. It follows Night 1 (#22).

## What's in it
- **Duel engine** (fork #72, #80): 40-card decks of cards you own, Notability/Citations, keywords, effects T1–T12, Connected, a hidden-information-safe `viewFor`/`logFor`, and replay. Balance v1 tuning (#84) gives the first player about 51%.
- **Card profiles** (#70, #82): Figure, Location, Event, Institution or Doctrine, plus stats, keywords and rules text, all derived from real article data. Templates only.
- **Design and story** (#66, #69, #83): DUEL_DESIGN.md, plus the match log and the encyclopedic "Battle of X (2026)" recap.
- **PvP** (#74, #77, #81, #76, #85):
  - The server checks ownership, and 40-card eligibility is enforced.
  - Modes: Classic (ranked), Draft and Trending.
  - Invites, quick match, Elo, a ladder and recap pages. Online matches render on the duel board.
- **Duel board UI** (#79): MTG-style card faces and combat declaration, built for 360 px first.
- **Polite Wikimedia client** (#73, #75): throttled, cached and identified requests, the mint-path fix, and a prefetch pool.
- **Android mining** (#78): native RandomX, as a sideload build. The emulator mined a testnet block.
- **Testnet ops** (#67, #68).

PR numbers refer to `claude/wikideck`.

## Status
- **Tests:** 423, of which 422 pass, 0 fail and 1 is skipped. The build is OK (`node:24-alpine`, `--network none`).
- **Testnet:** running this commit (036489c) on r350.
- **Untouched:** no changes to `server/testnet/consensus.ts`, `randomx.ts`, `native/` or the mainnet compose.
- **Review:** night-review reviewed fork #66–#79. #80–#85 came from the agents' unfinished branches and were not reviewed.
- **Known gaps:**
  - The PvP end-to-end test hasn't been run (it needs two eom.dev accounts).
  - Bot matches aren't reachable from Play.
  - Card identity pre-bake hasn't been done.
  - The RandomX verifier latch (`server/testnet/randomx.ts:140`) is still open.

This PR is for Eric to merge.

🤖 Generated with [Claude Code](https://claude.com/claude-code)Reviewed-on: WikiDeck/wikideck#23

Co-authored-by: Claude <claude@eom.dev>
2026-11-18 18:12:24 +00:00

24 KiB
Raw Permalink Blame History

Night 2 plan review: lead engineer (feasibility and scope)

Reviewed against wd @ 4f7a8a7 (upstream main with Night 1). Paths are repo-relative. docs/night/REPORT.md does not exist in this checkout, so Night 1 lessons come from HANDBOOK/BOUNDARIES and the coordinator's notes.

Verdict: the plan is feasible in 4.5 h if the duel engine is a new sibling package with no stack and sorcery-speed only, PvP stays on the self host, and the Wikimedia client is handled as transport-only for the mint path. Three facts change the plan:

  1. Owned cards cannot reach PvP today. The host never accepts a player deck (see §2).
  2. Card data is not trustworthy. Article and stats are claims made by the miner: consensus only checks internal consistency.
  3. The browser drives most Wikimedia traffic. Every card face triggers a server enrichment fetch.

1. Engine: reuse, rewrite, smallest change

Reusable as is:

  • shared/game/rng.ts (mulberry32, Rng.fromSeed, exported via index.ts:3)
  • the clone-on-apply pattern
  • the (ruleset, decks, seed, actions) replay contract: replay at engine.ts:433, applyAction at engine.ts:291
  • zod parseRuleset (ruleset.ts:83)
  • percentile/fame/costFor in derive.ts:52-79
  • the generated sample percentiles (card-data.ts, scripts/game-card-data.mjs)

The host is engine-agnostic through EnginePort (server/game/engine-port.ts:9-43), so a second engine plugs in with a new binding file instead of host surgery. Bots are also engine-agnostic (shared/bots/types.ts EngineAdapter, with toAct, assume and evaluate), and a sequential duel fits that adapter better than Edit War does: game-adapter.ts:243 fakes toAct from committed.

Must be rewritten:

  • Everything lane- or Topic-shaped:
    • MatchState.lanes / LaneState (types.ts:136-170)
    • the simultaneous queue/commit/reveal turn (engine.ts:291-363)
    • Topic scoring (finish, engine.ts:366)
    • Portals and keywords (keywords.ts, 241 lines, hooks assume lanes and onReveal)
  • GameCard (types.ts:24-43): a duel card needs type, toughness, rules-text ids and flavour, and validateDeck (engine.ts:27) hard-codes cost 0–6, power 0–30, Faction and lane fields.
  • UI boards (src/game/MatchBoard.tsx, adapter.ts).
  • parseModeRuleset host checks (engine-binding.ts:31-43), which are Edit War-specific: turns × turnSeconds ≤ 240, topicCount.

Recommendation: build shared/duel/ as a sibling package and leave shared/game/ untouched.

  • Edit War stays playable: its 6 test files keep passing and its modes keep working.
  • Two engine agents don't conflict with anyone.
  • Duel exposes the same API names (createMatch, legalActions, applyAction, viewFor, replay, validateDeck, isOver, result), so EnginePort and EngineAdapter bindings are thin files.

Smallest core that still feels like Magic (one night):

  • Turn: start (untap, income, draw) → main → combat → end. No second main phase, no stack, no instants and no priority passing. Events are sorcery-speed only.

  • Triggers resolve immediately in a fixed order: active player first, then reveal seq, as Edit War's onReveal already does.

  • Resources: fixed income ramp, incomeByTurn as data (Edit War's energyByTurn idea, types.ts:70), with no carry. A Location is a permanent that gives +1 income. No land cards means no land screw.

  • Figures have power, toughness and summoning sickness; damage clears at end of turn. Institutions and Doctrines are permanents with ongoing statics (port the pure ongoing hook contract, keywords.ts:16). Life is 20 by default (data).

  • Actions must be atomic so that legalActions stays small. That matters because the host checks each action by deep-equal against the full list (host.ts:187-189), and the bots enumerate it:

    • play {cardId, target?}
    • toggleAttacker {id}, then confirmAttack
    • block {blocker, attacker}, then confirmBlocks
    • endPhase, concede, timeout

    Never enumerate whole block assignments, which explode combinatorially.

  • Empty library behaviour is data: libraryEmpty: 'lose' | 'reshuffle' | 'fatigue'. This keeps option (a), small decks with recursion, open with no code change.

  • legalActions is [] for the seat without priority. The host sweep already treats "has legal actions" as "is the one waiting" (host.ts:264), so timeouts work without host changes.

Determinism, rules-as-data, viewFor and information hiding all carry over.

  • Hidden information is simpler than in Edit War: there is no simultaneous hidden queue, only the hand and library order.
  • New requirement: logFor(state, seat). Edit War's viewFor returns no log at all (engine.ts:395-419). The plan's "dry encyclopedic match log" and the recap both need a per-seat log that masks the opponent's draw card ids.
  • Card typing (P31) and "Connected" are not on-chain, so they must be frozen into the deck at match start, exactly as the trend arrow is today (host.ts:318-334). Match records already store the derived decks (host.ts:361-363), so replay stays exact even if Wikidata changes later.
  • Other host limits: the host's 2000-action cap (host.ts:344) is fine for about 15 turns of atomic actions. MatchRecord needs an engine field.
  • Multi-engine host (about 15 lines):
    • ModeHost holds one engine (host.ts:53); change to HostedMode {mode, rules, engine} and Lobby.engine.
    • Add an optional engine: 'editwar' | 'duel' to ModeSchema (modes.ts:88, default editwar).
    • Caveat: the schema is .strict(), so un-upgraded peers will count duel modes as rejected in discovery. That is acceptable on the testnet.

2. "The cards a player owns": the trace and the gaps

Today's path:

  1. The client computes ownership itself. src/App.tsx:130 filters snapshot.blocks (from GET /api/state, http.ts:68 → legacySnapshot(limits.legacyBlocks)) by the browser-local wallet address.
  2. PlaySection gets owned (App.tsx:203) and merges cardFromBlock into the deck-builder pool (PlaySection.tsx:42). cardFromBlock derives in the browser, marks the card unchecked with its cost capped, and computes rarity from powHash client-side (cards.ts:39-46).
  3. Owned cards are used only in browser-local bot matches (MatchScreen).

Gaps:

  • G1. No player decks in PvP. ModeHost.join deals engine.starterDeck to both seats for every non-draft policy (host.ts:144). The constructed policy (modes.ts:64, which is also the default, modes.ts:99) is unimplemented: no create/join route takes a deck (router.ts:123-131). Ownership is therefore never verified server-side, because it is never used.
  • G2. Accounts are not wired to the game.
    • Linked wallets live in accounts.sqlite (server/account/store.ts:126-130), but nothing in server/game/ reads them.
    • gameRouter receives only {dataDir, enrichment} (http.ts:154), with no ledger and no account store.
    • The AccountStore is created privately inside createAccountRouter (router.ts:19), so it must be injectable to be shared.
    • The auth middleware is local to that router (router.ts:25-33); export it, or call verifyIdToken directly.
  • G3. Host identity is not the account. The player id is sha256(localStorage secret HMAC hostOrigin) (online.ts:161, host.ts:380), so a ladder keyed on it can be farmed trivially by sybils. Also, Authorization: Bearer is already taken by seat tokens with a 16–64 character regex (router.ts:98-101). Pass the Dex ID token in the body at create/join instead.
  • G4. Collection truncation. /api/state returns at most 128 blocks (server/resources.ts:20), so older owned cards silently disappear from Play. Use ledger.deck(address), paged by 24 (ledger.ts:293), or a new authed GET /api/game/collection.
  • G5. Chain card data is a miner claim.
    • The ledger accepts any peer-valid block. template() (ledger.ts:255) is advisory, and nothing binds a block to a node-issued template.
    • articleSchema (consensus.ts:43-56) does not cross-check pageId against title.
    • statsSnapshotSchema (consensus.ts:59-93) only checks internal consistency (deriveStats of the declared bytes, languages and views).
    • So a custom miner can mint "Barack Obama" with any stats. DESIGN §1.10 plausibility exists only as types: verifyStats and check: 'verified' are never read (no hits outside types.ts, ruleset.ts, engine.ts:22 and derive.ts).
  • G6. Per-node account stores. Peer hosts have their own accounts.sqlite, so a wallet linked on node A is unknown on node B. Sending a Dex ID token to a peer also lets that peer replay it on other nodes until it expires, since every node shares the wikideck audience.

Recommended (MVP, self host only):

  • Create and join take {idToken, deck: tokenId[]}. The host:
    1. verifies the token (verifyIdToken);
    2. loads wallets(sub) from the account store;
    3. for each token, checks ledger.nft(token) (canonical-index.ts:163): owner ∈ wallets and confirmations ≥ rules.minConfirmations (1 casual, 3 rated);
    4. builds CardInput from the block, never from client card JSON, then derives and freezes.
  • Put this in a new server/game/ownership.ts exposing a pure resolveDeck(deps, sub, tokenIds). host.ts calls it from startMatch.
  • Plausibility (G5), stretch:
    • Check pageId → title and revisionId → size with one batched request per 50 cards (prop=revisions&revids=…&rvprop=size|ids). Revisions are immutable, so the result can be cached forever and verifies pageBytes exactly.
    • Past monthly pageviews are also immutable, so they can be checked exactly at one request per card.
    • On a mismatch, the card is marked unverified and its cost is capped.
  • Peers (stretch): replace the ID token with a wallet-signed deck claim ["wikideck:deck-claim:v1", NETWORK, hostOrigin, nonce, tokenIds]. The client builds the message itself, like shared/account-link.ts. This needs no account on the peer and cannot be replayed on another host.

3. PvP: what exists, what's needed, transport

What exists:

  • server/game/host.ts: in-memory lobbies, snake draft, the turn timer and AFK handling via timeoutAction (host.ts:263-270), legal-action enforcement, live-lobby persistence across restarts (index.ts:205-226), JSONL match records with replayable audit (store.ts) and a W/L leaderboard (store.ts:64-68).
  • router.ts: rate-limited (router.ts:90-94).
  • UI: OnlinePlay.tsx is a lobby list (polled every 4 s), create/join, draft and a match board. It is reachable only from inside the Play section.

What's needed:

Feature Minimal design Files Size
Invite link createLobby({private:true}) is excluded from openLobbies (host.ts:108-112); the UI route /play/join/<lobbyId> works because the SPA catch-all serves index.html (http.ts:157), and join already takes an id host, router, OnlinePlay S
Quick match POST /modes/:id/quick joins the oldest open lobby within the rating window, else creates one; no separate queue structure host, router S
Rated ladder Elo (K=24, start 1200) per mode, keyed by account id, recomputed by replaying matches.jsonl in order at startup (deterministic, no new store); rated only when both seats are account-verified and rated:true in mode limits; Glicko-2 is not worth the night store.ts, host.ts M
Account seat identity idToken in the create/join body → player id sha256('acct:'+iss+sub); guests keep the secret but are unrated host.ts, online.ts S
Duel binding server/game/duel-binding.ts plus multi-engine HostedMode new file, host.ts S

Transport is polling: the client polls every 1 s (OnlinePlay.tsx:11, 45-50), with no WebSocket or SSE anywhere. It is adequate for a sequential duel: about 0.5 s average hand-off latency.

Three caveats:

  1. Cost. Each poll runs viewFor and legalActions and returns the full view. Add a monotonic version to the lobby and GET …?v=N → 204 when unchanged. Poll every 500 ms while waiting on the opponent and every 3 s otherwise.
  2. Do not long-poll under /api. RpcBudget caps the whole node at 32 active /api requests (resources.ts:17, applied at http.ts:54), so 16 matches holding long-polls would starve the node. Real push would need SSE mounted outside /api (a server/testnet/http.ts shared-hook change): a stretch only.
  3. Rate limits. Two humans behind one NAT, or QA agents on one machine, see 1 req/s × 2 against plays 240/min and the global 300/min per IP (http.ts:56). That is OK, but QA should not run more than 2 matches per IP.

4. Wikimedia politeness

Every call site (grep over server, src, scripts, shared and android; the browser never calls Wikimedia APIs directly, because CSP connect-src 'self' at http.ts:50 forbids it):

# Where Upstream Trigger Limits today
W1 server/wiki.ts:73-78 random() en Action API, generator=random ×10 mint template http.ts:122 ≤4 concurrent, 3 attempts, 3.5 s timeout, no 429/Retry-After, no maxlag
W2 server/enrichment.ts:134-138 load() metadata en Action API, pageids=1 getFresh at mint http.ts:123; get from /api/wikipedia/:id http.ts:93-98; TrendCache ≤4 active, 8 pending, then reject; in-memory LRU of 128 entries, 6 h TTL; errors cached 30 s
W3 server/enrichment.ts:148 pageviews wikimedia.org REST, monthly same as W2 same
W4 server/game/trends.ts:37-56 via index.ts:174-186 W2+W3 background, one page per 20 s about 8.6k requests/day steady if the queue stays warm
W5 browser: src/Card.tsx:24 → src/useEnrichment.ts:10 → /api/wikipedia/:id W2+W3 every card face rendered (collection, explorer, hero) per-tab cache 5 min; server limit is 60/min per client IP only, with no node-wide upstream budget
W6 scripts/night/card_sample.py:13-38 en API, Wikidata wbgetentities, REST daily views offline research 1 req/s, honours Retry-After, disk cache (its docstring says "~4 req/s"; the code does 1)
W7 browser <img> from upload.wikimedia.org (Card.tsx:28, CSP http.ts:49) CDN each render hotlinking; acceptable, but the plan should cache thumbnails or use pithumbsize

Likely cause of the Night 1 429: W5 fan-out (each grid page means N cards × 2 upstream requests, with a 128-entry LRU thrashing across users) plus W4, multiplied by several testnet nodes sharing one egress IP. Each node also uses the default UA, Wikideck/0.1 (experimental …) (wikimedia-user-agent.ts:4-5), which has no contact. That breaks the Wikimedia UA policy and is the kind of client that gets blocked first.

Design: server/wikimedia/client.ts, one process-wide WikimediaClient.

  • Rate: a token bucket per upstream host. Defaults (env-configurable):

    • en.wikipedia.org: 1 req/s, burst 2
    • www.wikidata.org: 1 req/s
    • wikimedia.org REST: 5 req/s
  • Concurrency: 1 in flight per host by default (WIKIDECK_WIKIMEDIA_CONCURRENCY). The Action API etiquette is serial requests.

  • Co-located nodes: document WIKIDECK_WIKIMEDIA_RPS=0.3 for nodes behind a shared IP (testnet compose).

  • Priority lanes, with a bounded queue (64):

    • mint: always first; the timeout starts at dispatch; the queue wait is capped at 15 s, and the miner tolerates it (30 s timeout, miner.ts:57)
    • interactive: on overflow, serve stale cache or 503
    • background: trends, P31, links, plausibility; dropped when the queue is full
  • maxlag: add maxlag=5 to every Action API request (en and Wikidata). Detect error.code==='maxlag' (HTTP 200 with a JSON error), wait for Retry-After (default 5 s) and retry at most 3 times. REST has no maxlag.

  • 429 and 503: parse Retry-After (seconds or HTTP-date), then pause the whole host bucket (circuit-open) for max(Retry-After, exponential backoff 2^n s with jitter, cap 10 min). Log once per pause and expose a counter in /healthz-adjacent ops output.

  • Batching:

    • pageids=/titles=/revids= up to 50 for cheap props: info, pageprops (wikibase_item), description, revisions|size.
    • P31 via wbgetentities&ids=Q1|…(50)&props=claims is heavy (Obama's claims alone are megabytes). Use wbgetclaims&property=P31 per entity (small, cached for 30 days), or one WDQS VALUES query per ≤50 QIDs.
    • "Connected" costs one request per deck pair: prop=links&titles=<≤50 deck titles>&pltitles=<same>&pllimit=max returns exactly the intra-set links. Cache it by the sorted pageId set.
    • Never batch langlinks or categories: their limits are shared across the batch, which forces continuation and changes languagesTruncated semantics.
  • Persistent cache: node:sqlite (already used by accounts; Node 24) at $WIKIDECK_DATA_DIR/wikimedia-cache.sqlite. Key = canonical URL with sorted params and without maxlag. Store the body, ETag and Last-Modified; send If-None-Match (REST returns ETags; the Action API mostly doesn't); serve stale-while-revalidate for interactive. TTLs:

    Data TTL
    metadata 24 h
    monthly pageviews until month rollover (already the rule, enrichment.ts:70); closed months are immutable
    P31 30 d
    links 7 d
    revision size forever
    random never

    Raise the 128-entry cap (enrichment.ts:51) once the cache is on disk.

  • UA: WikiDeck/<pkg version> (+https://gitea.eom.dev/WikiDeck/wikideck; <WIKIDECK_OPERATOR_CONTACT or PUBLIC_ORIGIN>) node/<ver>.

    • Keep WIKIDECK_USER_AGENT as an override, still sanitized as at wikimedia-user-agent.ts:8-12.
    • Warn at startup if there is no operator contact.
    • Update tests/testnet-user-agent.test.ts, which pins today's fallback strings.
  • Volume budget:

    • mint: 3 requests (≤5 with random retries)
    • match: 0 synchronous (cache-only at match start; unknown data means "no bonus" or a fallback type, as trends.ts already does)
    • per new card first seen: ≤1 batched metadata/plausibility share + 1 P31
    • per deck save: 1 links request
    • card-face render: 0 when cached

Consensus boundary (checked carefully):

  • Validation never touches Wikimedia. consensus.ts:43-93 is pure, and the only callers of wikipediaArticles and wikipediaEnrichment are http.ts:96, 122-123, 154. Throttling, caching and retry therefore cannot affect block validation or fork choice.
  • The mint template's content becomes immutable chain data. The client must be transport-only on the mint path:
    1. Keep W1/W2/W3 request params byte-identical: grnlimit, exchars=900, pithumbsize, cllimit=20 (no hidden filter, which feeds category() at wiki.ts:17), clshow=!hidden, cllimit=50, lllimit=500. They determine article.category, languageCount and languagesTruncated, and the percentile calibration. tests/enrichment.test.ts:42-52 already pins part of this; add a golden URL test for W1. Adding maxlag is safe because it changes only error behaviour.
    2. getFresh must bypass the persistent cache. snapshotStats stamps capturedAt = new Date() (shared/enrichment.ts:41), so cached data would be misdated.
    3. Existing bug that throttling would amplify. A 429/5xx on the pageviews call is swallowed into status:'unavailable' (enrichment.ts:145-164). On the mint path that permanently mints a card with attention: null. With the new client, mint must fail the template (503, the miner retries) on 429/5xx/timeout, and record "unavailable" only on a genuine 404 or no-data. Both outcomes are valid blocks, so this is template policy, not a consensus change; it needs one owner and a test.

5. Scope: 4.5 h, about 10 agents, one integration branch

Rules learned from Night 1:

  • No stacked PRs. Squash-merge makes every child PR conflict. Branch only from night/2026-11-17 after the dependency has merged.
  • Contracts first: shared/duel/types.ts and docs/game/DUEL_API.md merge by 22:15.
  • Node 24 everywhere (node:sqlite; the Dockerfile uses node:24-alpine). Check node -v before npm ci.
  • No new npm dependencies. The lead alone owns lockfile regeneration.
  • Test files: top-level tests/<team>-*.test.ts only (scripts/run-tests.mjs:7).

Workstreams (9 workers plus the lead; ✱ = touches a shared file, one line or a small edit):

WS Owner paths Delivers Depends on
A duel-core shared/duel/{types,engine,ruleset,index}.ts, tests/duel-core*.test.ts, docs/game/DUEL_API.md turn and combat engine, viewFor/logFor, replay; types PR by 22:15, alpha by 23:15 —
B duel-cards shared/duel/{derive,classify,effects,text}.ts, tests/duel-cards*.test.ts P31 → type table (from card-sample.json instanceOf, 236 cards), category fallback, P/T and cost curve, ≤8 effect templates, deterministic MTG-register rules text, flavour from article.extract A types
C sim-balance shared/bots/duel-adapter.ts, scripts/sim/*duel*, docs/game/DUEL_BALANCE.md greedy and MC bots on duel; win rate by type and faction; ruleset number tuning (data-only PRs) A alpha (23:15)
D wikimedia server/wikimedia/*, server/wiki.ts, server/enrichment.ts, server/wikimedia-user-agent.ts, tests/wikimedia-*.test.ts §4 client, mint-path fix, sqlite cache, UA; trends.ts unchanged (it goes through enrichment) — (starts 21:30)
E identity server/game/identity.ts, scripts/night2/prebake-identity.ts background P31, links and plausibility via D's background lane; persistent per-token identity; pre-bakes testnet and mainnet cards D interface (stub until merged), B input type
F ownership server/game/ownership.ts, server/game/collection.ts, ✱server/account/router.ts (inject store, export auth), ✱http.ts (pass {ledger, accounts} into gameRouter) resolveDeck, GET /api/game/collection, chain-pool draft source (option c) —
G host-pvp server/game/{host,router,store,index,duel-binding}.ts, shared/game/modes.ts (engine field), deploy/night2/modes/*.json multi-engine host, constructed decks via F, account seats, private lobbies, invite, quick match, Elo, ?v= polling F function signature (agree by 22:00), A types
H ui-duel src/game/duel/* (board, card face with type line, P/T, text, flavour; adapter; local bot practice) playable vs bot in the browser A types → A alpha
I ui-pvp+story src/game/OnlinePlay.tsx, online.ts, PlaySection.tsx, Leaderboards.tsx, src/game/recap/*, shared/duel/recap.ts collection deck picker, invite and quick-match UI, ladder, "Battle of X (2026)" recap rendered client-side by replay of GET /matches/:id (router.ts:137) G API (stub), A log format
Lead integration branch, docs/night/*, QA, REPORT merges, lockfile, end-to-end on testnet with 2 Dex accounts —

Overlap is limited to the ✱ lines. host.ts is G's alone: F ships pure functions that G calls.

Timeline (EST):

Time Milestone
21:30 A, D and F start
22:15 types contract merged; B, G, H and I build against it
23:15 engine alpha; C starts sims; H plays vs bot
00:00 D merged; E live; G binds duel; I wired to G
00:45 balance v1 (data-only tuning)
01:15 freeze
01:15–01:45 QA PvP plus recap
01:50 REPORT
02:00 stop

Cut first, in order:

  1. WDQS/shared-property "Connected": keep article-link Connected only, or none.
  2. Plausibility verification (G5): trust chain stats and document the gap.
  3. Quick match: invite link and open lobbies suffice.
  4. Elo ladder: keep W/L keyed by account.
  5. Peer-hosted duel and wallet-signed deck claims.
  6. Recap infobox polish: keep the plain encyclopedic log.

Never cut:

  • the Wikimedia client (requirement 7: low risk, independent, and protects every later night)
  • server-side ownership verification
  • the duel core
  • self-hosted PvP with owned or draft decks
  • bot practice

Biggest risks:

  1. Duel engine plus balance in about 2 h of real build time. Mitigation: no stack, atomic actions, effects as ≤8 templates.
  2. UI combat readability. H must start on mock views at 22:15, not wait for the alpha.
  3. Supply: 12 mainnet cards make a constructed duel unplayable without option (c) or (a). Make deck size and libraryEmpty ruleset data so Eric's decision is a mode file, not code.