Plainer copy

README.md

@@ -1,145 +1,120 @@
----
-title: Prime Rush — a battle royale as an MCP environment
-emoji: 🎯
-colorFrom: blue
-colorTo: yellow
-sdk: docker
-app_port: 7860
-pinned: false
-license: apache-2.0
-short_description: A live battle royale as six MCP tools
----
-
-# Prime Rush as an MCP environment
-
-A live battle-royale match from a shipped commercial game, exposed to an LLM
-agent as six MCP tools. An agent is dropped in with a shrinking safe circle;
-anything outside it takes damage until it dies.
-
-Built for the [Archipelago](https://github.com/Mercor-Intelligence/archipelago)
-harness. The layout, the structured-output convention and the schema
-flattening mirror that repo's own MCP servers, so this can be reviewed next to
-the servers already in it.
-
-## The thing worth checking first
-
-**The match is frozen between tool calls.** The simulation advances only
-inside a tool that says it advances it, by exactly the amount that tool asks
-for. A model may spend thirty seconds reasoning and the game is in precisely
-the state it left it. A slow model is not punished and a fast one is not
-rewarded; the same seed and the same calls produce the same match.
-
-Almost no real-time game can be evaluated this way. It is the reason this is a
-test of spatial decision-making rather than of latency.
-
-## What the agent gets, and what it does not
-
-| Tool | Advances the match |
-|---|---|
-| `get_situation` | no |
-| `turn_to_bearing` | yes, by the time the turn takes |
-| `move` | yes, by the seconds requested |
-| `hold_position` | yes |
-| `shoot` | yes |
-| `finish` | no |
-
-There is deliberately **no `move_to(x, z)`** and **no "the zone is 40 degrees
-to your left" field**. `get_situation` returns raw coordinates: where you are,
-which way you are facing, and where the circle's centre is. Turning that into
-a heading is the skill being measured. A server that pre-computed the bearing
-would score every model identically and measure nothing.
-
-Movement is body-relative for the same reason — "go north" would let a model
-skip reasoning about its own heading entirely.
-
-## How grading works
-
-Archipelago grades by snapshotting the environment and diffing it, so a score
-that only ever existed in a tool response is invisible to the grader. Every
-call that advances the match rewrites `INDUS_OUTCOME_PATH`
-(default `/filesystem/outcome.json`):
-
-```json
-{
-  "task": "zone_survival",
-  "frac_inside_zone": 0.82,
-  "seconds_scored": 100.0,
-  "alive": true,
-  "player_rank": 12,
-  "tool_calls_that_advanced_time": 14
-}
-```
-
-The score comes from the game's own state, never from anything the agent said,
-so an agent cannot talk its way to a pass. Because the file is rewritten after
-every move rather than at the end, a run that crashed, timed out or gave up is
-still graded on what it actually did.
-
-`grading_eval/indus_zone_survival.py` is a reference eval definition that
-reads this file and thresholds it, with the snippet to register it. The task
-pack also ships `file_diff_check` and `output_llm` verifiers, both of which
-work in stock Archipelago with no additions.
-
-## What this Space runs
-
-The tools, their schemas, the scoring and the outcome file are the real ones —
-this page imports the same `indus_mcp` package a lab would run.
-
-The **game** is not. A Space has no Unity server, so the tools here drive
-`tests/fake_game.py`, a stand-in that speaks the same bridge protocol and
-reproduces the real game's response characteristics — including a look input
-that turns at 0.075 of the requested angle, so an agent behaves here the way
-it behaves there.
-
-For the real game, the environment is hosted. Get in touch.
-
-## Running it yourself
-
-```bash
-pip install fastmcp pydantic
-python tests/test_end_to_end.py      # 28 checks, no game build needed
-python tests/test_grading_eval.py    # 9 checks
-```
-
-Against a real match:
-
-```bash
-export INDUS_BRIDGE_HOST=... INDUS_BRIDGE_PORT=...
-python -m indus_mcp.main             # stdio, the transport Archipelago uses
-```
-
-Under Archipelago, `POST /apps` with `tasks/zone_survival/mcp_config.json`.
-
-### Configuration
-
-| Variable | Meaning | Default |
-|---|---|---|
-| `INDUS_BRIDGE_HOST` / `PORT` | the running match to attach to | `127.0.0.1:7850` |
-| `INDUS_TASK` | task name | `zone_survival` |
-| `INDUS_BUDGET_SECONDS` | game time the agent gets | `100` |
-| `INDUS_FF_RADIUS` | hand over once the circle is this small | `350` |
-| `INDUS_OUTCOME_PATH` | where the grader reads the result | `/filesystem/outcome.json` |
-| `MCP_TRANSPORT` | `stdio` or `http` | `stdio` |
-
-`INDUS_FF_RADIUS` matters more than it looks. Before the circle has closed it
-covers most of the map and every agent is trivially inside it, so a run
-started at match open measures nothing.
-
-## Known limitations
-
-- **No vertical aim.** `shoot` fires horizontally. Aim pitch is not yet
-  carried in the observation, so an agent could not verify the effect of a
-  `pitch` argument; it arrives once the observation does.
-- **No occlusion.** `get_situation` reports nearby enemies whether or not
-  there is a wall in the way. Fine for the zone task, wrong for combat.
-- **One task.** The session layer is task-aware, so a second task is a new
-  handover condition and a new metric, not a new server.
-- **One seat.** A match holds one agent today. Several agents in one match is
-  the next change.
-- **No scores published yet.** Comparative numbers follow once the benchmark
-  is finalised; a ranking is only worth publishing when every layout is
-  winnable, and that is pending a game build.
-
----
-
-Built by SuperGaming, from the live build of Prime Rush. Apache-2.0.
+---
+title: Prime Rush — a battle royale as an MCP environment
+emoji: 🎯
+colorFrom: blue
+colorTo: yellow
+sdk: docker
+app_port: 7860
+pinned: false
+license: apache-2.0
+short_description: A live battle royale as six MCP tools
+---
+
+# Prime Rush as an MCP environment
+
+A battle-royale match exposed to an LLM agent as six MCP tools. A safe circle
+shrinks on a timer; anything outside it takes damage until it dies.
+
+Built for the [Archipelago](https://github.com/Mercor-Intelligence/archipelago)
+harness, following the layout and conventions of the MCP servers already in
+that repo.
+
+## Timing
+
+The match only advances inside a tool call, by the amount that call asks for.
+A model can take as long as it likes to decide and the game waits, so a slow
+model is not penalised. The same seed and the same calls give the same match.
+
+## Tools
+
+| Tool | Advances the match |
+|---|---|
+| `get_situation` | no |
+| `turn_to_bearing` | yes, by the time the turn takes |
+| `move` | yes, by the seconds requested |
+| `hold_position` | yes |
+| `shoot` | yes |
+| `finish` | no |
+
+`get_situation` returns coordinates: position, heading, the circle's centre
+and radius, nearby enemies, time left. There is no `move_to` and no bearing to
+the circle — working that out is the task. Movement is relative to the
+direction the agent is facing, so it has to turn first.
+
+## Scoring
+
+Each call that advances the match writes `INDUS_OUTCOME_PATH`
+(default `/filesystem/outcome.json`) from the game state:
+
+```json
+{
+  "task": "zone_survival",
+  "frac_inside_zone": 0.82,
+  "seconds_scored": 100.0,
+  "alive": true,
+  "player_rank": 12,
+  "tool_calls_that_advanced_time": 14
+}
+```
+
+Archipelago grades by snapshotting the environment, so the score is read from
+that file rather than from the transcript. It is rewritten after every move,
+so a run that crashed or stopped early is still scored on what it did.
+
+`grading_eval/indus_zone_survival.py` is a reference eval definition that
+reads the file and thresholds it, with the snippet to register it. The task
+pack also ships `file_diff_check` and `output_llm` verifiers, which work in
+stock Archipelago.
+
+## What this Space runs
+
+The tools, their schemas and the scoring are the ones a lab would run. The
+game is not: a Space has no Unity server, so the tools drive
+`tests/fake_game.py`, a stand-in that speaks the same bridge protocol and
+reproduces the real game's response characteristics. The map on the page
+shows only what the tools returned.
+
+For the real game, the environment is hosted. Get in touch.
+
+## Running it
+
+```bash
+pip install fastmcp pydantic
+python tests/test_end_to_end.py      # 28 checks, no game build needed
+python tests/test_grading_eval.py    # 9 checks
+```
+
+Against a real match:
+
+```bash
+export INDUS_BRIDGE_HOST=... INDUS_BRIDGE_PORT=...
+python -m indus_mcp.main             # stdio, the transport Archipelago uses
+```
+
+Under Archipelago, `POST /apps` with `tasks/zone_survival/mcp_config.json`.
+
+| Variable | Meaning | Default |
+|---|---|---|
+| `INDUS_BRIDGE_HOST` / `PORT` | the running match to attach to | `127.0.0.1:7850` |
+| `INDUS_TASK` | task name | `zone_survival` |
+| `INDUS_BUDGET_SECONDS` | game time the agent gets | `100` |
+| `INDUS_FF_RADIUS` | hand over once the circle is this small | `350` |
+| `INDUS_OUTCOME_PATH` | where the grader reads the result | `/filesystem/outcome.json` |
+| `MCP_TRANSPORT` | `stdio` or `http` | `stdio` |
+
+`INDUS_FF_RADIUS` matters: before the circle has closed it covers most of the
+map and any agent is inside it, so a run started at match open measures
+nothing.
+
+## Limitations
+
+- `shoot` is horizontal only. Aim pitch is not in the observation yet, so an
+  agent could not check the effect of a `pitch` argument.
+- No line of sight: nearby enemies are reported through walls.
+- One task.
+- One agent per match.
+- No scores published yet.
+
+---
+
+SuperGaming. Apache-2.0.

app.py

@@ -262,58 +262,50 @@ CSS = """
 
 HERO = """
 <div id="pr-hero">
-  <h1>A live battle royale, as six MCP tools</h1>
-  <p class="pr-sub">An agent is dropped into a real match with a shrinking safe circle. It is
-  given its own coordinates and the circle&rsquo;s &mdash; never a direction. Working out
-  where to go is the thing being measured.</p>
+  <h1>Prime Rush as an MCP environment</h1>
+  <p class="pr-sub">An agent plays a battle-royale match through six tools. A safe circle
+  shrinks and the agent has to be inside it. It is given its own coordinates and the
+  circle&rsquo;s, and has to work out the direction itself.</p>
   <div class="pr-chips">
-    <span class="pr-chip on">frozen between tool calls</span>
     <span class="pr-chip">six tools</span>
-    <span class="pr-chip">graded from a snapshot, not the transcript</span>
-    <span class="pr-chip">Archipelago-compatible</span>
+    <span class="pr-chip">runs under Archipelago</span>
     <span class="pr-chip">Apache-2.0</span>
   </div>
 </div>
 """
 
 WHY = """
-<div class="pr-lab">A reasoning test, not a reaction test</div>
+<div class="pr-lab">Timing</div>
 
-**The match is frozen between tool calls.** The simulation advances only inside a tool that
-says it does, by exactly the amount it asks for. A model may think for thirty seconds and the
-game is in precisely the state it left it &mdash; a slow model is not punished and a fast one
-is not rewarded. The same seed and the same calls reproduce the same match. Almost no
-real-time game can be evaluated this way.
+The match only advances inside a tool call, by the amount that call asks for. A model can
+take as long as it likes to decide and the game waits. The same seed and the same calls
+give the same match.
 
-<div class="pr-lab" style="margin-top:20px">What the agent is not given</div>
+<div class="pr-lab" style="margin-top:20px">What the agent gets</div>
 
-There is no `move_to(x, z)` and no &ldquo;the circle is 40&deg; to your left&rdquo; field.
-`get_situation` returns raw coordinates. A server that pre-computed the bearing would score
-every model identically and measure nothing. Movement is body-relative for the same reason.
+`get_situation` returns coordinates: where it is, which way it is facing, where the circle
+is and how big. There is no `move_to` and no bearing. Movement is relative to the direction
+it is facing, so it has to turn first.
 """
 
 NOTE = """
-<div class="pr-lab">How it is graded</div>
+<div class="pr-lab">Scoring</div>
 
-Every call that advances the match rewrites `outcome.json` from the game&rsquo;s own state.
-The score never comes from anything the agent said, so an agent cannot talk its way to a
-pass &mdash; and a run that crashed or gave up is still graded on what it actually did.
-A reference eval definition and the Archipelago task pack are in the Files tab.
+Each call that advances the match writes `outcome.json` from the game state. The score is
+read from that file, not from the transcript, and a run that stops early is still scored on
+what it did. The task pack and a reference grader are in the Files tab.
 
 <div class="pr-lab" style="margin-top:20px">What this page runs</div>
 
-The tools, schemas, scoring and outcome file are the real ones, and the map is drawn only
-from what the tools reported &mdash; you see exactly what the agent saw. The **game** is
-not: a Space has no Unity server, so the tools drive a stand-in that speaks the same bridge
-protocol and reproduces the real game&rsquo;s response characteristics. For the real game,
-the environment is hosted.
+The tools, their schemas and the scoring are the ones a lab would run. The game is not: a
+Space has no Unity server, so the tools drive a stand-in that speaks the same protocol. The
+map shows only what the tools returned.
 """
 
 FOOT = """
 <div id="pr-foot">
-Built by SuperGaming from the live build of Prime Rush &nbsp;&middot;&nbsp;
-adapter, task pack, reference grader and tests are in the Files tab &nbsp;&middot;&nbsp;
-Apache-2.0
+SuperGaming &nbsp;&middot;&nbsp; code, task pack and tests in the Files tab
+&nbsp;&middot;&nbsp; Apache-2.0
 </div>
 """