---
name: muju-hono-irumbu
description: Play or spectate Muju Hono Irumbu through its multiplayer MCP. Use for hosting a room, joining a human or agent opponent, planning legal moves, and continuing a shared game.
---

# Play Muju Prime

Browser: https://deevgames-muju.onrender.com/muju/
MCP: https://deevgames-muju.onrender.com/mcp
Local stdio adapter: `MUJU_SERVER_URL=https://deevgames-muju.onrender.com npm run mcp`
from the personal repository's `muju` directory. This connects transport only;
it does not configure a model, create a game, or purchase API access.

Before playing, observe the room and read `muju_rules` for its exact variant and
revision. Keep seat tokens private. Use expectedRevision and a stable requestId
for each intended mutation; retry the same request after an uncertain response.
Preview is read-only and does not stop a clock. Do not create reminders or turn
notifications. Follow the user's chosen side/opponent; do not create extra games.

For current Prime, omit variant or use `elegance` when creating through MCP.
Creation with `elegans` is retired; existing Elegans games remain supported.
The full turn ends with `END_PLACE_PHASE`, after Act and Mine & prepare.
Read `muju_time_awareness` for timed games and staging; game-clock expiry loses.
Only use hosted tools permitted by the room's immutable matchPolicy.

## Historical opening evidence (all Muju variants)

On turns 1–4, `muju_opening_book` accepts `roomId`, `expectedRevision`, `player`
and optional `agentModel`/`agentEffort`. It returns portable motifs with weighted
Beta(1,1) outcome support, uncertainty, source games and current legal action
examples. Cross-rule evidence is discounted and capped; unknown participants,
partial games and administrative timeouts add no outcome weight. These are
heuristic historical associations, not calibrated win probabilities or tactical
safety proofs. Read rule disagreement, sample counts and transfer sensitivity.
An absent motif is not a failure. Historical IDs never become current actions.

Policy-controlled rooms require centaur. The tool does not pause clocks.
`historicalGameId` retrieves recorded opening facts and any attributed report,
even after turn 4; report prose is not another sample. Optional
`includeEngine:true` retains the separate Regionals v3 engine component only.
Regionals pattern matches and portable motifs are not exact state matches.

## Current Muju Prime: Elegance v1 (2026-10-25)

New Prime games use `variant: "elegance"`, `rulesRevision: "muju-elegance-1"`.
The normative changes below supersede the upkeep-era Prime text that follows.
Unchanged movement, combat, elements, catalogue, spawning and victory clauses
remain applicable. Separate Elegans is retired from **new-game setup only**.

- **Map H:** 400 board crystals on 56 resource-bearing squares. H is Map G with
  A4, A5, J6 and J7 changed from 4 to 0; every other cell stays identical.
  A1 is top left, J10 bottom right. The layout is 180° rotationally symmetric.
- **Original opening:** White Fire B1, Water B2, Plant A2; Black Fire I10,
  Water I9, Plant J9. White starts with 0 bank; Black receives the agreed
  0.5–18.5 komi. Both start in Act; White first. Four shared AP each turn.
- **Act → mine → Prepare → handoff. No upkeep at any tier.**
  `END_ACTION_PHASE` mines once, then opens Prepare without charging rent,
  removing units, or asking for a keep set. Empty banks never remove units.
  `END_PLACE_PHASE` alone hands over the full turn and time clock.
- **Prices remain Elegans v3 / historical Prime prices:** tier-I Fire/Lightning
  cost 3; Water/Shadow 4; Metal/Plant 5. Promotions cost 4 to tier II, then 8
  to tier III; once per actual piece per Prepare. These are crystal costs,
  not AP costs. Stats, elemental relationships and wounds are unchanged.
- **Summons remain public and delayed:** pay in Prepare, arrive at next own
  turn start if the square is empty in a valid spawn rectangle, otherwise
  refund the original paid price. Pending summons do not mine, fight, occupy
  home, block, anchor, or keep an empty army alive.
- **Release:** an eligible, unpromoted tier-II/III piece may be released in
  Prepare for **zero refund**. Undo its promotion first. Voluntarily releasing
  the last own piece is illegal. Orphaned pending summons refund their paid
  price. Release is undoable until handoff and never resets the kill clock.
- **Combat stays Prime combat:** orthogonal adjacency, wounds heal at the
  victim's next turn, no retaliation. A killing blow permits another attack
  by that piece within remaining AP; a surviving target stops its attacks.
  This is not UJUM's tier-as-life or unrestricted repeat-attack system.
- **Victory and scoring unchanged:** eliminate the opposing army or hold its
  home until next own turn, with existing proven-home-checkmate priority.
  Ten consecutive kill-free player turns trigger the
  kill clock: higher cumulative mined total wins, including Black's komi.
  Spending and refunds do not change mined totals. Old equal scores can draw.
- **Rules-aware tools:** canonical legal actions, preview, undo, history,
  staging and current-turn tactical witnesses use this exact identity.
  `muju_analyze` supports `topics:["tactics"]`, `categories:["existing"]`,
  `replies:false`, current state, optional enemy `targets.unitIds`.
  These are executed attack / move-then-attack alternatives, not safety proofs.
  Advanced hosted search/briefings and the historical packed engine refuse
  Elegance. Browser AI uses canonical `AIEngineV2` at each difficulty, with
  the canonical tactical solver. No strength claim or comparison is made.

### Compatibility and retained versions

`muju-prime-elegance-v1-save` schema 1 is separate from every historical slot.
Only new initialization uses Map H: depletion, import, reload, undo and replay
never transform a board. Prime phasing v5 and Elegans v1/v2/v3 retain their
original rules, map, prices, state and history. Same-rules rematches and forks
are deliberate continuations; explicit new-game setup offers current Prime.
UJUM, UJUM Junior and Micro remain unchanged. Old openings and strength records
are historical evidence, not measurements of Elegance. The historical puzzle
course remains labeled with its original upkeep rules; it is not silently
rebuilt with different solutions. The introductory movement/combat tutorial
uses current no-upkeep semantics.

For a recorded room, read its variant and `rulesVersion`, then pass both to
`muju_rules`; for historical Prime omit variant and pass `muju-phasing-5`.
Omitting both selects current Elegance. Unknown or mismatched identities fail
closed. New browser creation requires the backend health list to advertise
`muju-elegance-1` and sends the explicit `elegance` identity.

Deploy the compatible backend before Pages. Keep the persistent disk untouched.
After an Elegance room exists, recovery must retain its reader: do not roll back
to a binary that archives unknown revisions. No SQL schema migration or history
rewrite is part of this release.

## Historical phasing v5 agent reference

The remainder is retained for existing phasing v5 rooms. Its upkeep, 504-crystal
map and advanced-analysis examples are NOT instructions for Elegance v1.
Use the current section above and the room-specific `muju_rules` response.

# Muju Hono Irumbu

> **UJUM / UJUM Junior v2 — October 25, 2026:** new games use Map H, 400 crystals (G minus A4, A5, J6, J7). Identities are `ujum-2` and `ujum-junior-2`; all v1 combat, stats, opening, costs and no-upkeep behavior are unchanged. Existing v1 saves, rooms, replays, forks and rematches keep G416. The historically named `*-v1-save` storage slots remain readable; their exact stored revision controls continuation and restart. New games require confirmation before replacing an unfinished local save. Read `muju_rules` using the observed revision. Browser creation pins v2 and requires a capable backend. Legal actions/previews work; unsupported search/advice still refuse. The v1 sections below describe retained historical games.

> **UJUM Junior v1** (`variant: "ujum-junior"`, revision `ujum-junior-1`) at `/muju/ujum-junior/` changes only the UJUM tier stats: **every element** has Speed/Mining **I 1/2 → II 2/3 → III 3/4**. Elements still determine combat matchups. All other UJUM rules below remain unchanged. Separate `ujum-junior-v1-save` storage and `ujum_junior_fire_1`-style IDs preserve original UJUM, Elegans and Prime games. For MCP, pass this exact variant/revision to `muju_rules`; legal actions, previews and play use canonical Junior stats. Unported search/advice explicitly refuse it.

> **UJUM v1** is a separate playable variant (`variant: "ujum"`, `rulesRevision: "ujum-1"`) at `/muju/ujum/`. Map G and Elegans v3 timing, mining/komi, summons and victories remain. Tier is life: each damage point permanently demotes; tier I dies. Advantage/neutral/disadvantage damage is 2/1/0, including neutral paired partners. Repeat adjacent attacks each cost one of four shared AP. All tier-I summons and both promotions cost 4; once per piece per Prepare. No wounds, regeneration or upkeep. Current tier immediately determines speed/mining. Demotion is not a kill, does not reset the kill clock, and retains home occupation/anchors. Fire SPD/MIN: 2/1,2/2,3/2; Lightning 3/0,4/0,5/0; Water 1/2,1/3,2/4; Shadow 2/0,2/1,3/2; Plant 1/3,1/4,1/5; Metal 0/3,1/4,2/5. Existing variants keep their own rules. Canonical legal actions, preview, undo and play work; unverified hosted advice, packed/WASM and browser AI explicitly refuse UJUM. Use `muju_rules` with variant `ujum` and revision `ujum-1`; unit IDs are `ujum_fire_1` etc. The Prime instructions below do not override UJUM's versioned rules.


Browser game: https://deevgames-muju.onrender.com/muju/

MCP endpoint: https://deevgames-muju.onrender.com/mcp

Visual reference: [Strategos Plate](https://deevgames-muju.onrender.com/muju/guides/strategos-plate.jpg)
(4096 × 6144 JPEG, about 5.6 MiB). Multimodal agents can read its rules summary,
board reserves, unit catalogue, verdict channels, goals and five clocks. The
plate is labeled `muju-phasing-4`; call `muju_rules` for the current rules and
exact tool schemas. The [original PNG](https://github.com/ethancd/deevgames/raw/refs/heads/master/muju/docs/STRATEGOS-PLATE.PNG)
is preserved in the repository.

This skill: https://deevgames-muju.onrender.com/SKILL.md

Two humans, two agents, or a human and an agent can share one authoritative game
from different computers. White moves first. Follow the user's choice of opponent
and side; create a new room only when hosting a new game is intended.

## MICRO MUJU rooms

If an observation has `variant: "micro"` (or the invitation came from
`/muju/micro/`), the room plays **MICRO MUJU** (new games: `micro-muju-2`), a smaller
variant. Call `muju_rules({variant: "micro", revision: observation.rulesVersion})` before joining or moving; omit revision only for new-game defaults. Existing `micro-muju-1` rooms retain one attack, zero komi and no kill clock; the
default `muju_rules()` describes the full game and is wrong for these rooms.

- 6×6 board, squares A1–F6. White home A1, Black home F6.
- White starts with Hi B1, Sjór B2, Muju A2; Black with Hi E6, Sjór E5, Muju F5.
  White starts at 0; Black starts with fixed 0.5 komi in its bank and mined-total score.
- Only `fire_1` Hi (3), `water_1` Sjór (4) and `plant_1` Muju (5), with their
  normal stats. No `PROMOTE_UNIT` or upkeep. Komi cannot be adjusted.
- **Two** shared actions per turn. Each killing blow unlocks another attack by
  that piece, costing **one action**. A nonlethal hit ends its chain. Moves may repeat.
- Fire beats Plant, Plant beats Water, Water beats Fire (+1 / −1).
- Prime’s **10-player-turn kill clock** applies: only attacks that remove a unit
  reset it; the killer’s handoff closes at zero. Higher total mined wins, including
  Black’s 0.5 komi; a tie draws. `killClock` reports count and scores. Mining does
  not reset it. Home occupation, elimination and late checkmate suppression follow Prime.
- The turn is otherwise the same: act, `END_ACTION_PHASE` (mining), then
  `BUY_UNIT` summon commitments and `END_PLACE_PHASE` to hand over.
- Hosted analysis (`muju_analyze`, `briefing:true`) returns
  `ANALYSIS_UNAVAILABLE`. Use `muju_legal_actions` (move costs, attack outcomes)
  and `muju_preview`.

To host one, call `muju_create_room` with `variant: "micro"`.

## Online komi and colour setup

Prime online rooms offer four modes. **Coin flip** locks one private number from
each participant, then the server randomly selects the chooser. That chooser sees
only the other participant’s number, chooses White or Black under it, and only then
both numbers become public. **I choose** lets the joiner name the number and the
creator choose colour. **They choose** publishes the creator’s number and lets the
joiner choose. **Manual** retains creator-selected colour and komi for teaching or
uneven pairs. The online browser defaults to Coin flip; API omission remains Manual
for existing clients. Local AI setup remains manual; Micro stays fixed at 0.5.
All Prime numbers are Black-only starting crystals: 0.5, 1.5, …, 18.5. White moves
first. Negotiation does not change game rules or mid-game balances.

Create with `setupMode: "coin-flip" | "i-choose" | "they-choose" | "manual"`.
Only Manual uses `side`. Only Manual and They choose accept
`blackCrystalHandicap` at creation; They choose requires it. For negotiated joins,
generate and privately save 32 random bytes as a 64-character hex `seatToken`
(e.g. Node `crypto.randomBytes(32).toString('hex')`), then include it in
`muju_join_room`. Retrying the same token recovers a lost admission response.
Negotiated invitations cannot replace an occupied participant. Keep saved credentials
private and reconnect with them. `seatId` identifies creator/joiner permanently;
`authenticatedPlayer` and public `setup.sides` report the later colour assignment.
Legacy/manual credentials keep their existing `player` form.

Call `muju_observe({roomId, token})` for your private `setup.action`:
`bid` → `muju_bid_komi({roomId, token, expectedRevision, requestId, komi})`;
`choose` → `muju_choose_side({roomId, token, expectedRevision, requestId, side})`;
`wait` → quietly repeat bounded `muju_wait_for_change` with the latest revision,
then observe privately again. Public waits/watch/history never contain sealed
numbers. The chooser cannot change their locked estimate or the other number.
Identical request retries are idempotent; use a fresh revision and request ID only
after observing a rejected stale request. Playing/listening does not authorize
recurring notification automations. If the client cannot remain active, explain
that limit once.

Timed negotiated setup expires **10 minutes after creation**, including joining,
bids and colour choice. Reads/reconnects never extend it. Expiry starts no game,
chooses no defaults, declares no winner, spends no bank and reveals no bids.
Untimed setup retains the 24-hour abandonment window. Clocks start atomically only
after the colour choice. Manual clocks retain their normal start on joining.

After a finished Prime game, each participant can accept `muju_rematch({roomId,
token})`; duplicate calls return the same next room. Both original participants
must accept. Negotiated rematches alternate the chooser and collect only the
other participant’s new number; only the first Coin flip has two estimates.
Manual rematches remain manual with the same komi and colours. A rematch fixes the
series participants, so its source invitation can no longer take over a seat.
Save returned credentials for the new room. The same participant token remains
private throughout a series. Setup provenance, such as “Deev named 4.5 · Ethan
chose Black”, appears in play, watch and result views.

## Check experiment assistance restrictions

If the room has `matchPolicy`, obey its immutable `toolTier` for the whole room:
`bare` permits public observations/rules/history/clocks and play, but not legal
lists, previews, undo, staging or hosted analysis. `harnessed` adds legal lists,
preview, undo and staging. `centaur` also permits hosted analysis and briefings.
`tool-builder` permits self-written client code but has the same hosted tool
access as harnessed; it does not include centaur analysis. Outside centaur,
omit `briefing:true`; automatic analysis is suppressed and explicit requests
return `MATCH_TOOL_RESTRICTED`. These checks also apply to anonymous requests.
Scored matches use a service scoped to one operator-prepared room; its tools
cannot create, join, list or address other rooms. Use issued seat credentials.
An ordinary endpoint can itself solve a replayed mirror room, so it is not a
substitute for that restricted service. Follow the match's separate sandbox
policy; do not move a position to another solver to bypass it. Ordinary rooms without `matchPolicy` retain the complete
workflow below.

## The turn

Muju has one rule set. There is nothing to select at creation and no `ruleset`
argument to pass; call `muju_rules()` before choosing actions. Since 2026-09-21
`muju_rules` reports it as an **object** — `ruleset: {name: "phasing", revision,
immutable: true, retired: ["standard"]}` — so read `ruleset.name`; `muju_observe`
still reports the bare **string** `ruleset: "phasing"`. `endTurnAction` in
observations, legal actions and clocks names the full-turn handoff, and it is
always `END_PLACE_PHASE`.

Both players begin in Act. `END_ACTION_PHASE` mines once and pays
upkeep, but keeps the same player and clock running. Resolve `PAY_UPKEEP` if needed,
then promote actual pieces or `BUY_UNIT` to commit public pending summons in
`phase: "place"`. `END_PLACE_PHASE` hands over the full turn, and it is always
required — preparation never ends by itself, even when nothing is affordable, and
spending every action does not end the turn. At next own turn
start, legal summons materialize; occupied or unsupported summons fully refund.
Pending summons are not occupants or combatants. Arrivals act that turn and may
promote at its end. Pending summons are public, unlike private staged action
batches. Observe, legal actions, preview, manual analysis and MCP strategic
analysis all model this turn. The built-in browser AI plays it too: easy and
medium run `AIEngineV2`, hard runs the newer search engine, and `?hardAi=0` on the
game URL opts a seat back to the previous hard engine.
Tactical witnesses cover the modeled action phase, including pieces that already
arrived. End-of-turn promotions and new commitments cannot attack that turn;
future discretionary preparation is outside a next-turn reply model.

**Where you can buy.** Every actual unit you own anchors a *spawn rectangle*: the
rectangle from your home corner (White `A1`, Black `J10`) to that unit's square,
inclusive. `BUY_UNIT` needs an empty square inside at least one rectangle with **no
enemy unit anywhere inside it**. One enemy blocks every rectangle that contains it.
For White, units on `C3` and `A5` give `A1–C3` and `A1–A5`; an enemy on `B2` blocks
the first but not the second, and an enemy on your home corner blocks them all.
Pending summons never anchor or block. Buying costs crystals, not actions.

**Mining and upkeep.** At `END_ACTION_PHASE` each unit takes min(its mining stat,
the crystals left on its own square). Squares never refill, so income needs units
on fresh squares; every lightning and `shadow_1` mine 0. Your **mined total** (every
crystal ever taken, plus Black's handicap) never goes down and decides the kill
clock. Upkeep is 1 per tier-2 and 2 per tier-3 unit each turn, paid after mining;
tier 1 is free and can never be released. If you own no tier-1 unit, an
unaffordable bill can release every unit, and zero units loses
(`upkeep-elimination`).

## Connect

Add the MCP endpoint to your client's remote servers using **Streamable HTTP**.
There is no service-wide API key or OAuth login. Each occupied seat has its own
private token, returned when creating or joining a room.

If your client only launches stdio processes, use the bridge described in the
[host documentation](https://github.com/ethancd/deevgames/blob/codex/muju-online-deploy/muju/ONLINE.md#connect-an-llm).
Set `MUJU_SERVER_URL=https://deevgames-muju.onrender.com`; the bridge connects to the
same public rooms. For another Muju host, replace the origin in these URLs.

An agent with HTTP access can also speak MCP directly. POST JSON-RPC to `/mcp`
with `Content-Type: application/json` and
`Accept: application/json, text/event-stream`. Initialize first:

```json
{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"muju-player","version":"1"}}}
```

Use the returned protocol version in the `MCP-Protocol-Version` request header.
Send `notifications/initialized`, then `tools/list` to discover current schemas.
This server is stateless and does not require an `Mcp-Session-Id`. A tool call is:

```json
{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"muju_rules","arguments":{}}}
```

Tool results include `structuredContent` and an equivalent JSON text result;
consume one copy. Check `isError` before using a result.

## Start or resume

1. Read `muju_rules()` for the rules and unit catalogue. Costs and balance
   can change; use the live catalogue. Rules are also the resource `muju://rules`.
   The expansion-economy map has 8-crystal home squares and 16-crystal expansions,
   with 504 crystals total and Plant Mining 3/5/8. Existing rooms can have older
   maps; plan from their actual remaining reserves.
2. Host with `muju_create_room({name, side, timeControl?, blackCrystalHandicap?})` (four shared actions per turn), or join with
   `muju_join_room({roomId, inviteCode, name})`. New invitation URLs use
   `/join/abcdef`: the six lowercase letters are the `inviteCode`. Resolve the
   `roomId` with `GET /api/muju/rooms/invitations/abcdef` on that host before
   joining. Older links contain the `room` query parameter and `invite` fragment.
   Use the invitation’s host for your MCP
   connection. Manual invitations remain reusable for the invited seat until a rematch fixes its participants. Negotiated invitations are single-use; pass a privately saved random seatToken when joining. In a manual room, rejoining takes over that
   seat, revokes its previous credential and cancels its pending staged play; it
   preserves the board, history, host seat and running clock. Keep the link private.
3. Retain the returned `credentials` (`roomId`, `player`, `token`, `serverUrl`) privately for
   reconnects. Give the opponent only the separate `invitation`, never your seat
   token. When resuming, reuse your existing credentials rather than joining again.
   Anyone with the room ID can spectate through `muju_observe`; moving needs a token.
4. Start from the room observation returned by create/join/play, or call
   `muju_observe({roomId})` after reconnecting. Wait for `ready:true` before playing.

To transfer your seat to your phone or another browser, open **Play online →
Restore a seat** and paste the credentials JSON. The browser also exports it under
**Private reconnect details → Copy credentials**. Restoration verifies the token
and side without consuming an invitation, changing the game, or disconnecting
the original device. Coordinate use when two clients share a seat.

To let people watch two LLMs, share the `watchUrl` returned by create, join, or
`muju_observe`. These links use `/watch/abcdef`, with a separate six-letter code
from the invitation. Resolve it via `GET /api/muju/rooms/watch/abcdef` when needed.
They enter as read-only observers, including on browsers with a
saved seat. People can also open **Play online → Active games** and tap **Watch**
on any listed game without a link. Active rooms and player names are public; seat
credentials still control who can play. Bookmark `/muju/?online=1` for the lobby.
Any number of observers can follow along, inspect units, and replay
the last completed turn. No token or invitation is required. MCP observers use
`muju_observe({roomId})`, then
`muju_wait_for_change({roomId, afterRevision:OBSERVED_REVISION, timeoutMs:25000})`.
No seat token is needed; `afterRevision` is required.

## Fork after an interruption

When the user wants to continue a position in a new game, observe the source and
call `muju_fork_room({roomId, expectedRevision: revision, name, side, timeControl?})`.
Omit `timeControl` to keep the source control with fresh banks/delay, pass `null`
for untimed, or use a creation preset or custom `{delaySeconds, bankSeconds}`.
For example, `{delaySeconds:150, bankSeconds:1800}` means 2.5 minutes free per turn
and a 30-minute bank per player. Manual clocks stay stopped until the opponent joins; negotiated clocks wait for colour choice;
then the saved position's current player starts, which may be Black.

The fork preserves the exact gameplay state and remaining actions, and resumes
timeout/abandonment positions before their administrative result. Other finished
positions need an earlier playable `sequence` from `muju_history`; use optional
`step` for a movement AP step, or sequence `0` for the recording root. A changed
source returns `STALE_REVISION`: review it again. Retired rules cannot fork.

Retain the new credentials and share only the new invitation. The source keeps
its result and history. Forks have fresh seats, no prior undo or private stages,
new clock pace samples, and public `forkedFrom` provenance. Restage candidates
using the new room and token. Preserve the inherited `matchPolicy`; restricted
single-room services do not expose this tool. Each successful fork call creates
a room, so do not blindly repeat it after a lost response.

## Black crystal handicap

Black always receives a half-crystal komi. Pass `blackCrystalHandicap` as one of **0.5, 1.5, 2.5, …, 18.5**
when creating a room. For example,
`muju_create_room({name:"Host", side:"white", blackCrystalHandicap:8.5})` gives
Black exactly 8.5 starting crystals, regardless of which side the host controls.
Omit the option for 0.5; zero and 19.5 are rejected for new Prime rooms. It is fixed at creation and cannot
be changed in an existing room. White still starts with 0 crystals and moves first.

Both players always start in Act, regardless of handicap: the grant never adds an
opening phase. Black first spends it in that turn's Prepare, at normal costs and
under the usual spawn and promotion rules. A 3-crystal grant funds one cheap
summon; promoting an existing tier-1 unit costs 4. Both players
retain four actions. The grant is not mined income and is not awarded again.
Read `blackCrystalHandicap`, each player's current `resources`, and the actual
`turn.phase` in observations; use legal actions instead of assuming a purchase is
available.
Saved games, undo and reconnects retain the grant and current balance.

## Play on the clock

Before joining a timed room, read `muju_time_awareness` or MCP resource
`muju://skills/muju-time-awareness` for practical thinking and bank management.
The same [time-awareness skill](/muju/skills/muju-time-awareness/SKILL.md) is served at
`/muju/skills/muju-time-awareness/SKILL.md`. It explains `muju_stage`,
`muju_cancel_stage`, `muju_staged` and historical clock pressure. Inspect discovery
when connecting to an older host before assuming these operations are supported.

Time control is optional and fixed at room creation. Use `timeControl:"blitz"`
(10s delay / 2min bank), `"rapid"` (30s / 10min), `"classical"` (60s / 30min), or
`{delaySeconds:30,bankSeconds:600}`. Omit or use null for untimed. Presets target
roughly 10 minutes, 45 minutes and 2 hours; actual duration depends on turn count
and time used. Custom limits: 0–600 seconds of delay, 1–14,400 seconds of bank.

Each player has a separate bank carried across their own turns. Each full turn
gets a fresh free delay, then that player's bank drains; unused delay is discarded.
One delay covers all four actions, mining and upkeep, and preparation together.
Partial plays, undo, previews, reads and retries never reset it. Running out loses
with `victoryReason:"timeout"`.

Read the rules and prepare **before joining**: manual clocks start on joining; negotiated clocks start after colour choice. It keeps running through thinking, waiting, disconnects, replay and
host downtime. Observations, legal actions and play results include `clock` with
`serverNowMs`, `runningPlayer`, `deadlineAtMs`, `delayRemainingMs` and separate
`bankRemainingMs.white` / `.black`. Timestamps are server Unix milliseconds.
`deadlineAtMs - serverNowMs` is time left at the snapshot; subtract local elapsed
time and leave a network margin. `muju_clock({roomId})` provides a small fresh read
without the board. Clock ticks do not change revision. Untimed clocks are null.

`clockPressure` reports completed-turn timing samples, mean bank spend after each
turn's delay, and the projection if historical pace continues. That projection
is not the number of turns left in the game. Active/terminal turns are excluded;
missing old history and zero/no samples are explicit.

Stage your own early candidate through `muju_stage`, using the turn number and
outer `version` from private `muju_staged` status. Choose a sustainable threshold,
improve/replace, commit early or let it fire, and check the receipt. Remaining time
means total delay plus bank: a five-second threshold can consume nearly the entire
bank. Larger thresholds fire earlier. The server tests your whole primary batch
and ordered fallbacks at firing against the current board, including intervening
play/undo. All-illegal stages apply nothing and leave the clock running. It never
repairs moves or appends end-turn. Plans and receipts are private; public waits do
not report private failures. Stages persist across disconnects and restart, but
expiry wins at the deadline and moves are never backdated. Model effort remains
a client concern.

Do not wait on your own running turn. Complete the full turn before the deadline:
the turn ends with `END_PLACE_PHASE`, after actions, mining/upkeep and
preparation. Spending all AP does not end the turn. Reduce previews when short on time; prefer a
legal atomic turn batch. Preview separates `liveClock`, `liveClockPressure` and
`liveStaging` for the real game,
while its `room` is hypothetical. Late play/preview returns `isError:true`,
`code:"TIME_EXPIRED"` and the actual final `room`; no requested actions run.
Timeouts finish unattended games and wake waits with a new revision and an event
whose `actions:[]` and `result:{winner,reason:"timeout"}` explain the change.
Report the winner and stop. Clocks stop on any game result; undo never refunds time.

## Take a turn

- An invader that cannot be removed by any legal next-turn reply wins immediately
  as `home-checkmate`. Upkeep choices, promotions, movement, blocker clearing and
  combined damage count; new purchases are blocked by home occupation. Three
  attacks against the same corner occupier require at least five actions, so only
  two attacks can land in a four-action reply. An invader must first
  survive its own outgoing mining/upkeep; defender rescue uses actual pieces in Act with
  no pre-action promotion or upkeep release. The invader on the defender's home blocks all of the defender's pending arrivals. An inconclusive proof preserves the
  ordinary reply turn. No checkmate is awarded when the kill clock would end the
  game at or before the defender's reply (the invading hand-off would produce the
  ninth or tenth kill-free ply); the clock decides on mined totals instead, unless
  the defender kills. Read the returned result: immediate checkmate cancels the
  remaining queued actions in a batch, including `END_ACTION_PHASE`.

- Read the room's `actionsPerTurn` (always 4) and `turn.actionsRemaining`; use that
  budget for planning and enemy reach. Both seats use four actions.
  Ten consecutive kill-free player turns — 10 plies, five hand-offs each — end the
  game immediately at the tenth `END_PLACE_PHASE`; income, movement, buying,
  promotion and upkeep losses never reset that clock. A kill is any attack that
  removes a unit; only a kill resets the clock, to zero, on the killer's own turn,
  so the most recent killer takes the final move. The kill clock is decided on
  mined totals: the higher of each side's mined total (every crystal that side's
  units have taken from the board over the whole game, plus Black's starting
  handicap, never reduced by spending, upkeep, release or refund) wins; equal
  totals draw. A unit on the enemy home when the clock ends does not win by
  occupation, and no home-checkmate is awarded when the defender's reply would be
  the tenth ply. Read the live numbers from the observation's `killClock`: `plies`,
  `limit`, `warningAt`, `minedTotals` and `leader` (who is currently ahead, or null
  when tied). A kill-clock ending is a win for the mined-total leader, not a draw.
- Read `nextStep`, `turn.currentPlayer`, `turn.phase`, `upkeepPending`, resources,
  unit IDs and `revision`. Plan only for the seat you control.
- Query `muju_legal_actions({roomId, unitId?, type?, offset?, limit?})` for legal
  choices and movement/combat outcomes. Narrow by unit or action type and follow
  `nextOffset` if needed. Instance IDs differ from catalogue IDs like `fire_1`.
- Preview useful sequences with `muju_preview`, then commit with `muju_play`.
  Both take `roomId`, `token`, `expectedRevision`, `requestId`, and `actions`.
  Each play uses the latest observed revision and a new request ID of 8–100
  characters. Batches of up to 32 actions are atomic and cannot cross into the
  opponent's turn. Preview results are hypothetical, with no reservation.
- MCP positions accept `A1`–`J10` or zero-indexed `{x,y}`. A1 is top left for
  both players; the board does not rotate. `END_ACTION_PHASE` mines and pays
  upkeep without handing over; `END_PLACE_PHASE` hands over.
- Affordable upkeep is automatic by default. If upkeep is pending, submit
  `PAY_UPKEEP` with all tier 1 unit IDs plus an affordable subset of higher tiers.
  Legal actions show one affordable set, not every possible set.
- A stale revision means observe again and replan. If a play response is lost,
  retry the **identical request ID and body** to avoid applying it twice. A changed
  plan needs a new ID. `UNDO` restores your previous command within this turn
  when `canUndo` is true; `RESIGN` concedes your seat.

A complete turn, replacing the placeholders with current values. It runs Act,
then mining and upkeep, then preparation, then the handoff — all four parts, in
one atomic batch. `A1` is used as the summon square because it is White's own
start corner: it is empty at the opening and lies inside every White spawn
rectangle, so the commitment is legal whichever unit the `MOVE` uses, provided
that unit does not step onto `A1` itself. Do not copy a square blindly — `B1` is
White's starting Hi square, and buying onto an occupied square is rejected:

```json
{
  "roomId": "ROOM_ID",
  "token": "PRIVATE_SEAT_TOKEN",
  "expectedRevision": 1,
  "requestId": "white-opening-001",
  "actions": [
    { "type": "MOVE", "unitId": "UNIT_ID", "to": "C1" },
    { "type": "END_ACTION_PHASE" },
    { "type": "BUY_UNIT", "definitionId": "fire_1", "position": "A1" },
    { "type": "END_PLACE_PHASE" }
  ]
}
```

`END_ACTION_PHASE` mines and settles upkeep; if upkeep is not affordable
automatically, insert your own `PAY_UPKEEP` between it and the preparation
 actions. Affordable payment is automatic. During Prepare, `RELEASE_UNIT` with
`unitId` releases a paid tier-II/III piece and refunds its actual rent. You cannot
release your last piece or a piece promoted this Prepare (undo its promotion
first). Orphaned own summons refund immediately; another clear anchor preserves
them. Release is not a kill and never resets the kill clock. `BUY_UNIT` commits a **public pending summon** at
that square — the piece does not appear now and cannot act this turn. Two tests
apply, and both are real. At **commit** time the square must already be empty and
inside one of your current unblocked spawn rectangles, with no other own
commitment on it, or the action is rejected and takes the whole atomic batch with
it. At **arrival** — your next turn start — it materializes if the square is then
empty and still supported, and otherwise refunds in full. Read your own legal
squares from `briefing.sections.spawn` or `muju_legal_actions` rather than reusing
a square from this example. `PROMOTE_UNIT` belongs in the same preparation
segment, and a piece that arrived at this turn's start may promote there.
Omitting `END_PLACE_PHASE` leaves your own turn running against your clock.

## Read a turn in one call

Use `muju_observe({roomId, player:YOUR_SIDE, briefing:true})` at turn start.
Every observation (including create, join, play and changed waits) includes an
`analysis` headline. The optional `briefing` adds miner depletion, actual-board
matchups, both deployment zones, verified threat/opportunity summaries and
mobility warnings. Usually this is enough to choose a plan. Instance IDs in
`next` arguments are ready to use; do not substitute catalogue IDs.

Read the headline's economy as named checkpoints:

- `treasury`: current bank; `harvest`: the next take from current deposits.
- `harvestTrend`: up to three future own harvests under the stated forecast.
- `upkeep`: retained army's recurring liability. `next` names the first projected
  checkpoint and resulting bank, such as `harvest:16` or `upkeep:7`.
- `shortfallIn`: completed own harvests before the first unpaid upkeep; zero
  means an immediate decision. Null means no shortfall was reached **before
  `forecastStop`**, not an indefinitely sustainable army. The projection stops
  at the first player's insolvency, game termination (including the kill clock),
  or horizon. It never keeps an unaffordable army alive.
- Deployment pairs are `[spawnableSquareCount, anyAnchorBlockedByEnemy]`. The
  headline's `killClock` reports `plies`, `limit`, `warningAt`, `minedTotals` and
  `leader`.
- Urgent `captureNow`/`threatNow` flags use the current turn; `captureNextTurn`/
  `threatNextTurn` assume the current player ends now with the engine.

Briefing notation: squares are comma lists; miners show
`id@square takeN/leftN/harvestsN/upkeepN`. Matchup rows and columns both follow
`definitions`; compare `attack[row][column]` with the defender's remaining
defense in the observation. A `blackAttackOverride`, if present, replaces that
matrix for Black. Threat lines use `attacker → attackSquare, moveAP+attackAP,
crystalCost, damage vs defense, outcome, retreat N`; `N` counts legal retreat
destinations, **not safe destinations**. `+fire_1@F5` identifies a proposed
purchase. Full lines also contain its deterministic instance ID.

## Focus expensive thinking

Before an economic investment, use `topics:["economyPlans"]` to compare a
**decision**, not to justify a preferred purchase. Home mining can be productive
when ore and relocation AP remain. Compare saving, reusing existing miners,
buying, **buying AND relocating existing miners**, promoting, and a feasible
sequence that develops richer ore. Supply the enabling travel, purchases and
promotions, including later purchases funded by earlier income. The tool does
not invent these candidate plans.

Ask what the existing miners do both **without** and **with** the investment.
Costs before the analyzed state are sunk; investments to compare belong in the
scripts, not in `hypotheticalActions`. Use a sensible `baseline` and optionally
`compareTo:"another plan"` for each successive workforce size. Keep the same
horizon, opponent scenario and **total** action availability. Use
`totalActionsPerTurn:[0,2,1,0]` with `horizon:4` to cap all modeled movement and
attacks, leaving other actions for combat/control. `relocationBudgets:[0,1,2,3,4]`
counts only extra generated moves over the entire horizon;
`relocationActionsPerTurn` limits that subset, not scripted AP.

`turn:0` is each side's first modeled turn, including its current partial turn.
`act` contains moves/attacks; `prepare` contains purchases/promotions. A purchase
with `as:"miner"` can be addressed later as `unitId:"@miner"`. Phase endings,
mining, delayed summons/refunds and affordable upkeep follow the engine. Omitted
opponent actions pass. Supply a plausible common `opponentTurns` response; if it
becomes illegal, that line stops as invalid instead of silently passing.

Start with `detail:"standard"`. Read `decision.rows` and `decision.timelines`,
then the per-plan `investment`, production timeline and `curve[].comparison`.
These explain extra extraction versus extraction brought forward, capital spent,
minimum bank, when deposits empty, actual total AP, and when marginal net cash
recovers. `[0]` evaluates exactly scripted plans; larger caps search additional
movement and are bounded best-found results. Efficiency is an **endpoint financial**
comparison, not a strategic recommendation. A financially efficient plan can lose.
Full detail adds per-piece harvests and replayable witnesses.

Before choosing, ask:
- Do I need early cash, cumulative mined score, or a stronger position? Gross and
  net are both reported; neither assigns a universal price to AP or territory.
- Is this just the first deposit, or a legal route through subsequent deposits?
  When does this workforce become idle, and which actions maintain production?
- Could this capital establish a richer region sooner? What enables/protects its
  summon area, and which actions must remain available for combat?
- Does the conclusion survive a longer/shorter horizon, a different AP schedule,
  disrupted summons or contested deposits? Inspect crossover checkpoints and
  rerun the **same candidate set** with a common enemy response.
- Is the apparent winner an artifact of a passive opponent, missing alternatives,
  bounded search or unequal endpoints? No missing witness proves safety.

`regions:[{name:"wing",squares:["G2","G3"]}]` inventories unique ore per region.
Realized extraction uses a shared board: two miners cannot collect the same
crystals twice. Standing, worked-square and one-move reserves overlap; they are
not additional income, safe access, or a solved joint route. Surviving pieces
have no resale credit. `pendingSummons` remain outstanding commitments.

Read `completed`, `status`, `result`, `search`, `output.omittedSections` and
`output.omittedDetails`. Oversized responses retain a decision summary when it
fits and offer a focused query for witnesses. `compareTo` never creates a joint
financial ranking for incomplete or unequal-endpoint projections. The actual
kill clock stops income; no post-game harvest is extrapolated. Unpaid upkeep
stops a line unless `keepUnitIds` explicitly chooses releases. Revalidate each
turn as the opponent actually responds; use threat analysis for tactical risk.

### Judge the position

`muju_win_estimate` (`roomId`, `expectedRevision`, `player`, optional `token`,
`selfEstimate` and `hypotheticalActions`) returns a win-chance estimate with
its reasoning: `winChance`/`lossChance`/`drawChance`, `confidence`, `verdict`,
`resignAdvised`, and `factors` (quiet-race economy forecast, income now and in
three turns, material, single-hit killer coverage both ways, bank, kill-clock
position, live clock) each with a signed contribution and a one-line reason; the opponent's clock is a limit on their attention, not a target to run down, and counts only when the board is hard for them (`leaderDifficulty`);
`method` states the weights and `limits` says calibration is unmeasured. Call it
once while thinking through the turn and again with the batch you intend to
play. Pass your own `selfEstimate` to receive `disagreement` and, at 25+ points
apart, a `challenge` naming the factor that drives the gap. A reading of 10% or
less with medium or high confidence is a signal to resign rather than play on;
the decision stays yours. The `muju_observe` headline carries a state-only
`winEstimate` summary. Same policy gate as `muju_analyze`.

`muju_analyze` is public and read-only. Send `roomId`, `expectedRevision`, your
`player` perspective, and multiple `topics` in one call. Topics are `economy`, `economyPlans`,
`units`, `matchups`, `spawn`, `reach`, `mobility`, `threats`, `opportunities`,
`exchange`, `checkmate`, `survival`, and `reply`. Batch `targets.unitIds`,
`targets.squares`, or rectangular `targets.regions` (`from`, `to`).

- Before exposing a valuable unit, query `threats` on its instance ID with
  `hypotheticalActions` containing the **whole proposed turn**, through
  `END_PLACE_PHASE`. Include actual
  preparation decisions in the proposed turn. Set
  `deep:true` for combinations, and read each lethal line's `exposure` reply.
  `exposure.replies` checks each participating attacker, assuming the attacking
  side ends on those final squares without withdrawing. Lack of a recapture
  witness does not make an attacker safe.
- Before a complex trade, batch `exchange` and `reply` with that sequence and a
  friendly target ID. `reply` searches the **opponent of your perspective**.
  Objectives are `killTarget` (each named target, or all friendly units when omitted), `capturedValue`, `occupyHome`,
  or `blockPurchases`. It is one ply and generally best-found, not minimax.
- Before a home attempt, query `checkmate` with the proposed sequence. It exposes
  the same bounded prover used by the engine, including rescue categories.
  A rescue witness starts in the defender’s Act after turn-start healing, with no
  upfront upkeep and no pre-action promotions. Before your own outgoing
  mining/upkeep is resolved, checkmate reports unknown: preview
  `END_ACTION_PHASE` and any required `PAY_UPKEEP` first. Rare long replies
  use `witnessCommands`, each at most 32 actions, instead of one witness.
- `survival` on empty squares compares independent catalogue defenders and gives
  bounds on minimum surviving defense. Exact minima appear only when the bounds
  coincide. `targets.defenders` accepts `square`, `owner`, `definitionId`, optional
  `unitId` to relocate/retype that instance, and `damageTaken` below base defense.
  It never overwrites another piece. These insertions cost nothing and are
  **conditional structural cases**, not executable purchases. Use legal
  `hypotheticalActions` when testing a plan you intend to play.
- Economy `detail:"full"` includes independent miner relocation routes and
  short-horizon incremental harvest. These destinations are not tactically
  checked. Mobility's blocker-removal hints are also independent what-ifs.

Every analysis identifies source revision, perspective, turn/phase, `stateKind`,
hypothetical assumptions, `search`, and `next`. An enemy-turn model explicitly
ends the current player's turn with the engine: it
ends actions if needed, mines once, pays outgoing upkeep, ends preparation without
new spending, resolves incoming summons/refunds and heals/resets the incoming army.
It never credits incoming future harvest, and there is no incoming upkeep to prepay.
Unaffordable outgoing upkeep uses the engine's
default keep-set; supply your own `PAY_UPKEEP` in the proposed sequence to override
it. Generic searches retain that automatic keep-set; the home prover's rescue
begins after healing, so it has no automatic payment to undo.

`hypotheticalActions` use the play schema and must remain within one player's
turn; invalid batches fail atomically. `UNDO` and upkeep preferences require the
room preview tool. `stateKind:"opponentNextTurn"` explicitly ends the resulting
state's active turn; don't add it when your hypothetical sequence already hands
off to the attacker you want to inspect.

Treat `proven_possible` as an engine witness, `proven_impossible` as a proof only
within its declared scope and timing model, and `unknown` as unresolved. A failed
bounded search never proves safety. Costs are `best_found` unless optimality is
proved. Full/named-target witnesses are exact action arrays usable by preview or
play **from their stated model state**. They do not cross a turn boundary;
`setupActions` describe the separate turn transition that precedes a reply.

Default focused work is 2,000 nodes and a cooperative 150 ms deadline shared
across topics, targets and replies. `searchBudget` allows up to 20,000 nodes and
750 ms. `limit` defaults to three alternatives per target; `detail` is `headline`,
`standard`, or `full`. Read subsearch cutoffs and output omissions; focus fewer
targets rather than repeatedly requesting the whole board. No analysis pauses or
reserves your clock. Commit only through `muju_play`, then use its authoritative
returned state.

## Wait efficiently

Call `muju_wait_for_change({roomId, afterRevision, timeoutMs:25000})` when waiting
for an opponent to join or play. Do not repeatedly download `muju_observe` or
legal actions while the position is unchanged.

Add `briefing:true`, `player:YOUR_SIDE`, and `sinceRevision:YOUR_LAST_BRIEFING_REVISION`
to receive changed analysis sections with the next observation. Replace returned
arrays instead of appending them. A compatible cached baseline is required;
`diff.mode:"full"` explicitly means the baseline was unavailable. Removed witnesses
are not proof of safety. Unchanged waits stay tiny and contain no repeated briefing.

- `changed:true`: `room` contains the new observation. Save its revision and
  reevaluate whose turn it is; a revision change does not always hand over the turn.
- `changed:false`: the ordinary wait expired without a new revision. This is not
  a game-clock loss or a connection failure. The result contains `revision`,
  `phase` and a fresh `clock` for timed games. Keep the previous board and quietly
  issue another wait if the user wants to continue and the opponent has yet to
  join or finish their turn.
  Do not narrate or notify the user about each unchanged result.
- A game-clock loss instead changes the revision and returns a terminal room and
  an event with `actions:[]` and `result:{winner,reason:"timeout"}`.
- Stop when the observation's `status` or the wait result's `phase` is `victory`.
  Report the winner or draw. Also stop if the user ends the session.
- On connection failures, back off before retrying. Respect HTTP `Retry-After`
  when rate limited. Do not continuously retry invalid credentials or invitations.

Listening means repeated bounded calls in the active client session, not one
indefinite connection or an unsolicited wake-up. Use the latest returned revision
as `afterRevision`; moves committed between waits are returned immediately.
A request to play or wait for a move does **not** authorize recurring tasks,
reminders or notification automations. Create those only if explicitly requested.
If the client cannot remain active or keep issuing waits, disclose that limitation
once and stop claiming to listen; do not replace the wait loop with a schedule.
Retain the existing seat credentials and latest revision. When the user resumes,
observe the existing room and check whose turn it is before acting. Game clocks
continue while the client is inactive.

The host runs the rules engine and stores rooms. It does not run or pay for your
LLM inference; model usage belongs to the agent's own client or account.

## Undo and move notifications

Send `actions:[{"type":"UNDO"}]` alone to `muju_play`, with your token, the
latest revision and a new request ID. `canUndo` means the current player can
reverse their latest command, including placement, promotion and starting actions.
An atomic batch is one undo step. Turn end and game completion clear undo history.
There is no incoming upkeep, so a turn never opens with an upkeep undo step.
Mining and automatic upkeep form one outgoing `END_ACTION_PHASE` undo step. Undo
back to Act to reverse mining/payment, or use `RELEASE_UNIT` during Prepare to
refund a paid piece directly. Forced keep-sets must contain every tier-I unit.
Release itself is an undo step. Undo does not reverse the opponent's
completed turn or income. `END_PLACE_PHASE` clears undo and hands over.

`muju_wait_for_change` is the supported way to detect human moves. Use the latest
revision as `afterRevision`; moves between calls return immediately. Changed
results include `events` (revision, player, actions, including UNDO),
`eventsComplete` (false if history was truncated), and the authoritative `room`.
Joining may have no action event. Play only when `room.activePlayer` equals your
seat; moves and undos within a human turn do not transfer control. Update the
revision after each result and keep waiting as needed. The client must keep
issuing bounded waits; the server cannot wake an idle LLM session by itself.

## Read the full game score

Call `muju_history({roomId, limit:50})` for the latest recorded events, oldest
first. No seat token is needed. The same score is available under **History** in
the room, including to observers and after the game ends. Records persist across
server restarts and are separate from the rolling 100-command notification log.

- Use `after:0` to start at the beginning, then `after` the last returned
  `sequence` while `hasLater` is true. To go backward, use `before` the first
  returned sequence while `hasEarlier` is true. Do not combine both cursors.
- Each entry identifies its player, turn, revision, timestamp, notation, and
  structured outcome. Purchases/promotions include cost and resulting bank;
  public summon commitments use `◌`, and arrival events include full refunds;
  moves include route and AP; attacks include damage/defense and capture;
  upkeep includes automatic/chosen payment, kept units and releases; mining
  includes every piece's take, reserve change and resulting bank.
- Notation: `🔥1 B1→C1`, `🔥1 C1×C2`, `+🌱1@B3`, `↑🔥2@C1`.
  Attacks do not move the attacker. `#` means the server adjudicated home
  checkmate. There are no coaching judgments or invented moves.
- Undone commands are omitted by default. `includeUndone:true` exposes them
  with `undoneAtRevision`. After an UNDO notification, refresh the score for
  the affected turn; do not just append entries after your previous cursor.
- `recordingStart.complete:false` means this room predates detailed history.
  Earlier missing moves cannot be reconstructed. Preserve that qualification
  when writing a game review. Routine phase-ending commands are omitted.

Human review: **History → Analyze game** opens the recorded positions on the
board. Clicking a notation entry jumps to that event. Review can step within a
multi-AP move or across full player turns. **Explore from here** lets the human
control both sides in a private variation; it never submits actions to the room.
The game modes page also has a standalone **Analysis board**.

Rooms close and archive after 24 hours without a successful game action (creation
starts the deadline). Joins, takeovers, reads, previews and staging edits do not
reset it. Archived rooms are read-only; history and positions remain available
for analysis. New commands return `ROOM_ARCHIVED`.

## Metal catalogue (v2.9)

Poṉ (`metal_1`): ATK/DEF/SPD/MINE 1/3/0/3; Veḷḷi: 1/4/1/4; Irumbu: 2/5/2/5. Costs remain 5/9/17. Poṉ cannot move until promoted, but can attack adjacent enemies, mine and anchor purchases.

## Muju Elegans v3 and preserved v1/v2

Historical Elegans v3 games use variant `elegans`, revision `muju-elegans-3`: no upkeep
at any tier; tier-I Fire/Lightning cost 3, Water/Shadow cost 4, Metal/Plant cost 5.
Map G has 416 crystals: 40 empty squares, 32 fours, 20 eights and 8 sixteens.
It has 180-degree rotational symmetry, with A1/J10 homes containing 8.
Existing `muju-elegans-2` records retain map B (424 crystals) and the same prices. Existing `muju-elegans-1` records retain all tier-I costs 4
and the 288-crystal map (Prime starting fours removed). Saves, replays, forks,
rematches and unfinished colour negotiations preserve their recorded revision. All other Prime rules, stats, promotions (4 then 8), komi
and victory/scoring stay unchanged. Existing standard records keep their rules.
Release retains the normal restrictions and refunds zero; last-piece release
is illegal. Read the observed variant and revision through `muju_rules({variant: "elegans", revision: observation.rulesVersion})`.
Use canonical legal actions, previews, atomic play, undo and staging. Hosted
search/briefings and built-in AI remain unavailable in Elegans.
A backend whose muju_analyze schema advertises `tactics` also supports canonical
current-player attack and move-then-attack witnesses: use `topics:["tactics"]`,
`categories:["existing"]`, `replies:false`, and the current `expectedRevision`.
Optional `targets.unitIds` filters enemy targets. Inspect cutoffs and omitted lines;
these alternatives are not a combined plan, strategic ranking or safety proof.
Older backends explicitly refuse this topic; do not assume it is deployed.
Entry: `/muju/elegans/`. All three revisions use the existing separate `muju-elegans-v1-save` slot; its historical name is retained for compatibility. The envelope and state revisions must agree; loaded cells are never regenerated.


## Saving human-versus-LLM games for later

In an ordinary timed game against a human, the LLM first calls
`muju_register_llm({roomId, token, expectedRevision})` using its **own** seat token.
This labels only that authenticated seat; names never grant pause permissions.
Competition/experiment rooms (`matchPolicy`), unfinished setup and finished games
cannot use this feature. Registration does not change game rules, board, history,
clocks, room identity or either saved seat.

The opposing human can then use **Pause game** and **Resume game** above the board.
The server stops both clocks and the 24-hour idle deadline, preserving the exact
remaining bank and free delay. Saved games stay in **Your games**, including after
server restart. Closing a tab by itself still does not pause anything. Resume uses
the same room and position, without resetting time or history.

After resume, `llmResumeGrace: true` leaves the LLM clock stopped until its first
accepted action. If the human is to move, the human's saved clock runs normally,
and this grace carries through to the next LLM response. If the LLM was already
to move, its remaining clock stays frozen immediately. Rejected, stale, retried
or preview actions do not consume grace. An accepted batch counts as the first
response; later actions use normal clocks. Grace and its frozen time survive restart.

While `pause` is present, do not play or stage; wait for the human to resume.
When the human resumes, an already accepted stage resumes its saved countdown
and can be the first LLM response. Check `muju_staged` before submitting anything
else; that stage still commits exactly once. Its countdown excludes the full pause,
while the LLM clock remains free until the stage actually plays. If no accepted
stage is pending and it is your turn with `llmResumeGrace`, submit the first reply
directly with `muju_play`. A new staged request during grace returns
`LLM_RESUME_GRACE` with this instruction. Normal move validation still applies.

HTTP uses `POST /api/muju/rooms/:id/register-llm`, `/pause` or `/resume`, with
`Authorization: Bearer <seat token>` and `{expectedRevision}`. Only the opposing
human's own token can pause/resume. A stale revision returns `STALE_REVISION`;
read again before deciding what to do. Do not change seats, fork games, invent a
new clock allowance or replay already accepted moves to recover from an error.